From cfef8935778a4cafbc507839df85bbd558c857bf Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 08:33:36 +0200
Subject: [PATCH 001/160] Add crysview-structure-visualization ADR suggestion

---
 .../crysview-structure-visualization.md       | 682 ++++++++++++++
 .../suggestions/crysview-threejs-demo.html    | 855 ++++++++++++++++++
 2 files changed, 1537 insertions(+)
 create mode 100644 docs/dev/adrs/suggestions/crysview-structure-visualization.md
 create mode 100644 docs/dev/adrs/suggestions/crysview-threejs-demo.html

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
new file mode 100644
index 000000000..05538e669
--- /dev/null
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -0,0 +1,682 @@
+# ADR: crysview Structure Visualization
+
+## Status
+
+Proposed.
+
+**Date:** 2026-05-29
+
+## Context
+
+EasyDiffraction refines crystal structures but offers no interactive 3D
+view of them. The accepted
+[Display UX Facade](../../../docs/dev/adrs/accepted/display-ux.md) ADR
+defines `project.display` for 1D pattern charts and for parameter, fit,
+and posterior tables and plots, but nothing spatial: there is no way to
+look at the atoms, the unit cell, or the anisotropic displacement
+parameters a refinement is adjusting.
+
+A working prototype establishes the target experience and the data it
+needs. It lives at
+[`crysview-threejs-demo.html`](crysview-threejs-demo.html) and
+demonstrates, against a non-orthogonal unit cell:
+
+- atoms as spheres with element radius and colour;
+- anisotropic ADP ellipsoids (semi-axis lengths plus orientation);
+- mixed-occupancy atoms drawn as occupancy wedges (a sphere split by
+  site occupancy);
+- two-colour bonds split at their midpoint;
+- magnetic-moment arrows;
+- an a/b/c axis triad drawn longer than the cell edges;
+- a Plotly-style modebar: perspective/parallel projection toggle,
+  view-along-a/b/c buttons, a home/reset button, and per-feature
+  visibility toggles for cell, axes, atoms, bonds, moments, and labels;
+- a shrink-wrapped legend, hover tooltips, and persistent atom labels;
+- orbit / zoom / pan controls and both perspective and orthographic
+  cameras, with parallel projection as the default.
+
+The prototype's input comment already separates the concerns: a
+crystallography layer performs symmetry expansion, fractional →
+Cartesian conversion, ADP eigendecomposition, and element-radius lookup;
+a visualization layer chooses sizes, colours, bonds, and occupancy
+splitting; and the renderer only consumes prepared geometry.
+
+Relevant facts about the current codebase:
+
+- The structure model lives under
+  `src/easydiffraction/datablocks/structure/categories/`: `cell`,
+  `atom_sites` (fractional coordinates, occupancy, isotropic ADP),
+  `atom_site_aniso` (anisotropic ADP), and `space_group`.
+- The 1D charting subsystem already uses a switchable-engine pattern.
+  `project.chart.type` selects a plotter engine implemented under
+  `src/easydiffraction/display/plotters/` (`ascii.py`, `plotly.py`), and
+  `project.table.type` selects a tabler. These follow the
+  switchable-category ADRs, with CIF tags `_chart.type` and
+  `_table.type`.
+- `easycrystallography` is **not** a dependency today and is not
+  imported anywhere in `src/`. Any layering that places a separate
+  visualization package between `easycrystallography` and
+  `easydiffraction` is therefore a future direction, not the current
+  state.
+
+The audience is scientists, often non-programmers, working mostly in
+Jupyter notebooks and the planned GUI. Discoverability, clear names, and
+safe defaults take priority over developer ergonomics.
+
+## Decision
+
+This is the first version of the decision, written for review. The
+points that earlier reviews left open are now settled in the sections
+below; the remaining genuinely-open items are listed under Open
+Questions.
+
+### 1. Build a renderer-neutral structure scene
+
+crysview converts a crystal structure into a prepared, renderer-neutral
+**structure scene**: a flat collection of typed primitives expressed in
+Cartesian space and carrying no rendering-library types. The primitive
+set matches the prototype:
+
+- atom spheres (centre, radius, colour);
+- occupancy wedges for mixed-occupancy sites;
+- ADP ellipsoids (semi-axes scaled to the configured probability, plus
+  orientation);
+- bonds (two endpoints, split colour);
+- magnetic-moment arrows;
+- unit-cell edges;
+- the a/b/c axis triad;
+- text labels.
+
+All crystallographic computation — symmetry expansion over the
+configured cell range (section 3), fractional → Cartesian conversion,
+ADP eigendecomposition, radii and colours from the selected model and
+colour scheme, bond detection, and occupancy splitting — happens while
+building the scene, upstream of any renderer. This is the contract the
+prototype already assumes.
+
+### 2. Draw the scene with thin, pluggable renderers
+
+Renderers consume the scene and draw it; they hold no crystallographic
+logic. Renderer choice mirrors `project.chart.type`:
+
+- an ASCII renderer for terminal, CLI, and headless contexts;
+- a Three.js renderer for notebooks (embedded HTML/JS) and standalone
+  HTML;
+- a Qt Quick 3D renderer for the GUI is planned.
+
+ASCII and Three.js are the initial engines, shipping together exactly as
+the `ascii` and `plotly` chart engines do; Qt Quick 3D follows for the
+GUI.
+
+A switchable engine selector is added on the project owner, parallel to
+`project.chart` / `project.table`. It is named `view`:
+
+```python
+project.view.type = 'threejs'   # or 'ascii' for the terminal
+project.view.show_supported()
+```
+
+with CIF tag `_view.type`. The name is kept short and parallel to
+`chart` / `table`, and follows the category-owned selector contract:
+`project.view` is a read-only attribute on the owner;
+`project.view.type` is the writable selector;
+`project.view.show_supported()` lists engines. Switching `type` calls
+the owner's private `_swap_view` hook, which rebinds the active renderer
+— the same Family B rebinding the chart engine selector uses — so no
+public `view_type` setter or `show_supported_view_types()` is added.
+
+### 3. Add a `structure()` entry point on the display facade
+
+Add `project.display.structure(struct_name=...)`, parallel to the
+existing `project.display.pattern(expt_name=...)`. It renders one
+structure with the active `view` engine — interactive 3D in a notebook,
+a schematic projection in the terminal. In the Three.js engine, feature
+visibility, projection, and view-along presets are interactive through
+the modebar with sensible defaults (parallel projection; cell, axes,
+atoms, and bonds visible, plus moments where the data exists; labels
+off). In a notebook it embeds an interactive view (an IPython HTML
+representation); like the HTML report it can also write a standalone
+HTML file to a path. The exact return and save signature is left to the
+implementation plan.
+
+Content selection mirrors `pattern(include=...)` rather than inventing a
+new vocabulary:
+
+```python
+project.display.structure(struct_name='lbco')
+project.display.structure(struct_name='lbco', include='auto')
+project.display.structure(
+    struct_name='lbco',
+    include=('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'),
+)
+```
+
+`include='auto'` shows what the structure state supports (cell, axes,
+atoms, bonds, and moments where moment data exists; labels off by
+default). The option vocabulary is `auto`, `atoms`, `bonds`, `cell`,
+`axes`, `moments`, and `labels`. ADP ellipsoids and mixed-occupancy
+splits are not separate keywords: they are drawn automatically as part
+of `atoms` (anisotropic ADP gives an ellipsoid, isotropic a sphere; a
+mixed site is split), so the data decides. The interactive modebar
+toggles the same features after the initial view is drawn, so `include`
+sets the starting state and the modebar refines it.
+
+A companion `project.display.show_structure_options(struct_name=...)`
+mirrors the existing `show_pattern_options(expt_name=...)`: it lists
+each `include=` option with whether the active engine and the current
+structure state support it, and the reason when they do not — for
+example `moments` is unavailable until the structure model carries
+moment fields, and the `ascii` engine reports the features only the 3D
+engines draw. This gives the structure view the same per-option
+discoverability the pattern view already offers.
+
+The view also has a spatial extent: which symmetry-equivalent atoms the
+scene contains. The scene builder takes the unique (asymmetric-unit)
+atoms, applies the space-group symmetry, and keeps every generated copy
+whose fractional coordinates fall within a per-axis range, **borders
+included**. The default range is `[0, 1]` on each of a, b, and c, so a
+full unit cell is drawn with the atoms on the 0 and 1 faces, edges, and
+corners all present (a corner site therefore appears at all eight
+corners). The range is user-settable per axis, validated so each minimum
+is below its maximum, and need not be integer — `[0, 2]` along a draws
+two cells, `[-0.2, 1.2]` adds a margin. Like the other settings it is
+persisted and overridable per call:
+
+```python
+project.view.range = ((0, 1), (0, 1), (0, 1))   # default: full cell, borders included
+project.display.structure(
+    struct_name='lbco',
+    range=((0, 2), (0, 1), (0, 1)),             # two cells along a, this call only
+)
+```
+
+Symmetry expansion can map several operations onto one point — a site on
+a special position, or the shared 0-and-1 faces the default range keeps
+— so the scene builder applies a **scene-atom identity rule** as it
+collects copies. Two generated atoms are the same scene atom when they
+come from the same atom-site row _and_ their fractional coordinates
+coincide within a small tolerance (`1e-4` in fractional units); the
+builder keeps one and drops the rest. The tolerance is far below any
+cell fraction, so a copy at 0 and its border-included copy at 1 are
+distinct positions and both survive — special-position overlaps collapse
+without discarding the intentional boundary translations. The atom-site
+row participates in the key, so two different rows that happen to share
+a position are not merged here; that case is occupancy grouping, handled
+next.
+
+When two or more atom-site rows resolve to the same position (within
+that same tolerance), the scene builder groups them into one
+**occupancy-wedge sphere** rather than overdrawing coincident spheres:
+each row contributes a wedge whose angular share is proportional to its
+occupancy. Coincident position is the only grouping signal the model
+offers — atom sites carry an occupancy but no disorder-group or
+occupancy-group field — so it is the documented version-1 criterion.
+When the grouped occupancies sum below one, the remainder is drawn as a
+vacancy wedge so the empty fraction is visible (a lone site with
+occupancy below one is the one-row case); when they meet or exceed one,
+the shares are normalized to their sum and no vacancy wedge is drawn.
+The builder invents no occupancies — it shows exactly what the rows
+carry.
+
+Because expansion happens in the scene builder (section 1), the 3D
+engines draw this expanded set in full. The `ascii` engine is the
+reduced-fidelity sibling (section 7): it always renders the single
+default cell and reports a wider `project.view.range` as a 3D-only
+capability through `show_structure_options()`, the same way it announces
+the other features only the 3D engines draw.
+
+### 4. Start internal, design for later extraction
+
+Implement crysview first as an internal subpackage that mirrors
+`display/plotters/` (for example
+`src/easydiffraction/display/structure/` with renderers under a
+`renderers/` subpackage). Keep the scene model free of
+easydiffraction-domain imports so it can later be extracted into a
+standalone `crysview` package and, eventually, consume
+`easycrystallography`. Do **not** add `easycrystallography` as a
+dependency now.
+
+### 5. Pin and deliver Three.js deliberately
+
+The prototype loads a pinned Three.js (`three@0.160.0`) plus
+`OrbitControls` and `CSS2DRenderer` through a CDN importmap. Production
+ships the pinned Three.js bundled with the package so the notebook and
+standalone-HTML views are autonomous — they render with no network,
+which is what a CDN-blocked or sandboxed context (where the demo renders
+blank) needs. This mirrors how the existing report path already embeds
+its JavaScript when asked: `report/html_renderer.py` exposes an
+`offline` flag that sets `include_plotlyjs=True` (embed) versus `'cdn'`,
+gated in the template by `html_offline`.
+
+The HTML report's structure view follows the same rule: it honours the
+report's `html_offline` flag, embedding the Three.js assets when offline
+and otherwise linking them, so a structure figure behaves like the
+existing Plotly figures in a report.
+
+### 6. Source styling from standard models and colour schemes
+
+Atom radii and colours are not typed in per element. They follow from
+**standard, user-selected models** that every structure viewer
+recognises, looked up automatically from each atom's element (and its
+charge where the model needs it):
+
+- a **radius model** turns an element into a sphere radius — van der
+  Waals, ionic (Shannon; the site charge where a model carries one,
+  otherwise a documented per-element default, see below), covalent, or
+  atomic/empirical;
+- a **colour scheme** is a named element-colour palette — the Jmol/CPK
+  scheme, the VESTA scheme, and similar well-known sets.
+
+A scientist picks one model and one scheme instead of editing dozens of
+per-element rows, which keeps the view consistent and reproducible:
+
+```python
+project.style.atom_shape = 'ortep'        # ball | ortep
+project.style.radius_model = 'covalent'   # vdw | covalent | ionic | atomic (default covalent)
+project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
+project.style.show_supported()            # accepted values per setting
+```
+
+How an atom is shaped is a single **display-style switch**,
+`atom_shape`, because a ball-and-stick radius and an ADP probability
+surface are different depictions and a view shows one of them at a time:
+
+- `'ball'` draws every atom as a **radius-model sphere** (the radius
+  model above); displacement parameters do not affect size. This is the
+  familiar ball-and-stick depiction and works for any structure, with or
+  without ADP.
+- `'ortep'` draws each atom as its **ADP probability surface** — a
+  sphere for an atom with only isotropic ADP, an ellipsoid (semi-axes
+  and orientation from the ADP tensor) for an anisotropic one. Atoms
+  that carry no ADP fall back to a radius-model sphere. This is the
+  thermal-ellipsoid (ORTEP) depiction crystallographers use to inspect
+  the displacement parameters a refinement adjusts.
+
+The default is `'ortep'`, because this is a refinement tool and the
+thermal ellipsoids are usually the point; a structure with no ADP simply
+renders as radius-model spheres, identical to `'ball'`.
+
+In `'ortep'` the surfaces are drawn at one **probability level**,
+`adp_probability`, a fraction in the open interval (0, 1) — not a
+percentage — validated on assignment. It defaults to `0.5` (the ORTEP
+and journal 50% convention) and is freely changeable (for example
+`0.95`). It has no effect in `'ball'`.
+
+Which bonds the view draws is **not** a styling choice — it is a
+geometric property of the structure, and it follows the **standard
+cif_core `_geom` auto-bonding model**, not the display `radius_model`. A
+bond is drawn between two sites when their distance `d` satisfies
+`_geom.min_bond_distance_cutoff ≤ d ≤ r_bond(i) + r_bond(j) + _geom.bond_distance_incr`,
+where the per-type bonding radius `r_bond` is `_atom_type.radius_bond`
+when the structure carries it, otherwise the element's covalent radius
+from the bundled database. These two cutoffs live on the **structure**
+and persist in the structure's own CIF (see section 8), not in
+`project.style`. The display `radius_model` (vdw / covalent / ionic /
+atomic) changes only the rendered sphere _size_ — it never decides which
+bonds appear; bond detection is governed solely by the `_geom` cutoffs
+and the per-type bonding radius. Version 1 draws bonds computed on the
+fly from this rule while the scene is built and persists no bond table.
+The full computed bond and angle geometry — the standard `_geom_bond`
+and `_geom_angle` loops, with distances, angles, symmetry codes, and
+standard uncertainties — is a separate, related feature that reuses the
+same symmetry-expansion and distance math (see Deferred Work).
+
+`atom_shape`, `radius_model`, and `color_scheme` are finite, closed
+value sets, so each is a `(str, Enum)` validated on assignment per the
+[Enum-Backed Closed Value Sets](../../../docs/dev/adrs/accepted/enum-backed-closed-values.md)
+ADR, and `project.style.show_supported()` lists the accepted values for
+every styling setting — the same discoverability the engine selectors
+give through `show_supported()`. `style` is a plain category, not a
+switchable one: it has no factory-swapped `type`, only these validated
+value settings.
+
+The defaults are the **covalent** radius model and the **Jmol/CPK**
+colour scheme, so the view looks right with no configuration. Covalent
+is the default because it is backed by complete, well-documented
+per-element data and needs no oxidation state: today's atom-site model
+carries only an element symbol — no charge, oxidation-state, or
+coordination field — so a model that depends on charge cannot be
+resolved per site yet.
+
+The radii and colours come from a **bundled element database** — a
+package asset, like the colour palettes, not a per-project value, so it
+is not CIF-serialized; the project CIF records only which model and
+scheme are selected. The database carries, per element, the van der
+Waals, covalent, ionic (a representative Shannon radius at a documented
+default oxidation state and coordination), and atomic/empirical radii,
+plus the Jmol/CPK and VESTA colour palettes, each value carrying a
+documented provenance. The ionic entries let `radius_model = 'ionic'`
+work today against the documented default oxidation state; when a future
+atom-site charge field exists the ionic model will prefer the site's
+charge. An element with no entry for the selected radius model falls
+back to its covalent radius, and `show_structure_options()` reports the
+substitution instead of failing. Version 1 adds no per-element overrides
+on top of the chosen model and scheme.
+
+All of this is CIF-persisted, so a reopened project renders identically.
+The decision is that styling is **an atom-shape mode plus model, scheme,
+and probability-level selection**, not a per-element table; the exact
+CIF tag names and serialization shape are pinned in the implementation
+plan (Open Questions, resolved).
+
+The view also adapts to the host's **colour theme**. Like the Plotly
+chart engine — which selects the `plotly_dark` or `plotly_white`
+template from the detected theme — the structure view reuses the
+project's existing dark/light detection (`is_dark()` in
+`utils/_vendored`) and switches the scene background and the label,
+axis, and edge colours to match, so a notebook in dark mode gets a dark
+canvas. Element colours still come from the selected colour scheme
+regardless of theme; only the surrounding canvas and annotations follow
+it. The theme is auto-detected, not a persisted styling value.
+
+### 7. Terminal view (ASCII engine)
+
+The `ascii` engine renders in the terminal, mirroring the existing
+`ascii` chart plotter: it builds a character grid and prints it, with no
+GUI or JavaScript. Like that chart engine — which openly announces the
+features only Plotly can draw — it is a deliberately reduced-fidelity
+sibling of the 3D engines: one schematic projection, one unit cell, and
+no bonds, labels, ADP ellipsoids, or moment arrows. When an `include=`
+request asks for one of those features, the engine announces it is
+available with the 3D engines and skips it, just as the ascii chart
+engine does for Plotly-only features. A `project.view.range` wider than
+the default single cell is treated the same way: the terminal view
+always draws one cell and announces that multi-cell and margin ranges
+are honored only by the 3D engines, so its schematic stays uncluttered
+and the single parallelogram never disagrees with the atoms it frames.
+
+Like the other engines it consumes the same renderer-neutral scene
+(section 1): it projects the scene's Cartesian atom centres and
+unit-cell edges onto a plane and draws a schematic 2D view. The longest
+in-plane cell axis runs horizontally, the shortest vertically, and the
+remaining (middle-length) axis is the viewing direction.
+
+The cell is drawn as a schematic parallelogram. Its two side edges are
+rasterized with the asciichartpy glyph set (`│ ╭ ╮ ╯ ╰ ─`), and the
+staircase slope encodes the in-plane angle: near 90° gives long `│` runs
+with few corners (a rectangle at exactly 90°), while a larger deviation
+from 90° introduces more `╭╯` steps (mirrored to `╰╮` for the opposite
+lean). The view is schematic — lengths and angles are approximate, just
+enough to convey the cell — so non-orthogonal cells render the same way
+as orthogonal ones, with the slant shown rather than dropped.
+
+Atoms are drawn as coloured Unicode circles: colour by element from the
+selected colour scheme (the scene colour from section 6, mapped to the
+nearest terminal colour) and size by a small radius-bucketed glyph ramp
+(for example `· • ● ⬤`). Each axis arrow points to its letter: the
+vertical axis is the letter stacked over an up-arrow above the cell (`c`
+then `↑`), and the horizontal axis is a right-arrow pointing to the
+letter at the end of the bottom-border line, after a short gap (`→ a`).
+Each axis arrow and its letter are tinted with that axis's colour — the
+same a/b/c colours the scene gives the 3D engines, mapped to the nearest
+terminal colour and reset afterwards, just as the existing ASCII chart
+legend colours its entries. A legend maps each glyph to its element
+name, and both the legend glyph and its element label are tinted with
+that element's colour-scheme colour (mapped to the nearest terminal
+colour and reset afterwards), so the atoms in the cell, the legend, and
+the axis letters all share the one selected colour scheme. The mocks
+below are monochrome; a real terminal shows these colours.
+
+An orthorhombic cell viewed down b, with vertical side edges:
+
+```
+   c
+   ↑
+   ╭─────────────────────────╮
+   │        ●            ●   │
+   │    ⬤                   │
+   │  •              ●       │
+   ╰─────────────────────────╯  → a
+
+   Legend:  ● La   ● Ba   ⬤ Co   • O
+```
+
+A monoclinic cell viewed down b, with slanted side edges:
+
+```
+   c
+   ↑
+      ╭─────────────────────────╮
+     ╭╯       ●            ●   ╭╯
+    ╭╯    ⬤                  ╭╯
+   ╭╯   •              ●     ╭╯
+   ╰─────────────────────────╯  → a
+
+   Legend:  ● La   ● Ba   ⬤ Co   • O
+```
+
+A small gap-free line helper provides the edge rasterization: it
+generalizes the asciichartpy connector (fill vertical runs with `│`, cap
+bends with corner glyphs) so it can be walked row-major for the
+near-vertical edges that the column-major chart code cannot express.
+
+### 8. Configuring what is shown and how
+
+The view has two configuration axes — _what_ is shown (content) and
+_how_ it is drawn (engine plus styling) — both reachable from Python and
+persisted to CIF.
+
+```python
+# How: renderer engine
+project.view.type = 'threejs'        # or 'ascii' for the terminal
+project.view.show_supported()
+
+# How: standard styling models, not per-element values (visual only)
+project.style.atom_shape = 'ortep'        # ball | ortep
+project.style.radius_model = 'covalent'   # vdw | covalent | ionic | atomic (default covalent)
+project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
+project.style.adp_probability = 0.5       # ortep only; fraction in (0, 1)
+project.style.show_supported()            # accepted values per setting
+
+# Which bonds exist: a per-structure geometric property, not styling.
+# Standard cif_core _geom auto-bonding (r_bond defaults to covalent radius):
+# bond iff  min_cutoff <= d <= r_bond(i) + r_bond(j) + incr.
+structure = project.structures['lbco']
+structure.geom.min_bond_distance_cutoff = 0.0   # default 0.0 Å
+structure.geom.bond_distance_incr       = 0.4   # default 0.4 Å (documented, tunable)
+
+# What (per call): content for one view, overriding the initial defaults
+project.display.structure(struct_name='lbco')                    # 'auto'
+project.display.structure(
+    struct_name='lbco',
+    include=('atoms', 'bonds', 'cell', 'axes'),
+)
+
+# Initial view state (persisted): what is shown when the view opens. The
+# Three.js modebar stays active, so the user can still toggle each
+# feature live afterwards. show_moments stays inert until the structure
+# model carries moment fields (see Deferred Work).
+project.view.show_labels = False
+project.view.show_moments = True
+
+# What region (persisted): which symmetry-equivalent atoms are generated,
+# as a per-axis fractional range (default below, borders included).
+project.view.range = ((0, 1), (0, 1), (0, 1))
+```
+
+The persisted equivalent in the project CIF:
+
+```
+# In the project CIF (project-level view + style):
+_view.type           threejs
+_view.show_labels    false
+_view.show_moments   true
+_view.range_a        0 1
+_view.range_b        0 1
+_view.range_c        0 1
+
+_style.atom_shape       ortep
+_style.radius_model     covalent
+_style.color_scheme     jmol
+_style.adp_probability  0.5
+
+# In the structure (sample) CIF, beside _cell / _atom_site (per-structure):
+_geom.min_bond_distance_cutoff   0.0
+_geom.bond_distance_incr         0.4
+```
+
+The `_view.type` tag follows `_chart.type` / `_table.type` from the
+Display UX Facade ADR; `_geom.min_bond_distance_cutoff` and
+`_geom.bond_distance_incr` are the **standard cif_core** bond-cutoff
+tags (`_atom_type.radius_bond` is the standard per-type bonding radius,
+used when present). The `_style.*` and `_view.*` tags are
+project-internal app settings whose exact spelling is finalized in the
+implementation plan (see sections 6, 8 and Open Questions).
+
+Initial visibility resolves in a fixed order, so a reopened project and
+a per-call request behave predictably:
+
+1. **An explicit `include=(...)` tuple wins outright.** The view opens
+   showing exactly those features; persisted `_view.show_*` flags are
+   ignored for that call. So `include=('atoms',)` shows only atoms even
+   when `show_labels=True` is persisted.
+2. **`include='auto'`** — the default, and what a bare `structure()`
+   call uses — resolves each feature in turn from: data availability
+   first (a feature with no data is off, such as moments without moment
+   fields), then the persisted `_view.show_*` flag where one exists,
+   then the built-in default otherwise. Version 1 persists flags only
+   for the two features whose default a scientist most often flips —
+   `show_labels` (off) and `show_moments` (on where data exists); atoms,
+   bonds, cell, and axes follow their built-in 'auto' defaults and are
+   set per call through an explicit `include=` tuple. So
+   `show_labels=True` with `include='auto'` opens with labels on.
+3. **Unsupported options are skipped and announced, never errored.**
+   Whether it arrived through an explicit tuple or 'auto', a feature the
+   engine cannot draw (any 3D-only feature under `ascii`) or the data
+   does not support (moments without fields) is reported by
+   `show_structure_options()` and at draw time.
+4. **Live modebar changes apply on top of that initial state and are
+   runtime-only.** Toggling a feature in the Three.js modebar never
+   rewrites the persisted `_view.show_*` flags or the `include=` set, so
+   reopening the project restores the resolved initial state rather than
+   the last live toggle.
+
+## Consequences
+
+- `project.display` gains a spatial view (`structure()`) that
+  complements the 1D `pattern()` view and reuses the `include=`
+  vocabulary.
+- `project.display` also gains `show_structure_options()`, parallel to
+  `show_pattern_options()`, so the supported content for a given
+  structure and engine is discoverable with reasons.
+- Keeping crystallography in the scene builder and out of renderers lets
+  several front-ends (Three.js now, Qt Quick 3D later) share one model.
+- A new switchable `view` category (`project.view.type`, CIF
+  `_view.type`) must be added per the switchable-category and
+  category-owner ADRs, alongside a plain (non-switchable) `style`
+  category: `style` has no factory-swapped `type`, only enum-backed
+  value settings discoverable through `show_supported()`.
+- The `ascii` and `threejs` engines ship together, mirroring the chart
+  engines: `ascii` needs no JavaScript and renders a schematic view in
+  the terminal, CLI, and headless contexts, while `threejs` covers
+  notebooks and HTML.
+- Content selection (`include=`) and a small set of visibility flags
+  become persisted _initial-view_ settings, so a project reopens looking
+  the same; the interactive engines still let the user toggle features
+  live.
+- The scene's spatial extent is configurable: a per-axis fractional
+  range (default `[0, 1]`, borders included) decides which
+  symmetry-equivalent atoms are generated, so a single cell, an added
+  margin, or several cells need no new primitives. The 3D engines draw
+  the expanded set; the `ascii` engine draws the single default cell and
+  reports wider ranges as a 3D-only capability.
+- The styling category lets scientists choose an atom-shape mode
+  (ball-and-stick or ORTEP), a standard radius model (defaulting to
+  covalent, the model with complete charge-free per-element data), a
+  colour scheme, and an ADP probability level — not hand-edit
+  per-element rows — all CIF-persisted, with defaults that work
+  unconfigured. The radii and colours come from a bundled element
+  database (covalent, vdW, ionic, and atomic radii; Jmol/CPK and VESTA
+  palettes) shipped as a package asset.
+- Bond generation is a per-structure geometric property, not styling: it
+  uses the standard cif_core `_geom` auto-bonding cutoffs
+  (`_geom.min_bond_distance_cutoff`, `_geom.bond_distance_incr`) plus a
+  per-type bonding radius (`_atom_type.radius_bond`, defaulting to the
+  covalent radius), all on the structure and persisted in the structure
+  CIF — not in `project.style`, and independent of the display
+  `radius_model`. Version 1 draws bonds on the fly and persists no bond
+  table; the full computed `_geom_bond` / `_geom_angle` tables are
+  deferred to a separate feature.
+- The structure view auto-detects the host's dark/light theme (reusing
+  the project's existing `is_dark()` detection) and adapts its
+  background and annotation colours, mirroring how the Plotly chart
+  engine switches templates; element colours still come from the
+  selected colour scheme.
+- The scene builder must expose occupancy splitting, anisotropic ADP,
+  and magnetic moments. Where the current structure model lacks a field
+  (magnetic moments are not in `atom_sites`/`atom_site_aniso` today),
+  that feature stays gated until the model provides the data.
+- A pinned Three.js version becomes a bundled package asset to keep up
+  to date, and the HTML report embeds it under `html_offline`.
+- Tutorials and public API docs gain a structure-view example.
+
+## Alternatives Considered
+
+- **Reuse the 1D chart engines (Plotly) for 3D.** Rejected: Plotly's 3D
+  primitives do not express ADP ellipsoids, occupancy wedges, or
+  crystallographic camera/axis controls cleanly.
+- **Put rendering directly in easydiffraction with no scene
+  abstraction.** Rejected: it couples crystallography to one rendering
+  library and blocks the planned GUI renderer.
+- **Start as a standalone `crysview` package and adopt
+  `easycrystallography` now.** Rejected for the first step as a
+  premature dependency and repo split before the design is proven;
+  retained as the strategic direction.
+- **Server-rendered static images instead of an interactive scene.**
+  Rejected: it loses the interactivity (rotate, toggle, view-along)
+  scientists expect when inspecting a structure.
+
+## Open Questions
+
+All items below are now **resolved** so the implementation plan can be
+executed autonomously; the plan records the verified data sources and
+the final names.
+
+- **CIF tag spelling — resolved.** Project CIF: `_style.atom_shape`,
+  `_style.radius_model`, `_style.color_scheme`,
+  `_style.adp_probability`, and `_view.type` / `_view.show_labels` /
+  `_view.show_moments` / `_view.range_a|b|c`. These are project-internal
+  app/settings tags (`_view.type` follows the Display-UX `_chart.type` /
+  `_table.type` precedent); the radii and colours are a bundled
+  element-database asset, not CIF-serialized.
+- **Per-structure bond-cutoff category — resolved (standard
+  `_geom.*`).** A single-record `structure.geom` category holding the
+  cif_core cutoffs `_geom.min_bond_distance_cutoff` (default `0.0` Å)
+  and `_geom.bond_distance_incr` (default `0.4` Å, documented and
+  tunable), in the structure datablock. A bond is drawn when
+  `min_bond_distance_cutoff ≤ d ≤ r_bond(i) + r_bond(j) + bond_distance_incr`,
+  with `r_bond` = `_atom_type.radius_bond` when present, else the
+  covalent radius. These are the **standard** cif_core tags (review-4
+  finding 1): `_geom.min_bond_distance_cutoff` (dic 13084),
+  `_geom.bond_distance_incr` (dic 13044), `_atom_type.radius_bond` (dic
+  25419); the earlier project-internal `_bonds.*` proposal was dropped.
+  The computed `_geom_bond.*` / `_geom_angle.*` loops remain reserved
+  for the deferred geometry tables.
+- **ASCII rendering details — resolved.** A 4-bucket radius glyph ramp
+  (`· • ● ⬤`) and the 8/16-colour ANSI mapping the existing ascii chart
+  legend already uses.
+- **Per-axis range boundary completion — resolved.** Version 1 draws
+  only atoms inside the range (borders included) and bonds only between
+  in-scene atoms — no out-of-range partner atoms or edge-coordination
+  completion. Range CIF spelling is `_view.range_a|b|c` (two numbers
+  each).
+
+## Deferred Work
+
+- The computed bond and angle geometry tables — the standard
+  `_geom_bond` and `_geom_angle` loops (atom-pair/triplet labels,
+  distances, angles, site-symmetry codes, standard uncertainties,
+  `publ_flag`) — as a separate, related feature. It reuses crysview's
+  symmetry-expansion and distance math and the same per-structure
+  `_geom` cutoffs (extended with the angle/contact increments cif_core
+  already defines). Version 1 draws bonds on the fly from the `_geom`
+  bond cutoffs and persists no geometry table.
+- The Qt Quick 3D renderer for the GUI.
+- Magnetic-moment fields on the structure model (a separate
+  magnetic-structure effort); the scene's moment-arrow primitive stays
+  gated until they exist.
+- Extraction of a standalone `crysview` package and the
+  `easycrystallography` layering.
+- Advanced depictions beyond atoms, bonds, and ADP surfaces, such as
+  coordination polyhedra. Symmetry expansion and multiple-cell views are
+  in scope through the per-axis range (section 3).
diff --git a/docs/dev/adrs/suggestions/crysview-threejs-demo.html b/docs/dev/adrs/suggestions/crysview-threejs-demo.html
new file mode 100644
index 000000000..82148ff35
--- /dev/null
+++ b/docs/dev/adrs/suggestions/crysview-threejs-demo.html
@@ -0,0 +1,855 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>crysview — Three.js structure prototype</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+        height: 100%;
+        overflow: hidden;
+        font-family:
+          system-ui,
+          -apple-system,
+          'Segoe UI',
+          sans-serif;
+      }
+      #app {
+        position: fixed;
+        inset: 0;
+      }
+      .card {
+        position: fixed;
+        z-index: 10;
+        background: rgba(255, 255, 255, 0.94);
+        border: 1px solid #e2e2e2;
+        border-radius: 8px;
+        box-shadow: 0 1px 6px rgba(0, 0, 0, 0.12);
+        font-size: 12px;
+        color: #222;
+      }
+
+      /* ---- modebar: horizontal icon set, Plotly-style ---- */
+      #modebar {
+        top: 12px;
+        right: 12px;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        padding: 6px 8px;
+      }
+      .mb-grp {
+        display: flex;
+        gap: 4px;
+      }
+      .mb-sep {
+        align-self: stretch;
+        width: 1px;
+        background: #e4e4e4;
+        margin: 3px 2px;
+      }
+      .mb {
+        width: 34px;
+        height: 32px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        padding: 0;
+        border: 1px solid #dcdcdc;
+        border-radius: 6px;
+        background: #f5f5f6;
+        color: #2a3f5f;
+        cursor: pointer;
+        transition:
+          background 0.12s,
+          color 0.12s,
+          border-color 0.12s;
+      }
+      .mb:hover {
+        background: #e9eaef;
+      }
+      .mb svg {
+        width: 18px;
+        height: 18px;
+        display: block;
+      }
+      .mb.lt {
+        font:
+          700 15px/1 Georgia,
+          'Times New Roman',
+          serif;
+      }
+      .mb.tog {
+        color: #b9bdc6;
+      } /* toggle OFF = greyed */
+      .mb.tog.on {
+        color: #2a3f5f;
+        background: #e7ecf5;
+        border-color: #c6d0e2;
+      } /* ON = active */
+
+      /* ---- legend: top-left corner, shrink-wrapped to its content ---- */
+      #legend {
+        top: 12px;
+        left: 12px;
+        padding: 9px 12px;
+        line-height: 1.7;
+        white-space: nowrap;
+      }
+      .sw {
+        display: inline-block;
+        width: 11px;
+        height: 11px;
+        border-radius: 50%;
+        margin-right: 8px;
+        vertical-align: middle;
+        border: 1px solid rgba(0, 0, 0, 0.18);
+      }
+      #legend .ax {
+        margin-top: 6px;
+      }
+
+      /* ---- hover tooltip ---- */
+      #tooltip {
+        position: fixed;
+        z-index: 30;
+        pointer-events: none;
+        display: none;
+        background: rgba(33, 42, 62, 0.92);
+        color: #fff;
+        padding: 3px 8px;
+        border-radius: 5px;
+        font-size: 12px;
+        white-space: nowrap;
+      }
+
+      /* ---- 3D atom labels (CSS2D) ---- */
+      .atom-label {
+        font-size: 11px;
+        font-weight: 600;
+        color: #1b2433;
+        text-shadow:
+          0 0 3px #fff,
+          0 0 3px #fff,
+          0 0 3px #fff;
+        pointer-events: none;
+        white-space: nowrap;
+      }
+
+      #hint {
+        position: fixed;
+        bottom: 10px;
+        left: 12px;
+        z-index: 10;
+        font-size: 11px;
+        color: #555;
+        background: rgba(255, 255, 255, 0.82);
+        padding: 6px 10px;
+        border-radius: 6px;
+        line-height: 1.6;
+      }
+    </style>
+    <script type="importmap">
+      {
+        "imports": {
+          "three": "https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js",
+          "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <div id="app"></div>
+    <div id="tooltip"></div>
+
+    <div id="modebar" class="card">
+      <div class="mb-grp">
+        <button class="mb" id="mb-proj" title="Parallel (orthographic) view">
+          <svg
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.7"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <rect x="3.5" y="4.5" width="17" height="15" rx="1.5" />
+            <path d="M9.5 4.5V19.5M14.5 4.5V19.5" />
+          </svg>
+        </button>
+        <button
+          class="mb lt"
+          id="mb-a"
+          title="View along a"
+          style="color: #2a9fd6"
+        >
+          a
+        </button>
+        <button
+          class="mb lt"
+          id="mb-b"
+          title="View along b"
+          style="color: #e8763c"
+        >
+          b
+        </button>
+        <button
+          class="mb lt"
+          id="mb-c"
+          title="View along c"
+          style="color: #7f9c3a"
+        >
+          c
+        </button>
+        <button class="mb" id="mb-home" title="Reset view">
+          <svg
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.8"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <path d="M3 11 12 3l9 8" />
+            <path d="M5 9.5V20h5v-6h4v6h5V9.5" />
+          </svg>
+        </button>
+      </div>
+      <div class="mb-sep"></div>
+      <div class="mb-grp">
+        <button class="mb tog on" id="mb-cell" title="Unit cell">
+          <svg
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.7"
+            stroke-linejoin="round"
+            stroke-linecap="round"
+          >
+            <path d="M12 2.5 20 7v9l-8 4.5L4 16V7Z" />
+            <path d="M4 7l8 4.5L20 7M12 11.5v9" />
+          </svg>
+        </button>
+        <button class="mb tog on" id="mb-axes" title="Axes a/b/c">
+          <svg
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.7"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <path d="M5 19V6M5 19h13M5 19l7-7" />
+            <path d="M5 6 3.3 8.2M5 6l1.7 2.2M18 19l-2.2-1.4M18 19l-2.2 1.4" />
+          </svg>
+        </button>
+        <button class="mb tog on" id="mb-atoms" title="Atoms">
+          <svg viewBox="0 0 24 24" fill="currentColor">
+            <circle cx="9.5" cy="13.5" r="5" />
+            <circle cx="16.5" cy="8" r="3.2" />
+          </svg>
+        </button>
+        <button class="mb tog on" id="mb-bonds" title="Bonds">
+          <svg viewBox="0 0 24 24">
+            <line
+              x1="8"
+              y1="16"
+              x2="16"
+              y2="8"
+              stroke="currentColor"
+              stroke-width="2.4"
+              stroke-linecap="round"
+            />
+            <circle cx="6.7" cy="17.3" r="3.1" fill="currentColor" />
+            <circle cx="17.3" cy="6.7" r="3.1" fill="currentColor" />
+          </svg>
+        </button>
+        <button class="mb tog on" id="mb-moments" title="Magnetic moments">
+          <svg
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.9"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          >
+            <path d="M12 20V5" />
+            <path d="M7 10l5-6 5 6" />
+          </svg>
+        </button>
+        <button class="mb tog" id="mb-labels" title="Atom labels">
+          <svg
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.6"
+            stroke-linejoin="round"
+            stroke-linecap="round"
+          >
+            <rect x="3.5" y="5" width="17" height="14" rx="2" />
+            <path d="M9 15.5 12 8.5l3 7M10.1 13.2h3.8" />
+          </svg>
+        </button>
+      </div>
+    </div>
+
+    <div id="legend" class="card">
+      <div>
+        <span
+          class="sw"
+          style="background: linear-gradient(90deg, #35b035 50%, #8a5a2c 50%)"
+        ></span
+        >A/B (50/50)
+      </div>
+      <div><span class="sw" style="background: #2a9fd6"></span>C</div>
+      <div><span class="sw" style="background: #e23b2e"></span>D</div>
+    </div>
+
+    <div id="hint">
+      <div>drag = rotate</div>
+      <div>wheel = zoom</div>
+      <div>right-drag = pan</div>
+    </div>
+
+    <script type="module">
+      import * as THREE from 'three'
+      import { OrbitControls } from 'three/addons/controls/OrbitControls.js'
+      import {
+        CSS2DRenderer,
+        CSS2DObject,
+      } from 'three/addons/renderers/CSS2DRenderer.js'
+
+      // ============================================================================
+      // INPUT — produced by easycrystallography (symmetry expansion, frac->cart, ADP
+      // eigendecomposition, element radii) + crysview (size/colour scheme, bonds,
+      // occupancy splitting). The renderer below only consumes prepared geometry.
+      // ============================================================================
+      const cell = { a: 6.0, b: 6.0, c: 8.0, alpha: 90, beta: 110, gamma: 90 } // non-orthogonal
+
+      const COL = {
+        green: 0x35b035,
+        red: 0xe23b2e,
+        blue: 0x2a9fd6,
+        brown: 0x8a5a2c,
+      }
+      const elements = {
+        A: { radius: 0.65, color: COL.green }, // mixture component (shares its site with B)
+        B: { radius: 0.65, color: COL.brown }, // mixture component (shares its site with A)
+        C: { radius: 0.8, color: COL.blue }, // ADP ellipsoids
+        D: { radius: 0.55, color: COL.red }, // simple spheres
+      }
+
+      const sites = [
+        // mixed-occupancy site at (0,1,0): 50/50 A(green)/B(brown) split sphere
+        {
+          el: 'A',
+          label: 'A1/B1 (50/50)',
+          f: [0.0, 1.0, 0.0],
+          occupancy: [
+            { color: COL.green, fraction: 0.5 },
+            { color: COL.brown, fraction: 0.5 },
+          ],
+        },
+        // C site: solid anisotropic ADP ellipsoid with a magnetic moment
+        {
+          el: 'C',
+          label: 'C1',
+          f: [0.5, 0.5, 0.5],
+          ellipsoid: { axes: [1.0, 0.55, 0.45], euler: [0.4, 0.9, 0.2] },
+          moment: [0.4, 0.0, 1.0],
+        },
+        { el: 'D', label: 'D1', f: [0.5, 0.5, 0.0] },
+        { el: 'D', label: 'D2', f: [0.5, 0.0, 0.5] },
+        { el: 'D', label: 'D3', f: [0.0, 0.5, 0.5] },
+        // second ADP ellipsoid (C) with a magnetic moment
+        {
+          el: 'C',
+          label: 'C2',
+          f: [1.0, 0.0, 1.0],
+          ellipsoid: { axes: [0.95, 0.62, 0.5], euler: [0.2, -0.6, 0.5] },
+          moment: [1.0, 0.2, -0.5],
+        },
+      ]
+      const bonds = [
+        [1, 2],
+        [1, 3],
+        [1, 4],
+      ]
+
+      // axis colours (a/b/c) and the fractional extent axes run past the cell edges
+      const AXIS_COL = { a: 0x2a9fd6, b: 0xe8763c, c: 0x7f9c3a }
+      const AXIS_EXT = 1.25
+
+      // thickness hierarchy: cell < axes < bonds < moment
+      const CELL_R = 0.01,
+        AXIS_SHAFT = 0.07,
+        BOND_R = 0.09,
+        MOMENT_SHAFT = 0.15
+
+      // ---- fractional -> Cartesian (convention: a ∥ x, b in xy-plane) ----
+      function cellVectors({ a, b, c, alpha, beta, gamma }) {
+        const d2r = Math.PI / 180
+        const ca = Math.cos(alpha * d2r),
+          cb = Math.cos(beta * d2r),
+          cg = Math.cos(gamma * d2r)
+        const sg = Math.sin(gamma * d2r)
+        const vol = Math.sqrt(
+          1 - ca * ca - cb * cb - cg * cg + 2 * ca * cb * cg,
+        )
+        return {
+          av: new THREE.Vector3(a, 0, 0),
+          bv: new THREE.Vector3(b * cg, b * sg, 0),
+          cv: new THREE.Vector3(
+            c * cb,
+            (c * (ca - cb * cg)) / sg,
+            (c * vol) / sg,
+          ),
+        }
+      }
+      const { av, bv, cv } = cellVectors(cell)
+      const fracToCart = (f) =>
+        new THREE.Vector3()
+          .addScaledVector(av, f[0])
+          .addScaledVector(bv, f[1])
+          .addScaledVector(cv, f[2])
+
+      // ============================================================================
+      // RENDERER
+      // ============================================================================
+      const app = document.getElementById('app')
+      const scene = new THREE.Scene()
+      scene.background = new THREE.Color(0xffffff)
+
+      const renderer = new THREE.WebGLRenderer({ antialias: true })
+      renderer.setPixelRatio(devicePixelRatio)
+      renderer.setSize(innerWidth, innerHeight)
+      app.appendChild(renderer.domElement)
+
+      // overlay for 3D text labels (atom labels)
+      const labelRenderer = new CSS2DRenderer()
+      labelRenderer.setSize(innerWidth, innerHeight)
+      Object.assign(labelRenderer.domElement.style, {
+        position: 'fixed',
+        top: '0',
+        left: '0',
+        pointerEvents: 'none',
+        zIndex: '5',
+      })
+      app.appendChild(labelRenderer.domElement)
+
+      const center = fracToCart([0.5, 0.5, 0.5])
+      const HOME = {
+        pos: center.clone().add(new THREE.Vector3(11, 7, 15)),
+        target: center.clone(),
+      }
+
+      let projection = 'perspective'
+      let camera = makePerspective()
+      camera.position.copy(HOME.pos)
+
+      const controls = new OrbitControls(camera, renderer.domElement)
+      controls.enableDamping = true
+      controls.dampingFactor = 0.08
+      controls.target.copy(HOME.target)
+      controls.update()
+
+      function makePerspective() {
+        return new THREE.PerspectiveCamera(
+          45,
+          innerWidth / innerHeight,
+          0.1,
+          1000,
+        )
+      }
+      function makeOrthographic(fromCamera) {
+        const dist = fromCamera.position.distanceTo(controls.target)
+        const halfH = dist * Math.tan(((45 / 2) * Math.PI) / 180) // match perspective scale at target
+        const aspect = innerWidth / innerHeight
+        return new THREE.OrthographicCamera(
+          -halfH * aspect,
+          halfH * aspect,
+          halfH,
+          -halfH,
+          0.1,
+          1000,
+        )
+      }
+
+      const PROJ_ICON = {
+        perspective:
+          '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="4.5" width="17" height="15" rx="1.5"/><path d="M9 4.5 11 19.5M15 4.5 13 19.5"/></svg>',
+        orthographic:
+          '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="4.5" width="17" height="15" rx="1.5"/><path d="M9.5 4.5V19.5M14.5 4.5V19.5"/></svg>',
+      }
+      function setProjection(mode) {
+        const prev = camera
+        camera =
+          mode === 'orthographic' ? makeOrthographic(prev) : makePerspective()
+        camera.position.copy(prev.position)
+        camera.up.copy(prev.up)
+        camera.lookAt(controls.target)
+        controls.object = camera
+        controls.update()
+        projection = mode
+        const b = document.getElementById('mb-proj')
+        b.innerHTML = PROJ_ICON[mode]
+        b.title =
+          mode === 'orthographic'
+            ? 'Parallel (orthographic) view'
+            : 'Perspective view'
+      }
+
+      // lights
+      scene.add(new THREE.AmbientLight(0xffffff, 0.55))
+      const key = new THREE.DirectionalLight(0xffffff, 0.9)
+      key.position.set(1, 1, 1)
+      scene.add(key)
+      const fill = new THREE.DirectionalLight(0xffffff, 0.35)
+      fill.position.set(-1, -0.5, -1)
+      scene.add(fill)
+
+      // toggle-able groups
+      const groups = {
+        cell: new THREE.Group(),
+        axes: new THREE.Group(),
+        atoms: new THREE.Group(),
+        bonds: new THREE.Group(),
+        moments: new THREE.Group(),
+      }
+      Object.values(groups).forEach((g) => scene.add(g))
+
+      // ---- shared builders ----
+      const unitSphere = new THREE.SphereGeometry(1, 32, 24)
+      const Y = new THREE.Vector3(0, 1, 0)
+      const mat = (color, rough = 0.4) =>
+        new THREE.MeshStandardMaterial({
+          color,
+          roughness: rough,
+          metalness: 0,
+        })
+
+      function cylinder(p1, p2, radius, color) {
+        const dir = new THREE.Vector3().subVectors(p2, p1)
+        const m = new THREE.Mesh(
+          new THREE.CylinderGeometry(radius, radius, dir.length(), 16),
+          mat(color),
+        )
+        m.position.copy(p1).add(p2).multiplyScalar(0.5)
+        m.quaternion.setFromUnitVectors(Y, dir.clone().normalize())
+        return m
+      }
+      function arrow(dir, origin, length, color, shaftR, headScale = 1) {
+        const g = new THREE.Group()
+        const headLen = Math.min(length * 0.32, shaftR * 5) * headScale
+        const headR = shaftR * 2.1 * headScale
+        const shaftLen = Math.max(length - headLen, 1e-3)
+        const m = mat(color)
+        const shaft = new THREE.Mesh(
+          new THREE.CylinderGeometry(shaftR, shaftR, shaftLen, 16),
+          m,
+        )
+        shaft.position.y = shaftLen / 2
+        const head = new THREE.Mesh(
+          new THREE.ConeGeometry(headR, headLen, 20),
+          m,
+        )
+        head.position.y = shaftLen + headLen / 2
+        g.add(shaft, head)
+        g.quaternion.setFromUnitVectors(Y, dir.clone().normalize())
+        g.position.copy(origin)
+        return g
+      }
+
+      // atom: one mesh per occupancy wedge (split by longitude), then sphere-scaled
+      // or ellipsoid-scaled+rotated. Wedge boundaries stay planar through the centre.
+      function buildAtom(site) {
+        const e = elements[site.el] || {}
+        const g = new THREE.Group()
+        const segs = site.occupancy || [{ color: e.color, fraction: 1 }]
+        let phi = 0
+        for (const s of segs) {
+          const len = s.fraction * Math.PI * 2
+          const geo =
+            segs.length === 1
+              ? unitSphere
+              : new THREE.SphereGeometry(1, 64, 32, phi, len)
+          g.add(new THREE.Mesh(geo, mat(s.color, 0.3)))
+          phi += len
+        }
+        if (site.ellipsoid) {
+          g.scale.set(...site.ellipsoid.axes)
+          g.rotation.set(...site.ellipsoid.euler)
+        } else g.scale.setScalar(e.radius)
+        g.position.copy(fracToCart(site.f))
+        g.userData.label = site.label
+        return g
+      }
+
+      // ---- unit-cell edges (thin cylinders + corner spheres for clean joints) ----
+      ;(function buildCell() {
+        const corner = (i, j, k) => fracToCart([i, j, k])
+        const E = [
+          [
+            [0, 0, 0],
+            [1, 0, 0],
+          ],
+          [
+            [0, 0, 0],
+            [0, 1, 0],
+          ],
+          [
+            [0, 0, 0],
+            [0, 0, 1],
+          ],
+          [
+            [1, 1, 1],
+            [0, 1, 1],
+          ],
+          [
+            [1, 1, 1],
+            [1, 0, 1],
+          ],
+          [
+            [1, 1, 1],
+            [1, 1, 0],
+          ],
+          [
+            [1, 0, 0],
+            [1, 1, 0],
+          ],
+          [
+            [1, 0, 0],
+            [1, 0, 1],
+          ],
+          [
+            [0, 1, 0],
+            [1, 1, 0],
+          ],
+          [
+            [0, 1, 0],
+            [0, 1, 1],
+          ],
+          [
+            [0, 0, 1],
+            [1, 0, 1],
+          ],
+          [
+            [0, 0, 1],
+            [0, 1, 1],
+          ],
+        ]
+        for (const [p, q] of E)
+          groups.cell.add(
+            cylinder(corner(...p), corner(...q), CELL_R, 0x555555),
+          )
+        for (let i = 0; i < 2; i++)
+          for (let j = 0; j < 2; j++)
+            for (let k = 0; k < 2; k++) {
+              const s = new THREE.Mesh(unitSphere, mat(0x555555))
+              s.position.copy(corner(i, j, k))
+              s.scale.setScalar(CELL_R)
+              groups.cell.add(s)
+            }
+      })()
+
+      // ---- a/b/c triad (longer than the cell edges; oversized caps) ----
+      groups.axes.add(
+        arrow(
+          av,
+          new THREE.Vector3(),
+          av.length() * AXIS_EXT,
+          AXIS_COL.a,
+          AXIS_SHAFT,
+          2,
+        ),
+      )
+      groups.axes.add(
+        arrow(
+          bv,
+          new THREE.Vector3(),
+          bv.length() * AXIS_EXT,
+          AXIS_COL.b,
+          AXIS_SHAFT,
+          2,
+        ),
+      )
+      groups.axes.add(
+        arrow(
+          cv,
+          new THREE.Vector3(),
+          cv.length() * AXIS_EXT,
+          AXIS_COL.c,
+          AXIS_SHAFT,
+          2,
+        ),
+      )
+
+      // ---- atoms (spheres, ellipsoids, mixed-occupancy wedges) ----
+      const sitePos = sites.map((s) => fracToCart(s.f))
+      sites.forEach((s) => groups.atoms.add(buildAtom(s)))
+
+      // ---- bonds (two-colour, split at midpoint) ----
+      bonds.forEach(([i, j]) => {
+        const midp = sitePos[i].clone().add(sitePos[j]).multiplyScalar(0.5)
+        groups.bonds.add(
+          cylinder(sitePos[i], midp, BOND_R, elements[sites[i].el].color),
+        )
+        groups.bonds.add(
+          cylinder(midp, sitePos[j], BOND_R, elements[sites[j].el].color),
+        )
+      })
+
+      // ---- moments (atom colour, thicker than bonds, centred on the atom) ----
+      sites.forEach((s, i) => {
+        if (!s.moment) return
+        const dir = new THREE.Vector3(...s.moment).normalize()
+        const length = 3.0
+        const origin = sitePos[i].clone().addScaledVector(dir, -length / 2)
+        groups.moments.add(
+          arrow(dir, origin, length, elements[s.el].color, MOMENT_SHAFT),
+        )
+      })
+
+      // ---- atom labels (CSS2D text, lifted above each atom) ----
+      const labelGroup = new THREE.Group()
+      scene.add(labelGroup)
+      sites.forEach((s, i) => {
+        const div = document.createElement('div')
+        div.className = 'atom-label'
+        div.textContent = s.label
+        const o = new CSS2DObject(div)
+        const r = s.ellipsoid
+          ? Math.max(...s.ellipsoid.axes)
+          : elements[s.el]
+            ? elements[s.el].radius
+            : 0.5
+        o.position.copy(sitePos[i]).add(new THREE.Vector3(0, r + 0.35, 0))
+        labelGroup.add(o)
+      })
+
+      // ============================================================================
+      // UI wiring  (these controls map 1:1 to fields of the future CIF view category)
+      // ============================================================================
+      function wireToggle(id, group) {
+        const btn = document.getElementById(id)
+        group.visible = btn.classList.contains('on')
+        btn.addEventListener('click', () => {
+          const on = !group.visible
+          group.visible = on
+          btn.classList.toggle('on', on)
+        })
+      }
+      wireToggle('mb-cell', groups.cell)
+      wireToggle('mb-axes', groups.axes)
+      wireToggle('mb-atoms', groups.atoms)
+      wireToggle('mb-bonds', groups.bonds)
+      wireToggle('mb-moments', groups.moments)
+
+      // atom labels live in the CSS2D overlay; toggle the whole layer
+      ;(function wireLabels() {
+        const btn = document.getElementById('mb-labels')
+        const apply = (on) => {
+          labelRenderer.domElement.style.display = on ? '' : 'none'
+          btn.classList.toggle('on', on)
+        }
+        apply(btn.classList.contains('on'))
+        btn.addEventListener('click', () =>
+          apply(labelRenderer.domElement.style.display === 'none'),
+        )
+      })()
+
+      document
+        .getElementById('mb-proj')
+        .addEventListener('click', () =>
+          setProjection(
+            projection === 'perspective' ? 'orthographic' : 'perspective',
+          ),
+        )
+
+      // default to parallel (orthographic) projection
+      setProjection('orthographic')
+
+      function resetView() {
+        camera.up.set(0, 1, 0)
+        camera.position.copy(HOME.pos)
+        controls.target.copy(HOME.target)
+        camera.zoom = 1
+        camera.updateProjectionMatrix()
+        controls.update()
+      }
+      document.getElementById('mb-home').addEventListener('click', resetView)
+
+      // orient the camera to look down a chosen crystal axis (preserve zoom distance)
+      function viewAlong(dirVec, upVec) {
+        const dist = camera.position.distanceTo(controls.target)
+        camera.up.copy(upVec.clone().normalize())
+        camera.position
+          .copy(controls.target)
+          .addScaledVector(dirVec.clone().normalize(), dist)
+        camera.lookAt(controls.target)
+        controls.update()
+      }
+      document
+        .getElementById('mb-a')
+        .addEventListener('click', () => viewAlong(av, cv))
+      document
+        .getElementById('mb-b')
+        .addEventListener('click', () => viewAlong(bv, cv))
+      document
+        .getElementById('mb-c')
+        .addEventListener('click', () => viewAlong(cv, bv))
+
+      // ---- hover tooltip: raycast atoms, show the hovered atom's label ----
+      const raycaster = new THREE.Raycaster()
+      const ndc = new THREE.Vector2()
+      const tip = document.getElementById('tooltip')
+      renderer.domElement.addEventListener('pointermove', (ev) => {
+        if (!groups.atoms.visible) {
+          tip.style.display = 'none'
+          return
+        }
+        ndc.x = (ev.clientX / innerWidth) * 2 - 1
+        ndc.y = -(ev.clientY / innerHeight) * 2 + 1
+        raycaster.setFromCamera(ndc, camera)
+        const hits = raycaster.intersectObjects(groups.atoms.children, true)
+        if (hits.length) {
+          let o = hits[0].object
+          while (o && o.userData.label === undefined) o = o.parent
+          if (o) {
+            tip.textContent = o.userData.label
+            tip.style.left = ev.clientX + 14 + 'px'
+            tip.style.top = ev.clientY + 14 + 'px'
+            tip.style.display = 'block'
+            return
+          }
+        }
+        tip.style.display = 'none'
+      })
+      renderer.domElement.addEventListener('pointerleave', () => {
+        tip.style.display = 'none'
+      })
+
+      addEventListener('resize', () => {
+        const aspect = innerWidth / innerHeight
+        if (camera.isPerspectiveCamera) {
+          camera.aspect = aspect
+        } else {
+          const halfH = camera.top
+          camera.left = -halfH * aspect
+          camera.right = halfH * aspect
+        }
+        camera.updateProjectionMatrix()
+        renderer.setSize(innerWidth, innerHeight)
+        labelRenderer.setSize(innerWidth, innerHeight)
+      })
+      ;(function animate() {
+        requestAnimationFrame(animate)
+        controls.update()
+        renderer.render(scene, camera)
+        labelRenderer.render(scene, camera)
+      })()
+    </script>
+  </body>
+</html>

From 95bacb4301e1fe1298ac8035baa2648935a3efb0 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 08:39:15 +0200
Subject: [PATCH 002/160] Add crysview-structure-visualization implementation
 plan

---
 .../plans/crysview-structure-visualization.md | 1136 +++++++++++++++++
 1 file changed, 1136 insertions(+)
 create mode 100644 docs/dev/plans/crysview-structure-visualization.md

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
new file mode 100644
index 000000000..a5a2f1c9f
--- /dev/null
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -0,0 +1,1136 @@
+# Plan: crysview Structure Visualization
+
+Implementation plan for the
+[`crysview-structure-visualization`](../adrs/suggestions/crysview-structure-visualization.md)
+ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
+exceptions to those instructions.
+
+> **Context for this plan.** This is a **greenfield feature**: there is
+> no prior crysview implementation on the branch. The ADR review cycle
+> closed at the review-5 sentinel ("No findings. Ready to commit."), so
+> the design below is settled; this plan only makes it concrete. It is a
+> **single comprehensive plan** covering both shipping engines (ASCII +
+> Three.js), the new `view` and `style` categories, the
+> `project.display.structure()` surface, CIF persistence, Three.js
+> bundling, the HTML-report structure figure, and tutorials — one
+> branch, one PR — matching the slug invoked and the project precedent
+> ([`project-summary-rendering`](project-summary-rendering.md) was one
+> large plan). The Phase 1 steps are ordered foundation-first (scene
+> model → builder → ASCII end-to-end → Three.js), so an early increment
+> is already terminal-viewable before the JavaScript work begins.
+
+## ADR cross-reference
+
+- **Primary (owned) ADR:**
+  [`crysview-structure-visualization.md`](../adrs/suggestions/crysview-structure-visualization.md)
+  (Status: Proposed; ADR review cycle closed at the review-5 sentinel).
+  This plan **owns** the ADR — it was drafted via `/draft-adr` and is
+  not yet committed. `/draft-impl-1` Phase A only commits the ADR
+  suggestion and the plan and removes their design-phase `_review-*.md`
+  / `_reply-*.md` siblings — it does **not** edit
+  [`docs/dev/adrs/index.md`](../adrs/index.md). The **User-facing API**
+  index row is a normal Phase 1 step (P1.16).
+- **Referenced accepted ADRs** (the design builds on these; none are
+  amended):
+  - [`display-ux.md`](../adrs/accepted/display-ux.md) — defines
+    `project.display` and the `pattern()` / `show_pattern_options()`
+    surface this plan parallels with `structure()` /
+    `show_structure_options()`.
+  - [`switchable-category-owned-selectors.md`](../adrs/accepted/switchable-category-owned-selectors.md)
+    and
+    [`switchable-category-api.md`](../adrs/accepted/switchable-category-api.md)
+    — the contract the new switchable `view` category follows
+    (`project.view` read-only attribute; `project.view.type` writable
+    selector; `project.view.show_supported()`; private `_swap_view`
+    hook, Family B engine rebind).
+  - [`selector-families.md`](../adrs/accepted/selector-families.md) —
+    `view` is a switchable-category selector (Family B), like `chart` /
+    `table`.
+  - [`enum-backed-closed-values.md`](../adrs/accepted/enum-backed-closed-values.md)
+    — every closed value set (`view.type`, `style.atom_shape`,
+    `style.radius_model`, `style.color_scheme`) is a `(str, Enum)`.
+  - [`factory-contracts.md`](../adrs/accepted/factory-contracts.md),
+    [`factory-tag-naming.md`](../adrs/accepted/factory-tag-naming.md) —
+    `@Factory.register` and tag-naming conventions for the new
+    renderer/category factories.
+  - [`category-owner-sections.md`](../adrs/accepted/category-owner-sections.md),
+    [`project-facade-and-persistence.md`](../adrs/accepted/project-facade-and-persistence.md)
+    — how owner-level categories persist to `project.cif`.
+- No **new** ADR is required. The owned suggestion ADR is the
+  authoritative reference.
+
+## Branch and PR
+
+- **Recommended branch:** `crysview-structure-visualization` (flat slug,
+  off `develop`, per AGENTS.md §Planning). **Do not create or switch
+  branches** while running the shortcut — stay on the current branch;
+  the branch note is for when the work is eventually pushed.
+- **PR target:** `develop`.
+- Do not push the branch until both Phase 1 and Phase 2 review cycles
+  close.
+
+## Decisions already made
+
+Settled by the accepted ADR (not re-litigated here), plus three
+plan-level structural choices confirmed with the author at plan start.
+
+### From the ADR
+
+- **Renderer-neutral scene + thin renderers** (§1, §2): all
+  crystallographic computation (symmetry expansion,
+  fractional→Cartesian, ADP eigendecomposition, radius/colour lookup,
+  bond detection, occupancy splitting) happens in a scene **builder**,
+  upstream of any renderer. Renderers consume a flat set of typed
+  Cartesian primitives carrying no rendering-library types.
+- **Two shipping engines** (§2): `ascii` (terminal/headless) and
+  `threejs` (notebook + standalone HTML), shipping together exactly as
+  the `asciichartpy` and `plotly` chart engines do. Qt Quick 3D is
+  deferred.
+- **Switchable `view` selector** (§2): `project.view.type` (`'threejs'`
+  default-capable / `'ascii'`), CIF `_view.type`, following the
+  category-owned selector contract with a private `_swap_view` Family B
+  rebind. No `view_type` setter, no `show_supported_view_types()`.
+- **`structure()` entry point** (§3):
+  `project.display.structure(struct_name=...)` parallel to
+  `pattern(expt_name=...)`, with `include=` reusing the pattern
+  vocabulary (`auto`, `atoms`, `bonds`, `cell`, `axes`, `moments`,
+  `labels`); a companion `show_structure_options(struct_name=...)`
+  mirrors `show_pattern_options()`. Notebook embeds an interactive view
+  (IPython HTML repr); a standalone HTML file can be written to a path.
+- **Per-axis fractional range** (§3):
+  `project.view.range = ((0,1),(0,1),(0,1))` default (full cell,
+  **borders included**), per-axis, non-integer allowed, validated min <
+  max, persisted, overridable per call.
+- **Scene-atom identity rule** (§3): two generated atoms are the same
+  scene atom iff same atom-site row **and** fractional coordinates
+  coincide within `1e-4` (fractional units); keep one, drop the rest.
+  Border copies at 0 and 1 are distinct positions and both survive.
+- **Occupancy grouping** (§3): distinct atom-site rows resolving to the
+  same position (within `1e-4`) group into one occupancy-wedge sphere,
+  each wedge proportional to occupancy. Sum < 1 → vacancy wedge; sum ≥ 1
+  → normalize to sum, no vacancy wedge. The builder invents no
+  occupancies.
+- **ASCII is the reduced-fidelity sibling** (§3, §7): always renders the
+  single default cell, no bonds/labels/ellipsoids/moments; announces
+  every 3D-only feature (including a wider `range`) through
+  `show_structure_options()` and at draw time, exactly as the ascii
+  chart engine announces Plotly-only features.
+- **Styling = atom-shape mode + standard models** (§6, visual only):
+  `atom_shape` (`ball` | `ortep`, default `ortep`), `radius_model`
+  (`vdw` | `covalent` | `ionic` | `atomic`, default `covalent`),
+  `color_scheme` (`jmol` | `vesta` | …, default `jmol`),
+  `adp_probability` (fraction in open interval (0,1), default `0.5`,
+  ortep-only). All enum-backed and CIF-persisted to the project CIF;
+  `project.style.show_supported()` lists accepted values. Bond cutoffs
+  are **not** here — they are a per-structure property (see below).
+- **Bundled element database** (§6): one package asset (not
+  CIF-serialized) carrying, per element, the `vdw` / `covalent` /
+  `ionic` (representative Shannon) / `atomic` radii and the `jmol` /
+  `vesta` colour palettes, each with documented provenance. `covalent`
+  is the default model because it needs no charge and is fully
+  populated. An element missing an entry for the selected model falls
+  back to its covalent radius; `show_structure_options()` reports the
+  substitution rather than failing.
+- **Bond cutoffs are per-structure, not styling** (§6, §8): bond
+  generation uses the standard cif_core `_geom` cutoffs
+  (`_geom.min_bond_distance_cutoff`, `_geom.bond_distance_incr`) plus a
+  per-type bonding radius (`_atom_type.radius_bond`, covalent by
+  default), on the structure and persisted in the structure CIF —
+  independent of the display `radius_model`. Version 1 draws bonds on
+  the fly; the full computed `_geom_bond` / `_geom_angle` tables are
+  deferred.
+- **Dark/light theme is auto-detected** (§6): the view reuses the
+  project's `is_dark()` detection (mirroring the Plotly engine's
+  `plotly_dark`/`plotly_white` switch) to theme the canvas +
+  annotations; element colours still come from the chosen scheme. Not
+  persisted.
+- **Pinned, bundled Three.js** (§5): `three@0.160.0` + `OrbitControls` +
+  `CSS2DRenderer` ship as **vendored static assets**, embedded inline
+  for the notebook and standalone HTML (autonomous, no network), and
+  embedded vs linked in the HTML report under the report's existing
+  `html_offline` flag — the same switch that already governs
+  Plotly/MathJax.
+- **Visibility precedence** (§8): explicit `include=(...)` tuple wins
+  outright (ignores persisted `_view.show_*`); `include='auto'` resolves
+  each feature from data-availability → persisted flag (only
+  `show_labels` off, `show_moments` on-where-data) → built-in default;
+  unsupported options are skipped and announced, never errored; live
+  modebar toggles are runtime-only and never rewrite persisted state.
+- **Moments stay gated** (§3, Deferred Work): the scene model carries a
+  moment-arrow primitive, but the builder never emits it because the
+  structure model has no moment fields today; `show_moments` is inert
+  and `show_structure_options()` reports `moments` unavailable.
+
+### Plan-level structural choices (confirmed at plan start)
+
+- **Single comprehensive plan / one PR** (vs. a foundation-first split):
+  ASCII and Three.js land together on one branch. The step order is
+  still foundation-first so the ASCII path is end-to-end before any JS
+  work.
+- **Dedicated cohesive subpackage** (ADR §4): the viewer subsystem lives
+  under `src/easydiffraction/display/structure/` with a `renderers/`
+  subpackage, keeping the renderer-neutral scene model + renderers
+  together as a future extraction unit (`crysview`). The **scene model**
+  (`scene.py`) imports nothing from easydiffraction domain code; the
+  **builder** (`builder.py`) is the easydiffraction-specific adapter.
+  The name `display/structure/` is **fixed by ADR §4** and used verbatim
+  by every Phase 1 step and Phase 2 test path below — it is **not** an
+  open question. It does not collide with `datablocks/structure/`: the
+  two live under different parents (`easydiffraction.display.structure`
+  vs `easydiffraction.datablocks.structure.categories`), so there is no
+  import ambiguity, and the rename candidate is dropped.
+- **Crystallographic math centralized**: the new orthogonalization
+  (fractional→Cartesian) and ADP-tensor eigendecomposition helpers are
+  added to `src/easydiffraction/crystallography/crystallography.py`
+  (where symmetry-operation parsing and ADP-constraint math already
+  live), and the existing symmetry-op generator
+  (`_get_general_position_ops`) is reused (promoted to a public entry
+  point if needed). The display builder stays a thin adapter.
+
+## Open questions — all resolved for autonomous implementation
+
+These were open during drafting and are now **resolved** (clarified with
+the author), so `/draft-impl-1` can run Phase 1 with **no
+stop-and-ask**. Each item records the final decision; the data sources
+below were verified reachable (HTTP 200).
+
+- **Exact CIF tag spelling for `style`, `view`, and `geom`** (ADR Open
+  Question 1) — **Resolved (final).** Project CIF: `_style.atom_shape`,
+  `_style.radius_model`, `_style.color_scheme`,
+  `_style.adp_probability`, and `_view.type`, `_view.show_labels`,
+  `_view.show_moments`, plus the range as `_view.range_a`,
+  `_view.range_b`, `_view.range_c` (two numbers each, e.g.
+  `_view.range_a   0 1`). Structure CIF (per-structure): the **standard
+  cif_core** bond cutoffs `_geom.min_bond_distance_cutoff` (default
+  `0.0`) and `_geom.bond_distance_incr` (default `0.4`), plus the
+  per-type bonding radius `_atom_type.radius_bond` when present (P1.11).
+  `_view.type` follows the Display-UX ADR (`_chart.type` /
+  `_table.type`); `_style.*` and `_view.*` are project-internal
+  app/settings tags; the bond cutoffs use the standard `_geom.*`
+  category `cif_core.dic` defines (`_geom.min_bond_distance_cutoff` dic
+  13084, `_geom.bond_distance_incr` dic 13044), while the computed
+  `_geom_bond.*` / `_geom_angle.*` loops are a separate, deferred
+  concern. No further confirmation needed during implementation.
+- **ASCII rendering details** (ADR Open Question 2) — **Resolved (final
+  for v1).** A **4-bucket** radius glyph ramp `· • ● ⬤`, and the **8/16
+  colour ANSI** mapping the existing ascii chart legend already uses
+  (`display/plotters/ascii.py`), reused verbatim. Implementers may
+  fine-tune glyph/colour choices against a terminal, but the ramp size
+  and the ANSI palette are fixed — no design decision remains.
+- **Range boundary completion** (ADR Open Question 3) — **Resolved
+  (final for v1).** The scene contains only atoms whose fractional
+  coordinates fall inside the range (borders included); bonds are drawn
+  **only between atoms already in the scene**, so no partner atoms
+  outside the range are generated and no edge-coordination completion is
+  attempted in v1. (Boundary completion can be revisited in a later
+  version.)
+- **Three.js asset acquisition** — **Resolved (URLs verified, HTTP
+  200).** Fetch and vendor these exact pinned files in P1.13 (network
+  needed for that step only), recording the URLs + version (MIT) in the
+  vendored `LICENSES.md`:
+  - `https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js`
+  - `https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/controls/OrbitControls.js`
+  - `https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/renderers/CSS2DRenderer.js`
+    These are **static JS assets, not a Python dependency**, so no
+    `pyproject.toml` change is required (and none is pre-approved).
+- **Plain-category base for `style`.** Resolved: model `Style` on
+  `project/categories/verbosity/` (and `info` / `publication` /
+  `report`), which are the existing plain (non-switchable) categories
+  with the `default.py` + `factory.py` shape — `Verbosity(CategoryItem)`
+  registers via `@VerbosityFactory.register`, derives from
+  `CategoryItem` only (no `SwitchableCategoryBase`), and uses
+  enum-backed `StringDescriptor`s with a `MembershipValidator` and a
+  getter/setter property per setting. `project/categories/rendering/`
+  has no `default.py` / `factory.py`, so it is **not** a usable template
+  and is dropped as a model.
+- **Element data provenance** — **Resolved.** Covalent + vdW radii and
+  Jmol colours from EasyDiffractionBeta `Tables.py` (BSD-3-Clause).
+  Ionic (Shannon) from pymatgen `Shannon_Radii.csv`, atomic from
+  pymatgen `radii.csv`, VESTA colours from pymatgen
+  `ElementColorSchemes.yaml` (all MIT, verified reachable). Shannon
+  representative selection and full URLs are pinned in P1.4. Each
+  value's source is recorded in `LICENSES.md`.
+
+## Concrete files likely to change
+
+**New viewer subsystem (`display/structure/`):**
+
+- `src/easydiffraction/display/structure/__init__.py` (new — package
+  docstring; no `__all__`, explicit imports per AGENTS.md).
+- `src/easydiffraction/display/structure/enums.py` (new —
+  `ViewerEngineEnum`, `AtomShapeEnum`, `RadiusModelEnum`,
+  `ColorSchemeEnum`, each `(str, Enum)` with a `default()` classmethod,
+  modelled on `src/easydiffraction/display/plotting.py:50`
+  `PlotterEngineEnum`).
+- `src/easydiffraction/display/structure/scene.py` (new — frozen
+  dataclasses for the renderer-neutral primitives + `StructureScene`
+  container; **no easydiffraction-domain imports**).
+- `src/easydiffraction/display/structure/builder.py` (new —
+  `build_scene(...)`, the easydiffraction adapter reading structure
+  categories and calling the crystallography helpers).
+- `src/easydiffraction/display/structure/assets/elements.py` (new — the
+  extended per-element database: `vdw`/`covalent`/`ionic`/`atomic`
+  radii + `jmol`/`vesta` palettes, seeded from EasyDiffractionBeta
+  `Tables.py`).
+- `src/easydiffraction/display/structure/assets/radii.py` (new —
+  `radius_for(element, model)` lookup over the database, covalent
+  fallback).
+- `src/easydiffraction/display/structure/assets/colors.py` (new —
+  `color_for(element, scheme)` + a/b/c axis colours + theme-dependent
+  canvas/annotation colours).
+- `src/easydiffraction/display/structure/assets/LICENSES.md` (new —
+  per-source provenance/licence for the vendored element data).
+- `src/easydiffraction/display/structure/viewing.py` (new —
+  `Viewer(RendererBase)` facade + `ViewerFactory(RendererFactoryBase)`,
+  modelled on `src/easydiffraction/display/plotting.py` `PlotterFactory`
+  and `src/easydiffraction/display/tables.py` `TableRendererFactory`).
+- `src/easydiffraction/display/structure/renderers/__init__.py` (new).
+- `src/easydiffraction/display/structure/renderers/base.py` (new —
+  `StructureRendererBase(ABC)`).
+- `src/easydiffraction/display/structure/renderers/ascii.py` (new —
+  `AsciiStructureRenderer`, `@ViewerFactory.register`).
+- `src/easydiffraction/display/structure/renderers/threejs.py` (new —
+  `ThreeJsStructureRenderer`, `@ViewerFactory.register`).
+- `src/easydiffraction/display/structure/renderers/vendor/threejs/` (new
+  — vendored `three.module.js`, `OrbitControls.js`, `CSS2DRenderer.js` +
+  `LICENSES.md`).
+- `src/easydiffraction/display/structure/templates/structure.html.j2`
+  (new — the Three.js HTML/JS shell; mirrors
+  `report/templates/html/report.html.j2`'s offline/online asset switch).
+
+**Core validation (exclusive-bound support for `adp_probability`):**
+
+- `src/easydiffraction/core/validation.py` (existing — extend
+  `RangeValidator` (`core/validation.py:169`) with optional exclusive
+  `gt` / `lt` bounds so a value can be validated in the **open**
+  interval `(0, 1)`; the current `ge` / `le` inclusive bounds stay
+  unchanged and default to ±∞, so every existing caller is unaffected).
+  Needed because the only numeric validator today is inclusive-only and
+  cannot reject `0.0` / `1.0` for `adp_probability` (ADR §6).
+
+**New project categories:**
+
+- `src/easydiffraction/project/categories/view/__init__.py`,
+  `default.py`, `factory.py` (new —
+  `View(CategoryItem, SwitchableCategoryBase)`,
+  `ViewFactory(FactoryBase)`, modelled on
+  `src/easydiffraction/project/categories/chart/`).
+- `src/easydiffraction/project/categories/style/__init__.py`,
+  `default.py`, `factory.py` (new — `Style` plain category +
+  `StyleFactory`, modelled on the existing plain category under
+  `src/easydiffraction/project/categories/verbosity/`).
+
+**New per-structure datablock category (bond cutoffs):**
+
+- `src/easydiffraction/datablocks/structure/categories/geom/__init__.py`,
+  `default.py`, `factory.py` (new — `Geom` single-record `CategoryItem`
+  with `min_bond_distance_cutoff` / `bond_distance_incr`, modelled on
+  the structure `cell` / `space_group` categories; standard CIF
+  `_geom.*` in the structure datablock).
+- `src/easydiffraction/datablocks/structure/item/base.py` (existing —
+  add the `geom` category to `Structure`, mirroring how `cell` /
+  `atom_sites` are owned).
+
+**Crystallography helpers:**
+
+- `src/easydiffraction/crystallography/crystallography.py` (existing —
+  add public `orthogonalization_matrix(a,b,c,alpha,beta,gamma)`,
+  `fractional_to_cartesian(...)`, `adp_principal_axes(tensor)`
+  (eigendecomposition → semi-axis lengths + orientation); reuse /
+  promote `_get_general_position_ops` for symmetry expansion).
+- `src/easydiffraction/crystallography/__init__.py` (existing — export
+  any newly public helpers per the explicit-`__init__` rule).
+
+**Project wiring + persistence:**
+
+- `src/easydiffraction/project/project.py` (existing — add `view` /
+  `style` read-only properties and the private `_swap_view` hook,
+  mirroring `_swap_chart` at `project.py:238`).
+- `src/easydiffraction/project/project_config.py` (existing — import +
+  instantiate `ViewFactory` / `StyleFactory` defaults, mirroring the
+  chart/table wiring at `project_config.py:36`).
+- The CIF read-side hook that restores chart/table (in
+  `project_config.py` / the project-config CIF deserializer) — extend to
+  restore `_view.*` / `_style.*` (mirrors the chart `from_cif` at
+  `project/categories/chart/default.py:94`).
+
+**Display facade:**
+
+- `src/easydiffraction/project/display.py` (existing — add
+  `structure(struct_name=..., include='auto', range=None, path=None)`
+  and `show_structure_options(struct_name=...)` to the class that backs
+  `project.display` and already owns `pattern()` /
+  `show_pattern_options()`; add the structure `include`-option
+  descriptions alongside `_PATTERN_OPTION_DESCRIPTIONS`).
+
+**HTML report integration:**
+
+- `src/easydiffraction/report/html_renderer.py` (existing — embed the
+  structure figure honoring `html_offline`, mirroring the Plotly/MathJax
+  offline path at `html_renderer.py:170` and the MathJax copy at
+  `_copy_mathjax`).
+- `src/easydiffraction/report/templates/html/report.html.j2` (existing —
+  optional structure-figure block under the same `html_offline` switch).
+
+**Packaging + lint/coverage excludes (vendored assets):**
+
+- `pyproject.toml` (existing — add the new vendored Three.js path to the
+  `[tool.ruff]`, `[tool.coverage.run]`, `[tool.interrogate]`, pydoclint,
+  and format-docstring `exclude` lists, mirroring the existing
+  `report/templates/html/vendor` entries; confirm hatchling's wheel
+  packaging ships the new `display/structure/renderers/vendor/` and
+  `display/structure/templates/` subtrees, adding a `force-include` rule
+  only if the defaults miss them).
+- `THIRD_PARTY_LICENSES.md` (existing at repo root — add the Three.js
+  entry and the element-data provenance entry).
+
+**ADR index + ADR promotion (handled by `/draft-impl-1` Phase A /
+P1.16):**
+
+- `docs/dev/adrs/index.md` (existing — add a **User-facing API** row for
+  the crysview ADR).
+- `docs/dev/adrs/suggestions/crysview-structure-visualization.md`
+  (committed by `/draft-impl-1` Phase A; its `_review-*` / `_reply-*`
+  siblings removed there).
+
+**Tutorials and docs:**
+
+- `docs/docs/tutorials/*.py` (existing — add a structure-view example to
+  a representative tutorial; regenerate notebooks via
+  `pixi run notebook-prepare`).
+- `docs/docs/tutorials/*.ipynb` (regenerated artefacts).
+- `docs/docs/user-guide/` and `docs/docs/api-reference/` (existing — add
+  `project.display.structure()`, `project.view`, `project.style`
+  reference + a short user-guide section).
+
+## Commit discipline
+
+When an AI agent follows this plan, **every completed Phase 1
+implementation step must be staged with explicit paths and committed
+locally before moving to the next implementation step or the Phase 1
+review gate.** Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
+**Commits**. Keep commits atomic, single-purpose, and aligned with the
+plan steps. Stage only the files a step enumerates; do not include
+generated artifacts (project directories, data CIFs, benchmark CSVs,
+built wheels) unless a step explicitly produces them — see **Workflow**
+in [`AGENTS.md`](../../../AGENTS.md) for the generated-artifact
+exceptions.
+
+## Implementation steps (Phase 1)
+
+Ordered foundation-first: the scene model, builder, and ASCII engine
+reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
+
+- [ ] **P1.1 — Add viewer + styling enums**
+  - Files: new `src/easydiffraction/display/structure/__init__.py`,
+    `src/easydiffraction/display/structure/enums.py`.
+  - Define four `(str, Enum)` classes per the Enum-Backed Closed Values
+    ADR, each with a `default()` classmethod (model on
+    `PlotterEngineEnum` at `display/plotting.py:50`):
+    - `ViewerEngineEnum`: `ASCII = 'ascii'`, `THREEJS = 'threejs'`
+      (default `THREEJS` — the rich engine, matching `chart`'s
+      default-to-rich-engine precedent and the ADR §8 persisted example
+      `_view.type threejs`). `project.view.type` therefore defaults to
+      `threejs`; see P1.9 and the headless note there.
+    - `AtomShapeEnum`: `BALL = 'ball'`, `ORTEP = 'ortep'` (default
+      `ORTEP`).
+    - `RadiusModelEnum`: `VDW = 'vdw'`, `COVALENT = 'covalent'`,
+      `IONIC = 'ionic'`, `ATOMIC = 'atomic'` (default `COVALENT` — the
+      charge-free model with complete per-element data).
+    - `ColorSchemeEnum`: `JMOL = 'jmol'`, `VESTA = 'vesta'` (default
+      `JMOL`).
+  - `__init__.py`: package docstring only; explicit imports added as
+    later steps land modules (no `__all__`).
+  - Commit: `Add crysview viewer and styling enums`.
+
+- [ ] **P1.2 — Add the renderer-neutral scene model**
+  - Files: new `src/easydiffraction/display/structure/scene.py`.
+  - `@dataclass(frozen=True, slots=True)` primitives in Cartesian space,
+    carrying only stdlib / numpy / RGB-tuple types — **no
+    easydiffraction-domain imports** (extraction constraint, ADR §4):
+    - `AtomSphere` (centre, radius, colour, label).
+    - `OccupancyWedgeSphere` (centre, radius, ordered
+      `(fraction, colour)` wedges incl. an optional vacancy wedge,
+      label).
+    - `AdpEllipsoid` (centre, semi-axis lengths, orientation
+      matrix/quaternion, colour, label).
+    - `Bond` (two endpoints, two colours split at midpoint).
+    - `MomentArrow` (origin, vector, colour) — **defined but never
+      emitted in version 1** (gated, ADR §1 + Deferred Work). It still
+      carries a numpy-style docstring like every other primitive (so
+      `interrogate` passes) and is exercised by a direct construction
+      test in Phase 2 (so it is not a coverage gap despite the builder
+      never emitting it).
+    - `CellEdges` (the 12 edges, as Cartesian segment endpoints).
+    - `AxisTriad` (a/b/c arrow vectors + per-axis colours + letters).
+    - `TextLabel` (anchor, text).
+    - `StructureScene` — the flat container holding lists of the above
+      plus the cell basis used for projection.
+  - Numpy-style docstrings ≤72-char summaries on every public class.
+  - Commit: `Add renderer-neutral structure scene model`.
+
+- [ ] **P1.3 — Add crystallographic geometry helpers**
+  - Files: existing
+    `src/easydiffraction/crystallography/crystallography.py`,
+    `src/easydiffraction/crystallography/__init__.py`.
+  - Add public helpers (centralized math decision):
+    - `orthogonalization_matrix(a, b, c, alpha, beta, gamma) -> np.ndarray`
+      — the 3×3 fractional→Cartesian matrix from cell parameters
+      (standard crystallographic convention; document the chosen axis
+      setting).
+    - `fractional_to_cartesian(frac, matrix) -> np.ndarray`.
+    - `adp_principal_axes(tensor) -> tuple[np.ndarray, np.ndarray]` —
+      eigendecomposition (`numpy.linalg.eigh`) of a symmetric 3×3 ADP
+      tensor returning semi-axis lengths + orientation; document the
+      U-vs-B and Cartesian-vs-crystal convention used.
+    - A public symmetry-expansion entry point reusing the existing
+      `_get_general_position_ops` / `_parse_rotation_matrix`
+      (`crystallography.py:399`, `:350`) — either promote
+      `_get_general_position_ops` to public or add a thin public wrapper
+      that yields `(rotation, translation)` ops for a space group.
+  - Export any newly public helpers from `crystallography/__init__.py`.
+  - Commit: `Add orthogonalization and ADP eigendecomposition helpers`.
+
+- [ ] **P1.4 — Build the extended element database (radii + colours)**
+  - Files: new
+    `src/easydiffraction/display/structure/assets/__init__.py`,
+    `assets/elements.py` (or a vendored data file + loader),
+    `assets/radii.py`, `assets/colors.py`, `assets/LICENSES.md`.
+  - Build **one extended per-element database** as a package asset (not
+    CIF-serialized), complete for the elements EasyDiffraction handles,
+    carrying for each element the four radii (`vdw`, `covalent`, `ionic`
+    representative Shannon at a documented default oxidation
+    state/coordination, `atomic`) and the `jmol`/CPK and `vesta` colour
+    palettes, every value tagged with its provenance.
+  - **Seed from our own prior data, then extend from verified sources.**
+    EasyDiffractionBeta's `easyDiffractionApp/Logic/Tables.py`
+    `PERIODIC_TABLE` (BSD-3-Clause, our project) provides the Jmol/CPK
+    `color` and the `covalent` and `vdW` radii per element — reuse
+    verbatim with provenance. Fetch the remaining values from
+    **pymatgen** (MIT; each URL verified reachable, HTTP 200),
+    **extracting the data values, not adding a runtime dependency**. Raw
+    URLs under
+    `https://raw.githubusercontent.com/materialsproject/pymatgen/master/`:
+    - **Ionic (Shannon)** radii →
+      `dev_scripts/periodic_table_resources/Shannon_Radii.csv` (columns
+      `Element, Charge, Coordination, Spin State, Crystal Radius, Ionic Radius`;
+      original: R. D. Shannon, Acta Cryst. (1976) A32, 751).
+    - **Atomic** radii →
+      `dev_scripts/periodic_table_resources/radii.csv` (`Atomic radius`
+      column; `Van der waals radius` there is a cross-check of the
+      seed).
+    - **VESTA** (and Jmol cross-check) colours →
+      `src/pymatgen/vis/ElementColorSchemes.yaml` (`Jmol:` / `VESTA:`
+      RGB maps; VESTA original: Momma & Izumi, J. Appl. Cryst. 2011).
+      Cite each pymatgen file URL **and** the primary scientific
+      reference in `LICENSES.md`. **Network access is needed for this
+      step** to fetch these.
+  - **Shannon representative-radius policy (deterministic,
+    reproducible).** The atom-site model carries only an element symbol,
+    so pick exactly one Shannon row per element by a fixed rule:
+    **charge** = the element's main oxidation state from pymatgen
+    `dev_scripts/periodic_table_resources/oxidation_states.yaml` (same
+    repo/raw-URL base, verified reachable HTTP 200; take its first
+    listed positive state, falling back to the first listed state);
+    **coordination** = `VI` (else the lowest coordination present if
+    `VI` is absent); **spin** = high-spin where a spin state is listed;
+    take the `Ionic Radius` column. If no Shannon row matches the chosen
+    charge, fall back to that element's covalent radius (the
+    `substituted` flag). Record the chosen `(charge, coordination)` per
+    element in `LICENSES.md`. Ionic is not the default model, so this
+    only applies when the user selects `radius_model = 'ionic'`.
+  - `radii.py`: `radius_for(element, model) -> tuple[float, bool]`
+    lookup returning the radius and a `substituted` flag; a miss for the
+    selected model (e.g. an element with no ionic entry) falls back to
+    **covalent** (the default model, always populated), surfaced by
+    `show_structure_options()` per ADR §6.
+  - `colors.py`: `color_for(element, scheme) -> RGB` for `jmol` /
+    `vesta`, plus the a/b/c axis colours the scene gives every engine,
+    plus the theme-dependent canvas/annotation colours the renderers
+    read from `is_dark()` (P1.14).
+  - `assets/LICENSES.md`: per-source provenance + licence (Tables.py
+    seed; Shannon ionic; atomic; VESTA), no hand-guessed values.
+  - Commit: `Add extended element database for radii and colours`.
+
+- [ ] **P1.5 — Add the scene builder**
+  - Files: new `src/easydiffraction/display/structure/builder.py`.
+  - `build_scene(structure, *, style, view_range, features) -> StructureScene`,
+    the easydiffraction adapter. **`features` is the already-resolved
+    concrete set of primitives to emit (e.g.
+    `frozenset({'atoms', 'bonds', 'cell', 'axes'})`), never the raw
+    `'auto'` request** — the builder only decides which primitive lists
+    to populate and **never re-implements ADR §8 precedence** (that is
+    the facade's job, P1.12):
+    - Read cell (`cell.length_a…angle_gamma`), atom sites (`atom_sites`:
+      label, `type_symbol`, `fract_x/y/z`, `occupancy`, `adp_iso`,
+      `adp_type`), anisotropic ADP (`atom_site_aniso.adp_11…adp_23`),
+      and the space group (`space_group.name_h_m`,
+      `it_coordinate_system_code`).
+    - **Symmetry expansion** over `view_range` using the P1.3 ops; keep
+      every generated copy whose fractional coords fall in the per-axis
+      range, **borders included**.
+    - **Scene-atom identity dedup**: same atom-site row + coords within
+      `1e-4` → keep one (ADR §3).
+    - **Occupancy grouping**: distinct rows at the same position (within
+      `1e-4`) → one `OccupancyWedgeSphere` with proportional wedges; sum
+      < 1 → vacancy wedge; sum ≥ 1 → normalize (ADR §3).
+    - **fractional→Cartesian** via P1.3.
+    - **Atom shape** (style.atom*shape): `ortep` → `AdpEllipsoid` from
+      `adp_principal_axes` scaled to `adp_probability` (anisotropic) or
+      a radius-model sphere (isotropic / no ADP); `ball` → radius-model
+      sphere always. The display radius model sets sphere \_size* only —
+      it does **not** drive bond detection (bonds use the `_geom`
+      cutoffs below).
+    - **Bonds**: between in-scene atoms whose separation `d` satisfies
+      the standard cif_core `_geom` auto-bonding rule (P1.11) —
+      `geom.min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + geom.bond_distance_incr`,
+      where `r_bond` is `_atom_type.radius_bond` when the structure
+      carries it, else the element's covalent radius from the bundled DB
+      (P1.4). Split-coloured at midpoint; only atoms already in the
+      scene (no out-of-range partners, see Open Questions). The builder
+      reads the cutoffs from `structure.geom`, like cell/atom data —
+      they are not styling and are independent of the display
+      `radius_model`.
+    - **Cell edges + axis triad + labels** always built; **moments never
+      emitted** (gated).
+  - **Single source of truth for visibility.** The builder receives the
+    facade-resolved `features` set and populates exactly those primitive
+    lists — it does not see `'auto'`, persisted `show_*` flags, or the
+    `include=` request, so ADR §8 precedence lives only in the facade
+    (P1.12).
+  - **Data-availability probe (same module).** Add
+    `structure_feature_availability(structure, *, style) -> FeatureAvailability`
+    — a lightweight read of the structure (no full scene build)
+    reporting, per feature, whether the data exists (e.g. `moments`
+    always absent in version 1; `bonds`/`axes`/`cell` always available;
+    `labels` always available) **plus** the ionic→covalent radius
+    substitutions the chosen `radius_model` would trigger. The builder
+    is the only place that reads the structure, so this probe is the one
+    source both the facade's `'auto'` resolution **and**
+    `show_structure_options()` (P1.12) call; neither re-reads the
+    structure for availability.
+  - Commit: `Add structure scene builder`.
+
+- [ ] **P1.6 — Add base + ASCII structure renderer**
+  - Files: new
+    `src/easydiffraction/display/structure/renderers/__init__.py`,
+    `renderers/base.py`, `renderers/ascii.py`.
+  - `StructureRendererBase(ABC)`: abstract `render(scene, *, features)`
+    contract (the content-resolved feature set from the facade, per
+    P1.12) and a `supported_features()` capability hook with two
+    distinct readers: (a) the **renderer** uses it to filter the passed
+    `features` set and announce + skip what it cannot draw (the
+    render-time owner, per P1.12); (b) the **facade** queries it **only
+    to preview** availability through `show_structure_options()` — the
+    facade never intersects or drops features itself.
+  - **Registration import point (AGENTS.md §Architecture).**
+    `renderers/__init__.py` explicitly imports the concrete renderer
+    class — `AsciiStructureRenderer` now, `ThreeJsStructureRenderer` in
+    P1.14 — so the package `__init__.py` is the single import point per
+    the convention, **not** an import side-effect in `viewing.py`. At
+    this step `ViewerFactory` does not exist yet (it lands in P1.7), so
+    `AsciiStructureRenderer` carries **no** decorator and importing the
+    package registers nothing yet. P1.7 attaches
+    `@ViewerFactory.register` once the factory exists, and that is when
+    importing the package triggers registration.
+  - `AsciiStructureRenderer` (ADR §7), the reduced-fidelity sibling:
+    - Project the scene's Cartesian atom centres + cell edges onto a
+      plane (longest in-plane axis horizontal, shortest vertical, middle
+      axis = viewing direction).
+    - Draw the cell as a schematic parallelogram using the asciichartpy
+      glyph set (`│ ╭ ╮ ╯ ╰ ─`); add a **row-major gap-free line
+      helper** generalizing the existing asciichartpy connector used by
+      `display/plotters/ascii.py` (column-major) so near-vertical
+      slanted edges rasterize.
+    - Atoms as colour-by-element Unicode circles on a radius-bucketed
+      glyph ramp; axis arrows tinted with the a/b/c scheme colours
+      (nearest terminal colour, reset after); a colour-tinted legend.
+    - Always one default cell; **announce** any 3D-only request (bonds,
+      labels, ellipsoids, moments, multi-cell/margin `range`) and skip
+      it, mirroring the ascii chart engine.
+  - Renderer is developed against a hand-built `StructureScene`, so it
+    is testable before the facade exists.
+  - Commit: `Add ASCII structure renderer`.
+
+- [ ] **P1.7 — Add the Viewer facade + factory; register ASCII**
+  - Files: new `src/easydiffraction/display/structure/viewing.py`;
+    update `display/structure/renderers/ascii.py` with
+    `@ViewerFactory.register`; update `display/structure/__init__.py`.
+  - `ViewerFactory(RendererFactoryBase)` + `Viewer(RendererBase)`
+    modelled on `PlotterFactory` / `Plotter`
+    (`display/plotting.py:5980`) and `TableRendererFactory` /
+    `TableRenderer` (`display/tables.py:142`): a `_registry()` of
+    `{engine: {'description', 'class'}}`, `descriptions()`, and the
+    active-engine binding the `_swap_view` hook rebinds. Add the
+    `@ViewerFactory.register` decorator to `AsciiStructureRenderer` in
+    this step (the factory now exists).
+  - **Registration wiring (AGENTS.md §Architecture).**
+    `display/structure/__init__.py` explicitly imports the `renderers`
+    package (which imports the concrete renderer classes, P1.6) **and**
+    `Viewer` / `ViewerFactory` from `viewing.py`, so importing the
+    `display.structure` package triggers every
+    `@ViewerFactory.register`. `viewing.py` itself does **not** import
+    the renderer modules (that would create an import cycle, since the
+    renderers import `ViewerFactory` for the decorator) — the package
+    `__init__.py` is the single import point, exactly as the
+    registration convention requires.
+  - Commit: `Add Viewer facade and factory with ASCII engine`.
+
+- [ ] **P1.8 — Add the plain `style` category**
+  - Files: existing `src/easydiffraction/core/validation.py`; new
+    `src/easydiffraction/project/categories/style/__init__.py`,
+    `default.py`, `factory.py`.
+  - **First, enable open-interval validation.** Extend `RangeValidator`
+    (`core/validation.py:169`) with optional exclusive `gt` / `lt`
+    bounds alongside the existing inclusive `ge` / `le` (all four
+    default to ±∞, so existing callers are unchanged): a value passes
+    when `ge <= value <= le` **and** `gt < value < lt`. Update the
+    docstring and `Diagnostics.range_mismatch` reporting to name
+    whichever bound was violated. This is bundled into P1.8's single
+    commit because it is the enabling prerequisite for
+    `adp_probability`; the validator change ships with the only caller
+    that needs it. (Its dedicated unit test is a Phase 2 item.)
+  - `Style` plain category (model on `project/categories/verbosity/`,
+    the plain-category-with-factory shape — `Verbosity(CategoryItem)` +
+    `@VerbosityFactory.register`, no `SwitchableCategoryBase`,
+    enum-backed `StringDescriptor`s with a `MembershipValidator` and a
+    getter/setter per setting) with descriptors validated on assignment:
+    `atom_shape` (`AtomShapeEnum`), `radius_model` (`RadiusModelEnum`),
+    `color_scheme` (`ColorSchemeEnum`), and `adp_probability` (float
+    validated in the **open** interval `(0, 1)` via the extended
+    `RangeValidator` with `gt=0.0, lt=1.0`). Bond cutoffs are **not**
+    here — they are a per-structure property (P1.11). CIF tags
+    `_style.*` (see Open Questions). `show_supported()` lists accepted
+    values for every styling setting (ADR §6). No factory-swapped
+    `type`.
+  - Register `Style` in `project/categories/style/__init__.py`.
+  - Commit: `Add style category for structure view styling`.
+
+- [ ] **P1.9 — Add the switchable `view` category**
+  - Files: new
+    `src/easydiffraction/project/categories/view/__init__.py`,
+    `default.py`, `factory.py`.
+  - `View(CategoryItem, SwitchableCategoryBase)` modelled on `Chart`
+    (`project/categories/chart/default.py`): `_category_code='view'`,
+    `_owner_attr_name='view'`, `_swap_method_name='_swap_view'`; a
+    `type` `StringDescriptor` with CIF `_view.type` validated against
+    `ViewerEngineEnum` + `ViewerFactory.descriptions()` and **defaulting
+    to `ViewerEngineEnum.default()` (`threejs`)**, matching P1.1;
+    `from_cif` calling `self._parent._swap_view`. Plus persisted
+    view-state descriptors: `show_labels` (bool, default off),
+    `show_moments` (bool, default on-where-data), and the per-axis
+    `range` as `_view.range_a/b/c` (two-number min/max each, validated
+    min < max). `show_supported()` lists engines.
+  - **Headless implication of the `threejs` default.** With `threejs`
+    default, `project.display.structure(...)` returns/writes an HTML
+    string and needs **no browser**, so it runs unattended in CI,
+    `script-tests`, and notebooks out of the box. The
+    terminal/CLI/headless `ascii` engine the ADR §2 names is opt-in via
+    `project.view.type = 'ascii'`. The P1.16 tutorial and the Phase 2
+    script-test coverage item therefore exercise **both** paths: the
+    default `threejs` HTML emission and an explicit
+    `view.type = 'ascii'` terminal render (see the Phase 2 "Integration
+    / script-test coverage" item).
+  - Register `View` in `project/categories/view/__init__.py`.
+  - Commit: `Add switchable view category for renderer selection`.
+
+- [ ] **P1.10 — Wire `project.view` / `project.style` + CIF
+      persistence**
+  - Files: existing `src/easydiffraction/project/project.py`,
+    `src/easydiffraction/project/project_config.py` (+ the
+    project-config CIF deserializer hook).
+  - Add read-only `view` / `style` properties on `Project` (mirror
+    `chart` / `table` at `project.py:315`) and the private `_swap_view`
+    hook (mirror `_swap_chart` at `project.py:238`) that rebinds the
+    active `Viewer` engine.
+  - Instantiate `ViewFactory` / `StyleFactory` defaults in
+    `project_config.py` (mirror `project_config.py:36`) and extend the
+    CIF read side to restore `_view.*` / `_style.*` (mirror the chart
+    `from_cif`).
+  - Round-trip check is deferred to the Phase 2 tests; this step only
+    wires the surfaces.
+  - Commit: `Wire project.view and project.style with CIF persistence`.
+
+- [ ] **P1.11 — Add the per-structure `geom` bond-cutoff category**
+  - Files: new
+    `src/easydiffraction/datablocks/structure/categories/geom/__init__.py`,
+    `default.py`, `factory.py`; existing
+    `src/easydiffraction/datablocks/structure/item/base.py` (add the
+    category to `Structure`).
+  - `Geom` per-structure category — a **single-record `CategoryItem`**
+    (model on `cell` / `space_group`, not the `atom_sites` loop) holding
+    the standard cif_core bond-generation cutoffs:
+    - `min_bond_distance_cutoff` (float Å, default `0.0`) — CIF
+      `_geom.min_bond_distance_cutoff`.
+    - `bond_distance_incr` (float Å, default `0.4`, documented and
+      tunable) — CIF `_geom.bond_distance_incr`. A bond forms between
+      two in-scene atoms when
+      `min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + bond_distance_incr`,
+      where `r_bond` is `_atom_type.radius_bond` when the structure
+      carries it, else the element's covalent radius from the bundled DB
+      (P1.4); version 1 has no `_atom_type` category, so covalent is
+      used. Both tags are the **standard** `cif_core.dic` definitions
+      (`_geom.min_bond_distance_cutoff`, `_geom.bond_distance_incr`) and
+      always serialize in the **structure datablock**.
+  - Add `geom` to `Structure` (the `CategoryOwner` auto-discovers any
+    `CategoryItem` attribute) and register the concrete class in
+    `datablocks/structure/categories/geom/__init__.py`.
+  - This is the per-structure home the builder reads bond cutoffs from
+    (P1.5), so multi-phase projects can carry different cutoffs per
+    phase; the computed `_geom_bond` / `_geom_angle` loops and the
+    angle/contact cutoffs are deferred (ADR Deferred Work).
+  - Commit: `Add per-structure geom bond-cutoff category`.
+
+- [ ] **P1.12 — Add `display.structure()` + `show_structure_options()`**
+  - Files: existing `src/easydiffraction/project/display.py`.
+  - Add to the class backing `project.display` (owner of `pattern()` /
+    `show_pattern_options()`):
+    - `structure(struct_name, include='auto', range=None, path=None)`:
+      resolve the structure by name; **resolve the concrete `features`
+      set here** (see precedence below) by calling P1.5's
+      `structure_feature_availability(structure, style=project.style)`;
+      build the scene via
+      `build_scene(structure, style=project.style, view_range=<resolved range>, features=<resolved set>)`
+      (per-call `range` overrides the persisted `project.view.range` for
+      that call); render with the active `project.view` engine.
+      **Signature mirrors `pattern()`**: `structure(...) -> None`,
+      displaying directly as a side effect (notebook: `IPython.display`
+      of the engine's HTML; terminal: print the ASCII view); when `path`
+      is given, also write a standalone, self-contained HTML file
+      (Three.js embedded). (`pattern()` is `-> None` and displays
+      directly — verified in `display.py` — so no open signature
+      decision remains.)
+    - `show_structure_options(struct_name)`: mirror
+      `show_pattern_options()` — list each `include=` option with engine
+      - data support and the reason when unavailable, reading the
+        **same** `structure_feature_availability(...)` probe (P1.5) plus
+        the active engine's `supported_features()` (P1.6), so it never
+        re-reads the structure: ascii's 3D-only skips; `moments` until
+        moment fields exist; ionic→covalent radius substitutions from
+        P1.4.
+    - **Content precedence — resolved only here (ADR §8).** The facade
+      is the single resolver of **which features the data and flags
+      select**; it does **not** filter by what the engine can draw. It
+      resolves content in a fixed order:
+      1. explicit `include=(...)` tuple → that set wins outright,
+         ignoring persisted `show_*`;
+      2. `include='auto'` → per feature, data-availability (from the
+         probe) → persisted `show_*` flag where one exists → built-in
+         default;
+      3. live modebar toggles are runtime-only and never rewrite the
+         resolved/persisted state.
+    - **Supported-feature filtering + announce/skip — the renderer's
+      job, not the facade's.** The content-resolved set is passed to
+      `build_scene(..., features=...)` and on to the active renderer;
+      the **renderer** is the authority on what it can draw, so it draws
+      the features `supported_features()` allows and **announces +
+      skips** any it cannot (ascii's 3D-only
+      bonds/labels/ellipsoids/moments/wider `range`), never erroring
+      (P1.6). The facade never drops features and never announces at
+      render time — it only queries `supported_features()` to
+      **preview** the same information through
+      `show_structure_options()`, so an unsupported feature is announced
+      exactly once.
+    - Add structure `include`-option descriptions next to
+      `_PATTERN_OPTION_DESCRIPTIONS`.
+  - End-to-end ASCII path works after this step
+    (`project.view.type='ascii'`).
+  - Commit:
+    `Add structure() and show_structure_options() display surface`.
+
+- [ ] **P1.13 — Vendor pinned Three.js assets + lint/coverage excludes**
+  - Files: new
+    `src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js`,
+    `OrbitControls.js`, `CSS2DRenderer.js`, and a sibling `LICENSES.md`;
+    existing `pyproject.toml`, `THIRD_PARTY_LICENSES.md`.
+  - Fetch `three@0.160.0` + the two addons from the upstream the
+    prototype pins; record exact source URLs + version + licence (MIT)
+    in the vendored `LICENSES.md`. **Network access is needed for this
+    step only.**
+  - Add the vendored path to the `exclude` lists for ruff, coverage,
+    interrogate, pydoclint, and format-docstring in `pyproject.toml`
+    (mirror the existing `report/templates/html/vendor` entries). Add
+    the Three.js row to `THIRD_PARTY_LICENSES.md`.
+  - If hatchling's defaults don't ship the new `vendor/` (and the P1.14
+    `templates/`) subtree, add a `force-include` rule under
+    `[tool.hatch.build.targets.wheel]`. The actual `pixi run dist-build`
+    wheel check is a Phase 2 step.
+  - Commit: `Vendor pinned Three.js assets`.
+
+- [ ] **P1.14 — Add the Three.js structure renderer**
+  - Files: new
+    `src/easydiffraction/display/structure/renderers/threejs.py`; new
+    `src/easydiffraction/display/structure/templates/structure.html.j2`;
+    update `display/structure/renderers/__init__.py` to add the explicit
+    `ThreeJsStructureRenderer` import (so its `@ViewerFactory.register`
+    fires on package import, per the registration convention — not via a
+    `viewing.py` side-effect).
+  - `ThreeJsStructureRenderer` (`@ViewerFactory.register`):
+    - Serialize the `StructureScene` to JSON (primitive arrays).
+    - Render the HTML/JS shell from `structure.html.j2`: pinned Three.js
+      - `OrbitControls` + `CSS2DRenderer`, the Plotly-style modebar
+        (perspective/parallel toggle, view-along a/b/c, home/reset,
+        per-feature visibility toggles for
+        cell/axes/atoms/bonds/moments/ labels), shrink-wrapped legend,
+        hover tooltips, persistent labels, orbit/zoom/pan; **parallel
+        projection default**; initial visibility from the resolved
+        `include` (P1.12).
+    - **Offline-autonomous by default** for notebook + standalone HTML
+      (assets embedded inline, no network — what a CDN-blocked context
+      needs); expose an `offline`/embed switch so the HTML-report path
+      (P1.15) can link vs embed.
+    - **Dark/light theme.** Detect the host theme via the project's
+      `is_dark()` (`utils/_vendored` — the same call the Plotly plotter
+      uses to pick `plotly_dark`/`plotly_white`) and set the scene
+      background and the label/axis/edge colours from the
+      theme-dependent colours in `assets/colors.py` (P1.4); element
+      colours still come from the selected scheme. Auto-detected, not
+      persisted.
+    - Provide the IPython HTML representation the facade returns and the
+      standalone-HTML write path.
+  - Commit: `Add Three.js structure renderer`.
+
+- [ ] **P1.15 — Embed the structure figure in the HTML report**
+  - Files: existing `src/easydiffraction/report/html_renderer.py`,
+    `src/easydiffraction/report/templates/html/report.html.j2`.
+  - Render a structure figure into the HTML report honoring the report's
+    existing `html_offline` flag — embed the Three.js assets when
+    offline, link them otherwise — so a structure figure behaves like
+    the existing Plotly figures (ADR §5). Reuse the offline-copy pattern
+    at `html_renderer.py` `_copy_mathjax` / the `include_plotlyjs`
+    switch at `html_renderer.py:170`.
+  - Commit: `Embed structure figure in HTML report under html_offline`.
+
+- [ ] **P1.16 — Promote ADR index row, tutorials, and docs**
+  - Files: existing [`docs/dev/adrs/index.md`](../adrs/index.md);
+    `docs/docs/tutorials/*.py` (+ regenerated `*.ipynb`);
+    `docs/docs/user-guide/`, `docs/docs/api-reference/`.
+  - Add the **User-facing API** index row for the crysview ADR (the ADR
+    file itself is committed/promoted by `/draft-impl-1` Phase A).
+  - Add a structure-view example to a representative tutorial
+    (`project.view.type`, `project.style.*`,
+    `structure.geom.min_bond_distance_cutoff` /
+    `structure.geom.bond_distance_incr`,
+    `project.display.structure(...)`, `show_structure_options(...)`);
+    regenerate notebooks via `pixi run notebook-prepare` and stage the
+    `.py` + regenerated `.ipynb` together.
+  - Add `project.display.structure()` / `project.view` / `project.style`
+    and the per-structure `structure.geom` bond cutoffs to the API
+    reference and a short user-guide section.
+  - Commit: `Document structure view in tutorials and reference`.
+
+- [ ] **P1.17 — Reach Phase 1 review gate**
+  - No-code step. Mark every `[ ]` above as `[x]`; commit the plan-file
+    update alone.
+  - Commit: `Reach Phase 1 review gate`.
+
+## Test plan (Phase 2)
+
+Per AGENTS.md §Testing, every new module/class ships with tests; unit
+tests mirror the source tree (`src/easydiffraction/<pkg>/<mod>.py` →
+`tests/unit/easydiffraction/<pkg>/test_<mod>.py`) — verify with
+`pixi run test-structure-check`. No network, no sleeping, no real
+calculation engines, no test-ordering dependence. Vendored Three.js +
+element-data assets are excluded from test-structure mirroring and
+coverage (configured in P1.13).
+
+- [ ] **`tests/unit/easydiffraction/display/structure/test_enums.py`**
+      (new) — each enum's members, values, and `default()`. P1.1.
+- [ ] **`tests/unit/easydiffraction/display/structure/test_scene.py`**
+      (new) — primitives are frozen/slotted; `StructureScene` holds the
+      primitive lists; the module imports **nothing** from
+      `easydiffraction` domain packages (assert via an import-graph
+      check). Includes a **direct `MomentArrow` construction test**
+      (build it, assert its fields) so the gated, never-emitted
+      primitive is covered. P1.2.
+- [ ] **`tests/unit/easydiffraction/crystallography/test_crystallography.py`**
+      (extend) — `orthogonalization_matrix` for orthorhombic (diagonal)
+      and a known monoclinic/triclinic cell (compare to a hand-computed
+      matrix and check `|det| = unit-cell volume`);
+      `fractional_to_cartesian` round-trips a known site;
+      `adp_principal_axes` diagonalizes a known tensor to expected
+      semi-axes/orientation and recovers an isotropic tensor as equal
+      axes; the public symmetry-expansion wrapper returns the right
+      operation count for a known space group. P1.3.
+- [ ] **`tests/unit/easydiffraction/display/structure/assets/test_radii.py`**
+      and **`test_colors.py`** (new) — a known element resolves to the
+      documented radius for each of the four models; a miss for the
+      selected model falls back to covalent with the `substituted` flag
+      set; the database is complete for the seeded covalent/vdW/Jmol
+      values from `Tables.py`; `jmol` and `vesta` palettes return RGB
+      for known elements; the a/b/c axis colours and the dark/light
+      canvas colours are returned. P1.4.
+- [ ] **`tests/unit/easydiffraction/display/structure/test_builder.py`**
+      (new) — against small hand-built structures (no real engine):
+  - Special-position overlap collapses to one scene atom; a corner site
+    with the default `[0,1]³` range appears at all eight corners (border
+    inclusion + identity rule). P1.5.
+  - Two rows at one position → one occupancy-wedge sphere; sum < 1 adds
+    a vacancy wedge; sum ≥ 1 normalizes with no vacancy wedge. P1.5.
+  - `ortep` anisotropic atom → `AdpEllipsoid` scaled to
+    `adp_probability`; isotropic/no-ADP → sphere; `ball` → sphere
+    always. P1.5.
+  - Bonds appear only between in-scene atoms satisfying the `_geom`
+    auto-bonding rule
+    `min_bond_distance_cutoff ≤ d ≤ r_bond(A)+r_bond(B)+ bond_distance_incr`
+    (`r_bond` = covalent radius in v1); varying `bond_distance_incr`
+    adds/drops bonds; nothing below `min_bond_distance_cutoff`; no
+    out-of-range partner atoms are generated. P1.5.
+  - Moments are never emitted. P1.5.
+  - The builder emits exactly the primitive lists named in the passed
+    `features` set and reads neither `'auto'` nor persisted `show_*`
+    flags (precedence is the facade's job);
+    `structure_feature_availability(...)` reports `moments` unavailable
+    and flags ionic→covalent substitutions without building a scene.
+    P1.5.
+- [ ] **`tests/unit/easydiffraction/display/structure/renderers/test_ascii.py`**
+      (new) — orthorhombic cell renders a rectangular parallelogram;
+      monoclinic renders the slanted staircase; atoms map to the
+      bucketed glyph ramp; a 3D-only `include` (bonds/labels/moments)
+      and a wider `range` are announced and skipped; legend lists
+      elements. P1.6.
+- [ ] **`tests/unit/easydiffraction/display/structure/test_viewing.py`**
+      (new) — `ViewerFactory` registers `ascii` (and `threejs` after
+      P1.14); `descriptions()` lists them; the facade rebinds the active
+      engine. P1.7, P1.14.
+- [ ] **`tests/unit/easydiffraction/core/test_validation.py`** (extend)
+      — the extended `RangeValidator` with exclusive `gt` / `lt` bounds
+      rejects the endpoints (`gt=0.0` rejects `0.0`, `lt=1.0` rejects
+      `1.0`) and accepts an interior value; a validator with only `ge` /
+      `le` still behaves exactly as before (no regression for existing
+      callers). P1.8.
+- [ ] **`tests/unit/easydiffraction/project/categories/style/test_style.py`**
+      (new — single parent-level test if the package is only
+      `default.py`/`factory.py`) — enum assignment validates (bad value
+      raises `typeguard.TypeCheckError` / `ValueError`);
+      `adp_probability` accepts an interior value (e.g. `0.5`) and
+      **rejects both endpoints `0.0` and `1.0`** (open interval, via the
+      extended `RangeValidator`); `show_supported()` lists every
+      setting's accepted values; `_style.*` CIF round-trips. P1.8.
+- [ ] **`tests/unit/easydiffraction/project/categories/view/test_view.py`**
+      (new) — `type` validates against `ViewerEngineEnum`; setting
+      `type` calls `_swap_view`; `range` rejects min ≥ max; `_view.type`
+      / `_view.show_*` / `_view.range_*` CIF round-trip;
+      `show_supported()` lists engines. P1.9.
+- [ ] **`tests/unit/easydiffraction/project/test_project.py`** (extend)
+      — `project.view` / `project.style` are read-only attributes;
+      switching `project.view.type` rebinds the active engine; a saved +
+      reloaded project restores `_view.*` / `_style.*` identically.
+      P1.10.
+- [ ] **`tests/unit/easydiffraction/datablocks/structure/categories/geom/test_geom.py`**
+      (new — single parent-level test if the package is only
+      `default.py`/`factory.py`) — defaults are
+      `min_bond_distance_cutoff = 0.0` and `bond_distance_incr = 0.4`;
+      both `_geom.min_bond_distance_cutoff` and
+      `_geom.bond_distance_incr` round-trip in the **structure**
+      datablock; a multi-phase project keeps independent cutoffs per
+      structure. P1.11.
+- [ ] **`tests/unit/easydiffraction/project/test_display.py`** (extend)
+      — `structure()` returns the expected representation per engine;
+      per-call `range=` overrides the persisted range for that call
+      only; `include='auto'` resolves per ADR §8 (data → persisted →
+      default); an explicit tuple ignores persisted `show_*`;
+      unsupported options are skipped, never raised;
+      `show_structure_options()` reports support + reasons (ascii
+      3D-only, moments gated, ionic→covalent substitution). P1.12.
+- [ ] **`tests/unit/easydiffraction/display/structure/renderers/test_threejs.py`**
+      (new) — the renderer emits an HTML string containing the scene
+      JSON and the modebar controls; **offline** mode embeds the
+      Three.js asset text inline (no CDN URL), online mode links it; the
+      standalone write path produces a self-contained file; the resolved
+      dark/light theme drives the canvas/annotation colours (assert the
+      dark vs light background differs when `is_dark()` is
+      monkeypatched), while element colours stay scheme-driven. Assert
+      on emitted markup, not a live browser. P1.14.
+- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
+      (extend) — `html_offline=True` embeds the Three.js assets next to
+      / inside the report; `html_offline=False` links them; the
+      structure figure block appears when a structure is present. P1.15.
+- [ ] **Wheel-packaging verification** — `pixi run dist-build` then
+      `unzip -l dist/*.whl | grep -E 'three.module.js|OrbitControls|CSS2DRenderer|structure.html.j2'`
+      confirms the vendored Three.js + HTML template ship in the wheel.
+      `dist/*.whl` is a verification artefact — do not stage it. P1.13.
+- [ ] **Integration / script-test coverage** — confirm
+      `pixi run script-tests` exercises the tutorial that calls
+      `project.display.structure(...)` along **both** engine paths: the
+      **default `threejs`** HTML emission (no browser, runs headless in
+      CI) and an explicit `project.view.type = 'ascii'` terminal render.
+      Extend a tutorial if not. P1.16.
+
+Use `pixi run test-structure-check` to confirm the unit-test layout
+mirrors the source tree per AGENTS.md §Testing.
+
+## Verification commands (Phase 2)
+
+Per AGENTS.md §Workflow, save any required check output with the
+zsh-safe pattern. Variable names per task (never assign to `status` in
+zsh — it is readonly):
+
+```sh
+pixi run fix > /tmp/easydiffraction-fix.log 2>&1; fix_exit_code=$?; tail -n 200 /tmp/easydiffraction-fix.log; exit $fix_exit_code
+pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
+pixi run test-structure-check > /tmp/easydiffraction-test-structure-check.log 2>&1; test_structure_check_exit_code=$?; tail -n 200 /tmp/easydiffraction-test-structure-check.log; exit $test_structure_check_exit_code
+pixi run unit-tests > /tmp/easydiffraction-unit-tests.log 2>&1; unit_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-unit-tests.log; exit $unit_tests_exit_code
+pixi run integration-tests > /tmp/easydiffraction-integration-tests.log 2>&1; integration_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-integration-tests.log; exit $integration_tests_exit_code
+pixi run script-tests > /tmp/easydiffraction-script-tests.log 2>&1; script_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-script-tests.log; exit $script_tests_exit_code
+```
+
+Run in order; each must complete clean before the next. Per AGENTS.md
+§Workflow: `pixi run fix` regenerates
+`docs/dev/package-structure/full.md` and `short.md` automatically —
+never edit those by hand. The vendored Three.js assets, the HTML
+template, and the element-data assets are intentional sources (included
+in commits); the built wheel under `dist/`, benchmark CSVs under
+`docs/dev/benchmarking/`, and any tutorial project output under
+`tmp/tutorials/` are verification artefacts — do not stage them. Lint
+complexity thresholds are guardrails: if the scene builder or a renderer
+trips `max-branches` / `max-statements`, refactor (extract helpers,
+parameter objects) rather than raising thresholds or adding `# noqa`.
+
+## Suggested Pull Request
+
+**Title:** `[display] Interactive 3D structure view (crysview)`
+
+**Description:**
+
+Adds an interactive 3D view of the crystal structure a refinement is
+adjusting — the atoms, the unit cell, the bonds, and the thermal (ADP)
+ellipsoids — alongside the existing 1D pattern view.
+
+- **`project.display.structure('lbco')`.** A new display method,
+  parallel to `project.display.pattern(...)`, draws one structure. In a
+  Jupyter notebook it renders an interactive Three.js scene (rotate,
+  zoom, pan, view down a/b/c, toggle features, switch
+  perspective/parallel projection); in a terminal it prints a schematic,
+  colour-coded ASCII view.
+  `project.display.show_structure_options('lbco')` lists what each
+  engine and the current structure can show, with reasons when something
+  is unavailable.
+- **Choose the engine and the styling, once.** `project.view.type`
+  selects `threejs` or `ascii`; `project.style` picks the depiction
+  (`ortep` thermal ellipsoids — the default — or `ball`-and-stick), a
+  standard radius model (covalent by default, or vdw/ionic/atomic), and
+  a colour scheme (Jmol/CPK, VESTA) and ADP probability level — standard
+  models drawn from a built-in element database, not dozens of
+  per-element rows. The view also follows your notebook's dark or light
+  theme automatically. It all persists to `project.cif`, so a reopened
+  project looks the same.
+- **Tune which bonds are drawn, per structure.** `structure.geom` sets
+  the standard bond cut-offs (a minimum distance and a tolerance added
+  to the atoms' bonding radii) for each structure, saved in that
+  structure's own file, so different phases can use different cut-offs.
+- **See a single cell, a margin, or several cells.**
+  `project.view.range` sets a per-axis fractional range (default: the
+  full cell with border atoms drawn); widen it for a margin or multiple
+  cells.
+- **Works offline.** The notebook and standalone-HTML views embed a
+  pinned Three.js so they render with no network, and a structure figure
+  can be embedded in the HTML report under the existing
+  `html_offline = True` switch — just like the Plotly figures.
+
+Full bond/angle geometry tables (`_geom_bond` / `_geom_angle`),
+magnetic-moment arrows, the Qt Quick 3D GUI renderer, and extraction of
+a standalone `crysview` package are intentionally deferred (see the
+ADR's Deferred Work).
+
+**Scope label:** `[display]`.

From 9ae8c80ee8565c394afe691fd99f0fbb54c6842c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 08:42:29 +0200
Subject: [PATCH 003/160] Add crysview viewer and styling enums

---
 .../plans/crysview-structure-visualization.md |  2 +-
 .../display/structure/__init__.py             |  5 +
 .../display/structure/enums.py                | 93 +++++++++++++++++++
 3 files changed, 99 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/display/structure/__init__.py
 create mode 100644 src/easydiffraction/display/structure/enums.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index a5a2f1c9f..57794c744 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -421,7 +421,7 @@ exceptions.
 Ordered foundation-first: the scene model, builder, and ASCII engine
 reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
 
-- [ ] **P1.1 — Add viewer + styling enums**
+- [x] **P1.1 — Add viewer + styling enums**
   - Files: new `src/easydiffraction/display/structure/__init__.py`,
     `src/easydiffraction/display/structure/enums.py`.
   - Define four `(str, Enum)` classes per the Enum-Backed Closed Values
diff --git a/src/easydiffraction/display/structure/__init__.py b/src/easydiffraction/display/structure/__init__.py
new file mode 100644
index 000000000..9cf6ab941
--- /dev/null
+++ b/src/easydiffraction/display/structure/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""crysview structure-visualization subsystem."""
+
+from __future__ import annotations
diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
new file mode 100644
index 000000000..2813beb1a
--- /dev/null
+++ b/src/easydiffraction/display/structure/enums.py
@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Enumerations for the crysview structure view."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ViewerEngineEnum(StrEnum):
+    """Available structure-view renderer engines."""
+
+    ASCII = 'ascii'
+    THREEJS = 'threejs'
+
+    @classmethod
+    def default(cls) -> ViewerEngineEnum:
+        """Select the default engine (rich Three.js, headless-friendly)."""
+        return cls.THREEJS
+
+    def description(self) -> str:
+        """Human-readable description for UI listings."""
+        if self is ViewerEngineEnum.ASCII:
+            return 'Console ASCII schematic structure view'
+        if self is ViewerEngineEnum.THREEJS:
+            return 'Interactive Three.js 3D structure view'
+        return ''
+
+
+class AtomShapeEnum(StrEnum):
+    """How each atom is depicted in the structure view."""
+
+    BALL = 'ball'
+    ORTEP = 'ortep'
+
+    @classmethod
+    def default(cls) -> AtomShapeEnum:
+        """Select the default atom shape (ORTEP thermal surfaces)."""
+        return cls.ORTEP
+
+    def description(self) -> str:
+        """Human-readable description for UI listings."""
+        if self is AtomShapeEnum.BALL:
+            return 'Ball-and-stick radius-model spheres'
+        if self is AtomShapeEnum.ORTEP:
+            return 'ORTEP ADP probability surfaces (ellipsoids)'
+        return ''
+
+
+class RadiusModelEnum(StrEnum):
+    """Standard per-element radius model for atom sphere size."""
+
+    VDW = 'vdw'
+    COVALENT = 'covalent'
+    IONIC = 'ionic'
+    ATOMIC = 'atomic'
+
+    @classmethod
+    def default(cls) -> RadiusModelEnum:
+        """Select the default radius model (covalent; charge-free)."""
+        return cls.COVALENT
+
+    def description(self) -> str:
+        """Human-readable description for UI listings."""
+        if self is RadiusModelEnum.VDW:
+            return 'Van der Waals radii'
+        if self is RadiusModelEnum.COVALENT:
+            return 'Covalent radii'
+        if self is RadiusModelEnum.IONIC:
+            return 'Ionic (Shannon) radii'
+        if self is RadiusModelEnum.ATOMIC:
+            return 'Atomic (empirical) radii'
+        return ''
+
+
+class ColorSchemeEnum(StrEnum):
+    """Standard element colour palette."""
+
+    JMOL = 'jmol'
+    VESTA = 'vesta'
+
+    @classmethod
+    def default(cls) -> ColorSchemeEnum:
+        """Select the default colour scheme (Jmol/CPK)."""
+        return cls.JMOL
+
+    def description(self) -> str:
+        """Human-readable description for UI listings."""
+        if self is ColorSchemeEnum.JMOL:
+            return 'Jmol / CPK colour scheme'
+        if self is ColorSchemeEnum.VESTA:
+            return 'VESTA colour scheme'
+        return ''

From 890122e61e56c94db7dd3ae612d9e2922aca75cf Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 08:46:02 +0200
Subject: [PATCH 004/160] Add renderer-neutral structure scene model

---
 .../plans/crysview-structure-visualization.md |   2 +-
 .../display/structure/scene.py                | 133 ++++++++++++++++++
 2 files changed, 134 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/display/structure/scene.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 57794c744..aed1d78ee 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -443,7 +443,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     later steps land modules (no `__all__`).
   - Commit: `Add crysview viewer and styling enums`.
 
-- [ ] **P1.2 — Add the renderer-neutral scene model**
+- [x] **P1.2 — Add the renderer-neutral scene model**
   - Files: new `src/easydiffraction/display/structure/scene.py`.
   - `@dataclass(frozen=True, slots=True)` primitives in Cartesian space,
     carrying only stdlib / numpy / RGB-tuple types — **no
diff --git a/src/easydiffraction/display/structure/scene.py b/src/easydiffraction/display/structure/scene.py
new file mode 100644
index 000000000..79bbdbe58
--- /dev/null
+++ b/src/easydiffraction/display/structure/scene.py
@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""
+Renderer-neutral structure scene primitives.
+
+A :class:`StructureScene` is a flat set of typed primitives expressed in
+Cartesian space, carrying no rendering-library or easydiffraction-domain
+types. The scene builder produces it; renderers consume it. Keeping this
+module free of domain imports lets the scene model be extracted into a
+standalone ``crysview`` package later.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Plain, serialisable coordinate/colour aliases (no numpy, no domain types).
+Vec3 = tuple[float, float, float]
+Rgb = tuple[int, int, int]
+Mat3 = tuple[Vec3, Vec3, Vec3]
+
+
+@dataclass(frozen=True, slots=True)
+class AtomSphere:
+    """A single-occupancy atom drawn as a coloured sphere."""
+
+    centre: Vec3
+    radius: float
+    colour: Rgb
+    label: str
+
+
+@dataclass(frozen=True, slots=True)
+class OccupancyWedge:
+    """One occupancy share (or vacancy) of a mixed site."""
+
+    fraction: float
+    colour: Rgb
+
+
+@dataclass(frozen=True, slots=True)
+class OccupancyWedgeSphere:
+    """A mixed-occupancy site drawn as a sphere split into wedges."""
+
+    centre: Vec3
+    radius: float
+    wedges: tuple[OccupancyWedge, ...]
+    label: str
+
+
+@dataclass(frozen=True, slots=True)
+class AdpEllipsoid:
+    """An anisotropic ADP probability ellipsoid for one atom."""
+
+    centre: Vec3
+    semi_axes: Vec3
+    orientation: Mat3
+    colour: Rgb
+    label: str
+
+
+@dataclass(frozen=True, slots=True)
+class Bond:
+    """A bond between two atoms, split-coloured at its midpoint."""
+
+    start: Vec3
+    end: Vec3
+    start_colour: Rgb
+    end_colour: Rgb
+
+
+@dataclass(frozen=True, slots=True)
+class MomentArrow:
+    """A magnetic-moment arrow (defined but unused in version 1)."""
+
+    origin: Vec3
+    vector: Vec3
+    colour: Rgb
+
+
+@dataclass(frozen=True, slots=True)
+class CellEdge:
+    """One unit-cell edge as a Cartesian segment."""
+
+    start: Vec3
+    end: Vec3
+
+
+@dataclass(frozen=True, slots=True)
+class CellEdges:
+    """The twelve unit-cell edges as Cartesian segments."""
+
+    edges: tuple[CellEdge, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class AxisArrow:
+    """One crystallographic axis arrow (a, b, or c)."""
+
+    vector: Vec3
+    colour: Rgb
+    letter: str
+
+
+@dataclass(frozen=True, slots=True)
+class AxisTriad:
+    """The a/b/c axis triad drawn from the cell origin."""
+
+    origin: Vec3
+    axes: tuple[AxisArrow, AxisArrow, AxisArrow]
+
+
+@dataclass(frozen=True, slots=True)
+class TextLabel:
+    """A text label anchored at a Cartesian point."""
+
+    anchor: Vec3
+    text: str
+
+
+@dataclass(frozen=True, slots=True)
+class StructureScene:
+    """Renderer-neutral Cartesian primitives for one structure."""
+
+    cell_basis: Mat3
+    atoms: tuple[AtomSphere, ...] = ()
+    occupancy_spheres: tuple[OccupancyWedgeSphere, ...] = ()
+    ellipsoids: tuple[AdpEllipsoid, ...] = ()
+    bonds: tuple[Bond, ...] = ()
+    moments: tuple[MomentArrow, ...] = ()
+    cell_edges: CellEdges | None = None
+    axes: AxisTriad | None = None
+    labels: tuple[TextLabel, ...] = ()

From 17ed15fcd669182ef72acdbd51c76a78329e0090 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 08:49:43 +0200
Subject: [PATCH 005/160] Add orthogonalization and ADP eigendecomposition
 helpers

---
 .../plans/crysview-structure-visualization.md |   2 +-
 .../crystallography/crystallography.py        | 129 ++++++++++++++++++
 2 files changed, 130 insertions(+), 1 deletion(-)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index aed1d78ee..a24f6f8d4 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -469,7 +469,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Numpy-style docstrings ≤72-char summaries on every public class.
   - Commit: `Add renderer-neutral structure scene model`.
 
-- [ ] **P1.3 — Add crystallographic geometry helpers**
+- [x] **P1.3 — Add crystallographic geometry helpers**
   - Files: existing
     `src/easydiffraction/crystallography/crystallography.py`,
     `src/easydiffraction/crystallography/__init__.py`.
diff --git a/src/easydiffraction/crystallography/crystallography.py b/src/easydiffraction/crystallography/crystallography.py
index 4bc0dba5c..0e694900c 100644
--- a/src/easydiffraction/crystallography/crystallography.py
+++ b/src/easydiffraction/crystallography/crystallography.py
@@ -649,3 +649,132 @@ def apply_atom_site_aniso_symmetry_constraints(
     atom_site_aniso.update(dict(zip(keys, param_i, strict=False)))
 
     return atom_site_aniso, ref_i
+
+
+def orthogonalization_matrix(
+    a: float,
+    b: float,
+    c: float,
+    alpha: float,
+    beta: float,
+    gamma: float,
+) -> np.ndarray:
+    """
+    Build the fractional-to-Cartesian orthogonalization matrix.
+
+    Uses the standard crystallographic convention with the Cartesian x
+    axis along **a** and **b** in the x-y plane (the IUCr / Busing-Levy
+    setting). Edge lengths are in angstrom and angles in degrees.
+
+    Parameters
+    ----------
+    a, b, c : float
+        Unit-cell edge lengths (angstrom).
+    alpha, beta, gamma : float
+        Unit-cell angles (degrees).
+
+    Returns
+    -------
+    np.ndarray
+        The ``(3, 3)`` matrix ``M`` with ``r_cartesian = M @ r_fractional``.
+    """
+    al, be, ga = np.radians([alpha, beta, gamma])
+    cos_al, cos_be, cos_ga = np.cos([al, be, ga])
+    sin_ga = np.sin(ga)
+    volume_factor = np.sqrt(
+        1.0
+        - cos_al**2
+        - cos_be**2
+        - cos_ga**2
+        + 2.0 * cos_al * cos_be * cos_ga
+    )
+    return np.array(
+        [
+            [a, b * cos_ga, c * cos_be],
+            [0.0, b * sin_ga, c * (cos_al - cos_be * cos_ga) / sin_ga],
+            [0.0, 0.0, c * volume_factor / sin_ga],
+        ]
+    )
+
+
+def fractional_to_cartesian(frac: object, matrix: np.ndarray) -> np.ndarray:
+    """
+    Convert fractional coordinates to Cartesian using a cell matrix.
+
+    Parameters
+    ----------
+    frac : array-like
+        A single ``(3,)`` fractional vector or an ``(n, 3)`` stack.
+    matrix : np.ndarray
+        The ``(3, 3)`` orthogonalization matrix from
+        :func:`orthogonalization_matrix`.
+
+    Returns
+    -------
+    np.ndarray
+        Cartesian coordinates with the same shape as *frac*.
+    """
+    return np.asarray(frac, dtype=float) @ np.asarray(matrix, dtype=float).T
+
+
+def adp_principal_axes(tensor: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Diagonalise a Cartesian ADP tensor into principal axes.
+
+    Expects a symmetric ``(3, 3)`` **U-type** (mean-square displacement)
+    tensor already in the Cartesian frame; conversion from the crystal
+    frame and from B to U (``U = B / (8 pi**2)``) is the caller's
+    responsibility. Returned semi-axes are RMS displacements
+    (sqrt-eigenvalue); scaling to a probability level is done by the
+    caller.
+
+    Parameters
+    ----------
+    tensor : np.ndarray
+        Symmetric ``(3, 3)`` Cartesian U tensor.
+
+    Returns
+    -------
+    tuple[np.ndarray, np.ndarray]
+        semi_axes : ``(3,)`` RMS principal semi-axis lengths. orientation
+        : ``(3, 3)`` matrix whose columns are the principal directions.
+    """
+    eigenvalues, eigenvectors = np.linalg.eigh(np.asarray(tensor, dtype=float))
+    semi_axes = np.sqrt(np.clip(eigenvalues, 0.0, None))
+    return semi_axes, eigenvectors
+
+
+def symmetry_operators(
+    name_hm: str,
+    coord_code: str | None = None,
+) -> list[tuple[np.ndarray, np.ndarray]]:
+    """
+    Return general-position symmetry operators for a space group.
+
+    Thin public wrapper over the general-position lookup, resolving the
+    International Tables number from the Hermann-Mauguin symbol. Falls
+    back to the identity operator (so the asymmetric unit is still drawn)
+    when the space group cannot be resolved.
+
+    Parameters
+    ----------
+    name_hm : str
+        Hermann-Mauguin symbol of the space group.
+    coord_code : str | None
+        IT coordinate system code, when one applies.
+
+    Returns
+    -------
+    list[tuple[np.ndarray, np.ndarray]]
+        ``(rotation, translation)`` pairs; rotation a ``(3, 3)`` integer
+        array, translation a ``(3,)`` fractional vector.
+    """
+    identity = [(np.eye(3, dtype=int), np.zeros(3))]
+    it_number = get_it_number_by_name_hm_short(name_hm)
+    if it_number is None:
+        log.warning(f"Unknown space group '{name_hm}'; showing asymmetric unit only")
+        return identity
+    ops = _get_general_position_ops(it_number, coord_code)
+    if ops is None:
+        return identity
+    return ops

From 777f0fc37d1c152559583dcd766da9c91b8c8e92 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:02:33 +0200
Subject: [PATCH 006/160] Add extended element database for radii and colours

---
 .../plans/crysview-structure-visualization.md |  26 +-
 .../display/structure/assets/LICENSES.md      |  58 ++++
 .../display/structure/assets/__init__.py      |   5 +
 .../display/structure/assets/colors.py        |  67 +++++
 .../display/structure/assets/elements.py      | 249 ++++++++++++++++++
 .../display/structure/assets/radii.py         |  44 ++++
 6 files changed, 438 insertions(+), 11 deletions(-)
 create mode 100644 src/easydiffraction/display/structure/assets/LICENSES.md
 create mode 100644 src/easydiffraction/display/structure/assets/__init__.py
 create mode 100644 src/easydiffraction/display/structure/assets/colors.py
 create mode 100644 src/easydiffraction/display/structure/assets/elements.py
 create mode 100644 src/easydiffraction/display/structure/assets/radii.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index a24f6f8d4..fbfd3a76e 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -491,7 +491,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Export any newly public helpers from `crystallography/__init__.py`.
   - Commit: `Add orthogonalization and ADP eigendecomposition helpers`.
 
-- [ ] **P1.4 — Build the extended element database (radii + colours)**
+- [x] **P1.4 — Build the extended element database (radii + colours)**
   - Files: new
     `src/easydiffraction/display/structure/assets/__init__.py`,
     `assets/elements.py` (or a vendored data file + loader),
@@ -528,17 +528,21 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - **Shannon representative-radius policy (deterministic,
     reproducible).** The atom-site model carries only an element symbol,
     so pick exactly one Shannon row per element by a fixed rule:
-    **charge** = the element's main oxidation state from pymatgen
+    **charge** = walk the element's oxidation states from pymatgen
     `dev_scripts/periodic_table_resources/oxidation_states.yaml` (same
-    repo/raw-URL base, verified reachable HTTP 200; take its first
-    listed positive state, falling back to the first listed state);
-    **coordination** = `VI` (else the lowest coordination present if
-    `VI` is absent); **spin** = high-spin where a spin state is listed;
-    take the `Ionic Radius` column. If no Shannon row matches the chosen
-    charge, fall back to that element's covalent radius (the
-    `substituted` flag). Record the chosen `(charge, coordination)` per
-    element in `LICENSES.md`. Ionic is not the default model, so this
-    only applies when the user selects `radius_model = 'ionic'`.
+    repo/raw-URL base, verified reachable HTTP 200) in listed order,
+    keeping those that have a Shannon entry, then any remaining Shannon
+    charges (lowest `|charge|` first) — this keeps anions such as O²⁻ /
+    F⁻, not just cations; **coordination** = `VI` (else the lowest
+    coordination present); **spin** = high-spin where a spin state is
+    listed; take the `Ionic Radius` column, skipping non-physical
+    (non-positive) entries such as the H⁺ value. The first charge that
+    yields a positive radius wins; if none does, fall back to the
+    covalent radius (the `substituted` flag). Record the chosen
+    `(charge, coordination)` per element in `LICENSES.md`. Ionic is not
+    the default model, so this only applies when the user selects
+    `radius_model = 'ionic'`. (Result: 93/118 elements carry a Shannon
+    radius; the rest fall back to covalent.)
   - `radii.py`: `radius_for(element, model) -> tuple[float, bool]`
     lookup returning the radius and a `substituted` flag; a miss for the
     selected model (e.g. an element with no ionic entry) falls back to
diff --git a/src/easydiffraction/display/structure/assets/LICENSES.md b/src/easydiffraction/display/structure/assets/LICENSES.md
new file mode 100644
index 000000000..b63af1830
--- /dev/null
+++ b/src/easydiffraction/display/structure/assets/LICENSES.md
@@ -0,0 +1,58 @@
+# Element data provenance
+
+`elements.py` is generated from the sources below. All are reused under
+permissive licences; the underlying values are scientific data.
+
+## Sources
+
+| Data | Source | Licence |
+| --- | --- | --- |
+| Jmol/CPK colours, covalent radii, van der Waals radii | EasyDiffractionBeta `easyDiffractionApp/Logic/Tables.py` `PERIODIC_TABLE` (github.com/easyscience/EasyDiffractionBeta) | BSD-3-Clause |
+| Ionic (Shannon) radii | pymatgen `dev_scripts/periodic_table_resources/Shannon_Radii.csv` | MIT |
+| Atomic radii | pymatgen `dev_scripts/periodic_table_resources/radii.csv` (`Atomic radius`) | MIT |
+| VESTA colours | pymatgen `src/pymatgen/vis/ElementColorSchemes.yaml` (`VESTA`) | MIT |
+| Oxidation states (for Shannon selection) | pymatgen `dev_scripts/periodic_table_resources/oxidation_states.yaml` | MIT |
+
+Primary scientific references:
+
+- R. D. Shannon, *Revised effective ionic radii and systematic studies of
+  interatomic distances in halides and chalcogenides*, Acta Cryst. (1976)
+  **A32**, 751.
+- K. Momma and F. Izumi, *VESTA 3*, J. Appl. Cryst. (2011) **44**, 1272
+  (element colour palette).
+
+pymatgen raw files were fetched from
+`https://raw.githubusercontent.com/materialsproject/pymatgen/master/`.
+
+## Shannon representative-radius selection
+
+The atom-site model carries only an element symbol, so one representative
+Shannon row is chosen per element by a fixed, reproducible rule:
+
+1. consider the element's oxidation states from `oxidation_states.yaml`, in
+   listed order, keeping those that have a Shannon entry; then any
+   remaining Shannon charges, lowest `|charge|` first;
+2. for the first such charge, prefer coordination `VI`, else the lowest
+   coordination present; prefer high-spin where a spin state is listed;
+3. take the `Ionic Radius` column; skip non-physical entries (e.g. the
+   negative H+ value) and fall back to the covalent radius.
+
+Elements with no usable Shannon entry (noble gases and a few others) carry
+`ionic = None` and fall back to the covalent radius at lookup time.
+
+## Chosen (charge / coordination) per element
+
+```
+Li:+1/VI  Be:+2/VI  B:+3/VI  C:+4/VI  N:-3/IV  O:-2/VI  F:-1/VI  Na:+1/VI
+Mg:+2/VI  Al:+3/VI  Si:+4/VI  P:+3/VI  S:-2/VI  Cl:-1/VI  K:+1/VI  Ca:+2/VI
+Sc:+3/VI  Ti:+2/VI  V:+2/VI  Cr:+2/VI  Mn:+2/VI  Fe:+2/VI  Co:+2/VI  Ni:+2/VI
+Cu:+1/VI  Zn:+2/VI  Ga:+3/VI  Ge:+2/VI  As:+3/VI  Se:-2/VI  Br:-1/VI  Rb:+1/VI
+Sr:+2/VI  Y:+3/VI  Zr:+4/VI  Nb:+3/VI  Mo:+3/VI  Tc:+4/VI  Ru:+3/VI  Rh:+3/VI
+Pd:+2/VI  Ag:+1/VI  Cd:+2/VI  In:+3/VI  Sn:+4/VI  Sb:+3/VI  Te:-2/VI  I:-1/VI
+Xe:+8/VI  Cs:+1/VI  Ba:+2/VI  La:+3/VI  Ce:+3/VI  Pr:+3/VI  Nd:+2/VIII
+Pm:+3/VI  Sm:+2/VII  Eu:+2/VI  Gd:+3/VI  Tb:+3/VI  Dy:+2/VI  Ho:+3/VI  Er:+3/VI
+Tm:+2/VI  Yb:+2/VI  Lu:+3/VI  Hf:+4/VI  Ta:+3/VI  W:+4/VI  Re:+4/VI  Os:+4/VI
+Ir:+3/VI  Pt:+2/VI  Au:+1/VI  Hg:+1/VI  Tl:+1/VI  Pb:+2/VI  Bi:+3/VI  Po:+4/VI
+At:+7/VI  Fr:+1/VI  Ra:+2/VIII  Ac:+3/VI  Th:+4/VI  Pa:+3/VI  U:+3/VI  Np:+3/VI
+Pu:+3/VI  Am:+2/VII  Cm:+3/VI  Bk:+3/VI  Cf:+3/VI  No:+2/VI
+```
diff --git a/src/easydiffraction/display/structure/assets/__init__.py b/src/easydiffraction/display/structure/assets/__init__.py
new file mode 100644
index 000000000..556ff93ec
--- /dev/null
+++ b/src/easydiffraction/display/structure/assets/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Bundled element data and lookups for the structure view."""
+
+from __future__ import annotations
diff --git a/src/easydiffraction/display/structure/assets/colors.py b/src/easydiffraction/display/structure/assets/colors.py
new file mode 100644
index 000000000..3e71aee3f
--- /dev/null
+++ b/src/easydiffraction/display/structure/assets/colors.py
@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Per-element colours, axis colours, and theme-dependent canvas colours."""
+
+from __future__ import annotations
+
+from easydiffraction.display.structure.assets.elements import ELEMENT_COLORS
+
+Rgb = tuple[int, int, int]
+
+# Fallback element colour (pale pink) for an unknown element.
+DEFAULT_COLOR: Rgb = (255, 192, 203)
+
+# Crystallographic axis colours (a=red, b=green, c=blue), as in VESTA.
+AXIS_COLORS: dict[str, Rgb] = {'a': (220, 40, 40), 'b': (40, 180, 40), 'c': (40, 80, 220)}
+
+# Neutral wedge colour for the vacant fraction of a mixed-occupancy site.
+VACANCY_COLOR: Rgb = (210, 210, 210)
+
+# Canvas + annotation colours selected by the detected light/dark theme.
+LIGHT_THEME: dict[str, Rgb] = {'background': (255, 255, 255), 'foreground': (33, 33, 33)}
+DARK_THEME: dict[str, Rgb] = {'background': (20, 20, 24), 'foreground': (235, 235, 235)}
+
+
+def color_for(element: str, scheme: str) -> Rgb:
+    """
+    Return the RGB colour for an element under a colour scheme.
+
+    Falls back to the element's Jmol colour when the scheme has no entry,
+    and to :data:`DEFAULT_COLOR` when the element is unknown.
+
+    Parameters
+    ----------
+    element : str
+        Bare element symbol, e.g. ``'Fe'``.
+    scheme : str
+        One of ``'jmol'``, ``'vesta'``.
+
+    Returns
+    -------
+    tuple[int, int, int]
+        RGB triple in the 0-255 range.
+    """
+    entry = ELEMENT_COLORS.get(element)
+    if entry is None:
+        return DEFAULT_COLOR
+    value = entry.get(scheme)
+    if value is not None:
+        return value
+    return entry.get('jmol') or DEFAULT_COLOR
+
+
+def theme_colors(dark: bool) -> dict[str, Rgb]:
+    """
+    Return canvas/annotation colours for the detected theme.
+
+    Parameters
+    ----------
+    dark : bool
+        ``True`` for a dark host theme, ``False`` for light.
+
+    Returns
+    -------
+    dict[str, tuple[int, int, int]]
+        Mapping with ``'background'`` and ``'foreground'`` colours.
+    """
+    return DARK_THEME if dark else LIGHT_THEME
diff --git a/src/easydiffraction/display/structure/assets/elements.py b/src/easydiffraction/display/structure/assets/elements.py
new file mode 100644
index 000000000..92b32601c
--- /dev/null
+++ b/src/easydiffraction/display/structure/assets/elements.py
@@ -0,0 +1,249 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Bundled per-element radii and colour palettes (generated; see LICENSES.md)."""
+
+from __future__ import annotations
+
+# Radii in angstrom; None where the model has no value for the element.
+ELEMENT_RADII: dict[str, dict[str, float | None]] = {
+    'H': {'vdw': 1.1, 'covalent': 0.31, 'ionic': None, 'atomic': 0.25},
+    'He': {'vdw': 1.4, 'covalent': 0.28, 'ionic': None, 'atomic': None},
+    'Li': {'vdw': 1.82, 'covalent': 1.28, 'ionic': 0.76, 'atomic': 1.45},
+    'Be': {'vdw': 1.53, 'covalent': 0.96, 'ionic': 0.45, 'atomic': 1.05},
+    'B': {'vdw': 1.92, 'covalent': 0.84, 'ionic': 0.27, 'atomic': 0.85},
+    'C': {'vdw': 1.7, 'covalent': 0.76, 'ionic': 0.16, 'atomic': 0.7},
+    'N': {'vdw': 1.55, 'covalent': 0.71, 'ionic': 1.46, 'atomic': 0.65},
+    'O': {'vdw': 1.52, 'covalent': 0.66, 'ionic': 1.4, 'atomic': 0.6},
+    'F': {'vdw': 1.47, 'covalent': 0.57, 'ionic': 1.33, 'atomic': 0.5},
+    'Ne': {'vdw': 1.54, 'covalent': 0.58, 'ionic': None, 'atomic': None},
+    'Na': {'vdw': 2.27, 'covalent': 1.66, 'ionic': 1.02, 'atomic': 1.8},
+    'Mg': {'vdw': 1.73, 'covalent': 1.41, 'ionic': 0.72, 'atomic': 1.5},
+    'Al': {'vdw': 2.11, 'covalent': 1.21, 'ionic': 0.535, 'atomic': 1.25},
+    'Si': {'vdw': 2.03, 'covalent': 1.11, 'ionic': 0.4, 'atomic': 1.1},
+    'P': {'vdw': 1.8, 'covalent': 1.07, 'ionic': 0.44, 'atomic': 1.0},
+    'S': {'vdw': 1.8, 'covalent': 1.05, 'ionic': 1.84, 'atomic': 1.0},
+    'Cl': {'vdw': 1.75, 'covalent': 1.02, 'ionic': 1.81, 'atomic': 1.0},
+    'Ar': {'vdw': 1.88, 'covalent': 1.06, 'ionic': None, 'atomic': 0.71},
+    'K': {'vdw': 2.75, 'covalent': 2.03, 'ionic': 1.38, 'atomic': 2.2},
+    'Ca': {'vdw': 2.31, 'covalent': 1.76, 'ionic': 1.0, 'atomic': 1.8},
+    'Sc': {'vdw': 2.11, 'covalent': 1.7, 'ionic': 0.745, 'atomic': 1.6},
+    'Ti': {'vdw': 2.0, 'covalent': 1.6, 'ionic': 0.86, 'atomic': 1.4},
+    'V': {'vdw': 1.92, 'covalent': 1.53, 'ionic': 0.79, 'atomic': 1.35},
+    'Cr': {'vdw': 1.85, 'covalent': 1.39, 'ionic': 0.8, 'atomic': 1.4},
+    'Mn': {'vdw': 1.79, 'covalent': 1.39, 'ionic': 0.83, 'atomic': 1.4},
+    'Fe': {'vdw': 1.72, 'covalent': 1.32, 'ionic': 0.78, 'atomic': 1.4},
+    'Co': {'vdw': 1.67, 'covalent': 1.26, 'ionic': 0.745, 'atomic': 1.35},
+    'Ni': {'vdw': 1.62, 'covalent': 1.24, 'ionic': 0.69, 'atomic': 1.35},
+    'Cu': {'vdw': 1.57, 'covalent': 1.32, 'ionic': 0.77, 'atomic': 1.35},
+    'Zn': {'vdw': 1.53, 'covalent': 1.22, 'ionic': 0.74, 'atomic': 1.35},
+    'Ga': {'vdw': 1.87, 'covalent': 1.22, 'ionic': 0.62, 'atomic': 1.3},
+    'Ge': {'vdw': 2.11, 'covalent': 1.2, 'ionic': 0.73, 'atomic': 1.25},
+    'As': {'vdw': 1.85, 'covalent': 1.19, 'ionic': 0.58, 'atomic': 1.15},
+    'Se': {'vdw': 1.9, 'covalent': 1.2, 'ionic': 1.98, 'atomic': 1.15},
+    'Br': {'vdw': 1.85, 'covalent': 1.2, 'ionic': 1.96, 'atomic': 1.15},
+    'Kr': {'vdw': 2.02, 'covalent': 1.16, 'ionic': None, 'atomic': None},
+    'Rb': {'vdw': 3.03, 'covalent': 2.2, 'ionic': 1.52, 'atomic': 2.35},
+    'Sr': {'vdw': 2.49, 'covalent': 1.95, 'ionic': 1.18, 'atomic': 2.0},
+    'Y': {'vdw': 2.27, 'covalent': 1.9, 'ionic': 0.9, 'atomic': 1.8},
+    'Zr': {'vdw': 2.16, 'covalent': 1.75, 'ionic': 0.72, 'atomic': 1.55},
+    'Nb': {'vdw': 2.08, 'covalent': 1.64, 'ionic': 0.72, 'atomic': 1.45},
+    'Mo': {'vdw': 2.01, 'covalent': 1.54, 'ionic': 0.69, 'atomic': 1.45},
+    'Tc': {'vdw': 1.95, 'covalent': 1.47, 'ionic': 0.645, 'atomic': 1.35},
+    'Ru': {'vdw': 1.89, 'covalent': 1.46, 'ionic': 0.68, 'atomic': 1.3},
+    'Rh': {'vdw': 1.83, 'covalent': 1.42, 'ionic': 0.665, 'atomic': 1.35},
+    'Pd': {'vdw': 1.79, 'covalent': 1.39, 'ionic': 0.86, 'atomic': 1.4},
+    'Ag': {'vdw': 1.75, 'covalent': 1.45, 'ionic': 1.15, 'atomic': 1.6},
+    'Cd': {'vdw': 1.71, 'covalent': 1.44, 'ionic': 0.95, 'atomic': 1.55},
+    'In': {'vdw': 1.66, 'covalent': 1.42, 'ionic': 0.8, 'atomic': 1.55},
+    'Sn': {'vdw': 1.62, 'covalent': 1.39, 'ionic': 0.69, 'atomic': 1.45},
+    'Sb': {'vdw': 1.59, 'covalent': 1.39, 'ionic': 0.76, 'atomic': 1.45},
+    'Te': {'vdw': 1.57, 'covalent': 1.38, 'ionic': 2.21, 'atomic': 1.4},
+    'I': {'vdw': 1.56, 'covalent': 1.39, 'ionic': 2.2, 'atomic': 1.4},
+    'Xe': {'vdw': 2.16, 'covalent': 1.4, 'ionic': 0.48, 'atomic': None},
+    'Cs': {'vdw': 3.43, 'covalent': 2.44, 'ionic': 1.67, 'atomic': 2.6},
+    'Ba': {'vdw': 2.68, 'covalent': 2.15, 'ionic': 1.35, 'atomic': 2.15},
+    'La': {'vdw': 2.57, 'covalent': 2.07, 'ionic': 1.032, 'atomic': 1.95},
+    'Ce': {'vdw': 2.58, 'covalent': 2.04, 'ionic': 1.01, 'atomic': 1.85},
+    'Pr': {'vdw': 2.47, 'covalent': 2.03, 'ionic': 0.99, 'atomic': 1.85},
+    'Nd': {'vdw': 2.49, 'covalent': 2.01, 'ionic': 1.29, 'atomic': 1.85},
+    'Pm': {'vdw': 2.43, 'covalent': 1.99, 'ionic': 0.97, 'atomic': 1.85},
+    'Sm': {'vdw': 2.46, 'covalent': 1.98, 'ionic': 1.22, 'atomic': 1.85},
+    'Eu': {'vdw': 2.4, 'covalent': 1.98, 'ionic': 1.17, 'atomic': 1.85},
+    'Gd': {'vdw': 2.38, 'covalent': 1.96, 'ionic': 0.938, 'atomic': 1.8},
+    'Tb': {'vdw': 2.33, 'covalent': 1.94, 'ionic': 0.923, 'atomic': 1.75},
+    'Dy': {'vdw': 2.31, 'covalent': 1.92, 'ionic': 1.07, 'atomic': 1.75},
+    'Ho': {'vdw': 2.33, 'covalent': 1.92, 'ionic': 0.901, 'atomic': 1.75},
+    'Er': {'vdw': 2.31, 'covalent': 1.89, 'ionic': 0.89, 'atomic': 1.75},
+    'Tm': {'vdw': 2.33, 'covalent': 1.9, 'ionic': 1.03, 'atomic': 1.75},
+    'Yb': {'vdw': 2.32, 'covalent': 1.87, 'ionic': 1.02, 'atomic': 1.75},
+    'Lu': {'vdw': 2.25, 'covalent': 1.87, 'ionic': 0.861, 'atomic': 1.75},
+    'Hf': {'vdw': 2.16, 'covalent': 1.75, 'ionic': 0.71, 'atomic': 1.55},
+    'Ta': {'vdw': 2.09, 'covalent': 1.7, 'ionic': 0.72, 'atomic': 1.45},
+    'W': {'vdw': 2.02, 'covalent': 1.62, 'ionic': 0.66, 'atomic': 1.35},
+    'Re': {'vdw': 1.96, 'covalent': 1.51, 'ionic': 0.63, 'atomic': 1.35},
+    'Os': {'vdw': 1.9, 'covalent': 1.44, 'ionic': 0.63, 'atomic': 1.3},
+    'Ir': {'vdw': 1.83, 'covalent': 1.41, 'ionic': 0.68, 'atomic': 1.35},
+    'Pt': {'vdw': 1.79, 'covalent': 1.36, 'ionic': 0.8, 'atomic': 1.35},
+    'Au': {'vdw': 1.75, 'covalent': 1.36, 'ionic': 1.37, 'atomic': 1.35},
+    'Hg': {'vdw': 1.71, 'covalent': 1.32, 'ionic': 1.19, 'atomic': 1.5},
+    'Tl': {'vdw': 1.56, 'covalent': 1.45, 'ionic': 1.5, 'atomic': 1.9},
+    'Pb': {'vdw': 1.54, 'covalent': 1.46, 'ionic': 1.19, 'atomic': 1.8},
+    'Bi': {'vdw': 1.51, 'covalent': 1.48, 'ionic': 1.03, 'atomic': 1.6},
+    'Po': {'vdw': 1.5, 'covalent': 1.4, 'ionic': 0.94, 'atomic': 1.9},
+    'At': {'vdw': 1.62, 'covalent': 1.5, 'ionic': 0.62, 'atomic': None},
+    'Rn': {'vdw': 2.2, 'covalent': 1.5, 'ionic': None, 'atomic': None},
+    'Fr': {'vdw': 3.48, 'covalent': 2.6, 'ionic': 1.8, 'atomic': None},
+    'Ra': {'vdw': 2.83, 'covalent': 2.21, 'ionic': 1.48, 'atomic': 2.15},
+    'Ac': {'vdw': 2.835, 'covalent': 2.15, 'ionic': 1.12, 'atomic': 1.95},
+    'Th': {'vdw': 2.81, 'covalent': 2.06, 'ionic': 0.94, 'atomic': 1.8},
+    'Pa': {'vdw': 2.82, 'covalent': 2, 'ionic': 1.04, 'atomic': 1.8},
+    'U': {'vdw': 2.82, 'covalent': 1.96, 'ionic': 1.025, 'atomic': 1.75},
+    'Np': {'vdw': 2.81, 'covalent': 1.9, 'ionic': 1.01, 'atomic': 1.75},
+    'Pu': {'vdw': 2.84, 'covalent': 1.87, 'ionic': 1.0, 'atomic': 1.75},
+    'Am': {'vdw': 2.83, 'covalent': 1.8, 'ionic': 1.21, 'atomic': 1.75},
+    'Cm': {'vdw': 2.8, 'covalent': 1.69, 'ionic': 0.97, 'atomic': None},
+    'Bk': {'vdw': 2.8, 'covalent': 1.69, 'ionic': 0.96, 'atomic': None},
+    'Cf': {'vdw': 2.8, 'covalent': 1.68, 'ionic': 0.95, 'atomic': None},
+    'Es': {'vdw': 2.8, 'covalent': 1.65, 'ionic': None, 'atomic': None},
+    'Fm': {'vdw': 2.8, 'covalent': 1.67, 'ionic': None, 'atomic': None},
+    'Md': {'vdw': 2.8, 'covalent': 1.73, 'ionic': None, 'atomic': None},
+    'No': {'vdw': 2.8, 'covalent': 1.76, 'ionic': 1.1, 'atomic': None},
+    'Lr': {'vdw': 2.7, 'covalent': 1.61, 'ionic': None, 'atomic': None},
+    'Rf': {'vdw': 2.5, 'covalent': 1.57, 'ionic': None, 'atomic': None},
+    'Db': {'vdw': 2.4, 'covalent': 1.49, 'ionic': None, 'atomic': None},
+    'Sg': {'vdw': 2.3, 'covalent': 1.43, 'ionic': None, 'atomic': None},
+    'Bh': {'vdw': 2.25, 'covalent': 1.41, 'ionic': None, 'atomic': None},
+    'Hs': {'vdw': 2.2, 'covalent': 1.34, 'ionic': None, 'atomic': None},
+    'Mt': {'vdw': 2.1, 'covalent': 1.29, 'ionic': None, 'atomic': None},
+    'Ds': {'vdw': 2.1, 'covalent': 1.28, 'ionic': None, 'atomic': None},
+    'Rg': {'vdw': 2.05, 'covalent': 1.21, 'ionic': None, 'atomic': None},
+    'Cn': {'vdw': 2, 'covalent': 1.22, 'ionic': None, 'atomic': None},
+    'Nh': {'vdw': 2, 'covalent': 1.36, 'ionic': None, 'atomic': None},
+    'Fl': {'vdw': 2, 'covalent': 1.42, 'ionic': None, 'atomic': None},
+    'Mc': {'vdw': 2, 'covalent': 1.47, 'ionic': None, 'atomic': None},
+    'Lv': {'vdw': 2, 'covalent': 1.6, 'ionic': None, 'atomic': None},
+    'Ts': {'vdw': 2, 'covalent': 1.6, 'ionic': None, 'atomic': None},
+    'Og': {'vdw': 2, 'covalent': 1.6, 'ionic': None, 'atomic': None},
+}
+
+# RGB 0-255; vesta is None where VESTA lacks an entry (falls back to jmol).
+ELEMENT_COLORS: dict[str, dict[str, tuple[int, int, int] | None]] = {
+    'H': {'jmol': (255, 255, 255), 'vesta': (255, 204, 204)},
+    'He': {'jmol': (217, 255, 255), 'vesta': (252, 232, 206)},
+    'Li': {'jmol': (204, 128, 255), 'vesta': (134, 223, 115)},
+    'Be': {'jmol': (194, 255, 0), 'vesta': (94, 215, 123)},
+    'B': {'jmol': (255, 181, 181), 'vesta': (31, 162, 15)},
+    'C': {'jmol': (144, 144, 144), 'vesta': (76, 76, 76)},
+    'N': {'jmol': (48, 80, 248), 'vesta': (176, 185, 230)},
+    'O': {'jmol': (255, 13, 13), 'vesta': (254, 3, 0)},
+    'F': {'jmol': (144, 224, 80), 'vesta': (176, 185, 230)},
+    'Ne': {'jmol': (179, 227, 245), 'vesta': (254, 55, 181)},
+    'Na': {'jmol': (171, 92, 242), 'vesta': (249, 220, 60)},
+    'Mg': {'jmol': (138, 255, 0), 'vesta': (251, 123, 21)},
+    'Al': {'jmol': (191, 166, 166), 'vesta': (129, 178, 214)},
+    'Si': {'jmol': (240, 200, 160), 'vesta': (27, 59, 250)},
+    'P': {'jmol': (255, 128, 0), 'vesta': (192, 156, 194)},
+    'S': {'jmol': (255, 255, 48), 'vesta': (255, 250, 0)},
+    'Cl': {'jmol': (31, 240, 31), 'vesta': (49, 252, 2)},
+    'Ar': {'jmol': (128, 209, 227), 'vesta': (207, 254, 196)},
+    'K': {'jmol': (143, 64, 212), 'vesta': (161, 33, 246)},
+    'Ca': {'jmol': (61, 255, 0), 'vesta': (90, 150, 189)},
+    'Sc': {'jmol': (230, 230, 230), 'vesta': (181, 99, 171)},
+    'Ti': {'jmol': (191, 194, 199), 'vesta': (120, 202, 255)},
+    'V': {'jmol': (166, 166, 171), 'vesta': (229, 25, 0)},
+    'Cr': {'jmol': (138, 153, 199), 'vesta': (0, 0, 158)},
+    'Mn': {'jmol': (156, 122, 199), 'vesta': (167, 8, 157)},
+    'Fe': {'jmol': (224, 102, 51), 'vesta': (181, 113, 0)},
+    'Co': {'jmol': (240, 144, 160), 'vesta': (0, 0, 175)},
+    'Ni': {'jmol': (80, 208, 80), 'vesta': (183, 187, 189)},
+    'Cu': {'jmol': (200, 128, 51), 'vesta': (34, 71, 220)},
+    'Zn': {'jmol': (125, 128, 176), 'vesta': (143, 143, 129)},
+    'Ga': {'jmol': (194, 143, 143), 'vesta': (158, 227, 115)},
+    'Ge': {'jmol': (102, 143, 143), 'vesta': (126, 110, 166)},
+    'As': {'jmol': (189, 128, 227), 'vesta': (116, 208, 87)},
+    'Se': {'jmol': (255, 161, 0), 'vesta': (154, 239, 15)},
+    'Br': {'jmol': (166, 41, 41), 'vesta': (126, 49, 2)},
+    'Kr': {'jmol': (92, 184, 209), 'vesta': (250, 193, 243)},
+    'Rb': {'jmol': (112, 46, 176), 'vesta': (112, 46, 176)},
+    'Sr': {'jmol': (0, 255, 0), 'vesta': (0, 255, 0)},
+    'Y': {'jmol': (148, 255, 255), 'vesta': (148, 255, 255)},
+    'Zr': {'jmol': (148, 224, 224), 'vesta': (0, 255, 0)},
+    'Nb': {'jmol': (115, 194, 201), 'vesta': (115, 194, 201)},
+    'Mo': {'jmol': (84, 181, 181), 'vesta': (84, 181, 181)},
+    'Tc': {'jmol': (59, 158, 158), 'vesta': (59, 158, 158)},
+    'Ru': {'jmol': (36, 143, 143), 'vesta': (36, 143, 143)},
+    'Rh': {'jmol': (10, 125, 140), 'vesta': (10, 125, 140)},
+    'Pd': {'jmol': (0, 105, 133), 'vesta': (0, 105, 133)},
+    'Ag': {'jmol': (192, 192, 192), 'vesta': (192, 192, 192)},
+    'Cd': {'jmol': (255, 217, 143), 'vesta': (255, 217, 143)},
+    'In': {'jmol': (166, 117, 115), 'vesta': (166, 117, 115)},
+    'Sn': {'jmol': (102, 128, 128), 'vesta': (154, 142, 185)},
+    'Sb': {'jmol': (158, 99, 181), 'vesta': (158, 99, 181)},
+    'Te': {'jmol': (212, 122, 0), 'vesta': (212, 122, 0)},
+    'I': {'jmol': (148, 0, 148), 'vesta': (148, 0, 148)},
+    'Xe': {'jmol': (66, 158, 176), 'vesta': (66, 158, 176)},
+    'Cs': {'jmol': (87, 23, 143), 'vesta': (87, 23, 143)},
+    'Ba': {'jmol': (0, 201, 0), 'vesta': (0, 201, 0)},
+    'La': {'jmol': (112, 212, 255), 'vesta': (90, 196, 73)},
+    'Ce': {'jmol': (255, 255, 199), 'vesta': (255, 255, 199)},
+    'Pr': {'jmol': (217, 255, 199), 'vesta': (217, 255, 199)},
+    'Nd': {'jmol': (199, 255, 199), 'vesta': (199, 255, 199)},
+    'Pm': {'jmol': (163, 255, 199), 'vesta': (163, 255, 199)},
+    'Sm': {'jmol': (143, 255, 199), 'vesta': (143, 255, 199)},
+    'Eu': {'jmol': (97, 255, 199), 'vesta': (97, 255, 199)},
+    'Gd': {'jmol': (69, 255, 199), 'vesta': (69, 255, 199)},
+    'Tb': {'jmol': (48, 255, 199), 'vesta': (48, 255, 199)},
+    'Dy': {'jmol': (31, 255, 199), 'vesta': (31, 255, 199)},
+    'Ho': {'jmol': (0, 255, 156), 'vesta': (0, 255, 156)},
+    'Er': {'jmol': (0, 230, 117), 'vesta': (0, 230, 117)},
+    'Tm': {'jmol': (0, 212, 82), 'vesta': (0, 212, 82)},
+    'Yb': {'jmol': (0, 191, 56), 'vesta': (0, 191, 56)},
+    'Lu': {'jmol': (0, 171, 36), 'vesta': (0, 171, 36)},
+    'Hf': {'jmol': (77, 194, 255), 'vesta': (77, 194, 255)},
+    'Ta': {'jmol': (77, 166, 255), 'vesta': (77, 166, 255)},
+    'W': {'jmol': (33, 148, 214), 'vesta': (33, 148, 214)},
+    'Re': {'jmol': (38, 125, 171), 'vesta': (38, 125, 171)},
+    'Os': {'jmol': (38, 102, 150), 'vesta': (38, 102, 150)},
+    'Ir': {'jmol': (23, 84, 135), 'vesta': (23, 84, 135)},
+    'Pt': {'jmol': (208, 208, 224), 'vesta': (208, 208, 224)},
+    'Au': {'jmol': (255, 209, 35), 'vesta': (255, 209, 35)},
+    'Hg': {'jmol': (184, 184, 208), 'vesta': (184, 184, 208)},
+    'Tl': {'jmol': (166, 84, 77), 'vesta': (166, 84, 77)},
+    'Pb': {'jmol': (87, 89, 97), 'vesta': (87, 89, 97)},
+    'Bi': {'jmol': (158, 79, 181), 'vesta': (158, 79, 181)},
+    'Po': {'jmol': (171, 92, 0), 'vesta': (171, 92, 0)},
+    'At': {'jmol': (117, 79, 69), 'vesta': (117, 79, 69)},
+    'Rn': {'jmol': (66, 130, 150), 'vesta': (66, 130, 150)},
+    'Fr': {'jmol': (66, 0, 102), 'vesta': (66, 0, 102)},
+    'Ra': {'jmol': (0, 125, 0), 'vesta': (0, 125, 0)},
+    'Ac': {'jmol': (112, 171, 250), 'vesta': (112, 171, 250)},
+    'Th': {'jmol': (0, 186, 255), 'vesta': (0, 186, 255)},
+    'Pa': {'jmol': (0, 161, 255), 'vesta': (0, 161, 255)},
+    'U': {'jmol': (0, 143, 255), 'vesta': (0, 143, 255)},
+    'Np': {'jmol': (0, 128, 255), 'vesta': (0, 128, 255)},
+    'Pu': {'jmol': (0, 107, 255), 'vesta': (0, 107, 255)},
+    'Am': {'jmol': (84, 92, 242), 'vesta': (84, 92, 242)},
+    'Cm': {'jmol': (120, 92, 227), 'vesta': (120, 92, 227)},
+    'Bk': {'jmol': (138, 79, 227), 'vesta': (138, 79, 227)},
+    'Cf': {'jmol': (161, 54, 212), 'vesta': (161, 54, 212)},
+    'Es': {'jmol': (179, 31, 212), 'vesta': (179, 31, 212)},
+    'Fm': {'jmol': (179, 31, 186), 'vesta': (179, 31, 186)},
+    'Md': {'jmol': (179, 13, 166), 'vesta': (179, 13, 166)},
+    'No': {'jmol': (189, 13, 135), 'vesta': None},
+    'Lr': {'jmol': (199, 0, 102), 'vesta': (199, 0, 102)},
+    'Rf': {'jmol': (204, 0, 89), 'vesta': (204, 0, 89)},
+    'Db': {'jmol': (209, 0, 79), 'vesta': (209, 0, 79)},
+    'Sg': {'jmol': (217, 0, 69), 'vesta': (217, 0, 69)},
+    'Bh': {'jmol': (224, 0, 56), 'vesta': (224, 0, 56)},
+    'Hs': {'jmol': (230, 0, 46), 'vesta': (230, 0, 46)},
+    'Mt': {'jmol': (235, 0, 38), 'vesta': (235, 0, 38)},
+    'Ds': {'jmol': (238, 0, 38), 'vesta': None},
+    'Rg': {'jmol': (241, 0, 20), 'vesta': None},
+    'Cn': {'jmol': (246, 0, 2), 'vesta': None},
+    'Nh': {'jmol': (255, 79, 0), 'vesta': None},
+    'Fl': {'jmol': (255, 112, 0), 'vesta': None},
+    'Mc': {'jmol': (255, 140, 0), 'vesta': None},
+    'Lv': {'jmol': (255, 161, 0), 'vesta': None},
+    'Ts': {'jmol': (255, 186, 0), 'vesta': None},
+    'Og': {'jmol': (255, 209, 0), 'vesta': None},
+}
diff --git a/src/easydiffraction/display/structure/assets/radii.py b/src/easydiffraction/display/structure/assets/radii.py
new file mode 100644
index 000000000..458f46f28
--- /dev/null
+++ b/src/easydiffraction/display/structure/assets/radii.py
@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Per-element radius lookup with covalent fallback."""
+
+from __future__ import annotations
+
+from easydiffraction.display.structure.assets.elements import ELEMENT_RADII
+
+# Last-resort radius (angstrom) for an element absent from the database.
+DEFAULT_RADIUS = 1.0
+
+
+def radius_for(element: str, model: str) -> tuple[float, bool]:
+    """
+    Return a sphere radius for an element under a radius model.
+
+    Falls back to the element's covalent radius when the selected model
+    has no value for it, and to :data:`DEFAULT_RADIUS` when the element is
+    unknown.
+
+    Parameters
+    ----------
+    element : str
+        Bare element symbol, e.g. ``'Fe'``.
+    model : str
+        One of ``'vdw'``, ``'covalent'``, ``'ionic'``, ``'atomic'``.
+
+    Returns
+    -------
+    tuple[float, bool]
+        The radius (angstrom) and a ``substituted`` flag that is ``True``
+        when the requested model's value was unavailable and a fallback
+        was used.
+    """
+    entry = ELEMENT_RADII.get(element)
+    if entry is None:
+        return DEFAULT_RADIUS, True
+    value = entry.get(model)
+    if value is not None:
+        return value, False
+    covalent = entry.get('covalent')
+    if covalent is not None:
+        return covalent, True
+    return DEFAULT_RADIUS, True

From a959553719f90735aaea170b7ac8c3ab73161eb9 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:13:14 +0200
Subject: [PATCH 007/160] Add structure scene builder

---
 .../plans/crysview-structure-visualization.md |   2 +-
 .../display/structure/builder.py              | 343 ++++++++++++++++++
 2 files changed, 344 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/display/structure/builder.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index fbfd3a76e..976654fae 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -556,7 +556,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     seed; Shannon ionic; atomic; VESTA), no hand-guessed values.
   - Commit: `Add extended element database for radii and colours`.
 
-- [ ] **P1.5 — Add the scene builder**
+- [x] **P1.5 — Add the scene builder**
   - Files: new `src/easydiffraction/display/structure/builder.py`.
   - `build_scene(structure, *, style, view_range, features) -> StructureScene`,
     the easydiffraction adapter. **`features` is the already-resolved
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
new file mode 100644
index 000000000..1b5499ba2
--- /dev/null
+++ b/src/easydiffraction/display/structure/builder.py
@@ -0,0 +1,343 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""
+Scene builder: crystal structure to renderer-neutral scene.
+
+The easydiffraction-specific adapter. It reads the structure categories,
+performs symmetry expansion, fractional-to-Cartesian conversion, ADP
+eigendecomposition, radius/colour lookup, occupancy splitting, and bond
+detection, and emits a :class:`StructureScene`. All crystallographic
+computation lives here so renderers stay thin.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from itertools import product
+
+import numpy as np
+from scipy.stats import chi
+
+from easydiffraction.crystallography import crystallography as ecr
+from easydiffraction.datablocks.structure.categories.atom_sites.enums import AdpTypeEnum
+from easydiffraction.display.structure.assets.colors import AXIS_COLORS
+from easydiffraction.display.structure.assets.colors import VACANCY_COLOR
+from easydiffraction.display.structure.assets.colors import color_for
+from easydiffraction.display.structure.assets.radii import radius_for
+from easydiffraction.display.structure.scene import AdpEllipsoid
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import AxisArrow
+from easydiffraction.display.structure.scene import AxisTriad
+from easydiffraction.display.structure.scene import Bond
+from easydiffraction.display.structure.scene import CellEdge
+from easydiffraction.display.structure.scene import CellEdges
+from easydiffraction.display.structure.scene import OccupancyWedge
+from easydiffraction.display.structure.scene import OccupancyWedgeSphere
+from easydiffraction.display.structure.scene import StructureScene
+from easydiffraction.display.structure.scene import TextLabel
+
+# Tolerance (fractional units) for scene-atom identity and occupancy grouping.
+IDENTITY_TOL = 1e-4
+EIGHT_PI_SQ = 8.0 * np.pi**2
+DEFAULT_BOND_INCR = 0.4
+ALL_FEATURES = ('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels')
+
+
+@dataclass(frozen=True)
+class FeatureAvailability:
+    """What a structure's data supports, for 'auto' resolution + options."""
+
+    available: frozenset[str]
+    radius_substitutions: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class _SceneAtom:
+    """An emitted atom primitive plus data needed for bonds and labels."""
+
+    primitive: object
+    centre: np.ndarray
+    element: str
+    colour: tuple[int, int, int]
+    label: str
+
+
+def _element_symbol(type_symbol: str) -> str:
+    """Extract the bare element symbol from a CIF type symbol."""
+    match = re.match(r'[A-Z][a-z]?', type_symbol.strip())
+    return match.group() if match else type_symbol.strip()
+
+
+def _vec3(values) -> tuple[float, float, float]:
+    return (float(values[0]), float(values[1]), float(values[2]))
+
+
+def _cell_lengths_angles(cell) -> tuple[float, float, float, float, float, float]:
+    return (
+        cell.length_a.value, cell.length_b.value, cell.length_c.value,
+        cell.angle_alpha.value, cell.angle_beta.value, cell.angle_gamma.value,
+    )
+
+
+def _reciprocal_lengths(cell) -> np.ndarray:
+    a, b, c, alpha, beta, gamma = _cell_lengths_angles(cell)
+    al, be, ga = np.radians([alpha, beta, gamma])
+    ca, cb, cg = np.cos([al, be, ga])
+    omega = np.sqrt(1.0 - ca * ca - cb * cb - cg * cg + 2.0 * ca * cb * cg)
+    return np.array([np.sin(al) / (a * omega), np.sin(be) / (b * omega), np.sin(cg) / (c * omega)])
+
+
+def _lattice_shifts(pos: np.ndarray, view_range):
+    axis_ranges = []
+    for i in range(3):
+        lo, hi = view_range[i]
+        n_lo = int(np.ceil(lo - pos[i] - IDENTITY_TOL))
+        n_hi = int(np.floor(hi - pos[i] + IDENTITY_TOL))
+        axis_ranges.append(range(n_lo, n_hi + 1))
+    for shift in product(*axis_ranges):
+        yield np.array(shift, dtype=float)
+
+
+def _pos_key(pos: np.ndarray) -> tuple[int, int, int]:
+    return tuple(int(round(v / IDENTITY_TOL)) for v in pos)
+
+
+def _expand_positions(sites, ops, view_range):
+    """Generate (row_index, fractional position) for every in-range copy."""
+    generated = []
+    for idx, atom in enumerate(sites):
+        base = np.array([atom.fract_x.value, atom.fract_y.value, atom.fract_z.value], dtype=float)
+        for rot, trans in ops:
+            image = rot @ base + trans
+            for shift in _lattice_shifts(image, view_range):
+                generated.append((idx, image + shift))
+    return generated
+
+
+def _group_by_position(generated):
+    """Dedup scene atoms (row + position) and cluster coincident positions."""
+    seen: dict = {}
+    for idx, pos in generated:
+        seen.setdefault((idx, _pos_key(pos)), (idx, pos))
+    clusters: dict = {}
+    for idx, pos in seen.values():
+        clusters.setdefault(_pos_key(pos), []).append((idx, pos))
+    return clusters
+
+
+def _cartesian_u(atom, aniso, matrix: np.ndarray, cell) -> np.ndarray:
+    """Cartesian U tensor for an anisotropic atom (CIF U^ij convention)."""
+    comps = np.array([
+        [aniso.adp_11.value, aniso.adp_12.value, aniso.adp_13.value],
+        [aniso.adp_12.value, aniso.adp_22.value, aniso.adp_23.value],
+        [aniso.adp_13.value, aniso.adp_23.value, aniso.adp_33.value],
+    ], dtype=float)
+    if AdpTypeEnum(atom.adp_type.value) is AdpTypeEnum.BANI:
+        comps = comps / EIGHT_PI_SQ
+    mn = matrix @ np.diag(_reciprocal_lengths(cell))
+    return mn @ comps @ mn.T
+
+
+def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
+    """Build the sphere/ellipsoid primitive for a single full-occupancy atom."""
+    element = _element_symbol(atom.type_symbol.value)
+    colour = color_for(element, style.color_scheme.value)
+    radius, substituted = radius_for(element, style.radius_model.value)
+    label = atom.label.value
+    adp_type = AdpTypeEnum(atom.adp_type.value)
+    scale = float(chi.ppf(style.adp_probability.value, 3))
+    if style.atom_shape.value == 'ortep' and adp_type in {AdpTypeEnum.UANI, AdpTypeEnum.BANI} \
+            and label in aniso_collection:
+        u_cart = _cartesian_u(atom, aniso_collection[label], matrix, cell)
+        semi, orient = ecr.adp_principal_axes(u_cart)
+        primitive = AdpEllipsoid(
+            _vec3(centre), _vec3(semi * scale),
+            tuple(_vec3(orient[:, i]) for i in range(3)), colour, label,
+        )
+    elif style.atom_shape.value == 'ortep' and adp_type in {AdpTypeEnum.UISO, AdpTypeEnum.BISO}:
+        u_iso = atom.adp_iso.value
+        if adp_type is AdpTypeEnum.BISO:
+            u_iso = u_iso / EIGHT_PI_SQ
+        iso_radius = float(np.sqrt(max(u_iso, 0.0))) * scale
+        primitive = AtomSphere(_vec3(centre), iso_radius or radius, colour, label)
+    else:
+        primitive = AtomSphere(_vec3(centre), radius, colour, label)
+    return _SceneAtom(primitive, centre, element, colour, label), substituted
+
+
+def _wedge_sphere(rows, centre, *, style):
+    """Build an occupancy-wedge sphere for coincident atom-site rows."""
+    total = sum(occ for _, occ, _, _, _ in rows)
+    wedges = []
+    if total >= 1.0:
+        wedges = [OccupancyWedge(occ / total, colour) for _, occ, _, colour, _ in rows]
+    else:
+        wedges = [OccupancyWedge(occ, colour) for _, occ, _, colour, _ in rows]
+        wedges.append(OccupancyWedge(1.0 - total, VACANCY_COLOR))
+    radius = max(radius for _, _, _, _, radius in rows)
+    major = max(rows, key=lambda r: r[1])
+    label = '/'.join(r[0].label.value for r in rows)
+    primitive = OccupancyWedgeSphere(_vec3(centre), radius, tuple(wedges), label)
+    return _SceneAtom(primitive, centre, major[2], major[3], label)
+
+
+def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
+    """Return the scene atoms (one per position cluster) and substitutions."""
+    scene_atoms = []
+    substitutions: set = set()
+    for members in clusters.values():
+        centre = ecr.fractional_to_cartesian(members[0][1], matrix)
+        if len(members) == 1:
+            atom = sites[members[0][0]]
+            occ = atom.occupancy.value
+            if occ >= 1.0 - IDENTITY_TOL:
+                scene_atom, substituted = _atom_primitive(
+                    atom, centre, style=style, matrix=matrix, cell=cell,
+                    aniso_collection=aniso_collection,
+                )
+                scene_atoms.append(scene_atom)
+                if substituted:
+                    substitutions.add(_element_symbol(atom.type_symbol.value))
+                continue
+        rows = []
+        for idx, _ in members:
+            atom = sites[idx]
+            element = _element_symbol(atom.type_symbol.value)
+            colour = color_for(element, style.color_scheme.value)
+            radius, substituted = radius_for(element, style.radius_model.value)
+            rows.append((atom, atom.occupancy.value, element, colour, radius))
+            if substituted:
+                substitutions.add(element)
+        scene_atoms.append(_wedge_sphere(rows, centre, style=style))
+    return scene_atoms, substitutions
+
+
+def _build_bonds(scene_atoms, geom_min: float, geom_incr: float):
+    """Detect bonds between in-scene atoms via the cif_core _geom rule."""
+    bonds = []
+    radii = [radius_for(a.element, 'covalent')[0] for a in scene_atoms]
+    for i, atom_i in enumerate(scene_atoms):
+        for j in range(i + 1, len(scene_atoms)):
+            atom_j = scene_atoms[j]
+            distance = float(np.linalg.norm(atom_i.centre - atom_j.centre))
+            if geom_min <= distance <= radii[i] + radii[j] + geom_incr:
+                bonds.append(Bond(_vec3(atom_i.centre), _vec3(atom_j.centre),
+                                  atom_i.colour, atom_j.colour))
+    return bonds
+
+
+def _cell_edges(matrix: np.ndarray) -> CellEdges:
+    corners = {tuple(c): _vec3(matrix @ np.array(c, dtype=float))
+               for c in product((0, 1), repeat=3)}
+    edges = []
+    for c in corners:
+        for axis in range(3):
+            if c[axis] == 0:
+                neighbour = tuple(1 if k == axis else c[k] for k in range(3))
+                edges.append(CellEdge(corners[c], corners[neighbour]))
+    return CellEdges(tuple(edges))
+
+
+def _axis_triad(matrix: np.ndarray) -> AxisTriad:
+    length = 1.3 * max(float(np.linalg.norm(matrix[:, i])) for i in range(3))
+    arrows = []
+    for i, letter in enumerate('abc'):
+        direction = matrix[:, i] / float(np.linalg.norm(matrix[:, i]))
+        arrows.append(AxisArrow(_vec3(direction * length), AXIS_COLORS[letter], letter))
+    return AxisTriad((0.0, 0.0, 0.0), (arrows[0], arrows[1], arrows[2]))
+
+
+def build_scene(structure, *, style, view_range, features) -> StructureScene:
+    """
+    Build a renderer-neutral scene from a structure and resolved features.
+
+    Parameters
+    ----------
+    structure : object
+        A structure datablock with ``cell``, ``atom_sites``,
+        ``atom_site_aniso``, ``space_group`` and ``geom`` categories.
+    style : object
+        The ``project.style`` category (atom shape, radius model, colour
+        scheme, ADP probability).
+    view_range : tuple
+        Per-axis ``((min, max), (min, max), (min, max))`` fractional range.
+    features : frozenset[str]
+        The already-resolved set of primitives to emit (never ``'auto'``);
+        the builder never re-implements visibility precedence.
+
+    Returns
+    -------
+    StructureScene
+        The flat Cartesian primitive set for the renderers.
+    """
+    cell = structure.cell
+    matrix = ecr.orthogonalization_matrix(*_cell_lengths_angles(cell))
+    sg = structure.space_group
+    ops = ecr.symmetry_operators(sg.name_h_m.value, sg.it_coordinate_system_code.value)
+    sites = list(structure.atom_sites)
+
+    clusters = _group_by_position(_expand_positions(sites, ops, view_range))
+    scene_atoms, _ = _build_atoms(
+        sites, clusters, style=style, matrix=matrix, cell=cell,
+        aniso_collection=structure.atom_site_aniso,
+    )
+
+    bonds: tuple = ()
+    if 'bonds' in features:
+        geom = getattr(structure, 'geom', None)
+        geom_min = geom.min_bond_distance_cutoff.value if geom is not None else 0.0
+        geom_incr = geom.bond_distance_incr.value if geom is not None else DEFAULT_BOND_INCR
+        bonds = tuple(_build_bonds(scene_atoms, geom_min, geom_incr))
+
+    show_atoms = 'atoms' in features
+    return StructureScene(
+        cell_basis=tuple(_vec3(matrix[:, i]) for i in range(3)),
+        atoms=tuple(a.primitive for a in scene_atoms
+                    if show_atoms and isinstance(a.primitive, AtomSphere)),
+        occupancy_spheres=tuple(a.primitive for a in scene_atoms
+                                if show_atoms and isinstance(a.primitive, OccupancyWedgeSphere)),
+        ellipsoids=tuple(a.primitive for a in scene_atoms
+                         if show_atoms and isinstance(a.primitive, AdpEllipsoid)),
+        bonds=bonds,
+        moments=(),
+        cell_edges=_cell_edges(matrix) if 'cell' in features else None,
+        axes=_axis_triad(matrix) if 'axes' in features else None,
+        labels=tuple(TextLabel(_vec3(a.centre), a.label) for a in scene_atoms)
+        if 'labels' in features else (),
+    )
+
+
+def structure_feature_availability(structure, *, style) -> FeatureAvailability:
+    """
+    Report which features a structure supports, without building a scene.
+
+    Used by the display facade for ``include='auto'`` resolution and by
+    ``show_structure_options()``; the builder is the only reader of the
+    structure, so availability is computed once here.
+
+    Parameters
+    ----------
+    structure : object
+        A structure datablock.
+    style : object
+        The ``project.style`` category (its radius model drives the
+        covalent-substitution report).
+
+    Returns
+    -------
+    FeatureAvailability
+        Available feature names and the elements whose radius fell back to
+        covalent under the selected model.
+    """
+    sites = list(structure.atom_sites)
+    available = {'cell', 'axes'}
+    if sites:
+        available |= {'atoms', 'bonds', 'labels'}
+    substitutions = set()
+    for atom in sites:
+        element = _element_symbol(atom.type_symbol.value)
+        _, substituted = radius_for(element, style.radius_model.value)
+        if substituted:
+            substitutions.add(element)
+    return FeatureAvailability(frozenset(available), tuple(sorted(substitutions)))

From df333e8df4c91a5bcdcf175154ee7292df889f7c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:17:00 +0200
Subject: [PATCH 008/160] Add ASCII structure renderer

---
 .../plans/crysview-structure-visualization.md |   2 +-
 .../display/structure/renderers/__init__.py   |   8 +
 .../display/structure/renderers/ascii.py      | 166 ++++++++++++++++++
 .../display/structure/renderers/base.py       |  47 +++++
 4 files changed, 222 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/display/structure/renderers/__init__.py
 create mode 100644 src/easydiffraction/display/structure/renderers/ascii.py
 create mode 100644 src/easydiffraction/display/structure/renderers/base.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 976654fae..26478ca29 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -615,7 +615,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     structure for availability.
   - Commit: `Add structure scene builder`.
 
-- [ ] **P1.6 — Add base + ASCII structure renderer**
+- [x] **P1.6 — Add base + ASCII structure renderer**
   - Files: new
     `src/easydiffraction/display/structure/renderers/__init__.py`,
     `renderers/base.py`, `renderers/ascii.py`.
diff --git a/src/easydiffraction/display/structure/renderers/__init__.py b/src/easydiffraction/display/structure/renderers/__init__.py
new file mode 100644
index 000000000..7faed819a
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Structure-scene renderer engines."""
+
+from __future__ import annotations
+
+from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
diff --git a/src/easydiffraction/display/structure/renderers/ascii.py b/src/easydiffraction/display/structure/renderers/ascii.py
new file mode 100644
index 000000000..b2f8d1b07
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/ascii.py
@@ -0,0 +1,166 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""ASCII terminal renderer: a schematic single-cell structure view."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.scene import StructureScene
+
+Rgb = tuple[int, int, int]
+
+GLYPH_RAMP = ('·', '•', '●', '⬤')
+GRID_WIDTH = 56
+PAD = 2
+CHAR_ASPECT = 0.5  # terminal cells are roughly twice as tall as wide
+
+
+def _ansi256(rgb: Rgb) -> int:
+    """Map an RGB triple to the nearest xterm-256 cube colour."""
+    return 16 + 36 * round(rgb[0] / 255 * 5) + 6 * round(rgb[1] / 255 * 5) + round(rgb[2] / 255 * 5)
+
+
+def _tint(rgb: Rgb, text: str) -> str:
+    return f'\x1b[38;5;{_ansi256(rgb)}m{text}\x1b[0m'
+
+
+def _collect_atoms(scene: StructureScene):
+    """Flatten every drawable atom to (centre, radius, colour, label)."""
+    atoms = [(a.centre, a.radius, a.colour, a.label) for a in scene.atoms]
+    atoms += [(s.centre, s.radius, s.wedges[0].colour, s.label) for s in scene.occupancy_spheres]
+    atoms += [(e.centre, float(np.mean(e.semi_axes)) or 0.4, e.colour, e.label)
+              for e in scene.ellipsoids]
+    return atoms
+
+
+class AsciiStructureRenderer(StructureRendererBase):
+    """Reduced-fidelity terminal renderer (one schematic cell)."""
+
+    SUPPORTED = frozenset({'atoms', 'cell', 'axes'})
+
+    def supported_features(self) -> frozenset[str]:
+        """Return the features the ASCII engine can draw."""
+        return self.SUPPORTED
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        """Render a schematic ASCII view and announce 3D-only features."""
+        atoms = _collect_atoms(scene)
+        basis = np.array(scene.cell_basis, dtype=float)
+        lengths = [float(np.linalg.norm(v)) for v in basis]
+        h_vec = basis[int(np.argmax(lengths))]
+        v_vec = basis[int(np.argmin(lengths))]
+        h_hat = h_vec / (np.linalg.norm(h_vec) or 1.0)
+        v_hat = v_vec / (np.linalg.norm(v_vec) or 1.0)
+
+        def project(point) -> tuple[float, float]:
+            p = np.array(point, dtype=float)
+            return float(p @ h_hat), float(p @ v_hat)
+
+        corners = [project((0, 0, 0)), project(h_vec), project(v_vec), project(h_vec + v_vec)]
+        points = [project(a[0]) for a in atoms] + corners
+        grid, place = _make_grid(points)
+
+        if 'cell' in features:
+            _draw_cell(grid, place, corners)
+        if 'atoms' in features and atoms:
+            _draw_atoms(grid, place, atoms)
+
+        lines = _grid_to_lines(grid)
+        if 'axes' in features:
+            lines = _annotate_axes(lines)
+        text = '\n'.join(lines)
+        if 'atoms' in features and atoms:
+            text += '\n\n' + _legend(atoms)
+        notes = _announcements(scene, features, self.SUPPORTED)
+        if notes:
+            text += '\n\n' + '\n'.join(notes)
+        return text
+
+
+def _make_grid(points):
+    xs = [p[0] for p in points] or [0.0]
+    ys = [p[1] for p in points] or [0.0]
+    min_x, max_x, min_y, max_y = min(xs), max(xs), min(ys), max(ys)
+    span_x = (max_x - min_x) or 1.0
+    span_y = (max_y - min_y) or 1.0
+    width = GRID_WIDTH
+    height = max(8, int((width - 2 * PAD) * span_y / span_x * CHAR_ASPECT))
+    grid: dict = {}
+
+    def place(point) -> tuple[int, int]:
+        col = PAD + int((point[0] - min_x) / span_x * (width - 1 - 2 * PAD))
+        row = PAD + int((max_y - point[1]) / span_y * (height - 1 - 2 * PAD))
+        return row, col
+
+    grid['_size'] = (height, width)
+    return grid, place
+
+
+def _draw_line(grid, p0, p1, glyph, colour):
+    (r0, c0), (r1, c1) = p0, p1
+    steps = max(abs(r1 - r0), abs(c1 - c0)) or 1
+    for i in range(steps + 1):
+        row = round(r0 + (r1 - r0) * i / steps)
+        col = round(c0 + (c1 - c0) * i / steps)
+        grid.setdefault((row, col), (glyph, colour))
+
+
+def _draw_cell(grid, place, corners):
+    grey = (150, 150, 150)
+    c00, c10, c01, c11 = (place(c) for c in corners)
+    for a, b in ((c00, c10), (c01, c11)):
+        _draw_line(grid, a, b, '─', grey)
+    for a, b in ((c00, c01), (c10, c11)):
+        _draw_line(grid, a, b, '│', grey)
+
+
+def _draw_atoms(grid, place, atoms):
+    max_radius = max(a[1] for a in atoms) or 1.0
+    for centre, radius, colour, _label in atoms:
+        bucket = min(len(GLYPH_RAMP) - 1, int(radius / max_radius * len(GLYPH_RAMP)))
+        grid[place(centre)] = (GLYPH_RAMP[bucket], colour)
+
+
+def _grid_to_lines(grid):
+    height, width = grid['_size']
+    lines = []
+    for row in range(height):
+        chars = []
+        for col in range(width):
+            cell = grid.get((row, col))
+            chars.append(_tint(cell[1], cell[0]) if cell else ' ')
+        lines.append(''.join(chars).rstrip())
+    return lines
+
+
+def _annotate_axes(lines):
+    if lines:
+        lines[0] = '  c ↑' + lines[0][5:] if len(lines[0]) > 5 else '  c ↑'
+        lines[-1] = lines[-1] + '  → a'
+    return lines
+
+
+def _legend(atoms) -> str:
+    seen: dict = {}
+    for _centre, radius, colour, label in atoms:
+        element = ''.join(ch for ch in label if ch.isalpha()) or label
+        seen.setdefault(element, (radius, colour))
+    max_radius = max(r for r, _ in seen.values()) or 1.0
+    items = []
+    for element, (radius, colour) in seen.items():
+        bucket = min(len(GLYPH_RAMP) - 1, int(radius / max_radius * len(GLYPH_RAMP)))
+        items.append(_tint(colour, f'{GLYPH_RAMP[bucket]} {element}'))
+    return 'Legend:  ' + '   '.join(items)
+
+
+def _announcements(scene, features, supported) -> list[str]:
+    notes = []
+    skipped = [f for f in ('bonds', 'labels', 'moments') if f in features and f not in supported]
+    if skipped:
+        notes.append('Shown only by the 3D engines: ' + ', '.join(skipped) + '.')
+    if scene.ellipsoids:
+        notes.append('ADP ellipsoids are flattened to dots; use a 3D engine for ellipsoids.')
+    notes.append('Schematic single-cell view; wider ranges are shown only by the 3D engines.')
+    return notes
diff --git a/src/easydiffraction/display/structure/renderers/base.py b/src/easydiffraction/display/structure/renderers/base.py
new file mode 100644
index 000000000..5f6173524
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/base.py
@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Abstract base for structure-scene renderer engines."""
+
+from __future__ import annotations
+
+from abc import ABC
+from abc import abstractmethod
+
+from easydiffraction.display.structure.scene import StructureScene
+
+
+class StructureRendererBase(ABC):
+    """Base class an engine implements to draw a structure scene."""
+
+    @abstractmethod
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        """
+        Draw the scene and return the engine-specific output.
+
+        Parameters
+        ----------
+        scene : StructureScene
+            The renderer-neutral primitives to draw.
+        features : frozenset[str]
+            The content-resolved feature set from the facade. The renderer
+            draws the features it supports and announces + skips the rest.
+
+        Returns
+        -------
+        str
+            ASCII text or an HTML document, depending on the engine.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def supported_features(self) -> frozenset[str]:
+        """
+        Return the feature names this engine can draw.
+
+        Returns
+        -------
+        frozenset[str]
+            Subset of ``atoms``, ``bonds``, ``cell``, ``axes``,
+            ``moments``, ``labels``.
+        """
+        raise NotImplementedError

From fe1e19617d2f132edbabf4a4d1a506a552035623 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:19:21 +0200
Subject: [PATCH 009/160] Add Viewer facade and factory with ASCII engine

---
 .../plans/crysview-structure-visualization.md |  2 +-
 .../display/structure/__init__.py             |  7 ++
 .../display/structure/viewing.py              | 64 +++++++++++++++++++
 3 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/display/structure/viewing.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 26478ca29..58381ff60 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -656,7 +656,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     is testable before the facade exists.
   - Commit: `Add ASCII structure renderer`.
 
-- [ ] **P1.7 — Add the Viewer facade + factory; register ASCII**
+- [x] **P1.7 — Add the Viewer facade + factory; register ASCII**
   - Files: new `src/easydiffraction/display/structure/viewing.py`;
     update `display/structure/renderers/ascii.py` with
     `@ViewerFactory.register`; update `display/structure/__init__.py`.
diff --git a/src/easydiffraction/display/structure/__init__.py b/src/easydiffraction/display/structure/__init__.py
index 9cf6ab941..d22b6ca41 100644
--- a/src/easydiffraction/display/structure/__init__.py
+++ b/src/easydiffraction/display/structure/__init__.py
@@ -3,3 +3,10 @@
 """crysview structure-visualization subsystem."""
 
 from __future__ import annotations
+
+from easydiffraction.display.structure.enums import AtomShapeEnum
+from easydiffraction.display.structure.enums import ColorSchemeEnum
+from easydiffraction.display.structure.enums import RadiusModelEnum
+from easydiffraction.display.structure.enums import ViewerEngineEnum
+from easydiffraction.display.structure.viewing import Viewer
+from easydiffraction.display.structure.viewing import ViewerFactory
diff --git a/src/easydiffraction/display/structure/viewing.py b/src/easydiffraction/display/structure/viewing.py
new file mode 100644
index 000000000..bdaee0f5e
--- /dev/null
+++ b/src/easydiffraction/display/structure/viewing.py
@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Viewer facade and engine factory for the structure view."""
+
+from __future__ import annotations
+
+from easydiffraction.display.base import RendererBase
+from easydiffraction.display.base import RendererFactoryBase
+from easydiffraction.display.structure.enums import ViewerEngineEnum
+from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+from easydiffraction.display.structure.scene import StructureScene
+
+
+class ViewerFactory(RendererFactoryBase):
+    """Factory for structure-view renderer engines."""
+
+    @classmethod
+    def _registry(cls) -> dict:
+        return {
+            ViewerEngineEnum.ASCII.value: {
+                'description': ViewerEngineEnum.ASCII.description(),
+                'class': AsciiStructureRenderer,
+            },
+        }
+
+
+class Viewer(RendererBase):
+    """Switchable facade that draws a scene with the active engine."""
+
+    @classmethod
+    def _factory(cls) -> type[RendererFactoryBase]:
+        """Return the structure-view engine factory."""
+        return ViewerFactory
+
+    @classmethod
+    def _default_engine(cls) -> str:
+        """Return the default engine name (Three.js)."""
+        return ViewerEngineEnum.default().value
+
+    def show_config(self) -> None:
+        """Display the active structure-view engine."""
+        self.show_current_engine()
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        """
+        Draw the scene with the active engine.
+
+        Parameters
+        ----------
+        scene : StructureScene
+            The renderer-neutral primitives to draw.
+        features : frozenset[str]
+            The content-resolved feature set from the display facade.
+
+        Returns
+        -------
+        str
+            ASCII text or an HTML document, depending on the active engine.
+        """
+        return self._backend.render(scene, features=features)
+
+    def supported_features(self) -> frozenset[str]:
+        """Return the feature names the active engine can draw."""
+        return self._backend.supported_features()

From b2211b7449ce254b9d2aa71a29f4a1968a357639 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:22:21 +0200
Subject: [PATCH 010/160] Add style category for structure view styling

---
 .../plans/crysview-structure-visualization.md |   2 +-
 src/easydiffraction/core/validation.py        |  12 +-
 .../project/categories/style/__init__.py      |   8 ++
 .../project/categories/style/default.py       | 129 ++++++++++++++++++
 .../project/categories/style/factory.py       |  17 +++
 5 files changed, 162 insertions(+), 6 deletions(-)
 create mode 100644 src/easydiffraction/project/categories/style/__init__.py
 create mode 100644 src/easydiffraction/project/categories/style/default.py
 create mode 100644 src/easydiffraction/project/categories/style/factory.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 58381ff60..9008fff5a 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -680,7 +680,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     registration convention requires.
   - Commit: `Add Viewer facade and factory with ASCII engine`.
 
-- [ ] **P1.8 — Add the plain `style` category**
+- [x] **P1.8 — Add the plain `style` category**
   - Files: existing `src/easydiffraction/core/validation.py`; new
     `src/easydiffraction/project/categories/style/__init__.py`,
     `default.py`, `factory.py`.
diff --git a/src/easydiffraction/core/validation.py b/src/easydiffraction/core/validation.py
index b937ac081..546719fe9 100644
--- a/src/easydiffraction/core/validation.py
+++ b/src/easydiffraction/core/validation.py
@@ -167,15 +167,17 @@ def validated(
 
 
 class RangeValidator(ValidatorBase):
-    """Ensure a numeric value lies within [ge, le]."""
+    """Ensure a numeric value lies within [ge, le] and (gt, lt)."""
 
     def __init__(
         self,
         *,
         ge: float = -np.inf,
         le: float = np.inf,
+        gt: float = -np.inf,
+        lt: float = np.inf,
     ) -> None:
-        self.ge, self.le = ge, le
+        self.ge, self.le, self.gt, self.lt = ge, le, gt, lt
 
     def validated(
         self,
@@ -185,12 +187,12 @@ def validated(
         current: object = None,
     ) -> object:
         """Validate range and return value or fallback."""
-        if not (self.ge <= value <= self.le):
+        if not (self.ge <= value <= self.le and self.gt < value < self.lt):
             Diagnostics.range_mismatch(
                 name,
                 value,
-                self.ge,
-                self.le,
+                max(self.ge, self.gt),
+                min(self.le, self.lt),
                 current=current,
                 default=default,
             )
diff --git a/src/easydiffraction/project/categories/style/__init__.py b/src/easydiffraction/project/categories/style/__init__.py
new file mode 100644
index 000000000..736c97652
--- /dev/null
+++ b/src/easydiffraction/project/categories/style/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project style category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.style.default import Style
+from easydiffraction.project.categories.style.factory import StyleFactory
diff --git a/src/easydiffraction/project/categories/style/default.py b/src/easydiffraction/project/categories/style/default.py
new file mode 100644
index 000000000..3530bed4c
--- /dev/null
+++ b/src/easydiffraction/project/categories/style/default.py
@@ -0,0 +1,129 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project structure-view styling category."""
+
+from __future__ import annotations
+
+from easydiffraction.core.category import CategoryItem
+from easydiffraction.core.metadata import TypeInfo
+from easydiffraction.core.validation import AttributeSpec
+from easydiffraction.core.validation import MembershipValidator
+from easydiffraction.core.validation import RangeValidator
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.core.variable import StringDescriptor
+from easydiffraction.display.structure.enums import AtomShapeEnum
+from easydiffraction.display.structure.enums import ColorSchemeEnum
+from easydiffraction.display.structure.enums import RadiusModelEnum
+from easydiffraction.io.cif.handler import CifHandler
+from easydiffraction.project.categories.style.factory import StyleFactory
+from easydiffraction.utils.logging import console
+
+
+@StyleFactory.register
+class Style(CategoryItem):
+    """Visual styling for the structure view (not per-element)."""
+
+    _category_code = 'style'
+
+    type_info = TypeInfo(
+        tag='default',
+        description='Project structure-view style category',
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._atom_shape = StringDescriptor(
+            name='atom_shape',
+            description='Atom depiction mode for the structure view.',
+            value_spec=AttributeSpec(
+                default=AtomShapeEnum.default().value,
+                validator=MembershipValidator(
+                    allowed=[member.value for member in AtomShapeEnum],
+                ),
+            ),
+            cif_handler=CifHandler(names=['_style.atom_shape']),
+        )
+        self._radius_model = StringDescriptor(
+            name='radius_model',
+            description='Standard per-element radius model.',
+            value_spec=AttributeSpec(
+                default=RadiusModelEnum.default().value,
+                validator=MembershipValidator(
+                    allowed=[member.value for member in RadiusModelEnum],
+                ),
+            ),
+            cif_handler=CifHandler(names=['_style.radius_model']),
+        )
+        self._color_scheme = StringDescriptor(
+            name='color_scheme',
+            description='Standard element colour scheme.',
+            value_spec=AttributeSpec(
+                default=ColorSchemeEnum.default().value,
+                validator=MembershipValidator(
+                    allowed=[member.value for member in ColorSchemeEnum],
+                ),
+            ),
+            cif_handler=CifHandler(names=['_style.color_scheme']),
+        )
+        self._adp_probability = NumericDescriptor(
+            name='adp_probability',
+            description='ORTEP probability level, a fraction in (0, 1).',
+            value_spec=AttributeSpec(
+                default=0.5,
+                validator=RangeValidator(gt=0.0, lt=1.0),
+            ),
+            cif_handler=CifHandler(names=['_style.adp_probability']),
+        )
+
+    @property
+    def atom_shape(self) -> StringDescriptor:
+        """Atom depiction mode (``ball`` or ``ortep``)."""
+        return self._atom_shape
+
+    @atom_shape.setter
+    def atom_shape(self, value: str) -> None:
+        self._atom_shape.value = AtomShapeEnum(value).value
+
+    @property
+    def radius_model(self) -> StringDescriptor:
+        """Standard per-element radius model."""
+        return self._radius_model
+
+    @radius_model.setter
+    def radius_model(self, value: str) -> None:
+        self._radius_model.value = RadiusModelEnum(value).value
+
+    @property
+    def color_scheme(self) -> StringDescriptor:
+        """Standard element colour scheme."""
+        return self._color_scheme
+
+    @color_scheme.setter
+    def color_scheme(self, value: str) -> None:
+        self._color_scheme.value = ColorSchemeEnum(value).value
+
+    @property
+    def adp_probability(self) -> NumericDescriptor:
+        """ORTEP probability level (fraction in the open interval (0, 1))."""
+        return self._adp_probability
+
+    @adp_probability.setter
+    def adp_probability(self, value: float) -> None:
+        self._adp_probability.value = value
+
+    def show_supported(self) -> None:
+        """List the accepted values for every styling setting."""
+        console.paragraph('Supported style settings')
+        for setting, enum in (
+            ('atom_shape', AtomShapeEnum),
+            ('radius_model', RadiusModelEnum),
+            ('color_scheme', ColorSchemeEnum),
+        ):
+            console.print(f"{setting}: {', '.join(member.value for member in enum)}")
+        console.print('adp_probability: float in the open interval (0, 1)')
+
+    @property
+    def as_cif(self) -> str:
+        """Return CIF representation of this style category."""
+        return super().as_cif
diff --git a/src/easydiffraction/project/categories/style/factory.py b/src/easydiffraction/project/categories/style/factory.py
new file mode 100644
index 000000000..e1613a462
--- /dev/null
+++ b/src/easydiffraction/project/categories/style/factory.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Factory for project style categories."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from easydiffraction.core.factory import FactoryBase
+
+
+class StyleFactory(FactoryBase):
+    """Create project style category instances."""
+
+    _default_rules: ClassVar[dict] = {
+        frozenset(): 'default',
+    }

From a1abc2bc65b7fb0719d8c3b98962751faae49784 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:35:11 +0200
Subject: [PATCH 011/160] Use six scalar descriptors for the view range

---
 .../crysview-structure-visualization.md       | 39 ++++++++++++------
 .../plans/crysview-structure-visualization.md | 40 +++++++++++--------
 2 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 05538e669..2ac563dcc 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -183,10 +183,16 @@ two cells, `[-0.2, 1.2]` adds a margin. Like the other settings it is
 persisted and overridable per call:
 
 ```python
-project.view.range = ((0, 1), (0, 1), (0, 1))   # default: full cell, borders included
+# Persisted per-axis bounds — six scalar settings, like the cell
+# parameters (defaults 0 and 1 on each axis = the full cell, borders
+# included):
+project.view.range_a_max = 2                       # two cells along a
+project.view.range_c_min, project.view.range_c_max = -0.2, 1.2   # margin on c
+
+# A convenience tuple overrides the persisted range for one call only:
 project.display.structure(
     struct_name='lbco',
-    range=((0, 2), (0, 1), (0, 1)),             # two cells along a, this call only
+    range=((0, 2), (0, 1), (0, 1)),
 )
 ```
 
@@ -221,7 +227,7 @@ carry.
 Because expansion happens in the scene builder (section 1), the 3D
 engines draw this expanded set in full. The `ascii` engine is the
 reduced-fidelity sibling (section 7): it always renders the single
-default cell and reports a wider `project.view.range` as a 3D-only
+default cell and reports a wider view range as a 3D-only
 capability through `show_structure_options()`, the same way it announces
 the other features only the 3D engines draw.
 
@@ -379,7 +385,7 @@ sibling of the 3D engines: one schematic projection, one unit cell, and
 no bonds, labels, ADP ellipsoids, or moment arrows. When an `include=`
 request asks for one of those features, the engine announces it is
 available with the 3D engines and skips it, just as the ascii chart
-engine does for Plotly-only features. A `project.view.range` wider than
+engine does for Plotly-only features. A view range wider than
 the default single cell is treated the same way: the terminal view
 always draws one cell and announces that multi-cell and margin ranges
 are honored only by the 3D engines, so its schematic stays uncluttered
@@ -489,9 +495,11 @@ project.display.structure(
 project.view.show_labels = False
 project.view.show_moments = True
 
-# What region (persisted): which symmetry-equivalent atoms are generated,
-# as a per-axis fractional range (default below, borders included).
-project.view.range = ((0, 1), (0, 1), (0, 1))
+# What region (persisted): six per-axis fractional bounds (defaults 0 and
+# 1 = full cell, borders included), mirroring the six scalar cell
+# parameters.
+project.view.range_a_min = 0
+project.view.range_a_max = 1   # range_b_min/max and range_c_min/max likewise
 ```
 
 The persisted equivalent in the project CIF:
@@ -501,9 +509,12 @@ The persisted equivalent in the project CIF:
 _view.type           threejs
 _view.show_labels    false
 _view.show_moments   true
-_view.range_a        0 1
-_view.range_b        0 1
-_view.range_c        0 1
+_view.range_a_min    0
+_view.range_a_max    1
+_view.range_b_min    0
+_view.range_b_max    1
+_view.range_c_min    0
+_view.range_c_max    1
 
 _style.atom_shape       ortep
 _style.radius_model     covalent
@@ -635,7 +646,7 @@ the final names.
 - **CIF tag spelling — resolved.** Project CIF: `_style.atom_shape`,
   `_style.radius_model`, `_style.color_scheme`,
   `_style.adp_probability`, and `_view.type` / `_view.show_labels` /
-  `_view.show_moments` / `_view.range_a|b|c`. These are project-internal
+  `_view.show_moments` / `_view.range_{a,b,c}_{min,max}`. These are project-internal
   app/settings tags (`_view.type` follows the Display-UX `_chart.type` /
   `_table.type` precedent); the radii and colours are a bundled
   element-database asset, not CIF-serialized.
@@ -658,8 +669,10 @@ the final names.
 - **Per-axis range boundary completion — resolved.** Version 1 draws
   only atoms inside the range (borders included) and bonds only between
   in-scene atoms — no out-of-range partner atoms or edge-coordination
-  completion. Range CIF spelling is `_view.range_a|b|c` (two numbers
-  each).
+  completion. The range is persisted as six scalar tags
+  `_view.range_{a,b,c}_{min,max}` (one number each, defaults 0 and 1),
+  mirroring the six scalar cell parameters; a per-call `range=` tuple on
+  `structure()` overrides them for one call.
 
 ## Deferred Work
 
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 9008fff5a..73b9b0203 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -97,10 +97,11 @@ plan-level structural choices confirmed with the author at plan start.
   `labels`); a companion `show_structure_options(struct_name=...)`
   mirrors `show_pattern_options()`. Notebook embeds an interactive view
   (IPython HTML repr); a standalone HTML file can be written to a path.
-- **Per-axis fractional range** (§3):
-  `project.view.range = ((0,1),(0,1),(0,1))` default (full cell,
-  **borders included**), per-axis, non-integer allowed, validated min <
-  max, persisted, overridable per call.
+- **Per-axis fractional range** (§3): six scalar bounds
+  `project.view.range_{a,b,c}_{min,max}` (defaults 0 and 1 = full cell,
+  **borders included**), mirroring the six scalar cell parameters;
+  non-integer allowed, validated min < max per axis, persisted; a
+  per-call `range=` tuple on `structure()` overrides for one call.
 - **Scene-atom identity rule** (§3): two generated atoms are the same
   scene atom iff same atom-site row **and** fractional coordinates
   coincide within `1e-4` (fractional units); keep one, drop the rest.
@@ -198,9 +199,11 @@ below were verified reachable (HTTP 200).
   Question 1) — **Resolved (final).** Project CIF: `_style.atom_shape`,
   `_style.radius_model`, `_style.color_scheme`,
   `_style.adp_probability`, and `_view.type`, `_view.show_labels`,
-  `_view.show_moments`, plus the range as `_view.range_a`,
-  `_view.range_b`, `_view.range_c` (two numbers each, e.g.
-  `_view.range_a   0 1`). Structure CIF (per-structure): the **standard
+  `_view.show_moments`, plus the per-axis range as six scalar tags
+  `_view.range_a_min` / `_view.range_a_max` / `_view.range_b_min` /
+  `_view.range_b_max` / `_view.range_c_min` / `_view.range_c_max` (one
+  number each, defaults 0 and 1), mirroring the cell parameters. Structure
+  CIF (per-structure): the **standard
   cif_core** bond cutoffs `_geom.min_bond_distance_cutoff` (default
   `0.0`) and `_geom.bond_distance_incr` (default `0.4`), plus the
   per-type bonding radius `_atom_type.radius_bond` when present (P1.11).
@@ -721,10 +724,14 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     `ViewerEngineEnum` + `ViewerFactory.descriptions()` and **defaulting
     to `ViewerEngineEnum.default()` (`threejs`)**, matching P1.1;
     `from_cif` calling `self._parent._swap_view`. Plus persisted
-    view-state descriptors: `show_labels` (bool, default off),
-    `show_moments` (bool, default on-where-data), and the per-axis
-    `range` as `_view.range_a/b/c` (two-number min/max each, validated
-    min < max). `show_supported()` lists engines.
+    view-state descriptors: `show_labels` (`BoolDescriptor`, default off),
+    `show_moments` (`BoolDescriptor`, default on-where-data), and the
+    per-axis range as **six scalar `NumericDescriptor`s**
+    `range_a_min` / `range_a_max` / `range_b_min` / `range_b_max` /
+    `range_c_min` / `range_c_max` (CIF `_view.range_a_min` … , defaults 0
+    and 1, each axis validated `min < max` in the setter), mirroring the
+    six scalar cell parameters; `structure()`'s `range=` tuple arg
+    overrides them per call. `show_supported()` lists engines.
   - **Headless implication of the `threejs` default.** With `threejs`
     default, `project.display.structure(...)` returns/writes an HTML
     string and needs **no browser**, so it runs unattended in CI,
@@ -795,7 +802,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
       `structure_feature_availability(structure, style=project.style)`;
       build the scene via
       `build_scene(structure, style=project.style, view_range=<resolved range>, features=<resolved set>)`
-      (per-call `range` overrides the persisted `project.view.range` for
+      (per-call `range` overrides the persisted view range for
       that call); render with the active `project.view` engine.
       **Signature mirrors `pattern()`**: `structure(...) -> None`,
       displaying directly as a side effect (notebook: `IPython.display`
@@ -1013,8 +1020,9 @@ coverage (configured in P1.13).
       setting's accepted values; `_style.*` CIF round-trips. P1.8.
 - [ ] **`tests/unit/easydiffraction/project/categories/view/test_view.py`**
       (new) — `type` validates against `ViewerEngineEnum`; setting
-      `type` calls `_swap_view`; `range` rejects min ≥ max; `_view.type`
-      / `_view.show_*` / `_view.range_*` CIF round-trip;
+      `type` calls `_swap_view`; a `range_a_max` below `range_a_min` is
+      rejected (per-axis `min < max`); `_view.type` / `_view.show_*` /
+      `_view.range_a_min` … `_view.range_c_max` CIF round-trip;
       `show_supported()` lists engines. P1.9.
 - [ ] **`tests/unit/easydiffraction/project/test_project.py`** (extend)
       — `project.view` / `project.style` are read-only attributes;
@@ -1123,8 +1131,8 @@ ellipsoids — alongside the existing 1D pattern view.
   the standard bond cut-offs (a minimum distance and a tolerance added
   to the atoms' bonding radii) for each structure, saved in that
   structure's own file, so different phases can use different cut-offs.
-- **See a single cell, a margin, or several cells.**
-  `project.view.range` sets a per-axis fractional range (default: the
+- **See a single cell, a margin, or several cells.** `project.view` sets
+  a per-axis fractional range (default: the
   full cell with border atoms drawn); widen it for a margin or multiple
   cells.
 - **Works offline.** The notebook and standalone-HTML views embed a

From 78484a31e6b3402243620a0c6a77b48aaaad80ea Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:42:19 +0200
Subject: [PATCH 012/160] Add switchable view category for renderer selection

---
 .../plans/crysview-structure-visualization.md |   2 +-
 .../project/categories/view/__init__.py       |   8 +
 .../project/categories/view/default.py        | 203 ++++++++++++++++++
 .../project/categories/view/factory.py        |  17 ++
 4 files changed, 229 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/project/categories/view/__init__.py
 create mode 100644 src/easydiffraction/project/categories/view/default.py
 create mode 100644 src/easydiffraction/project/categories/view/factory.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 73b9b0203..580b61cee 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -713,7 +713,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Register `Style` in `project/categories/style/__init__.py`.
   - Commit: `Add style category for structure view styling`.
 
-- [ ] **P1.9 — Add the switchable `view` category**
+- [x] **P1.9 — Add the switchable `view` category**
   - Files: new
     `src/easydiffraction/project/categories/view/__init__.py`,
     `default.py`, `factory.py`.
diff --git a/src/easydiffraction/project/categories/view/__init__.py b/src/easydiffraction/project/categories/view/__init__.py
new file mode 100644
index 000000000..8bed937f7
--- /dev/null
+++ b/src/easydiffraction/project/categories/view/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project view category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.view.default import View
+from easydiffraction.project.categories.view.factory import ViewFactory
diff --git a/src/easydiffraction/project/categories/view/default.py b/src/easydiffraction/project/categories/view/default.py
new file mode 100644
index 000000000..9ff8ef44f
--- /dev/null
+++ b/src/easydiffraction/project/categories/view/default.py
@@ -0,0 +1,203 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project structure-view category (switchable renderer + view state)."""
+
+from __future__ import annotations
+
+from easydiffraction.core.category import CategoryItem
+from easydiffraction.core.metadata import TypeInfo
+from easydiffraction.core.switchable import SwitchableCategoryBase
+from easydiffraction.core.validation import AttributeSpec
+from easydiffraction.core.validation import MembershipValidator
+from easydiffraction.core.variable import BoolDescriptor
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.core.variable import StringDescriptor
+from easydiffraction.display.structure.enums import ViewerEngineEnum
+from easydiffraction.display.structure.viewing import Viewer
+from easydiffraction.display.structure.viewing import ViewerFactory
+from easydiffraction.io.cif.handler import CifHandler
+from easydiffraction.io.cif.parse import read_cif_str
+from easydiffraction.project.categories.view.factory import ViewFactory
+from easydiffraction.utils.logging import log
+
+VIEW_ENGINE_OPTIONS = [member.value for member in ViewerEngineEnum]
+
+
+def _range_descriptor(name: str, default: float) -> NumericDescriptor:
+    return NumericDescriptor(
+        name=name,
+        description='Per-axis fractional view-range bound.',
+        value_spec=AttributeSpec(default=default),
+        cif_handler=CifHandler(names=[f'_view.{name}']),
+    )
+
+
+@ViewFactory.register
+class View(CategoryItem, SwitchableCategoryBase):
+    """Renderer engine selection and view state for a project."""
+
+    _category_code = 'view'
+    _owner_attr_name = 'view'
+    _swap_method_name = '_swap_view'
+
+    type_info = TypeInfo(
+        tag='default',
+        description='Project view category',
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._viewer = Viewer()
+        self._type = StringDescriptor(
+            name='type',
+            description='Structure-view renderer backend type',
+            value_spec=AttributeSpec(
+                default=ViewerEngineEnum.default().value,
+                validator=MembershipValidator(allowed=VIEW_ENGINE_OPTIONS),
+            ),
+            cif_handler=CifHandler(names=['_view.type']),
+        )
+        self._show_labels = BoolDescriptor(
+            name='show_labels',
+            description='Show atom labels when the view opens.',
+            value_spec=AttributeSpec(default=False),
+            cif_handler=CifHandler(names=['_view.show_labels']),
+        )
+        self._show_moments = BoolDescriptor(
+            name='show_moments',
+            description='Show magnetic-moment arrows where the data exists.',
+            value_spec=AttributeSpec(default=True),
+            cif_handler=CifHandler(names=['_view.show_moments']),
+        )
+        self._range_a_min = _range_descriptor('range_a_min', 0.0)
+        self._range_a_max = _range_descriptor('range_a_max', 1.0)
+        self._range_b_min = _range_descriptor('range_b_min', 0.0)
+        self._range_b_max = _range_descriptor('range_b_max', 1.0)
+        self._range_c_min = _range_descriptor('range_c_min', 0.0)
+        self._range_c_max = _range_descriptor('range_c_max', 1.0)
+
+    def _set_type(self, value: str, *, strict: bool = True) -> None:
+        if value not in VIEW_ENGINE_OPTIONS:
+            msg = (
+                f"Unsupported view type '{value}'. Supported: {VIEW_ENGINE_OPTIONS}. "
+                f"For more information, use 'view.show_supported()'"
+            )
+            if strict:
+                raise ValueError(msg)
+            log.warning(msg)
+            return
+        if self._viewer.engine != value:
+            self._viewer.engine = value
+        self._type.value = value
+
+    @staticmethod
+    def _supported_types(filters: dict[str, object]) -> list[tuple[str, str]]:
+        """Return supported structure-view renderer backends."""
+        del filters
+        return ViewerFactory.descriptions()
+
+    @property
+    def viewer(self) -> Viewer:
+        """Live structure-view facade bound to the active engine."""
+        return self._viewer
+
+    @property
+    def show_labels(self) -> BoolDescriptor:
+        """Whether atom labels are shown when the view opens."""
+        return self._show_labels
+
+    @show_labels.setter
+    def show_labels(self, value: bool) -> None:
+        self._show_labels.value = value
+
+    @property
+    def show_moments(self) -> BoolDescriptor:
+        """Whether moment arrows are shown where the data exists."""
+        return self._show_moments
+
+    @show_moments.setter
+    def show_moments(self, value: bool) -> None:
+        self._show_moments.value = value
+
+    def _set_bound(self, descriptor: NumericDescriptor, value: float, *, lower: float, upper: float) -> None:
+        if not lower < value < upper:
+            log.warning(
+                f"'{descriptor.name}' = {value} violates min < max on its axis; ignored.",
+            )
+            return
+        descriptor.value = value
+
+    @property
+    def range_a_min(self) -> NumericDescriptor:
+        """Lower fractional bound along a."""
+        return self._range_a_min
+
+    @range_a_min.setter
+    def range_a_min(self, value: float) -> None:
+        self._set_bound(self._range_a_min, value, lower=float('-inf'), upper=self._range_a_max.value)
+
+    @property
+    def range_a_max(self) -> NumericDescriptor:
+        """Upper fractional bound along a."""
+        return self._range_a_max
+
+    @range_a_max.setter
+    def range_a_max(self, value: float) -> None:
+        self._set_bound(self._range_a_max, value, lower=self._range_a_min.value, upper=float('inf'))
+
+    @property
+    def range_b_min(self) -> NumericDescriptor:
+        """Lower fractional bound along b."""
+        return self._range_b_min
+
+    @range_b_min.setter
+    def range_b_min(self, value: float) -> None:
+        self._set_bound(self._range_b_min, value, lower=float('-inf'), upper=self._range_b_max.value)
+
+    @property
+    def range_b_max(self) -> NumericDescriptor:
+        """Upper fractional bound along b."""
+        return self._range_b_max
+
+    @range_b_max.setter
+    def range_b_max(self, value: float) -> None:
+        self._set_bound(self._range_b_max, value, lower=self._range_b_min.value, upper=float('inf'))
+
+    @property
+    def range_c_min(self) -> NumericDescriptor:
+        """Lower fractional bound along c."""
+        return self._range_c_min
+
+    @range_c_min.setter
+    def range_c_min(self, value: float) -> None:
+        self._set_bound(self._range_c_min, value, lower=float('-inf'), upper=self._range_c_max.value)
+
+    @property
+    def range_c_max(self) -> NumericDescriptor:
+        """Upper fractional bound along c."""
+        return self._range_c_max
+
+    @range_c_max.setter
+    def range_c_max(self, value: float) -> None:
+        self._set_bound(self._range_c_max, value, lower=self._range_c_min.value, upper=float('inf'))
+
+    def view_range(self) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
+        """Assemble the per-axis ``((min, max), ...)`` fractional window."""
+        return (
+            (self._range_a_min.value, self._range_a_max.value),
+            (self._range_b_min.value, self._range_b_max.value),
+            (self._range_c_min.value, self._range_c_max.value),
+        )
+
+    def from_cif(self, block: object, idx: int = 0) -> None:
+        """Populate this view category from a CIF block, rebinding engine."""
+        super().from_cif(block, idx)
+        view_type = read_cif_str(block, '_view.type')
+        if view_type is not None:
+            self._parent._swap_view(view_type, strict=False)
+
+    @property
+    def as_cif(self) -> str:
+        """Return CIF representation of this view category."""
+        return super().as_cif
diff --git a/src/easydiffraction/project/categories/view/factory.py b/src/easydiffraction/project/categories/view/factory.py
new file mode 100644
index 000000000..c9af4aa9b
--- /dev/null
+++ b/src/easydiffraction/project/categories/view/factory.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Factory for project view categories."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from easydiffraction.core.factory import FactoryBase
+
+
+class ViewFactory(FactoryBase):
+    """Create project view category instances."""
+
+    _default_rules: ClassVar[dict] = {
+        frozenset(): 'default',
+    }

From 62d2faf4ed7a83d6a28751c926bcb79dee7abf88 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:46:30 +0200
Subject: [PATCH 013/160] Wire project.view and project.style with CIF
 persistence

---
 .../plans/crysview-structure-visualization.md |  2 +-
 src/easydiffraction/io/cif/serialize.py       |  8 ++++++++
 src/easydiffraction/project/project.py        | 20 +++++++++++++++++++
 src/easydiffraction/project/project_config.py | 16 +++++++++++++++
 4 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 580b61cee..d7b26a497 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -745,7 +745,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Register `View` in `project/categories/view/__init__.py`.
   - Commit: `Add switchable view category for renderer selection`.
 
-- [ ] **P1.10 — Wire `project.view` / `project.style` + CIF
+- [x] **P1.10 — Wire `project.view` / `project.style` + CIF
       persistence**
   - Files: existing `src/easydiffraction/project/project.py`,
     `src/easydiffraction/project/project_config.py` (+ the
diff --git a/src/easydiffraction/io/cif/serialize.py b/src/easydiffraction/io/cif/serialize.py
index e3080aa97..d09236ba4 100644
--- a/src/easydiffraction/io/cif/serialize.py
+++ b/src/easydiffraction/io/cif/serialize.py
@@ -705,6 +705,14 @@ def project_config_from_cif(project: object, cif_text: str) -> None:
     if verbosity is not None:
         verbosity.from_cif(block)
 
+    view = getattr(project, 'view', None)
+    if view is not None:
+        view.from_cif(block)
+
+    style = getattr(project, 'style', None)
+    if style is not None:
+        style.from_cif(block)
+
 
 def analysis_from_cif(analysis: object, cif_text: str) -> None:
     """
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index c1c42eadb..f7e70a397 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -37,8 +37,10 @@
     from collections.abc import Callable
 
     from easydiffraction.project.categories.chart import Chart
+    from easydiffraction.project.categories.style import Style
     from easydiffraction.project.categories.table import Table
     from easydiffraction.project.categories.verbosity import Verbosity
+    from easydiffraction.project.categories.view import View
     from easydiffraction.project.project_info import ProjectInfo
     from easydiffraction.report import Report
 
@@ -210,6 +212,8 @@ def __init__(
         object.__setattr__(self, '_chart', self._config.chart)
         object.__setattr__(self, '_table', self._config.table)
         object.__setattr__(self, '_verbosity', self._config.verbosity)
+        object.__setattr__(self, '_view', self._config.view)
+        object.__setattr__(self, '_style', self._config.style)
         object.__setattr__(self, '_report', self._config.report)
         self._publication = PublicationFactory.create(PublicationFactory.default_tag())
         self._display = ProjectDisplay(self)
@@ -226,6 +230,8 @@ def _attach_category_parents(self) -> None:
         self._analysis._parent = self
         self._chart._parent = self
         self._table._parent = self
+        self._view._parent = self
+        self._style._parent = self
         self._report._parent = self
         self._publication._parent = self
 
@@ -243,6 +249,10 @@ def _swap_table(self, new_type: str, *, strict: bool = True) -> None:
         """Switch the active table renderer."""
         self._table._set_type(new_type, strict=strict)
 
+    def _swap_view(self, new_type: str, *, strict: bool = True) -> None:
+        """Switch the active structure-view renderer."""
+        self._view._set_type(new_type, strict=strict)
+
     @classmethod
     def current_project_path(cls) -> pathlib.Path | None:
         """Return the saved path of the current project, if any."""
@@ -322,6 +332,16 @@ def table(self) -> Table:
         """Table configuration bound to the project."""
         return self._table
 
+    @property
+    def view(self) -> View:
+        """Structure-view configuration bound to the project."""
+        return self._view
+
+    @property
+    def style(self) -> Style:
+        """Structure-view styling bound to the project."""
+        return self._style
+
     @property
     def display(self) -> ProjectDisplay:
         """Current display entry-point bound to the project."""
diff --git a/src/easydiffraction/project/project_config.py b/src/easydiffraction/project/project_config.py
index 2c779c8a7..feff171bc 100644
--- a/src/easydiffraction/project/project_config.py
+++ b/src/easydiffraction/project/project_config.py
@@ -13,8 +13,12 @@
 from easydiffraction.project.categories.report import ReportFactory
 from easydiffraction.project.categories.table import Table
 from easydiffraction.project.categories.table import TableFactory
+from easydiffraction.project.categories.style import Style
+from easydiffraction.project.categories.style import StyleFactory
 from easydiffraction.project.categories.verbosity import Verbosity
 from easydiffraction.project.categories.verbosity import VerbosityFactory
+from easydiffraction.project.categories.view import View
+from easydiffraction.project.categories.view import ViewFactory
 
 
 class ProjectConfig(CategoryOwner):
@@ -37,6 +41,8 @@ def __init__(
         self._report = ReportFactory.create(ReportFactory.default_tag())
         self._table = TableFactory.create(TableFactory.default_tag())
         self._verbosity = VerbosityFactory.create(VerbosityFactory.default_tag())
+        self._view = ViewFactory.create(ViewFactory.default_tag())
+        self._style = StyleFactory.create(StyleFactory.default_tag())
 
     @property
     def info(self) -> ProjectInfo:
@@ -63,6 +69,16 @@ def verbosity(self) -> Verbosity:
         """Verbosity configuration category."""
         return self._verbosity
 
+    @property
+    def view(self) -> View:
+        """Structure-view configuration category."""
+        return self._view
+
+    @property
+    def style(self) -> Style:
+        """Structure-view styling category."""
+        return self._style
+
     @property
     def as_cif(self) -> str:
         """Serialize singleton project categories to CIF."""

From c39bf8f11bd2b7800731e5ad4011f4e01398b76f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:49:10 +0200
Subject: [PATCH 014/160] Add per-structure geom bond-cutoff category

---
 .../plans/crysview-structure-visualization.md |  2 +-
 .../structure/categories/geom/__init__.py     |  4 ++
 .../structure/categories/geom/default.py      | 70 +++++++++++++++++++
 .../structure/categories/geom/factory.py      | 17 +++++
 .../datablocks/structure/item/base.py         | 22 ++++++
 5 files changed, 114 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/datablocks/structure/categories/geom/__init__.py
 create mode 100644 src/easydiffraction/datablocks/structure/categories/geom/default.py
 create mode 100644 src/easydiffraction/datablocks/structure/categories/geom/factory.py

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index d7b26a497..b73209f4b 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -762,7 +762,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     wires the surfaces.
   - Commit: `Wire project.view and project.style with CIF persistence`.
 
-- [ ] **P1.11 — Add the per-structure `geom` bond-cutoff category**
+- [x] **P1.11 — Add the per-structure `geom` bond-cutoff category**
   - Files: new
     `src/easydiffraction/datablocks/structure/categories/geom/__init__.py`,
     `default.py`, `factory.py`; existing
diff --git a/src/easydiffraction/datablocks/structure/categories/geom/__init__.py b/src/easydiffraction/datablocks/structure/categories/geom/__init__.py
new file mode 100644
index 000000000..1fcc34dbf
--- /dev/null
+++ b/src/easydiffraction/datablocks/structure/categories/geom/__init__.py
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+
+from easydiffraction.datablocks.structure.categories.geom.default import Geom
diff --git a/src/easydiffraction/datablocks/structure/categories/geom/default.py b/src/easydiffraction/datablocks/structure/categories/geom/default.py
new file mode 100644
index 000000000..21a491a03
--- /dev/null
+++ b/src/easydiffraction/datablocks/structure/categories/geom/default.py
@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Per-structure bond-generation cutoffs (standard cif_core ``_geom``)."""
+
+from __future__ import annotations
+
+from easydiffraction.core.category import CategoryItem
+from easydiffraction.core.metadata import TypeInfo
+from easydiffraction.core.validation import AttributeSpec
+from easydiffraction.core.validation import RangeValidator
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.datablocks.structure.categories.geom.factory import GeomFactory
+from easydiffraction.io.cif.handler import CifHandler
+
+
+@GeomFactory.register
+class Geom(CategoryItem):
+    """Bond-generation cutoffs for a structure (cif_core ``_geom``)."""
+
+    _category_code = 'geom'
+
+    type_info = TypeInfo(
+        tag='default',
+        description='Structure bond-geometry cutoffs',
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._min_bond_distance_cutoff = NumericDescriptor(
+            name='min_bond_distance_cutoff',
+            description='Minimum permitted bonded distance (angstrom).',
+            value_spec=AttributeSpec(
+                default=0.0,
+                validator=RangeValidator(ge=0.0),
+            ),
+            cif_handler=CifHandler(names=['_geom.min_bond_distance_cutoff']),
+        )
+        self._bond_distance_incr = NumericDescriptor(
+            name='bond_distance_incr',
+            description='Increment added to the summed bonding radii (angstrom).',
+            value_spec=AttributeSpec(
+                default=0.4,
+                validator=RangeValidator(ge=0.0),
+            ),
+            cif_handler=CifHandler(names=['_geom.bond_distance_incr']),
+        )
+
+    @property
+    def min_bond_distance_cutoff(self) -> NumericDescriptor:
+        """Minimum permitted bonded distance (angstrom)."""
+        return self._min_bond_distance_cutoff
+
+    @min_bond_distance_cutoff.setter
+    def min_bond_distance_cutoff(self, value: float) -> None:
+        self._min_bond_distance_cutoff.value = value
+
+    @property
+    def bond_distance_incr(self) -> NumericDescriptor:
+        """Increment added to the summed bonding radii (angstrom)."""
+        return self._bond_distance_incr
+
+    @bond_distance_incr.setter
+    def bond_distance_incr(self, value: float) -> None:
+        self._bond_distance_incr.value = value
+
+    @property
+    def as_cif(self) -> str:
+        """Return CIF representation of this geom category."""
+        return super().as_cif
diff --git a/src/easydiffraction/datablocks/structure/categories/geom/factory.py b/src/easydiffraction/datablocks/structure/categories/geom/factory.py
new file mode 100644
index 000000000..bfc7aaf5c
--- /dev/null
+++ b/src/easydiffraction/datablocks/structure/categories/geom/factory.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Geom factory — delegates entirely to ``FactoryBase``."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from easydiffraction.core.factory import FactoryBase
+
+
+class GeomFactory(FactoryBase):
+    """Create bond-geometry-cutoff categories by tag."""
+
+    _default_rules: ClassVar[dict] = {
+        frozenset(): 'default',
+    }
diff --git a/src/easydiffraction/datablocks/structure/item/base.py b/src/easydiffraction/datablocks/structure/item/base.py
index a7cc24ba4..108c10142 100644
--- a/src/easydiffraction/datablocks/structure/item/base.py
+++ b/src/easydiffraction/datablocks/structure/item/base.py
@@ -15,6 +15,8 @@
 from easydiffraction.datablocks.structure.categories.atom_sites.factory import AtomSitesFactory
 from easydiffraction.datablocks.structure.categories.cell import Cell
 from easydiffraction.datablocks.structure.categories.cell.factory import CellFactory
+from easydiffraction.datablocks.structure.categories.geom import Geom
+from easydiffraction.datablocks.structure.categories.geom.factory import GeomFactory
 from easydiffraction.datablocks.structure.categories.space_group import SpaceGroup
 from easydiffraction.datablocks.structure.categories.space_group.factory import SpaceGroupFactory
 from easydiffraction.utils.logging import console
@@ -39,6 +41,8 @@ def __init__(
         self._atom_sites = AtomSitesFactory.create(self._atom_sites_type)
         self._atom_site_aniso_type: str = AtomSiteAnisoFactory.default_tag()
         self._atom_site_aniso = AtomSiteAnisoFactory.create(self._atom_site_aniso_type)
+        self._geom_type: str = GeomFactory.default_tag()
+        self._geom = GeomFactory.create(self._geom_type)
         self._identity.datablock_entry_name = lambda: self.name
 
     # ------------------------------------------------------------------
@@ -158,6 +162,24 @@ def atom_site_aniso(self, new: AtomSiteAnisoCollection) -> None:
         """
         self._atom_site_aniso = new
 
+    @property
+    def geom(self) -> Geom:
+        """Bond-geometry cutoffs for this structure."""
+        return self._geom
+
+    @geom.setter
+    @typechecked
+    def geom(self, new: Geom) -> None:
+        """
+        Replace the bond-geometry cutoffs for this structure.
+
+        Parameters
+        ----------
+        new : Geom
+            New bond-geometry-cutoff category.
+        """
+        self._geom = new
+
     # ------------------------------------------------------------------
     # Private methods
     # ------------------------------------------------------------------

From 85e9e601714e20728c7854c60295908227613a4d Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:55:27 +0200
Subject: [PATCH 015/160] Align single-crystal scatter axes and style in HTML
 and PDF

---
 .../display/plotters/plotly.py                | 198 ++++++++++++++----
 src/easydiffraction/report/fit_plot.py        |  46 ++--
 .../report/templates/tex/figure_sc.tex.j2     |   5 +-
 3 files changed, 186 insertions(+), 63 deletions(-)

diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index f16437184..f10edd231 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -48,12 +48,19 @@
 RESIDUAL_LINE_WIDTH = 2.0
 MEASURED_MARKER_SIZE = 6
 MEASURED_MARKER_LINE_WIDTH = 0
-MEASURED_ERROR_BAR_THICKNESS = 2
-MEASURED_ERROR_BAR_WIDTH = 4
+SINGLE_CRYSTAL_MARKER_LINE_WIDTH = 0.5
+MEASURED_ERROR_BAR_THICKNESS = 1.0
+MEASURED_ERROR_BAR_WIDTH = 3
 LIGHT_AXIS_FRAME_COLOR = 'rgba(120, 140, 160, 0.28)'
 DARK_AXIS_FRAME_COLOR = 'rgba(110, 145, 190, 0.35)'
 LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
 DARK_LEGEND_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0.5)'
+# Single source for the y=x reference-line colour, shared with the report
+# axis gray (report.style.REPORT_AXIS_RGB) and imported by report.fit_plot
+# so the diagonal looks identical in the Plotly and pgfplots renderers.
+DIAGONAL_LINE_RGB = (190, 199, 208)
+DIAGONAL_LINE_COLOR = f'rgb({DIAGONAL_LINE_RGB[0]}, {DIAGONAL_LINE_RGB[1]}, {DIAGONAL_LINE_RGB[2]})'
+DIAGONAL_LINE_WIDTH = 0.5
 
 BRAGG_TICK_COLORS = (
     'rgb(255, 127, 14)',
@@ -86,6 +93,91 @@
 FIXED_ASPECT_WRAPPER_CLASS_NAME = 'ed-fixed-aspect-plotly-wrapper'
 
 
+def single_crystal_axis_range(
+    x_calc: object,
+    y_meas: object,
+    y_meas_su: object,
+) -> tuple[float, float]:
+    """Return one shared (min, max) range for a single-crystal scatter.
+
+    The range spans the calculated values and the measured values widened
+    by their standard uncertainties, then pads both ends by
+    ``MAIN_INTENSITY_RANGE_MARGIN_FRACTION``. Applying the same range to
+    both axes keeps the y=x diagonal meaningful.
+
+    Parameters
+    ----------
+    x_calc : object
+        1D array-like of calculated values (x-axis).
+    y_meas : object
+        1D array-like of measured values (y-axis).
+    y_meas_su : object
+        1D array-like of measurement uncertainties, or None.
+
+    Returns
+    -------
+    tuple[float, float]
+        The padded ``(minimum, maximum)`` shared by both axes.
+    """
+    calc = [float(value) for value in x_calc]
+    meas = [float(value) for value in y_meas]
+    if y_meas_su is not None:
+        su = [float(value) for value in y_meas_su]
+        low = [value - error for value, error in zip(meas, su, strict=True)]
+        high = [value + error for value, error in zip(meas, su, strict=True)]
+    else:
+        low = meas
+        high = meas
+    candidates_low = [*calc, *low]
+    candidates_high = [*calc, *high]
+    if not candidates_low or not candidates_high:
+        return 0.0, 1.0
+    minimum = min(candidates_low)
+    maximum = max(candidates_high)
+    margin = max(maximum - minimum, 0.0) * MAIN_INTENSITY_RANGE_MARGIN_FRACTION
+    if margin <= 0.0:
+        margin = 1.0
+    return minimum - margin, maximum + margin
+
+
+def single_crystal_tick_step(
+    minimum: float,
+    maximum: float,
+    target_ticks: int = 6,
+) -> float:
+    """Return a 'nice' tick step covering ``[minimum, maximum]``.
+
+    The raw step ``span / target_ticks`` is rounded up to the nearest
+    ``DISPLAY_TICK_FRACTIONS`` value, so two axes sharing this step and the
+    same range show identical ticks.
+
+    Parameters
+    ----------
+    minimum : float
+        Lower bound of the shared axis range.
+    maximum : float
+        Upper bound of the shared axis range.
+    target_ticks : int, default=6
+        Approximate number of tick intervals to aim for.
+
+    Returns
+    -------
+    float
+        The rounded tick step.
+    """
+    span = maximum - minimum
+    if span <= 0.0 or target_ticks <= 0:
+        return 1.0
+    raw_step = span / target_ticks
+    exponent = float(np.floor(np.log10(raw_step)))
+    base = 10.0**exponent
+    fraction = raw_step / base
+    for nice_fraction in DISPLAY_TICK_FRACTIONS:
+        if fraction <= nice_fraction:
+            return nice_fraction * base
+    return DISPLAY_TICK_FRACTIONS[-1] * base
+
+
 @dataclass(frozen=True)
 class PowderCompositeRows:
     """Resolved row layout for the composite powder figure."""
@@ -559,41 +651,52 @@ def _get_single_crystal_trace(
             mode='markers',
             marker={
                 'symbol': 'circle',
-                'size': 10,
-                'line': {'width': 0.5},
+                'size': MEASURED_MARKER_SIZE,
+                'line': {'width': SINGLE_CRYSTAL_MARKER_LINE_WIDTH},
                 'color': DEFAULT_COLORS['meas'],
             },
             error_y={
                 'type': 'data',
                 'array': y_meas_su,
                 'visible': True,
+                'color': DEFAULT_COLORS['meas'],
+                'thickness': MEASURED_ERROR_BAR_THICKNESS,
+                'width': MEASURED_ERROR_BAR_WIDTH,
             },
             hovertemplate='calc: %{x}<br>meas: %{y}<br><extra></extra>',
         )
 
     @staticmethod
-    def _get_diagonal_shape() -> dict:
+    def _get_diagonal_shape(minimum: float, maximum: float) -> dict:
         """
-        Create a diagonal reference line shape.
+        Create a y=x reference line in data coordinates.
+
+        The line runs from ``(minimum, minimum)`` to ``(maximum, maximum)``
+        in axis (data) coordinates, so it tracks y=x regardless of the
+        axis aspect ratio rather than the paper-rectangle diagonal.
 
-        Returns a y=x diagonal line spanning the plot area using paper
-        coordinates (0,0) to (1,1).
+        Parameters
+        ----------
+        minimum : float
+            Lower bound of the shared axis range.
+        maximum : float
+            Upper bound of the shared axis range.
 
         Returns
         -------
         dict
-            A dict configuring a diagonal line shape.
+            A dict configuring the diagonal line shape.
         """
         return {
             'type': 'line',
-            'x0': 0,
-            'y0': 0,
-            'x1': 1,
-            'y1': 1,
-            'xref': 'paper',
-            'yref': 'paper',
+            'x0': minimum,
+            'y0': minimum,
+            'x1': maximum,
+            'y1': maximum,
+            'xref': 'x',
+            'yref': 'y',
             'layer': 'below',
-            'line': {'width': 0.5},
+            'line': {'color': DIAGONAL_LINE_COLOR, 'width': DIAGONAL_LINE_WIDTH},
         }
 
     @staticmethod
@@ -1055,6 +1158,9 @@ def _get_layout(
         title: str,
         axes_labels: object,
         shapes: list | None = None,
+        *,
+        axis_range: tuple[float, float] | None = None,
+        axis_dtick: float | None = None,
     ) -> object:
         """
         Create a Plotly layout configuration.
@@ -1067,12 +1173,44 @@ def _get_layout(
             Pair of strings for the x and y titles.
         shapes : list | None, default=None
             Optional list of shape dicts to overlay on the plot.
+        axis_range : tuple[float, float] | None, default=None
+            When given, the same explicit range applied to both axes.
+        axis_dtick : float | None, default=None
+            When given, the same tick step applied to both axes, so the
+            x and y ticks match.
 
         Returns
         -------
         object
             A configured :class:`plotly.graph_objects.Layout`.
         """
+        xaxis = {
+            'title': {
+                'text': axes_labels[0],
+                'font': {'size': AXIS_TITLE_FONT_SIZE},
+            },
+            'showline': True,
+            'linecolor': cls._axis_frame_color(),
+            'mirror': True,
+            'zeroline': False,
+        }
+        yaxis = {
+            'title': {
+                'text': axes_labels[1],
+                'font': {'size': AXIS_TITLE_FONT_SIZE},
+            },
+            'showline': True,
+            'linecolor': cls._axis_frame_color(),
+            'mirror': True,
+            'zeroline': False,
+        }
+        if axis_range is not None:
+            for axis in (xaxis, yaxis):
+                axis['range'] = list(axis_range)
+                axis['tick0'] = axis_range[0]
+        if axis_dtick is not None:
+            for axis in (xaxis, yaxis):
+                axis['dtick'] = axis_dtick
         return go.Layout(
             margin={
                 'autoexpand': True,
@@ -1091,26 +1229,8 @@ def _get_layout(
                 'yanchor': 'top',
                 'y': 1.0,
             },
-            xaxis={
-                'title': {
-                    'text': axes_labels[0],
-                    'font': {'size': AXIS_TITLE_FONT_SIZE},
-                },
-                'showline': True,
-                'linecolor': cls._axis_frame_color(),
-                'mirror': True,
-                'zeroline': False,
-            },
-            yaxis={
-                'title': {
-                    'text': axes_labels[1],
-                    'font': {'size': AXIS_TITLE_FONT_SIZE},
-                },
-                'showline': True,
-                'linecolor': cls._axis_frame_color(),
-                'mirror': True,
-                'zeroline': False,
-            },
+            xaxis=xaxis,
+            yaxis=yaxis,
             shapes=shapes,
         )
 
@@ -1955,10 +2075,14 @@ def build_single_crystal_figure(
             )
         ]
 
+        axis_min, axis_max = single_crystal_axis_range(x_calc, y_meas, y_meas_su)
+        tick_step = single_crystal_tick_step(axis_min, axis_max)
         layout = self._get_layout(
             title,
             axes_labels,
-            shapes=[self._get_diagonal_shape()],
+            shapes=[self._get_diagonal_shape(axis_min, axis_max)],
+            axis_range=(axis_min, axis_max),
+            axis_dtick=tick_step,
         )
 
         return self._get_figure(data, layout)
diff --git a/src/easydiffraction/report/fit_plot.py b/src/easydiffraction/report/fit_plot.py
index fca30f9ad..3d1d370d6 100644
--- a/src/easydiffraction/report/fit_plot.py
+++ b/src/easydiffraction/report/fit_plot.py
@@ -21,11 +21,14 @@
 from easydiffraction.display.plotters.plotly import COMPOSITE_MARGIN_TOP
 from easydiffraction.display.plotters.plotly import COMPOSITE_VERTICAL_SPACING
 from easydiffraction.display.plotters.plotly import DEFAULT_COLORS
+from easydiffraction.display.plotters.plotly import DIAGONAL_LINE_RGB
 from easydiffraction.display.plotters.plotly import DISPLAY_TICK_FRACTIONS
 from easydiffraction.display.plotters.plotly import MAIN_INTENSITY_RANGE_MARGIN_FRACTION
 from easydiffraction.display.plotters.plotly import MEASURED_LINE_WIDTH
 from easydiffraction.display.plotters.plotly import PLOTLY_HEIGHT_PER_UNIT
 from easydiffraction.display.plotters.plotly import RESIDUAL_LINE_WIDTH
+from easydiffraction.display.plotters.plotly import single_crystal_axis_range
+from easydiffraction.display.plotters.plotly import single_crystal_tick_step
 from easydiffraction.display.plotting import DEFAULT_RESIDUAL_HEIGHT_FRACTION
 from easydiffraction.report.style import REPORT_AXIS_RGB
 from easydiffraction.report.style import REPORT_CHART_GRID_RGB
@@ -148,6 +151,7 @@ def fit_plot_axis_styles() -> dict[str, str]:
     return {
         'axis_rgb': _style_rgb_channels(REPORT_AXIS_RGB),
         'grid_rgb': _style_rgb_channels(REPORT_CHART_GRID_RGB),
+        'diag_rgb': _style_rgb_channels(DIAGONAL_LINE_RGB),
     }
 
 
@@ -160,28 +164,28 @@ def fit_scatter_geometry() -> dict[str, float]:
 
 
 def fit_scatter_ranges(fit_data: dict[str, Any]) -> dict[str, float]:
-    """Return x/y ranges and the y=x diagonal span for an SC scatter."""
+    """Return the shared x/y range, tick step, and y=x diagonal span.
+
+    The x and y axes share one range (computed across the calculated
+    values and the measured values widened by their uncertainties) so the
+    diagonal is a true y=x line and the ticks can match.
+    """
     x_values = _numeric_values(fit_data['x']['values'])
     meas = fit_data['series']['meas']
     y_values = _numeric_values(meas['values'])
     su = meas.get('su')
-    if su is not None:
-        su_values = _numeric_values(su)
-        y_low = [value - error for value, error in zip(y_values, su_values, strict=True)]
-        y_high = [value + error for value, error in zip(y_values, su_values, strict=True)]
-    else:
-        y_low = y_values
-        y_high = y_values
-
-    x_min, x_max = _padded_range(*_data_range([x_values]))
-    y_min, y_max = _padded_range(*_data_range([y_low, y_high]))
+    su_values = _numeric_values(su) if su is not None else None
+
+    axis_min, axis_max = single_crystal_axis_range(x_values, y_values, su_values)
+    tick_step = single_crystal_tick_step(axis_min, axis_max)
     return {
-        'x_min': x_min,
-        'x_max': x_max,
-        'y_min': y_min,
-        'y_max': y_max,
-        'diag_min': min(x_min, y_min),
-        'diag_max': max(x_max, y_max),
+        'x_min': axis_min,
+        'x_max': axis_max,
+        'y_min': axis_min,
+        'y_max': axis_max,
+        'diag_min': axis_min,
+        'diag_max': axis_max,
+        'tick_step': tick_step,
     }
 
 
@@ -296,14 +300,6 @@ def _style_rgb_channels(rgb: tuple[int, int, int]) -> str:
     return ','.join(str(channel) for channel in rgb)
 
 
-def _padded_range(minimum: float, maximum: float) -> tuple[float, float]:
-    """Return a range padded by the main-intensity margin fraction."""
-    margin = max(maximum - minimum, 0.0) * MAIN_INTENSITY_RANGE_MARGIN_FRACTION
-    if margin <= 0.0:
-        margin = 1.0
-    return minimum - margin, maximum + margin
-
-
 def _data_range(series_list: list[list[float]]) -> tuple[float, float]:
     values = [value for series in series_list for value in series]
     if not values:
diff --git a/src/easydiffraction/report/templates/tex/figure_sc.tex.j2 b/src/easydiffraction/report/templates/tex/figure_sc.tex.j2
index 8d6d1b169..2e2d0dfac 100644
--- a/src/easydiffraction/report/templates/tex/figure_sc.tex.j2
+++ b/src/easydiffraction/report/templates/tex/figure_sc.tex.j2
@@ -9,6 +9,7 @@
 \definecolor{ {{- style.color_name -}} }{RGB}{ {{- style.rgb -}} }
 \definecolor{edAxis}{RGB}{ {{- axis_styles.axis_rgb -}} }
 \definecolor{edGrid}{RGB}{ {{- axis_styles.grid_rgb -}} }
+\definecolor{edDiag}{RGB}{ {{- axis_styles.diag_rgb -}} }
 {% set axes_labels = fit_data.axes_labels | default(["Icalc", "Imeas"], true) -%}
 {% set x_label = axes_labels[0] | tex_axis_label -%}
 {% set y_label = axes_labels[1] | tex_axis_label -%}
@@ -22,6 +23,8 @@ xmin={{ ranges.x_min | tex_number }},
 xmax={{ ranges.x_max | tex_number }},
 ymin={{ ranges.y_min | tex_number }},
 ymax={{ ranges.y_max | tex_number }},
+xtick distance={{ ranges.tick_step | tex_number }},
+ytick distance={{ ranges.tick_step | tex_number }},
 xlabel={ {{ x_label }} },
 ylabel={ {{ y_label }} },
 axis line style={draw=edAxis},
@@ -32,7 +35,7 @@ major grid style={draw=edGrid, line width=0.4pt},
 xmajorgrids=true,
 ymajorgrids=true,
 ]
-\addplot[domain={{ ranges.diag_min | tex_number }}:{{ ranges.diag_max | tex_number }}, samples=2, color=edAxis, line width=0.4pt, forget plot] {x};
+\addplot[domain={{ ranges.diag_min | tex_number }}:{{ ranges.diag_max | tex_number }}, samples=2, color=edDiag, line width=0.4pt, forget plot] {x};
 \addplot[only marks, mark=*, mark size={{ style.marker_size_pt | tex_number }}pt, color={{ style.color_name }}, mark options={fill={{ style.color_name }}, draw={{ style.color_name }}, line width={{ style.marker_line_width_pt | tex_number }}pt}, error bars/.cd, y dir=both, y explicit] table[x={ {{- fit_csv.x -}} }, y={ {{- fit_csv.meas -}} }, y error={ {{- fit_csv.meas_su -}} }, col sep=comma] { {{- csv_filename -}} };
 \end{axis}
 \end{tikzpicture}

From f86f169395417abddbf4819819ddb0a194692863 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 09:58:28 +0200
Subject: [PATCH 016/160] Add structure() and show_structure_options() display
 surface

---
 .../plans/crysview-structure-visualization.md |   2 +-
 src/easydiffraction/project/display.py        | 161 ++++++++++++++++++
 2 files changed, 162 insertions(+), 1 deletion(-)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index b73209f4b..01d413392 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -792,7 +792,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     angle/contact cutoffs are deferred (ADR Deferred Work).
   - Commit: `Add per-structure geom bond-cutoff category`.
 
-- [ ] **P1.12 — Add `display.structure()` + `show_structure_options()`**
+- [x] **P1.12 — Add `display.structure()` + `show_structure_options()`**
   - Files: existing `src/easydiffraction/project/display.py`.
   - Add to the class backing `project.display` (owner of `pattern()` /
     `show_pattern_options()`):
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index fb5983d8c..461797a0c 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -39,6 +39,17 @@
 }
 
 
+_STRUCTURE_OPTION_DESCRIPTIONS: dict[str, str] = {
+    'auto': 'Show the features the structure and engine support.',
+    'atoms': 'Atoms as spheres, occupancy wedges, or ADP ellipsoids.',
+    'bonds': 'Bonds between atoms within the per-structure cutoffs.',
+    'cell': 'Unit-cell edges.',
+    'axes': 'The a/b/c axis triad.',
+    'moments': 'Magnetic-moment arrows (no moment data in version 1).',
+    'labels': 'Atom labels at each site.',
+}
+
+
 @dataclass(frozen=True, slots=True)
 class PatternOptionStatus:
     """Availability metadata for one ``display.pattern`` option."""
@@ -459,6 +470,156 @@ def show_pattern_options(self, expt_name: str) -> None:
             ],
         )
 
+    def structure(
+        self,
+        struct_name: str,
+        include: str | tuple[str, ...] = 'auto',
+        range: tuple[tuple[float, float], tuple[float, float], tuple[float, float]] | None = None,
+        path: str | None = None,
+    ) -> None:
+        """
+        Show a 3D structure view for one structure.
+
+        Parallels :meth:`pattern`: it draws with the active
+        ``project.view`` engine and displays directly (no return value).
+        Feature visibility is resolved per ADR section 8; the renderer
+        announces and skips any feature it cannot draw.
+
+        Parameters
+        ----------
+        struct_name : str
+            Name of the structure to draw.
+        include : str | tuple[str, ...]
+            ``'auto'`` (default) resolves features from data availability,
+            persisted ``project.view`` flags, then built-in defaults; an
+            explicit tuple of ``atoms``/``bonds``/``cell``/``axes``/
+            ``moments``/``labels`` wins outright.
+        range : tuple | None
+            Optional per-axis ``((min, max), ...)`` window overriding the
+            persisted ``project.view`` range for this call only.
+        path : str | None
+            When given, write the rendered view to this path instead of
+            displaying it (a standalone HTML file for the Three.js engine).
+        """
+        from easydiffraction.display.structure.builder import build_scene  # noqa: PLC0415
+        from easydiffraction.display.structure.builder import (  # noqa: PLC0415
+            structure_feature_availability,
+        )
+
+        structure = self._project.structures[struct_name]
+        availability = structure_feature_availability(structure, style=self._project.style)
+        features = self._resolve_structure_features(include, availability)
+        window = range if range is not None else self._project.view.view_range()
+        scene = build_scene(
+            structure,
+            style=self._project.style,
+            view_range=window,
+            features=features,
+        )
+        output = self._project.view.viewer.render(scene, features=features)
+        if path is not None:
+            import pathlib  # noqa: PLC0415
+
+            pathlib.Path(path).write_text(output)
+            return
+        self._emit_structure_output(output)
+
+    def show_structure_options(self, struct_name: str) -> None:
+        """Show available ``structure(include=...)`` options with reasons."""
+        from easydiffraction.display.structure.builder import (  # noqa: PLC0415
+            structure_feature_availability,
+        )
+
+        structure = self._project.structures[struct_name]
+        availability = structure_feature_availability(structure, style=self._project.style)
+        supported = self._project.view.viewer.supported_features()
+        auto = self._resolve_structure_features('auto', availability)
+
+        rows = []
+        for option in ('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'):
+            in_data = option in availability.available
+            in_engine = option in supported
+            reason = self._structure_option_reason(option, in_data=in_data, in_engine=in_engine)
+            rows.append([
+                option,
+                _STRUCTURE_OPTION_DESCRIPTIONS[option],
+                'yes' if (in_data and in_engine) else 'no',
+                'yes' if (option in auto and in_engine) else 'no',
+                reason or '-',
+            ])
+        render_table(
+            columns_headers=['Option', 'Description', 'Available', 'Auto', 'Reason'],
+            columns_alignment=['left', 'left', 'center', 'center', 'left'],
+            columns_data=rows,
+        )
+        if availability.radius_substitutions:
+            console.paragraph('Radius substitutions (fell back to covalent)')
+            console.print(', '.join(availability.radius_substitutions))
+
+    def _resolve_structure_features(
+        self,
+        include: str | tuple[str, ...],
+        availability: object,
+    ) -> frozenset[str]:
+        """Resolve the concrete feature set per ADR section 8 precedence."""
+        normalized = self._normalize_structure_include(include)
+        if normalized != ('auto',):
+            return frozenset(normalized)
+        view = self._project.view
+        resolved = {f for f in ('atoms', 'bonds', 'cell', 'axes') if f in availability.available}
+        if 'labels' in availability.available and view.show_labels.value:
+            resolved.add('labels')
+        if 'moments' in availability.available and view.show_moments.value:
+            resolved.add('moments')
+        return frozenset(resolved)
+
+    @staticmethod
+    def _normalize_structure_include(include: str | tuple[str, ...]) -> tuple[str, ...]:
+        """Validate and normalize a ``structure(include=...)`` value."""
+        values = (include,) if isinstance(include, str) else include
+        if not values:
+            msg = 'include must contain at least one option.'
+            raise ValueError(msg)
+        normalized = tuple(dict.fromkeys(values))
+        unknown = [value for value in normalized if value not in _STRUCTURE_OPTION_DESCRIPTIONS]
+        if unknown:
+            msg = f'Unknown structure include option(s): {unknown}.'
+            raise ValueError(msg)
+        if 'auto' in normalized and len(normalized) > 1:
+            msg = "include='auto' cannot be combined with other options."
+            raise ValueError(msg)
+        return normalized
+
+    @staticmethod
+    def _structure_option_reason(option: str, *, in_data: bool, in_engine: bool) -> str:
+        """Explain why a structure option is unavailable, if it is."""
+        if not in_engine:
+            return 'Shown only by the 3D engines.'
+        if not in_data:
+            if option == 'moments':
+                return 'No moment data in version 1.'
+            return 'No data for this structure.'
+        return ''
+
+    def _emit_structure_output(self, output: str) -> None:
+        """Display ASCII text in the console or HTML in a notebook."""
+        from easydiffraction.display.structure.enums import ViewerEngineEnum  # noqa: PLC0415
+        from easydiffraction.utils.environment import in_jupyter  # noqa: PLC0415
+
+        if self._project.view.type == ViewerEngineEnum.ASCII.value:
+            console.print(output)
+            return
+        if in_jupyter():
+            from IPython.display import HTML  # noqa: PLC0415
+            from IPython.display import display  # noqa: PLC0415
+
+            display(HTML(output))
+            return
+        console.print(
+            'Three.js structure view generated as HTML. Pass path=... to save it, '
+            "or set project.view.type = 'ascii' for a terminal view.",
+        )
+
     @staticmethod
     def _normalize_include(include: str | tuple[str, ...]) -> tuple[str, ...]:
         """Validate and normalize a ``pattern(include=...)`` value."""

From 956fc0b9cb09297763d67eb43d3582c448cd43b6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:00:45 +0200
Subject: [PATCH 017/160] Add tests for single-crystal scatter range, ticks,
 and diagonal

Cover the new single_crystal_axis_range / single_crystal_tick_step
helpers, the data-coordinate diagonal and smaller markers/error bars in
the Plotly trace, and the shared x/y range, tick step, and diagonal
colour in the report fit-plot context.
---
 .../display/plotters/test_plotly.py           | 50 +++++++++++++++++--
 .../easydiffraction/report/test_fit_plot.py   | 27 ++++++++++
 2 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 35fd5f2b8..6384bd821 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -350,12 +350,19 @@ def __init__(self, html):
     assert trace.kwargs['y'] == y_meas
     assert trace.kwargs['mode'] == 'markers'
     assert 'error_y' in trace.kwargs
+    assert trace.kwargs['marker']['size'] == pp.MEASURED_MARKER_SIZE
+    assert trace.kwargs['error_y']['thickness'] == pp.MEASURED_ERROR_BAR_THICKNESS
+    assert trace.kwargs['error_y']['width'] == pp.MEASURED_ERROR_BAR_WIDTH
 
-    # Exercise _get_diagonal_shape
-    shape = plotter._get_diagonal_shape()
+    # Exercise _get_diagonal_shape (now a data-coordinate y=x line)
+    shape = plotter._get_diagonal_shape(0.0, 10.0)
     assert shape['type'] == 'line'
-    assert shape['xref'] == 'paper'
-    assert shape['yref'] == 'paper'
+    assert shape['xref'] == 'x'
+    assert shape['yref'] == 'y'
+    assert (shape['x0'], shape['y0']) == (0.0, 0.0)
+    assert (shape['x1'], shape['y1']) == (10.0, 10.0)
+    assert shape['line']['color'] == pp.DIAGONAL_LINE_COLOR
+    assert shape['line']['width'] == pp.DIAGONAL_LINE_WIDTH
 
     # Exercise plot_single_crystal
     plotter.plot_single_crystal(
@@ -370,6 +377,41 @@ def __init__(self, html):
     assert dummy_display_calls['count'] == 1 or shown['count'] == 1
 
 
+def test_single_crystal_axis_range_unions_calc_and_meas_with_uncertainty():
+    import easydiffraction.display.plotters.plotly as pp
+
+    minimum, maximum = pp.single_crystal_axis_range(
+        x_calc=[2.0, 8.0],
+        y_meas=[1.0, 10.0],
+        y_meas_su=[0.5, 1.0],
+    )
+    # Spans meas-su minimum (0.5) to meas+su maximum (11.0); calc 2..8 is
+    # inside. A 5% margin of the 10.5 span pads both ends symmetrically.
+    assert minimum == pytest.approx(0.5 - 0.525)
+    assert maximum == pytest.approx(11.0 + 0.525)
+
+
+def test_single_crystal_axis_range_handles_missing_uncertainty():
+    import easydiffraction.display.plotters.plotly as pp
+
+    minimum, maximum = pp.single_crystal_axis_range(
+        x_calc=[0.0, 4.0],
+        y_meas=[1.0, 3.0],
+        y_meas_su=None,
+    )
+    assert minimum < 0.0
+    assert maximum > 4.0
+
+
+def test_single_crystal_tick_step_rounds_to_nice_value():
+    import easydiffraction.display.plotters.plotly as pp
+
+    # Span 3000 over ~6 intervals -> raw 500 -> nice 500.
+    assert pp.single_crystal_tick_step(0.0, 3000.0) == pytest.approx(500.0)
+    # Degenerate span falls back to 1.0.
+    assert pp.single_crystal_tick_step(5.0, 5.0) == pytest.approx(1.0)
+
+
 def test_get_bragg_tick_trace_includes_peak_metadata():
     from easydiffraction.display.plotters.base import BraggTickSet
     from easydiffraction.display.plotters.plotly import PlotlyPlotter
diff --git a/tests/unit/easydiffraction/report/test_fit_plot.py b/tests/unit/easydiffraction/report/test_fit_plot.py
index c041f1948..0a231f1a8 100644
--- a/tests/unit/easydiffraction/report/test_fit_plot.py
+++ b/tests/unit/easydiffraction/report/test_fit_plot.py
@@ -45,3 +45,30 @@ def test_fit_plot_ranges_match_plotly_main_intensity_margin():
     assert ranges['y_max'] == pytest.approx(31.25)
     assert ranges['residual_y_min'] == pytest.approx(-3.4375)
     assert ranges['residual_y_max'] == pytest.approx(3.4375)
+
+
+def test_fit_scatter_ranges_share_one_range_and_add_tick_step():
+    from easydiffraction.report.fit_plot import fit_scatter_ranges
+
+    fit_data = {
+        'x': {'values': [10.0, 90.0]},
+        'series': {'meas': {'values': [0.0, 80.0], 'su': [5.0, 5.0]}},
+    }
+
+    ranges = fit_scatter_ranges(fit_data)
+
+    # x and y share one range (so the diagonal is a true y=x line), and it
+    # unions calc (10..90) with meas +/- su (-5..85), padded both ends.
+    assert ranges['x_min'] == ranges['y_min'] == ranges['diag_min']
+    assert ranges['x_max'] == ranges['y_max'] == ranges['diag_max']
+    assert ranges['x_min'] < -5.0
+    assert ranges['x_max'] > 90.0
+    assert ranges['tick_step'] > 0.0
+
+
+def test_fit_plot_axis_styles_expose_shared_diagonal_color():
+    from easydiffraction.report.fit_plot import fit_plot_axis_styles
+
+    styles = fit_plot_axis_styles()
+
+    assert styles['diag_rgb'] == '190,199,208'

From 29860384503552bb422e8f72db261ecefaccfb6b Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:01:01 +0200
Subject: [PATCH 018/160] Vendor pinned Three.js assets

---
 THIRD_PARTY_LICENSES.md                       |    12 +
 .../plans/crysview-structure-visualization.md |     2 +-
 pyproject.toml                                |     7 +-
 .../renderers/vendor/threejs/CSS2DRenderer.js |   215 +
 .../renderers/vendor/threejs/LICENSES.md      |    21 +
 .../renderers/vendor/threejs/OrbitControls.js |  1417 +
 .../renderers/vendor/threejs/three.module.js  | 53044 ++++++++++++++++
 7 files changed, 54715 insertions(+), 3 deletions(-)
 create mode 100644 src/easydiffraction/display/structure/renderers/vendor/threejs/CSS2DRenderer.js
 create mode 100644 src/easydiffraction/display/structure/renderers/vendor/threejs/LICENSES.md
 create mode 100644 src/easydiffraction/display/structure/renderers/vendor/threejs/OrbitControls.js
 create mode 100644 src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js

diff --git a/THIRD_PARTY_LICENSES.md b/THIRD_PARTY_LICENSES.md
index ceb7fcf87..96e7c70ec 100644
--- a/THIRD_PARTY_LICENSES.md
+++ b/THIRD_PARTY_LICENSES.md
@@ -11,3 +11,15 @@ The vendored report LaTeX style files are documented in
 
 The vendored report HTML assets are documented in
 `src/easydiffraction/report/templates/html/vendor/LICENSES.md`.
+
+## Structure-View Three.js
+
+The vendored Three.js assets for the crysview structure view (MIT) are
+documented in
+`src/easydiffraction/display/structure/renderers/vendor/threejs/LICENSES.md`.
+
+## Structure-View Element Data
+
+The bundled per-element radii and colour palettes (with per-source
+provenance) are documented in
+`src/easydiffraction/display/structure/assets/LICENSES.md`.
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 01d413392..3271591aa 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -849,7 +849,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Commit:
     `Add structure() and show_structure_options() display surface`.
 
-- [ ] **P1.13 — Vendor pinned Three.js assets + lint/coverage excludes**
+- [x] **P1.13 — Vendor pinned Three.js assets + lint/coverage excludes**
   - Files: new
     `src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js`,
     `OrbitControls.js`, `CSS2DRenderer.js`, and a sibling `LICENSES.md`;
diff --git a/pyproject.toml b/pyproject.toml
index e981ff879..f069fac3c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -157,6 +157,7 @@ exclude = [
   'src/easydiffraction/report/templates/html/vendor',
   'src/easydiffraction/report/templates/tex/styles',
   'src/easydiffraction/utils/_vendored/jupyter_dark_detect',
+  'src/easydiffraction/display/structure/renderers/vendor',
 ]
 
 #######################################
@@ -175,6 +176,7 @@ omit = [
   'src/easydiffraction/report/templates/html/vendor/*',
   'src/easydiffraction/report/templates/tex/styles/*',
   'src/easydiffraction/utils/_vendored/jupyter_dark_detect/*',
+  'src/easydiffraction/display/structure/renderers/vendor/*',
 ]
 
 [tool.coverage.report]
@@ -217,6 +219,7 @@ exclude = [
   'src/easydiffraction/report/templates/html/vendor',
   'src/easydiffraction/report/templates/tex/styles',
   'src/easydiffraction/utils/_vendored/jupyter_dark_detect',
+  'src/easydiffraction/display/structure/renderers/vendor',
 ]
 indent-width = 4
 line-length = 99 # See also `max-line-length` in [tool.ruff.lint.pycodestyle]
@@ -403,7 +406,7 @@ max-positional-args = 7
 [tool.pydoclint]
 #exclude = '\.' # Temporarily disable pydoclint until we are ready
 # ED only.
-exclude = 'src/easydiffraction/(report/templates/html/vendor|report/templates/tex/styles|utils/_vendored/jupyter_dark_detect)'
+exclude = 'src/easydiffraction/(report/templates/html/vendor|report/templates/tex/styles|utils/_vendored/jupyter_dark_detect|display/structure/renderers/vendor)'
 style = 'numpy'
 check-style-mismatch = true
 check-arg-defaults = true
@@ -419,7 +422,7 @@ allow-init-docstring = true
 [tool.format_docstring]
 #exclude = '\.' # Temporarily disable format-docstring until we are ready
 # ED only.
-exclude = 'src/easydiffraction/(report/templates/html/vendor|report/templates/tex/styles|utils/_vendored/jupyter_dark_detect)'
+exclude = 'src/easydiffraction/(report/templates/html/vendor|report/templates/tex/styles|utils/_vendored/jupyter_dark_detect|display/structure/renderers/vendor)'
 docstring_style = 'numpy'
 line_length = 72
 fix_rst_backticks = true
diff --git a/src/easydiffraction/display/structure/renderers/vendor/threejs/CSS2DRenderer.js b/src/easydiffraction/display/structure/renderers/vendor/threejs/CSS2DRenderer.js
new file mode 100644
index 000000000..6d67931b9
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/vendor/threejs/CSS2DRenderer.js
@@ -0,0 +1,215 @@
+import {
+	Matrix4,
+	Object3D,
+	Vector2,
+	Vector3
+} from 'three';
+
+class CSS2DObject extends Object3D {
+
+	constructor( element = document.createElement( 'div' ) ) {
+
+		super();
+
+		this.isCSS2DObject = true;
+
+		this.element = element;
+
+		this.element.style.position = 'absolute';
+		this.element.style.userSelect = 'none';
+
+		this.element.setAttribute( 'draggable', false );
+
+		this.center = new Vector2( 0.5, 0.5 ); // ( 0, 0 ) is the lower left; ( 1, 1 ) is the top right
+
+		this.addEventListener( 'removed', function () {
+
+			this.traverse( function ( object ) {
+
+				if ( object.element instanceof Element && object.element.parentNode !== null ) {
+
+					object.element.parentNode.removeChild( object.element );
+
+				}
+
+			} );
+
+		} );
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.element = source.element.cloneNode( true );
+
+		this.center = source.center;
+
+		return this;
+
+	}
+
+}
+
+//
+
+const _vector = new Vector3();
+const _viewMatrix = new Matrix4();
+const _viewProjectionMatrix = new Matrix4();
+const _a = new Vector3();
+const _b = new Vector3();
+
+class CSS2DRenderer {
+
+	constructor( parameters = {} ) {
+
+		const _this = this;
+
+		let _width, _height;
+		let _widthHalf, _heightHalf;
+
+		const cache = {
+			objects: new WeakMap()
+		};
+
+		const domElement = parameters.element !== undefined ? parameters.element : document.createElement( 'div' );
+
+		domElement.style.overflow = 'hidden';
+
+		this.domElement = domElement;
+
+		this.getSize = function () {
+
+			return {
+				width: _width,
+				height: _height
+			};
+
+		};
+
+		this.render = function ( scene, camera ) {
+
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+
+			_viewMatrix.copy( camera.matrixWorldInverse );
+			_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
+
+			renderObject( scene, scene, camera );
+			zOrder( scene );
+
+		};
+
+		this.setSize = function ( width, height ) {
+
+			_width = width;
+			_height = height;
+
+			_widthHalf = _width / 2;
+			_heightHalf = _height / 2;
+
+			domElement.style.width = width + 'px';
+			domElement.style.height = height + 'px';
+
+		};
+
+		function renderObject( object, scene, camera ) {
+
+			if ( object.isCSS2DObject ) {
+
+				_vector.setFromMatrixPosition( object.matrixWorld );
+				_vector.applyMatrix4( _viewProjectionMatrix );
+
+				const visible = ( object.visible === true ) && ( _vector.z >= - 1 && _vector.z <= 1 ) && ( object.layers.test( camera.layers ) === true );
+				object.element.style.display = ( visible === true ) ? '' : 'none';
+
+				if ( visible === true ) {
+
+					object.onBeforeRender( _this, scene, camera );
+
+					const element = object.element;
+
+					element.style.transform = 'translate(' + ( - 100 * object.center.x ) + '%,' + ( - 100 * object.center.y ) + '%)' + 'translate(' + ( _vector.x * _widthHalf + _widthHalf ) + 'px,' + ( - _vector.y * _heightHalf + _heightHalf ) + 'px)';
+
+					if ( element.parentNode !== domElement ) {
+
+						domElement.appendChild( element );
+
+					}
+
+					object.onAfterRender( _this, scene, camera );
+
+				}
+
+				const objectData = {
+					distanceToCameraSquared: getDistanceToSquared( camera, object )
+				};
+
+				cache.objects.set( object, objectData );
+
+			}
+
+			for ( let i = 0, l = object.children.length; i < l; i ++ ) {
+
+				renderObject( object.children[ i ], scene, camera );
+
+			}
+
+		}
+
+		function getDistanceToSquared( object1, object2 ) {
+
+			_a.setFromMatrixPosition( object1.matrixWorld );
+			_b.setFromMatrixPosition( object2.matrixWorld );
+
+			return _a.distanceToSquared( _b );
+
+		}
+
+		function filterAndFlatten( scene ) {
+
+			const result = [];
+
+			scene.traverse( function ( object ) {
+
+				if ( object.isCSS2DObject ) result.push( object );
+
+			} );
+
+			return result;
+
+		}
+
+		function zOrder( scene ) {
+
+			const sorted = filterAndFlatten( scene ).sort( function ( a, b ) {
+
+				if ( a.renderOrder !== b.renderOrder ) {
+
+					return b.renderOrder - a.renderOrder;
+
+				}
+
+				const distanceA = cache.objects.get( a ).distanceToCameraSquared;
+				const distanceB = cache.objects.get( b ).distanceToCameraSquared;
+
+				return distanceA - distanceB;
+
+			} );
+
+			const zMax = sorted.length;
+
+			for ( let i = 0, l = sorted.length; i < l; i ++ ) {
+
+				sorted[ i ].element.style.zIndex = zMax - i;
+
+			}
+
+		}
+
+	}
+
+}
+
+export { CSS2DObject, CSS2DRenderer };
diff --git a/src/easydiffraction/display/structure/renderers/vendor/threejs/LICENSES.md b/src/easydiffraction/display/structure/renderers/vendor/threejs/LICENSES.md
new file mode 100644
index 000000000..eb518245b
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/vendor/threejs/LICENSES.md
@@ -0,0 +1,21 @@
+# Vendored Three.js
+
+Pinned, bundled Three.js so the structure view renders autonomously with
+no network (notebook and standalone HTML). Fetched verbatim from jsDelivr
+(npm `three@0.160.0`):
+
+| File | Source URL |
+| --- | --- |
+| `three.module.js` | `https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js` |
+| `OrbitControls.js` | `https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/controls/OrbitControls.js` |
+| `CSS2DRenderer.js` | `https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/renderers/CSS2DRenderer.js` |
+
+**Version:** three r160 (0.160.0).
+
+**Licence:** MIT — Copyright © 2010-2024 three.js authors. See
+`https://github.com/mrdoob/three.js/blob/dev/LICENSE`.
+
+These are upstream snapshots, not project-owned code: do not edit or
+reformat them (they are excluded from linting, formatting, coverage, and
+test-structure mirroring in `pyproject.toml`). Replace only by re-fetching
+the pinned version.
diff --git a/src/easydiffraction/display/structure/renderers/vendor/threejs/OrbitControls.js b/src/easydiffraction/display/structure/renderers/vendor/threejs/OrbitControls.js
new file mode 100644
index 000000000..f29e7feb0
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/vendor/threejs/OrbitControls.js
@@ -0,0 +1,1417 @@
+import {
+	EventDispatcher,
+	MOUSE,
+	Quaternion,
+	Spherical,
+	TOUCH,
+	Vector2,
+	Vector3,
+	Plane,
+	Ray,
+	MathUtils
+} from 'three';
+
+// OrbitControls performs orbiting, dollying (zooming), and panning.
+// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+//
+//    Orbit - left mouse / touch: one-finger move
+//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+//    Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move
+
+const _changeEvent = { type: 'change' };
+const _startEvent = { type: 'start' };
+const _endEvent = { type: 'end' };
+const _ray = new Ray();
+const _plane = new Plane();
+const TILT_LIMIT = Math.cos( 70 * MathUtils.DEG2RAD );
+
+class OrbitControls extends EventDispatcher {
+
+	constructor( object, domElement ) {
+
+		super();
+
+		this.object = object;
+		this.domElement = domElement;
+		this.domElement.style.touchAction = 'none'; // disable touch scroll
+
+		// Set to false to disable this control
+		this.enabled = true;
+
+		// "target" sets the location of focus, where the object orbits around
+		this.target = new Vector3();
+
+		// Sets the 3D cursor (similar to Blender), from which the maxTargetRadius takes effect
+		this.cursor = new Vector3();
+
+		// How far you can dolly in and out ( PerspectiveCamera only )
+		this.minDistance = 0;
+		this.maxDistance = Infinity;
+
+		// How far you can zoom in and out ( OrthographicCamera only )
+		this.minZoom = 0;
+		this.maxZoom = Infinity;
+
+		// Limit camera target within a spherical area around the cursor
+		this.minTargetRadius = 0;
+		this.maxTargetRadius = Infinity;
+
+		// How far you can orbit vertically, upper and lower limits.
+		// Range is 0 to Math.PI radians.
+		this.minPolarAngle = 0; // radians
+		this.maxPolarAngle = Math.PI; // radians
+
+		// How far you can orbit horizontally, upper and lower limits.
+		// If set, the interval [ min, max ] must be a sub-interval of [ - 2 PI, 2 PI ], with ( max - min < 2 PI )
+		this.minAzimuthAngle = - Infinity; // radians
+		this.maxAzimuthAngle = Infinity; // radians
+
+		// Set to true to enable damping (inertia)
+		// If damping is enabled, you must call controls.update() in your animation loop
+		this.enableDamping = false;
+		this.dampingFactor = 0.05;
+
+		// This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
+		// Set to false to disable zooming
+		this.enableZoom = true;
+		this.zoomSpeed = 1.0;
+
+		// Set to false to disable rotating
+		this.enableRotate = true;
+		this.rotateSpeed = 1.0;
+
+		// Set to false to disable panning
+		this.enablePan = true;
+		this.panSpeed = 1.0;
+		this.screenSpacePanning = true; // if false, pan orthogonal to world-space direction camera.up
+		this.keyPanSpeed = 7.0;	// pixels moved per arrow key push
+		this.zoomToCursor = false;
+
+		// Set to true to automatically rotate around the target
+		// If auto-rotate is enabled, you must call controls.update() in your animation loop
+		this.autoRotate = false;
+		this.autoRotateSpeed = 2.0; // 30 seconds per orbit when fps is 60
+
+		// The four arrow keys
+		this.keys = { LEFT: 'ArrowLeft', UP: 'ArrowUp', RIGHT: 'ArrowRight', BOTTOM: 'ArrowDown' };
+
+		// Mouse buttons
+		this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
+
+		// Touch fingers
+		this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
+
+		// for reset
+		this.target0 = this.target.clone();
+		this.position0 = this.object.position.clone();
+		this.zoom0 = this.object.zoom;
+
+		// the target DOM element for key events
+		this._domElementKeyEvents = null;
+
+		//
+		// public methods
+		//
+
+		this.getPolarAngle = function () {
+
+			return spherical.phi;
+
+		};
+
+		this.getAzimuthalAngle = function () {
+
+			return spherical.theta;
+
+		};
+
+		this.getDistance = function () {
+
+			return this.object.position.distanceTo( this.target );
+
+		};
+
+		this.listenToKeyEvents = function ( domElement ) {
+
+			domElement.addEventListener( 'keydown', onKeyDown );
+			this._domElementKeyEvents = domElement;
+
+		};
+
+		this.stopListenToKeyEvents = function () {
+
+			this._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
+			this._domElementKeyEvents = null;
+
+		};
+
+		this.saveState = function () {
+
+			scope.target0.copy( scope.target );
+			scope.position0.copy( scope.object.position );
+			scope.zoom0 = scope.object.zoom;
+
+		};
+
+		this.reset = function () {
+
+			scope.target.copy( scope.target0 );
+			scope.object.position.copy( scope.position0 );
+			scope.object.zoom = scope.zoom0;
+
+			scope.object.updateProjectionMatrix();
+			scope.dispatchEvent( _changeEvent );
+
+			scope.update();
+
+			state = STATE.NONE;
+
+		};
+
+		// this method is exposed, but perhaps it would be better if we can make it private...
+		this.update = function () {
+
+			const offset = new Vector3();
+
+			// so camera.up is the orbit axis
+			const quat = new Quaternion().setFromUnitVectors( object.up, new Vector3( 0, 1, 0 ) );
+			const quatInverse = quat.clone().invert();
+
+			const lastPosition = new Vector3();
+			const lastQuaternion = new Quaternion();
+			const lastTargetPosition = new Vector3();
+
+			const twoPI = 2 * Math.PI;
+
+			return function update( deltaTime = null ) {
+
+				const position = scope.object.position;
+
+				offset.copy( position ).sub( scope.target );
+
+				// rotate offset to "y-axis-is-up" space
+				offset.applyQuaternion( quat );
+
+				// angle from z-axis around y-axis
+				spherical.setFromVector3( offset );
+
+				if ( scope.autoRotate && state === STATE.NONE ) {
+
+					rotateLeft( getAutoRotationAngle( deltaTime ) );
+
+				}
+
+				if ( scope.enableDamping ) {
+
+					spherical.theta += sphericalDelta.theta * scope.dampingFactor;
+					spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+
+				} else {
+
+					spherical.theta += sphericalDelta.theta;
+					spherical.phi += sphericalDelta.phi;
+
+				}
+
+				// restrict theta to be between desired limits
+
+				let min = scope.minAzimuthAngle;
+				let max = scope.maxAzimuthAngle;
+
+				if ( isFinite( min ) && isFinite( max ) ) {
+
+					if ( min < - Math.PI ) min += twoPI; else if ( min > Math.PI ) min -= twoPI;
+
+					if ( max < - Math.PI ) max += twoPI; else if ( max > Math.PI ) max -= twoPI;
+
+					if ( min <= max ) {
+
+						spherical.theta = Math.max( min, Math.min( max, spherical.theta ) );
+
+					} else {
+
+						spherical.theta = ( spherical.theta > ( min + max ) / 2 ) ?
+							Math.max( min, spherical.theta ) :
+							Math.min( max, spherical.theta );
+
+					}
+
+				}
+
+				// restrict phi to be between desired limits
+				spherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) );
+
+				spherical.makeSafe();
+
+
+				// move target to panned location
+
+				if ( scope.enableDamping === true ) {
+
+					scope.target.addScaledVector( panOffset, scope.dampingFactor );
+
+				} else {
+
+					scope.target.add( panOffset );
+
+				}
+
+				// Limit the target distance from the cursor to create a sphere around the center of interest
+				scope.target.sub( scope.cursor );
+				scope.target.clampLength( scope.minTargetRadius, scope.maxTargetRadius );
+				scope.target.add( scope.cursor );
+
+				// adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera
+				// we adjust zoom later in these cases
+				if ( scope.zoomToCursor && performCursorZoom || scope.object.isOrthographicCamera ) {
+
+					spherical.radius = clampDistance( spherical.radius );
+
+				} else {
+
+					spherical.radius = clampDistance( spherical.radius * scale );
+
+				}
+
+				offset.setFromSpherical( spherical );
+
+				// rotate offset back to "camera-up-vector-is-up" space
+				offset.applyQuaternion( quatInverse );
+
+				position.copy( scope.target ).add( offset );
+
+				scope.object.lookAt( scope.target );
+
+				if ( scope.enableDamping === true ) {
+
+					sphericalDelta.theta *= ( 1 - scope.dampingFactor );
+					sphericalDelta.phi *= ( 1 - scope.dampingFactor );
+
+					panOffset.multiplyScalar( 1 - scope.dampingFactor );
+
+				} else {
+
+					sphericalDelta.set( 0, 0, 0 );
+
+					panOffset.set( 0, 0, 0 );
+
+				}
+
+				// adjust camera position
+				let zoomChanged = false;
+				if ( scope.zoomToCursor && performCursorZoom ) {
+
+					let newRadius = null;
+					if ( scope.object.isPerspectiveCamera ) {
+
+						// move the camera down the pointer ray
+						// this method avoids floating point error
+						const prevRadius = offset.length();
+						newRadius = clampDistance( prevRadius * scale );
+
+						const radiusDelta = prevRadius - newRadius;
+						scope.object.position.addScaledVector( dollyDirection, radiusDelta );
+						scope.object.updateMatrixWorld();
+
+					} else if ( scope.object.isOrthographicCamera ) {
+
+						// adjust the ortho camera position based on zoom changes
+						const mouseBefore = new Vector3( mouse.x, mouse.y, 0 );
+						mouseBefore.unproject( scope.object );
+
+						scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / scale ) );
+						scope.object.updateProjectionMatrix();
+						zoomChanged = true;
+
+						const mouseAfter = new Vector3( mouse.x, mouse.y, 0 );
+						mouseAfter.unproject( scope.object );
+
+						scope.object.position.sub( mouseAfter ).add( mouseBefore );
+						scope.object.updateMatrixWorld();
+
+						newRadius = offset.length();
+
+					} else {
+
+						console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.' );
+						scope.zoomToCursor = false;
+
+					}
+
+					// handle the placement of the target
+					if ( newRadius !== null ) {
+
+						if ( this.screenSpacePanning ) {
+
+							// position the orbit target in front of the new camera position
+							scope.target.set( 0, 0, - 1 )
+								.transformDirection( scope.object.matrix )
+								.multiplyScalar( newRadius )
+								.add( scope.object.position );
+
+						} else {
+
+							// get the ray and translation plane to compute target
+							_ray.origin.copy( scope.object.position );
+							_ray.direction.set( 0, 0, - 1 ).transformDirection( scope.object.matrix );
+
+							// if the camera is 20 degrees above the horizon then don't adjust the focus target to avoid
+							// extremely large values
+							if ( Math.abs( scope.object.up.dot( _ray.direction ) ) < TILT_LIMIT ) {
+
+								object.lookAt( scope.target );
+
+							} else {
+
+								_plane.setFromNormalAndCoplanarPoint( scope.object.up, scope.target );
+								_ray.intersectPlane( _plane, scope.target );
+
+							}
+
+						}
+
+					}
+
+				} else if ( scope.object.isOrthographicCamera ) {
+
+					scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / scale ) );
+					scope.object.updateProjectionMatrix();
+					zoomChanged = true;
+
+				}
+
+				scale = 1;
+				performCursorZoom = false;
+
+				// update condition is:
+				// min(camera displacement, camera rotation in radians)^2 > EPS
+				// using small-angle approximation cos(x/2) = 1 - x^2 / 8
+
+				if ( zoomChanged ||
+					lastPosition.distanceToSquared( scope.object.position ) > EPS ||
+					8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ||
+					lastTargetPosition.distanceToSquared( scope.target ) > 0 ) {
+
+					scope.dispatchEvent( _changeEvent );
+
+					lastPosition.copy( scope.object.position );
+					lastQuaternion.copy( scope.object.quaternion );
+					lastTargetPosition.copy( scope.target );
+
+					return true;
+
+				}
+
+				return false;
+
+			};
+
+		}();
+
+		this.dispose = function () {
+
+			scope.domElement.removeEventListener( 'contextmenu', onContextMenu );
+
+			scope.domElement.removeEventListener( 'pointerdown', onPointerDown );
+			scope.domElement.removeEventListener( 'pointercancel', onPointerUp );
+			scope.domElement.removeEventListener( 'wheel', onMouseWheel );
+
+			scope.domElement.removeEventListener( 'pointermove', onPointerMove );
+			scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+
+
+			if ( scope._domElementKeyEvents !== null ) {
+
+				scope._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
+				scope._domElementKeyEvents = null;
+
+			}
+
+			//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
+
+		};
+
+		//
+		// internals
+		//
+
+		const scope = this;
+
+		const STATE = {
+			NONE: - 1,
+			ROTATE: 0,
+			DOLLY: 1,
+			PAN: 2,
+			TOUCH_ROTATE: 3,
+			TOUCH_PAN: 4,
+			TOUCH_DOLLY_PAN: 5,
+			TOUCH_DOLLY_ROTATE: 6
+		};
+
+		let state = STATE.NONE;
+
+		const EPS = 0.000001;
+
+		// current position in spherical coordinates
+		const spherical = new Spherical();
+		const sphericalDelta = new Spherical();
+
+		let scale = 1;
+		const panOffset = new Vector3();
+
+		const rotateStart = new Vector2();
+		const rotateEnd = new Vector2();
+		const rotateDelta = new Vector2();
+
+		const panStart = new Vector2();
+		const panEnd = new Vector2();
+		const panDelta = new Vector2();
+
+		const dollyStart = new Vector2();
+		const dollyEnd = new Vector2();
+		const dollyDelta = new Vector2();
+
+		const dollyDirection = new Vector3();
+		const mouse = new Vector2();
+		let performCursorZoom = false;
+
+		const pointers = [];
+		const pointerPositions = {};
+
+		function getAutoRotationAngle( deltaTime ) {
+
+			if ( deltaTime !== null ) {
+
+				return ( 2 * Math.PI / 60 * scope.autoRotateSpeed ) * deltaTime;
+
+			} else {
+
+				return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+
+			}
+
+		}
+
+		function getZoomScale( delta ) {
+
+			const normalized_delta = Math.abs( delta ) / ( 100 * ( window.devicePixelRatio | 0 ) );
+			return Math.pow( 0.95, scope.zoomSpeed * normalized_delta );
+
+		}
+
+		function rotateLeft( angle ) {
+
+			sphericalDelta.theta -= angle;
+
+		}
+
+		function rotateUp( angle ) {
+
+			sphericalDelta.phi -= angle;
+
+		}
+
+		const panLeft = function () {
+
+			const v = new Vector3();
+
+			return function panLeft( distance, objectMatrix ) {
+
+				v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix
+				v.multiplyScalar( - distance );
+
+				panOffset.add( v );
+
+			};
+
+		}();
+
+		const panUp = function () {
+
+			const v = new Vector3();
+
+			return function panUp( distance, objectMatrix ) {
+
+				if ( scope.screenSpacePanning === true ) {
+
+					v.setFromMatrixColumn( objectMatrix, 1 );
+
+				} else {
+
+					v.setFromMatrixColumn( objectMatrix, 0 );
+					v.crossVectors( scope.object.up, v );
+
+				}
+
+				v.multiplyScalar( distance );
+
+				panOffset.add( v );
+
+			};
+
+		}();
+
+		// deltaX and deltaY are in pixels; right and down are positive
+		const pan = function () {
+
+			const offset = new Vector3();
+
+			return function pan( deltaX, deltaY ) {
+
+				const element = scope.domElement;
+
+				if ( scope.object.isPerspectiveCamera ) {
+
+					// perspective
+					const position = scope.object.position;
+					offset.copy( position ).sub( scope.target );
+					let targetDistance = offset.length();
+
+					// half of the fov is center to top of screen
+					targetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );
+
+					// we use only clientHeight here so aspect ratio does not distort speed
+					panLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix );
+					panUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix );
+
+				} else if ( scope.object.isOrthographicCamera ) {
+
+					// orthographic
+					panLeft( deltaX * ( scope.object.right - scope.object.left ) / scope.object.zoom / element.clientWidth, scope.object.matrix );
+					panUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / element.clientHeight, scope.object.matrix );
+
+				} else {
+
+					// camera neither orthographic nor perspective
+					console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
+					scope.enablePan = false;
+
+				}
+
+			};
+
+		}();
+
+		function dollyOut( dollyScale ) {
+
+			if ( scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera ) {
+
+				scale /= dollyScale;
+
+			} else {
+
+				console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+				scope.enableZoom = false;
+
+			}
+
+		}
+
+		function dollyIn( dollyScale ) {
+
+			if ( scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera ) {
+
+				scale *= dollyScale;
+
+			} else {
+
+				console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+				scope.enableZoom = false;
+
+			}
+
+		}
+
+		function updateZoomParameters( x, y ) {
+
+			if ( ! scope.zoomToCursor ) {
+
+				return;
+
+			}
+
+			performCursorZoom = true;
+
+			const rect = scope.domElement.getBoundingClientRect();
+			const dx = x - rect.left;
+			const dy = y - rect.top;
+			const w = rect.width;
+			const h = rect.height;
+
+			mouse.x = ( dx / w ) * 2 - 1;
+			mouse.y = - ( dy / h ) * 2 + 1;
+
+			dollyDirection.set( mouse.x, mouse.y, 1 ).unproject( scope.object ).sub( scope.object.position ).normalize();
+
+		}
+
+		function clampDistance( dist ) {
+
+			return Math.max( scope.minDistance, Math.min( scope.maxDistance, dist ) );
+
+		}
+
+		//
+		// event callbacks - update the object state
+		//
+
+		function handleMouseDownRotate( event ) {
+
+			rotateStart.set( event.clientX, event.clientY );
+
+		}
+
+		function handleMouseDownDolly( event ) {
+
+			updateZoomParameters( event.clientX, event.clientX );
+			dollyStart.set( event.clientX, event.clientY );
+
+		}
+
+		function handleMouseDownPan( event ) {
+
+			panStart.set( event.clientX, event.clientY );
+
+		}
+
+		function handleMouseMoveRotate( event ) {
+
+			rotateEnd.set( event.clientX, event.clientY );
+
+			rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed );
+
+			const element = scope.domElement;
+
+			rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height
+
+			rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight );
+
+			rotateStart.copy( rotateEnd );
+
+			scope.update();
+
+		}
+
+		function handleMouseMoveDolly( event ) {
+
+			dollyEnd.set( event.clientX, event.clientY );
+
+			dollyDelta.subVectors( dollyEnd, dollyStart );
+
+			if ( dollyDelta.y > 0 ) {
+
+				dollyOut( getZoomScale( dollyDelta.y ) );
+
+			} else if ( dollyDelta.y < 0 ) {
+
+				dollyIn( getZoomScale( dollyDelta.y ) );
+
+			}
+
+			dollyStart.copy( dollyEnd );
+
+			scope.update();
+
+		}
+
+		function handleMouseMovePan( event ) {
+
+			panEnd.set( event.clientX, event.clientY );
+
+			panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed );
+
+			pan( panDelta.x, panDelta.y );
+
+			panStart.copy( panEnd );
+
+			scope.update();
+
+		}
+
+		function handleMouseWheel( event ) {
+
+			updateZoomParameters( event.clientX, event.clientY );
+
+			if ( event.deltaY < 0 ) {
+
+				dollyIn( getZoomScale( event.deltaY ) );
+
+			} else if ( event.deltaY > 0 ) {
+
+				dollyOut( getZoomScale( event.deltaY ) );
+
+			}
+
+			scope.update();
+
+		}
+
+		function handleKeyDown( event ) {
+
+			let needsUpdate = false;
+
+			switch ( event.code ) {
+
+				case scope.keys.UP:
+
+					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+						rotateUp( 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+
+					} else {
+
+						pan( 0, scope.keyPanSpeed );
+
+					}
+
+					needsUpdate = true;
+					break;
+
+				case scope.keys.BOTTOM:
+
+					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+						rotateUp( - 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+
+					} else {
+
+						pan( 0, - scope.keyPanSpeed );
+
+					}
+
+					needsUpdate = true;
+					break;
+
+				case scope.keys.LEFT:
+
+					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+						rotateLeft( 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+
+					} else {
+
+						pan( scope.keyPanSpeed, 0 );
+
+					}
+
+					needsUpdate = true;
+					break;
+
+				case scope.keys.RIGHT:
+
+					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+						rotateLeft( - 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+
+					} else {
+
+						pan( - scope.keyPanSpeed, 0 );
+
+					}
+
+					needsUpdate = true;
+					break;
+
+			}
+
+			if ( needsUpdate ) {
+
+				// prevent the browser from scrolling on cursor keys
+				event.preventDefault();
+
+				scope.update();
+
+			}
+
+
+		}
+
+		function handleTouchStartRotate( event ) {
+
+			if ( pointers.length === 1 ) {
+
+				rotateStart.set( event.pageX, event.pageY );
+
+			} else {
+
+				const position = getSecondPointerPosition( event );
+
+				const x = 0.5 * ( event.pageX + position.x );
+				const y = 0.5 * ( event.pageY + position.y );
+
+				rotateStart.set( x, y );
+
+			}
+
+		}
+
+		function handleTouchStartPan( event ) {
+
+			if ( pointers.length === 1 ) {
+
+				panStart.set( event.pageX, event.pageY );
+
+			} else {
+
+				const position = getSecondPointerPosition( event );
+
+				const x = 0.5 * ( event.pageX + position.x );
+				const y = 0.5 * ( event.pageY + position.y );
+
+				panStart.set( x, y );
+
+			}
+
+		}
+
+		function handleTouchStartDolly( event ) {
+
+			const position = getSecondPointerPosition( event );
+
+			const dx = event.pageX - position.x;
+			const dy = event.pageY - position.y;
+
+			const distance = Math.sqrt( dx * dx + dy * dy );
+
+			dollyStart.set( 0, distance );
+
+		}
+
+		function handleTouchStartDollyPan( event ) {
+
+			if ( scope.enableZoom ) handleTouchStartDolly( event );
+
+			if ( scope.enablePan ) handleTouchStartPan( event );
+
+		}
+
+		function handleTouchStartDollyRotate( event ) {
+
+			if ( scope.enableZoom ) handleTouchStartDolly( event );
+
+			if ( scope.enableRotate ) handleTouchStartRotate( event );
+
+		}
+
+		function handleTouchMoveRotate( event ) {
+
+			if ( pointers.length == 1 ) {
+
+				rotateEnd.set( event.pageX, event.pageY );
+
+			} else {
+
+				const position = getSecondPointerPosition( event );
+
+				const x = 0.5 * ( event.pageX + position.x );
+				const y = 0.5 * ( event.pageY + position.y );
+
+				rotateEnd.set( x, y );
+
+			}
+
+			rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed );
+
+			const element = scope.domElement;
+
+			rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height
+
+			rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight );
+
+			rotateStart.copy( rotateEnd );
+
+		}
+
+		function handleTouchMovePan( event ) {
+
+			if ( pointers.length === 1 ) {
+
+				panEnd.set( event.pageX, event.pageY );
+
+			} else {
+
+				const position = getSecondPointerPosition( event );
+
+				const x = 0.5 * ( event.pageX + position.x );
+				const y = 0.5 * ( event.pageY + position.y );
+
+				panEnd.set( x, y );
+
+			}
+
+			panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed );
+
+			pan( panDelta.x, panDelta.y );
+
+			panStart.copy( panEnd );
+
+		}
+
+		function handleTouchMoveDolly( event ) {
+
+			const position = getSecondPointerPosition( event );
+
+			const dx = event.pageX - position.x;
+			const dy = event.pageY - position.y;
+
+			const distance = Math.sqrt( dx * dx + dy * dy );
+
+			dollyEnd.set( 0, distance );
+
+			dollyDelta.set( 0, Math.pow( dollyEnd.y / dollyStart.y, scope.zoomSpeed ) );
+
+			dollyOut( dollyDelta.y );
+
+			dollyStart.copy( dollyEnd );
+
+			const centerX = ( event.pageX + position.x ) * 0.5;
+			const centerY = ( event.pageY + position.y ) * 0.5;
+
+			updateZoomParameters( centerX, centerY );
+
+		}
+
+		function handleTouchMoveDollyPan( event ) {
+
+			if ( scope.enableZoom ) handleTouchMoveDolly( event );
+
+			if ( scope.enablePan ) handleTouchMovePan( event );
+
+		}
+
+		function handleTouchMoveDollyRotate( event ) {
+
+			if ( scope.enableZoom ) handleTouchMoveDolly( event );
+
+			if ( scope.enableRotate ) handleTouchMoveRotate( event );
+
+		}
+
+		//
+		// event handlers - FSM: listen for events and reset state
+		//
+
+		function onPointerDown( event ) {
+
+			if ( scope.enabled === false ) return;
+
+			if ( pointers.length === 0 ) {
+
+				scope.domElement.setPointerCapture( event.pointerId );
+
+				scope.domElement.addEventListener( 'pointermove', onPointerMove );
+				scope.domElement.addEventListener( 'pointerup', onPointerUp );
+
+			}
+
+			//
+
+			addPointer( event );
+
+			if ( event.pointerType === 'touch' ) {
+
+				onTouchStart( event );
+
+			} else {
+
+				onMouseDown( event );
+
+			}
+
+		}
+
+		function onPointerMove( event ) {
+
+			if ( scope.enabled === false ) return;
+
+			if ( event.pointerType === 'touch' ) {
+
+				onTouchMove( event );
+
+			} else {
+
+				onMouseMove( event );
+
+			}
+
+		}
+
+		function onPointerUp( event ) {
+
+			removePointer( event );
+
+			if ( pointers.length === 0 ) {
+
+				scope.domElement.releasePointerCapture( event.pointerId );
+
+				scope.domElement.removeEventListener( 'pointermove', onPointerMove );
+				scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+
+			}
+
+			scope.dispatchEvent( _endEvent );
+
+			state = STATE.NONE;
+
+		}
+
+		function onMouseDown( event ) {
+
+			let mouseAction;
+
+			switch ( event.button ) {
+
+				case 0:
+
+					mouseAction = scope.mouseButtons.LEFT;
+					break;
+
+				case 1:
+
+					mouseAction = scope.mouseButtons.MIDDLE;
+					break;
+
+				case 2:
+
+					mouseAction = scope.mouseButtons.RIGHT;
+					break;
+
+				default:
+
+					mouseAction = - 1;
+
+			}
+
+			switch ( mouseAction ) {
+
+				case MOUSE.DOLLY:
+
+					if ( scope.enableZoom === false ) return;
+
+					handleMouseDownDolly( event );
+
+					state = STATE.DOLLY;
+
+					break;
+
+				case MOUSE.ROTATE:
+
+					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+						if ( scope.enablePan === false ) return;
+
+						handleMouseDownPan( event );
+
+						state = STATE.PAN;
+
+					} else {
+
+						if ( scope.enableRotate === false ) return;
+
+						handleMouseDownRotate( event );
+
+						state = STATE.ROTATE;
+
+					}
+
+					break;
+
+				case MOUSE.PAN:
+
+					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+						if ( scope.enableRotate === false ) return;
+
+						handleMouseDownRotate( event );
+
+						state = STATE.ROTATE;
+
+					} else {
+
+						if ( scope.enablePan === false ) return;
+
+						handleMouseDownPan( event );
+
+						state = STATE.PAN;
+
+					}
+
+					break;
+
+				default:
+
+					state = STATE.NONE;
+
+			}
+
+			if ( state !== STATE.NONE ) {
+
+				scope.dispatchEvent( _startEvent );
+
+			}
+
+		}
+
+		function onMouseMove( event ) {
+
+			switch ( state ) {
+
+				case STATE.ROTATE:
+
+					if ( scope.enableRotate === false ) return;
+
+					handleMouseMoveRotate( event );
+
+					break;
+
+				case STATE.DOLLY:
+
+					if ( scope.enableZoom === false ) return;
+
+					handleMouseMoveDolly( event );
+
+					break;
+
+				case STATE.PAN:
+
+					if ( scope.enablePan === false ) return;
+
+					handleMouseMovePan( event );
+
+					break;
+
+			}
+
+		}
+
+		function onMouseWheel( event ) {
+
+			if ( scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE ) return;
+
+			event.preventDefault();
+
+			scope.dispatchEvent( _startEvent );
+
+			handleMouseWheel( event );
+
+			scope.dispatchEvent( _endEvent );
+
+		}
+
+		function onKeyDown( event ) {
+
+			if ( scope.enabled === false || scope.enablePan === false ) return;
+
+			handleKeyDown( event );
+
+		}
+
+		function onTouchStart( event ) {
+
+			trackPointer( event );
+
+			switch ( pointers.length ) {
+
+				case 1:
+
+					switch ( scope.touches.ONE ) {
+
+						case TOUCH.ROTATE:
+
+							if ( scope.enableRotate === false ) return;
+
+							handleTouchStartRotate( event );
+
+							state = STATE.TOUCH_ROTATE;
+
+							break;
+
+						case TOUCH.PAN:
+
+							if ( scope.enablePan === false ) return;
+
+							handleTouchStartPan( event );
+
+							state = STATE.TOUCH_PAN;
+
+							break;
+
+						default:
+
+							state = STATE.NONE;
+
+					}
+
+					break;
+
+				case 2:
+
+					switch ( scope.touches.TWO ) {
+
+						case TOUCH.DOLLY_PAN:
+
+							if ( scope.enableZoom === false && scope.enablePan === false ) return;
+
+							handleTouchStartDollyPan( event );
+
+							state = STATE.TOUCH_DOLLY_PAN;
+
+							break;
+
+						case TOUCH.DOLLY_ROTATE:
+
+							if ( scope.enableZoom === false && scope.enableRotate === false ) return;
+
+							handleTouchStartDollyRotate( event );
+
+							state = STATE.TOUCH_DOLLY_ROTATE;
+
+							break;
+
+						default:
+
+							state = STATE.NONE;
+
+					}
+
+					break;
+
+				default:
+
+					state = STATE.NONE;
+
+			}
+
+			if ( state !== STATE.NONE ) {
+
+				scope.dispatchEvent( _startEvent );
+
+			}
+
+		}
+
+		function onTouchMove( event ) {
+
+			trackPointer( event );
+
+			switch ( state ) {
+
+				case STATE.TOUCH_ROTATE:
+
+					if ( scope.enableRotate === false ) return;
+
+					handleTouchMoveRotate( event );
+
+					scope.update();
+
+					break;
+
+				case STATE.TOUCH_PAN:
+
+					if ( scope.enablePan === false ) return;
+
+					handleTouchMovePan( event );
+
+					scope.update();
+
+					break;
+
+				case STATE.TOUCH_DOLLY_PAN:
+
+					if ( scope.enableZoom === false && scope.enablePan === false ) return;
+
+					handleTouchMoveDollyPan( event );
+
+					scope.update();
+
+					break;
+
+				case STATE.TOUCH_DOLLY_ROTATE:
+
+					if ( scope.enableZoom === false && scope.enableRotate === false ) return;
+
+					handleTouchMoveDollyRotate( event );
+
+					scope.update();
+
+					break;
+
+				default:
+
+					state = STATE.NONE;
+
+			}
+
+		}
+
+		function onContextMenu( event ) {
+
+			if ( scope.enabled === false ) return;
+
+			event.preventDefault();
+
+		}
+
+		function addPointer( event ) {
+
+			pointers.push( event.pointerId );
+
+		}
+
+		function removePointer( event ) {
+
+			delete pointerPositions[ event.pointerId ];
+
+			for ( let i = 0; i < pointers.length; i ++ ) {
+
+				if ( pointers[ i ] == event.pointerId ) {
+
+					pointers.splice( i, 1 );
+					return;
+
+				}
+
+			}
+
+		}
+
+		function trackPointer( event ) {
+
+			let position = pointerPositions[ event.pointerId ];
+
+			if ( position === undefined ) {
+
+				position = new Vector2();
+				pointerPositions[ event.pointerId ] = position;
+
+			}
+
+			position.set( event.pageX, event.pageY );
+
+		}
+
+		function getSecondPointerPosition( event ) {
+
+			const pointerId = ( event.pointerId === pointers[ 0 ] ) ? pointers[ 1 ] : pointers[ 0 ];
+
+			return pointerPositions[ pointerId ];
+
+		}
+
+		//
+
+		scope.domElement.addEventListener( 'contextmenu', onContextMenu );
+
+		scope.domElement.addEventListener( 'pointerdown', onPointerDown );
+		scope.domElement.addEventListener( 'pointercancel', onPointerUp );
+		scope.domElement.addEventListener( 'wheel', onMouseWheel, { passive: false } );
+
+		// force an update at start
+
+		this.update();
+
+	}
+
+}
+
+export { OrbitControls };
diff --git a/src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js b/src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js
new file mode 100644
index 000000000..0bcc7a286
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js
@@ -0,0 +1,53044 @@
+/**
+ * @license
+ * Copyright 2010-2023 Three.js Authors
+ * SPDX-License-Identifier: MIT
+ */
+const REVISION = '160';
+
+const MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
+const TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
+const CullFaceNone = 0;
+const CullFaceBack = 1;
+const CullFaceFront = 2;
+const CullFaceFrontBack = 3;
+const BasicShadowMap = 0;
+const PCFShadowMap = 1;
+const PCFSoftShadowMap = 2;
+const VSMShadowMap = 3;
+const FrontSide = 0;
+const BackSide = 1;
+const DoubleSide = 2;
+const TwoPassDoubleSide = 2; // r149
+const NoBlending = 0;
+const NormalBlending = 1;
+const AdditiveBlending = 2;
+const SubtractiveBlending = 3;
+const MultiplyBlending = 4;
+const CustomBlending = 5;
+const AddEquation = 100;
+const SubtractEquation = 101;
+const ReverseSubtractEquation = 102;
+const MinEquation = 103;
+const MaxEquation = 104;
+const ZeroFactor = 200;
+const OneFactor = 201;
+const SrcColorFactor = 202;
+const OneMinusSrcColorFactor = 203;
+const SrcAlphaFactor = 204;
+const OneMinusSrcAlphaFactor = 205;
+const DstAlphaFactor = 206;
+const OneMinusDstAlphaFactor = 207;
+const DstColorFactor = 208;
+const OneMinusDstColorFactor = 209;
+const SrcAlphaSaturateFactor = 210;
+const ConstantColorFactor = 211;
+const OneMinusConstantColorFactor = 212;
+const ConstantAlphaFactor = 213;
+const OneMinusConstantAlphaFactor = 214;
+const NeverDepth = 0;
+const AlwaysDepth = 1;
+const LessDepth = 2;
+const LessEqualDepth = 3;
+const EqualDepth = 4;
+const GreaterEqualDepth = 5;
+const GreaterDepth = 6;
+const NotEqualDepth = 7;
+const MultiplyOperation = 0;
+const MixOperation = 1;
+const AddOperation = 2;
+const NoToneMapping = 0;
+const LinearToneMapping = 1;
+const ReinhardToneMapping = 2;
+const CineonToneMapping = 3;
+const ACESFilmicToneMapping = 4;
+const CustomToneMapping = 5;
+const AgXToneMapping = 6;
+const AttachedBindMode = 'attached';
+const DetachedBindMode = 'detached';
+
+const UVMapping = 300;
+const CubeReflectionMapping = 301;
+const CubeRefractionMapping = 302;
+const EquirectangularReflectionMapping = 303;
+const EquirectangularRefractionMapping = 304;
+const CubeUVReflectionMapping = 306;
+const RepeatWrapping = 1000;
+const ClampToEdgeWrapping = 1001;
+const MirroredRepeatWrapping = 1002;
+const NearestFilter = 1003;
+const NearestMipmapNearestFilter = 1004;
+const NearestMipMapNearestFilter = 1004;
+const NearestMipmapLinearFilter = 1005;
+const NearestMipMapLinearFilter = 1005;
+const LinearFilter = 1006;
+const LinearMipmapNearestFilter = 1007;
+const LinearMipMapNearestFilter = 1007;
+const LinearMipmapLinearFilter = 1008;
+const LinearMipMapLinearFilter = 1008;
+const UnsignedByteType = 1009;
+const ByteType = 1010;
+const ShortType = 1011;
+const UnsignedShortType = 1012;
+const IntType = 1013;
+const UnsignedIntType = 1014;
+const FloatType = 1015;
+const HalfFloatType = 1016;
+const UnsignedShort4444Type = 1017;
+const UnsignedShort5551Type = 1018;
+const UnsignedInt248Type = 1020;
+const AlphaFormat = 1021;
+const RGBAFormat = 1023;
+const LuminanceFormat = 1024;
+const LuminanceAlphaFormat = 1025;
+const DepthFormat = 1026;
+const DepthStencilFormat = 1027;
+const RedFormat = 1028;
+const RedIntegerFormat = 1029;
+const RGFormat = 1030;
+const RGIntegerFormat = 1031;
+const RGBAIntegerFormat = 1033;
+
+const RGB_S3TC_DXT1_Format = 33776;
+const RGBA_S3TC_DXT1_Format = 33777;
+const RGBA_S3TC_DXT3_Format = 33778;
+const RGBA_S3TC_DXT5_Format = 33779;
+const RGB_PVRTC_4BPPV1_Format = 35840;
+const RGB_PVRTC_2BPPV1_Format = 35841;
+const RGBA_PVRTC_4BPPV1_Format = 35842;
+const RGBA_PVRTC_2BPPV1_Format = 35843;
+const RGB_ETC1_Format = 36196;
+const RGB_ETC2_Format = 37492;
+const RGBA_ETC2_EAC_Format = 37496;
+const RGBA_ASTC_4x4_Format = 37808;
+const RGBA_ASTC_5x4_Format = 37809;
+const RGBA_ASTC_5x5_Format = 37810;
+const RGBA_ASTC_6x5_Format = 37811;
+const RGBA_ASTC_6x6_Format = 37812;
+const RGBA_ASTC_8x5_Format = 37813;
+const RGBA_ASTC_8x6_Format = 37814;
+const RGBA_ASTC_8x8_Format = 37815;
+const RGBA_ASTC_10x5_Format = 37816;
+const RGBA_ASTC_10x6_Format = 37817;
+const RGBA_ASTC_10x8_Format = 37818;
+const RGBA_ASTC_10x10_Format = 37819;
+const RGBA_ASTC_12x10_Format = 37820;
+const RGBA_ASTC_12x12_Format = 37821;
+const RGBA_BPTC_Format = 36492;
+const RGB_BPTC_SIGNED_Format = 36494;
+const RGB_BPTC_UNSIGNED_Format = 36495;
+const RED_RGTC1_Format = 36283;
+const SIGNED_RED_RGTC1_Format = 36284;
+const RED_GREEN_RGTC2_Format = 36285;
+const SIGNED_RED_GREEN_RGTC2_Format = 36286;
+const LoopOnce = 2200;
+const LoopRepeat = 2201;
+const LoopPingPong = 2202;
+const InterpolateDiscrete = 2300;
+const InterpolateLinear = 2301;
+const InterpolateSmooth = 2302;
+const ZeroCurvatureEnding = 2400;
+const ZeroSlopeEnding = 2401;
+const WrapAroundEnding = 2402;
+const NormalAnimationBlendMode = 2500;
+const AdditiveAnimationBlendMode = 2501;
+const TrianglesDrawMode = 0;
+const TriangleStripDrawMode = 1;
+const TriangleFanDrawMode = 2;
+/** @deprecated Use LinearSRGBColorSpace or NoColorSpace in three.js r152+. */
+const LinearEncoding = 3000;
+/** @deprecated Use SRGBColorSpace in three.js r152+. */
+const sRGBEncoding = 3001;
+const BasicDepthPacking = 3200;
+const RGBADepthPacking = 3201;
+const TangentSpaceNormalMap = 0;
+const ObjectSpaceNormalMap = 1;
+
+// Color space string identifiers, matching CSS Color Module Level 4 and WebGPU names where available.
+const NoColorSpace = '';
+const SRGBColorSpace = 'srgb';
+const LinearSRGBColorSpace = 'srgb-linear';
+const DisplayP3ColorSpace = 'display-p3';
+const LinearDisplayP3ColorSpace = 'display-p3-linear';
+
+const LinearTransfer = 'linear';
+const SRGBTransfer = 'srgb';
+
+const Rec709Primaries = 'rec709';
+const P3Primaries = 'p3';
+
+const ZeroStencilOp = 0;
+const KeepStencilOp = 7680;
+const ReplaceStencilOp = 7681;
+const IncrementStencilOp = 7682;
+const DecrementStencilOp = 7683;
+const IncrementWrapStencilOp = 34055;
+const DecrementWrapStencilOp = 34056;
+const InvertStencilOp = 5386;
+
+const NeverStencilFunc = 512;
+const LessStencilFunc = 513;
+const EqualStencilFunc = 514;
+const LessEqualStencilFunc = 515;
+const GreaterStencilFunc = 516;
+const NotEqualStencilFunc = 517;
+const GreaterEqualStencilFunc = 518;
+const AlwaysStencilFunc = 519;
+
+const NeverCompare = 512;
+const LessCompare = 513;
+const EqualCompare = 514;
+const LessEqualCompare = 515;
+const GreaterCompare = 516;
+const NotEqualCompare = 517;
+const GreaterEqualCompare = 518;
+const AlwaysCompare = 519;
+
+const StaticDrawUsage = 35044;
+const DynamicDrawUsage = 35048;
+const StreamDrawUsage = 35040;
+const StaticReadUsage = 35045;
+const DynamicReadUsage = 35049;
+const StreamReadUsage = 35041;
+const StaticCopyUsage = 35046;
+const DynamicCopyUsage = 35050;
+const StreamCopyUsage = 35042;
+
+const GLSL1 = '100';
+const GLSL3 = '300 es';
+
+const _SRGBAFormat = 1035; // fallback for WebGL 1
+
+const WebGLCoordinateSystem = 2000;
+const WebGPUCoordinateSystem = 2001;
+
+/**
+ * https://github.com/mrdoob/eventdispatcher.js/
+ */
+
+class EventDispatcher {
+
+	addEventListener( type, listener ) {
+
+		if ( this._listeners === undefined ) this._listeners = {};
+
+		const listeners = this._listeners;
+
+		if ( listeners[ type ] === undefined ) {
+
+			listeners[ type ] = [];
+
+		}
+
+		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
+
+			listeners[ type ].push( listener );
+
+		}
+
+	}
+
+	hasEventListener( type, listener ) {
+
+		if ( this._listeners === undefined ) return false;
+
+		const listeners = this._listeners;
+
+		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
+
+	}
+
+	removeEventListener( type, listener ) {
+
+		if ( this._listeners === undefined ) return;
+
+		const listeners = this._listeners;
+		const listenerArray = listeners[ type ];
+
+		if ( listenerArray !== undefined ) {
+
+			const index = listenerArray.indexOf( listener );
+
+			if ( index !== - 1 ) {
+
+				listenerArray.splice( index, 1 );
+
+			}
+
+		}
+
+	}
+
+	dispatchEvent( event ) {
+
+		if ( this._listeners === undefined ) return;
+
+		const listeners = this._listeners;
+		const listenerArray = listeners[ event.type ];
+
+		if ( listenerArray !== undefined ) {
+
+			event.target = this;
+
+			// Make a copy, in case listeners are removed while iterating.
+			const array = listenerArray.slice( 0 );
+
+			for ( let i = 0, l = array.length; i < l; i ++ ) {
+
+				array[ i ].call( this, event );
+
+			}
+
+			event.target = null;
+
+		}
+
+	}
+
+}
+
+const _lut = [ '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0a', '0b', '0c', '0d', '0e', '0f', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '2a', '2b', '2c', '2d', '2e', '2f', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '3a', '3b', '3c', '3d', '3e', '3f', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b', '4c', '4d', '4e', '4f', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e', '5f', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9a', '9b', '9c', '9d', '9e', '9f', 'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa', 'ab', 'ac', 'ad', 'ae', 'af', 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd', 'be', 'bf', 'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf', 'd0', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df', 'e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef', 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff' ];
+
+let _seed = 1234567;
+
+
+const DEG2RAD = Math.PI / 180;
+const RAD2DEG = 180 / Math.PI;
+
+// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
+function generateUUID() {
+
+	const d0 = Math.random() * 0xffffffff | 0;
+	const d1 = Math.random() * 0xffffffff | 0;
+	const d2 = Math.random() * 0xffffffff | 0;
+	const d3 = Math.random() * 0xffffffff | 0;
+	const uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
+			_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
+			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
+			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
+
+	// .toLowerCase() here flattens concatenated strings to save heap memory space.
+	return uuid.toLowerCase();
+
+}
+
+function clamp( value, min, max ) {
+
+	return Math.max( min, Math.min( max, value ) );
+
+}
+
+// compute euclidean modulo of m % n
+// https://en.wikipedia.org/wiki/Modulo_operation
+function euclideanModulo( n, m ) {
+
+	return ( ( n % m ) + m ) % m;
+
+}
+
+// Linear mapping from range <a1, a2> to range <b1, b2>
+function mapLinear( x, a1, a2, b1, b2 ) {
+
+	return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
+
+}
+
+// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
+function inverseLerp( x, y, value ) {
+
+	if ( x !== y ) {
+
+		return ( value - x ) / ( y - x );
+
+	} else {
+
+		return 0;
+
+	}
+
+}
+
+// https://en.wikipedia.org/wiki/Linear_interpolation
+function lerp( x, y, t ) {
+
+	return ( 1 - t ) * x + t * y;
+
+}
+
+// http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
+function damp( x, y, lambda, dt ) {
+
+	return lerp( x, y, 1 - Math.exp( - lambda * dt ) );
+
+}
+
+// https://www.desmos.com/calculator/vcsjnyz7x4
+function pingpong( x, length = 1 ) {
+
+	return length - Math.abs( euclideanModulo( x, length * 2 ) - length );
+
+}
+
+// http://en.wikipedia.org/wiki/Smoothstep
+function smoothstep( x, min, max ) {
+
+	if ( x <= min ) return 0;
+	if ( x >= max ) return 1;
+
+	x = ( x - min ) / ( max - min );
+
+	return x * x * ( 3 - 2 * x );
+
+}
+
+function smootherstep( x, min, max ) {
+
+	if ( x <= min ) return 0;
+	if ( x >= max ) return 1;
+
+	x = ( x - min ) / ( max - min );
+
+	return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
+
+}
+
+// Random integer from <low, high> interval
+function randInt( low, high ) {
+
+	return low + Math.floor( Math.random() * ( high - low + 1 ) );
+
+}
+
+// Random float from <low, high> interval
+function randFloat( low, high ) {
+
+	return low + Math.random() * ( high - low );
+
+}
+
+// Random float from <-range/2, range/2> interval
+function randFloatSpread( range ) {
+
+	return range * ( 0.5 - Math.random() );
+
+}
+
+// Deterministic pseudo-random float in the interval [ 0, 1 ]
+function seededRandom( s ) {
+
+	if ( s !== undefined ) _seed = s;
+
+	// Mulberry32 generator
+
+	let t = _seed += 0x6D2B79F5;
+
+	t = Math.imul( t ^ t >>> 15, t | 1 );
+
+	t ^= t + Math.imul( t ^ t >>> 7, t | 61 );
+
+	return ( ( t ^ t >>> 14 ) >>> 0 ) / 4294967296;
+
+}
+
+function degToRad( degrees ) {
+
+	return degrees * DEG2RAD;
+
+}
+
+function radToDeg( radians ) {
+
+	return radians * RAD2DEG;
+
+}
+
+function isPowerOfTwo( value ) {
+
+	return ( value & ( value - 1 ) ) === 0 && value !== 0;
+
+}
+
+function ceilPowerOfTwo( value ) {
+
+	return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );
+
+}
+
+function floorPowerOfTwo( value ) {
+
+	return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );
+
+}
+
+function setQuaternionFromProperEuler( q, a, b, c, order ) {
+
+	// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
+
+	// rotations are applied to the axes in the order specified by 'order'
+	// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
+	// angles are in radians
+
+	const cos = Math.cos;
+	const sin = Math.sin;
+
+	const c2 = cos( b / 2 );
+	const s2 = sin( b / 2 );
+
+	const c13 = cos( ( a + c ) / 2 );
+	const s13 = sin( ( a + c ) / 2 );
+
+	const c1_3 = cos( ( a - c ) / 2 );
+	const s1_3 = sin( ( a - c ) / 2 );
+
+	const c3_1 = cos( ( c - a ) / 2 );
+	const s3_1 = sin( ( c - a ) / 2 );
+
+	switch ( order ) {
+
+		case 'XYX':
+			q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
+			break;
+
+		case 'YZY':
+			q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
+			break;
+
+		case 'ZXZ':
+			q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
+			break;
+
+		case 'XZX':
+			q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
+			break;
+
+		case 'YXY':
+			q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
+			break;
+
+		case 'ZYZ':
+			q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
+			break;
+
+		default:
+			console.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );
+
+	}
+
+}
+
+function denormalize( value, array ) {
+
+	switch ( array.constructor ) {
+
+		case Float32Array:
+
+			return value;
+
+		case Uint32Array:
+
+			return value / 4294967295.0;
+
+		case Uint16Array:
+
+			return value / 65535.0;
+
+		case Uint8Array:
+
+			return value / 255.0;
+
+		case Int32Array:
+
+			return Math.max( value / 2147483647.0, - 1.0 );
+
+		case Int16Array:
+
+			return Math.max( value / 32767.0, - 1.0 );
+
+		case Int8Array:
+
+			return Math.max( value / 127.0, - 1.0 );
+
+		default:
+
+			throw new Error( 'Invalid component type.' );
+
+	}
+
+}
+
+function normalize( value, array ) {
+
+	switch ( array.constructor ) {
+
+		case Float32Array:
+
+			return value;
+
+		case Uint32Array:
+
+			return Math.round( value * 4294967295.0 );
+
+		case Uint16Array:
+
+			return Math.round( value * 65535.0 );
+
+		case Uint8Array:
+
+			return Math.round( value * 255.0 );
+
+		case Int32Array:
+
+			return Math.round( value * 2147483647.0 );
+
+		case Int16Array:
+
+			return Math.round( value * 32767.0 );
+
+		case Int8Array:
+
+			return Math.round( value * 127.0 );
+
+		default:
+
+			throw new Error( 'Invalid component type.' );
+
+	}
+
+}
+
+const MathUtils = {
+	DEG2RAD: DEG2RAD,
+	RAD2DEG: RAD2DEG,
+	generateUUID: generateUUID,
+	clamp: clamp,
+	euclideanModulo: euclideanModulo,
+	mapLinear: mapLinear,
+	inverseLerp: inverseLerp,
+	lerp: lerp,
+	damp: damp,
+	pingpong: pingpong,
+	smoothstep: smoothstep,
+	smootherstep: smootherstep,
+	randInt: randInt,
+	randFloat: randFloat,
+	randFloatSpread: randFloatSpread,
+	seededRandom: seededRandom,
+	degToRad: degToRad,
+	radToDeg: radToDeg,
+	isPowerOfTwo: isPowerOfTwo,
+	ceilPowerOfTwo: ceilPowerOfTwo,
+	floorPowerOfTwo: floorPowerOfTwo,
+	setQuaternionFromProperEuler: setQuaternionFromProperEuler,
+	normalize: normalize,
+	denormalize: denormalize
+};
+
+class Vector2 {
+
+	constructor( x = 0, y = 0 ) {
+
+		Vector2.prototype.isVector2 = true;
+
+		this.x = x;
+		this.y = y;
+
+	}
+
+	get width() {
+
+		return this.x;
+
+	}
+
+	set width( value ) {
+
+		this.x = value;
+
+	}
+
+	get height() {
+
+		return this.y;
+
+	}
+
+	set height( value ) {
+
+		this.y = value;
+
+	}
+
+	set( x, y ) {
+
+		this.x = x;
+		this.y = y;
+
+		return this;
+
+	}
+
+	setScalar( scalar ) {
+
+		this.x = scalar;
+		this.y = scalar;
+
+		return this;
+
+	}
+
+	setX( x ) {
+
+		this.x = x;
+
+		return this;
+
+	}
+
+	setY( y ) {
+
+		this.y = y;
+
+		return this;
+
+	}
+
+	setComponent( index, value ) {
+
+		switch ( index ) {
+
+			case 0: this.x = value; break;
+			case 1: this.y = value; break;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+		return this;
+
+	}
+
+	getComponent( index ) {
+
+		switch ( index ) {
+
+			case 0: return this.x;
+			case 1: return this.y;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+	}
+
+	clone() {
+
+		return new this.constructor( this.x, this.y );
+
+	}
+
+	copy( v ) {
+
+		this.x = v.x;
+		this.y = v.y;
+
+		return this;
+
+	}
+
+	add( v ) {
+
+		this.x += v.x;
+		this.y += v.y;
+
+		return this;
+
+	}
+
+	addScalar( s ) {
+
+		this.x += s;
+		this.y += s;
+
+		return this;
+
+	}
+
+	addVectors( a, b ) {
+
+		this.x = a.x + b.x;
+		this.y = a.y + b.y;
+
+		return this;
+
+	}
+
+	addScaledVector( v, s ) {
+
+		this.x += v.x * s;
+		this.y += v.y * s;
+
+		return this;
+
+	}
+
+	sub( v ) {
+
+		this.x -= v.x;
+		this.y -= v.y;
+
+		return this;
+
+	}
+
+	subScalar( s ) {
+
+		this.x -= s;
+		this.y -= s;
+
+		return this;
+
+	}
+
+	subVectors( a, b ) {
+
+		this.x = a.x - b.x;
+		this.y = a.y - b.y;
+
+		return this;
+
+	}
+
+	multiply( v ) {
+
+		this.x *= v.x;
+		this.y *= v.y;
+
+		return this;
+
+	}
+
+	multiplyScalar( scalar ) {
+
+		this.x *= scalar;
+		this.y *= scalar;
+
+		return this;
+
+	}
+
+	divide( v ) {
+
+		this.x /= v.x;
+		this.y /= v.y;
+
+		return this;
+
+	}
+
+	divideScalar( scalar ) {
+
+		return this.multiplyScalar( 1 / scalar );
+
+	}
+
+	applyMatrix3( m ) {
+
+		const x = this.x, y = this.y;
+		const e = m.elements;
+
+		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
+		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];
+
+		return this;
+
+	}
+
+	min( v ) {
+
+		this.x = Math.min( this.x, v.x );
+		this.y = Math.min( this.y, v.y );
+
+		return this;
+
+	}
+
+	max( v ) {
+
+		this.x = Math.max( this.x, v.x );
+		this.y = Math.max( this.y, v.y );
+
+		return this;
+
+	}
+
+	clamp( min, max ) {
+
+		// assumes min < max, componentwise
+
+		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
+		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
+
+		return this;
+
+	}
+
+	clampScalar( minVal, maxVal ) {
+
+		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
+		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
+
+		return this;
+
+	}
+
+	clampLength( min, max ) {
+
+		const length = this.length();
+
+		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
+
+	}
+
+	floor() {
+
+		this.x = Math.floor( this.x );
+		this.y = Math.floor( this.y );
+
+		return this;
+
+	}
+
+	ceil() {
+
+		this.x = Math.ceil( this.x );
+		this.y = Math.ceil( this.y );
+
+		return this;
+
+	}
+
+	round() {
+
+		this.x = Math.round( this.x );
+		this.y = Math.round( this.y );
+
+		return this;
+
+	}
+
+	roundToZero() {
+
+		this.x = Math.trunc( this.x );
+		this.y = Math.trunc( this.y );
+
+		return this;
+
+	}
+
+	negate() {
+
+		this.x = - this.x;
+		this.y = - this.y;
+
+		return this;
+
+	}
+
+	dot( v ) {
+
+		return this.x * v.x + this.y * v.y;
+
+	}
+
+	cross( v ) {
+
+		return this.x * v.y - this.y * v.x;
+
+	}
+
+	lengthSq() {
+
+		return this.x * this.x + this.y * this.y;
+
+	}
+
+	length() {
+
+		return Math.sqrt( this.x * this.x + this.y * this.y );
+
+	}
+
+	manhattanLength() {
+
+		return Math.abs( this.x ) + Math.abs( this.y );
+
+	}
+
+	normalize() {
+
+		return this.divideScalar( this.length() || 1 );
+
+	}
+
+	angle() {
+
+		// computes the angle in radians with respect to the positive x-axis
+
+		const angle = Math.atan2( - this.y, - this.x ) + Math.PI;
+
+		return angle;
+
+	}
+
+	angleTo( v ) {
+
+		const denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );
+
+		if ( denominator === 0 ) return Math.PI / 2;
+
+		const theta = this.dot( v ) / denominator;
+
+		// clamp, to handle numerical problems
+
+		return Math.acos( clamp( theta, - 1, 1 ) );
+
+	}
+
+	distanceTo( v ) {
+
+		return Math.sqrt( this.distanceToSquared( v ) );
+
+	}
+
+	distanceToSquared( v ) {
+
+		const dx = this.x - v.x, dy = this.y - v.y;
+		return dx * dx + dy * dy;
+
+	}
+
+	manhattanDistanceTo( v ) {
+
+		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
+
+	}
+
+	setLength( length ) {
+
+		return this.normalize().multiplyScalar( length );
+
+	}
+
+	lerp( v, alpha ) {
+
+		this.x += ( v.x - this.x ) * alpha;
+		this.y += ( v.y - this.y ) * alpha;
+
+		return this;
+
+	}
+
+	lerpVectors( v1, v2, alpha ) {
+
+		this.x = v1.x + ( v2.x - v1.x ) * alpha;
+		this.y = v1.y + ( v2.y - v1.y ) * alpha;
+
+		return this;
+
+	}
+
+	equals( v ) {
+
+		return ( ( v.x === this.x ) && ( v.y === this.y ) );
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		this.x = array[ offset ];
+		this.y = array[ offset + 1 ];
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this.x;
+		array[ offset + 1 ] = this.y;
+
+		return array;
+
+	}
+
+	fromBufferAttribute( attribute, index ) {
+
+		this.x = attribute.getX( index );
+		this.y = attribute.getY( index );
+
+		return this;
+
+	}
+
+	rotateAround( center, angle ) {
+
+		const c = Math.cos( angle ), s = Math.sin( angle );
+
+		const x = this.x - center.x;
+		const y = this.y - center.y;
+
+		this.x = x * c - y * s + center.x;
+		this.y = x * s + y * c + center.y;
+
+		return this;
+
+	}
+
+	random() {
+
+		this.x = Math.random();
+		this.y = Math.random();
+
+		return this;
+
+	}
+
+	*[ Symbol.iterator ]() {
+
+		yield this.x;
+		yield this.y;
+
+	}
+
+}
+
+class Matrix3 {
+
+	constructor( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
+
+		Matrix3.prototype.isMatrix3 = true;
+
+		this.elements = [
+
+			1, 0, 0,
+			0, 1, 0,
+			0, 0, 1
+
+		];
+
+		if ( n11 !== undefined ) {
+
+			this.set( n11, n12, n13, n21, n22, n23, n31, n32, n33 );
+
+		}
+
+	}
+
+	set( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
+
+		const te = this.elements;
+
+		te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
+		te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
+		te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
+
+		return this;
+
+	}
+
+	identity() {
+
+		this.set(
+
+			1, 0, 0,
+			0, 1, 0,
+			0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	copy( m ) {
+
+		const te = this.elements;
+		const me = m.elements;
+
+		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
+		te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
+		te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
+
+		return this;
+
+	}
+
+	extractBasis( xAxis, yAxis, zAxis ) {
+
+		xAxis.setFromMatrix3Column( this, 0 );
+		yAxis.setFromMatrix3Column( this, 1 );
+		zAxis.setFromMatrix3Column( this, 2 );
+
+		return this;
+
+	}
+
+	setFromMatrix4( m ) {
+
+		const me = m.elements;
+
+		this.set(
+
+			me[ 0 ], me[ 4 ], me[ 8 ],
+			me[ 1 ], me[ 5 ], me[ 9 ],
+			me[ 2 ], me[ 6 ], me[ 10 ]
+
+		);
+
+		return this;
+
+	}
+
+	multiply( m ) {
+
+		return this.multiplyMatrices( this, m );
+
+	}
+
+	premultiply( m ) {
+
+		return this.multiplyMatrices( m, this );
+
+	}
+
+	multiplyMatrices( a, b ) {
+
+		const ae = a.elements;
+		const be = b.elements;
+		const te = this.elements;
+
+		const a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
+		const a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
+		const a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
+
+		const b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
+		const b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
+		const b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
+
+		te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
+		te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
+		te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
+
+		te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
+		te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
+		te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
+
+		te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
+		te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
+		te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
+
+		return this;
+
+	}
+
+	multiplyScalar( s ) {
+
+		const te = this.elements;
+
+		te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
+		te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
+		te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
+
+		return this;
+
+	}
+
+	determinant() {
+
+		const te = this.elements;
+
+		const a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
+			d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
+			g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
+
+		return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
+
+	}
+
+	invert() {
+
+		const te = this.elements,
+
+			n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ],
+			n12 = te[ 3 ], n22 = te[ 4 ], n32 = te[ 5 ],
+			n13 = te[ 6 ], n23 = te[ 7 ], n33 = te[ 8 ],
+
+			t11 = n33 * n22 - n32 * n23,
+			t12 = n32 * n13 - n33 * n12,
+			t13 = n23 * n12 - n22 * n13,
+
+			det = n11 * t11 + n21 * t12 + n31 * t13;
+
+		if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );
+
+		const detInv = 1 / det;
+
+		te[ 0 ] = t11 * detInv;
+		te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
+		te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
+
+		te[ 3 ] = t12 * detInv;
+		te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
+		te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
+
+		te[ 6 ] = t13 * detInv;
+		te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
+		te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
+
+		return this;
+
+	}
+
+	transpose() {
+
+		let tmp;
+		const m = this.elements;
+
+		tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
+		tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
+		tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
+
+		return this;
+
+	}
+
+	getNormalMatrix( matrix4 ) {
+
+		return this.setFromMatrix4( matrix4 ).invert().transpose();
+
+	}
+
+	transposeIntoArray( r ) {
+
+		const m = this.elements;
+
+		r[ 0 ] = m[ 0 ];
+		r[ 1 ] = m[ 3 ];
+		r[ 2 ] = m[ 6 ];
+		r[ 3 ] = m[ 1 ];
+		r[ 4 ] = m[ 4 ];
+		r[ 5 ] = m[ 7 ];
+		r[ 6 ] = m[ 2 ];
+		r[ 7 ] = m[ 5 ];
+		r[ 8 ] = m[ 8 ];
+
+		return this;
+
+	}
+
+	setUvTransform( tx, ty, sx, sy, rotation, cx, cy ) {
+
+		const c = Math.cos( rotation );
+		const s = Math.sin( rotation );
+
+		this.set(
+			sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
+			- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
+			0, 0, 1
+		);
+
+		return this;
+
+	}
+
+	//
+
+	scale( sx, sy ) {
+
+		this.premultiply( _m3.makeScale( sx, sy ) );
+
+		return this;
+
+	}
+
+	rotate( theta ) {
+
+		this.premultiply( _m3.makeRotation( - theta ) );
+
+		return this;
+
+	}
+
+	translate( tx, ty ) {
+
+		this.premultiply( _m3.makeTranslation( tx, ty ) );
+
+		return this;
+
+	}
+
+	// for 2D Transforms
+
+	makeTranslation( x, y ) {
+
+		if ( x.isVector2 ) {
+
+			this.set(
+
+				1, 0, x.x,
+				0, 1, x.y,
+				0, 0, 1
+
+			);
+
+		} else {
+
+			this.set(
+
+				1, 0, x,
+				0, 1, y,
+				0, 0, 1
+
+			);
+
+		}
+
+		return this;
+
+	}
+
+	makeRotation( theta ) {
+
+		// counterclockwise
+
+		const c = Math.cos( theta );
+		const s = Math.sin( theta );
+
+		this.set(
+
+			c, - s, 0,
+			s, c, 0,
+			0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	makeScale( x, y ) {
+
+		this.set(
+
+			x, 0, 0,
+			0, y, 0,
+			0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	//
+
+	equals( matrix ) {
+
+		const te = this.elements;
+		const me = matrix.elements;
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			if ( te[ i ] !== me[ i ] ) return false;
+
+		}
+
+		return true;
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.elements[ i ] = array[ i + offset ];
+
+		}
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		const te = this.elements;
+
+		array[ offset ] = te[ 0 ];
+		array[ offset + 1 ] = te[ 1 ];
+		array[ offset + 2 ] = te[ 2 ];
+
+		array[ offset + 3 ] = te[ 3 ];
+		array[ offset + 4 ] = te[ 4 ];
+		array[ offset + 5 ] = te[ 5 ];
+
+		array[ offset + 6 ] = te[ 6 ];
+		array[ offset + 7 ] = te[ 7 ];
+		array[ offset + 8 ] = te[ 8 ];
+
+		return array;
+
+	}
+
+	clone() {
+
+		return new this.constructor().fromArray( this.elements );
+
+	}
+
+}
+
+const _m3 = /*@__PURE__*/ new Matrix3();
+
+function arrayNeedsUint32( array ) {
+
+	// assumes larger values usually on last
+
+	for ( let i = array.length - 1; i >= 0; -- i ) {
+
+		if ( array[ i ] >= 65535 ) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
+
+	}
+
+	return false;
+
+}
+
+const TYPED_ARRAYS = {
+	Int8Array: Int8Array,
+	Uint8Array: Uint8Array,
+	Uint8ClampedArray: Uint8ClampedArray,
+	Int16Array: Int16Array,
+	Uint16Array: Uint16Array,
+	Int32Array: Int32Array,
+	Uint32Array: Uint32Array,
+	Float32Array: Float32Array,
+	Float64Array: Float64Array
+};
+
+function getTypedArray( type, buffer ) {
+
+	return new TYPED_ARRAYS[ type ]( buffer );
+
+}
+
+function createElementNS( name ) {
+
+	return document.createElementNS( 'http://www.w3.org/1999/xhtml', name );
+
+}
+
+function createCanvasElement() {
+
+	const canvas = createElementNS( 'canvas' );
+	canvas.style.display = 'block';
+	return canvas;
+
+}
+
+const _cache = {};
+
+function warnOnce( message ) {
+
+	if ( message in _cache ) return;
+
+	_cache[ message ] = true;
+
+	console.warn( message );
+
+}
+
+/**
+ * Matrices converting P3 <-> Rec. 709 primaries, without gamut mapping
+ * or clipping. Based on W3C specifications for sRGB and Display P3,
+ * and ICC specifications for the D50 connection space. Values in/out
+ * are _linear_ sRGB and _linear_ Display P3.
+ *
+ * Note that both sRGB and Display P3 use the sRGB transfer functions.
+ *
+ * Reference:
+ * - http://www.russellcottrell.com/photo/matrixCalculator.htm
+ */
+
+const LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = /*@__PURE__*/ new Matrix3().set(
+	0.8224621, 0.177538, 0.0,
+	0.0331941, 0.9668058, 0.0,
+	0.0170827, 0.0723974, 0.9105199,
+);
+
+const LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = /*@__PURE__*/ new Matrix3().set(
+	1.2249401, - 0.2249404, 0.0,
+	- 0.0420569, 1.0420571, 0.0,
+	- 0.0196376, - 0.0786361, 1.0982735
+);
+
+/**
+ * Defines supported color spaces by transfer function and primaries,
+ * and provides conversions to/from the Linear-sRGB reference space.
+ */
+const COLOR_SPACES = {
+	[ LinearSRGBColorSpace ]: {
+		transfer: LinearTransfer,
+		primaries: Rec709Primaries,
+		toReference: ( color ) => color,
+		fromReference: ( color ) => color,
+	},
+	[ SRGBColorSpace ]: {
+		transfer: SRGBTransfer,
+		primaries: Rec709Primaries,
+		toReference: ( color ) => color.convertSRGBToLinear(),
+		fromReference: ( color ) => color.convertLinearToSRGB(),
+	},
+	[ LinearDisplayP3ColorSpace ]: {
+		transfer: LinearTransfer,
+		primaries: P3Primaries,
+		toReference: ( color ) => color.applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
+		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ),
+	},
+	[ DisplayP3ColorSpace ]: {
+		transfer: SRGBTransfer,
+		primaries: P3Primaries,
+		toReference: ( color ) => color.convertSRGBToLinear().applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
+		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ).convertLinearToSRGB(),
+	},
+};
+
+const SUPPORTED_WORKING_COLOR_SPACES = new Set( [ LinearSRGBColorSpace, LinearDisplayP3ColorSpace ] );
+
+const ColorManagement = {
+
+	enabled: true,
+
+	_workingColorSpace: LinearSRGBColorSpace,
+
+	get workingColorSpace() {
+
+		return this._workingColorSpace;
+
+	},
+
+	set workingColorSpace( colorSpace ) {
+
+		if ( ! SUPPORTED_WORKING_COLOR_SPACES.has( colorSpace ) ) {
+
+			throw new Error( `Unsupported working color space, "${ colorSpace }".` );
+
+		}
+
+		this._workingColorSpace = colorSpace;
+
+	},
+
+	convert: function ( color, sourceColorSpace, targetColorSpace ) {
+
+		if ( this.enabled === false || sourceColorSpace === targetColorSpace || ! sourceColorSpace || ! targetColorSpace ) {
+
+			return color;
+
+		}
+
+		const sourceToReference = COLOR_SPACES[ sourceColorSpace ].toReference;
+		const targetFromReference = COLOR_SPACES[ targetColorSpace ].fromReference;
+
+		return targetFromReference( sourceToReference( color ) );
+
+	},
+
+	fromWorkingColorSpace: function ( color, targetColorSpace ) {
+
+		return this.convert( color, this._workingColorSpace, targetColorSpace );
+
+	},
+
+	toWorkingColorSpace: function ( color, sourceColorSpace ) {
+
+		return this.convert( color, sourceColorSpace, this._workingColorSpace );
+
+	},
+
+	getPrimaries: function ( colorSpace ) {
+
+		return COLOR_SPACES[ colorSpace ].primaries;
+
+	},
+
+	getTransfer: function ( colorSpace ) {
+
+		if ( colorSpace === NoColorSpace ) return LinearTransfer;
+
+		return COLOR_SPACES[ colorSpace ].transfer;
+
+	},
+
+};
+
+
+function SRGBToLinear( c ) {
+
+	return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );
+
+}
+
+function LinearToSRGB( c ) {
+
+	return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
+
+}
+
+let _canvas;
+
+class ImageUtils {
+
+	static getDataURL( image ) {
+
+		if ( /^data:/i.test( image.src ) ) {
+
+			return image.src;
+
+		}
+
+		if ( typeof HTMLCanvasElement === 'undefined' ) {
+
+			return image.src;
+
+		}
+
+		let canvas;
+
+		if ( image instanceof HTMLCanvasElement ) {
+
+			canvas = image;
+
+		} else {
+
+			if ( _canvas === undefined ) _canvas = createElementNS( 'canvas' );
+
+			_canvas.width = image.width;
+			_canvas.height = image.height;
+
+			const context = _canvas.getContext( '2d' );
+
+			if ( image instanceof ImageData ) {
+
+				context.putImageData( image, 0, 0 );
+
+			} else {
+
+				context.drawImage( image, 0, 0, image.width, image.height );
+
+			}
+
+			canvas = _canvas;
+
+		}
+
+		if ( canvas.width > 2048 || canvas.height > 2048 ) {
+
+			console.warn( 'THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image );
+
+			return canvas.toDataURL( 'image/jpeg', 0.6 );
+
+		} else {
+
+			return canvas.toDataURL( 'image/png' );
+
+		}
+
+	}
+
+	static sRGBToLinear( image ) {
+
+		if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
+			( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
+			( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
+
+			const canvas = createElementNS( 'canvas' );
+
+			canvas.width = image.width;
+			canvas.height = image.height;
+
+			const context = canvas.getContext( '2d' );
+			context.drawImage( image, 0, 0, image.width, image.height );
+
+			const imageData = context.getImageData( 0, 0, image.width, image.height );
+			const data = imageData.data;
+
+			for ( let i = 0; i < data.length; i ++ ) {
+
+				data[ i ] = SRGBToLinear( data[ i ] / 255 ) * 255;
+
+			}
+
+			context.putImageData( imageData, 0, 0 );
+
+			return canvas;
+
+		} else if ( image.data ) {
+
+			const data = image.data.slice( 0 );
+
+			for ( let i = 0; i < data.length; i ++ ) {
+
+				if ( data instanceof Uint8Array || data instanceof Uint8ClampedArray ) {
+
+					data[ i ] = Math.floor( SRGBToLinear( data[ i ] / 255 ) * 255 );
+
+				} else {
+
+					// assuming float
+
+					data[ i ] = SRGBToLinear( data[ i ] );
+
+				}
+
+			}
+
+			return {
+				data: data,
+				width: image.width,
+				height: image.height
+			};
+
+		} else {
+
+			console.warn( 'THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.' );
+			return image;
+
+		}
+
+	}
+
+}
+
+let _sourceId = 0;
+
+class Source {
+
+	constructor( data = null ) {
+
+		this.isSource = true;
+
+		Object.defineProperty( this, 'id', { value: _sourceId ++ } );
+
+		this.uuid = generateUUID();
+
+		this.data = data;
+
+		this.version = 0;
+
+	}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+	toJSON( meta ) {
+
+		const isRootObject = ( meta === undefined || typeof meta === 'string' );
+
+		if ( ! isRootObject && meta.images[ this.uuid ] !== undefined ) {
+
+			return meta.images[ this.uuid ];
+
+		}
+
+		const output = {
+			uuid: this.uuid,
+			url: ''
+		};
+
+		const data = this.data;
+
+		if ( data !== null ) {
+
+			let url;
+
+			if ( Array.isArray( data ) ) {
+
+				// cube texture
+
+				url = [];
+
+				for ( let i = 0, l = data.length; i < l; i ++ ) {
+
+					if ( data[ i ].isDataTexture ) {
+
+						url.push( serializeImage( data[ i ].image ) );
+
+					} else {
+
+						url.push( serializeImage( data[ i ] ) );
+
+					}
+
+				}
+
+			} else {
+
+				// texture
+
+				url = serializeImage( data );
+
+			}
+
+			output.url = url;
+
+		}
+
+		if ( ! isRootObject ) {
+
+			meta.images[ this.uuid ] = output;
+
+		}
+
+		return output;
+
+	}
+
+}
+
+function serializeImage( image ) {
+
+	if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
+		( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
+		( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
+
+		// default images
+
+		return ImageUtils.getDataURL( image );
+
+	} else {
+
+		if ( image.data ) {
+
+			// images of DataTexture
+
+			return {
+				data: Array.from( image.data ),
+				width: image.width,
+				height: image.height,
+				type: image.data.constructor.name
+			};
+
+		} else {
+
+			console.warn( 'THREE.Texture: Unable to serialize Texture.' );
+			return {};
+
+		}
+
+	}
+
+}
+
+let _textureId = 0;
+
+class Texture extends EventDispatcher {
+
+	constructor( image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace ) {
+
+		super();
+
+		this.isTexture = true;
+
+		Object.defineProperty( this, 'id', { value: _textureId ++ } );
+
+		this.uuid = generateUUID();
+
+		this.name = '';
+
+		this.source = new Source( image );
+		this.mipmaps = [];
+
+		this.mapping = mapping;
+		this.channel = 0;
+
+		this.wrapS = wrapS;
+		this.wrapT = wrapT;
+
+		this.magFilter = magFilter;
+		this.minFilter = minFilter;
+
+		this.anisotropy = anisotropy;
+
+		this.format = format;
+		this.internalFormat = null;
+		this.type = type;
+
+		this.offset = new Vector2( 0, 0 );
+		this.repeat = new Vector2( 1, 1 );
+		this.center = new Vector2( 0, 0 );
+		this.rotation = 0;
+
+		this.matrixAutoUpdate = true;
+		this.matrix = new Matrix3();
+
+		this.generateMipmaps = true;
+		this.premultiplyAlpha = false;
+		this.flipY = true;
+		this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
+
+		if ( typeof colorSpace === 'string' ) {
+
+			this.colorSpace = colorSpace;
+
+		} else { // @deprecated, r152
+
+			warnOnce( 'THREE.Texture: Property .encoding has been replaced by .colorSpace.' );
+			this.colorSpace = colorSpace === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
+
+		}
+
+
+		this.userData = {};
+
+		this.version = 0;
+		this.onUpdate = null;
+
+		this.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not
+		this.needsPMREMUpdate = false; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)
+
+	}
+
+	get image() {
+
+		return this.source.data;
+
+	}
+
+	set image( value = null ) {
+
+		this.source.data = value;
+
+	}
+
+	updateMatrix() {
+
+		this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( source ) {
+
+		this.name = source.name;
+
+		this.source = source.source;
+		this.mipmaps = source.mipmaps.slice( 0 );
+
+		this.mapping = source.mapping;
+		this.channel = source.channel;
+
+		this.wrapS = source.wrapS;
+		this.wrapT = source.wrapT;
+
+		this.magFilter = source.magFilter;
+		this.minFilter = source.minFilter;
+
+		this.anisotropy = source.anisotropy;
+
+		this.format = source.format;
+		this.internalFormat = source.internalFormat;
+		this.type = source.type;
+
+		this.offset.copy( source.offset );
+		this.repeat.copy( source.repeat );
+		this.center.copy( source.center );
+		this.rotation = source.rotation;
+
+		this.matrixAutoUpdate = source.matrixAutoUpdate;
+		this.matrix.copy( source.matrix );
+
+		this.generateMipmaps = source.generateMipmaps;
+		this.premultiplyAlpha = source.premultiplyAlpha;
+		this.flipY = source.flipY;
+		this.unpackAlignment = source.unpackAlignment;
+		this.colorSpace = source.colorSpace;
+
+		this.userData = JSON.parse( JSON.stringify( source.userData ) );
+
+		this.needsUpdate = true;
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const isRootObject = ( meta === undefined || typeof meta === 'string' );
+
+		if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {
+
+			return meta.textures[ this.uuid ];
+
+		}
+
+		const output = {
+
+			metadata: {
+				version: 4.6,
+				type: 'Texture',
+				generator: 'Texture.toJSON'
+			},
+
+			uuid: this.uuid,
+			name: this.name,
+
+			image: this.source.toJSON( meta ).uuid,
+
+			mapping: this.mapping,
+			channel: this.channel,
+
+			repeat: [ this.repeat.x, this.repeat.y ],
+			offset: [ this.offset.x, this.offset.y ],
+			center: [ this.center.x, this.center.y ],
+			rotation: this.rotation,
+
+			wrap: [ this.wrapS, this.wrapT ],
+
+			format: this.format,
+			internalFormat: this.internalFormat,
+			type: this.type,
+			colorSpace: this.colorSpace,
+
+			minFilter: this.minFilter,
+			magFilter: this.magFilter,
+			anisotropy: this.anisotropy,
+
+			flipY: this.flipY,
+
+			generateMipmaps: this.generateMipmaps,
+			premultiplyAlpha: this.premultiplyAlpha,
+			unpackAlignment: this.unpackAlignment
+
+		};
+
+		if ( Object.keys( this.userData ).length > 0 ) output.userData = this.userData;
+
+		if ( ! isRootObject ) {
+
+			meta.textures[ this.uuid ] = output;
+
+		}
+
+		return output;
+
+	}
+
+	dispose() {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+	transformUv( uv ) {
+
+		if ( this.mapping !== UVMapping ) return uv;
+
+		uv.applyMatrix3( this.matrix );
+
+		if ( uv.x < 0 || uv.x > 1 ) {
+
+			switch ( this.wrapS ) {
+
+				case RepeatWrapping:
+
+					uv.x = uv.x - Math.floor( uv.x );
+					break;
+
+				case ClampToEdgeWrapping:
+
+					uv.x = uv.x < 0 ? 0 : 1;
+					break;
+
+				case MirroredRepeatWrapping:
+
+					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
+
+						uv.x = Math.ceil( uv.x ) - uv.x;
+
+					} else {
+
+						uv.x = uv.x - Math.floor( uv.x );
+
+					}
+
+					break;
+
+			}
+
+		}
+
+		if ( uv.y < 0 || uv.y > 1 ) {
+
+			switch ( this.wrapT ) {
+
+				case RepeatWrapping:
+
+					uv.y = uv.y - Math.floor( uv.y );
+					break;
+
+				case ClampToEdgeWrapping:
+
+					uv.y = uv.y < 0 ? 0 : 1;
+					break;
+
+				case MirroredRepeatWrapping:
+
+					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
+
+						uv.y = Math.ceil( uv.y ) - uv.y;
+
+					} else {
+
+						uv.y = uv.y - Math.floor( uv.y );
+
+					}
+
+					break;
+
+			}
+
+		}
+
+		if ( this.flipY ) {
+
+			uv.y = 1 - uv.y;
+
+		}
+
+		return uv;
+
+	}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) {
+
+			this.version ++;
+			this.source.needsUpdate = true;
+
+		}
+
+	}
+
+	get encoding() { // @deprecated, r152
+
+		warnOnce( 'THREE.Texture: Property .encoding has been replaced by .colorSpace.' );
+		return this.colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
+
+	}
+
+	set encoding( encoding ) { // @deprecated, r152
+
+		warnOnce( 'THREE.Texture: Property .encoding has been replaced by .colorSpace.' );
+		this.colorSpace = encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
+
+	}
+
+}
+
+Texture.DEFAULT_IMAGE = null;
+Texture.DEFAULT_MAPPING = UVMapping;
+Texture.DEFAULT_ANISOTROPY = 1;
+
+class Vector4 {
+
+	constructor( x = 0, y = 0, z = 0, w = 1 ) {
+
+		Vector4.prototype.isVector4 = true;
+
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.w = w;
+
+	}
+
+	get width() {
+
+		return this.z;
+
+	}
+
+	set width( value ) {
+
+		this.z = value;
+
+	}
+
+	get height() {
+
+		return this.w;
+
+	}
+
+	set height( value ) {
+
+		this.w = value;
+
+	}
+
+	set( x, y, z, w ) {
+
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.w = w;
+
+		return this;
+
+	}
+
+	setScalar( scalar ) {
+
+		this.x = scalar;
+		this.y = scalar;
+		this.z = scalar;
+		this.w = scalar;
+
+		return this;
+
+	}
+
+	setX( x ) {
+
+		this.x = x;
+
+		return this;
+
+	}
+
+	setY( y ) {
+
+		this.y = y;
+
+		return this;
+
+	}
+
+	setZ( z ) {
+
+		this.z = z;
+
+		return this;
+
+	}
+
+	setW( w ) {
+
+		this.w = w;
+
+		return this;
+
+	}
+
+	setComponent( index, value ) {
+
+		switch ( index ) {
+
+			case 0: this.x = value; break;
+			case 1: this.y = value; break;
+			case 2: this.z = value; break;
+			case 3: this.w = value; break;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+		return this;
+
+	}
+
+	getComponent( index ) {
+
+		switch ( index ) {
+
+			case 0: return this.x;
+			case 1: return this.y;
+			case 2: return this.z;
+			case 3: return this.w;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+	}
+
+	clone() {
+
+		return new this.constructor( this.x, this.y, this.z, this.w );
+
+	}
+
+	copy( v ) {
+
+		this.x = v.x;
+		this.y = v.y;
+		this.z = v.z;
+		this.w = ( v.w !== undefined ) ? v.w : 1;
+
+		return this;
+
+	}
+
+	add( v ) {
+
+		this.x += v.x;
+		this.y += v.y;
+		this.z += v.z;
+		this.w += v.w;
+
+		return this;
+
+	}
+
+	addScalar( s ) {
+
+		this.x += s;
+		this.y += s;
+		this.z += s;
+		this.w += s;
+
+		return this;
+
+	}
+
+	addVectors( a, b ) {
+
+		this.x = a.x + b.x;
+		this.y = a.y + b.y;
+		this.z = a.z + b.z;
+		this.w = a.w + b.w;
+
+		return this;
+
+	}
+
+	addScaledVector( v, s ) {
+
+		this.x += v.x * s;
+		this.y += v.y * s;
+		this.z += v.z * s;
+		this.w += v.w * s;
+
+		return this;
+
+	}
+
+	sub( v ) {
+
+		this.x -= v.x;
+		this.y -= v.y;
+		this.z -= v.z;
+		this.w -= v.w;
+
+		return this;
+
+	}
+
+	subScalar( s ) {
+
+		this.x -= s;
+		this.y -= s;
+		this.z -= s;
+		this.w -= s;
+
+		return this;
+
+	}
+
+	subVectors( a, b ) {
+
+		this.x = a.x - b.x;
+		this.y = a.y - b.y;
+		this.z = a.z - b.z;
+		this.w = a.w - b.w;
+
+		return this;
+
+	}
+
+	multiply( v ) {
+
+		this.x *= v.x;
+		this.y *= v.y;
+		this.z *= v.z;
+		this.w *= v.w;
+
+		return this;
+
+	}
+
+	multiplyScalar( scalar ) {
+
+		this.x *= scalar;
+		this.y *= scalar;
+		this.z *= scalar;
+		this.w *= scalar;
+
+		return this;
+
+	}
+
+	applyMatrix4( m ) {
+
+		const x = this.x, y = this.y, z = this.z, w = this.w;
+		const e = m.elements;
+
+		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
+		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
+		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
+		this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
+
+		return this;
+
+	}
+
+	divideScalar( scalar ) {
+
+		return this.multiplyScalar( 1 / scalar );
+
+	}
+
+	setAxisAngleFromQuaternion( q ) {
+
+		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
+
+		// q is assumed to be normalized
+
+		this.w = 2 * Math.acos( q.w );
+
+		const s = Math.sqrt( 1 - q.w * q.w );
+
+		if ( s < 0.0001 ) {
+
+			this.x = 1;
+			this.y = 0;
+			this.z = 0;
+
+		} else {
+
+			this.x = q.x / s;
+			this.y = q.y / s;
+			this.z = q.z / s;
+
+		}
+
+		return this;
+
+	}
+
+	setAxisAngleFromRotationMatrix( m ) {
+
+		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		let angle, x, y, z; // variables for result
+		const epsilon = 0.01,		// margin to allow for rounding errors
+			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
+
+			te = m.elements,
+
+			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
+			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
+			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
+
+		if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
+		     ( Math.abs( m13 - m31 ) < epsilon ) &&
+		     ( Math.abs( m23 - m32 ) < epsilon ) ) {
+
+			// singularity found
+			// first check for identity matrix which must have +1 for all terms
+			// in leading diagonal and zero in other terms
+
+			if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
+			     ( Math.abs( m13 + m31 ) < epsilon2 ) &&
+			     ( Math.abs( m23 + m32 ) < epsilon2 ) &&
+			     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
+
+				// this singularity is identity matrix so angle = 0
+
+				this.set( 1, 0, 0, 0 );
+
+				return this; // zero angle, arbitrary axis
+
+			}
+
+			// otherwise this singularity is angle = 180
+
+			angle = Math.PI;
+
+			const xx = ( m11 + 1 ) / 2;
+			const yy = ( m22 + 1 ) / 2;
+			const zz = ( m33 + 1 ) / 2;
+			const xy = ( m12 + m21 ) / 4;
+			const xz = ( m13 + m31 ) / 4;
+			const yz = ( m23 + m32 ) / 4;
+
+			if ( ( xx > yy ) && ( xx > zz ) ) {
+
+				// m11 is the largest diagonal term
+
+				if ( xx < epsilon ) {
+
+					x = 0;
+					y = 0.707106781;
+					z = 0.707106781;
+
+				} else {
+
+					x = Math.sqrt( xx );
+					y = xy / x;
+					z = xz / x;
+
+				}
+
+			} else if ( yy > zz ) {
+
+				// m22 is the largest diagonal term
+
+				if ( yy < epsilon ) {
+
+					x = 0.707106781;
+					y = 0;
+					z = 0.707106781;
+
+				} else {
+
+					y = Math.sqrt( yy );
+					x = xy / y;
+					z = yz / y;
+
+				}
+
+			} else {
+
+				// m33 is the largest diagonal term so base result on this
+
+				if ( zz < epsilon ) {
+
+					x = 0.707106781;
+					y = 0.707106781;
+					z = 0;
+
+				} else {
+
+					z = Math.sqrt( zz );
+					x = xz / z;
+					y = yz / z;
+
+				}
+
+			}
+
+			this.set( x, y, z, angle );
+
+			return this; // return 180 deg rotation
+
+		}
+
+		// as we have reached here there are no singularities so we can handle normally
+
+		let s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
+			( m13 - m31 ) * ( m13 - m31 ) +
+			( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
+
+		if ( Math.abs( s ) < 0.001 ) s = 1;
+
+		// prevent divide by zero, should not happen if matrix is orthogonal and should be
+		// caught by singularity test above, but I've left it in just in case
+
+		this.x = ( m32 - m23 ) / s;
+		this.y = ( m13 - m31 ) / s;
+		this.z = ( m21 - m12 ) / s;
+		this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
+
+		return this;
+
+	}
+
+	min( v ) {
+
+		this.x = Math.min( this.x, v.x );
+		this.y = Math.min( this.y, v.y );
+		this.z = Math.min( this.z, v.z );
+		this.w = Math.min( this.w, v.w );
+
+		return this;
+
+	}
+
+	max( v ) {
+
+		this.x = Math.max( this.x, v.x );
+		this.y = Math.max( this.y, v.y );
+		this.z = Math.max( this.z, v.z );
+		this.w = Math.max( this.w, v.w );
+
+		return this;
+
+	}
+
+	clamp( min, max ) {
+
+		// assumes min < max, componentwise
+
+		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
+		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
+		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
+		this.w = Math.max( min.w, Math.min( max.w, this.w ) );
+
+		return this;
+
+	}
+
+	clampScalar( minVal, maxVal ) {
+
+		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
+		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
+		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
+		this.w = Math.max( minVal, Math.min( maxVal, this.w ) );
+
+		return this;
+
+	}
+
+	clampLength( min, max ) {
+
+		const length = this.length();
+
+		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
+
+	}
+
+	floor() {
+
+		this.x = Math.floor( this.x );
+		this.y = Math.floor( this.y );
+		this.z = Math.floor( this.z );
+		this.w = Math.floor( this.w );
+
+		return this;
+
+	}
+
+	ceil() {
+
+		this.x = Math.ceil( this.x );
+		this.y = Math.ceil( this.y );
+		this.z = Math.ceil( this.z );
+		this.w = Math.ceil( this.w );
+
+		return this;
+
+	}
+
+	round() {
+
+		this.x = Math.round( this.x );
+		this.y = Math.round( this.y );
+		this.z = Math.round( this.z );
+		this.w = Math.round( this.w );
+
+		return this;
+
+	}
+
+	roundToZero() {
+
+		this.x = Math.trunc( this.x );
+		this.y = Math.trunc( this.y );
+		this.z = Math.trunc( this.z );
+		this.w = Math.trunc( this.w );
+
+		return this;
+
+	}
+
+	negate() {
+
+		this.x = - this.x;
+		this.y = - this.y;
+		this.z = - this.z;
+		this.w = - this.w;
+
+		return this;
+
+	}
+
+	dot( v ) {
+
+		return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+
+	}
+
+	lengthSq() {
+
+		return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+
+	}
+
+	length() {
+
+		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );
+
+	}
+
+	manhattanLength() {
+
+		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
+
+	}
+
+	normalize() {
+
+		return this.divideScalar( this.length() || 1 );
+
+	}
+
+	setLength( length ) {
+
+		return this.normalize().multiplyScalar( length );
+
+	}
+
+	lerp( v, alpha ) {
+
+		this.x += ( v.x - this.x ) * alpha;
+		this.y += ( v.y - this.y ) * alpha;
+		this.z += ( v.z - this.z ) * alpha;
+		this.w += ( v.w - this.w ) * alpha;
+
+		return this;
+
+	}
+
+	lerpVectors( v1, v2, alpha ) {
+
+		this.x = v1.x + ( v2.x - v1.x ) * alpha;
+		this.y = v1.y + ( v2.y - v1.y ) * alpha;
+		this.z = v1.z + ( v2.z - v1.z ) * alpha;
+		this.w = v1.w + ( v2.w - v1.w ) * alpha;
+
+		return this;
+
+	}
+
+	equals( v ) {
+
+		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		this.x = array[ offset ];
+		this.y = array[ offset + 1 ];
+		this.z = array[ offset + 2 ];
+		this.w = array[ offset + 3 ];
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this.x;
+		array[ offset + 1 ] = this.y;
+		array[ offset + 2 ] = this.z;
+		array[ offset + 3 ] = this.w;
+
+		return array;
+
+	}
+
+	fromBufferAttribute( attribute, index ) {
+
+		this.x = attribute.getX( index );
+		this.y = attribute.getY( index );
+		this.z = attribute.getZ( index );
+		this.w = attribute.getW( index );
+
+		return this;
+
+	}
+
+	random() {
+
+		this.x = Math.random();
+		this.y = Math.random();
+		this.z = Math.random();
+		this.w = Math.random();
+
+		return this;
+
+	}
+
+	*[ Symbol.iterator ]() {
+
+		yield this.x;
+		yield this.y;
+		yield this.z;
+		yield this.w;
+
+	}
+
+}
+
+/*
+ In options, we can specify:
+ * Texture parameters for an auto-generated target texture
+ * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
+*/
+class RenderTarget extends EventDispatcher {
+
+	constructor( width = 1, height = 1, options = {} ) {
+
+		super();
+
+		this.isRenderTarget = true;
+
+		this.width = width;
+		this.height = height;
+		this.depth = 1;
+
+		this.scissor = new Vector4( 0, 0, width, height );
+		this.scissorTest = false;
+
+		this.viewport = new Vector4( 0, 0, width, height );
+
+		const image = { width: width, height: height, depth: 1 };
+
+		if ( options.encoding !== undefined ) {
+
+			// @deprecated, r152
+			warnOnce( 'THREE.WebGLRenderTarget: option.encoding has been replaced by option.colorSpace.' );
+			options.colorSpace = options.encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
+
+		}
+
+		options = Object.assign( {
+			generateMipmaps: false,
+			internalFormat: null,
+			minFilter: LinearFilter,
+			depthBuffer: true,
+			stencilBuffer: false,
+			depthTexture: null,
+			samples: 0
+		}, options );
+
+		this.texture = new Texture( image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace );
+		this.texture.isRenderTargetTexture = true;
+
+		this.texture.flipY = false;
+		this.texture.generateMipmaps = options.generateMipmaps;
+		this.texture.internalFormat = options.internalFormat;
+
+		this.depthBuffer = options.depthBuffer;
+		this.stencilBuffer = options.stencilBuffer;
+
+		this.depthTexture = options.depthTexture;
+
+		this.samples = options.samples;
+
+	}
+
+	setSize( width, height, depth = 1 ) {
+
+		if ( this.width !== width || this.height !== height || this.depth !== depth ) {
+
+			this.width = width;
+			this.height = height;
+			this.depth = depth;
+
+			this.texture.image.width = width;
+			this.texture.image.height = height;
+			this.texture.image.depth = depth;
+
+			this.dispose();
+
+		}
+
+		this.viewport.set( 0, 0, width, height );
+		this.scissor.set( 0, 0, width, height );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( source ) {
+
+		this.width = source.width;
+		this.height = source.height;
+		this.depth = source.depth;
+
+		this.scissor.copy( source.scissor );
+		this.scissorTest = source.scissorTest;
+
+		this.viewport.copy( source.viewport );
+
+		this.texture = source.texture.clone();
+		this.texture.isRenderTargetTexture = true;
+
+		// ensure image object is not shared, see #20328
+
+		const image = Object.assign( {}, source.texture.image );
+		this.texture.source = new Source( image );
+
+		this.depthBuffer = source.depthBuffer;
+		this.stencilBuffer = source.stencilBuffer;
+
+		if ( source.depthTexture !== null ) this.depthTexture = source.depthTexture.clone();
+
+		this.samples = source.samples;
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+}
+
+class WebGLRenderTarget extends RenderTarget {
+
+	constructor( width = 1, height = 1, options = {} ) {
+
+		super( width, height, options );
+
+		this.isWebGLRenderTarget = true;
+
+	}
+
+}
+
+class DataArrayTexture extends Texture {
+
+	constructor( data = null, width = 1, height = 1, depth = 1 ) {
+
+		super( null );
+
+		this.isDataArrayTexture = true;
+
+		this.image = { data, width, height, depth };
+
+		this.magFilter = NearestFilter;
+		this.minFilter = NearestFilter;
+
+		this.wrapR = ClampToEdgeWrapping;
+
+		this.generateMipmaps = false;
+		this.flipY = false;
+		this.unpackAlignment = 1;
+
+	}
+
+}
+
+class WebGLArrayRenderTarget extends WebGLRenderTarget {
+
+	constructor( width = 1, height = 1, depth = 1, options = {} ) {
+
+		super( width, height, options );
+
+		this.isWebGLArrayRenderTarget = true;
+
+		this.depth = depth;
+
+		this.texture = new DataArrayTexture( null, width, height, depth );
+
+		this.texture.isRenderTargetTexture = true;
+
+	}
+
+}
+
+class Data3DTexture extends Texture {
+
+	constructor( data = null, width = 1, height = 1, depth = 1 ) {
+
+		// We're going to add .setXXX() methods for setting properties later.
+		// Users can still set in DataTexture3D directly.
+		//
+		//	const texture = new THREE.DataTexture3D( data, width, height, depth );
+		// 	texture.anisotropy = 16;
+		//
+		// See #14839
+
+		super( null );
+
+		this.isData3DTexture = true;
+
+		this.image = { data, width, height, depth };
+
+		this.magFilter = NearestFilter;
+		this.minFilter = NearestFilter;
+
+		this.wrapR = ClampToEdgeWrapping;
+
+		this.generateMipmaps = false;
+		this.flipY = false;
+		this.unpackAlignment = 1;
+
+	}
+
+}
+
+class WebGL3DRenderTarget extends WebGLRenderTarget {
+
+	constructor( width = 1, height = 1, depth = 1, options = {} ) {
+
+		super( width, height, options );
+
+		this.isWebGL3DRenderTarget = true;
+
+		this.depth = depth;
+
+		this.texture = new Data3DTexture( null, width, height, depth );
+
+		this.texture.isRenderTargetTexture = true;
+
+	}
+
+}
+
+class WebGLMultipleRenderTargets extends WebGLRenderTarget {
+
+	constructor( width = 1, height = 1, count = 1, options = {} ) {
+
+		super( width, height, options );
+
+		this.isWebGLMultipleRenderTargets = true;
+
+		const texture = this.texture;
+
+		this.texture = [];
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			this.texture[ i ] = texture.clone();
+			this.texture[ i ].isRenderTargetTexture = true;
+
+		}
+
+	}
+
+	setSize( width, height, depth = 1 ) {
+
+		if ( this.width !== width || this.height !== height || this.depth !== depth ) {
+
+			this.width = width;
+			this.height = height;
+			this.depth = depth;
+
+			for ( let i = 0, il = this.texture.length; i < il; i ++ ) {
+
+				this.texture[ i ].image.width = width;
+				this.texture[ i ].image.height = height;
+				this.texture[ i ].image.depth = depth;
+
+			}
+
+			this.dispose();
+
+		}
+
+		this.viewport.set( 0, 0, width, height );
+		this.scissor.set( 0, 0, width, height );
+
+	}
+
+	copy( source ) {
+
+		this.dispose();
+
+		this.width = source.width;
+		this.height = source.height;
+		this.depth = source.depth;
+
+		this.scissor.copy( source.scissor );
+		this.scissorTest = source.scissorTest;
+
+		this.viewport.copy( source.viewport );
+
+		this.depthBuffer = source.depthBuffer;
+		this.stencilBuffer = source.stencilBuffer;
+
+		if ( source.depthTexture !== null ) this.depthTexture = source.depthTexture.clone();
+
+		this.texture.length = 0;
+
+		for ( let i = 0, il = source.texture.length; i < il; i ++ ) {
+
+			this.texture[ i ] = source.texture[ i ].clone();
+			this.texture[ i ].isRenderTargetTexture = true;
+
+		}
+
+		return this;
+
+	}
+
+}
+
+class Quaternion {
+
+	constructor( x = 0, y = 0, z = 0, w = 1 ) {
+
+		this.isQuaternion = true;
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._w = w;
+
+	}
+
+	static slerpFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
+
+		// fuzz-free, array-based Quaternion SLERP operation
+
+		let x0 = src0[ srcOffset0 + 0 ],
+			y0 = src0[ srcOffset0 + 1 ],
+			z0 = src0[ srcOffset0 + 2 ],
+			w0 = src0[ srcOffset0 + 3 ];
+
+		const x1 = src1[ srcOffset1 + 0 ],
+			y1 = src1[ srcOffset1 + 1 ],
+			z1 = src1[ srcOffset1 + 2 ],
+			w1 = src1[ srcOffset1 + 3 ];
+
+		if ( t === 0 ) {
+
+			dst[ dstOffset + 0 ] = x0;
+			dst[ dstOffset + 1 ] = y0;
+			dst[ dstOffset + 2 ] = z0;
+			dst[ dstOffset + 3 ] = w0;
+			return;
+
+		}
+
+		if ( t === 1 ) {
+
+			dst[ dstOffset + 0 ] = x1;
+			dst[ dstOffset + 1 ] = y1;
+			dst[ dstOffset + 2 ] = z1;
+			dst[ dstOffset + 3 ] = w1;
+			return;
+
+		}
+
+		if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
+
+			let s = 1 - t;
+			const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
+				dir = ( cos >= 0 ? 1 : - 1 ),
+				sqrSin = 1 - cos * cos;
+
+			// Skip the Slerp for tiny steps to avoid numeric problems:
+			if ( sqrSin > Number.EPSILON ) {
+
+				const sin = Math.sqrt( sqrSin ),
+					len = Math.atan2( sin, cos * dir );
+
+				s = Math.sin( s * len ) / sin;
+				t = Math.sin( t * len ) / sin;
+
+			}
+
+			const tDir = t * dir;
+
+			x0 = x0 * s + x1 * tDir;
+			y0 = y0 * s + y1 * tDir;
+			z0 = z0 * s + z1 * tDir;
+			w0 = w0 * s + w1 * tDir;
+
+			// Normalize in case we just did a lerp:
+			if ( s === 1 - t ) {
+
+				const f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
+
+				x0 *= f;
+				y0 *= f;
+				z0 *= f;
+				w0 *= f;
+
+			}
+
+		}
+
+		dst[ dstOffset ] = x0;
+		dst[ dstOffset + 1 ] = y0;
+		dst[ dstOffset + 2 ] = z0;
+		dst[ dstOffset + 3 ] = w0;
+
+	}
+
+	static multiplyQuaternionsFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {
+
+		const x0 = src0[ srcOffset0 ];
+		const y0 = src0[ srcOffset0 + 1 ];
+		const z0 = src0[ srcOffset0 + 2 ];
+		const w0 = src0[ srcOffset0 + 3 ];
+
+		const x1 = src1[ srcOffset1 ];
+		const y1 = src1[ srcOffset1 + 1 ];
+		const z1 = src1[ srcOffset1 + 2 ];
+		const w1 = src1[ srcOffset1 + 3 ];
+
+		dst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
+		dst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
+		dst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
+		dst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
+
+		return dst;
+
+	}
+
+	get x() {
+
+		return this._x;
+
+	}
+
+	set x( value ) {
+
+		this._x = value;
+		this._onChangeCallback();
+
+	}
+
+	get y() {
+
+		return this._y;
+
+	}
+
+	set y( value ) {
+
+		this._y = value;
+		this._onChangeCallback();
+
+	}
+
+	get z() {
+
+		return this._z;
+
+	}
+
+	set z( value ) {
+
+		this._z = value;
+		this._onChangeCallback();
+
+	}
+
+	get w() {
+
+		return this._w;
+
+	}
+
+	set w( value ) {
+
+		this._w = value;
+		this._onChangeCallback();
+
+	}
+
+	set( x, y, z, w ) {
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._w = w;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor( this._x, this._y, this._z, this._w );
+
+	}
+
+	copy( quaternion ) {
+
+		this._x = quaternion.x;
+		this._y = quaternion.y;
+		this._z = quaternion.z;
+		this._w = quaternion.w;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromEuler( euler, update = true ) {
+
+		const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
+
+		// http://www.mathworks.com/matlabcentral/fileexchange/
+		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
+		//	content/SpinCalc.m
+
+		const cos = Math.cos;
+		const sin = Math.sin;
+
+		const c1 = cos( x / 2 );
+		const c2 = cos( y / 2 );
+		const c3 = cos( z / 2 );
+
+		const s1 = sin( x / 2 );
+		const s2 = sin( y / 2 );
+		const s3 = sin( z / 2 );
+
+		switch ( order ) {
+
+			case 'XYZ':
+				this._x = s1 * c2 * c3 + c1 * s2 * s3;
+				this._y = c1 * s2 * c3 - s1 * c2 * s3;
+				this._z = c1 * c2 * s3 + s1 * s2 * c3;
+				this._w = c1 * c2 * c3 - s1 * s2 * s3;
+				break;
+
+			case 'YXZ':
+				this._x = s1 * c2 * c3 + c1 * s2 * s3;
+				this._y = c1 * s2 * c3 - s1 * c2 * s3;
+				this._z = c1 * c2 * s3 - s1 * s2 * c3;
+				this._w = c1 * c2 * c3 + s1 * s2 * s3;
+				break;
+
+			case 'ZXY':
+				this._x = s1 * c2 * c3 - c1 * s2 * s3;
+				this._y = c1 * s2 * c3 + s1 * c2 * s3;
+				this._z = c1 * c2 * s3 + s1 * s2 * c3;
+				this._w = c1 * c2 * c3 - s1 * s2 * s3;
+				break;
+
+			case 'ZYX':
+				this._x = s1 * c2 * c3 - c1 * s2 * s3;
+				this._y = c1 * s2 * c3 + s1 * c2 * s3;
+				this._z = c1 * c2 * s3 - s1 * s2 * c3;
+				this._w = c1 * c2 * c3 + s1 * s2 * s3;
+				break;
+
+			case 'YZX':
+				this._x = s1 * c2 * c3 + c1 * s2 * s3;
+				this._y = c1 * s2 * c3 + s1 * c2 * s3;
+				this._z = c1 * c2 * s3 - s1 * s2 * c3;
+				this._w = c1 * c2 * c3 - s1 * s2 * s3;
+				break;
+
+			case 'XZY':
+				this._x = s1 * c2 * c3 - c1 * s2 * s3;
+				this._y = c1 * s2 * c3 - s1 * c2 * s3;
+				this._z = c1 * c2 * s3 + s1 * s2 * c3;
+				this._w = c1 * c2 * c3 + s1 * s2 * s3;
+				break;
+
+			default:
+				console.warn( 'THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order );
+
+		}
+
+		if ( update === true ) this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromAxisAngle( axis, angle ) {
+
+		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+
+		// assumes axis is normalized
+
+		const halfAngle = angle / 2, s = Math.sin( halfAngle );
+
+		this._x = axis.x * s;
+		this._y = axis.y * s;
+		this._z = axis.z * s;
+		this._w = Math.cos( halfAngle );
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromRotationMatrix( m ) {
+
+		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		const te = m.elements,
+
+			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
+			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
+			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],
+
+			trace = m11 + m22 + m33;
+
+		if ( trace > 0 ) {
+
+			const s = 0.5 / Math.sqrt( trace + 1.0 );
+
+			this._w = 0.25 / s;
+			this._x = ( m32 - m23 ) * s;
+			this._y = ( m13 - m31 ) * s;
+			this._z = ( m21 - m12 ) * s;
+
+		} else if ( m11 > m22 && m11 > m33 ) {
+
+			const s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );
+
+			this._w = ( m32 - m23 ) / s;
+			this._x = 0.25 * s;
+			this._y = ( m12 + m21 ) / s;
+			this._z = ( m13 + m31 ) / s;
+
+		} else if ( m22 > m33 ) {
+
+			const s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );
+
+			this._w = ( m13 - m31 ) / s;
+			this._x = ( m12 + m21 ) / s;
+			this._y = 0.25 * s;
+			this._z = ( m23 + m32 ) / s;
+
+		} else {
+
+			const s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );
+
+			this._w = ( m21 - m12 ) / s;
+			this._x = ( m13 + m31 ) / s;
+			this._y = ( m23 + m32 ) / s;
+			this._z = 0.25 * s;
+
+		}
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromUnitVectors( vFrom, vTo ) {
+
+		// assumes direction vectors vFrom and vTo are normalized
+
+		let r = vFrom.dot( vTo ) + 1;
+
+		if ( r < Number.EPSILON ) {
+
+			// vFrom and vTo point in opposite directions
+
+			r = 0;
+
+			if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
+
+				this._x = - vFrom.y;
+				this._y = vFrom.x;
+				this._z = 0;
+				this._w = r;
+
+			} else {
+
+				this._x = 0;
+				this._y = - vFrom.z;
+				this._z = vFrom.y;
+				this._w = r;
+
+			}
+
+		} else {
+
+			// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
+
+			this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
+			this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
+			this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
+			this._w = r;
+
+		}
+
+		return this.normalize();
+
+	}
+
+	angleTo( q ) {
+
+		return 2 * Math.acos( Math.abs( clamp( this.dot( q ), - 1, 1 ) ) );
+
+	}
+
+	rotateTowards( q, step ) {
+
+		const angle = this.angleTo( q );
+
+		if ( angle === 0 ) return this;
+
+		const t = Math.min( 1, step / angle );
+
+		this.slerp( q, t );
+
+		return this;
+
+	}
+
+	identity() {
+
+		return this.set( 0, 0, 0, 1 );
+
+	}
+
+	invert() {
+
+		// quaternion is assumed to have unit length
+
+		return this.conjugate();
+
+	}
+
+	conjugate() {
+
+		this._x *= - 1;
+		this._y *= - 1;
+		this._z *= - 1;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	dot( v ) {
+
+		return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
+
+	}
+
+	lengthSq() {
+
+		return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
+
+	}
+
+	length() {
+
+		return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );
+
+	}
+
+	normalize() {
+
+		let l = this.length();
+
+		if ( l === 0 ) {
+
+			this._x = 0;
+			this._y = 0;
+			this._z = 0;
+			this._w = 1;
+
+		} else {
+
+			l = 1 / l;
+
+			this._x = this._x * l;
+			this._y = this._y * l;
+			this._z = this._z * l;
+			this._w = this._w * l;
+
+		}
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	multiply( q ) {
+
+		return this.multiplyQuaternions( this, q );
+
+	}
+
+	premultiply( q ) {
+
+		return this.multiplyQuaternions( q, this );
+
+	}
+
+	multiplyQuaternions( a, b ) {
+
+		// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+
+		const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
+		const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
+
+		this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+		this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+		this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+		this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	slerp( qb, t ) {
+
+		if ( t === 0 ) return this;
+		if ( t === 1 ) return this.copy( qb );
+
+		const x = this._x, y = this._y, z = this._z, w = this._w;
+
+		// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
+
+		let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
+
+		if ( cosHalfTheta < 0 ) {
+
+			this._w = - qb._w;
+			this._x = - qb._x;
+			this._y = - qb._y;
+			this._z = - qb._z;
+
+			cosHalfTheta = - cosHalfTheta;
+
+		} else {
+
+			this.copy( qb );
+
+		}
+
+		if ( cosHalfTheta >= 1.0 ) {
+
+			this._w = w;
+			this._x = x;
+			this._y = y;
+			this._z = z;
+
+			return this;
+
+		}
+
+		const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
+
+		if ( sqrSinHalfTheta <= Number.EPSILON ) {
+
+			const s = 1 - t;
+			this._w = s * w + t * this._w;
+			this._x = s * x + t * this._x;
+			this._y = s * y + t * this._y;
+			this._z = s * z + t * this._z;
+
+			this.normalize(); // normalize calls _onChangeCallback()
+
+			return this;
+
+		}
+
+		const sinHalfTheta = Math.sqrt( sqrSinHalfTheta );
+		const halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
+		const ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
+			ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;
+
+		this._w = ( w * ratioA + this._w * ratioB );
+		this._x = ( x * ratioA + this._x * ratioB );
+		this._y = ( y * ratioA + this._y * ratioB );
+		this._z = ( z * ratioA + this._z * ratioB );
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	slerpQuaternions( qa, qb, t ) {
+
+		return this.copy( qa ).slerp( qb, t );
+
+	}
+
+	random() {
+
+		// Derived from http://planning.cs.uiuc.edu/node198.html
+		// Note, this source uses w, x, y, z ordering,
+		// so we swap the order below.
+
+		const u1 = Math.random();
+		const sqrt1u1 = Math.sqrt( 1 - u1 );
+		const sqrtu1 = Math.sqrt( u1 );
+
+		const u2 = 2 * Math.PI * Math.random();
+
+		const u3 = 2 * Math.PI * Math.random();
+
+		return this.set(
+			sqrt1u1 * Math.cos( u2 ),
+			sqrtu1 * Math.sin( u3 ),
+			sqrtu1 * Math.cos( u3 ),
+			sqrt1u1 * Math.sin( u2 ),
+		);
+
+	}
+
+	equals( quaternion ) {
+
+		return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		this._x = array[ offset ];
+		this._y = array[ offset + 1 ];
+		this._z = array[ offset + 2 ];
+		this._w = array[ offset + 3 ];
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this._x;
+		array[ offset + 1 ] = this._y;
+		array[ offset + 2 ] = this._z;
+		array[ offset + 3 ] = this._w;
+
+		return array;
+
+	}
+
+	fromBufferAttribute( attribute, index ) {
+
+		this._x = attribute.getX( index );
+		this._y = attribute.getY( index );
+		this._z = attribute.getZ( index );
+		this._w = attribute.getW( index );
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		return this.toArray();
+
+	}
+
+	_onChange( callback ) {
+
+		this._onChangeCallback = callback;
+
+		return this;
+
+	}
+
+	_onChangeCallback() {}
+
+	*[ Symbol.iterator ]() {
+
+		yield this._x;
+		yield this._y;
+		yield this._z;
+		yield this._w;
+
+	}
+
+}
+
+class Vector3 {
+
+	constructor( x = 0, y = 0, z = 0 ) {
+
+		Vector3.prototype.isVector3 = true;
+
+		this.x = x;
+		this.y = y;
+		this.z = z;
+
+	}
+
+	set( x, y, z ) {
+
+		if ( z === undefined ) z = this.z; // sprite.scale.set(x,y)
+
+		this.x = x;
+		this.y = y;
+		this.z = z;
+
+		return this;
+
+	}
+
+	setScalar( scalar ) {
+
+		this.x = scalar;
+		this.y = scalar;
+		this.z = scalar;
+
+		return this;
+
+	}
+
+	setX( x ) {
+
+		this.x = x;
+
+		return this;
+
+	}
+
+	setY( y ) {
+
+		this.y = y;
+
+		return this;
+
+	}
+
+	setZ( z ) {
+
+		this.z = z;
+
+		return this;
+
+	}
+
+	setComponent( index, value ) {
+
+		switch ( index ) {
+
+			case 0: this.x = value; break;
+			case 1: this.y = value; break;
+			case 2: this.z = value; break;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+		return this;
+
+	}
+
+	getComponent( index ) {
+
+		switch ( index ) {
+
+			case 0: return this.x;
+			case 1: return this.y;
+			case 2: return this.z;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+	}
+
+	clone() {
+
+		return new this.constructor( this.x, this.y, this.z );
+
+	}
+
+	copy( v ) {
+
+		this.x = v.x;
+		this.y = v.y;
+		this.z = v.z;
+
+		return this;
+
+	}
+
+	add( v ) {
+
+		this.x += v.x;
+		this.y += v.y;
+		this.z += v.z;
+
+		return this;
+
+	}
+
+	addScalar( s ) {
+
+		this.x += s;
+		this.y += s;
+		this.z += s;
+
+		return this;
+
+	}
+
+	addVectors( a, b ) {
+
+		this.x = a.x + b.x;
+		this.y = a.y + b.y;
+		this.z = a.z + b.z;
+
+		return this;
+
+	}
+
+	addScaledVector( v, s ) {
+
+		this.x += v.x * s;
+		this.y += v.y * s;
+		this.z += v.z * s;
+
+		return this;
+
+	}
+
+	sub( v ) {
+
+		this.x -= v.x;
+		this.y -= v.y;
+		this.z -= v.z;
+
+		return this;
+
+	}
+
+	subScalar( s ) {
+
+		this.x -= s;
+		this.y -= s;
+		this.z -= s;
+
+		return this;
+
+	}
+
+	subVectors( a, b ) {
+
+		this.x = a.x - b.x;
+		this.y = a.y - b.y;
+		this.z = a.z - b.z;
+
+		return this;
+
+	}
+
+	multiply( v ) {
+
+		this.x *= v.x;
+		this.y *= v.y;
+		this.z *= v.z;
+
+		return this;
+
+	}
+
+	multiplyScalar( scalar ) {
+
+		this.x *= scalar;
+		this.y *= scalar;
+		this.z *= scalar;
+
+		return this;
+
+	}
+
+	multiplyVectors( a, b ) {
+
+		this.x = a.x * b.x;
+		this.y = a.y * b.y;
+		this.z = a.z * b.z;
+
+		return this;
+
+	}
+
+	applyEuler( euler ) {
+
+		return this.applyQuaternion( _quaternion$4.setFromEuler( euler ) );
+
+	}
+
+	applyAxisAngle( axis, angle ) {
+
+		return this.applyQuaternion( _quaternion$4.setFromAxisAngle( axis, angle ) );
+
+	}
+
+	applyMatrix3( m ) {
+
+		const x = this.x, y = this.y, z = this.z;
+		const e = m.elements;
+
+		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
+		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
+		this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;
+
+		return this;
+
+	}
+
+	applyNormalMatrix( m ) {
+
+		return this.applyMatrix3( m ).normalize();
+
+	}
+
+	applyMatrix4( m ) {
+
+		const x = this.x, y = this.y, z = this.z;
+		const e = m.elements;
+
+		const w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );
+
+		this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;
+		this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;
+		this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;
+
+		return this;
+
+	}
+
+	applyQuaternion( q ) {
+
+		// quaternion q is assumed to have unit length
+
+		const vx = this.x, vy = this.y, vz = this.z;
+		const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+
+		// t = 2 * cross( q.xyz, v );
+		const tx = 2 * ( qy * vz - qz * vy );
+		const ty = 2 * ( qz * vx - qx * vz );
+		const tz = 2 * ( qx * vy - qy * vx );
+
+		// v + q.w * t + cross( q.xyz, t );
+		this.x = vx + qw * tx + qy * tz - qz * ty;
+		this.y = vy + qw * ty + qz * tx - qx * tz;
+		this.z = vz + qw * tz + qx * ty - qy * tx;
+
+		return this;
+
+	}
+
+	project( camera ) {
+
+		return this.applyMatrix4( camera.matrixWorldInverse ).applyMatrix4( camera.projectionMatrix );
+
+	}
+
+	unproject( camera ) {
+
+		return this.applyMatrix4( camera.projectionMatrixInverse ).applyMatrix4( camera.matrixWorld );
+
+	}
+
+	transformDirection( m ) {
+
+		// input: THREE.Matrix4 affine matrix
+		// vector interpreted as a direction
+
+		const x = this.x, y = this.y, z = this.z;
+		const e = m.elements;
+
+		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
+		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
+		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
+
+		return this.normalize();
+
+	}
+
+	divide( v ) {
+
+		this.x /= v.x;
+		this.y /= v.y;
+		this.z /= v.z;
+
+		return this;
+
+	}
+
+	divideScalar( scalar ) {
+
+		return this.multiplyScalar( 1 / scalar );
+
+	}
+
+	min( v ) {
+
+		this.x = Math.min( this.x, v.x );
+		this.y = Math.min( this.y, v.y );
+		this.z = Math.min( this.z, v.z );
+
+		return this;
+
+	}
+
+	max( v ) {
+
+		this.x = Math.max( this.x, v.x );
+		this.y = Math.max( this.y, v.y );
+		this.z = Math.max( this.z, v.z );
+
+		return this;
+
+	}
+
+	clamp( min, max ) {
+
+		// assumes min < max, componentwise
+
+		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
+		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
+		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
+
+		return this;
+
+	}
+
+	clampScalar( minVal, maxVal ) {
+
+		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
+		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
+		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
+
+		return this;
+
+	}
+
+	clampLength( min, max ) {
+
+		const length = this.length();
+
+		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
+
+	}
+
+	floor() {
+
+		this.x = Math.floor( this.x );
+		this.y = Math.floor( this.y );
+		this.z = Math.floor( this.z );
+
+		return this;
+
+	}
+
+	ceil() {
+
+		this.x = Math.ceil( this.x );
+		this.y = Math.ceil( this.y );
+		this.z = Math.ceil( this.z );
+
+		return this;
+
+	}
+
+	round() {
+
+		this.x = Math.round( this.x );
+		this.y = Math.round( this.y );
+		this.z = Math.round( this.z );
+
+		return this;
+
+	}
+
+	roundToZero() {
+
+		this.x = Math.trunc( this.x );
+		this.y = Math.trunc( this.y );
+		this.z = Math.trunc( this.z );
+
+		return this;
+
+	}
+
+	negate() {
+
+		this.x = - this.x;
+		this.y = - this.y;
+		this.z = - this.z;
+
+		return this;
+
+	}
+
+	dot( v ) {
+
+		return this.x * v.x + this.y * v.y + this.z * v.z;
+
+	}
+
+	// TODO lengthSquared?
+
+	lengthSq() {
+
+		return this.x * this.x + this.y * this.y + this.z * this.z;
+
+	}
+
+	length() {
+
+		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
+
+	}
+
+	manhattanLength() {
+
+		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
+
+	}
+
+	normalize() {
+
+		return this.divideScalar( this.length() || 1 );
+
+	}
+
+	setLength( length ) {
+
+		return this.normalize().multiplyScalar( length );
+
+	}
+
+	lerp( v, alpha ) {
+
+		this.x += ( v.x - this.x ) * alpha;
+		this.y += ( v.y - this.y ) * alpha;
+		this.z += ( v.z - this.z ) * alpha;
+
+		return this;
+
+	}
+
+	lerpVectors( v1, v2, alpha ) {
+
+		this.x = v1.x + ( v2.x - v1.x ) * alpha;
+		this.y = v1.y + ( v2.y - v1.y ) * alpha;
+		this.z = v1.z + ( v2.z - v1.z ) * alpha;
+
+		return this;
+
+	}
+
+	cross( v ) {
+
+		return this.crossVectors( this, v );
+
+	}
+
+	crossVectors( a, b ) {
+
+		const ax = a.x, ay = a.y, az = a.z;
+		const bx = b.x, by = b.y, bz = b.z;
+
+		this.x = ay * bz - az * by;
+		this.y = az * bx - ax * bz;
+		this.z = ax * by - ay * bx;
+
+		return this;
+
+	}
+
+	projectOnVector( v ) {
+
+		const denominator = v.lengthSq();
+
+		if ( denominator === 0 ) return this.set( 0, 0, 0 );
+
+		const scalar = v.dot( this ) / denominator;
+
+		return this.copy( v ).multiplyScalar( scalar );
+
+	}
+
+	projectOnPlane( planeNormal ) {
+
+		_vector$c.copy( this ).projectOnVector( planeNormal );
+
+		return this.sub( _vector$c );
+
+	}
+
+	reflect( normal ) {
+
+		// reflect incident vector off plane orthogonal to normal
+		// normal is assumed to have unit length
+
+		return this.sub( _vector$c.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
+
+	}
+
+	angleTo( v ) {
+
+		const denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );
+
+		if ( denominator === 0 ) return Math.PI / 2;
+
+		const theta = this.dot( v ) / denominator;
+
+		// clamp, to handle numerical problems
+
+		return Math.acos( clamp( theta, - 1, 1 ) );
+
+	}
+
+	distanceTo( v ) {
+
+		return Math.sqrt( this.distanceToSquared( v ) );
+
+	}
+
+	distanceToSquared( v ) {
+
+		const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+
+		return dx * dx + dy * dy + dz * dz;
+
+	}
+
+	manhattanDistanceTo( v ) {
+
+		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );
+
+	}
+
+	setFromSpherical( s ) {
+
+		return this.setFromSphericalCoords( s.radius, s.phi, s.theta );
+
+	}
+
+	setFromSphericalCoords( radius, phi, theta ) {
+
+		const sinPhiRadius = Math.sin( phi ) * radius;
+
+		this.x = sinPhiRadius * Math.sin( theta );
+		this.y = Math.cos( phi ) * radius;
+		this.z = sinPhiRadius * Math.cos( theta );
+
+		return this;
+
+	}
+
+	setFromCylindrical( c ) {
+
+		return this.setFromCylindricalCoords( c.radius, c.theta, c.y );
+
+	}
+
+	setFromCylindricalCoords( radius, theta, y ) {
+
+		this.x = radius * Math.sin( theta );
+		this.y = y;
+		this.z = radius * Math.cos( theta );
+
+		return this;
+
+	}
+
+	setFromMatrixPosition( m ) {
+
+		const e = m.elements;
+
+		this.x = e[ 12 ];
+		this.y = e[ 13 ];
+		this.z = e[ 14 ];
+
+		return this;
+
+	}
+
+	setFromMatrixScale( m ) {
+
+		const sx = this.setFromMatrixColumn( m, 0 ).length();
+		const sy = this.setFromMatrixColumn( m, 1 ).length();
+		const sz = this.setFromMatrixColumn( m, 2 ).length();
+
+		this.x = sx;
+		this.y = sy;
+		this.z = sz;
+
+		return this;
+
+	}
+
+	setFromMatrixColumn( m, index ) {
+
+		return this.fromArray( m.elements, index * 4 );
+
+	}
+
+	setFromMatrix3Column( m, index ) {
+
+		return this.fromArray( m.elements, index * 3 );
+
+	}
+
+	setFromEuler( e ) {
+
+		this.x = e._x;
+		this.y = e._y;
+		this.z = e._z;
+
+		return this;
+
+	}
+
+	setFromColor( c ) {
+
+		this.x = c.r;
+		this.y = c.g;
+		this.z = c.b;
+
+		return this;
+
+	}
+
+	equals( v ) {
+
+		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		this.x = array[ offset ];
+		this.y = array[ offset + 1 ];
+		this.z = array[ offset + 2 ];
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this.x;
+		array[ offset + 1 ] = this.y;
+		array[ offset + 2 ] = this.z;
+
+		return array;
+
+	}
+
+	fromBufferAttribute( attribute, index ) {
+
+		this.x = attribute.getX( index );
+		this.y = attribute.getY( index );
+		this.z = attribute.getZ( index );
+
+		return this;
+
+	}
+
+	random() {
+
+		this.x = Math.random();
+		this.y = Math.random();
+		this.z = Math.random();
+
+		return this;
+
+	}
+
+	randomDirection() {
+
+		// Derived from https://mathworld.wolfram.com/SpherePointPicking.html
+
+		const u = ( Math.random() - 0.5 ) * 2;
+		const t = Math.random() * Math.PI * 2;
+		const f = Math.sqrt( 1 - u ** 2 );
+
+		this.x = f * Math.cos( t );
+		this.y = f * Math.sin( t );
+		this.z = u;
+
+		return this;
+
+	}
+
+	*[ Symbol.iterator ]() {
+
+		yield this.x;
+		yield this.y;
+		yield this.z;
+
+	}
+
+}
+
+const _vector$c = /*@__PURE__*/ new Vector3();
+const _quaternion$4 = /*@__PURE__*/ new Quaternion();
+
+class Box3 {
+
+	constructor( min = new Vector3( + Infinity, + Infinity, + Infinity ), max = new Vector3( - Infinity, - Infinity, - Infinity ) ) {
+
+		this.isBox3 = true;
+
+		this.min = min;
+		this.max = max;
+
+	}
+
+	set( min, max ) {
+
+		this.min.copy( min );
+		this.max.copy( max );
+
+		return this;
+
+	}
+
+	setFromArray( array ) {
+
+		this.makeEmpty();
+
+		for ( let i = 0, il = array.length; i < il; i += 3 ) {
+
+			this.expandByPoint( _vector$b.fromArray( array, i ) );
+
+		}
+
+		return this;
+
+	}
+
+	setFromBufferAttribute( attribute ) {
+
+		this.makeEmpty();
+
+		for ( let i = 0, il = attribute.count; i < il; i ++ ) {
+
+			this.expandByPoint( _vector$b.fromBufferAttribute( attribute, i ) );
+
+		}
+
+		return this;
+
+	}
+
+	setFromPoints( points ) {
+
+		this.makeEmpty();
+
+		for ( let i = 0, il = points.length; i < il; i ++ ) {
+
+			this.expandByPoint( points[ i ] );
+
+		}
+
+		return this;
+
+	}
+
+	setFromCenterAndSize( center, size ) {
+
+		const halfSize = _vector$b.copy( size ).multiplyScalar( 0.5 );
+
+		this.min.copy( center ).sub( halfSize );
+		this.max.copy( center ).add( halfSize );
+
+		return this;
+
+	}
+
+	setFromObject( object, precise = false ) {
+
+		this.makeEmpty();
+
+		return this.expandByObject( object, precise );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( box ) {
+
+		this.min.copy( box.min );
+		this.max.copy( box.max );
+
+		return this;
+
+	}
+
+	makeEmpty() {
+
+		this.min.x = this.min.y = this.min.z = + Infinity;
+		this.max.x = this.max.y = this.max.z = - Infinity;
+
+		return this;
+
+	}
+
+	isEmpty() {
+
+		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
+
+		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );
+
+	}
+
+	getCenter( target ) {
+
+		return this.isEmpty() ? target.set( 0, 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
+
+	}
+
+	getSize( target ) {
+
+		return this.isEmpty() ? target.set( 0, 0, 0 ) : target.subVectors( this.max, this.min );
+
+	}
+
+	expandByPoint( point ) {
+
+		this.min.min( point );
+		this.max.max( point );
+
+		return this;
+
+	}
+
+	expandByVector( vector ) {
+
+		this.min.sub( vector );
+		this.max.add( vector );
+
+		return this;
+
+	}
+
+	expandByScalar( scalar ) {
+
+		this.min.addScalar( - scalar );
+		this.max.addScalar( scalar );
+
+		return this;
+
+	}
+
+	expandByObject( object, precise = false ) {
+
+		// Computes the world-axis-aligned bounding box of an object (including its children),
+		// accounting for both the object's, and children's, world transforms
+
+		object.updateWorldMatrix( false, false );
+
+		const geometry = object.geometry;
+
+		if ( geometry !== undefined ) {
+
+			const positionAttribute = geometry.getAttribute( 'position' );
+
+			// precise AABB computation based on vertex data requires at least a position attribute.
+			// instancing isn't supported so far and uses the normal (conservative) code path.
+
+			if ( precise === true && positionAttribute !== undefined && object.isInstancedMesh !== true ) {
+
+				for ( let i = 0, l = positionAttribute.count; i < l; i ++ ) {
+
+					if ( object.isMesh === true ) {
+
+						object.getVertexPosition( i, _vector$b );
+
+					} else {
+
+						_vector$b.fromBufferAttribute( positionAttribute, i );
+
+					}
+
+					_vector$b.applyMatrix4( object.matrixWorld );
+					this.expandByPoint( _vector$b );
+
+				}
+
+			} else {
+
+				if ( object.boundingBox !== undefined ) {
+
+					// object-level bounding box
+
+					if ( object.boundingBox === null ) {
+
+						object.computeBoundingBox();
+
+					}
+
+					_box$4.copy( object.boundingBox );
+
+
+				} else {
+
+					// geometry-level bounding box
+
+					if ( geometry.boundingBox === null ) {
+
+						geometry.computeBoundingBox();
+
+					}
+
+					_box$4.copy( geometry.boundingBox );
+
+				}
+
+				_box$4.applyMatrix4( object.matrixWorld );
+
+				this.union( _box$4 );
+
+			}
+
+		}
+
+		const children = object.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			this.expandByObject( children[ i ], precise );
+
+		}
+
+		return this;
+
+	}
+
+	containsPoint( point ) {
+
+		return point.x < this.min.x || point.x > this.max.x ||
+			point.y < this.min.y || point.y > this.max.y ||
+			point.z < this.min.z || point.z > this.max.z ? false : true;
+
+	}
+
+	containsBox( box ) {
+
+		return this.min.x <= box.min.x && box.max.x <= this.max.x &&
+			this.min.y <= box.min.y && box.max.y <= this.max.y &&
+			this.min.z <= box.min.z && box.max.z <= this.max.z;
+
+	}
+
+	getParameter( point, target ) {
+
+		// This can potentially have a divide by zero if the box
+		// has a size dimension of 0.
+
+		return target.set(
+			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
+			( point.y - this.min.y ) / ( this.max.y - this.min.y ),
+			( point.z - this.min.z ) / ( this.max.z - this.min.z )
+		);
+
+	}
+
+	intersectsBox( box ) {
+
+		// using 6 splitting planes to rule out intersections.
+		return box.max.x < this.min.x || box.min.x > this.max.x ||
+			box.max.y < this.min.y || box.min.y > this.max.y ||
+			box.max.z < this.min.z || box.min.z > this.max.z ? false : true;
+
+	}
+
+	intersectsSphere( sphere ) {
+
+		// Find the point on the AABB closest to the sphere center.
+		this.clampPoint( sphere.center, _vector$b );
+
+		// If that point is inside the sphere, the AABB and sphere intersect.
+		return _vector$b.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );
+
+	}
+
+	intersectsPlane( plane ) {
+
+		// We compute the minimum and maximum dot product values. If those values
+		// are on the same side (back or front) of the plane, then there is no intersection.
+
+		let min, max;
+
+		if ( plane.normal.x > 0 ) {
+
+			min = plane.normal.x * this.min.x;
+			max = plane.normal.x * this.max.x;
+
+		} else {
+
+			min = plane.normal.x * this.max.x;
+			max = plane.normal.x * this.min.x;
+
+		}
+
+		if ( plane.normal.y > 0 ) {
+
+			min += plane.normal.y * this.min.y;
+			max += plane.normal.y * this.max.y;
+
+		} else {
+
+			min += plane.normal.y * this.max.y;
+			max += plane.normal.y * this.min.y;
+
+		}
+
+		if ( plane.normal.z > 0 ) {
+
+			min += plane.normal.z * this.min.z;
+			max += plane.normal.z * this.max.z;
+
+		} else {
+
+			min += plane.normal.z * this.max.z;
+			max += plane.normal.z * this.min.z;
+
+		}
+
+		return ( min <= - plane.constant && max >= - plane.constant );
+
+	}
+
+	intersectsTriangle( triangle ) {
+
+		if ( this.isEmpty() ) {
+
+			return false;
+
+		}
+
+		// compute box center and extents
+		this.getCenter( _center );
+		_extents.subVectors( this.max, _center );
+
+		// translate triangle to aabb origin
+		_v0$2.subVectors( triangle.a, _center );
+		_v1$7.subVectors( triangle.b, _center );
+		_v2$4.subVectors( triangle.c, _center );
+
+		// compute edge vectors for triangle
+		_f0.subVectors( _v1$7, _v0$2 );
+		_f1.subVectors( _v2$4, _v1$7 );
+		_f2.subVectors( _v0$2, _v2$4 );
+
+		// test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
+		// make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
+		// axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
+		let axes = [
+			0, - _f0.z, _f0.y, 0, - _f1.z, _f1.y, 0, - _f2.z, _f2.y,
+			_f0.z, 0, - _f0.x, _f1.z, 0, - _f1.x, _f2.z, 0, - _f2.x,
+			- _f0.y, _f0.x, 0, - _f1.y, _f1.x, 0, - _f2.y, _f2.x, 0
+		];
+		if ( ! satForAxes( axes, _v0$2, _v1$7, _v2$4, _extents ) ) {
+
+			return false;
+
+		}
+
+		// test 3 face normals from the aabb
+		axes = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];
+		if ( ! satForAxes( axes, _v0$2, _v1$7, _v2$4, _extents ) ) {
+
+			return false;
+
+		}
+
+		// finally testing the face normal of the triangle
+		// use already existing triangle edge vectors here
+		_triangleNormal.crossVectors( _f0, _f1 );
+		axes = [ _triangleNormal.x, _triangleNormal.y, _triangleNormal.z ];
+
+		return satForAxes( axes, _v0$2, _v1$7, _v2$4, _extents );
+
+	}
+
+	clampPoint( point, target ) {
+
+		return target.copy( point ).clamp( this.min, this.max );
+
+	}
+
+	distanceToPoint( point ) {
+
+		return this.clampPoint( point, _vector$b ).distanceTo( point );
+
+	}
+
+	getBoundingSphere( target ) {
+
+		if ( this.isEmpty() ) {
+
+			target.makeEmpty();
+
+		} else {
+
+			this.getCenter( target.center );
+
+			target.radius = this.getSize( _vector$b ).length() * 0.5;
+
+		}
+
+		return target;
+
+	}
+
+	intersect( box ) {
+
+		this.min.max( box.min );
+		this.max.min( box.max );
+
+		// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
+		if ( this.isEmpty() ) this.makeEmpty();
+
+		return this;
+
+	}
+
+	union( box ) {
+
+		this.min.min( box.min );
+		this.max.max( box.max );
+
+		return this;
+
+	}
+
+	applyMatrix4( matrix ) {
+
+		// transform of empty box is an empty box.
+		if ( this.isEmpty() ) return this;
+
+		// NOTE: I am using a binary pattern to specify all 2^3 combinations below
+		_points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000
+		_points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001
+		_points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010
+		_points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011
+		_points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100
+		_points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101
+		_points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110
+		_points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111
+
+		this.setFromPoints( _points );
+
+		return this;
+
+	}
+
+	translate( offset ) {
+
+		this.min.add( offset );
+		this.max.add( offset );
+
+		return this;
+
+	}
+
+	equals( box ) {
+
+		return box.min.equals( this.min ) && box.max.equals( this.max );
+
+	}
+
+}
+
+const _points = [
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3(),
+	/*@__PURE__*/ new Vector3()
+];
+
+const _vector$b = /*@__PURE__*/ new Vector3();
+
+const _box$4 = /*@__PURE__*/ new Box3();
+
+// triangle centered vertices
+
+const _v0$2 = /*@__PURE__*/ new Vector3();
+const _v1$7 = /*@__PURE__*/ new Vector3();
+const _v2$4 = /*@__PURE__*/ new Vector3();
+
+// triangle edge vectors
+
+const _f0 = /*@__PURE__*/ new Vector3();
+const _f1 = /*@__PURE__*/ new Vector3();
+const _f2 = /*@__PURE__*/ new Vector3();
+
+const _center = /*@__PURE__*/ new Vector3();
+const _extents = /*@__PURE__*/ new Vector3();
+const _triangleNormal = /*@__PURE__*/ new Vector3();
+const _testAxis = /*@__PURE__*/ new Vector3();
+
+function satForAxes( axes, v0, v1, v2, extents ) {
+
+	for ( let i = 0, j = axes.length - 3; i <= j; i += 3 ) {
+
+		_testAxis.fromArray( axes, i );
+		// project the aabb onto the separating axis
+		const r = extents.x * Math.abs( _testAxis.x ) + extents.y * Math.abs( _testAxis.y ) + extents.z * Math.abs( _testAxis.z );
+		// project all 3 vertices of the triangle onto the separating axis
+		const p0 = v0.dot( _testAxis );
+		const p1 = v1.dot( _testAxis );
+		const p2 = v2.dot( _testAxis );
+		// actual test, basically see if either of the most extreme of the triangle points intersects r
+		if ( Math.max( - Math.max( p0, p1, p2 ), Math.min( p0, p1, p2 ) ) > r ) {
+
+			// points of the projected triangle are outside the projected half-length of the aabb
+			// the axis is separating and we can exit
+			return false;
+
+		}
+
+	}
+
+	return true;
+
+}
+
+const _box$3 = /*@__PURE__*/ new Box3();
+const _v1$6 = /*@__PURE__*/ new Vector3();
+const _v2$3 = /*@__PURE__*/ new Vector3();
+
+class Sphere {
+
+	constructor( center = new Vector3(), radius = - 1 ) {
+
+		this.isSphere = true;
+
+		this.center = center;
+		this.radius = radius;
+
+	}
+
+	set( center, radius ) {
+
+		this.center.copy( center );
+		this.radius = radius;
+
+		return this;
+
+	}
+
+	setFromPoints( points, optionalCenter ) {
+
+		const center = this.center;
+
+		if ( optionalCenter !== undefined ) {
+
+			center.copy( optionalCenter );
+
+		} else {
+
+			_box$3.setFromPoints( points ).getCenter( center );
+
+		}
+
+		let maxRadiusSq = 0;
+
+		for ( let i = 0, il = points.length; i < il; i ++ ) {
+
+			maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );
+
+		}
+
+		this.radius = Math.sqrt( maxRadiusSq );
+
+		return this;
+
+	}
+
+	copy( sphere ) {
+
+		this.center.copy( sphere.center );
+		this.radius = sphere.radius;
+
+		return this;
+
+	}
+
+	isEmpty() {
+
+		return ( this.radius < 0 );
+
+	}
+
+	makeEmpty() {
+
+		this.center.set( 0, 0, 0 );
+		this.radius = - 1;
+
+		return this;
+
+	}
+
+	containsPoint( point ) {
+
+		return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );
+
+	}
+
+	distanceToPoint( point ) {
+
+		return ( point.distanceTo( this.center ) - this.radius );
+
+	}
+
+	intersectsSphere( sphere ) {
+
+		const radiusSum = this.radius + sphere.radius;
+
+		return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );
+
+	}
+
+	intersectsBox( box ) {
+
+		return box.intersectsSphere( this );
+
+	}
+
+	intersectsPlane( plane ) {
+
+		return Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius;
+
+	}
+
+	clampPoint( point, target ) {
+
+		const deltaLengthSq = this.center.distanceToSquared( point );
+
+		target.copy( point );
+
+		if ( deltaLengthSq > ( this.radius * this.radius ) ) {
+
+			target.sub( this.center ).normalize();
+			target.multiplyScalar( this.radius ).add( this.center );
+
+		}
+
+		return target;
+
+	}
+
+	getBoundingBox( target ) {
+
+		if ( this.isEmpty() ) {
+
+			// Empty sphere produces empty bounding box
+			target.makeEmpty();
+			return target;
+
+		}
+
+		target.set( this.center, this.center );
+		target.expandByScalar( this.radius );
+
+		return target;
+
+	}
+
+	applyMatrix4( matrix ) {
+
+		this.center.applyMatrix4( matrix );
+		this.radius = this.radius * matrix.getMaxScaleOnAxis();
+
+		return this;
+
+	}
+
+	translate( offset ) {
+
+		this.center.add( offset );
+
+		return this;
+
+	}
+
+	expandByPoint( point ) {
+
+		if ( this.isEmpty() ) {
+
+			this.center.copy( point );
+
+			this.radius = 0;
+
+			return this;
+
+		}
+
+		_v1$6.subVectors( point, this.center );
+
+		const lengthSq = _v1$6.lengthSq();
+
+		if ( lengthSq > ( this.radius * this.radius ) ) {
+
+			// calculate the minimal sphere
+
+			const length = Math.sqrt( lengthSq );
+
+			const delta = ( length - this.radius ) * 0.5;
+
+			this.center.addScaledVector( _v1$6, delta / length );
+
+			this.radius += delta;
+
+		}
+
+		return this;
+
+	}
+
+	union( sphere ) {
+
+		if ( sphere.isEmpty() ) {
+
+			return this;
+
+		}
+
+		if ( this.isEmpty() ) {
+
+			this.copy( sphere );
+
+			return this;
+
+		}
+
+		if ( this.center.equals( sphere.center ) === true ) {
+
+			 this.radius = Math.max( this.radius, sphere.radius );
+
+		} else {
+
+			_v2$3.subVectors( sphere.center, this.center ).setLength( sphere.radius );
+
+			this.expandByPoint( _v1$6.copy( sphere.center ).add( _v2$3 ) );
+
+			this.expandByPoint( _v1$6.copy( sphere.center ).sub( _v2$3 ) );
+
+		}
+
+		return this;
+
+	}
+
+	equals( sphere ) {
+
+		return sphere.center.equals( this.center ) && ( sphere.radius === this.radius );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+const _vector$a = /*@__PURE__*/ new Vector3();
+const _segCenter = /*@__PURE__*/ new Vector3();
+const _segDir = /*@__PURE__*/ new Vector3();
+const _diff = /*@__PURE__*/ new Vector3();
+
+const _edge1 = /*@__PURE__*/ new Vector3();
+const _edge2 = /*@__PURE__*/ new Vector3();
+const _normal$1 = /*@__PURE__*/ new Vector3();
+
+class Ray {
+
+	constructor( origin = new Vector3(), direction = new Vector3( 0, 0, - 1 ) ) {
+
+		this.origin = origin;
+		this.direction = direction;
+
+	}
+
+	set( origin, direction ) {
+
+		this.origin.copy( origin );
+		this.direction.copy( direction );
+
+		return this;
+
+	}
+
+	copy( ray ) {
+
+		this.origin.copy( ray.origin );
+		this.direction.copy( ray.direction );
+
+		return this;
+
+	}
+
+	at( t, target ) {
+
+		return target.copy( this.origin ).addScaledVector( this.direction, t );
+
+	}
+
+	lookAt( v ) {
+
+		this.direction.copy( v ).sub( this.origin ).normalize();
+
+		return this;
+
+	}
+
+	recast( t ) {
+
+		this.origin.copy( this.at( t, _vector$a ) );
+
+		return this;
+
+	}
+
+	closestPointToPoint( point, target ) {
+
+		target.subVectors( point, this.origin );
+
+		const directionDistance = target.dot( this.direction );
+
+		if ( directionDistance < 0 ) {
+
+			return target.copy( this.origin );
+
+		}
+
+		return target.copy( this.origin ).addScaledVector( this.direction, directionDistance );
+
+	}
+
+	distanceToPoint( point ) {
+
+		return Math.sqrt( this.distanceSqToPoint( point ) );
+
+	}
+
+	distanceSqToPoint( point ) {
+
+		const directionDistance = _vector$a.subVectors( point, this.origin ).dot( this.direction );
+
+		// point behind the ray
+
+		if ( directionDistance < 0 ) {
+
+			return this.origin.distanceToSquared( point );
+
+		}
+
+		_vector$a.copy( this.origin ).addScaledVector( this.direction, directionDistance );
+
+		return _vector$a.distanceToSquared( point );
+
+	}
+
+	distanceSqToSegment( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {
+
+		// from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteDistRaySegment.h
+		// It returns the min distance between the ray and the segment
+		// defined by v0 and v1
+		// It can also set two optional targets :
+		// - The closest point on the ray
+		// - The closest point on the segment
+
+		_segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );
+		_segDir.copy( v1 ).sub( v0 ).normalize();
+		_diff.copy( this.origin ).sub( _segCenter );
+
+		const segExtent = v0.distanceTo( v1 ) * 0.5;
+		const a01 = - this.direction.dot( _segDir );
+		const b0 = _diff.dot( this.direction );
+		const b1 = - _diff.dot( _segDir );
+		const c = _diff.lengthSq();
+		const det = Math.abs( 1 - a01 * a01 );
+		let s0, s1, sqrDist, extDet;
+
+		if ( det > 0 ) {
+
+			// The ray and segment are not parallel.
+
+			s0 = a01 * b1 - b0;
+			s1 = a01 * b0 - b1;
+			extDet = segExtent * det;
+
+			if ( s0 >= 0 ) {
+
+				if ( s1 >= - extDet ) {
+
+					if ( s1 <= extDet ) {
+
+						// region 0
+						// Minimum at interior points of ray and segment.
+
+						const invDet = 1 / det;
+						s0 *= invDet;
+						s1 *= invDet;
+						sqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;
+
+					} else {
+
+						// region 1
+
+						s1 = segExtent;
+						s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
+						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+					}
+
+				} else {
+
+					// region 5
+
+					s1 = - segExtent;
+					s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
+					sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+				}
+
+			} else {
+
+				if ( s1 <= - extDet ) {
+
+					// region 4
+
+					s0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );
+					s1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
+					sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+				} else if ( s1 <= extDet ) {
+
+					// region 3
+
+					s0 = 0;
+					s1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );
+					sqrDist = s1 * ( s1 + 2 * b1 ) + c;
+
+				} else {
+
+					// region 2
+
+					s0 = Math.max( 0, - ( a01 * segExtent + b0 ) );
+					s1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
+					sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+				}
+
+			}
+
+		} else {
+
+			// Ray and segment are parallel.
+
+			s1 = ( a01 > 0 ) ? - segExtent : segExtent;
+			s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
+			sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+		}
+
+		if ( optionalPointOnRay ) {
+
+			optionalPointOnRay.copy( this.origin ).addScaledVector( this.direction, s0 );
+
+		}
+
+		if ( optionalPointOnSegment ) {
+
+			optionalPointOnSegment.copy( _segCenter ).addScaledVector( _segDir, s1 );
+
+		}
+
+		return sqrDist;
+
+	}
+
+	intersectSphere( sphere, target ) {
+
+		_vector$a.subVectors( sphere.center, this.origin );
+		const tca = _vector$a.dot( this.direction );
+		const d2 = _vector$a.dot( _vector$a ) - tca * tca;
+		const radius2 = sphere.radius * sphere.radius;
+
+		if ( d2 > radius2 ) return null;
+
+		const thc = Math.sqrt( radius2 - d2 );
+
+		// t0 = first intersect point - entrance on front of sphere
+		const t0 = tca - thc;
+
+		// t1 = second intersect point - exit point on back of sphere
+		const t1 = tca + thc;
+
+		// test to see if t1 is behind the ray - if so, return null
+		if ( t1 < 0 ) return null;
+
+		// test to see if t0 is behind the ray:
+		// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
+		// in order to always return an intersect point that is in front of the ray.
+		if ( t0 < 0 ) return this.at( t1, target );
+
+		// else t0 is in front of the ray, so return the first collision point scaled by t0
+		return this.at( t0, target );
+
+	}
+
+	intersectsSphere( sphere ) {
+
+		return this.distanceSqToPoint( sphere.center ) <= ( sphere.radius * sphere.radius );
+
+	}
+
+	distanceToPlane( plane ) {
+
+		const denominator = plane.normal.dot( this.direction );
+
+		if ( denominator === 0 ) {
+
+			// line is coplanar, return origin
+			if ( plane.distanceToPoint( this.origin ) === 0 ) {
+
+				return 0;
+
+			}
+
+			// Null is preferable to undefined since undefined means.... it is undefined
+
+			return null;
+
+		}
+
+		const t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;
+
+		// Return if the ray never intersects the plane
+
+		return t >= 0 ? t : null;
+
+	}
+
+	intersectPlane( plane, target ) {
+
+		const t = this.distanceToPlane( plane );
+
+		if ( t === null ) {
+
+			return null;
+
+		}
+
+		return this.at( t, target );
+
+	}
+
+	intersectsPlane( plane ) {
+
+		// check if the ray lies on the plane first
+
+		const distToPoint = plane.distanceToPoint( this.origin );
+
+		if ( distToPoint === 0 ) {
+
+			return true;
+
+		}
+
+		const denominator = plane.normal.dot( this.direction );
+
+		if ( denominator * distToPoint < 0 ) {
+
+			return true;
+
+		}
+
+		// ray origin is behind the plane (and is pointing behind it)
+
+		return false;
+
+	}
+
+	intersectBox( box, target ) {
+
+		let tmin, tmax, tymin, tymax, tzmin, tzmax;
+
+		const invdirx = 1 / this.direction.x,
+			invdiry = 1 / this.direction.y,
+			invdirz = 1 / this.direction.z;
+
+		const origin = this.origin;
+
+		if ( invdirx >= 0 ) {
+
+			tmin = ( box.min.x - origin.x ) * invdirx;
+			tmax = ( box.max.x - origin.x ) * invdirx;
+
+		} else {
+
+			tmin = ( box.max.x - origin.x ) * invdirx;
+			tmax = ( box.min.x - origin.x ) * invdirx;
+
+		}
+
+		if ( invdiry >= 0 ) {
+
+			tymin = ( box.min.y - origin.y ) * invdiry;
+			tymax = ( box.max.y - origin.y ) * invdiry;
+
+		} else {
+
+			tymin = ( box.max.y - origin.y ) * invdiry;
+			tymax = ( box.min.y - origin.y ) * invdiry;
+
+		}
+
+		if ( ( tmin > tymax ) || ( tymin > tmax ) ) return null;
+
+		if ( tymin > tmin || isNaN( tmin ) ) tmin = tymin;
+
+		if ( tymax < tmax || isNaN( tmax ) ) tmax = tymax;
+
+		if ( invdirz >= 0 ) {
+
+			tzmin = ( box.min.z - origin.z ) * invdirz;
+			tzmax = ( box.max.z - origin.z ) * invdirz;
+
+		} else {
+
+			tzmin = ( box.max.z - origin.z ) * invdirz;
+			tzmax = ( box.min.z - origin.z ) * invdirz;
+
+		}
+
+		if ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null;
+
+		if ( tzmin > tmin || tmin !== tmin ) tmin = tzmin;
+
+		if ( tzmax < tmax || tmax !== tmax ) tmax = tzmax;
+
+		//return point closest to the ray (positive side)
+
+		if ( tmax < 0 ) return null;
+
+		return this.at( tmin >= 0 ? tmin : tmax, target );
+
+	}
+
+	intersectsBox( box ) {
+
+		return this.intersectBox( box, _vector$a ) !== null;
+
+	}
+
+	intersectTriangle( a, b, c, backfaceCulling, target ) {
+
+		// Compute the offset origin, edges, and normal.
+
+		// from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+
+		_edge1.subVectors( b, a );
+		_edge2.subVectors( c, a );
+		_normal$1.crossVectors( _edge1, _edge2 );
+
+		// Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
+		// E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
+		//   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
+		//   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
+		//   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
+		let DdN = this.direction.dot( _normal$1 );
+		let sign;
+
+		if ( DdN > 0 ) {
+
+			if ( backfaceCulling ) return null;
+			sign = 1;
+
+		} else if ( DdN < 0 ) {
+
+			sign = - 1;
+			DdN = - DdN;
+
+		} else {
+
+			return null;
+
+		}
+
+		_diff.subVectors( this.origin, a );
+		const DdQxE2 = sign * this.direction.dot( _edge2.crossVectors( _diff, _edge2 ) );
+
+		// b1 < 0, no intersection
+		if ( DdQxE2 < 0 ) {
+
+			return null;
+
+		}
+
+		const DdE1xQ = sign * this.direction.dot( _edge1.cross( _diff ) );
+
+		// b2 < 0, no intersection
+		if ( DdE1xQ < 0 ) {
+
+			return null;
+
+		}
+
+		// b1+b2 > 1, no intersection
+		if ( DdQxE2 + DdE1xQ > DdN ) {
+
+			return null;
+
+		}
+
+		// Line intersects triangle, check if ray does.
+		const QdN = - sign * _diff.dot( _normal$1 );
+
+		// t < 0, no intersection
+		if ( QdN < 0 ) {
+
+			return null;
+
+		}
+
+		// Ray intersects triangle.
+		return this.at( QdN / DdN, target );
+
+	}
+
+	applyMatrix4( matrix4 ) {
+
+		this.origin.applyMatrix4( matrix4 );
+		this.direction.transformDirection( matrix4 );
+
+		return this;
+
+	}
+
+	equals( ray ) {
+
+		return ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+class Matrix4 {
+
+	constructor( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {
+
+		Matrix4.prototype.isMatrix4 = true;
+
+		this.elements = [
+
+			1, 0, 0, 0,
+			0, 1, 0, 0,
+			0, 0, 1, 0,
+			0, 0, 0, 1
+
+		];
+
+		if ( n11 !== undefined ) {
+
+			this.set( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 );
+
+		}
+
+	}
+
+	set( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {
+
+		const te = this.elements;
+
+		te[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;
+		te[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;
+		te[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;
+		te[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;
+
+		return this;
+
+	}
+
+	identity() {
+
+		this.set(
+
+			1, 0, 0, 0,
+			0, 1, 0, 0,
+			0, 0, 1, 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new Matrix4().fromArray( this.elements );
+
+	}
+
+	copy( m ) {
+
+		const te = this.elements;
+		const me = m.elements;
+
+		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];
+		te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];
+		te[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];
+		te[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];
+
+		return this;
+
+	}
+
+	copyPosition( m ) {
+
+		const te = this.elements, me = m.elements;
+
+		te[ 12 ] = me[ 12 ];
+		te[ 13 ] = me[ 13 ];
+		te[ 14 ] = me[ 14 ];
+
+		return this;
+
+	}
+
+	setFromMatrix3( m ) {
+
+		const me = m.elements;
+
+		this.set(
+
+			me[ 0 ], me[ 3 ], me[ 6 ], 0,
+			me[ 1 ], me[ 4 ], me[ 7 ], 0,
+			me[ 2 ], me[ 5 ], me[ 8 ], 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	extractBasis( xAxis, yAxis, zAxis ) {
+
+		xAxis.setFromMatrixColumn( this, 0 );
+		yAxis.setFromMatrixColumn( this, 1 );
+		zAxis.setFromMatrixColumn( this, 2 );
+
+		return this;
+
+	}
+
+	makeBasis( xAxis, yAxis, zAxis ) {
+
+		this.set(
+			xAxis.x, yAxis.x, zAxis.x, 0,
+			xAxis.y, yAxis.y, zAxis.y, 0,
+			xAxis.z, yAxis.z, zAxis.z, 0,
+			0, 0, 0, 1
+		);
+
+		return this;
+
+	}
+
+	extractRotation( m ) {
+
+		// this method does not support reflection matrices
+
+		const te = this.elements;
+		const me = m.elements;
+
+		const scaleX = 1 / _v1$5.setFromMatrixColumn( m, 0 ).length();
+		const scaleY = 1 / _v1$5.setFromMatrixColumn( m, 1 ).length();
+		const scaleZ = 1 / _v1$5.setFromMatrixColumn( m, 2 ).length();
+
+		te[ 0 ] = me[ 0 ] * scaleX;
+		te[ 1 ] = me[ 1 ] * scaleX;
+		te[ 2 ] = me[ 2 ] * scaleX;
+		te[ 3 ] = 0;
+
+		te[ 4 ] = me[ 4 ] * scaleY;
+		te[ 5 ] = me[ 5 ] * scaleY;
+		te[ 6 ] = me[ 6 ] * scaleY;
+		te[ 7 ] = 0;
+
+		te[ 8 ] = me[ 8 ] * scaleZ;
+		te[ 9 ] = me[ 9 ] * scaleZ;
+		te[ 10 ] = me[ 10 ] * scaleZ;
+		te[ 11 ] = 0;
+
+		te[ 12 ] = 0;
+		te[ 13 ] = 0;
+		te[ 14 ] = 0;
+		te[ 15 ] = 1;
+
+		return this;
+
+	}
+
+	makeRotationFromEuler( euler ) {
+
+		const te = this.elements;
+
+		const x = euler.x, y = euler.y, z = euler.z;
+		const a = Math.cos( x ), b = Math.sin( x );
+		const c = Math.cos( y ), d = Math.sin( y );
+		const e = Math.cos( z ), f = Math.sin( z );
+
+		if ( euler.order === 'XYZ' ) {
+
+			const ae = a * e, af = a * f, be = b * e, bf = b * f;
+
+			te[ 0 ] = c * e;
+			te[ 4 ] = - c * f;
+			te[ 8 ] = d;
+
+			te[ 1 ] = af + be * d;
+			te[ 5 ] = ae - bf * d;
+			te[ 9 ] = - b * c;
+
+			te[ 2 ] = bf - ae * d;
+			te[ 6 ] = be + af * d;
+			te[ 10 ] = a * c;
+
+		} else if ( euler.order === 'YXZ' ) {
+
+			const ce = c * e, cf = c * f, de = d * e, df = d * f;
+
+			te[ 0 ] = ce + df * b;
+			te[ 4 ] = de * b - cf;
+			te[ 8 ] = a * d;
+
+			te[ 1 ] = a * f;
+			te[ 5 ] = a * e;
+			te[ 9 ] = - b;
+
+			te[ 2 ] = cf * b - de;
+			te[ 6 ] = df + ce * b;
+			te[ 10 ] = a * c;
+
+		} else if ( euler.order === 'ZXY' ) {
+
+			const ce = c * e, cf = c * f, de = d * e, df = d * f;
+
+			te[ 0 ] = ce - df * b;
+			te[ 4 ] = - a * f;
+			te[ 8 ] = de + cf * b;
+
+			te[ 1 ] = cf + de * b;
+			te[ 5 ] = a * e;
+			te[ 9 ] = df - ce * b;
+
+			te[ 2 ] = - a * d;
+			te[ 6 ] = b;
+			te[ 10 ] = a * c;
+
+		} else if ( euler.order === 'ZYX' ) {
+
+			const ae = a * e, af = a * f, be = b * e, bf = b * f;
+
+			te[ 0 ] = c * e;
+			te[ 4 ] = be * d - af;
+			te[ 8 ] = ae * d + bf;
+
+			te[ 1 ] = c * f;
+			te[ 5 ] = bf * d + ae;
+			te[ 9 ] = af * d - be;
+
+			te[ 2 ] = - d;
+			te[ 6 ] = b * c;
+			te[ 10 ] = a * c;
+
+		} else if ( euler.order === 'YZX' ) {
+
+			const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+
+			te[ 0 ] = c * e;
+			te[ 4 ] = bd - ac * f;
+			te[ 8 ] = bc * f + ad;
+
+			te[ 1 ] = f;
+			te[ 5 ] = a * e;
+			te[ 9 ] = - b * e;
+
+			te[ 2 ] = - d * e;
+			te[ 6 ] = ad * f + bc;
+			te[ 10 ] = ac - bd * f;
+
+		} else if ( euler.order === 'XZY' ) {
+
+			const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+
+			te[ 0 ] = c * e;
+			te[ 4 ] = - f;
+			te[ 8 ] = d * e;
+
+			te[ 1 ] = ac * f + bd;
+			te[ 5 ] = a * e;
+			te[ 9 ] = ad * f - bc;
+
+			te[ 2 ] = bc * f - ad;
+			te[ 6 ] = b * e;
+			te[ 10 ] = bd * f + ac;
+
+		}
+
+		// bottom row
+		te[ 3 ] = 0;
+		te[ 7 ] = 0;
+		te[ 11 ] = 0;
+
+		// last column
+		te[ 12 ] = 0;
+		te[ 13 ] = 0;
+		te[ 14 ] = 0;
+		te[ 15 ] = 1;
+
+		return this;
+
+	}
+
+	makeRotationFromQuaternion( q ) {
+
+		return this.compose( _zero, q, _one );
+
+	}
+
+	lookAt( eye, target, up ) {
+
+		const te = this.elements;
+
+		_z.subVectors( eye, target );
+
+		if ( _z.lengthSq() === 0 ) {
+
+			// eye and target are in the same position
+
+			_z.z = 1;
+
+		}
+
+		_z.normalize();
+		_x.crossVectors( up, _z );
+
+		if ( _x.lengthSq() === 0 ) {
+
+			// up and z are parallel
+
+			if ( Math.abs( up.z ) === 1 ) {
+
+				_z.x += 0.0001;
+
+			} else {
+
+				_z.z += 0.0001;
+
+			}
+
+			_z.normalize();
+			_x.crossVectors( up, _z );
+
+		}
+
+		_x.normalize();
+		_y.crossVectors( _z, _x );
+
+		te[ 0 ] = _x.x; te[ 4 ] = _y.x; te[ 8 ] = _z.x;
+		te[ 1 ] = _x.y; te[ 5 ] = _y.y; te[ 9 ] = _z.y;
+		te[ 2 ] = _x.z; te[ 6 ] = _y.z; te[ 10 ] = _z.z;
+
+		return this;
+
+	}
+
+	multiply( m ) {
+
+		return this.multiplyMatrices( this, m );
+
+	}
+
+	premultiply( m ) {
+
+		return this.multiplyMatrices( m, this );
+
+	}
+
+	multiplyMatrices( a, b ) {
+
+		const ae = a.elements;
+		const be = b.elements;
+		const te = this.elements;
+
+		const a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];
+		const a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];
+		const a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];
+		const a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];
+
+		const b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];
+		const b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];
+		const b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];
+		const b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];
+
+		te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
+		te[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
+		te[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
+		te[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
+
+		te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
+		te[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
+		te[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
+		te[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
+
+		te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
+		te[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
+		te[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
+		te[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
+
+		te[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
+		te[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
+		te[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
+		te[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
+
+		return this;
+
+	}
+
+	multiplyScalar( s ) {
+
+		const te = this.elements;
+
+		te[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;
+		te[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;
+		te[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;
+		te[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;
+
+		return this;
+
+	}
+
+	determinant() {
+
+		const te = this.elements;
+
+		const n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];
+		const n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];
+		const n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];
+		const n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];
+
+		//TODO: make this more efficient
+		//( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )
+
+		return (
+			n41 * (
+				+ n14 * n23 * n32
+				 - n13 * n24 * n32
+				 - n14 * n22 * n33
+				 + n12 * n24 * n33
+				 + n13 * n22 * n34
+				 - n12 * n23 * n34
+			) +
+			n42 * (
+				+ n11 * n23 * n34
+				 - n11 * n24 * n33
+				 + n14 * n21 * n33
+				 - n13 * n21 * n34
+				 + n13 * n24 * n31
+				 - n14 * n23 * n31
+			) +
+			n43 * (
+				+ n11 * n24 * n32
+				 - n11 * n22 * n34
+				 - n14 * n21 * n32
+				 + n12 * n21 * n34
+				 + n14 * n22 * n31
+				 - n12 * n24 * n31
+			) +
+			n44 * (
+				- n13 * n22 * n31
+				 - n11 * n23 * n32
+				 + n11 * n22 * n33
+				 + n13 * n21 * n32
+				 - n12 * n21 * n33
+				 + n12 * n23 * n31
+			)
+
+		);
+
+	}
+
+	transpose() {
+
+		const te = this.elements;
+		let tmp;
+
+		tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;
+		tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;
+		tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;
+
+		tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;
+		tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;
+		tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;
+
+		return this;
+
+	}
+
+	setPosition( x, y, z ) {
+
+		const te = this.elements;
+
+		if ( x.isVector3 ) {
+
+			te[ 12 ] = x.x;
+			te[ 13 ] = x.y;
+			te[ 14 ] = x.z;
+
+		} else {
+
+			te[ 12 ] = x;
+			te[ 13 ] = y;
+			te[ 14 ] = z;
+
+		}
+
+		return this;
+
+	}
+
+	invert() {
+
+		// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
+		const te = this.elements,
+
+			n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ], n41 = te[ 3 ],
+			n12 = te[ 4 ], n22 = te[ 5 ], n32 = te[ 6 ], n42 = te[ 7 ],
+			n13 = te[ 8 ], n23 = te[ 9 ], n33 = te[ 10 ], n43 = te[ 11 ],
+			n14 = te[ 12 ], n24 = te[ 13 ], n34 = te[ 14 ], n44 = te[ 15 ],
+
+			t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
+			t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
+			t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
+			t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+
+		const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+
+		if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
+
+		const detInv = 1 / det;
+
+		te[ 0 ] = t11 * detInv;
+		te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;
+		te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;
+		te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;
+
+		te[ 4 ] = t12 * detInv;
+		te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;
+		te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;
+		te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;
+
+		te[ 8 ] = t13 * detInv;
+		te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;
+		te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;
+		te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;
+
+		te[ 12 ] = t14 * detInv;
+		te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;
+		te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;
+		te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;
+
+		return this;
+
+	}
+
+	scale( v ) {
+
+		const te = this.elements;
+		const x = v.x, y = v.y, z = v.z;
+
+		te[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;
+		te[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;
+		te[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;
+		te[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;
+
+		return this;
+
+	}
+
+	getMaxScaleOnAxis() {
+
+		const te = this.elements;
+
+		const scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];
+		const scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];
+		const scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];
+
+		return Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );
+
+	}
+
+	makeTranslation( x, y, z ) {
+
+		if ( x.isVector3 ) {
+
+			this.set(
+
+				1, 0, 0, x.x,
+				0, 1, 0, x.y,
+				0, 0, 1, x.z,
+				0, 0, 0, 1
+
+			);
+
+		} else {
+
+			this.set(
+
+				1, 0, 0, x,
+				0, 1, 0, y,
+				0, 0, 1, z,
+				0, 0, 0, 1
+
+			);
+
+		}
+
+		return this;
+
+	}
+
+	makeRotationX( theta ) {
+
+		const c = Math.cos( theta ), s = Math.sin( theta );
+
+		this.set(
+
+			1, 0, 0, 0,
+			0, c, - s, 0,
+			0, s, c, 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	makeRotationY( theta ) {
+
+		const c = Math.cos( theta ), s = Math.sin( theta );
+
+		this.set(
+
+			 c, 0, s, 0,
+			 0, 1, 0, 0,
+			- s, 0, c, 0,
+			 0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	makeRotationZ( theta ) {
+
+		const c = Math.cos( theta ), s = Math.sin( theta );
+
+		this.set(
+
+			c, - s, 0, 0,
+			s, c, 0, 0,
+			0, 0, 1, 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	makeRotationAxis( axis, angle ) {
+
+		// Based on http://www.gamedev.net/reference/articles/article1199.asp
+
+		const c = Math.cos( angle );
+		const s = Math.sin( angle );
+		const t = 1 - c;
+		const x = axis.x, y = axis.y, z = axis.z;
+		const tx = t * x, ty = t * y;
+
+		this.set(
+
+			tx * x + c, tx * y - s * z, tx * z + s * y, 0,
+			tx * y + s * z, ty * y + c, ty * z - s * x, 0,
+			tx * z - s * y, ty * z + s * x, t * z * z + c, 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	makeScale( x, y, z ) {
+
+		this.set(
+
+			x, 0, 0, 0,
+			0, y, 0, 0,
+			0, 0, z, 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	makeShear( xy, xz, yx, yz, zx, zy ) {
+
+		this.set(
+
+			1, yx, zx, 0,
+			xy, 1, zy, 0,
+			xz, yz, 1, 0,
+			0, 0, 0, 1
+
+		);
+
+		return this;
+
+	}
+
+	compose( position, quaternion, scale ) {
+
+		const te = this.elements;
+
+		const x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
+		const x2 = x + x,	y2 = y + y, z2 = z + z;
+		const xx = x * x2, xy = x * y2, xz = x * z2;
+		const yy = y * y2, yz = y * z2, zz = z * z2;
+		const wx = w * x2, wy = w * y2, wz = w * z2;
+
+		const sx = scale.x, sy = scale.y, sz = scale.z;
+
+		te[ 0 ] = ( 1 - ( yy + zz ) ) * sx;
+		te[ 1 ] = ( xy + wz ) * sx;
+		te[ 2 ] = ( xz - wy ) * sx;
+		te[ 3 ] = 0;
+
+		te[ 4 ] = ( xy - wz ) * sy;
+		te[ 5 ] = ( 1 - ( xx + zz ) ) * sy;
+		te[ 6 ] = ( yz + wx ) * sy;
+		te[ 7 ] = 0;
+
+		te[ 8 ] = ( xz + wy ) * sz;
+		te[ 9 ] = ( yz - wx ) * sz;
+		te[ 10 ] = ( 1 - ( xx + yy ) ) * sz;
+		te[ 11 ] = 0;
+
+		te[ 12 ] = position.x;
+		te[ 13 ] = position.y;
+		te[ 14 ] = position.z;
+		te[ 15 ] = 1;
+
+		return this;
+
+	}
+
+	decompose( position, quaternion, scale ) {
+
+		const te = this.elements;
+
+		let sx = _v1$5.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
+		const sy = _v1$5.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
+		const sz = _v1$5.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
+
+		// if determine is negative, we need to invert one scale
+		const det = this.determinant();
+		if ( det < 0 ) sx = - sx;
+
+		position.x = te[ 12 ];
+		position.y = te[ 13 ];
+		position.z = te[ 14 ];
+
+		// scale the rotation part
+		_m1$2.copy( this );
+
+		const invSX = 1 / sx;
+		const invSY = 1 / sy;
+		const invSZ = 1 / sz;
+
+		_m1$2.elements[ 0 ] *= invSX;
+		_m1$2.elements[ 1 ] *= invSX;
+		_m1$2.elements[ 2 ] *= invSX;
+
+		_m1$2.elements[ 4 ] *= invSY;
+		_m1$2.elements[ 5 ] *= invSY;
+		_m1$2.elements[ 6 ] *= invSY;
+
+		_m1$2.elements[ 8 ] *= invSZ;
+		_m1$2.elements[ 9 ] *= invSZ;
+		_m1$2.elements[ 10 ] *= invSZ;
+
+		quaternion.setFromRotationMatrix( _m1$2 );
+
+		scale.x = sx;
+		scale.y = sy;
+		scale.z = sz;
+
+		return this;
+
+	}
+
+	makePerspective( left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem ) {
+
+		const te = this.elements;
+		const x = 2 * near / ( right - left );
+		const y = 2 * near / ( top - bottom );
+
+		const a = ( right + left ) / ( right - left );
+		const b = ( top + bottom ) / ( top - bottom );
+
+		let c, d;
+
+		if ( coordinateSystem === WebGLCoordinateSystem ) {
+
+			c = - ( far + near ) / ( far - near );
+			d = ( - 2 * far * near ) / ( far - near );
+
+		} else if ( coordinateSystem === WebGPUCoordinateSystem ) {
+
+			c = - far / ( far - near );
+			d = ( - far * near ) / ( far - near );
+
+		} else {
+
+			throw new Error( 'THREE.Matrix4.makePerspective(): Invalid coordinate system: ' + coordinateSystem );
+
+		}
+
+		te[ 0 ] = x;	te[ 4 ] = 0;	te[ 8 ] = a; 	te[ 12 ] = 0;
+		te[ 1 ] = 0;	te[ 5 ] = y;	te[ 9 ] = b; 	te[ 13 ] = 0;
+		te[ 2 ] = 0;	te[ 6 ] = 0;	te[ 10 ] = c; 	te[ 14 ] = d;
+		te[ 3 ] = 0;	te[ 7 ] = 0;	te[ 11 ] = - 1;	te[ 15 ] = 0;
+
+		return this;
+
+	}
+
+	makeOrthographic( left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem ) {
+
+		const te = this.elements;
+		const w = 1.0 / ( right - left );
+		const h = 1.0 / ( top - bottom );
+		const p = 1.0 / ( far - near );
+
+		const x = ( right + left ) * w;
+		const y = ( top + bottom ) * h;
+
+		let z, zInv;
+
+		if ( coordinateSystem === WebGLCoordinateSystem ) {
+
+			z = ( far + near ) * p;
+			zInv = - 2 * p;
+
+		} else if ( coordinateSystem === WebGPUCoordinateSystem ) {
+
+			z = near * p;
+			zInv = - 1 * p;
+
+		} else {
+
+			throw new Error( 'THREE.Matrix4.makeOrthographic(): Invalid coordinate system: ' + coordinateSystem );
+
+		}
+
+		te[ 0 ] = 2 * w;	te[ 4 ] = 0;		te[ 8 ] = 0; 		te[ 12 ] = - x;
+		te[ 1 ] = 0; 		te[ 5 ] = 2 * h;	te[ 9 ] = 0; 		te[ 13 ] = - y;
+		te[ 2 ] = 0; 		te[ 6 ] = 0;		te[ 10 ] = zInv;	te[ 14 ] = - z;
+		te[ 3 ] = 0; 		te[ 7 ] = 0;		te[ 11 ] = 0;		te[ 15 ] = 1;
+
+		return this;
+
+	}
+
+	equals( matrix ) {
+
+		const te = this.elements;
+		const me = matrix.elements;
+
+		for ( let i = 0; i < 16; i ++ ) {
+
+			if ( te[ i ] !== me[ i ] ) return false;
+
+		}
+
+		return true;
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		for ( let i = 0; i < 16; i ++ ) {
+
+			this.elements[ i ] = array[ i + offset ];
+
+		}
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		const te = this.elements;
+
+		array[ offset ] = te[ 0 ];
+		array[ offset + 1 ] = te[ 1 ];
+		array[ offset + 2 ] = te[ 2 ];
+		array[ offset + 3 ] = te[ 3 ];
+
+		array[ offset + 4 ] = te[ 4 ];
+		array[ offset + 5 ] = te[ 5 ];
+		array[ offset + 6 ] = te[ 6 ];
+		array[ offset + 7 ] = te[ 7 ];
+
+		array[ offset + 8 ] = te[ 8 ];
+		array[ offset + 9 ] = te[ 9 ];
+		array[ offset + 10 ] = te[ 10 ];
+		array[ offset + 11 ] = te[ 11 ];
+
+		array[ offset + 12 ] = te[ 12 ];
+		array[ offset + 13 ] = te[ 13 ];
+		array[ offset + 14 ] = te[ 14 ];
+		array[ offset + 15 ] = te[ 15 ];
+
+		return array;
+
+	}
+
+}
+
+const _v1$5 = /*@__PURE__*/ new Vector3();
+const _m1$2 = /*@__PURE__*/ new Matrix4();
+const _zero = /*@__PURE__*/ new Vector3( 0, 0, 0 );
+const _one = /*@__PURE__*/ new Vector3( 1, 1, 1 );
+const _x = /*@__PURE__*/ new Vector3();
+const _y = /*@__PURE__*/ new Vector3();
+const _z = /*@__PURE__*/ new Vector3();
+
+const _matrix$1 = /*@__PURE__*/ new Matrix4();
+const _quaternion$3 = /*@__PURE__*/ new Quaternion();
+
+class Euler {
+
+	constructor( x = 0, y = 0, z = 0, order = Euler.DEFAULT_ORDER ) {
+
+		this.isEuler = true;
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._order = order;
+
+	}
+
+	get x() {
+
+		return this._x;
+
+	}
+
+	set x( value ) {
+
+		this._x = value;
+		this._onChangeCallback();
+
+	}
+
+	get y() {
+
+		return this._y;
+
+	}
+
+	set y( value ) {
+
+		this._y = value;
+		this._onChangeCallback();
+
+	}
+
+	get z() {
+
+		return this._z;
+
+	}
+
+	set z( value ) {
+
+		this._z = value;
+		this._onChangeCallback();
+
+	}
+
+	get order() {
+
+		return this._order;
+
+	}
+
+	set order( value ) {
+
+		this._order = value;
+		this._onChangeCallback();
+
+	}
+
+	set( x, y, z, order = this._order ) {
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._order = order;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor( this._x, this._y, this._z, this._order );
+
+	}
+
+	copy( euler ) {
+
+		this._x = euler._x;
+		this._y = euler._y;
+		this._z = euler._z;
+		this._order = euler._order;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromRotationMatrix( m, order = this._order, update = true ) {
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		const te = m.elements;
+		const m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];
+		const m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];
+		const m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
+
+		switch ( order ) {
+
+			case 'XYZ':
+
+				this._y = Math.asin( clamp( m13, - 1, 1 ) );
+
+				if ( Math.abs( m13 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( - m23, m33 );
+					this._z = Math.atan2( - m12, m11 );
+
+				} else {
+
+					this._x = Math.atan2( m32, m22 );
+					this._z = 0;
+
+				}
+
+				break;
+
+			case 'YXZ':
+
+				this._x = Math.asin( - clamp( m23, - 1, 1 ) );
+
+				if ( Math.abs( m23 ) < 0.9999999 ) {
+
+					this._y = Math.atan2( m13, m33 );
+					this._z = Math.atan2( m21, m22 );
+
+				} else {
+
+					this._y = Math.atan2( - m31, m11 );
+					this._z = 0;
+
+				}
+
+				break;
+
+			case 'ZXY':
+
+				this._x = Math.asin( clamp( m32, - 1, 1 ) );
+
+				if ( Math.abs( m32 ) < 0.9999999 ) {
+
+					this._y = Math.atan2( - m31, m33 );
+					this._z = Math.atan2( - m12, m22 );
+
+				} else {
+
+					this._y = 0;
+					this._z = Math.atan2( m21, m11 );
+
+				}
+
+				break;
+
+			case 'ZYX':
+
+				this._y = Math.asin( - clamp( m31, - 1, 1 ) );
+
+				if ( Math.abs( m31 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( m32, m33 );
+					this._z = Math.atan2( m21, m11 );
+
+				} else {
+
+					this._x = 0;
+					this._z = Math.atan2( - m12, m22 );
+
+				}
+
+				break;
+
+			case 'YZX':
+
+				this._z = Math.asin( clamp( m21, - 1, 1 ) );
+
+				if ( Math.abs( m21 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( - m23, m22 );
+					this._y = Math.atan2( - m31, m11 );
+
+				} else {
+
+					this._x = 0;
+					this._y = Math.atan2( m13, m33 );
+
+				}
+
+				break;
+
+			case 'XZY':
+
+				this._z = Math.asin( - clamp( m12, - 1, 1 ) );
+
+				if ( Math.abs( m12 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( m32, m22 );
+					this._y = Math.atan2( m13, m11 );
+
+				} else {
+
+					this._x = Math.atan2( - m23, m33 );
+					this._y = 0;
+
+				}
+
+				break;
+
+			default:
+
+				console.warn( 'THREE.Euler: .setFromRotationMatrix() encountered an unknown order: ' + order );
+
+		}
+
+		this._order = order;
+
+		if ( update === true ) this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromQuaternion( q, order, update ) {
+
+		_matrix$1.makeRotationFromQuaternion( q );
+
+		return this.setFromRotationMatrix( _matrix$1, order, update );
+
+	}
+
+	setFromVector3( v, order = this._order ) {
+
+		return this.set( v.x, v.y, v.z, order );
+
+	}
+
+	reorder( newOrder ) {
+
+		// WARNING: this discards revolution information -bhouston
+
+		_quaternion$3.setFromEuler( this );
+
+		return this.setFromQuaternion( _quaternion$3, newOrder );
+
+	}
+
+	equals( euler ) {
+
+		return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
+
+	}
+
+	fromArray( array ) {
+
+		this._x = array[ 0 ];
+		this._y = array[ 1 ];
+		this._z = array[ 2 ];
+		if ( array[ 3 ] !== undefined ) this._order = array[ 3 ];
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this._x;
+		array[ offset + 1 ] = this._y;
+		array[ offset + 2 ] = this._z;
+		array[ offset + 3 ] = this._order;
+
+		return array;
+
+	}
+
+	_onChange( callback ) {
+
+		this._onChangeCallback = callback;
+
+		return this;
+
+	}
+
+	_onChangeCallback() {}
+
+	*[ Symbol.iterator ]() {
+
+		yield this._x;
+		yield this._y;
+		yield this._z;
+		yield this._order;
+
+	}
+
+}
+
+Euler.DEFAULT_ORDER = 'XYZ';
+
+class Layers {
+
+	constructor() {
+
+		this.mask = 1 | 0;
+
+	}
+
+	set( channel ) {
+
+		this.mask = ( 1 << channel | 0 ) >>> 0;
+
+	}
+
+	enable( channel ) {
+
+		this.mask |= 1 << channel | 0;
+
+	}
+
+	enableAll() {
+
+		this.mask = 0xffffffff | 0;
+
+	}
+
+	toggle( channel ) {
+
+		this.mask ^= 1 << channel | 0;
+
+	}
+
+	disable( channel ) {
+
+		this.mask &= ~ ( 1 << channel | 0 );
+
+	}
+
+	disableAll() {
+
+		this.mask = 0;
+
+	}
+
+	test( layers ) {
+
+		return ( this.mask & layers.mask ) !== 0;
+
+	}
+
+	isEnabled( channel ) {
+
+		return ( this.mask & ( 1 << channel | 0 ) ) !== 0;
+
+	}
+
+}
+
+let _object3DId = 0;
+
+const _v1$4 = /*@__PURE__*/ new Vector3();
+const _q1 = /*@__PURE__*/ new Quaternion();
+const _m1$1 = /*@__PURE__*/ new Matrix4();
+const _target = /*@__PURE__*/ new Vector3();
+
+const _position$3 = /*@__PURE__*/ new Vector3();
+const _scale$2 = /*@__PURE__*/ new Vector3();
+const _quaternion$2 = /*@__PURE__*/ new Quaternion();
+
+const _xAxis = /*@__PURE__*/ new Vector3( 1, 0, 0 );
+const _yAxis = /*@__PURE__*/ new Vector3( 0, 1, 0 );
+const _zAxis = /*@__PURE__*/ new Vector3( 0, 0, 1 );
+
+const _addedEvent = { type: 'added' };
+const _removedEvent = { type: 'removed' };
+
+class Object3D extends EventDispatcher {
+
+	constructor() {
+
+		super();
+
+		this.isObject3D = true;
+
+		Object.defineProperty( this, 'id', { value: _object3DId ++ } );
+
+		this.uuid = generateUUID();
+
+		this.name = '';
+		this.type = 'Object3D';
+
+		this.parent = null;
+		this.children = [];
+
+		this.up = Object3D.DEFAULT_UP.clone();
+
+		const position = new Vector3();
+		const rotation = new Euler();
+		const quaternion = new Quaternion();
+		const scale = new Vector3( 1, 1, 1 );
+
+		function onRotationChange() {
+
+			quaternion.setFromEuler( rotation, false );
+
+		}
+
+		function onQuaternionChange() {
+
+			rotation.setFromQuaternion( quaternion, undefined, false );
+
+		}
+
+		rotation._onChange( onRotationChange );
+		quaternion._onChange( onQuaternionChange );
+
+		Object.defineProperties( this, {
+			position: {
+				configurable: true,
+				enumerable: true,
+				value: position
+			},
+			rotation: {
+				configurable: true,
+				enumerable: true,
+				value: rotation
+			},
+			quaternion: {
+				configurable: true,
+				enumerable: true,
+				value: quaternion
+			},
+			scale: {
+				configurable: true,
+				enumerable: true,
+				value: scale
+			},
+			modelViewMatrix: {
+				value: new Matrix4()
+			},
+			normalMatrix: {
+				value: new Matrix3()
+			}
+		} );
+
+		this.matrix = new Matrix4();
+		this.matrixWorld = new Matrix4();
+
+		this.matrixAutoUpdate = Object3D.DEFAULT_MATRIX_AUTO_UPDATE;
+
+		this.matrixWorldAutoUpdate = Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE; // checked by the renderer
+		this.matrixWorldNeedsUpdate = false;
+
+		this.layers = new Layers();
+		this.visible = true;
+
+		this.castShadow = false;
+		this.receiveShadow = false;
+
+		this.frustumCulled = true;
+		this.renderOrder = 0;
+
+		this.animations = [];
+
+		this.userData = {};
+
+	}
+
+	onBeforeShadow( /* renderer, object, camera, shadowCamera, geometry, depthMaterial, group */ ) {}
+
+	onAfterShadow( /* renderer, object, camera, shadowCamera, geometry, depthMaterial, group */ ) {}
+
+	onBeforeRender( /* renderer, scene, camera, geometry, material, group */ ) {}
+
+	onAfterRender( /* renderer, scene, camera, geometry, material, group */ ) {}
+
+	applyMatrix4( matrix ) {
+
+		if ( this.matrixAutoUpdate ) this.updateMatrix();
+
+		this.matrix.premultiply( matrix );
+
+		this.matrix.decompose( this.position, this.quaternion, this.scale );
+
+	}
+
+	applyQuaternion( q ) {
+
+		this.quaternion.premultiply( q );
+
+		return this;
+
+	}
+
+	setRotationFromAxisAngle( axis, angle ) {
+
+		// assumes axis is normalized
+
+		this.quaternion.setFromAxisAngle( axis, angle );
+
+	}
+
+	setRotationFromEuler( euler ) {
+
+		this.quaternion.setFromEuler( euler, true );
+
+	}
+
+	setRotationFromMatrix( m ) {
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		this.quaternion.setFromRotationMatrix( m );
+
+	}
+
+	setRotationFromQuaternion( q ) {
+
+		// assumes q is normalized
+
+		this.quaternion.copy( q );
+
+	}
+
+	rotateOnAxis( axis, angle ) {
+
+		// rotate object on axis in object space
+		// axis is assumed to be normalized
+
+		_q1.setFromAxisAngle( axis, angle );
+
+		this.quaternion.multiply( _q1 );
+
+		return this;
+
+	}
+
+	rotateOnWorldAxis( axis, angle ) {
+
+		// rotate object on axis in world space
+		// axis is assumed to be normalized
+		// method assumes no rotated parent
+
+		_q1.setFromAxisAngle( axis, angle );
+
+		this.quaternion.premultiply( _q1 );
+
+		return this;
+
+	}
+
+	rotateX( angle ) {
+
+		return this.rotateOnAxis( _xAxis, angle );
+
+	}
+
+	rotateY( angle ) {
+
+		return this.rotateOnAxis( _yAxis, angle );
+
+	}
+
+	rotateZ( angle ) {
+
+		return this.rotateOnAxis( _zAxis, angle );
+
+	}
+
+	translateOnAxis( axis, distance ) {
+
+		// translate object by distance along axis in object space
+		// axis is assumed to be normalized
+
+		_v1$4.copy( axis ).applyQuaternion( this.quaternion );
+
+		this.position.add( _v1$4.multiplyScalar( distance ) );
+
+		return this;
+
+	}
+
+	translateX( distance ) {
+
+		return this.translateOnAxis( _xAxis, distance );
+
+	}
+
+	translateY( distance ) {
+
+		return this.translateOnAxis( _yAxis, distance );
+
+	}
+
+	translateZ( distance ) {
+
+		return this.translateOnAxis( _zAxis, distance );
+
+	}
+
+	localToWorld( vector ) {
+
+		this.updateWorldMatrix( true, false );
+
+		return vector.applyMatrix4( this.matrixWorld );
+
+	}
+
+	worldToLocal( vector ) {
+
+		this.updateWorldMatrix( true, false );
+
+		return vector.applyMatrix4( _m1$1.copy( this.matrixWorld ).invert() );
+
+	}
+
+	lookAt( x, y, z ) {
+
+		// This method does not support objects having non-uniformly-scaled parent(s)
+
+		if ( x.isVector3 ) {
+
+			_target.copy( x );
+
+		} else {
+
+			_target.set( x, y, z );
+
+		}
+
+		const parent = this.parent;
+
+		this.updateWorldMatrix( true, false );
+
+		_position$3.setFromMatrixPosition( this.matrixWorld );
+
+		if ( this.isCamera || this.isLight ) {
+
+			_m1$1.lookAt( _position$3, _target, this.up );
+
+		} else {
+
+			_m1$1.lookAt( _target, _position$3, this.up );
+
+		}
+
+		this.quaternion.setFromRotationMatrix( _m1$1 );
+
+		if ( parent ) {
+
+			_m1$1.extractRotation( parent.matrixWorld );
+			_q1.setFromRotationMatrix( _m1$1 );
+			this.quaternion.premultiply( _q1.invert() );
+
+		}
+
+	}
+
+	add( object ) {
+
+		if ( arguments.length > 1 ) {
+
+			for ( let i = 0; i < arguments.length; i ++ ) {
+
+				this.add( arguments[ i ] );
+
+			}
+
+			return this;
+
+		}
+
+		if ( object === this ) {
+
+			console.error( 'THREE.Object3D.add: object can\'t be added as a child of itself.', object );
+			return this;
+
+		}
+
+		if ( object && object.isObject3D ) {
+
+			if ( object.parent !== null ) {
+
+				object.parent.remove( object );
+
+			}
+
+			object.parent = this;
+			this.children.push( object );
+
+			object.dispatchEvent( _addedEvent );
+
+		} else {
+
+			console.error( 'THREE.Object3D.add: object not an instance of THREE.Object3D.', object );
+
+		}
+
+		return this;
+
+	}
+
+	remove( object ) {
+
+		if ( arguments.length > 1 ) {
+
+			for ( let i = 0; i < arguments.length; i ++ ) {
+
+				this.remove( arguments[ i ] );
+
+			}
+
+			return this;
+
+		}
+
+		const index = this.children.indexOf( object );
+
+		if ( index !== - 1 ) {
+
+			object.parent = null;
+			this.children.splice( index, 1 );
+
+			object.dispatchEvent( _removedEvent );
+
+		}
+
+		return this;
+
+	}
+
+	removeFromParent() {
+
+		const parent = this.parent;
+
+		if ( parent !== null ) {
+
+			parent.remove( this );
+
+		}
+
+		return this;
+
+	}
+
+	clear() {
+
+		return this.remove( ... this.children );
+
+	}
+
+	attach( object ) {
+
+		// adds object as a child of this, while maintaining the object's world transform
+
+		// Note: This method does not support scene graphs having non-uniformly-scaled nodes(s)
+
+		this.updateWorldMatrix( true, false );
+
+		_m1$1.copy( this.matrixWorld ).invert();
+
+		if ( object.parent !== null ) {
+
+			object.parent.updateWorldMatrix( true, false );
+
+			_m1$1.multiply( object.parent.matrixWorld );
+
+		}
+
+		object.applyMatrix4( _m1$1 );
+
+		this.add( object );
+
+		object.updateWorldMatrix( false, true );
+
+		return this;
+
+	}
+
+	getObjectById( id ) {
+
+		return this.getObjectByProperty( 'id', id );
+
+	}
+
+	getObjectByName( name ) {
+
+		return this.getObjectByProperty( 'name', name );
+
+	}
+
+	getObjectByProperty( name, value ) {
+
+		if ( this[ name ] === value ) return this;
+
+		for ( let i = 0, l = this.children.length; i < l; i ++ ) {
+
+			const child = this.children[ i ];
+			const object = child.getObjectByProperty( name, value );
+
+			if ( object !== undefined ) {
+
+				return object;
+
+			}
+
+		}
+
+		return undefined;
+
+	}
+
+	getObjectsByProperty( name, value, result = [] ) {
+
+		if ( this[ name ] === value ) result.push( this );
+
+		const children = this.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			children[ i ].getObjectsByProperty( name, value, result );
+
+		}
+
+		return result;
+
+	}
+
+	getWorldPosition( target ) {
+
+		this.updateWorldMatrix( true, false );
+
+		return target.setFromMatrixPosition( this.matrixWorld );
+
+	}
+
+	getWorldQuaternion( target ) {
+
+		this.updateWorldMatrix( true, false );
+
+		this.matrixWorld.decompose( _position$3, target, _scale$2 );
+
+		return target;
+
+	}
+
+	getWorldScale( target ) {
+
+		this.updateWorldMatrix( true, false );
+
+		this.matrixWorld.decompose( _position$3, _quaternion$2, target );
+
+		return target;
+
+	}
+
+	getWorldDirection( target ) {
+
+		this.updateWorldMatrix( true, false );
+
+		const e = this.matrixWorld.elements;
+
+		return target.set( e[ 8 ], e[ 9 ], e[ 10 ] ).normalize();
+
+	}
+
+	raycast( /* raycaster, intersects */ ) {}
+
+	traverse( callback ) {
+
+		callback( this );
+
+		const children = this.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			children[ i ].traverse( callback );
+
+		}
+
+	}
+
+	traverseVisible( callback ) {
+
+		if ( this.visible === false ) return;
+
+		callback( this );
+
+		const children = this.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			children[ i ].traverseVisible( callback );
+
+		}
+
+	}
+
+	traverseAncestors( callback ) {
+
+		const parent = this.parent;
+
+		if ( parent !== null ) {
+
+			callback( parent );
+
+			parent.traverseAncestors( callback );
+
+		}
+
+	}
+
+	updateMatrix() {
+
+		this.matrix.compose( this.position, this.quaternion, this.scale );
+
+		this.matrixWorldNeedsUpdate = true;
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		if ( this.matrixAutoUpdate ) this.updateMatrix();
+
+		if ( this.matrixWorldNeedsUpdate || force ) {
+
+			if ( this.parent === null ) {
+
+				this.matrixWorld.copy( this.matrix );
+
+			} else {
+
+				this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
+
+			}
+
+			this.matrixWorldNeedsUpdate = false;
+
+			force = true;
+
+		}
+
+		// update children
+
+		const children = this.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			const child = children[ i ];
+
+			if ( child.matrixWorldAutoUpdate === true || force === true ) {
+
+				child.updateMatrixWorld( force );
+
+			}
+
+		}
+
+	}
+
+	updateWorldMatrix( updateParents, updateChildren ) {
+
+		const parent = this.parent;
+
+		if ( updateParents === true && parent !== null && parent.matrixWorldAutoUpdate === true ) {
+
+			parent.updateWorldMatrix( true, false );
+
+		}
+
+		if ( this.matrixAutoUpdate ) this.updateMatrix();
+
+		if ( this.parent === null ) {
+
+			this.matrixWorld.copy( this.matrix );
+
+		} else {
+
+			this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
+
+		}
+
+		// update children
+
+		if ( updateChildren === true ) {
+
+			const children = this.children;
+
+			for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+				const child = children[ i ];
+
+				if ( child.matrixWorldAutoUpdate === true ) {
+
+					child.updateWorldMatrix( false, true );
+
+				}
+
+			}
+
+		}
+
+	}
+
+	toJSON( meta ) {
+
+		// meta is a string when called from JSON.stringify
+		const isRootObject = ( meta === undefined || typeof meta === 'string' );
+
+		const output = {};
+
+		// meta is a hash used to collect geometries, materials.
+		// not providing it implies that this is the root object
+		// being serialized.
+		if ( isRootObject ) {
+
+			// initialize meta obj
+			meta = {
+				geometries: {},
+				materials: {},
+				textures: {},
+				images: {},
+				shapes: {},
+				skeletons: {},
+				animations: {},
+				nodes: {}
+			};
+
+			output.metadata = {
+				version: 4.6,
+				type: 'Object',
+				generator: 'Object3D.toJSON'
+			};
+
+		}
+
+		// standard Object3D serialization
+
+		const object = {};
+
+		object.uuid = this.uuid;
+		object.type = this.type;
+
+		if ( this.name !== '' ) object.name = this.name;
+		if ( this.castShadow === true ) object.castShadow = true;
+		if ( this.receiveShadow === true ) object.receiveShadow = true;
+		if ( this.visible === false ) object.visible = false;
+		if ( this.frustumCulled === false ) object.frustumCulled = false;
+		if ( this.renderOrder !== 0 ) object.renderOrder = this.renderOrder;
+		if ( Object.keys( this.userData ).length > 0 ) object.userData = this.userData;
+
+		object.layers = this.layers.mask;
+		object.matrix = this.matrix.toArray();
+		object.up = this.up.toArray();
+
+		if ( this.matrixAutoUpdate === false ) object.matrixAutoUpdate = false;
+
+		// object specific properties
+
+		if ( this.isInstancedMesh ) {
+
+			object.type = 'InstancedMesh';
+			object.count = this.count;
+			object.instanceMatrix = this.instanceMatrix.toJSON();
+			if ( this.instanceColor !== null ) object.instanceColor = this.instanceColor.toJSON();
+
+		}
+
+		if ( this.isBatchedMesh ) {
+
+			object.type = 'BatchedMesh';
+			object.perObjectFrustumCulled = this.perObjectFrustumCulled;
+			object.sortObjects = this.sortObjects;
+
+			object.drawRanges = this._drawRanges;
+			object.reservedRanges = this._reservedRanges;
+
+			object.visibility = this._visibility;
+			object.active = this._active;
+			object.bounds = this._bounds.map( bound => ( {
+				boxInitialized: bound.boxInitialized,
+				boxMin: bound.box.min.toArray(),
+				boxMax: bound.box.max.toArray(),
+
+				sphereInitialized: bound.sphereInitialized,
+				sphereRadius: bound.sphere.radius,
+				sphereCenter: bound.sphere.center.toArray()
+			} ) );
+
+			object.maxGeometryCount = this._maxGeometryCount;
+			object.maxVertexCount = this._maxVertexCount;
+			object.maxIndexCount = this._maxIndexCount;
+
+			object.geometryInitialized = this._geometryInitialized;
+			object.geometryCount = this._geometryCount;
+
+			object.matricesTexture = this._matricesTexture.toJSON( meta );
+
+			if ( this.boundingSphere !== null ) {
+
+				object.boundingSphere = {
+					center: object.boundingSphere.center.toArray(),
+					radius: object.boundingSphere.radius
+				};
+
+			}
+
+			if ( this.boundingBox !== null ) {
+
+				object.boundingBox = {
+					min: object.boundingBox.min.toArray(),
+					max: object.boundingBox.max.toArray()
+				};
+
+			}
+
+		}
+
+		//
+
+		function serialize( library, element ) {
+
+			if ( library[ element.uuid ] === undefined ) {
+
+				library[ element.uuid ] = element.toJSON( meta );
+
+			}
+
+			return element.uuid;
+
+		}
+
+		if ( this.isScene ) {
+
+			if ( this.background ) {
+
+				if ( this.background.isColor ) {
+
+					object.background = this.background.toJSON();
+
+				} else if ( this.background.isTexture ) {
+
+					object.background = this.background.toJSON( meta ).uuid;
+
+				}
+
+			}
+
+			if ( this.environment && this.environment.isTexture && this.environment.isRenderTargetTexture !== true ) {
+
+				object.environment = this.environment.toJSON( meta ).uuid;
+
+			}
+
+		} else if ( this.isMesh || this.isLine || this.isPoints ) {
+
+			object.geometry = serialize( meta.geometries, this.geometry );
+
+			const parameters = this.geometry.parameters;
+
+			if ( parameters !== undefined && parameters.shapes !== undefined ) {
+
+				const shapes = parameters.shapes;
+
+				if ( Array.isArray( shapes ) ) {
+
+					for ( let i = 0, l = shapes.length; i < l; i ++ ) {
+
+						const shape = shapes[ i ];
+
+						serialize( meta.shapes, shape );
+
+					}
+
+				} else {
+
+					serialize( meta.shapes, shapes );
+
+				}
+
+			}
+
+		}
+
+		if ( this.isSkinnedMesh ) {
+
+			object.bindMode = this.bindMode;
+			object.bindMatrix = this.bindMatrix.toArray();
+
+			if ( this.skeleton !== undefined ) {
+
+				serialize( meta.skeletons, this.skeleton );
+
+				object.skeleton = this.skeleton.uuid;
+
+			}
+
+		}
+
+		if ( this.material !== undefined ) {
+
+			if ( Array.isArray( this.material ) ) {
+
+				const uuids = [];
+
+				for ( let i = 0, l = this.material.length; i < l; i ++ ) {
+
+					uuids.push( serialize( meta.materials, this.material[ i ] ) );
+
+				}
+
+				object.material = uuids;
+
+			} else {
+
+				object.material = serialize( meta.materials, this.material );
+
+			}
+
+		}
+
+		//
+
+		if ( this.children.length > 0 ) {
+
+			object.children = [];
+
+			for ( let i = 0; i < this.children.length; i ++ ) {
+
+				object.children.push( this.children[ i ].toJSON( meta ).object );
+
+			}
+
+		}
+
+		//
+
+		if ( this.animations.length > 0 ) {
+
+			object.animations = [];
+
+			for ( let i = 0; i < this.animations.length; i ++ ) {
+
+				const animation = this.animations[ i ];
+
+				object.animations.push( serialize( meta.animations, animation ) );
+
+			}
+
+		}
+
+		if ( isRootObject ) {
+
+			const geometries = extractFromCache( meta.geometries );
+			const materials = extractFromCache( meta.materials );
+			const textures = extractFromCache( meta.textures );
+			const images = extractFromCache( meta.images );
+			const shapes = extractFromCache( meta.shapes );
+			const skeletons = extractFromCache( meta.skeletons );
+			const animations = extractFromCache( meta.animations );
+			const nodes = extractFromCache( meta.nodes );
+
+			if ( geometries.length > 0 ) output.geometries = geometries;
+			if ( materials.length > 0 ) output.materials = materials;
+			if ( textures.length > 0 ) output.textures = textures;
+			if ( images.length > 0 ) output.images = images;
+			if ( shapes.length > 0 ) output.shapes = shapes;
+			if ( skeletons.length > 0 ) output.skeletons = skeletons;
+			if ( animations.length > 0 ) output.animations = animations;
+			if ( nodes.length > 0 ) output.nodes = nodes;
+
+		}
+
+		output.object = object;
+
+		return output;
+
+		// extract data from the cache hash
+		// remove metadata on each item
+		// and return as array
+		function extractFromCache( cache ) {
+
+			const values = [];
+			for ( const key in cache ) {
+
+				const data = cache[ key ];
+				delete data.metadata;
+				values.push( data );
+
+			}
+
+			return values;
+
+		}
+
+	}
+
+	clone( recursive ) {
+
+		return new this.constructor().copy( this, recursive );
+
+	}
+
+	copy( source, recursive = true ) {
+
+		this.name = source.name;
+
+		this.up.copy( source.up );
+
+		this.position.copy( source.position );
+		this.rotation.order = source.rotation.order;
+		this.quaternion.copy( source.quaternion );
+		this.scale.copy( source.scale );
+
+		this.matrix.copy( source.matrix );
+		this.matrixWorld.copy( source.matrixWorld );
+
+		this.matrixAutoUpdate = source.matrixAutoUpdate;
+
+		this.matrixWorldAutoUpdate = source.matrixWorldAutoUpdate;
+		this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
+
+		this.layers.mask = source.layers.mask;
+		this.visible = source.visible;
+
+		this.castShadow = source.castShadow;
+		this.receiveShadow = source.receiveShadow;
+
+		this.frustumCulled = source.frustumCulled;
+		this.renderOrder = source.renderOrder;
+
+		this.animations = source.animations.slice();
+
+		this.userData = JSON.parse( JSON.stringify( source.userData ) );
+
+		if ( recursive === true ) {
+
+			for ( let i = 0; i < source.children.length; i ++ ) {
+
+				const child = source.children[ i ];
+				this.add( child.clone() );
+
+			}
+
+		}
+
+		return this;
+
+	}
+
+}
+
+Object3D.DEFAULT_UP = /*@__PURE__*/ new Vector3( 0, 1, 0 );
+Object3D.DEFAULT_MATRIX_AUTO_UPDATE = true;
+Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE = true;
+
+const _v0$1 = /*@__PURE__*/ new Vector3();
+const _v1$3 = /*@__PURE__*/ new Vector3();
+const _v2$2 = /*@__PURE__*/ new Vector3();
+const _v3$1 = /*@__PURE__*/ new Vector3();
+
+const _vab = /*@__PURE__*/ new Vector3();
+const _vac = /*@__PURE__*/ new Vector3();
+const _vbc = /*@__PURE__*/ new Vector3();
+const _vap = /*@__PURE__*/ new Vector3();
+const _vbp = /*@__PURE__*/ new Vector3();
+const _vcp = /*@__PURE__*/ new Vector3();
+
+let warnedGetUV = false;
+
+class Triangle {
+
+	constructor( a = new Vector3(), b = new Vector3(), c = new Vector3() ) {
+
+		this.a = a;
+		this.b = b;
+		this.c = c;
+
+	}
+
+	static getNormal( a, b, c, target ) {
+
+		target.subVectors( c, b );
+		_v0$1.subVectors( a, b );
+		target.cross( _v0$1 );
+
+		const targetLengthSq = target.lengthSq();
+		if ( targetLengthSq > 0 ) {
+
+			return target.multiplyScalar( 1 / Math.sqrt( targetLengthSq ) );
+
+		}
+
+		return target.set( 0, 0, 0 );
+
+	}
+
+	// static/instance method to calculate barycentric coordinates
+	// based on: http://www.blackpawn.com/texts/pointinpoly/default.html
+	static getBarycoord( point, a, b, c, target ) {
+
+		_v0$1.subVectors( c, a );
+		_v1$3.subVectors( b, a );
+		_v2$2.subVectors( point, a );
+
+		const dot00 = _v0$1.dot( _v0$1 );
+		const dot01 = _v0$1.dot( _v1$3 );
+		const dot02 = _v0$1.dot( _v2$2 );
+		const dot11 = _v1$3.dot( _v1$3 );
+		const dot12 = _v1$3.dot( _v2$2 );
+
+		const denom = ( dot00 * dot11 - dot01 * dot01 );
+
+		// collinear or singular triangle
+		if ( denom === 0 ) {
+
+			target.set( 0, 0, 0 );
+			return null;
+
+		}
+
+		const invDenom = 1 / denom;
+		const u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;
+		const v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;
+
+		// barycentric coordinates must always sum to 1
+		return target.set( 1 - u - v, v, u );
+
+	}
+
+	static containsPoint( point, a, b, c ) {
+
+		// if the triangle is degenerate then we can't contain a point
+		if ( this.getBarycoord( point, a, b, c, _v3$1 ) === null ) {
+
+			return false;
+
+		}
+
+		return ( _v3$1.x >= 0 ) && ( _v3$1.y >= 0 ) && ( ( _v3$1.x + _v3$1.y ) <= 1 );
+
+	}
+
+	static getUV( point, p1, p2, p3, uv1, uv2, uv3, target ) { // @deprecated, r151
+
+		if ( warnedGetUV === false ) {
+
+			console.warn( 'THREE.Triangle.getUV() has been renamed to THREE.Triangle.getInterpolation().' );
+
+			warnedGetUV = true;
+
+		}
+
+		return this.getInterpolation( point, p1, p2, p3, uv1, uv2, uv3, target );
+
+	}
+
+	static getInterpolation( point, p1, p2, p3, v1, v2, v3, target ) {
+
+		if ( this.getBarycoord( point, p1, p2, p3, _v3$1 ) === null ) {
+
+			target.x = 0;
+			target.y = 0;
+			if ( 'z' in target ) target.z = 0;
+			if ( 'w' in target ) target.w = 0;
+			return null;
+
+		}
+
+		target.setScalar( 0 );
+		target.addScaledVector( v1, _v3$1.x );
+		target.addScaledVector( v2, _v3$1.y );
+		target.addScaledVector( v3, _v3$1.z );
+
+		return target;
+
+	}
+
+	static isFrontFacing( a, b, c, direction ) {
+
+		_v0$1.subVectors( c, b );
+		_v1$3.subVectors( a, b );
+
+		// strictly front facing
+		return ( _v0$1.cross( _v1$3 ).dot( direction ) < 0 ) ? true : false;
+
+	}
+
+	set( a, b, c ) {
+
+		this.a.copy( a );
+		this.b.copy( b );
+		this.c.copy( c );
+
+		return this;
+
+	}
+
+	setFromPointsAndIndices( points, i0, i1, i2 ) {
+
+		this.a.copy( points[ i0 ] );
+		this.b.copy( points[ i1 ] );
+		this.c.copy( points[ i2 ] );
+
+		return this;
+
+	}
+
+	setFromAttributeAndIndices( attribute, i0, i1, i2 ) {
+
+		this.a.fromBufferAttribute( attribute, i0 );
+		this.b.fromBufferAttribute( attribute, i1 );
+		this.c.fromBufferAttribute( attribute, i2 );
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( triangle ) {
+
+		this.a.copy( triangle.a );
+		this.b.copy( triangle.b );
+		this.c.copy( triangle.c );
+
+		return this;
+
+	}
+
+	getArea() {
+
+		_v0$1.subVectors( this.c, this.b );
+		_v1$3.subVectors( this.a, this.b );
+
+		return _v0$1.cross( _v1$3 ).length() * 0.5;
+
+	}
+
+	getMidpoint( target ) {
+
+		return target.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );
+
+	}
+
+	getNormal( target ) {
+
+		return Triangle.getNormal( this.a, this.b, this.c, target );
+
+	}
+
+	getPlane( target ) {
+
+		return target.setFromCoplanarPoints( this.a, this.b, this.c );
+
+	}
+
+	getBarycoord( point, target ) {
+
+		return Triangle.getBarycoord( point, this.a, this.b, this.c, target );
+
+	}
+
+	getUV( point, uv1, uv2, uv3, target ) { // @deprecated, r151
+
+		if ( warnedGetUV === false ) {
+
+			console.warn( 'THREE.Triangle.getUV() has been renamed to THREE.Triangle.getInterpolation().' );
+
+			warnedGetUV = true;
+
+		}
+
+		return Triangle.getInterpolation( point, this.a, this.b, this.c, uv1, uv2, uv3, target );
+
+	}
+
+	getInterpolation( point, v1, v2, v3, target ) {
+
+		return Triangle.getInterpolation( point, this.a, this.b, this.c, v1, v2, v3, target );
+
+	}
+
+	containsPoint( point ) {
+
+		return Triangle.containsPoint( point, this.a, this.b, this.c );
+
+	}
+
+	isFrontFacing( direction ) {
+
+		return Triangle.isFrontFacing( this.a, this.b, this.c, direction );
+
+	}
+
+	intersectsBox( box ) {
+
+		return box.intersectsTriangle( this );
+
+	}
+
+	closestPointToPoint( p, target ) {
+
+		const a = this.a, b = this.b, c = this.c;
+		let v, w;
+
+		// algorithm thanks to Real-Time Collision Detection by Christer Ericson,
+		// published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
+		// under the accompanying license; see chapter 5.1.5 for detailed explanation.
+		// basically, we're distinguishing which of the voronoi regions of the triangle
+		// the point lies in with the minimum amount of redundant computation.
+
+		_vab.subVectors( b, a );
+		_vac.subVectors( c, a );
+		_vap.subVectors( p, a );
+		const d1 = _vab.dot( _vap );
+		const d2 = _vac.dot( _vap );
+		if ( d1 <= 0 && d2 <= 0 ) {
+
+			// vertex region of A; barycentric coords (1, 0, 0)
+			return target.copy( a );
+
+		}
+
+		_vbp.subVectors( p, b );
+		const d3 = _vab.dot( _vbp );
+		const d4 = _vac.dot( _vbp );
+		if ( d3 >= 0 && d4 <= d3 ) {
+
+			// vertex region of B; barycentric coords (0, 1, 0)
+			return target.copy( b );
+
+		}
+
+		const vc = d1 * d4 - d3 * d2;
+		if ( vc <= 0 && d1 >= 0 && d3 <= 0 ) {
+
+			v = d1 / ( d1 - d3 );
+			// edge region of AB; barycentric coords (1-v, v, 0)
+			return target.copy( a ).addScaledVector( _vab, v );
+
+		}
+
+		_vcp.subVectors( p, c );
+		const d5 = _vab.dot( _vcp );
+		const d6 = _vac.dot( _vcp );
+		if ( d6 >= 0 && d5 <= d6 ) {
+
+			// vertex region of C; barycentric coords (0, 0, 1)
+			return target.copy( c );
+
+		}
+
+		const vb = d5 * d2 - d1 * d6;
+		if ( vb <= 0 && d2 >= 0 && d6 <= 0 ) {
+
+			w = d2 / ( d2 - d6 );
+			// edge region of AC; barycentric coords (1-w, 0, w)
+			return target.copy( a ).addScaledVector( _vac, w );
+
+		}
+
+		const va = d3 * d6 - d5 * d4;
+		if ( va <= 0 && ( d4 - d3 ) >= 0 && ( d5 - d6 ) >= 0 ) {
+
+			_vbc.subVectors( c, b );
+			w = ( d4 - d3 ) / ( ( d4 - d3 ) + ( d5 - d6 ) );
+			// edge region of BC; barycentric coords (0, 1-w, w)
+			return target.copy( b ).addScaledVector( _vbc, w ); // edge region of BC
+
+		}
+
+		// face region
+		const denom = 1 / ( va + vb + vc );
+		// u = va * denom
+		v = vb * denom;
+		w = vc * denom;
+
+		return target.copy( a ).addScaledVector( _vab, v ).addScaledVector( _vac, w );
+
+	}
+
+	equals( triangle ) {
+
+		return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );
+
+	}
+
+}
+
+const _colorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,
+	'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,
+	'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,
+	'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,
+	'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,
+	'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,
+	'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,
+	'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,
+	'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,
+	'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,
+	'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,
+	'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,
+	'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,
+	'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,
+	'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,
+	'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,
+	'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,
+	'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,
+	'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,
+	'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,
+	'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,
+	'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,
+	'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,
+	'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };
+
+const _hslA = { h: 0, s: 0, l: 0 };
+const _hslB = { h: 0, s: 0, l: 0 };
+
+function hue2rgb( p, q, t ) {
+
+	if ( t < 0 ) t += 1;
+	if ( t > 1 ) t -= 1;
+	if ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;
+	if ( t < 1 / 2 ) return q;
+	if ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );
+	return p;
+
+}
+
+class Color {
+
+	constructor( r, g, b ) {
+
+		this.isColor = true;
+
+		this.r = 1;
+		this.g = 1;
+		this.b = 1;
+
+		return this.set( r, g, b );
+
+	}
+
+	set( r, g, b ) {
+
+		if ( g === undefined && b === undefined ) {
+
+			// r is THREE.Color, hex or string
+
+			const value = r;
+
+			if ( value && value.isColor ) {
+
+				this.copy( value );
+
+			} else if ( typeof value === 'number' ) {
+
+				this.setHex( value );
+
+			} else if ( typeof value === 'string' ) {
+
+				this.setStyle( value );
+
+			}
+
+		} else {
+
+			this.setRGB( r, g, b );
+
+		}
+
+		return this;
+
+	}
+
+	setScalar( scalar ) {
+
+		this.r = scalar;
+		this.g = scalar;
+		this.b = scalar;
+
+		return this;
+
+	}
+
+	setHex( hex, colorSpace = SRGBColorSpace ) {
+
+		hex = Math.floor( hex );
+
+		this.r = ( hex >> 16 & 255 ) / 255;
+		this.g = ( hex >> 8 & 255 ) / 255;
+		this.b = ( hex & 255 ) / 255;
+
+		ColorManagement.toWorkingColorSpace( this, colorSpace );
+
+		return this;
+
+	}
+
+	setRGB( r, g, b, colorSpace = ColorManagement.workingColorSpace ) {
+
+		this.r = r;
+		this.g = g;
+		this.b = b;
+
+		ColorManagement.toWorkingColorSpace( this, colorSpace );
+
+		return this;
+
+	}
+
+	setHSL( h, s, l, colorSpace = ColorManagement.workingColorSpace ) {
+
+		// h,s,l ranges are in 0.0 - 1.0
+		h = euclideanModulo( h, 1 );
+		s = clamp( s, 0, 1 );
+		l = clamp( l, 0, 1 );
+
+		if ( s === 0 ) {
+
+			this.r = this.g = this.b = l;
+
+		} else {
+
+			const p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );
+			const q = ( 2 * l ) - p;
+
+			this.r = hue2rgb( q, p, h + 1 / 3 );
+			this.g = hue2rgb( q, p, h );
+			this.b = hue2rgb( q, p, h - 1 / 3 );
+
+		}
+
+		ColorManagement.toWorkingColorSpace( this, colorSpace );
+
+		return this;
+
+	}
+
+	setStyle( style, colorSpace = SRGBColorSpace ) {
+
+		function handleAlpha( string ) {
+
+			if ( string === undefined ) return;
+
+			if ( parseFloat( string ) < 1 ) {
+
+				console.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );
+
+			}
+
+		}
+
+
+		let m;
+
+		if ( m = /^(\w+)\(([^\)]*)\)/.exec( style ) ) {
+
+			// rgb / hsl
+
+			let color;
+			const name = m[ 1 ];
+			const components = m[ 2 ];
+
+			switch ( name ) {
+
+				case 'rgb':
+				case 'rgba':
+
+					if ( color = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec( components ) ) {
+
+						// rgb(255,0,0) rgba(255,0,0,0.5)
+
+						handleAlpha( color[ 4 ] );
+
+						return this.setRGB(
+							Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255,
+							Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255,
+							Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255,
+							colorSpace
+						);
+
+					}
+
+					if ( color = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec( components ) ) {
+
+						// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
+
+						handleAlpha( color[ 4 ] );
+
+						return this.setRGB(
+							Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100,
+							Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100,
+							Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100,
+							colorSpace
+						);
+
+					}
+
+					break;
+
+				case 'hsl':
+				case 'hsla':
+
+					if ( color = /^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec( components ) ) {
+
+						// hsl(120,50%,50%) hsla(120,50%,50%,0.5)
+
+						handleAlpha( color[ 4 ] );
+
+						return this.setHSL(
+							parseFloat( color[ 1 ] ) / 360,
+							parseFloat( color[ 2 ] ) / 100,
+							parseFloat( color[ 3 ] ) / 100,
+							colorSpace
+						);
+
+					}
+
+					break;
+
+				default:
+
+					console.warn( 'THREE.Color: Unknown color model ' + style );
+
+			}
+
+		} else if ( m = /^\#([A-Fa-f\d]+)$/.exec( style ) ) {
+
+			// hex color
+
+			const hex = m[ 1 ];
+			const size = hex.length;
+
+			if ( size === 3 ) {
+
+				// #ff0
+				return this.setRGB(
+					parseInt( hex.charAt( 0 ), 16 ) / 15,
+					parseInt( hex.charAt( 1 ), 16 ) / 15,
+					parseInt( hex.charAt( 2 ), 16 ) / 15,
+					colorSpace
+				);
+
+			} else if ( size === 6 ) {
+
+				// #ff0000
+				return this.setHex( parseInt( hex, 16 ), colorSpace );
+
+			} else {
+
+				console.warn( 'THREE.Color: Invalid hex color ' + style );
+
+			}
+
+		} else if ( style && style.length > 0 ) {
+
+			return this.setColorName( style, colorSpace );
+
+		}
+
+		return this;
+
+	}
+
+	setColorName( style, colorSpace = SRGBColorSpace ) {
+
+		// color keywords
+		const hex = _colorKeywords[ style.toLowerCase() ];
+
+		if ( hex !== undefined ) {
+
+			// red
+			this.setHex( hex, colorSpace );
+
+		} else {
+
+			// unknown color
+			console.warn( 'THREE.Color: Unknown color ' + style );
+
+		}
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor( this.r, this.g, this.b );
+
+	}
+
+	copy( color ) {
+
+		this.r = color.r;
+		this.g = color.g;
+		this.b = color.b;
+
+		return this;
+
+	}
+
+	copySRGBToLinear( color ) {
+
+		this.r = SRGBToLinear( color.r );
+		this.g = SRGBToLinear( color.g );
+		this.b = SRGBToLinear( color.b );
+
+		return this;
+
+	}
+
+	copyLinearToSRGB( color ) {
+
+		this.r = LinearToSRGB( color.r );
+		this.g = LinearToSRGB( color.g );
+		this.b = LinearToSRGB( color.b );
+
+		return this;
+
+	}
+
+	convertSRGBToLinear() {
+
+		this.copySRGBToLinear( this );
+
+		return this;
+
+	}
+
+	convertLinearToSRGB() {
+
+		this.copyLinearToSRGB( this );
+
+		return this;
+
+	}
+
+	getHex( colorSpace = SRGBColorSpace ) {
+
+		ColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );
+
+		return Math.round( clamp( _color.r * 255, 0, 255 ) ) * 65536 + Math.round( clamp( _color.g * 255, 0, 255 ) ) * 256 + Math.round( clamp( _color.b * 255, 0, 255 ) );
+
+	}
+
+	getHexString( colorSpace = SRGBColorSpace ) {
+
+		return ( '000000' + this.getHex( colorSpace ).toString( 16 ) ).slice( - 6 );
+
+	}
+
+	getHSL( target, colorSpace = ColorManagement.workingColorSpace ) {
+
+		// h,s,l ranges are in 0.0 - 1.0
+
+		ColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );
+
+		const r = _color.r, g = _color.g, b = _color.b;
+
+		const max = Math.max( r, g, b );
+		const min = Math.min( r, g, b );
+
+		let hue, saturation;
+		const lightness = ( min + max ) / 2.0;
+
+		if ( min === max ) {
+
+			hue = 0;
+			saturation = 0;
+
+		} else {
+
+			const delta = max - min;
+
+			saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );
+
+			switch ( max ) {
+
+				case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;
+				case g: hue = ( b - r ) / delta + 2; break;
+				case b: hue = ( r - g ) / delta + 4; break;
+
+			}
+
+			hue /= 6;
+
+		}
+
+		target.h = hue;
+		target.s = saturation;
+		target.l = lightness;
+
+		return target;
+
+	}
+
+	getRGB( target, colorSpace = ColorManagement.workingColorSpace ) {
+
+		ColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );
+
+		target.r = _color.r;
+		target.g = _color.g;
+		target.b = _color.b;
+
+		return target;
+
+	}
+
+	getStyle( colorSpace = SRGBColorSpace ) {
+
+		ColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );
+
+		const r = _color.r, g = _color.g, b = _color.b;
+
+		if ( colorSpace !== SRGBColorSpace ) {
+
+			// Requires CSS Color Module Level 4 (https://www.w3.org/TR/css-color-4/).
+			return `color(${ colorSpace } ${ r.toFixed( 3 ) } ${ g.toFixed( 3 ) } ${ b.toFixed( 3 ) })`;
+
+		}
+
+		return `rgb(${ Math.round( r * 255 ) },${ Math.round( g * 255 ) },${ Math.round( b * 255 ) })`;
+
+	}
+
+	offsetHSL( h, s, l ) {
+
+		this.getHSL( _hslA );
+
+		return this.setHSL( _hslA.h + h, _hslA.s + s, _hslA.l + l );
+
+	}
+
+	add( color ) {
+
+		this.r += color.r;
+		this.g += color.g;
+		this.b += color.b;
+
+		return this;
+
+	}
+
+	addColors( color1, color2 ) {
+
+		this.r = color1.r + color2.r;
+		this.g = color1.g + color2.g;
+		this.b = color1.b + color2.b;
+
+		return this;
+
+	}
+
+	addScalar( s ) {
+
+		this.r += s;
+		this.g += s;
+		this.b += s;
+
+		return this;
+
+	}
+
+	sub( color ) {
+
+		this.r = Math.max( 0, this.r - color.r );
+		this.g = Math.max( 0, this.g - color.g );
+		this.b = Math.max( 0, this.b - color.b );
+
+		return this;
+
+	}
+
+	multiply( color ) {
+
+		this.r *= color.r;
+		this.g *= color.g;
+		this.b *= color.b;
+
+		return this;
+
+	}
+
+	multiplyScalar( s ) {
+
+		this.r *= s;
+		this.g *= s;
+		this.b *= s;
+
+		return this;
+
+	}
+
+	lerp( color, alpha ) {
+
+		this.r += ( color.r - this.r ) * alpha;
+		this.g += ( color.g - this.g ) * alpha;
+		this.b += ( color.b - this.b ) * alpha;
+
+		return this;
+
+	}
+
+	lerpColors( color1, color2, alpha ) {
+
+		this.r = color1.r + ( color2.r - color1.r ) * alpha;
+		this.g = color1.g + ( color2.g - color1.g ) * alpha;
+		this.b = color1.b + ( color2.b - color1.b ) * alpha;
+
+		return this;
+
+	}
+
+	lerpHSL( color, alpha ) {
+
+		this.getHSL( _hslA );
+		color.getHSL( _hslB );
+
+		const h = lerp( _hslA.h, _hslB.h, alpha );
+		const s = lerp( _hslA.s, _hslB.s, alpha );
+		const l = lerp( _hslA.l, _hslB.l, alpha );
+
+		this.setHSL( h, s, l );
+
+		return this;
+
+	}
+
+	setFromVector3( v ) {
+
+		this.r = v.x;
+		this.g = v.y;
+		this.b = v.z;
+
+		return this;
+
+	}
+
+	applyMatrix3( m ) {
+
+		const r = this.r, g = this.g, b = this.b;
+		const e = m.elements;
+
+		this.r = e[ 0 ] * r + e[ 3 ] * g + e[ 6 ] * b;
+		this.g = e[ 1 ] * r + e[ 4 ] * g + e[ 7 ] * b;
+		this.b = e[ 2 ] * r + e[ 5 ] * g + e[ 8 ] * b;
+
+		return this;
+
+	}
+
+	equals( c ) {
+
+		return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		this.r = array[ offset ];
+		this.g = array[ offset + 1 ];
+		this.b = array[ offset + 2 ];
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this.r;
+		array[ offset + 1 ] = this.g;
+		array[ offset + 2 ] = this.b;
+
+		return array;
+
+	}
+
+	fromBufferAttribute( attribute, index ) {
+
+		this.r = attribute.getX( index );
+		this.g = attribute.getY( index );
+		this.b = attribute.getZ( index );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		return this.getHex();
+
+	}
+
+	*[ Symbol.iterator ]() {
+
+		yield this.r;
+		yield this.g;
+		yield this.b;
+
+	}
+
+}
+
+const _color = /*@__PURE__*/ new Color();
+
+Color.NAMES = _colorKeywords;
+
+let _materialId = 0;
+
+class Material extends EventDispatcher {
+
+	constructor() {
+
+		super();
+
+		this.isMaterial = true;
+
+		Object.defineProperty( this, 'id', { value: _materialId ++ } );
+
+		this.uuid = generateUUID();
+
+		this.name = '';
+		this.type = 'Material';
+
+		this.blending = NormalBlending;
+		this.side = FrontSide;
+		this.vertexColors = false;
+
+		this.opacity = 1;
+		this.transparent = false;
+		this.alphaHash = false;
+
+		this.blendSrc = SrcAlphaFactor;
+		this.blendDst = OneMinusSrcAlphaFactor;
+		this.blendEquation = AddEquation;
+		this.blendSrcAlpha = null;
+		this.blendDstAlpha = null;
+		this.blendEquationAlpha = null;
+		this.blendColor = new Color( 0, 0, 0 );
+		this.blendAlpha = 0;
+
+		this.depthFunc = LessEqualDepth;
+		this.depthTest = true;
+		this.depthWrite = true;
+
+		this.stencilWriteMask = 0xff;
+		this.stencilFunc = AlwaysStencilFunc;
+		this.stencilRef = 0;
+		this.stencilFuncMask = 0xff;
+		this.stencilFail = KeepStencilOp;
+		this.stencilZFail = KeepStencilOp;
+		this.stencilZPass = KeepStencilOp;
+		this.stencilWrite = false;
+
+		this.clippingPlanes = null;
+		this.clipIntersection = false;
+		this.clipShadows = false;
+
+		this.shadowSide = null;
+
+		this.colorWrite = true;
+
+		this.precision = null; // override the renderer's default precision for this material
+
+		this.polygonOffset = false;
+		this.polygonOffsetFactor = 0;
+		this.polygonOffsetUnits = 0;
+
+		this.dithering = false;
+
+		this.alphaToCoverage = false;
+		this.premultipliedAlpha = false;
+		this.forceSinglePass = false;
+
+		this.visible = true;
+
+		this.toneMapped = true;
+
+		this.userData = {};
+
+		this.version = 0;
+
+		this._alphaTest = 0;
+
+	}
+
+	get alphaTest() {
+
+		return this._alphaTest;
+
+	}
+
+	set alphaTest( value ) {
+
+		if ( this._alphaTest > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._alphaTest = value;
+
+	}
+
+	onBuild( /* shaderobject, renderer */ ) {}
+
+	onBeforeRender( /* renderer, scene, camera, geometry, object, group */ ) {}
+
+	onBeforeCompile( /* shaderobject, renderer */ ) {}
+
+	customProgramCacheKey() {
+
+		return this.onBeforeCompile.toString();
+
+	}
+
+	setValues( values ) {
+
+		if ( values === undefined ) return;
+
+		for ( const key in values ) {
+
+			const newValue = values[ key ];
+
+			if ( newValue === undefined ) {
+
+				console.warn( `THREE.Material: parameter '${ key }' has value of undefined.` );
+				continue;
+
+			}
+
+			const currentValue = this[ key ];
+
+			if ( currentValue === undefined ) {
+
+				console.warn( `THREE.Material: '${ key }' is not a property of THREE.${ this.type }.` );
+				continue;
+
+			}
+
+			if ( currentValue && currentValue.isColor ) {
+
+				currentValue.set( newValue );
+
+			} else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) {
+
+				currentValue.copy( newValue );
+
+			} else {
+
+				this[ key ] = newValue;
+
+			}
+
+		}
+
+	}
+
+	toJSON( meta ) {
+
+		const isRootObject = ( meta === undefined || typeof meta === 'string' );
+
+		if ( isRootObject ) {
+
+			meta = {
+				textures: {},
+				images: {}
+			};
+
+		}
+
+		const data = {
+			metadata: {
+				version: 4.6,
+				type: 'Material',
+				generator: 'Material.toJSON'
+			}
+		};
+
+		// standard Material serialization
+		data.uuid = this.uuid;
+		data.type = this.type;
+
+		if ( this.name !== '' ) data.name = this.name;
+
+		if ( this.color && this.color.isColor ) data.color = this.color.getHex();
+
+		if ( this.roughness !== undefined ) data.roughness = this.roughness;
+		if ( this.metalness !== undefined ) data.metalness = this.metalness;
+
+		if ( this.sheen !== undefined ) data.sheen = this.sheen;
+		if ( this.sheenColor && this.sheenColor.isColor ) data.sheenColor = this.sheenColor.getHex();
+		if ( this.sheenRoughness !== undefined ) data.sheenRoughness = this.sheenRoughness;
+		if ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex();
+		if ( this.emissiveIntensity && this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity;
+
+		if ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex();
+		if ( this.specularIntensity !== undefined ) data.specularIntensity = this.specularIntensity;
+		if ( this.specularColor && this.specularColor.isColor ) data.specularColor = this.specularColor.getHex();
+		if ( this.shininess !== undefined ) data.shininess = this.shininess;
+		if ( this.clearcoat !== undefined ) data.clearcoat = this.clearcoat;
+		if ( this.clearcoatRoughness !== undefined ) data.clearcoatRoughness = this.clearcoatRoughness;
+
+		if ( this.clearcoatMap && this.clearcoatMap.isTexture ) {
+
+			data.clearcoatMap = this.clearcoatMap.toJSON( meta ).uuid;
+
+		}
+
+		if ( this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture ) {
+
+			data.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON( meta ).uuid;
+
+		}
+
+		if ( this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture ) {
+
+			data.clearcoatNormalMap = this.clearcoatNormalMap.toJSON( meta ).uuid;
+			data.clearcoatNormalScale = this.clearcoatNormalScale.toArray();
+
+		}
+
+		if ( this.iridescence !== undefined ) data.iridescence = this.iridescence;
+		if ( this.iridescenceIOR !== undefined ) data.iridescenceIOR = this.iridescenceIOR;
+		if ( this.iridescenceThicknessRange !== undefined ) data.iridescenceThicknessRange = this.iridescenceThicknessRange;
+
+		if ( this.iridescenceMap && this.iridescenceMap.isTexture ) {
+
+			data.iridescenceMap = this.iridescenceMap.toJSON( meta ).uuid;
+
+		}
+
+		if ( this.iridescenceThicknessMap && this.iridescenceThicknessMap.isTexture ) {
+
+			data.iridescenceThicknessMap = this.iridescenceThicknessMap.toJSON( meta ).uuid;
+
+		}
+
+		if ( this.anisotropy !== undefined ) data.anisotropy = this.anisotropy;
+		if ( this.anisotropyRotation !== undefined ) data.anisotropyRotation = this.anisotropyRotation;
+
+		if ( this.anisotropyMap && this.anisotropyMap.isTexture ) {
+
+			data.anisotropyMap = this.anisotropyMap.toJSON( meta ).uuid;
+
+		}
+
+		if ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;
+		if ( this.matcap && this.matcap.isTexture ) data.matcap = this.matcap.toJSON( meta ).uuid;
+		if ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;
+
+		if ( this.lightMap && this.lightMap.isTexture ) {
+
+			data.lightMap = this.lightMap.toJSON( meta ).uuid;
+			data.lightMapIntensity = this.lightMapIntensity;
+
+		}
+
+		if ( this.aoMap && this.aoMap.isTexture ) {
+
+			data.aoMap = this.aoMap.toJSON( meta ).uuid;
+			data.aoMapIntensity = this.aoMapIntensity;
+
+		}
+
+		if ( this.bumpMap && this.bumpMap.isTexture ) {
+
+			data.bumpMap = this.bumpMap.toJSON( meta ).uuid;
+			data.bumpScale = this.bumpScale;
+
+		}
+
+		if ( this.normalMap && this.normalMap.isTexture ) {
+
+			data.normalMap = this.normalMap.toJSON( meta ).uuid;
+			data.normalMapType = this.normalMapType;
+			data.normalScale = this.normalScale.toArray();
+
+		}
+
+		if ( this.displacementMap && this.displacementMap.isTexture ) {
+
+			data.displacementMap = this.displacementMap.toJSON( meta ).uuid;
+			data.displacementScale = this.displacementScale;
+			data.displacementBias = this.displacementBias;
+
+		}
+
+		if ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;
+		if ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;
+
+		if ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;
+		if ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;
+		if ( this.specularIntensityMap && this.specularIntensityMap.isTexture ) data.specularIntensityMap = this.specularIntensityMap.toJSON( meta ).uuid;
+		if ( this.specularColorMap && this.specularColorMap.isTexture ) data.specularColorMap = this.specularColorMap.toJSON( meta ).uuid;
+
+		if ( this.envMap && this.envMap.isTexture ) {
+
+			data.envMap = this.envMap.toJSON( meta ).uuid;
+
+			if ( this.combine !== undefined ) data.combine = this.combine;
+
+		}
+
+		if ( this.envMapIntensity !== undefined ) data.envMapIntensity = this.envMapIntensity;
+		if ( this.reflectivity !== undefined ) data.reflectivity = this.reflectivity;
+		if ( this.refractionRatio !== undefined ) data.refractionRatio = this.refractionRatio;
+
+		if ( this.gradientMap && this.gradientMap.isTexture ) {
+
+			data.gradientMap = this.gradientMap.toJSON( meta ).uuid;
+
+		}
+
+		if ( this.transmission !== undefined ) data.transmission = this.transmission;
+		if ( this.transmissionMap && this.transmissionMap.isTexture ) data.transmissionMap = this.transmissionMap.toJSON( meta ).uuid;
+		if ( this.thickness !== undefined ) data.thickness = this.thickness;
+		if ( this.thicknessMap && this.thicknessMap.isTexture ) data.thicknessMap = this.thicknessMap.toJSON( meta ).uuid;
+		if ( this.attenuationDistance !== undefined && this.attenuationDistance !== Infinity ) data.attenuationDistance = this.attenuationDistance;
+		if ( this.attenuationColor !== undefined ) data.attenuationColor = this.attenuationColor.getHex();
+
+		if ( this.size !== undefined ) data.size = this.size;
+		if ( this.shadowSide !== null ) data.shadowSide = this.shadowSide;
+		if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;
+
+		if ( this.blending !== NormalBlending ) data.blending = this.blending;
+		if ( this.side !== FrontSide ) data.side = this.side;
+		if ( this.vertexColors === true ) data.vertexColors = true;
+
+		if ( this.opacity < 1 ) data.opacity = this.opacity;
+		if ( this.transparent === true ) data.transparent = true;
+
+		if ( this.blendSrc !== SrcAlphaFactor ) data.blendSrc = this.blendSrc;
+		if ( this.blendDst !== OneMinusSrcAlphaFactor ) data.blendDst = this.blendDst;
+		if ( this.blendEquation !== AddEquation ) data.blendEquation = this.blendEquation;
+		if ( this.blendSrcAlpha !== null ) data.blendSrcAlpha = this.blendSrcAlpha;
+		if ( this.blendDstAlpha !== null ) data.blendDstAlpha = this.blendDstAlpha;
+		if ( this.blendEquationAlpha !== null ) data.blendEquationAlpha = this.blendEquationAlpha;
+		if ( this.blendColor && this.blendColor.isColor ) data.blendColor = this.blendColor.getHex();
+		if ( this.blendAlpha !== 0 ) data.blendAlpha = this.blendAlpha;
+
+		if ( this.depthFunc !== LessEqualDepth ) data.depthFunc = this.depthFunc;
+		if ( this.depthTest === false ) data.depthTest = this.depthTest;
+		if ( this.depthWrite === false ) data.depthWrite = this.depthWrite;
+		if ( this.colorWrite === false ) data.colorWrite = this.colorWrite;
+
+		if ( this.stencilWriteMask !== 0xff ) data.stencilWriteMask = this.stencilWriteMask;
+		if ( this.stencilFunc !== AlwaysStencilFunc ) data.stencilFunc = this.stencilFunc;
+		if ( this.stencilRef !== 0 ) data.stencilRef = this.stencilRef;
+		if ( this.stencilFuncMask !== 0xff ) data.stencilFuncMask = this.stencilFuncMask;
+		if ( this.stencilFail !== KeepStencilOp ) data.stencilFail = this.stencilFail;
+		if ( this.stencilZFail !== KeepStencilOp ) data.stencilZFail = this.stencilZFail;
+		if ( this.stencilZPass !== KeepStencilOp ) data.stencilZPass = this.stencilZPass;
+		if ( this.stencilWrite === true ) data.stencilWrite = this.stencilWrite;
+
+		// rotation (SpriteMaterial)
+		if ( this.rotation !== undefined && this.rotation !== 0 ) data.rotation = this.rotation;
+
+		if ( this.polygonOffset === true ) data.polygonOffset = true;
+		if ( this.polygonOffsetFactor !== 0 ) data.polygonOffsetFactor = this.polygonOffsetFactor;
+		if ( this.polygonOffsetUnits !== 0 ) data.polygonOffsetUnits = this.polygonOffsetUnits;
+
+		if ( this.linewidth !== undefined && this.linewidth !== 1 ) data.linewidth = this.linewidth;
+		if ( this.dashSize !== undefined ) data.dashSize = this.dashSize;
+		if ( this.gapSize !== undefined ) data.gapSize = this.gapSize;
+		if ( this.scale !== undefined ) data.scale = this.scale;
+
+		if ( this.dithering === true ) data.dithering = true;
+
+		if ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest;
+		if ( this.alphaHash === true ) data.alphaHash = true;
+		if ( this.alphaToCoverage === true ) data.alphaToCoverage = true;
+		if ( this.premultipliedAlpha === true ) data.premultipliedAlpha = true;
+		if ( this.forceSinglePass === true ) data.forceSinglePass = true;
+
+		if ( this.wireframe === true ) data.wireframe = true;
+		if ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth;
+		if ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap;
+		if ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin;
+
+		if ( this.flatShading === true ) data.flatShading = true;
+
+		if ( this.visible === false ) data.visible = false;
+
+		if ( this.toneMapped === false ) data.toneMapped = false;
+
+		if ( this.fog === false ) data.fog = false;
+
+		if ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;
+
+		// TODO: Copied from Object3D.toJSON
+
+		function extractFromCache( cache ) {
+
+			const values = [];
+
+			for ( const key in cache ) {
+
+				const data = cache[ key ];
+				delete data.metadata;
+				values.push( data );
+
+			}
+
+			return values;
+
+		}
+
+		if ( isRootObject ) {
+
+			const textures = extractFromCache( meta.textures );
+			const images = extractFromCache( meta.images );
+
+			if ( textures.length > 0 ) data.textures = textures;
+			if ( images.length > 0 ) data.images = images;
+
+		}
+
+		return data;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( source ) {
+
+		this.name = source.name;
+
+		this.blending = source.blending;
+		this.side = source.side;
+		this.vertexColors = source.vertexColors;
+
+		this.opacity = source.opacity;
+		this.transparent = source.transparent;
+
+		this.blendSrc = source.blendSrc;
+		this.blendDst = source.blendDst;
+		this.blendEquation = source.blendEquation;
+		this.blendSrcAlpha = source.blendSrcAlpha;
+		this.blendDstAlpha = source.blendDstAlpha;
+		this.blendEquationAlpha = source.blendEquationAlpha;
+		this.blendColor.copy( source.blendColor );
+		this.blendAlpha = source.blendAlpha;
+
+		this.depthFunc = source.depthFunc;
+		this.depthTest = source.depthTest;
+		this.depthWrite = source.depthWrite;
+
+		this.stencilWriteMask = source.stencilWriteMask;
+		this.stencilFunc = source.stencilFunc;
+		this.stencilRef = source.stencilRef;
+		this.stencilFuncMask = source.stencilFuncMask;
+		this.stencilFail = source.stencilFail;
+		this.stencilZFail = source.stencilZFail;
+		this.stencilZPass = source.stencilZPass;
+		this.stencilWrite = source.stencilWrite;
+
+		const srcPlanes = source.clippingPlanes;
+		let dstPlanes = null;
+
+		if ( srcPlanes !== null ) {
+
+			const n = srcPlanes.length;
+			dstPlanes = new Array( n );
+
+			for ( let i = 0; i !== n; ++ i ) {
+
+				dstPlanes[ i ] = srcPlanes[ i ].clone();
+
+			}
+
+		}
+
+		this.clippingPlanes = dstPlanes;
+		this.clipIntersection = source.clipIntersection;
+		this.clipShadows = source.clipShadows;
+
+		this.shadowSide = source.shadowSide;
+
+		this.colorWrite = source.colorWrite;
+
+		this.precision = source.precision;
+
+		this.polygonOffset = source.polygonOffset;
+		this.polygonOffsetFactor = source.polygonOffsetFactor;
+		this.polygonOffsetUnits = source.polygonOffsetUnits;
+
+		this.dithering = source.dithering;
+
+		this.alphaTest = source.alphaTest;
+		this.alphaHash = source.alphaHash;
+		this.alphaToCoverage = source.alphaToCoverage;
+		this.premultipliedAlpha = source.premultipliedAlpha;
+		this.forceSinglePass = source.forceSinglePass;
+
+		this.visible = source.visible;
+
+		this.toneMapped = source.toneMapped;
+
+		this.userData = JSON.parse( JSON.stringify( source.userData ) );
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+}
+
+class MeshBasicMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshBasicMaterial = true;
+
+		this.type = 'MeshBasicMaterial';
+
+		this.color = new Color( 0xffffff ); // emissive
+
+		this.map = null;
+
+		this.lightMap = null;
+		this.lightMapIntensity = 1.0;
+
+		this.aoMap = null;
+		this.aoMapIntensity = 1.0;
+
+		this.specularMap = null;
+
+		this.alphaMap = null;
+
+		this.envMap = null;
+		this.combine = MultiplyOperation;
+		this.reflectivity = 1;
+		this.refractionRatio = 0.98;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+		this.wireframeLinecap = 'round';
+		this.wireframeLinejoin = 'round';
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+
+		this.lightMap = source.lightMap;
+		this.lightMapIntensity = source.lightMapIntensity;
+
+		this.aoMap = source.aoMap;
+		this.aoMapIntensity = source.aoMapIntensity;
+
+		this.specularMap = source.specularMap;
+
+		this.alphaMap = source.alphaMap;
+
+		this.envMap = source.envMap;
+		this.combine = source.combine;
+		this.reflectivity = source.reflectivity;
+		this.refractionRatio = source.refractionRatio;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+		this.wireframeLinecap = source.wireframeLinecap;
+		this.wireframeLinejoin = source.wireframeLinejoin;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+
+const _tables = /*@__PURE__*/ _generateTables();
+
+function _generateTables() {
+
+	// float32 to float16 helpers
+
+	const buffer = new ArrayBuffer( 4 );
+	const floatView = new Float32Array( buffer );
+	const uint32View = new Uint32Array( buffer );
+
+	const baseTable = new Uint32Array( 512 );
+	const shiftTable = new Uint32Array( 512 );
+
+	for ( let i = 0; i < 256; ++ i ) {
+
+		const e = i - 127;
+
+		// very small number (0, -0)
+
+		if ( e < - 27 ) {
+
+			baseTable[ i ] = 0x0000;
+			baseTable[ i | 0x100 ] = 0x8000;
+			shiftTable[ i ] = 24;
+			shiftTable[ i | 0x100 ] = 24;
+
+			// small number (denorm)
+
+		} else if ( e < - 14 ) {
+
+			baseTable[ i ] = 0x0400 >> ( - e - 14 );
+			baseTable[ i | 0x100 ] = ( 0x0400 >> ( - e - 14 ) ) | 0x8000;
+			shiftTable[ i ] = - e - 1;
+			shiftTable[ i | 0x100 ] = - e - 1;
+
+			// normal number
+
+		} else if ( e <= 15 ) {
+
+			baseTable[ i ] = ( e + 15 ) << 10;
+			baseTable[ i | 0x100 ] = ( ( e + 15 ) << 10 ) | 0x8000;
+			shiftTable[ i ] = 13;
+			shiftTable[ i | 0x100 ] = 13;
+
+			// large number (Infinity, -Infinity)
+
+		} else if ( e < 128 ) {
+
+			baseTable[ i ] = 0x7c00;
+			baseTable[ i | 0x100 ] = 0xfc00;
+			shiftTable[ i ] = 24;
+			shiftTable[ i | 0x100 ] = 24;
+
+			// stay (NaN, Infinity, -Infinity)
+
+		} else {
+
+			baseTable[ i ] = 0x7c00;
+			baseTable[ i | 0x100 ] = 0xfc00;
+			shiftTable[ i ] = 13;
+			shiftTable[ i | 0x100 ] = 13;
+
+		}
+
+	}
+
+	// float16 to float32 helpers
+
+	const mantissaTable = new Uint32Array( 2048 );
+	const exponentTable = new Uint32Array( 64 );
+	const offsetTable = new Uint32Array( 64 );
+
+	for ( let i = 1; i < 1024; ++ i ) {
+
+		let m = i << 13; // zero pad mantissa bits
+		let e = 0; // zero exponent
+
+		// normalized
+		while ( ( m & 0x00800000 ) === 0 ) {
+
+			m <<= 1;
+			e -= 0x00800000; // decrement exponent
+
+		}
+
+		m &= ~ 0x00800000; // clear leading 1 bit
+		e += 0x38800000; // adjust bias
+
+		mantissaTable[ i ] = m | e;
+
+	}
+
+	for ( let i = 1024; i < 2048; ++ i ) {
+
+		mantissaTable[ i ] = 0x38000000 + ( ( i - 1024 ) << 13 );
+
+	}
+
+	for ( let i = 1; i < 31; ++ i ) {
+
+		exponentTable[ i ] = i << 23;
+
+	}
+
+	exponentTable[ 31 ] = 0x47800000;
+	exponentTable[ 32 ] = 0x80000000;
+
+	for ( let i = 33; i < 63; ++ i ) {
+
+		exponentTable[ i ] = 0x80000000 + ( ( i - 32 ) << 23 );
+
+	}
+
+	exponentTable[ 63 ] = 0xc7800000;
+
+	for ( let i = 1; i < 64; ++ i ) {
+
+		if ( i !== 32 ) {
+
+			offsetTable[ i ] = 1024;
+
+		}
+
+	}
+
+	return {
+		floatView: floatView,
+		uint32View: uint32View,
+		baseTable: baseTable,
+		shiftTable: shiftTable,
+		mantissaTable: mantissaTable,
+		exponentTable: exponentTable,
+		offsetTable: offsetTable
+	};
+
+}
+
+// float32 to float16
+
+function toHalfFloat( val ) {
+
+	if ( Math.abs( val ) > 65504 ) console.warn( 'THREE.DataUtils.toHalfFloat(): Value out of range.' );
+
+	val = clamp( val, - 65504, 65504 );
+
+	_tables.floatView[ 0 ] = val;
+	const f = _tables.uint32View[ 0 ];
+	const e = ( f >> 23 ) & 0x1ff;
+	return _tables.baseTable[ e ] + ( ( f & 0x007fffff ) >> _tables.shiftTable[ e ] );
+
+}
+
+// float16 to float32
+
+function fromHalfFloat( val ) {
+
+	const m = val >> 10;
+	_tables.uint32View[ 0 ] = _tables.mantissaTable[ _tables.offsetTable[ m ] + ( val & 0x3ff ) ] + _tables.exponentTable[ m ];
+	return _tables.floatView[ 0 ];
+
+}
+
+const DataUtils = {
+	toHalfFloat: toHalfFloat,
+	fromHalfFloat: fromHalfFloat,
+};
+
+const _vector$9 = /*@__PURE__*/ new Vector3();
+const _vector2$1 = /*@__PURE__*/ new Vector2();
+
+class BufferAttribute {
+
+	constructor( array, itemSize, normalized = false ) {
+
+		if ( Array.isArray( array ) ) {
+
+			throw new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );
+
+		}
+
+		this.isBufferAttribute = true;
+
+		this.name = '';
+
+		this.array = array;
+		this.itemSize = itemSize;
+		this.count = array !== undefined ? array.length / itemSize : 0;
+		this.normalized = normalized;
+
+		this.usage = StaticDrawUsage;
+		this._updateRange = { offset: 0, count: - 1 };
+		this.updateRanges = [];
+		this.gpuType = FloatType;
+
+		this.version = 0;
+
+	}
+
+	onUploadCallback() {}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+	get updateRange() {
+
+		console.warn( 'THREE.BufferAttribute: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159
+		return this._updateRange;
+
+	}
+
+	setUsage( value ) {
+
+		this.usage = value;
+
+		return this;
+
+	}
+
+	addUpdateRange( start, count ) {
+
+		this.updateRanges.push( { start, count } );
+
+	}
+
+	clearUpdateRanges() {
+
+		this.updateRanges.length = 0;
+
+	}
+
+	copy( source ) {
+
+		this.name = source.name;
+		this.array = new source.array.constructor( source.array );
+		this.itemSize = source.itemSize;
+		this.count = source.count;
+		this.normalized = source.normalized;
+
+		this.usage = source.usage;
+		this.gpuType = source.gpuType;
+
+		return this;
+
+	}
+
+	copyAt( index1, attribute, index2 ) {
+
+		index1 *= this.itemSize;
+		index2 *= attribute.itemSize;
+
+		for ( let i = 0, l = this.itemSize; i < l; i ++ ) {
+
+			this.array[ index1 + i ] = attribute.array[ index2 + i ];
+
+		}
+
+		return this;
+
+	}
+
+	copyArray( array ) {
+
+		this.array.set( array );
+
+		return this;
+
+	}
+
+	applyMatrix3( m ) {
+
+		if ( this.itemSize === 2 ) {
+
+			for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+				_vector2$1.fromBufferAttribute( this, i );
+				_vector2$1.applyMatrix3( m );
+
+				this.setXY( i, _vector2$1.x, _vector2$1.y );
+
+			}
+
+		} else if ( this.itemSize === 3 ) {
+
+			for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+				_vector$9.fromBufferAttribute( this, i );
+				_vector$9.applyMatrix3( m );
+
+				this.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );
+
+			}
+
+		}
+
+		return this;
+
+	}
+
+	applyMatrix4( m ) {
+
+		for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+			_vector$9.fromBufferAttribute( this, i );
+
+			_vector$9.applyMatrix4( m );
+
+			this.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );
+
+		}
+
+		return this;
+
+	}
+
+	applyNormalMatrix( m ) {
+
+		for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+			_vector$9.fromBufferAttribute( this, i );
+
+			_vector$9.applyNormalMatrix( m );
+
+			this.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );
+
+		}
+
+		return this;
+
+	}
+
+	transformDirection( m ) {
+
+		for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+			_vector$9.fromBufferAttribute( this, i );
+
+			_vector$9.transformDirection( m );
+
+			this.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );
+
+		}
+
+		return this;
+
+	}
+
+	set( value, offset = 0 ) {
+
+		// Matching BufferAttribute constructor, do not normalize the array.
+		this.array.set( value, offset );
+
+		return this;
+
+	}
+
+	getComponent( index, component ) {
+
+		let value = this.array[ index * this.itemSize + component ];
+
+		if ( this.normalized ) value = denormalize( value, this.array );
+
+		return value;
+
+	}
+
+	setComponent( index, component, value ) {
+
+		if ( this.normalized ) value = normalize( value, this.array );
+
+		this.array[ index * this.itemSize + component ] = value;
+
+		return this;
+
+	}
+
+	getX( index ) {
+
+		let x = this.array[ index * this.itemSize ];
+
+		if ( this.normalized ) x = denormalize( x, this.array );
+
+		return x;
+
+	}
+
+	setX( index, x ) {
+
+		if ( this.normalized ) x = normalize( x, this.array );
+
+		this.array[ index * this.itemSize ] = x;
+
+		return this;
+
+	}
+
+	getY( index ) {
+
+		let y = this.array[ index * this.itemSize + 1 ];
+
+		if ( this.normalized ) y = denormalize( y, this.array );
+
+		return y;
+
+	}
+
+	setY( index, y ) {
+
+		if ( this.normalized ) y = normalize( y, this.array );
+
+		this.array[ index * this.itemSize + 1 ] = y;
+
+		return this;
+
+	}
+
+	getZ( index ) {
+
+		let z = this.array[ index * this.itemSize + 2 ];
+
+		if ( this.normalized ) z = denormalize( z, this.array );
+
+		return z;
+
+	}
+
+	setZ( index, z ) {
+
+		if ( this.normalized ) z = normalize( z, this.array );
+
+		this.array[ index * this.itemSize + 2 ] = z;
+
+		return this;
+
+	}
+
+	getW( index ) {
+
+		let w = this.array[ index * this.itemSize + 3 ];
+
+		if ( this.normalized ) w = denormalize( w, this.array );
+
+		return w;
+
+	}
+
+	setW( index, w ) {
+
+		if ( this.normalized ) w = normalize( w, this.array );
+
+		this.array[ index * this.itemSize + 3 ] = w;
+
+		return this;
+
+	}
+
+	setXY( index, x, y ) {
+
+		index *= this.itemSize;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+
+		}
+
+		this.array[ index + 0 ] = x;
+		this.array[ index + 1 ] = y;
+
+		return this;
+
+	}
+
+	setXYZ( index, x, y, z ) {
+
+		index *= this.itemSize;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+			z = normalize( z, this.array );
+
+		}
+
+		this.array[ index + 0 ] = x;
+		this.array[ index + 1 ] = y;
+		this.array[ index + 2 ] = z;
+
+		return this;
+
+	}
+
+	setXYZW( index, x, y, z, w ) {
+
+		index *= this.itemSize;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+			z = normalize( z, this.array );
+			w = normalize( w, this.array );
+
+		}
+
+		this.array[ index + 0 ] = x;
+		this.array[ index + 1 ] = y;
+		this.array[ index + 2 ] = z;
+		this.array[ index + 3 ] = w;
+
+		return this;
+
+	}
+
+	onUpload( callback ) {
+
+		this.onUploadCallback = callback;
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor( this.array, this.itemSize ).copy( this );
+
+	}
+
+	toJSON() {
+
+		const data = {
+			itemSize: this.itemSize,
+			type: this.array.constructor.name,
+			array: Array.from( this.array ),
+			normalized: this.normalized
+		};
+
+		if ( this.name !== '' ) data.name = this.name;
+		if ( this.usage !== StaticDrawUsage ) data.usage = this.usage;
+
+		return data;
+
+	}
+
+}
+
+//
+
+class Int8BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Int8Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Uint8BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Uint8Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Uint8ClampedBufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Uint8ClampedArray( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Int16BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Int16Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Uint16BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Uint16Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Int32BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Int32Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Uint32BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Uint32Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Float16BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Uint16Array( array ), itemSize, normalized );
+
+		this.isFloat16BufferAttribute = true;
+
+	}
+
+	getX( index ) {
+
+		let x = fromHalfFloat( this.array[ index * this.itemSize ] );
+
+		if ( this.normalized ) x = denormalize( x, this.array );
+
+		return x;
+
+	}
+
+	setX( index, x ) {
+
+		if ( this.normalized ) x = normalize( x, this.array );
+
+		this.array[ index * this.itemSize ] = toHalfFloat( x );
+
+		return this;
+
+	}
+
+	getY( index ) {
+
+		let y = fromHalfFloat( this.array[ index * this.itemSize + 1 ] );
+
+		if ( this.normalized ) y = denormalize( y, this.array );
+
+		return y;
+
+	}
+
+	setY( index, y ) {
+
+		if ( this.normalized ) y = normalize( y, this.array );
+
+		this.array[ index * this.itemSize + 1 ] = toHalfFloat( y );
+
+		return this;
+
+	}
+
+	getZ( index ) {
+
+		let z = fromHalfFloat( this.array[ index * this.itemSize + 2 ] );
+
+		if ( this.normalized ) z = denormalize( z, this.array );
+
+		return z;
+
+	}
+
+	setZ( index, z ) {
+
+		if ( this.normalized ) z = normalize( z, this.array );
+
+		this.array[ index * this.itemSize + 2 ] = toHalfFloat( z );
+
+		return this;
+
+	}
+
+	getW( index ) {
+
+		let w = fromHalfFloat( this.array[ index * this.itemSize + 3 ] );
+
+		if ( this.normalized ) w = denormalize( w, this.array );
+
+		return w;
+
+	}
+
+	setW( index, w ) {
+
+		if ( this.normalized ) w = normalize( w, this.array );
+
+		this.array[ index * this.itemSize + 3 ] = toHalfFloat( w );
+
+		return this;
+
+	}
+
+	setXY( index, x, y ) {
+
+		index *= this.itemSize;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+
+		}
+
+		this.array[ index + 0 ] = toHalfFloat( x );
+		this.array[ index + 1 ] = toHalfFloat( y );
+
+		return this;
+
+	}
+
+	setXYZ( index, x, y, z ) {
+
+		index *= this.itemSize;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+			z = normalize( z, this.array );
+
+		}
+
+		this.array[ index + 0 ] = toHalfFloat( x );
+		this.array[ index + 1 ] = toHalfFloat( y );
+		this.array[ index + 2 ] = toHalfFloat( z );
+
+		return this;
+
+	}
+
+	setXYZW( index, x, y, z, w ) {
+
+		index *= this.itemSize;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+			z = normalize( z, this.array );
+			w = normalize( w, this.array );
+
+		}
+
+		this.array[ index + 0 ] = toHalfFloat( x );
+		this.array[ index + 1 ] = toHalfFloat( y );
+		this.array[ index + 2 ] = toHalfFloat( z );
+		this.array[ index + 3 ] = toHalfFloat( w );
+
+		return this;
+
+	}
+
+}
+
+
+class Float32BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Float32Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+class Float64BufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized ) {
+
+		super( new Float64Array( array ), itemSize, normalized );
+
+	}
+
+}
+
+let _id$2 = 0;
+
+const _m1 = /*@__PURE__*/ new Matrix4();
+const _obj = /*@__PURE__*/ new Object3D();
+const _offset = /*@__PURE__*/ new Vector3();
+const _box$2 = /*@__PURE__*/ new Box3();
+const _boxMorphTargets = /*@__PURE__*/ new Box3();
+const _vector$8 = /*@__PURE__*/ new Vector3();
+
+class BufferGeometry extends EventDispatcher {
+
+	constructor() {
+
+		super();
+
+		this.isBufferGeometry = true;
+
+		Object.defineProperty( this, 'id', { value: _id$2 ++ } );
+
+		this.uuid = generateUUID();
+
+		this.name = '';
+		this.type = 'BufferGeometry';
+
+		this.index = null;
+		this.attributes = {};
+
+		this.morphAttributes = {};
+		this.morphTargetsRelative = false;
+
+		this.groups = [];
+
+		this.boundingBox = null;
+		this.boundingSphere = null;
+
+		this.drawRange = { start: 0, count: Infinity };
+
+		this.userData = {};
+
+	}
+
+	getIndex() {
+
+		return this.index;
+
+	}
+
+	setIndex( index ) {
+
+		if ( Array.isArray( index ) ) {
+
+			this.index = new ( arrayNeedsUint32( index ) ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );
+
+		} else {
+
+			this.index = index;
+
+		}
+
+		return this;
+
+	}
+
+	getAttribute( name ) {
+
+		return this.attributes[ name ];
+
+	}
+
+	setAttribute( name, attribute ) {
+
+		this.attributes[ name ] = attribute;
+
+		return this;
+
+	}
+
+	deleteAttribute( name ) {
+
+		delete this.attributes[ name ];
+
+		return this;
+
+	}
+
+	hasAttribute( name ) {
+
+		return this.attributes[ name ] !== undefined;
+
+	}
+
+	addGroup( start, count, materialIndex = 0 ) {
+
+		this.groups.push( {
+
+			start: start,
+			count: count,
+			materialIndex: materialIndex
+
+		} );
+
+	}
+
+	clearGroups() {
+
+		this.groups = [];
+
+	}
+
+	setDrawRange( start, count ) {
+
+		this.drawRange.start = start;
+		this.drawRange.count = count;
+
+	}
+
+	applyMatrix4( matrix ) {
+
+		const position = this.attributes.position;
+
+		if ( position !== undefined ) {
+
+			position.applyMatrix4( matrix );
+
+			position.needsUpdate = true;
+
+		}
+
+		const normal = this.attributes.normal;
+
+		if ( normal !== undefined ) {
+
+			const normalMatrix = new Matrix3().getNormalMatrix( matrix );
+
+			normal.applyNormalMatrix( normalMatrix );
+
+			normal.needsUpdate = true;
+
+		}
+
+		const tangent = this.attributes.tangent;
+
+		if ( tangent !== undefined ) {
+
+			tangent.transformDirection( matrix );
+
+			tangent.needsUpdate = true;
+
+		}
+
+		if ( this.boundingBox !== null ) {
+
+			this.computeBoundingBox();
+
+		}
+
+		if ( this.boundingSphere !== null ) {
+
+			this.computeBoundingSphere();
+
+		}
+
+		return this;
+
+	}
+
+	applyQuaternion( q ) {
+
+		_m1.makeRotationFromQuaternion( q );
+
+		this.applyMatrix4( _m1 );
+
+		return this;
+
+	}
+
+	rotateX( angle ) {
+
+		// rotate geometry around world x-axis
+
+		_m1.makeRotationX( angle );
+
+		this.applyMatrix4( _m1 );
+
+		return this;
+
+	}
+
+	rotateY( angle ) {
+
+		// rotate geometry around world y-axis
+
+		_m1.makeRotationY( angle );
+
+		this.applyMatrix4( _m1 );
+
+		return this;
+
+	}
+
+	rotateZ( angle ) {
+
+		// rotate geometry around world z-axis
+
+		_m1.makeRotationZ( angle );
+
+		this.applyMatrix4( _m1 );
+
+		return this;
+
+	}
+
+	translate( x, y, z ) {
+
+		// translate geometry
+
+		_m1.makeTranslation( x, y, z );
+
+		this.applyMatrix4( _m1 );
+
+		return this;
+
+	}
+
+	scale( x, y, z ) {
+
+		// scale geometry
+
+		_m1.makeScale( x, y, z );
+
+		this.applyMatrix4( _m1 );
+
+		return this;
+
+	}
+
+	lookAt( vector ) {
+
+		_obj.lookAt( vector );
+
+		_obj.updateMatrix();
+
+		this.applyMatrix4( _obj.matrix );
+
+		return this;
+
+	}
+
+	center() {
+
+		this.computeBoundingBox();
+
+		this.boundingBox.getCenter( _offset ).negate();
+
+		this.translate( _offset.x, _offset.y, _offset.z );
+
+		return this;
+
+	}
+
+	setFromPoints( points ) {
+
+		const position = [];
+
+		for ( let i = 0, l = points.length; i < l; i ++ ) {
+
+			const point = points[ i ];
+			position.push( point.x, point.y, point.z || 0 );
+
+		}
+
+		this.setAttribute( 'position', new Float32BufferAttribute( position, 3 ) );
+
+		return this;
+
+	}
+
+	computeBoundingBox() {
+
+		if ( this.boundingBox === null ) {
+
+			this.boundingBox = new Box3();
+
+		}
+
+		const position = this.attributes.position;
+		const morphAttributesPosition = this.morphAttributes.position;
+
+		if ( position && position.isGLBufferAttribute ) {
+
+			console.error( 'THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".', this );
+
+			this.boundingBox.set(
+				new Vector3( - Infinity, - Infinity, - Infinity ),
+				new Vector3( + Infinity, + Infinity, + Infinity )
+			);
+
+			return;
+
+		}
+
+		if ( position !== undefined ) {
+
+			this.boundingBox.setFromBufferAttribute( position );
+
+			// process morph attributes if present
+
+			if ( morphAttributesPosition ) {
+
+				for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {
+
+					const morphAttribute = morphAttributesPosition[ i ];
+					_box$2.setFromBufferAttribute( morphAttribute );
+
+					if ( this.morphTargetsRelative ) {
+
+						_vector$8.addVectors( this.boundingBox.min, _box$2.min );
+						this.boundingBox.expandByPoint( _vector$8 );
+
+						_vector$8.addVectors( this.boundingBox.max, _box$2.max );
+						this.boundingBox.expandByPoint( _vector$8 );
+
+					} else {
+
+						this.boundingBox.expandByPoint( _box$2.min );
+						this.boundingBox.expandByPoint( _box$2.max );
+
+					}
+
+				}
+
+			}
+
+		} else {
+
+			this.boundingBox.makeEmpty();
+
+		}
+
+		if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {
+
+			console.error( 'THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this );
+
+		}
+
+	}
+
+	computeBoundingSphere() {
+
+		if ( this.boundingSphere === null ) {
+
+			this.boundingSphere = new Sphere();
+
+		}
+
+		const position = this.attributes.position;
+		const morphAttributesPosition = this.morphAttributes.position;
+
+		if ( position && position.isGLBufferAttribute ) {
+
+			console.error( 'THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".', this );
+
+			this.boundingSphere.set( new Vector3(), Infinity );
+
+			return;
+
+		}
+
+		if ( position ) {
+
+			// first, find the center of the bounding sphere
+
+			const center = this.boundingSphere.center;
+
+			_box$2.setFromBufferAttribute( position );
+
+			// process morph attributes if present
+
+			if ( morphAttributesPosition ) {
+
+				for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {
+
+					const morphAttribute = morphAttributesPosition[ i ];
+					_boxMorphTargets.setFromBufferAttribute( morphAttribute );
+
+					if ( this.morphTargetsRelative ) {
+
+						_vector$8.addVectors( _box$2.min, _boxMorphTargets.min );
+						_box$2.expandByPoint( _vector$8 );
+
+						_vector$8.addVectors( _box$2.max, _boxMorphTargets.max );
+						_box$2.expandByPoint( _vector$8 );
+
+					} else {
+
+						_box$2.expandByPoint( _boxMorphTargets.min );
+						_box$2.expandByPoint( _boxMorphTargets.max );
+
+					}
+
+				}
+
+			}
+
+			_box$2.getCenter( center );
+
+			// second, try to find a boundingSphere with a radius smaller than the
+			// boundingSphere of the boundingBox: sqrt(3) smaller in the best case
+
+			let maxRadiusSq = 0;
+
+			for ( let i = 0, il = position.count; i < il; i ++ ) {
+
+				_vector$8.fromBufferAttribute( position, i );
+
+				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector$8 ) );
+
+			}
+
+			// process morph attributes if present
+
+			if ( morphAttributesPosition ) {
+
+				for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {
+
+					const morphAttribute = morphAttributesPosition[ i ];
+					const morphTargetsRelative = this.morphTargetsRelative;
+
+					for ( let j = 0, jl = morphAttribute.count; j < jl; j ++ ) {
+
+						_vector$8.fromBufferAttribute( morphAttribute, j );
+
+						if ( morphTargetsRelative ) {
+
+							_offset.fromBufferAttribute( position, j );
+							_vector$8.add( _offset );
+
+						}
+
+						maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector$8 ) );
+
+					}
+
+				}
+
+			}
+
+			this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
+
+			if ( isNaN( this.boundingSphere.radius ) ) {
+
+				console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this );
+
+			}
+
+		}
+
+	}
+
+	computeTangents() {
+
+		const index = this.index;
+		const attributes = this.attributes;
+
+		// based on http://www.terathon.com/code/tangent.html
+		// (per vertex tangents)
+
+		if ( index === null ||
+			 attributes.position === undefined ||
+			 attributes.normal === undefined ||
+			 attributes.uv === undefined ) {
+
+			console.error( 'THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)' );
+			return;
+
+		}
+
+		const indices = index.array;
+		const positions = attributes.position.array;
+		const normals = attributes.normal.array;
+		const uvs = attributes.uv.array;
+
+		const nVertices = positions.length / 3;
+
+		if ( this.hasAttribute( 'tangent' ) === false ) {
+
+			this.setAttribute( 'tangent', new BufferAttribute( new Float32Array( 4 * nVertices ), 4 ) );
+
+		}
+
+		const tangents = this.getAttribute( 'tangent' ).array;
+
+		const tan1 = [], tan2 = [];
+
+		for ( let i = 0; i < nVertices; i ++ ) {
+
+			tan1[ i ] = new Vector3();
+			tan2[ i ] = new Vector3();
+
+		}
+
+		const vA = new Vector3(),
+			vB = new Vector3(),
+			vC = new Vector3(),
+
+			uvA = new Vector2(),
+			uvB = new Vector2(),
+			uvC = new Vector2(),
+
+			sdir = new Vector3(),
+			tdir = new Vector3();
+
+		function handleTriangle( a, b, c ) {
+
+			vA.fromArray( positions, a * 3 );
+			vB.fromArray( positions, b * 3 );
+			vC.fromArray( positions, c * 3 );
+
+			uvA.fromArray( uvs, a * 2 );
+			uvB.fromArray( uvs, b * 2 );
+			uvC.fromArray( uvs, c * 2 );
+
+			vB.sub( vA );
+			vC.sub( vA );
+
+			uvB.sub( uvA );
+			uvC.sub( uvA );
+
+			const r = 1.0 / ( uvB.x * uvC.y - uvC.x * uvB.y );
+
+			// silently ignore degenerate uv triangles having coincident or colinear vertices
+
+			if ( ! isFinite( r ) ) return;
+
+			sdir.copy( vB ).multiplyScalar( uvC.y ).addScaledVector( vC, - uvB.y ).multiplyScalar( r );
+			tdir.copy( vC ).multiplyScalar( uvB.x ).addScaledVector( vB, - uvC.x ).multiplyScalar( r );
+
+			tan1[ a ].add( sdir );
+			tan1[ b ].add( sdir );
+			tan1[ c ].add( sdir );
+
+			tan2[ a ].add( tdir );
+			tan2[ b ].add( tdir );
+			tan2[ c ].add( tdir );
+
+		}
+
+		let groups = this.groups;
+
+		if ( groups.length === 0 ) {
+
+			groups = [ {
+				start: 0,
+				count: indices.length
+			} ];
+
+		}
+
+		for ( let i = 0, il = groups.length; i < il; ++ i ) {
+
+			const group = groups[ i ];
+
+			const start = group.start;
+			const count = group.count;
+
+			for ( let j = start, jl = start + count; j < jl; j += 3 ) {
+
+				handleTriangle(
+					indices[ j + 0 ],
+					indices[ j + 1 ],
+					indices[ j + 2 ]
+				);
+
+			}
+
+		}
+
+		const tmp = new Vector3(), tmp2 = new Vector3();
+		const n = new Vector3(), n2 = new Vector3();
+
+		function handleVertex( v ) {
+
+			n.fromArray( normals, v * 3 );
+			n2.copy( n );
+
+			const t = tan1[ v ];
+
+			// Gram-Schmidt orthogonalize
+
+			tmp.copy( t );
+			tmp.sub( n.multiplyScalar( n.dot( t ) ) ).normalize();
+
+			// Calculate handedness
+
+			tmp2.crossVectors( n2, t );
+			const test = tmp2.dot( tan2[ v ] );
+			const w = ( test < 0.0 ) ? - 1.0 : 1.0;
+
+			tangents[ v * 4 ] = tmp.x;
+			tangents[ v * 4 + 1 ] = tmp.y;
+			tangents[ v * 4 + 2 ] = tmp.z;
+			tangents[ v * 4 + 3 ] = w;
+
+		}
+
+		for ( let i = 0, il = groups.length; i < il; ++ i ) {
+
+			const group = groups[ i ];
+
+			const start = group.start;
+			const count = group.count;
+
+			for ( let j = start, jl = start + count; j < jl; j += 3 ) {
+
+				handleVertex( indices[ j + 0 ] );
+				handleVertex( indices[ j + 1 ] );
+				handleVertex( indices[ j + 2 ] );
+
+			}
+
+		}
+
+	}
+
+	computeVertexNormals() {
+
+		const index = this.index;
+		const positionAttribute = this.getAttribute( 'position' );
+
+		if ( positionAttribute !== undefined ) {
+
+			let normalAttribute = this.getAttribute( 'normal' );
+
+			if ( normalAttribute === undefined ) {
+
+				normalAttribute = new BufferAttribute( new Float32Array( positionAttribute.count * 3 ), 3 );
+				this.setAttribute( 'normal', normalAttribute );
+
+			} else {
+
+				// reset existing normals to zero
+
+				for ( let i = 0, il = normalAttribute.count; i < il; i ++ ) {
+
+					normalAttribute.setXYZ( i, 0, 0, 0 );
+
+				}
+
+			}
+
+			const pA = new Vector3(), pB = new Vector3(), pC = new Vector3();
+			const nA = new Vector3(), nB = new Vector3(), nC = new Vector3();
+			const cb = new Vector3(), ab = new Vector3();
+
+			// indexed elements
+
+			if ( index ) {
+
+				for ( let i = 0, il = index.count; i < il; i += 3 ) {
+
+					const vA = index.getX( i + 0 );
+					const vB = index.getX( i + 1 );
+					const vC = index.getX( i + 2 );
+
+					pA.fromBufferAttribute( positionAttribute, vA );
+					pB.fromBufferAttribute( positionAttribute, vB );
+					pC.fromBufferAttribute( positionAttribute, vC );
+
+					cb.subVectors( pC, pB );
+					ab.subVectors( pA, pB );
+					cb.cross( ab );
+
+					nA.fromBufferAttribute( normalAttribute, vA );
+					nB.fromBufferAttribute( normalAttribute, vB );
+					nC.fromBufferAttribute( normalAttribute, vC );
+
+					nA.add( cb );
+					nB.add( cb );
+					nC.add( cb );
+
+					normalAttribute.setXYZ( vA, nA.x, nA.y, nA.z );
+					normalAttribute.setXYZ( vB, nB.x, nB.y, nB.z );
+					normalAttribute.setXYZ( vC, nC.x, nC.y, nC.z );
+
+				}
+
+			} else {
+
+				// non-indexed elements (unconnected triangle soup)
+
+				for ( let i = 0, il = positionAttribute.count; i < il; i += 3 ) {
+
+					pA.fromBufferAttribute( positionAttribute, i + 0 );
+					pB.fromBufferAttribute( positionAttribute, i + 1 );
+					pC.fromBufferAttribute( positionAttribute, i + 2 );
+
+					cb.subVectors( pC, pB );
+					ab.subVectors( pA, pB );
+					cb.cross( ab );
+
+					normalAttribute.setXYZ( i + 0, cb.x, cb.y, cb.z );
+					normalAttribute.setXYZ( i + 1, cb.x, cb.y, cb.z );
+					normalAttribute.setXYZ( i + 2, cb.x, cb.y, cb.z );
+
+				}
+
+			}
+
+			this.normalizeNormals();
+
+			normalAttribute.needsUpdate = true;
+
+		}
+
+	}
+
+	normalizeNormals() {
+
+		const normals = this.attributes.normal;
+
+		for ( let i = 0, il = normals.count; i < il; i ++ ) {
+
+			_vector$8.fromBufferAttribute( normals, i );
+
+			_vector$8.normalize();
+
+			normals.setXYZ( i, _vector$8.x, _vector$8.y, _vector$8.z );
+
+		}
+
+	}
+
+	toNonIndexed() {
+
+		function convertBufferAttribute( attribute, indices ) {
+
+			const array = attribute.array;
+			const itemSize = attribute.itemSize;
+			const normalized = attribute.normalized;
+
+			const array2 = new array.constructor( indices.length * itemSize );
+
+			let index = 0, index2 = 0;
+
+			for ( let i = 0, l = indices.length; i < l; i ++ ) {
+
+				if ( attribute.isInterleavedBufferAttribute ) {
+
+					index = indices[ i ] * attribute.data.stride + attribute.offset;
+
+				} else {
+
+					index = indices[ i ] * itemSize;
+
+				}
+
+				for ( let j = 0; j < itemSize; j ++ ) {
+
+					array2[ index2 ++ ] = array[ index ++ ];
+
+				}
+
+			}
+
+			return new BufferAttribute( array2, itemSize, normalized );
+
+		}
+
+		//
+
+		if ( this.index === null ) {
+
+			console.warn( 'THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed.' );
+			return this;
+
+		}
+
+		const geometry2 = new BufferGeometry();
+
+		const indices = this.index.array;
+		const attributes = this.attributes;
+
+		// attributes
+
+		for ( const name in attributes ) {
+
+			const attribute = attributes[ name ];
+
+			const newAttribute = convertBufferAttribute( attribute, indices );
+
+			geometry2.setAttribute( name, newAttribute );
+
+		}
+
+		// morph attributes
+
+		const morphAttributes = this.morphAttributes;
+
+		for ( const name in morphAttributes ) {
+
+			const morphArray = [];
+			const morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes
+
+			for ( let i = 0, il = morphAttribute.length; i < il; i ++ ) {
+
+				const attribute = morphAttribute[ i ];
+
+				const newAttribute = convertBufferAttribute( attribute, indices );
+
+				morphArray.push( newAttribute );
+
+			}
+
+			geometry2.morphAttributes[ name ] = morphArray;
+
+		}
+
+		geometry2.morphTargetsRelative = this.morphTargetsRelative;
+
+		// groups
+
+		const groups = this.groups;
+
+		for ( let i = 0, l = groups.length; i < l; i ++ ) {
+
+			const group = groups[ i ];
+			geometry2.addGroup( group.start, group.count, group.materialIndex );
+
+		}
+
+		return geometry2;
+
+	}
+
+	toJSON() {
+
+		const data = {
+			metadata: {
+				version: 4.6,
+				type: 'BufferGeometry',
+				generator: 'BufferGeometry.toJSON'
+			}
+		};
+
+		// standard BufferGeometry serialization
+
+		data.uuid = this.uuid;
+		data.type = this.type;
+		if ( this.name !== '' ) data.name = this.name;
+		if ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;
+
+		if ( this.parameters !== undefined ) {
+
+			const parameters = this.parameters;
+
+			for ( const key in parameters ) {
+
+				if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];
+
+			}
+
+			return data;
+
+		}
+
+		// for simplicity the code assumes attributes are not shared across geometries, see #15811
+
+		data.data = { attributes: {} };
+
+		const index = this.index;
+
+		if ( index !== null ) {
+
+			data.data.index = {
+				type: index.array.constructor.name,
+				array: Array.prototype.slice.call( index.array )
+			};
+
+		}
+
+		const attributes = this.attributes;
+
+		for ( const key in attributes ) {
+
+			const attribute = attributes[ key ];
+
+			data.data.attributes[ key ] = attribute.toJSON( data.data );
+
+		}
+
+		const morphAttributes = {};
+		let hasMorphAttributes = false;
+
+		for ( const key in this.morphAttributes ) {
+
+			const attributeArray = this.morphAttributes[ key ];
+
+			const array = [];
+
+			for ( let i = 0, il = attributeArray.length; i < il; i ++ ) {
+
+				const attribute = attributeArray[ i ];
+
+				array.push( attribute.toJSON( data.data ) );
+
+			}
+
+			if ( array.length > 0 ) {
+
+				morphAttributes[ key ] = array;
+
+				hasMorphAttributes = true;
+
+			}
+
+		}
+
+		if ( hasMorphAttributes ) {
+
+			data.data.morphAttributes = morphAttributes;
+			data.data.morphTargetsRelative = this.morphTargetsRelative;
+
+		}
+
+		const groups = this.groups;
+
+		if ( groups.length > 0 ) {
+
+			data.data.groups = JSON.parse( JSON.stringify( groups ) );
+
+		}
+
+		const boundingSphere = this.boundingSphere;
+
+		if ( boundingSphere !== null ) {
+
+			data.data.boundingSphere = {
+				center: boundingSphere.center.toArray(),
+				radius: boundingSphere.radius
+			};
+
+		}
+
+		return data;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( source ) {
+
+		// reset
+
+		this.index = null;
+		this.attributes = {};
+		this.morphAttributes = {};
+		this.groups = [];
+		this.boundingBox = null;
+		this.boundingSphere = null;
+
+		// used for storing cloned, shared data
+
+		const data = {};
+
+		// name
+
+		this.name = source.name;
+
+		// index
+
+		const index = source.index;
+
+		if ( index !== null ) {
+
+			this.setIndex( index.clone( data ) );
+
+		}
+
+		// attributes
+
+		const attributes = source.attributes;
+
+		for ( const name in attributes ) {
+
+			const attribute = attributes[ name ];
+			this.setAttribute( name, attribute.clone( data ) );
+
+		}
+
+		// morph attributes
+
+		const morphAttributes = source.morphAttributes;
+
+		for ( const name in morphAttributes ) {
+
+			const array = [];
+			const morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes
+
+			for ( let i = 0, l = morphAttribute.length; i < l; i ++ ) {
+
+				array.push( morphAttribute[ i ].clone( data ) );
+
+			}
+
+			this.morphAttributes[ name ] = array;
+
+		}
+
+		this.morphTargetsRelative = source.morphTargetsRelative;
+
+		// groups
+
+		const groups = source.groups;
+
+		for ( let i = 0, l = groups.length; i < l; i ++ ) {
+
+			const group = groups[ i ];
+			this.addGroup( group.start, group.count, group.materialIndex );
+
+		}
+
+		// bounding box
+
+		const boundingBox = source.boundingBox;
+
+		if ( boundingBox !== null ) {
+
+			this.boundingBox = boundingBox.clone();
+
+		}
+
+		// bounding sphere
+
+		const boundingSphere = source.boundingSphere;
+
+		if ( boundingSphere !== null ) {
+
+			this.boundingSphere = boundingSphere.clone();
+
+		}
+
+		// draw range
+
+		this.drawRange.start = source.drawRange.start;
+		this.drawRange.count = source.drawRange.count;
+
+		// user data
+
+		this.userData = source.userData;
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+}
+
+const _inverseMatrix$3 = /*@__PURE__*/ new Matrix4();
+const _ray$3 = /*@__PURE__*/ new Ray();
+const _sphere$6 = /*@__PURE__*/ new Sphere();
+const _sphereHitAt = /*@__PURE__*/ new Vector3();
+
+const _vA$1 = /*@__PURE__*/ new Vector3();
+const _vB$1 = /*@__PURE__*/ new Vector3();
+const _vC$1 = /*@__PURE__*/ new Vector3();
+
+const _tempA = /*@__PURE__*/ new Vector3();
+const _morphA = /*@__PURE__*/ new Vector3();
+
+const _uvA$1 = /*@__PURE__*/ new Vector2();
+const _uvB$1 = /*@__PURE__*/ new Vector2();
+const _uvC$1 = /*@__PURE__*/ new Vector2();
+
+const _normalA = /*@__PURE__*/ new Vector3();
+const _normalB = /*@__PURE__*/ new Vector3();
+const _normalC = /*@__PURE__*/ new Vector3();
+
+const _intersectionPoint = /*@__PURE__*/ new Vector3();
+const _intersectionPointWorld = /*@__PURE__*/ new Vector3();
+
+class Mesh extends Object3D {
+
+	constructor( geometry = new BufferGeometry(), material = new MeshBasicMaterial() ) {
+
+		super();
+
+		this.isMesh = true;
+
+		this.type = 'Mesh';
+
+		this.geometry = geometry;
+		this.material = material;
+
+		this.updateMorphTargets();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		if ( source.morphTargetInfluences !== undefined ) {
+
+			this.morphTargetInfluences = source.morphTargetInfluences.slice();
+
+		}
+
+		if ( source.morphTargetDictionary !== undefined ) {
+
+			this.morphTargetDictionary = Object.assign( {}, source.morphTargetDictionary );
+
+		}
+
+		this.material = Array.isArray( source.material ) ? source.material.slice() : source.material;
+		this.geometry = source.geometry;
+
+		return this;
+
+	}
+
+	updateMorphTargets() {
+
+		const geometry = this.geometry;
+
+		const morphAttributes = geometry.morphAttributes;
+		const keys = Object.keys( morphAttributes );
+
+		if ( keys.length > 0 ) {
+
+			const morphAttribute = morphAttributes[ keys[ 0 ] ];
+
+			if ( morphAttribute !== undefined ) {
+
+				this.morphTargetInfluences = [];
+				this.morphTargetDictionary = {};
+
+				for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {
+
+					const name = morphAttribute[ m ].name || String( m );
+
+					this.morphTargetInfluences.push( 0 );
+					this.morphTargetDictionary[ name ] = m;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	getVertexPosition( index, target ) {
+
+		const geometry = this.geometry;
+		const position = geometry.attributes.position;
+		const morphPosition = geometry.morphAttributes.position;
+		const morphTargetsRelative = geometry.morphTargetsRelative;
+
+		target.fromBufferAttribute( position, index );
+
+		const morphInfluences = this.morphTargetInfluences;
+
+		if ( morphPosition && morphInfluences ) {
+
+			_morphA.set( 0, 0, 0 );
+
+			for ( let i = 0, il = morphPosition.length; i < il; i ++ ) {
+
+				const influence = morphInfluences[ i ];
+				const morphAttribute = morphPosition[ i ];
+
+				if ( influence === 0 ) continue;
+
+				_tempA.fromBufferAttribute( morphAttribute, index );
+
+				if ( morphTargetsRelative ) {
+
+					_morphA.addScaledVector( _tempA, influence );
+
+				} else {
+
+					_morphA.addScaledVector( _tempA.sub( target ), influence );
+
+				}
+
+			}
+
+			target.add( _morphA );
+
+		}
+
+		return target;
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const geometry = this.geometry;
+		const material = this.material;
+		const matrixWorld = this.matrixWorld;
+
+		if ( material === undefined ) return;
+
+		// test with bounding sphere in world space
+
+		if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+
+		_sphere$6.copy( geometry.boundingSphere );
+		_sphere$6.applyMatrix4( matrixWorld );
+
+		// check distance from ray origin to bounding sphere
+
+		_ray$3.copy( raycaster.ray ).recast( raycaster.near );
+
+		if ( _sphere$6.containsPoint( _ray$3.origin ) === false ) {
+
+			if ( _ray$3.intersectSphere( _sphere$6, _sphereHitAt ) === null ) return;
+
+			if ( _ray$3.origin.distanceToSquared( _sphereHitAt ) > ( raycaster.far - raycaster.near ) ** 2 ) return;
+
+		}
+
+		// convert ray to local space of mesh
+
+		_inverseMatrix$3.copy( matrixWorld ).invert();
+		_ray$3.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$3 );
+
+		// test with bounding box in local space
+
+		if ( geometry.boundingBox !== null ) {
+
+			if ( _ray$3.intersectsBox( geometry.boundingBox ) === false ) return;
+
+		}
+
+		// test for intersections with geometry
+
+		this._computeIntersections( raycaster, intersects, _ray$3 );
+
+	}
+
+	_computeIntersections( raycaster, intersects, rayLocalSpace ) {
+
+		let intersection;
+
+		const geometry = this.geometry;
+		const material = this.material;
+
+		const index = geometry.index;
+		const position = geometry.attributes.position;
+		const uv = geometry.attributes.uv;
+		const uv1 = geometry.attributes.uv1;
+		const normal = geometry.attributes.normal;
+		const groups = geometry.groups;
+		const drawRange = geometry.drawRange;
+
+		if ( index !== null ) {
+
+			// indexed buffer geometry
+
+			if ( Array.isArray( material ) ) {
+
+				for ( let i = 0, il = groups.length; i < il; i ++ ) {
+
+					const group = groups[ i ];
+					const groupMaterial = material[ group.materialIndex ];
+
+					const start = Math.max( group.start, drawRange.start );
+					const end = Math.min( index.count, Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) ) );
+
+					for ( let j = start, jl = end; j < jl; j += 3 ) {
+
+						const a = index.getX( j );
+						const b = index.getX( j + 1 );
+						const c = index.getX( j + 2 );
+
+						intersection = checkGeometryIntersection( this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );
+
+						if ( intersection ) {
+
+							intersection.faceIndex = Math.floor( j / 3 ); // triangle number in indexed buffer semantics
+							intersection.face.materialIndex = group.materialIndex;
+							intersects.push( intersection );
+
+						}
+
+					}
+
+				}
+
+			} else {
+
+				const start = Math.max( 0, drawRange.start );
+				const end = Math.min( index.count, ( drawRange.start + drawRange.count ) );
+
+				for ( let i = start, il = end; i < il; i += 3 ) {
+
+					const a = index.getX( i );
+					const b = index.getX( i + 1 );
+					const c = index.getX( i + 2 );
+
+					intersection = checkGeometryIntersection( this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );
+
+					if ( intersection ) {
+
+						intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indexed buffer semantics
+						intersects.push( intersection );
+
+					}
+
+				}
+
+			}
+
+		} else if ( position !== undefined ) {
+
+			// non-indexed buffer geometry
+
+			if ( Array.isArray( material ) ) {
+
+				for ( let i = 0, il = groups.length; i < il; i ++ ) {
+
+					const group = groups[ i ];
+					const groupMaterial = material[ group.materialIndex ];
+
+					const start = Math.max( group.start, drawRange.start );
+					const end = Math.min( position.count, Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) ) );
+
+					for ( let j = start, jl = end; j < jl; j += 3 ) {
+
+						const a = j;
+						const b = j + 1;
+						const c = j + 2;
+
+						intersection = checkGeometryIntersection( this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );
+
+						if ( intersection ) {
+
+							intersection.faceIndex = Math.floor( j / 3 ); // triangle number in non-indexed buffer semantics
+							intersection.face.materialIndex = group.materialIndex;
+							intersects.push( intersection );
+
+						}
+
+					}
+
+				}
+
+			} else {
+
+				const start = Math.max( 0, drawRange.start );
+				const end = Math.min( position.count, ( drawRange.start + drawRange.count ) );
+
+				for ( let i = start, il = end; i < il; i += 3 ) {
+
+					const a = i;
+					const b = i + 1;
+					const c = i + 2;
+
+					intersection = checkGeometryIntersection( this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );
+
+					if ( intersection ) {
+
+						intersection.faceIndex = Math.floor( i / 3 ); // triangle number in non-indexed buffer semantics
+						intersects.push( intersection );
+
+					}
+
+				}
+
+			}
+
+		}
+
+	}
+
+}
+
+function checkIntersection( object, material, raycaster, ray, pA, pB, pC, point ) {
+
+	let intersect;
+
+	if ( material.side === BackSide ) {
+
+		intersect = ray.intersectTriangle( pC, pB, pA, true, point );
+
+	} else {
+
+		intersect = ray.intersectTriangle( pA, pB, pC, ( material.side === FrontSide ), point );
+
+	}
+
+	if ( intersect === null ) return null;
+
+	_intersectionPointWorld.copy( point );
+	_intersectionPointWorld.applyMatrix4( object.matrixWorld );
+
+	const distance = raycaster.ray.origin.distanceTo( _intersectionPointWorld );
+
+	if ( distance < raycaster.near || distance > raycaster.far ) return null;
+
+	return {
+		distance: distance,
+		point: _intersectionPointWorld.clone(),
+		object: object
+	};
+
+}
+
+function checkGeometryIntersection( object, material, raycaster, ray, uv, uv1, normal, a, b, c ) {
+
+	object.getVertexPosition( a, _vA$1 );
+	object.getVertexPosition( b, _vB$1 );
+	object.getVertexPosition( c, _vC$1 );
+
+	const intersection = checkIntersection( object, material, raycaster, ray, _vA$1, _vB$1, _vC$1, _intersectionPoint );
+
+	if ( intersection ) {
+
+		if ( uv ) {
+
+			_uvA$1.fromBufferAttribute( uv, a );
+			_uvB$1.fromBufferAttribute( uv, b );
+			_uvC$1.fromBufferAttribute( uv, c );
+
+			intersection.uv = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() );
+
+		}
+
+		if ( uv1 ) {
+
+			_uvA$1.fromBufferAttribute( uv1, a );
+			_uvB$1.fromBufferAttribute( uv1, b );
+			_uvC$1.fromBufferAttribute( uv1, c );
+
+			intersection.uv1 = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() );
+			intersection.uv2 = intersection.uv1; // @deprecated, r152
+
+		}
+
+		if ( normal ) {
+
+			_normalA.fromBufferAttribute( normal, a );
+			_normalB.fromBufferAttribute( normal, b );
+			_normalC.fromBufferAttribute( normal, c );
+
+			intersection.normal = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _normalA, _normalB, _normalC, new Vector3() );
+
+			if ( intersection.normal.dot( ray.direction ) > 0 ) {
+
+				intersection.normal.multiplyScalar( - 1 );
+
+			}
+
+		}
+
+		const face = {
+			a: a,
+			b: b,
+			c: c,
+			normal: new Vector3(),
+			materialIndex: 0
+		};
+
+		Triangle.getNormal( _vA$1, _vB$1, _vC$1, face.normal );
+
+		intersection.face = face;
+
+	}
+
+	return intersection;
+
+}
+
+class BoxGeometry extends BufferGeometry {
+
+	constructor( width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1 ) {
+
+		super();
+
+		this.type = 'BoxGeometry';
+
+		this.parameters = {
+			width: width,
+			height: height,
+			depth: depth,
+			widthSegments: widthSegments,
+			heightSegments: heightSegments,
+			depthSegments: depthSegments
+		};
+
+		const scope = this;
+
+		// segments
+
+		widthSegments = Math.floor( widthSegments );
+		heightSegments = Math.floor( heightSegments );
+		depthSegments = Math.floor( depthSegments );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// helper variables
+
+		let numberOfVertices = 0;
+		let groupStart = 0;
+
+		// build each side of the box geometry
+
+		buildPlane( 'z', 'y', 'x', - 1, - 1, depth, height, width, depthSegments, heightSegments, 0 ); // px
+		buildPlane( 'z', 'y', 'x', 1, - 1, depth, height, - width, depthSegments, heightSegments, 1 ); // nx
+		buildPlane( 'x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2 ); // py
+		buildPlane( 'x', 'z', 'y', 1, - 1, width, depth, - height, widthSegments, depthSegments, 3 ); // ny
+		buildPlane( 'x', 'y', 'z', 1, - 1, width, height, depth, widthSegments, heightSegments, 4 ); // pz
+		buildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth, widthSegments, heightSegments, 5 ); // nz
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+		function buildPlane( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {
+
+			const segmentWidth = width / gridX;
+			const segmentHeight = height / gridY;
+
+			const widthHalf = width / 2;
+			const heightHalf = height / 2;
+			const depthHalf = depth / 2;
+
+			const gridX1 = gridX + 1;
+			const gridY1 = gridY + 1;
+
+			let vertexCounter = 0;
+			let groupCount = 0;
+
+			const vector = new Vector3();
+
+			// generate vertices, normals and uvs
+
+			for ( let iy = 0; iy < gridY1; iy ++ ) {
+
+				const y = iy * segmentHeight - heightHalf;
+
+				for ( let ix = 0; ix < gridX1; ix ++ ) {
+
+					const x = ix * segmentWidth - widthHalf;
+
+					// set values to correct vector component
+
+					vector[ u ] = x * udir;
+					vector[ v ] = y * vdir;
+					vector[ w ] = depthHalf;
+
+					// now apply vector to vertex buffer
+
+					vertices.push( vector.x, vector.y, vector.z );
+
+					// set values to correct vector component
+
+					vector[ u ] = 0;
+					vector[ v ] = 0;
+					vector[ w ] = depth > 0 ? 1 : - 1;
+
+					// now apply vector to normal buffer
+
+					normals.push( vector.x, vector.y, vector.z );
+
+					// uvs
+
+					uvs.push( ix / gridX );
+					uvs.push( 1 - ( iy / gridY ) );
+
+					// counters
+
+					vertexCounter += 1;
+
+				}
+
+			}
+
+			// indices
+
+			// 1. you need three indices to draw a single face
+			// 2. a single segment consists of two faces
+			// 3. so we need to generate six (2*3) indices per segment
+
+			for ( let iy = 0; iy < gridY; iy ++ ) {
+
+				for ( let ix = 0; ix < gridX; ix ++ ) {
+
+					const a = numberOfVertices + ix + gridX1 * iy;
+					const b = numberOfVertices + ix + gridX1 * ( iy + 1 );
+					const c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );
+					const d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;
+
+					// faces
+
+					indices.push( a, b, d );
+					indices.push( b, c, d );
+
+					// increase counter
+
+					groupCount += 6;
+
+				}
+
+			}
+
+			// add a group to the geometry. this will ensure multi material support
+
+			scope.addGroup( groupStart, groupCount, materialIndex );
+
+			// calculate new start value for groups
+
+			groupStart += groupCount;
+
+			// update total number of vertices
+
+			numberOfVertices += vertexCounter;
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new BoxGeometry( data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments );
+
+	}
+
+}
+
+/**
+ * Uniform Utilities
+ */
+
+function cloneUniforms( src ) {
+
+	const dst = {};
+
+	for ( const u in src ) {
+
+		dst[ u ] = {};
+
+		for ( const p in src[ u ] ) {
+
+			const property = src[ u ][ p ];
+
+			if ( property && ( property.isColor ||
+				property.isMatrix3 || property.isMatrix4 ||
+				property.isVector2 || property.isVector3 || property.isVector4 ||
+				property.isTexture || property.isQuaternion ) ) {
+
+				if ( property.isRenderTargetTexture ) {
+
+					console.warn( 'UniformsUtils: Textures of render targets cannot be cloned via cloneUniforms() or mergeUniforms().' );
+					dst[ u ][ p ] = null;
+
+				} else {
+
+					dst[ u ][ p ] = property.clone();
+
+				}
+
+			} else if ( Array.isArray( property ) ) {
+
+				dst[ u ][ p ] = property.slice();
+
+			} else {
+
+				dst[ u ][ p ] = property;
+
+			}
+
+		}
+
+	}
+
+	return dst;
+
+}
+
+function mergeUniforms( uniforms ) {
+
+	const merged = {};
+
+	for ( let u = 0; u < uniforms.length; u ++ ) {
+
+		const tmp = cloneUniforms( uniforms[ u ] );
+
+		for ( const p in tmp ) {
+
+			merged[ p ] = tmp[ p ];
+
+		}
+
+	}
+
+	return merged;
+
+}
+
+function cloneUniformsGroups( src ) {
+
+	const dst = [];
+
+	for ( let u = 0; u < src.length; u ++ ) {
+
+		dst.push( src[ u ].clone() );
+
+	}
+
+	return dst;
+
+}
+
+function getUnlitUniformColorSpace( renderer ) {
+
+	if ( renderer.getRenderTarget() === null ) {
+
+		// https://github.com/mrdoob/three.js/pull/23937#issuecomment-1111067398
+		return renderer.outputColorSpace;
+
+	}
+
+	return ColorManagement.workingColorSpace;
+
+}
+
+// Legacy
+
+const UniformsUtils = { clone: cloneUniforms, merge: mergeUniforms };
+
+var default_vertex = "void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";
+
+var default_fragment = "void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}";
+
+class ShaderMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isShaderMaterial = true;
+
+		this.type = 'ShaderMaterial';
+
+		this.defines = {};
+		this.uniforms = {};
+		this.uniformsGroups = [];
+
+		this.vertexShader = default_vertex;
+		this.fragmentShader = default_fragment;
+
+		this.linewidth = 1;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+
+		this.fog = false; // set to use scene fog
+		this.lights = false; // set to use scene lights
+		this.clipping = false; // set to use user-defined clipping planes
+
+		this.forceSinglePass = true;
+
+		this.extensions = {
+			derivatives: false, // set to use derivatives
+			fragDepth: false, // set to use fragment depth values
+			drawBuffers: false, // set to use draw buffers
+			shaderTextureLOD: false, // set to use shader texture LOD
+			clipCullDistance: false // set to use vertex shader clipping
+		};
+
+		// When rendered geometry doesn't include these attributes but the material does,
+		// use these default values in WebGL. This avoids errors when buffer data is missing.
+		this.defaultAttributeValues = {
+			'color': [ 1, 1, 1 ],
+			'uv': [ 0, 0 ],
+			'uv1': [ 0, 0 ]
+		};
+
+		this.index0AttributeName = undefined;
+		this.uniformsNeedUpdate = false;
+
+		this.glslVersion = null;
+
+		if ( parameters !== undefined ) {
+
+			this.setValues( parameters );
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.fragmentShader = source.fragmentShader;
+		this.vertexShader = source.vertexShader;
+
+		this.uniforms = cloneUniforms( source.uniforms );
+		this.uniformsGroups = cloneUniformsGroups( source.uniformsGroups );
+
+		this.defines = Object.assign( {}, source.defines );
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+
+		this.fog = source.fog;
+		this.lights = source.lights;
+		this.clipping = source.clipping;
+
+		this.extensions = Object.assign( {}, source.extensions );
+
+		this.glslVersion = source.glslVersion;
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		data.glslVersion = this.glslVersion;
+		data.uniforms = {};
+
+		for ( const name in this.uniforms ) {
+
+			const uniform = this.uniforms[ name ];
+			const value = uniform.value;
+
+			if ( value && value.isTexture ) {
+
+				data.uniforms[ name ] = {
+					type: 't',
+					value: value.toJSON( meta ).uuid
+				};
+
+			} else if ( value && value.isColor ) {
+
+				data.uniforms[ name ] = {
+					type: 'c',
+					value: value.getHex()
+				};
+
+			} else if ( value && value.isVector2 ) {
+
+				data.uniforms[ name ] = {
+					type: 'v2',
+					value: value.toArray()
+				};
+
+			} else if ( value && value.isVector3 ) {
+
+				data.uniforms[ name ] = {
+					type: 'v3',
+					value: value.toArray()
+				};
+
+			} else if ( value && value.isVector4 ) {
+
+				data.uniforms[ name ] = {
+					type: 'v4',
+					value: value.toArray()
+				};
+
+			} else if ( value && value.isMatrix3 ) {
+
+				data.uniforms[ name ] = {
+					type: 'm3',
+					value: value.toArray()
+				};
+
+			} else if ( value && value.isMatrix4 ) {
+
+				data.uniforms[ name ] = {
+					type: 'm4',
+					value: value.toArray()
+				};
+
+			} else {
+
+				data.uniforms[ name ] = {
+					value: value
+				};
+
+				// note: the array variants v2v, v3v, v4v, m4v and tv are not supported so far
+
+			}
+
+		}
+
+		if ( Object.keys( this.defines ).length > 0 ) data.defines = this.defines;
+
+		data.vertexShader = this.vertexShader;
+		data.fragmentShader = this.fragmentShader;
+
+		data.lights = this.lights;
+		data.clipping = this.clipping;
+
+		const extensions = {};
+
+		for ( const key in this.extensions ) {
+
+			if ( this.extensions[ key ] === true ) extensions[ key ] = true;
+
+		}
+
+		if ( Object.keys( extensions ).length > 0 ) data.extensions = extensions;
+
+		return data;
+
+	}
+
+}
+
+class Camera extends Object3D {
+
+	constructor() {
+
+		super();
+
+		this.isCamera = true;
+
+		this.type = 'Camera';
+
+		this.matrixWorldInverse = new Matrix4();
+
+		this.projectionMatrix = new Matrix4();
+		this.projectionMatrixInverse = new Matrix4();
+
+		this.coordinateSystem = WebGLCoordinateSystem;
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.matrixWorldInverse.copy( source.matrixWorldInverse );
+
+		this.projectionMatrix.copy( source.projectionMatrix );
+		this.projectionMatrixInverse.copy( source.projectionMatrixInverse );
+
+		this.coordinateSystem = source.coordinateSystem;
+
+		return this;
+
+	}
+
+	getWorldDirection( target ) {
+
+		return super.getWorldDirection( target ).negate();
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		super.updateMatrixWorld( force );
+
+		this.matrixWorldInverse.copy( this.matrixWorld ).invert();
+
+	}
+
+	updateWorldMatrix( updateParents, updateChildren ) {
+
+		super.updateWorldMatrix( updateParents, updateChildren );
+
+		this.matrixWorldInverse.copy( this.matrixWorld ).invert();
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+class PerspectiveCamera extends Camera {
+
+	constructor( fov = 50, aspect = 1, near = 0.1, far = 2000 ) {
+
+		super();
+
+		this.isPerspectiveCamera = true;
+
+		this.type = 'PerspectiveCamera';
+
+		this.fov = fov;
+		this.zoom = 1;
+
+		this.near = near;
+		this.far = far;
+		this.focus = 10;
+
+		this.aspect = aspect;
+		this.view = null;
+
+		this.filmGauge = 35;	// width of the film (default in millimeters)
+		this.filmOffset = 0;	// horizontal film offset (same unit as gauge)
+
+		this.updateProjectionMatrix();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.fov = source.fov;
+		this.zoom = source.zoom;
+
+		this.near = source.near;
+		this.far = source.far;
+		this.focus = source.focus;
+
+		this.aspect = source.aspect;
+		this.view = source.view === null ? null : Object.assign( {}, source.view );
+
+		this.filmGauge = source.filmGauge;
+		this.filmOffset = source.filmOffset;
+
+		return this;
+
+	}
+
+	/**
+	 * Sets the FOV by focal length in respect to the current .filmGauge.
+	 *
+	 * The default film gauge is 35, so that the focal length can be specified for
+	 * a 35mm (full frame) camera.
+	 *
+	 * Values for focal length and film gauge must have the same unit.
+	 */
+	setFocalLength( focalLength ) {
+
+		/** see {@link http://www.bobatkins.com/photography/technical/field_of_view.html} */
+		const vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;
+
+		this.fov = RAD2DEG * 2 * Math.atan( vExtentSlope );
+		this.updateProjectionMatrix();
+
+	}
+
+	/**
+	 * Calculates the focal length from the current .fov and .filmGauge.
+	 */
+	getFocalLength() {
+
+		const vExtentSlope = Math.tan( DEG2RAD * 0.5 * this.fov );
+
+		return 0.5 * this.getFilmHeight() / vExtentSlope;
+
+	}
+
+	getEffectiveFOV() {
+
+		return RAD2DEG * 2 * Math.atan(
+			Math.tan( DEG2RAD * 0.5 * this.fov ) / this.zoom );
+
+	}
+
+	getFilmWidth() {
+
+		// film not completely covered in portrait format (aspect < 1)
+		return this.filmGauge * Math.min( this.aspect, 1 );
+
+	}
+
+	getFilmHeight() {
+
+		// film not completely covered in landscape format (aspect > 1)
+		return this.filmGauge / Math.max( this.aspect, 1 );
+
+	}
+
+	/**
+	 * Sets an offset in a larger frustum. This is useful for multi-window or
+	 * multi-monitor/multi-machine setups.
+	 *
+	 * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
+	 * the monitors are in grid like this
+	 *
+	 *   +---+---+---+
+	 *   | A | B | C |
+	 *   +---+---+---+
+	 *   | D | E | F |
+	 *   +---+---+---+
+	 *
+	 * then for each monitor you would call it like this
+	 *
+	 *   const w = 1920;
+	 *   const h = 1080;
+	 *   const fullWidth = w * 3;
+	 *   const fullHeight = h * 2;
+	 *
+	 *   --A--
+	 *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
+	 *   --B--
+	 *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
+	 *   --C--
+	 *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
+	 *   --D--
+	 *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
+	 *   --E--
+	 *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
+	 *   --F--
+	 *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
+	 *
+	 *   Note there is no reason monitors have to be the same size or in a grid.
+	 */
+	setViewOffset( fullWidth, fullHeight, x, y, width, height ) {
+
+		this.aspect = fullWidth / fullHeight;
+
+		if ( this.view === null ) {
+
+			this.view = {
+				enabled: true,
+				fullWidth: 1,
+				fullHeight: 1,
+				offsetX: 0,
+				offsetY: 0,
+				width: 1,
+				height: 1
+			};
+
+		}
+
+		this.view.enabled = true;
+		this.view.fullWidth = fullWidth;
+		this.view.fullHeight = fullHeight;
+		this.view.offsetX = x;
+		this.view.offsetY = y;
+		this.view.width = width;
+		this.view.height = height;
+
+		this.updateProjectionMatrix();
+
+	}
+
+	clearViewOffset() {
+
+		if ( this.view !== null ) {
+
+			this.view.enabled = false;
+
+		}
+
+		this.updateProjectionMatrix();
+
+	}
+
+	updateProjectionMatrix() {
+
+		const near = this.near;
+		let top = near * Math.tan( DEG2RAD * 0.5 * this.fov ) / this.zoom;
+		let height = 2 * top;
+		let width = this.aspect * height;
+		let left = - 0.5 * width;
+		const view = this.view;
+
+		if ( this.view !== null && this.view.enabled ) {
+
+			const fullWidth = view.fullWidth,
+				fullHeight = view.fullHeight;
+
+			left += view.offsetX * width / fullWidth;
+			top -= view.offsetY * height / fullHeight;
+			width *= view.width / fullWidth;
+			height *= view.height / fullHeight;
+
+		}
+
+		const skew = this.filmOffset;
+		if ( skew !== 0 ) left += near * skew / this.getFilmWidth();
+
+		this.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far, this.coordinateSystem );
+
+		this.projectionMatrixInverse.copy( this.projectionMatrix ).invert();
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		data.object.fov = this.fov;
+		data.object.zoom = this.zoom;
+
+		data.object.near = this.near;
+		data.object.far = this.far;
+		data.object.focus = this.focus;
+
+		data.object.aspect = this.aspect;
+
+		if ( this.view !== null ) data.object.view = Object.assign( {}, this.view );
+
+		data.object.filmGauge = this.filmGauge;
+		data.object.filmOffset = this.filmOffset;
+
+		return data;
+
+	}
+
+}
+
+const fov = - 90; // negative fov is not an error
+const aspect = 1;
+
+class CubeCamera extends Object3D {
+
+	constructor( near, far, renderTarget ) {
+
+		super();
+
+		this.type = 'CubeCamera';
+
+		this.renderTarget = renderTarget;
+		this.coordinateSystem = null;
+		this.activeMipmapLevel = 0;
+
+		const cameraPX = new PerspectiveCamera( fov, aspect, near, far );
+		cameraPX.layers = this.layers;
+		this.add( cameraPX );
+
+		const cameraNX = new PerspectiveCamera( fov, aspect, near, far );
+		cameraNX.layers = this.layers;
+		this.add( cameraNX );
+
+		const cameraPY = new PerspectiveCamera( fov, aspect, near, far );
+		cameraPY.layers = this.layers;
+		this.add( cameraPY );
+
+		const cameraNY = new PerspectiveCamera( fov, aspect, near, far );
+		cameraNY.layers = this.layers;
+		this.add( cameraNY );
+
+		const cameraPZ = new PerspectiveCamera( fov, aspect, near, far );
+		cameraPZ.layers = this.layers;
+		this.add( cameraPZ );
+
+		const cameraNZ = new PerspectiveCamera( fov, aspect, near, far );
+		cameraNZ.layers = this.layers;
+		this.add( cameraNZ );
+
+	}
+
+	updateCoordinateSystem() {
+
+		const coordinateSystem = this.coordinateSystem;
+
+		const cameras = this.children.concat();
+
+		const [ cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ ] = cameras;
+
+		for ( const camera of cameras ) this.remove( camera );
+
+		if ( coordinateSystem === WebGLCoordinateSystem ) {
+
+			cameraPX.up.set( 0, 1, 0 );
+			cameraPX.lookAt( 1, 0, 0 );
+
+			cameraNX.up.set( 0, 1, 0 );
+			cameraNX.lookAt( - 1, 0, 0 );
+
+			cameraPY.up.set( 0, 0, - 1 );
+			cameraPY.lookAt( 0, 1, 0 );
+
+			cameraNY.up.set( 0, 0, 1 );
+			cameraNY.lookAt( 0, - 1, 0 );
+
+			cameraPZ.up.set( 0, 1, 0 );
+			cameraPZ.lookAt( 0, 0, 1 );
+
+			cameraNZ.up.set( 0, 1, 0 );
+			cameraNZ.lookAt( 0, 0, - 1 );
+
+		} else if ( coordinateSystem === WebGPUCoordinateSystem ) {
+
+			cameraPX.up.set( 0, - 1, 0 );
+			cameraPX.lookAt( - 1, 0, 0 );
+
+			cameraNX.up.set( 0, - 1, 0 );
+			cameraNX.lookAt( 1, 0, 0 );
+
+			cameraPY.up.set( 0, 0, 1 );
+			cameraPY.lookAt( 0, 1, 0 );
+
+			cameraNY.up.set( 0, 0, - 1 );
+			cameraNY.lookAt( 0, - 1, 0 );
+
+			cameraPZ.up.set( 0, - 1, 0 );
+			cameraPZ.lookAt( 0, 0, 1 );
+
+			cameraNZ.up.set( 0, - 1, 0 );
+			cameraNZ.lookAt( 0, 0, - 1 );
+
+		} else {
+
+			throw new Error( 'THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: ' + coordinateSystem );
+
+		}
+
+		for ( const camera of cameras ) {
+
+			this.add( camera );
+
+			camera.updateMatrixWorld();
+
+		}
+
+	}
+
+	update( renderer, scene ) {
+
+		if ( this.parent === null ) this.updateMatrixWorld();
+
+		const { renderTarget, activeMipmapLevel } = this;
+
+		if ( this.coordinateSystem !== renderer.coordinateSystem ) {
+
+			this.coordinateSystem = renderer.coordinateSystem;
+
+			this.updateCoordinateSystem();
+
+		}
+
+		const [ cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ ] = this.children;
+
+		const currentRenderTarget = renderer.getRenderTarget();
+		const currentActiveCubeFace = renderer.getActiveCubeFace();
+		const currentActiveMipmapLevel = renderer.getActiveMipmapLevel();
+
+		const currentXrEnabled = renderer.xr.enabled;
+
+		renderer.xr.enabled = false;
+
+		const generateMipmaps = renderTarget.texture.generateMipmaps;
+
+		renderTarget.texture.generateMipmaps = false;
+
+		renderer.setRenderTarget( renderTarget, 0, activeMipmapLevel );
+		renderer.render( scene, cameraPX );
+
+		renderer.setRenderTarget( renderTarget, 1, activeMipmapLevel );
+		renderer.render( scene, cameraNX );
+
+		renderer.setRenderTarget( renderTarget, 2, activeMipmapLevel );
+		renderer.render( scene, cameraPY );
+
+		renderer.setRenderTarget( renderTarget, 3, activeMipmapLevel );
+		renderer.render( scene, cameraNY );
+
+		renderer.setRenderTarget( renderTarget, 4, activeMipmapLevel );
+		renderer.render( scene, cameraPZ );
+
+		// mipmaps are generated during the last call of render()
+		// at this point, all sides of the cube render target are defined
+
+		renderTarget.texture.generateMipmaps = generateMipmaps;
+
+		renderer.setRenderTarget( renderTarget, 5, activeMipmapLevel );
+		renderer.render( scene, cameraNZ );
+
+		renderer.setRenderTarget( currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel );
+
+		renderer.xr.enabled = currentXrEnabled;
+
+		renderTarget.texture.needsPMREMUpdate = true;
+
+	}
+
+}
+
+class CubeTexture extends Texture {
+
+	constructor( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace ) {
+
+		images = images !== undefined ? images : [];
+		mapping = mapping !== undefined ? mapping : CubeReflectionMapping;
+
+		super( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace );
+
+		this.isCubeTexture = true;
+
+		this.flipY = false;
+
+	}
+
+	get images() {
+
+		return this.image;
+
+	}
+
+	set images( value ) {
+
+		this.image = value;
+
+	}
+
+}
+
+class WebGLCubeRenderTarget extends WebGLRenderTarget {
+
+	constructor( size = 1, options = {} ) {
+
+		super( size, size, options );
+
+		this.isWebGLCubeRenderTarget = true;
+
+		const image = { width: size, height: size, depth: 1 };
+		const images = [ image, image, image, image, image, image ];
+
+		if ( options.encoding !== undefined ) {
+
+			// @deprecated, r152
+			warnOnce( 'THREE.WebGLCubeRenderTarget: option.encoding has been replaced by option.colorSpace.' );
+			options.colorSpace = options.encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
+
+		}
+
+		this.texture = new CubeTexture( images, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace );
+
+		// By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)
+		// in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,
+		// in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.
+
+		// three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
+		// and the flag isRenderTargetTexture controls this conversion. The flip is not required when using WebGLCubeRenderTarget.texture
+		// as a cube texture (this is detected when isRenderTargetTexture is set to true for cube textures).
+
+		this.texture.isRenderTargetTexture = true;
+
+		this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
+		this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;
+
+	}
+
+	fromEquirectangularTexture( renderer, texture ) {
+
+		this.texture.type = texture.type;
+		this.texture.colorSpace = texture.colorSpace;
+
+		this.texture.generateMipmaps = texture.generateMipmaps;
+		this.texture.minFilter = texture.minFilter;
+		this.texture.magFilter = texture.magFilter;
+
+		const shader = {
+
+			uniforms: {
+				tEquirect: { value: null },
+			},
+
+			vertexShader: /* glsl */`
+
+				varying vec3 vWorldDirection;
+
+				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
+
+					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
+
+				}
+
+				void main() {
+
+					vWorldDirection = transformDirection( position, modelMatrix );
+
+					#include <begin_vertex>
+					#include <project_vertex>
+
+				}
+			`,
+
+			fragmentShader: /* glsl */`
+
+				uniform sampler2D tEquirect;
+
+				varying vec3 vWorldDirection;
+
+				#include <common>
+
+				void main() {
+
+					vec3 direction = normalize( vWorldDirection );
+
+					vec2 sampleUV = equirectUv( direction );
+
+					gl_FragColor = texture2D( tEquirect, sampleUV );
+
+				}
+			`
+		};
+
+		const geometry = new BoxGeometry( 5, 5, 5 );
+
+		const material = new ShaderMaterial( {
+
+			name: 'CubemapFromEquirect',
+
+			uniforms: cloneUniforms( shader.uniforms ),
+			vertexShader: shader.vertexShader,
+			fragmentShader: shader.fragmentShader,
+			side: BackSide,
+			blending: NoBlending
+
+		} );
+
+		material.uniforms.tEquirect.value = texture;
+
+		const mesh = new Mesh( geometry, material );
+
+		const currentMinFilter = texture.minFilter;
+
+		// Avoid blurred poles
+		if ( texture.minFilter === LinearMipmapLinearFilter ) texture.minFilter = LinearFilter;
+
+		const camera = new CubeCamera( 1, 10, this );
+		camera.update( renderer, mesh );
+
+		texture.minFilter = currentMinFilter;
+
+		mesh.geometry.dispose();
+		mesh.material.dispose();
+
+		return this;
+
+	}
+
+	clear( renderer, color, depth, stencil ) {
+
+		const currentRenderTarget = renderer.getRenderTarget();
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			renderer.setRenderTarget( this, i );
+
+			renderer.clear( color, depth, stencil );
+
+		}
+
+		renderer.setRenderTarget( currentRenderTarget );
+
+	}
+
+}
+
+const _vector1 = /*@__PURE__*/ new Vector3();
+const _vector2 = /*@__PURE__*/ new Vector3();
+const _normalMatrix = /*@__PURE__*/ new Matrix3();
+
+class Plane {
+
+	constructor( normal = new Vector3( 1, 0, 0 ), constant = 0 ) {
+
+		this.isPlane = true;
+
+		// normal is assumed to be normalized
+
+		this.normal = normal;
+		this.constant = constant;
+
+	}
+
+	set( normal, constant ) {
+
+		this.normal.copy( normal );
+		this.constant = constant;
+
+		return this;
+
+	}
+
+	setComponents( x, y, z, w ) {
+
+		this.normal.set( x, y, z );
+		this.constant = w;
+
+		return this;
+
+	}
+
+	setFromNormalAndCoplanarPoint( normal, point ) {
+
+		this.normal.copy( normal );
+		this.constant = - point.dot( this.normal );
+
+		return this;
+
+	}
+
+	setFromCoplanarPoints( a, b, c ) {
+
+		const normal = _vector1.subVectors( c, b ).cross( _vector2.subVectors( a, b ) ).normalize();
+
+		// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
+
+		this.setFromNormalAndCoplanarPoint( normal, a );
+
+		return this;
+
+	}
+
+	copy( plane ) {
+
+		this.normal.copy( plane.normal );
+		this.constant = plane.constant;
+
+		return this;
+
+	}
+
+	normalize() {
+
+		// Note: will lead to a divide by zero if the plane is invalid.
+
+		const inverseNormalLength = 1.0 / this.normal.length();
+		this.normal.multiplyScalar( inverseNormalLength );
+		this.constant *= inverseNormalLength;
+
+		return this;
+
+	}
+
+	negate() {
+
+		this.constant *= - 1;
+		this.normal.negate();
+
+		return this;
+
+	}
+
+	distanceToPoint( point ) {
+
+		return this.normal.dot( point ) + this.constant;
+
+	}
+
+	distanceToSphere( sphere ) {
+
+		return this.distanceToPoint( sphere.center ) - sphere.radius;
+
+	}
+
+	projectPoint( point, target ) {
+
+		return target.copy( point ).addScaledVector( this.normal, - this.distanceToPoint( point ) );
+
+	}
+
+	intersectLine( line, target ) {
+
+		const direction = line.delta( _vector1 );
+
+		const denominator = this.normal.dot( direction );
+
+		if ( denominator === 0 ) {
+
+			// line is coplanar, return origin
+			if ( this.distanceToPoint( line.start ) === 0 ) {
+
+				return target.copy( line.start );
+
+			}
+
+			// Unsure if this is the correct method to handle this case.
+			return null;
+
+		}
+
+		const t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;
+
+		if ( t < 0 || t > 1 ) {
+
+			return null;
+
+		}
+
+		return target.copy( line.start ).addScaledVector( direction, t );
+
+	}
+
+	intersectsLine( line ) {
+
+		// Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
+
+		const startSign = this.distanceToPoint( line.start );
+		const endSign = this.distanceToPoint( line.end );
+
+		return ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 );
+
+	}
+
+	intersectsBox( box ) {
+
+		return box.intersectsPlane( this );
+
+	}
+
+	intersectsSphere( sphere ) {
+
+		return sphere.intersectsPlane( this );
+
+	}
+
+	coplanarPoint( target ) {
+
+		return target.copy( this.normal ).multiplyScalar( - this.constant );
+
+	}
+
+	applyMatrix4( matrix, optionalNormalMatrix ) {
+
+		const normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix( matrix );
+
+		const referencePoint = this.coplanarPoint( _vector1 ).applyMatrix4( matrix );
+
+		const normal = this.normal.applyMatrix3( normalMatrix ).normalize();
+
+		this.constant = - referencePoint.dot( normal );
+
+		return this;
+
+	}
+
+	translate( offset ) {
+
+		this.constant -= offset.dot( this.normal );
+
+		return this;
+
+	}
+
+	equals( plane ) {
+
+		return plane.normal.equals( this.normal ) && ( plane.constant === this.constant );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+const _sphere$5 = /*@__PURE__*/ new Sphere();
+const _vector$7 = /*@__PURE__*/ new Vector3();
+
+class Frustum {
+
+	constructor( p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane() ) {
+
+		this.planes = [ p0, p1, p2, p3, p4, p5 ];
+
+	}
+
+	set( p0, p1, p2, p3, p4, p5 ) {
+
+		const planes = this.planes;
+
+		planes[ 0 ].copy( p0 );
+		planes[ 1 ].copy( p1 );
+		planes[ 2 ].copy( p2 );
+		planes[ 3 ].copy( p3 );
+		planes[ 4 ].copy( p4 );
+		planes[ 5 ].copy( p5 );
+
+		return this;
+
+	}
+
+	copy( frustum ) {
+
+		const planes = this.planes;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			planes[ i ].copy( frustum.planes[ i ] );
+
+		}
+
+		return this;
+
+	}
+
+	setFromProjectionMatrix( m, coordinateSystem = WebGLCoordinateSystem ) {
+
+		const planes = this.planes;
+		const me = m.elements;
+		const me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];
+		const me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];
+		const me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];
+		const me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];
+
+		planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();
+		planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();
+		planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();
+		planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();
+		planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();
+
+		if ( coordinateSystem === WebGLCoordinateSystem ) {
+
+			planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();
+
+		} else if ( coordinateSystem === WebGPUCoordinateSystem ) {
+
+			planes[ 5 ].setComponents( me2, me6, me10, me14 ).normalize();
+
+		} else {
+
+			throw new Error( 'THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: ' + coordinateSystem );
+
+		}
+
+		return this;
+
+	}
+
+	intersectsObject( object ) {
+
+		if ( object.boundingSphere !== undefined ) {
+
+			if ( object.boundingSphere === null ) object.computeBoundingSphere();
+
+			_sphere$5.copy( object.boundingSphere ).applyMatrix4( object.matrixWorld );
+
+		} else {
+
+			const geometry = object.geometry;
+
+			if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+
+			_sphere$5.copy( geometry.boundingSphere ).applyMatrix4( object.matrixWorld );
+
+		}
+
+		return this.intersectsSphere( _sphere$5 );
+
+	}
+
+	intersectsSprite( sprite ) {
+
+		_sphere$5.center.set( 0, 0, 0 );
+		_sphere$5.radius = 0.7071067811865476;
+		_sphere$5.applyMatrix4( sprite.matrixWorld );
+
+		return this.intersectsSphere( _sphere$5 );
+
+	}
+
+	intersectsSphere( sphere ) {
+
+		const planes = this.planes;
+		const center = sphere.center;
+		const negRadius = - sphere.radius;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const distance = planes[ i ].distanceToPoint( center );
+
+			if ( distance < negRadius ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	intersectsBox( box ) {
+
+		const planes = this.planes;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const plane = planes[ i ];
+
+			// corner at max distance
+
+			_vector$7.x = plane.normal.x > 0 ? box.max.x : box.min.x;
+			_vector$7.y = plane.normal.y > 0 ? box.max.y : box.min.y;
+			_vector$7.z = plane.normal.z > 0 ? box.max.z : box.min.z;
+
+			if ( plane.distanceToPoint( _vector$7 ) < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	containsPoint( point ) {
+
+		const planes = this.planes;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			if ( planes[ i ].distanceToPoint( point ) < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+function WebGLAnimation() {
+
+	let context = null;
+	let isAnimating = false;
+	let animationLoop = null;
+	let requestId = null;
+
+	function onAnimationFrame( time, frame ) {
+
+		animationLoop( time, frame );
+
+		requestId = context.requestAnimationFrame( onAnimationFrame );
+
+	}
+
+	return {
+
+		start: function () {
+
+			if ( isAnimating === true ) return;
+			if ( animationLoop === null ) return;
+
+			requestId = context.requestAnimationFrame( onAnimationFrame );
+
+			isAnimating = true;
+
+		},
+
+		stop: function () {
+
+			context.cancelAnimationFrame( requestId );
+
+			isAnimating = false;
+
+		},
+
+		setAnimationLoop: function ( callback ) {
+
+			animationLoop = callback;
+
+		},
+
+		setContext: function ( value ) {
+
+			context = value;
+
+		}
+
+	};
+
+}
+
+function WebGLAttributes( gl, capabilities ) {
+
+	const isWebGL2 = capabilities.isWebGL2;
+
+	const buffers = new WeakMap();
+
+	function createBuffer( attribute, bufferType ) {
+
+		const array = attribute.array;
+		const usage = attribute.usage;
+		const size = array.byteLength;
+
+		const buffer = gl.createBuffer();
+
+		gl.bindBuffer( bufferType, buffer );
+		gl.bufferData( bufferType, array, usage );
+
+		attribute.onUploadCallback();
+
+		let type;
+
+		if ( array instanceof Float32Array ) {
+
+			type = gl.FLOAT;
+
+		} else if ( array instanceof Uint16Array ) {
+
+			if ( attribute.isFloat16BufferAttribute ) {
+
+				if ( isWebGL2 ) {
+
+					type = gl.HALF_FLOAT;
+
+				} else {
+
+					throw new Error( 'THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2.' );
+
+				}
+
+			} else {
+
+				type = gl.UNSIGNED_SHORT;
+
+			}
+
+		} else if ( array instanceof Int16Array ) {
+
+			type = gl.SHORT;
+
+		} else if ( array instanceof Uint32Array ) {
+
+			type = gl.UNSIGNED_INT;
+
+		} else if ( array instanceof Int32Array ) {
+
+			type = gl.INT;
+
+		} else if ( array instanceof Int8Array ) {
+
+			type = gl.BYTE;
+
+		} else if ( array instanceof Uint8Array ) {
+
+			type = gl.UNSIGNED_BYTE;
+
+		} else if ( array instanceof Uint8ClampedArray ) {
+
+			type = gl.UNSIGNED_BYTE;
+
+		} else {
+
+			throw new Error( 'THREE.WebGLAttributes: Unsupported buffer data format: ' + array );
+
+		}
+
+		return {
+			buffer: buffer,
+			type: type,
+			bytesPerElement: array.BYTES_PER_ELEMENT,
+			version: attribute.version,
+			size: size
+		};
+
+	}
+
+	function updateBuffer( buffer, attribute, bufferType ) {
+
+		const array = attribute.array;
+		const updateRange = attribute._updateRange; // deprecated
+		const updateRanges = attribute.updateRanges;
+
+		gl.bindBuffer( bufferType, buffer );
+
+		if ( updateRange.count === - 1 && updateRanges.length === 0 ) {
+
+			// Not using update ranges
+			gl.bufferSubData( bufferType, 0, array );
+
+		}
+
+		if ( updateRanges.length !== 0 ) {
+
+			for ( let i = 0, l = updateRanges.length; i < l; i ++ ) {
+
+				const range = updateRanges[ i ];
+				if ( isWebGL2 ) {
+
+					gl.bufferSubData( bufferType, range.start * array.BYTES_PER_ELEMENT,
+						array, range.start, range.count );
+
+				} else {
+
+					gl.bufferSubData( bufferType, range.start * array.BYTES_PER_ELEMENT,
+						array.subarray( range.start, range.start + range.count ) );
+
+				}
+
+			}
+
+			attribute.clearUpdateRanges();
+
+		}
+
+		// deprecated
+		if ( updateRange.count !== - 1 ) {
+
+			if ( isWebGL2 ) {
+
+				gl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,
+					array, updateRange.offset, updateRange.count );
+
+			} else {
+
+				gl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,
+					array.subarray( updateRange.offset, updateRange.offset + updateRange.count ) );
+
+			}
+
+			updateRange.count = - 1; // reset range
+
+		}
+
+		attribute.onUploadCallback();
+
+	}
+
+	//
+
+	function get( attribute ) {
+
+		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
+
+		return buffers.get( attribute );
+
+	}
+
+	function remove( attribute ) {
+
+		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
+
+		const data = buffers.get( attribute );
+
+		if ( data ) {
+
+			gl.deleteBuffer( data.buffer );
+
+			buffers.delete( attribute );
+
+		}
+
+	}
+
+	function update( attribute, bufferType ) {
+
+		if ( attribute.isGLBufferAttribute ) {
+
+			const cached = buffers.get( attribute );
+
+			if ( ! cached || cached.version < attribute.version ) {
+
+				buffers.set( attribute, {
+					buffer: attribute.buffer,
+					type: attribute.type,
+					bytesPerElement: attribute.elementSize,
+					version: attribute.version
+				} );
+
+			}
+
+			return;
+
+		}
+
+		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
+
+		const data = buffers.get( attribute );
+
+		if ( data === undefined ) {
+
+			buffers.set( attribute, createBuffer( attribute, bufferType ) );
+
+		} else if ( data.version < attribute.version ) {
+
+			if ( data.size !== attribute.array.byteLength ) {
+
+				throw new Error( 'THREE.WebGLAttributes: The size of the buffer attribute\'s array buffer does not match the original size. Resizing buffer attributes is not supported.' );
+
+			}
+
+			updateBuffer( data.buffer, attribute, bufferType );
+
+			data.version = attribute.version;
+
+		}
+
+	}
+
+	return {
+
+		get: get,
+		remove: remove,
+		update: update
+
+	};
+
+}
+
+class PlaneGeometry extends BufferGeometry {
+
+	constructor( width = 1, height = 1, widthSegments = 1, heightSegments = 1 ) {
+
+		super();
+
+		this.type = 'PlaneGeometry';
+
+		this.parameters = {
+			width: width,
+			height: height,
+			widthSegments: widthSegments,
+			heightSegments: heightSegments
+		};
+
+		const width_half = width / 2;
+		const height_half = height / 2;
+
+		const gridX = Math.floor( widthSegments );
+		const gridY = Math.floor( heightSegments );
+
+		const gridX1 = gridX + 1;
+		const gridY1 = gridY + 1;
+
+		const segment_width = width / gridX;
+		const segment_height = height / gridY;
+
+		//
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		for ( let iy = 0; iy < gridY1; iy ++ ) {
+
+			const y = iy * segment_height - height_half;
+
+			for ( let ix = 0; ix < gridX1; ix ++ ) {
+
+				const x = ix * segment_width - width_half;
+
+				vertices.push( x, - y, 0 );
+
+				normals.push( 0, 0, 1 );
+
+				uvs.push( ix / gridX );
+				uvs.push( 1 - ( iy / gridY ) );
+
+			}
+
+		}
+
+		for ( let iy = 0; iy < gridY; iy ++ ) {
+
+			for ( let ix = 0; ix < gridX; ix ++ ) {
+
+				const a = ix + gridX1 * iy;
+				const b = ix + gridX1 * ( iy + 1 );
+				const c = ( ix + 1 ) + gridX1 * ( iy + 1 );
+				const d = ( ix + 1 ) + gridX1 * iy;
+
+				indices.push( a, b, d );
+				indices.push( b, c, d );
+
+			}
+
+		}
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new PlaneGeometry( data.width, data.height, data.widthSegments, data.heightSegments );
+
+	}
+
+}
+
+var alphahash_fragment = "#ifdef USE_ALPHAHASH\n\tif ( diffuseColor.a < getAlphaHashThreshold( vPosition ) ) discard;\n#endif";
+
+var alphahash_pars_fragment = "#ifdef USE_ALPHAHASH\n\tconst float ALPHA_HASH_SCALE = 0.05;\n\tfloat hash2D( vec2 value ) {\n\t\treturn fract( 1.0e4 * sin( 17.0 * value.x + 0.1 * value.y ) * ( 0.1 + abs( sin( 13.0 * value.y + value.x ) ) ) );\n\t}\n\tfloat hash3D( vec3 value ) {\n\t\treturn hash2D( vec2( hash2D( value.xy ), value.z ) );\n\t}\n\tfloat getAlphaHashThreshold( vec3 position ) {\n\t\tfloat maxDeriv = max(\n\t\t\tlength( dFdx( position.xyz ) ),\n\t\t\tlength( dFdy( position.xyz ) )\n\t\t);\n\t\tfloat pixScale = 1.0 / ( ALPHA_HASH_SCALE * maxDeriv );\n\t\tvec2 pixScales = vec2(\n\t\t\texp2( floor( log2( pixScale ) ) ),\n\t\t\texp2( ceil( log2( pixScale ) ) )\n\t\t);\n\t\tvec2 alpha = vec2(\n\t\t\thash3D( floor( pixScales.x * position.xyz ) ),\n\t\t\thash3D( floor( pixScales.y * position.xyz ) )\n\t\t);\n\t\tfloat lerpFactor = fract( log2( pixScale ) );\n\t\tfloat x = ( 1.0 - lerpFactor ) * alpha.x + lerpFactor * alpha.y;\n\t\tfloat a = min( lerpFactor, 1.0 - lerpFactor );\n\t\tvec3 cases = vec3(\n\t\t\tx * x / ( 2.0 * a * ( 1.0 - a ) ),\n\t\t\t( x - 0.5 * a ) / ( 1.0 - a ),\n\t\t\t1.0 - ( ( 1.0 - x ) * ( 1.0 - x ) / ( 2.0 * a * ( 1.0 - a ) ) )\n\t\t);\n\t\tfloat threshold = ( x < ( 1.0 - a ) )\n\t\t\t? ( ( x < a ) ? cases.x : cases.y )\n\t\t\t: cases.z;\n\t\treturn clamp( threshold , 1.0e-6, 1.0 );\n\t}\n#endif";
+
+var alphamap_fragment = "#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;\n#endif";
+
+var alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";
+
+var alphatest_fragment = "#ifdef USE_ALPHATEST\n\tif ( diffuseColor.a < alphaTest ) discard;\n#endif";
+
+var alphatest_pars_fragment = "#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif";
+
+var aomap_fragment = "#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_CLEARCOAT ) \n\t\tclearcoatSpecularIndirect *= ambientOcclusion;\n\t#endif\n\t#if defined( USE_SHEEN ) \n\t\tsheenSpecularIndirect *= ambientOcclusion;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometryNormal, geometryViewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif";
+
+var aomap_pars_fragment = "#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif";
+
+var batching_pars_vertex = "#ifdef USE_BATCHING\n\tattribute float batchId;\n\tuniform highp sampler2D batchingTexture;\n\tmat4 getBatchingMatrix( const in float i ) {\n\t\tint size = textureSize( batchingTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( batchingTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( batchingTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( batchingTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( batchingTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n#endif";
+
+var batching_vertex = "#ifdef USE_BATCHING\n\tmat4 batchingMatrix = getBatchingMatrix( batchId );\n#endif";
+
+var begin_vertex = "vec3 transformed = vec3( position );\n#ifdef USE_ALPHAHASH\n\tvPosition = vec3( position );\n#endif";
+
+var beginnormal_vertex = "vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif";
+
+var bsdfs = "float G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n} // validated";
+
+var iridescence_fragment = "#ifdef USE_IRIDESCENCE\n\tconst mat3 XYZ_TO_REC709 = mat3(\n\t\t 3.2404542, -0.9692660,  0.0556434,\n\t\t-1.5371385,  1.8760108, -0.2040259,\n\t\t-0.4985314,  0.0415560,  1.0572252\n\t);\n\tvec3 Fresnel0ToIor( vec3 fresnel0 ) {\n\t\tvec3 sqrtF0 = sqrt( fresnel0 );\n\t\treturn ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );\n\t}\n\tvec3 IorToFresnel0( vec3 transmittedIor, float incidentIor ) {\n\t\treturn pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );\n\t}\n\tfloat IorToFresnel0( float transmittedIor, float incidentIor ) {\n\t\treturn pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ));\n\t}\n\tvec3 evalSensitivity( float OPD, vec3 shift ) {\n\t\tfloat phase = 2.0 * PI * OPD * 1.0e-9;\n\t\tvec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );\n\t\tvec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );\n\t\tvec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );\n\t\tvec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - pow2( phase ) * var );\n\t\txyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * pow2( phase ) );\n\t\txyz /= 1.0685e-7;\n\t\tvec3 rgb = XYZ_TO_REC709 * xyz;\n\t\treturn rgb;\n\t}\n\tvec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {\n\t\tvec3 I;\n\t\tfloat iridescenceIOR = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );\n\t\tfloat sinTheta2Sq = pow2( outsideIOR / iridescenceIOR ) * ( 1.0 - pow2( cosTheta1 ) );\n\t\tfloat cosTheta2Sq = 1.0 - sinTheta2Sq;\n\t\tif ( cosTheta2Sq < 0.0 ) {\n\t\t\treturn vec3( 1.0 );\n\t\t}\n\t\tfloat cosTheta2 = sqrt( cosTheta2Sq );\n\t\tfloat R0 = IorToFresnel0( iridescenceIOR, outsideIOR );\n\t\tfloat R12 = F_Schlick( R0, 1.0, cosTheta1 );\n\t\tfloat T121 = 1.0 - R12;\n\t\tfloat phi12 = 0.0;\n\t\tif ( iridescenceIOR < outsideIOR ) phi12 = PI;\n\t\tfloat phi21 = PI - phi12;\n\t\tvec3 baseIOR = Fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) );\t\tvec3 R1 = IorToFresnel0( baseIOR, iridescenceIOR );\n\t\tvec3 R23 = F_Schlick( R1, 1.0, cosTheta2 );\n\t\tvec3 phi23 = vec3( 0.0 );\n\t\tif ( baseIOR[ 0 ] < iridescenceIOR ) phi23[ 0 ] = PI;\n\t\tif ( baseIOR[ 1 ] < iridescenceIOR ) phi23[ 1 ] = PI;\n\t\tif ( baseIOR[ 2 ] < iridescenceIOR ) phi23[ 2 ] = PI;\n\t\tfloat OPD = 2.0 * iridescenceIOR * thinFilmThickness * cosTheta2;\n\t\tvec3 phi = vec3( phi21 ) + phi23;\n\t\tvec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );\n\t\tvec3 r123 = sqrt( R123 );\n\t\tvec3 Rs = pow2( T121 ) * R23 / ( vec3( 1.0 ) - R123 );\n\t\tvec3 C0 = R12 + Rs;\n\t\tI = C0;\n\t\tvec3 Cm = Rs - T121;\n\t\tfor ( int m = 1; m <= 2; ++ m ) {\n\t\t\tCm *= r123;\n\t\t\tvec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );\n\t\t\tI += Cm * Sm;\n\t\t}\n\t\treturn max( I, vec3( 0.0 ) );\n\t}\n#endif";
+
+var bumpmap_pars_fragment = "#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vBumpMapUv );\n\t\tvec2 dSTdy = dFdy( vBumpMapUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vBumpMapUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = normalize( dFdx( surf_pos.xyz ) );\n\t\tvec3 vSigmaY = normalize( dFdy( surf_pos.xyz ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif";
+
+var clipping_planes_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif";
+
+var clipping_planes_pars_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif";
+
+var clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif";
+
+var clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif";
+
+var color_fragment = "#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif";
+
+var color_pars_fragment = "#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif";
+
+var color_pars_vertex = "#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif";
+
+var color_vertex = "#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif";
+
+var common = "#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nvec3 pow2( const in vec3 x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\n#ifdef USE_ALPHAHASH\n\tvarying vec3 vPosition;\n#endif\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat luminance( const in vec3 rgb ) {\n\tconst vec3 weights = vec3( 0.2126729, 0.7151522, 0.0721750 );\n\treturn dot( weights, rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n} // validated";
+
+var cube_uv_reflection_fragment = "#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\thighp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tuv.x += filterInt * 3.0 * cubeUV_minTileSize;\n\t\tuv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\n\t\tuv.x *= CUBEUV_TEXEL_WIDTH;\n\t\tuv.y *= CUBEUV_TEXEL_HEIGHT;\n\t\t#ifdef texture2DGradEXT\n\t\t\treturn texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\n\t\t#else\n\t\t\treturn texture2D( envMap, uv ).rgb;\n\t\t#endif\n\t}\n\t#define cubeUV_r0 1.0\n\t#define cubeUV_m0 - 2.0\n\t#define cubeUV_r1 0.8\n\t#define cubeUV_m1 - 1.0\n\t#define cubeUV_r4 0.4\n\t#define cubeUV_m4 2.0\n\t#define cubeUV_r5 0.305\n\t#define cubeUV_m5 3.0\n\t#define cubeUV_r6 0.21\n\t#define cubeUV_m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= cubeUV_r1 ) {\n\t\t\tmip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\n\t\t} else if ( roughness >= cubeUV_r4 ) {\n\t\t\tmip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\n\t\t} else if ( roughness >= cubeUV_r5 ) {\n\t\t\tmip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\n\t\t} else if ( roughness >= cubeUV_r6 ) {\n\t\t\tmip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif";
+
+var defaultnormal_vertex = "vec3 transformedNormal = objectNormal;\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = objectTangent;\n#endif\n#ifdef USE_BATCHING\n\tmat3 bm = mat3( batchingMatrix );\n\ttransformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );\n\ttransformedNormal = bm * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = bm * transformedTangent;\n\t#endif\n#endif\n#ifdef USE_INSTANCING\n\tmat3 im = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );\n\ttransformedNormal = im * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = im * transformedTangent;\n\t#endif\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\ttransformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif";
+
+var displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif";
+
+var displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\n#endif";
+
+var emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif";
+
+var emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif";
+
+var colorspace_fragment = "gl_FragColor = linearToOutputTexel( gl_FragColor );";
+
+var colorspace_pars_fragment = "\nconst mat3 LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = mat3(\n\tvec3( 0.8224621, 0.177538, 0.0 ),\n\tvec3( 0.0331941, 0.9668058, 0.0 ),\n\tvec3( 0.0170827, 0.0723974, 0.9105199 )\n);\nconst mat3 LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = mat3(\n\tvec3( 1.2249401, - 0.2249404, 0.0 ),\n\tvec3( - 0.0420569, 1.0420571, 0.0 ),\n\tvec3( - 0.0196376, - 0.0786361, 1.0982735 )\n);\nvec4 LinearSRGBToLinearDisplayP3( in vec4 value ) {\n\treturn vec4( value.rgb * LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, value.a );\n}\nvec4 LinearDisplayP3ToLinearSRGB( in vec4 value ) {\n\treturn vec4( value.rgb * LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, value.a );\n}\nvec4 LinearTransferOETF( in vec4 value ) {\n\treturn value;\n}\nvec4 sRGBTransferOETF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn sRGBTransferOETF( value );\n}";
+
+var envmap_fragment = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif";
+
+var envmap_common_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif";
+
+var envmap_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif";
+
+var envmap_pars_vertex = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif";
+
+var envmap_vertex = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif";
+
+var fog_vertex = "#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif";
+
+var fog_pars_vertex = "#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif";
+
+var fog_fragment = "#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif";
+
+var fog_pars_fragment = "#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif";
+
+var gradientmap_pars_fragment = "#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\tvec2 fw = fwidth( coord ) * 0.5;\n\t\treturn mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\n\t#endif\n}";
+
+var lightmap_fragment = "#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\treflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif";
+
+var lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif";
+
+var lights_lambert_fragment = "LambertMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularStrength = specularStrength;";
+
+var lights_lambert_pars_fragment = "varying vec3 vViewPosition;\nstruct LambertMaterial {\n\tvec3 diffuseColor;\n\tfloat specularStrength;\n};\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Lambert\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Lambert";
+
+var lights_pars_begin = "uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\n#if defined( USE_LIGHT_PROBES )\n\tuniform vec3 lightProbe[ 9 ];\n#endif\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\t#if defined ( LEGACY_LIGHTS )\n\t\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\t\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t\t}\n\t\treturn 1.0;\n\t#else\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tif ( cutoffDistance > 0.0 ) {\n\t\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\t}\n\t\treturn distanceFalloff;\n\t#endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif";
+
+var envmap_physical_pars_fragment = "#ifdef USE_ENVMAP\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\t#ifdef USE_ANISOTROPY\n\t\tvec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\n\t\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\t\tvec3 bentNormal = cross( bitangent, viewDir );\n\t\t\t\tbentNormal = normalize( cross( bentNormal, bitangent ) );\n\t\t\t\tbentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\n\t\t\t\treturn getIBLRadiance( viewDir, bentNormal, roughness );\n\t\t\t#else\n\t\t\t\treturn vec3( 0.0 );\n\t\t\t#endif\n\t\t}\n\t#endif\n#endif";
+
+var lights_toon_fragment = "ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;";
+
+var lights_toon_pars_fragment = "varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon";
+
+var lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;";
+
+var lights_phong_pars_fragment = "varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong";
+
+var lights_physical_fragment = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\tmaterial.ior = ior;\n\t#ifdef USE_SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULAR_COLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\n\t\t#endif\n\t\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_IRIDESCENCE\n\tmaterial.iridescence = iridescence;\n\tmaterial.iridescenceIOR = iridescenceIOR;\n\t#ifdef USE_IRIDESCENCEMAP\n\t\tmaterial.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\n\t#endif\n\t#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\t\tmaterial.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\n\t#else\n\t\tmaterial.iridescenceThickness = iridescenceThicknessMaximum;\n\t#endif\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\t#ifdef USE_ANISOTROPYMAP\n\t\tmat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\n\t\tvec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\n\t\tvec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\n\t#else\n\t\tvec2 anisotropyV = anisotropyVector;\n\t#endif\n\tmaterial.anisotropy = length( anisotropyV );\n\tif( material.anisotropy == 0.0 ) {\n\t\tanisotropyV = vec2( 1.0, 0.0 );\n\t} else {\n\t\tanisotropyV /= material.anisotropy;\n\t\tmaterial.anisotropy = saturate( material.anisotropy );\n\t}\n\tmaterial.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\n\tmaterial.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;\n\tmaterial.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;\n#endif";
+
+var lights_physical_pars_fragment = "struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_IRIDESCENCE\n\t\tfloat iridescence;\n\t\tfloat iridescenceIOR;\n\t\tfloat iridescenceThickness;\n\t\tvec3 iridescenceFresnel;\n\t\tvec3 iridescenceF0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n\t#ifdef IOR\n\t\tfloat ior;\n\t#endif\n\t#ifdef USE_TRANSMISSION\n\t\tfloat transmission;\n\t\tfloat transmissionAlpha;\n\t\tfloat thickness;\n\t\tfloat attenuationDistance;\n\t\tvec3 attenuationColor;\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat anisotropy;\n\t\tfloat alphaT;\n\t\tvec3 anisotropyT;\n\t\tvec3 anisotropyB;\n\t#endif\n};\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\nvec3 sheenSpecularDirect = vec3( 0.0 );\nvec3 sheenSpecularIndirect = vec3(0.0 );\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\n    float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\n    float x2 = x * x;\n    float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\n    return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\n#ifdef USE_ANISOTROPY\n\tfloat V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\n\t\tfloat gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\n\t\tfloat gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\n\t\tfloat v = 0.5 / ( gv + gl );\n\t\treturn saturate(v);\n\t}\n\tfloat D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\n\t\tfloat a2 = alphaT * alphaB;\n\t\thighp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\n\t\thighp float v2 = dot( v, v );\n\t\tfloat w2 = a2 / v2;\n\t\treturn RECIPROCAL_PI * a2 * pow2 ( w2 );\n\t}\n#endif\n#ifdef USE_CLEARCOAT\n\tvec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\n\t\tvec3 f0 = material.clearcoatF0;\n\t\tfloat f90 = material.clearcoatF90;\n\t\tfloat roughness = material.clearcoatRoughness;\n\t\tfloat alpha = pow2( roughness );\n\t\tvec3 halfDir = normalize( lightDir + viewDir );\n\t\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\t\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\t\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\t\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\t\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t\treturn F * ( V * D );\n\t}\n#endif\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n\tvec3 f0 = material.specularColor;\n\tfloat f90 = material.specularF90;\n\tfloat roughness = material.roughness;\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t#ifdef USE_IRIDESCENCE\n\t\tF = mix( F, material.iridescenceFresnel, material.iridescence );\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat dotTL = dot( material.anisotropyT, lightDir );\n\t\tfloat dotTV = dot( material.anisotropyT, viewDir );\n\t\tfloat dotTH = dot( material.anisotropyT, halfDir );\n\t\tfloat dotBL = dot( material.anisotropyB, lightDir );\n\t\tfloat dotBV = dot( material.anisotropyB, viewDir );\n\t\tfloat dotBH = dot( material.anisotropyB, halfDir );\n\t\tfloat V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\n\t\tfloat D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\n\t#else\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t#endif\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\n#ifdef USE_IRIDESCENCE\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#else\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#endif\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\t#ifdef USE_IRIDESCENCE\n\t\tvec3 Fr = mix( specularColor, iridescenceF0, iridescence );\n\t#else\n\t\tvec3 Fr = specularColor;\n\t#endif\n\tvec3 FssEss = Fr * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometryNormal;\n\t\tvec3 viewDir = geometryViewDir;\n\t\tvec3 position = geometryPosition;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\t#ifdef USE_IRIDESCENCE\n\t\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );\n\t#else\n\t\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\t#endif\n\tvec3 totalScattering = singleScattering + multiScattering;\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}";
+
+var lights_fragment_begin = "\nvec3 geometryPosition = - vViewPosition;\nvec3 geometryNormal = normal;\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\nvec3 geometryClearcoatNormal = vec3( 0.0 );\n#ifdef USE_CLEARCOAT\n\tgeometryClearcoatNormal = clearcoatNormal;\n#endif\n#ifdef USE_IRIDESCENCE\n\tfloat dotNVi = saturate( dot( normal, geometryViewDir ) );\n\tif ( material.iridescenceThickness == 0.0 ) {\n\t\tmaterial.iridescence = 0.0;\n\t} else {\n\t\tmaterial.iridescence = saturate( material.iridescence );\n\t}\n\tif ( material.iridescence > 0.0 ) {\n\t\tmaterial.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\n\t\tmaterial.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\n\t}\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometryPosition, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\tvec4 spotColor;\n\tvec3 spotLightCoord;\n\tbool inSpotLightMap;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometryPosition, directLight );\n\t\t#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\n\t\t#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\n\t\t#else\n\t\t#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#endif\n\t\t#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\n\t\t\tspotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\n\t\t\tinSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\n\t\t\tspotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\n\t\t\tdirectLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\n\t\t#endif\n\t\t#undef SPOT_LIGHT_MAP_INDEX\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#if defined( USE_LIGHT_PROBES )\n\t\tirradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif";
+
+var lights_fragment_maps = "#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometryNormal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\t#ifdef USE_ANISOTROPY\n\t\tradiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\n\t#else\n\t\tradiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif";
+
+var lights_fragment_end = "#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif";
+
+var logdepthbuf_fragment = "#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif";
+
+var logdepthbuf_pars_fragment = "#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif";
+
+var logdepthbuf_pars_vertex = "#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif";
+
+var logdepthbuf_vertex = "#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif";
+
+var map_fragment = "#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n\t\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif";
+
+var map_pars_fragment = "#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif";
+
+var map_particle_fragment = "#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t#if defined( USE_POINTS_UV )\n\t\tvec2 uv = vUv;\n\t#else\n\t\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif";
+
+var map_particle_pars_fragment = "#if defined( USE_POINTS_UV )\n\tvarying vec2 vUv;\n#else\n\t#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t\tuniform mat3 uvTransform;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";
+
+var metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif";
+
+var metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif";
+
+var morphcolor_vertex = "#if defined( USE_MORPHCOLORS ) && defined( MORPHTARGETS_TEXTURE )\n\tvColor *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t#if defined( USE_COLOR_ALPHA )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\n\t\t#elif defined( USE_COLOR )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\n\t\t#endif\n\t}\n#endif";
+
+var morphnormal_vertex = "#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\t\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\t\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\t\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n\t#endif\n#endif";
+
+var morphtarget_pars_vertex = "#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t\tuniform sampler2DArray morphTargetsTexture;\n\t\tuniform ivec2 morphTargetsTextureSize;\n\t\tvec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\n\t\t\tint texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\n\t\t\tint y = texelIndex / morphTargetsTextureSize.x;\n\t\t\tint x = texelIndex - y * morphTargetsTextureSize.x;\n\t\t\tivec3 morphUV = ivec3( x, y, morphTargetIndex );\n\t\t\treturn texelFetch( morphTargetsTexture, morphUV, 0 );\n\t\t}\n\t#else\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\tuniform float morphTargetInfluences[ 8 ];\n\t\t#else\n\t\t\tuniform float morphTargetInfluences[ 4 ];\n\t\t#endif\n\t#endif\n#endif";
+
+var morphtarget_vertex = "#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\t\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\t\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\t\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t\t#endif\n\t#endif\n#endif";
+
+var normal_fragment_begin = "float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = dFdx( vViewPosition );\n\tvec3 fdy = dFdy( vViewPosition );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal *= faceDirection;\n\t#endif\n#endif\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn = getTangentFrame( - vViewPosition, normal,\n\t\t#if defined( USE_NORMALMAP )\n\t\t\tvNormalMapUv\n\t\t#elif defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tvClearcoatNormalMapUv\n\t\t#else\n\t\t\tvUv\n\t\t#endif\n\t\t);\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn[0] *= faceDirection;\n\t\ttbn[1] *= faceDirection;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn2[0] *= faceDirection;\n\t\ttbn2[1] *= faceDirection;\n\t#endif\n#endif\nvec3 nonPerturbedNormal = normal;";
+
+var normal_fragment_maps = "#ifdef USE_NORMALMAP_OBJECTSPACE\n\tnormal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\n\tvec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\tnormal = normalize( tbn * mapN );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif";
+
+var normal_pars_fragment = "#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif";
+
+var normal_pars_vertex = "#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif";
+
+var normal_vertex = "#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif";
+
+var normalmap_pars_fragment = "#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef USE_NORMALMAP_OBJECTSPACE\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\n\tmat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\n\t\tvec3 q0 = dFdx( eye_pos.xyz );\n\t\tvec3 q1 = dFdy( eye_pos.xyz );\n\t\tvec2 st0 = dFdx( uv.st );\n\t\tvec2 st1 = dFdy( uv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\n\t\treturn mat3( T * scale, B * scale, N );\n\t}\n#endif";
+
+var clearcoat_normal_fragment_begin = "#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = nonPerturbedNormal;\n#endif";
+
+var clearcoat_normal_fragment_maps = "#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\tclearcoatNormal = normalize( tbn2 * clearcoatMapN );\n#endif";
+
+var clearcoat_pars_fragment = "#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif";
+
+var iridescence_pars_fragment = "#ifdef USE_IRIDESCENCEMAP\n\tuniform sampler2D iridescenceMap;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform sampler2D iridescenceThicknessMap;\n#endif";
+
+var opaque_fragment = "#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= material.transmissionAlpha;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );";
+
+var packing = "vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec2 packDepthToRG( in highp float v ) {\n\treturn packDepthToRGBA( v ).yx;\n}\nfloat unpackRGToDepth( const in highp vec2 v ) {\n\treturn unpackRGBAToDepth( vec4( v.xy, 0.0, 0.0 ) );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn depth * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * depth - far );\n}";
+
+var premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif";
+
+var project_vertex = "vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_BATCHING\n\tmvPosition = batchingMatrix * mvPosition;\n#endif\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;";
+
+var dithering_fragment = "#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif";
+
+var dithering_pars_fragment = "#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif";
+
+var roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\n\troughnessFactor *= texelRoughness.g;\n#endif";
+
+var roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif";
+
+var shadowmap_pars_fragment = "#if NUM_SPOT_LIGHT_COORDS > 0\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#if NUM_SPOT_LIGHT_MAPS > 0\n\tuniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif";
+
+var shadowmap_pars_vertex = "#if NUM_SPOT_LIGHT_COORDS > 0\n\tuniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif";
+
+var shadowmap_vertex = "#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\n\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\tvec4 shadowWorldPosition;\n#endif\n#if defined( USE_SHADOWMAP )\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if NUM_SPOT_LIGHT_COORDS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition;\n\t\t#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t\tshadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\n\t\t#endif\n\t\tvSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n#endif";
+
+var shadowmask_pars_fragment = "float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}";
+
+var skinbase_vertex = "#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";
+
+var skinning_pars_vertex = "#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\tuniform highp sampler2D boneTexture;\n\tmat4 getBoneMatrix( const in float i ) {\n\t\tint size = textureSize( boneTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n#endif";
+
+var skinning_vertex = "#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif";
+
+var skinnormal_vertex = "#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif";
+
+var specularmap_fragment = "float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif";
+
+var specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif";
+
+var tonemapping_fragment = "#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif";
+
+var tonemapping_pars_fragment = "#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn saturate( toneMappingExposure * color );\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\n\tvec3( 1.6605, - 0.1246, - 0.0182 ),\n\tvec3( - 0.5876, 1.1329, - 0.1006 ),\n\tvec3( - 0.0728, - 0.0083, 1.1187 )\n);\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\n\tvec3( 0.6274, 0.0691, 0.0164 ),\n\tvec3( 0.3293, 0.9195, 0.0880 ),\n\tvec3( 0.0433, 0.0113, 0.8956 )\n);\nvec3 agxDefaultContrastApprox( vec3 x ) {\n\tvec3 x2 = x * x;\n\tvec3 x4 = x2 * x2;\n\treturn + 15.5 * x4 * x2\n\t\t- 40.14 * x4 * x\n\t\t+ 31.96 * x4\n\t\t- 6.868 * x2 * x\n\t\t+ 0.4298 * x2\n\t\t+ 0.1191 * x\n\t\t- 0.00232;\n}\nvec3 AgXToneMapping( vec3 color ) {\n\tconst mat3 AgXInsetMatrix = mat3(\n\t\tvec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),\n\t\tvec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),\n\t\tvec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )\n\t);\n\tconst mat3 AgXOutsetMatrix = mat3(\n\t\tvec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),\n\t\tvec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),\n\t\tvec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )\n\t);\n\tconst float AgxMinEv = - 12.47393;\tconst float AgxMaxEv = 4.026069;\n\tcolor = LINEAR_SRGB_TO_LINEAR_REC2020 * color;\n\tcolor *= toneMappingExposure;\n\tcolor = AgXInsetMatrix * color;\n\tcolor = max( color, 1e-10 );\tcolor = log2( color );\n\tcolor = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );\n\tcolor = clamp( color, 0.0, 1.0 );\n\tcolor = agxDefaultContrastApprox( color );\n\tcolor = AgXOutsetMatrix * color;\n\tcolor = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );\n\tcolor = LINEAR_REC2020_TO_LINEAR_SRGB * color;\n\treturn color;\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }";
+
+var transmission_fragment = "#ifdef USE_TRANSMISSION\n\tmaterial.transmission = transmission;\n\tmaterial.transmissionAlpha = 1.0;\n\tmaterial.thickness = thickness;\n\tmaterial.attenuationDistance = attenuationDistance;\n\tmaterial.attenuationColor = attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tmaterial.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tmaterial.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmitted = getIBLVolumeRefraction(\n\t\tn, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness,\n\t\tmaterial.attenuationColor, material.attenuationDistance );\n\tmaterial.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\n\ttotalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\n#endif";
+
+var transmission_pars_fragment = "#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tfloat w0( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\n\t}\n\tfloat w1( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a *  a * ( 3.0 * a - 6.0 ) + 4.0 );\n\t}\n\tfloat w2( float a ){\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\n\t}\n\tfloat w3( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * a );\n\t}\n\tfloat g0( float a ) {\n\t\treturn w0( a ) + w1( a );\n\t}\n\tfloat g1( float a ) {\n\t\treturn w2( a ) + w3( a );\n\t}\n\tfloat h0( float a ) {\n\t\treturn - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\n\t}\n\tfloat h1( float a ) {\n\t\treturn 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\n\t}\n\tvec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\n\t\tuv = uv * texelSize.zw + 0.5;\n\t\tvec2 iuv = floor( uv );\n\t\tvec2 fuv = fract( uv );\n\t\tfloat g0x = g0( fuv.x );\n\t\tfloat g1x = g1( fuv.x );\n\t\tfloat h0x = h0( fuv.x );\n\t\tfloat h1x = h1( fuv.x );\n\t\tfloat h0y = h0( fuv.y );\n\t\tfloat h1y = h1( fuv.y );\n\t\tvec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\treturn g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\n\t\t\tg1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\n\t}\n\tvec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\n\t\tvec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\n\t\tvec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\n\t\tvec2 fLodSizeInv = 1.0 / fLodSize;\n\t\tvec2 cLodSizeInv = 1.0 / cLodSize;\n\t\tvec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\n\t\tvec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\n\t\treturn mix( fSample, cSample, fract( lod ) );\n\t}\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\treturn textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\n\t}\n\tvec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( isinf( attenuationDistance ) ) {\n\t\t\treturn vec3( 1.0 );\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\trefractionCoords += 1.0;\n\t\trefractionCoords /= 2.0;\n\t\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\tvec3 transmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\tvec3 attenuatedColor = transmittance * transmittedLight.rgb;\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\tfloat transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\n\t}\n#endif";
+
+var uv_pars_fragment = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif";
+
+var uv_pars_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tuniform mat3 mapTransform;\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform mat3 alphaMapTransform;\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tuniform mat3 lightMapTransform;\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tuniform mat3 aoMapTransform;\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tuniform mat3 bumpMapTransform;\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tuniform mat3 normalMapTransform;\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tuniform mat3 displacementMapTransform;\n\tvarying vec2 vDisplacementMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tuniform mat3 emissiveMapTransform;\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tuniform mat3 metalnessMapTransform;\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tuniform mat3 roughnessMapTransform;\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tuniform mat3 anisotropyMapTransform;\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tuniform mat3 clearcoatMapTransform;\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform mat3 clearcoatNormalMapTransform;\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform mat3 clearcoatRoughnessMapTransform;\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tuniform mat3 sheenColorMapTransform;\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tuniform mat3 sheenRoughnessMapTransform;\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tuniform mat3 iridescenceMapTransform;\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform mat3 iridescenceThicknessMapTransform;\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tuniform mat3 specularMapTransform;\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tuniform mat3 specularColorMapTransform;\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tuniform mat3 specularIntensityMapTransform;\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif";
+
+var uv_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvUv = vec3( uv, 1 ).xy;\n#endif\n#ifdef USE_MAP\n\tvMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ALPHAMAP\n\tvAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_LIGHTMAP\n\tvLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_AOMAP\n\tvAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_BUMPMAP\n\tvBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_NORMALMAP\n\tvNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tvDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_METALNESSMAP\n\tvMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULARMAP\n\tvSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tvTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_THICKNESSMAP\n\tvThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\n#endif";
+
+var worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_BATCHING\n\t\tworldPosition = batchingMatrix * worldPosition;\n\t#endif\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif";
+
+const vertex$h = "varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}";
+
+const fragment$h = "uniform sampler2D t2D;\nuniform float backgroundIntensity;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\ttexColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
+
+const vertex$g = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";
+
+const fragment$g = "#ifdef ENVMAP_TYPE_CUBE\n\tuniform samplerCube envMap;\n#elif defined( ENVMAP_TYPE_CUBE_UV )\n\tuniform sampler2D envMap;\n#endif\nuniform float flipEnvMap;\nuniform float backgroundBlurriness;\nuniform float backgroundIntensity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 texColor = textureCube( envMap, vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 texColor = textureCubeUV( envMap, vWorldDirection, backgroundBlurriness );\n\t#else\n\t\tvec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
+
+const vertex$f = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";
+
+const fragment$f = "uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor = texColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
+
+const vertex$e = "#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}";
+
+const fragment$e = "#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}";
+
+const vertex$d = "#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}";
+
+const fragment$d = "#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}";
+
+const vertex$c = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}";
+
+const fragment$c = "uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
+
+const vertex$b = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$b = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";
+
+const vertex$a = "#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$a = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
+
+const vertex$9 = "#define LAMBERT\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$9 = "#define LAMBERT\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_lambert_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_lambert_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
+
+const vertex$8 = "#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}";
+
+const fragment$8 = "#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
+
+const vertex$7 = "#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}";
+
+const fragment$7 = "#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n\t#ifdef OPAQUE\n\t\tgl_FragColor.a = 1.0;\n\t#endif\n}";
+
+const vertex$6 = "#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$6 = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
+
+const vertex$5 = "#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}";
+
+const fragment$5 = "#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\tuniform vec2 anisotropyVector;\n\t#ifdef USE_ANISOTROPYMAP\n\t\tuniform sampler2D anisotropyMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <iridescence_fragment>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <iridescence_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n\t#endif\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
+
+const vertex$4 = "#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$4 = "#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
+
+const vertex$3 = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n#ifdef USE_POINTS_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif\nvoid main() {\n\t#ifdef USE_POINTS_UV\n\t\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\t#endif\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$3 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";
+
+const vertex$2 = "#include <common>\n#include <batching_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$2 = "uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <logdepthbuf_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\t#include <logdepthbuf_fragment>\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
+
+const vertex$1 = "uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
+
+const fragment$1 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
+
+const ShaderChunk = {
+	alphahash_fragment: alphahash_fragment,
+	alphahash_pars_fragment: alphahash_pars_fragment,
+	alphamap_fragment: alphamap_fragment,
+	alphamap_pars_fragment: alphamap_pars_fragment,
+	alphatest_fragment: alphatest_fragment,
+	alphatest_pars_fragment: alphatest_pars_fragment,
+	aomap_fragment: aomap_fragment,
+	aomap_pars_fragment: aomap_pars_fragment,
+	batching_pars_vertex: batching_pars_vertex,
+	batching_vertex: batching_vertex,
+	begin_vertex: begin_vertex,
+	beginnormal_vertex: beginnormal_vertex,
+	bsdfs: bsdfs,
+	iridescence_fragment: iridescence_fragment,
+	bumpmap_pars_fragment: bumpmap_pars_fragment,
+	clipping_planes_fragment: clipping_planes_fragment,
+	clipping_planes_pars_fragment: clipping_planes_pars_fragment,
+	clipping_planes_pars_vertex: clipping_planes_pars_vertex,
+	clipping_planes_vertex: clipping_planes_vertex,
+	color_fragment: color_fragment,
+	color_pars_fragment: color_pars_fragment,
+	color_pars_vertex: color_pars_vertex,
+	color_vertex: color_vertex,
+	common: common,
+	cube_uv_reflection_fragment: cube_uv_reflection_fragment,
+	defaultnormal_vertex: defaultnormal_vertex,
+	displacementmap_pars_vertex: displacementmap_pars_vertex,
+	displacementmap_vertex: displacementmap_vertex,
+	emissivemap_fragment: emissivemap_fragment,
+	emissivemap_pars_fragment: emissivemap_pars_fragment,
+	colorspace_fragment: colorspace_fragment,
+	colorspace_pars_fragment: colorspace_pars_fragment,
+	envmap_fragment: envmap_fragment,
+	envmap_common_pars_fragment: envmap_common_pars_fragment,
+	envmap_pars_fragment: envmap_pars_fragment,
+	envmap_pars_vertex: envmap_pars_vertex,
+	envmap_physical_pars_fragment: envmap_physical_pars_fragment,
+	envmap_vertex: envmap_vertex,
+	fog_vertex: fog_vertex,
+	fog_pars_vertex: fog_pars_vertex,
+	fog_fragment: fog_fragment,
+	fog_pars_fragment: fog_pars_fragment,
+	gradientmap_pars_fragment: gradientmap_pars_fragment,
+	lightmap_fragment: lightmap_fragment,
+	lightmap_pars_fragment: lightmap_pars_fragment,
+	lights_lambert_fragment: lights_lambert_fragment,
+	lights_lambert_pars_fragment: lights_lambert_pars_fragment,
+	lights_pars_begin: lights_pars_begin,
+	lights_toon_fragment: lights_toon_fragment,
+	lights_toon_pars_fragment: lights_toon_pars_fragment,
+	lights_phong_fragment: lights_phong_fragment,
+	lights_phong_pars_fragment: lights_phong_pars_fragment,
+	lights_physical_fragment: lights_physical_fragment,
+	lights_physical_pars_fragment: lights_physical_pars_fragment,
+	lights_fragment_begin: lights_fragment_begin,
+	lights_fragment_maps: lights_fragment_maps,
+	lights_fragment_end: lights_fragment_end,
+	logdepthbuf_fragment: logdepthbuf_fragment,
+	logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
+	logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
+	logdepthbuf_vertex: logdepthbuf_vertex,
+	map_fragment: map_fragment,
+	map_pars_fragment: map_pars_fragment,
+	map_particle_fragment: map_particle_fragment,
+	map_particle_pars_fragment: map_particle_pars_fragment,
+	metalnessmap_fragment: metalnessmap_fragment,
+	metalnessmap_pars_fragment: metalnessmap_pars_fragment,
+	morphcolor_vertex: morphcolor_vertex,
+	morphnormal_vertex: morphnormal_vertex,
+	morphtarget_pars_vertex: morphtarget_pars_vertex,
+	morphtarget_vertex: morphtarget_vertex,
+	normal_fragment_begin: normal_fragment_begin,
+	normal_fragment_maps: normal_fragment_maps,
+	normal_pars_fragment: normal_pars_fragment,
+	normal_pars_vertex: normal_pars_vertex,
+	normal_vertex: normal_vertex,
+	normalmap_pars_fragment: normalmap_pars_fragment,
+	clearcoat_normal_fragment_begin: clearcoat_normal_fragment_begin,
+	clearcoat_normal_fragment_maps: clearcoat_normal_fragment_maps,
+	clearcoat_pars_fragment: clearcoat_pars_fragment,
+	iridescence_pars_fragment: iridescence_pars_fragment,
+	opaque_fragment: opaque_fragment,
+	packing: packing,
+	premultiplied_alpha_fragment: premultiplied_alpha_fragment,
+	project_vertex: project_vertex,
+	dithering_fragment: dithering_fragment,
+	dithering_pars_fragment: dithering_pars_fragment,
+	roughnessmap_fragment: roughnessmap_fragment,
+	roughnessmap_pars_fragment: roughnessmap_pars_fragment,
+	shadowmap_pars_fragment: shadowmap_pars_fragment,
+	shadowmap_pars_vertex: shadowmap_pars_vertex,
+	shadowmap_vertex: shadowmap_vertex,
+	shadowmask_pars_fragment: shadowmask_pars_fragment,
+	skinbase_vertex: skinbase_vertex,
+	skinning_pars_vertex: skinning_pars_vertex,
+	skinning_vertex: skinning_vertex,
+	skinnormal_vertex: skinnormal_vertex,
+	specularmap_fragment: specularmap_fragment,
+	specularmap_pars_fragment: specularmap_pars_fragment,
+	tonemapping_fragment: tonemapping_fragment,
+	tonemapping_pars_fragment: tonemapping_pars_fragment,
+	transmission_fragment: transmission_fragment,
+	transmission_pars_fragment: transmission_pars_fragment,
+	uv_pars_fragment: uv_pars_fragment,
+	uv_pars_vertex: uv_pars_vertex,
+	uv_vertex: uv_vertex,
+	worldpos_vertex: worldpos_vertex,
+
+	background_vert: vertex$h,
+	background_frag: fragment$h,
+	backgroundCube_vert: vertex$g,
+	backgroundCube_frag: fragment$g,
+	cube_vert: vertex$f,
+	cube_frag: fragment$f,
+	depth_vert: vertex$e,
+	depth_frag: fragment$e,
+	distanceRGBA_vert: vertex$d,
+	distanceRGBA_frag: fragment$d,
+	equirect_vert: vertex$c,
+	equirect_frag: fragment$c,
+	linedashed_vert: vertex$b,
+	linedashed_frag: fragment$b,
+	meshbasic_vert: vertex$a,
+	meshbasic_frag: fragment$a,
+	meshlambert_vert: vertex$9,
+	meshlambert_frag: fragment$9,
+	meshmatcap_vert: vertex$8,
+	meshmatcap_frag: fragment$8,
+	meshnormal_vert: vertex$7,
+	meshnormal_frag: fragment$7,
+	meshphong_vert: vertex$6,
+	meshphong_frag: fragment$6,
+	meshphysical_vert: vertex$5,
+	meshphysical_frag: fragment$5,
+	meshtoon_vert: vertex$4,
+	meshtoon_frag: fragment$4,
+	points_vert: vertex$3,
+	points_frag: fragment$3,
+	shadow_vert: vertex$2,
+	shadow_frag: fragment$2,
+	sprite_vert: vertex$1,
+	sprite_frag: fragment$1
+};
+
+/**
+ * Uniforms library for shared webgl shaders
+ */
+
+const UniformsLib = {
+
+	common: {
+
+		diffuse: { value: /*@__PURE__*/ new Color( 0xffffff ) },
+		opacity: { value: 1.0 },
+
+		map: { value: null },
+		mapTransform: { value: /*@__PURE__*/ new Matrix3() },
+
+		alphaMap: { value: null },
+		alphaMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+
+		alphaTest: { value: 0 }
+
+	},
+
+	specularmap: {
+
+		specularMap: { value: null },
+		specularMapTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	envmap: {
+
+		envMap: { value: null },
+		flipEnvMap: { value: - 1 },
+		reflectivity: { value: 1.0 }, // basic, lambert, phong
+		ior: { value: 1.5 }, // physical
+		refractionRatio: { value: 0.98 }, // basic, lambert, phong
+
+	},
+
+	aomap: {
+
+		aoMap: { value: null },
+		aoMapIntensity: { value: 1 },
+		aoMapTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	lightmap: {
+
+		lightMap: { value: null },
+		lightMapIntensity: { value: 1 },
+		lightMapTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	bumpmap: {
+
+		bumpMap: { value: null },
+		bumpMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		bumpScale: { value: 1 }
+
+	},
+
+	normalmap: {
+
+		normalMap: { value: null },
+		normalMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		normalScale: { value: /*@__PURE__*/ new Vector2( 1, 1 ) }
+
+	},
+
+	displacementmap: {
+
+		displacementMap: { value: null },
+		displacementMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		displacementScale: { value: 1 },
+		displacementBias: { value: 0 }
+
+	},
+
+	emissivemap: {
+
+		emissiveMap: { value: null },
+		emissiveMapTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	metalnessmap: {
+
+		metalnessMap: { value: null },
+		metalnessMapTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	roughnessmap: {
+
+		roughnessMap: { value: null },
+		roughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	gradientmap: {
+
+		gradientMap: { value: null }
+
+	},
+
+	fog: {
+
+		fogDensity: { value: 0.00025 },
+		fogNear: { value: 1 },
+		fogFar: { value: 2000 },
+		fogColor: { value: /*@__PURE__*/ new Color( 0xffffff ) }
+
+	},
+
+	lights: {
+
+		ambientLightColor: { value: [] },
+
+		lightProbe: { value: [] },
+
+		directionalLights: { value: [], properties: {
+			direction: {},
+			color: {}
+		} },
+
+		directionalLightShadows: { value: [], properties: {
+			shadowBias: {},
+			shadowNormalBias: {},
+			shadowRadius: {},
+			shadowMapSize: {}
+		} },
+
+		directionalShadowMap: { value: [] },
+		directionalShadowMatrix: { value: [] },
+
+		spotLights: { value: [], properties: {
+			color: {},
+			position: {},
+			direction: {},
+			distance: {},
+			coneCos: {},
+			penumbraCos: {},
+			decay: {}
+		} },
+
+		spotLightShadows: { value: [], properties: {
+			shadowBias: {},
+			shadowNormalBias: {},
+			shadowRadius: {},
+			shadowMapSize: {}
+		} },
+
+		spotLightMap: { value: [] },
+		spotShadowMap: { value: [] },
+		spotLightMatrix: { value: [] },
+
+		pointLights: { value: [], properties: {
+			color: {},
+			position: {},
+			decay: {},
+			distance: {}
+		} },
+
+		pointLightShadows: { value: [], properties: {
+			shadowBias: {},
+			shadowNormalBias: {},
+			shadowRadius: {},
+			shadowMapSize: {},
+			shadowCameraNear: {},
+			shadowCameraFar: {}
+		} },
+
+		pointShadowMap: { value: [] },
+		pointShadowMatrix: { value: [] },
+
+		hemisphereLights: { value: [], properties: {
+			direction: {},
+			skyColor: {},
+			groundColor: {}
+		} },
+
+		// TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
+		rectAreaLights: { value: [], properties: {
+			color: {},
+			position: {},
+			width: {},
+			height: {}
+		} },
+
+		ltc_1: { value: null },
+		ltc_2: { value: null }
+
+	},
+
+	points: {
+
+		diffuse: { value: /*@__PURE__*/ new Color( 0xffffff ) },
+		opacity: { value: 1.0 },
+		size: { value: 1.0 },
+		scale: { value: 1.0 },
+		map: { value: null },
+		alphaMap: { value: null },
+		alphaMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		alphaTest: { value: 0 },
+		uvTransform: { value: /*@__PURE__*/ new Matrix3() }
+
+	},
+
+	sprite: {
+
+		diffuse: { value: /*@__PURE__*/ new Color( 0xffffff ) },
+		opacity: { value: 1.0 },
+		center: { value: /*@__PURE__*/ new Vector2( 0.5, 0.5 ) },
+		rotation: { value: 0.0 },
+		map: { value: null },
+		mapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		alphaMap: { value: null },
+		alphaMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		alphaTest: { value: 0 }
+
+	}
+
+};
+
+const ShaderLib = {
+
+	basic: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.specularmap,
+			UniformsLib.envmap,
+			UniformsLib.aomap,
+			UniformsLib.lightmap,
+			UniformsLib.fog
+		] ),
+
+		vertexShader: ShaderChunk.meshbasic_vert,
+		fragmentShader: ShaderChunk.meshbasic_frag
+
+	},
+
+	lambert: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.specularmap,
+			UniformsLib.envmap,
+			UniformsLib.aomap,
+			UniformsLib.lightmap,
+			UniformsLib.emissivemap,
+			UniformsLib.bumpmap,
+			UniformsLib.normalmap,
+			UniformsLib.displacementmap,
+			UniformsLib.fog,
+			UniformsLib.lights,
+			{
+				emissive: { value: /*@__PURE__*/ new Color( 0x000000 ) }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.meshlambert_vert,
+		fragmentShader: ShaderChunk.meshlambert_frag
+
+	},
+
+	phong: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.specularmap,
+			UniformsLib.envmap,
+			UniformsLib.aomap,
+			UniformsLib.lightmap,
+			UniformsLib.emissivemap,
+			UniformsLib.bumpmap,
+			UniformsLib.normalmap,
+			UniformsLib.displacementmap,
+			UniformsLib.fog,
+			UniformsLib.lights,
+			{
+				emissive: { value: /*@__PURE__*/ new Color( 0x000000 ) },
+				specular: { value: /*@__PURE__*/ new Color( 0x111111 ) },
+				shininess: { value: 30 }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.meshphong_vert,
+		fragmentShader: ShaderChunk.meshphong_frag
+
+	},
+
+	standard: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.envmap,
+			UniformsLib.aomap,
+			UniformsLib.lightmap,
+			UniformsLib.emissivemap,
+			UniformsLib.bumpmap,
+			UniformsLib.normalmap,
+			UniformsLib.displacementmap,
+			UniformsLib.roughnessmap,
+			UniformsLib.metalnessmap,
+			UniformsLib.fog,
+			UniformsLib.lights,
+			{
+				emissive: { value: /*@__PURE__*/ new Color( 0x000000 ) },
+				roughness: { value: 1.0 },
+				metalness: { value: 0.0 },
+				envMapIntensity: { value: 1 } // temporary
+			}
+		] ),
+
+		vertexShader: ShaderChunk.meshphysical_vert,
+		fragmentShader: ShaderChunk.meshphysical_frag
+
+	},
+
+	toon: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.aomap,
+			UniformsLib.lightmap,
+			UniformsLib.emissivemap,
+			UniformsLib.bumpmap,
+			UniformsLib.normalmap,
+			UniformsLib.displacementmap,
+			UniformsLib.gradientmap,
+			UniformsLib.fog,
+			UniformsLib.lights,
+			{
+				emissive: { value: /*@__PURE__*/ new Color( 0x000000 ) }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.meshtoon_vert,
+		fragmentShader: ShaderChunk.meshtoon_frag
+
+	},
+
+	matcap: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.bumpmap,
+			UniformsLib.normalmap,
+			UniformsLib.displacementmap,
+			UniformsLib.fog,
+			{
+				matcap: { value: null }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.meshmatcap_vert,
+		fragmentShader: ShaderChunk.meshmatcap_frag
+
+	},
+
+	points: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.points,
+			UniformsLib.fog
+		] ),
+
+		vertexShader: ShaderChunk.points_vert,
+		fragmentShader: ShaderChunk.points_frag
+
+	},
+
+	dashed: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.fog,
+			{
+				scale: { value: 1 },
+				dashSize: { value: 1 },
+				totalSize: { value: 2 }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.linedashed_vert,
+		fragmentShader: ShaderChunk.linedashed_frag
+
+	},
+
+	depth: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.displacementmap
+		] ),
+
+		vertexShader: ShaderChunk.depth_vert,
+		fragmentShader: ShaderChunk.depth_frag
+
+	},
+
+	normal: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.bumpmap,
+			UniformsLib.normalmap,
+			UniformsLib.displacementmap,
+			{
+				opacity: { value: 1.0 }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.meshnormal_vert,
+		fragmentShader: ShaderChunk.meshnormal_frag
+
+	},
+
+	sprite: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.sprite,
+			UniformsLib.fog
+		] ),
+
+		vertexShader: ShaderChunk.sprite_vert,
+		fragmentShader: ShaderChunk.sprite_frag
+
+	},
+
+	background: {
+
+		uniforms: {
+			uvTransform: { value: /*@__PURE__*/ new Matrix3() },
+			t2D: { value: null },
+			backgroundIntensity: { value: 1 }
+		},
+
+		vertexShader: ShaderChunk.background_vert,
+		fragmentShader: ShaderChunk.background_frag
+
+	},
+
+	backgroundCube: {
+
+		uniforms: {
+			envMap: { value: null },
+			flipEnvMap: { value: - 1 },
+			backgroundBlurriness: { value: 0 },
+			backgroundIntensity: { value: 1 }
+		},
+
+		vertexShader: ShaderChunk.backgroundCube_vert,
+		fragmentShader: ShaderChunk.backgroundCube_frag
+
+	},
+
+	cube: {
+
+		uniforms: {
+			tCube: { value: null },
+			tFlip: { value: - 1 },
+			opacity: { value: 1.0 }
+		},
+
+		vertexShader: ShaderChunk.cube_vert,
+		fragmentShader: ShaderChunk.cube_frag
+
+	},
+
+	equirect: {
+
+		uniforms: {
+			tEquirect: { value: null },
+		},
+
+		vertexShader: ShaderChunk.equirect_vert,
+		fragmentShader: ShaderChunk.equirect_frag
+
+	},
+
+	distanceRGBA: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.common,
+			UniformsLib.displacementmap,
+			{
+				referencePosition: { value: /*@__PURE__*/ new Vector3() },
+				nearDistance: { value: 1 },
+				farDistance: { value: 1000 }
+			}
+		] ),
+
+		vertexShader: ShaderChunk.distanceRGBA_vert,
+		fragmentShader: ShaderChunk.distanceRGBA_frag
+
+	},
+
+	shadow: {
+
+		uniforms: /*@__PURE__*/ mergeUniforms( [
+			UniformsLib.lights,
+			UniformsLib.fog,
+			{
+				color: { value: /*@__PURE__*/ new Color( 0x00000 ) },
+				opacity: { value: 1.0 }
+			},
+		] ),
+
+		vertexShader: ShaderChunk.shadow_vert,
+		fragmentShader: ShaderChunk.shadow_frag
+
+	}
+
+};
+
+ShaderLib.physical = {
+
+	uniforms: /*@__PURE__*/ mergeUniforms( [
+		ShaderLib.standard.uniforms,
+		{
+			clearcoat: { value: 0 },
+			clearcoatMap: { value: null },
+			clearcoatMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			clearcoatNormalMap: { value: null },
+			clearcoatNormalMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			clearcoatNormalScale: { value: /*@__PURE__*/ new Vector2( 1, 1 ) },
+			clearcoatRoughness: { value: 0 },
+			clearcoatRoughnessMap: { value: null },
+			clearcoatRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			iridescence: { value: 0 },
+			iridescenceMap: { value: null },
+			iridescenceMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			iridescenceIOR: { value: 1.3 },
+			iridescenceThicknessMinimum: { value: 100 },
+			iridescenceThicknessMaximum: { value: 400 },
+			iridescenceThicknessMap: { value: null },
+			iridescenceThicknessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			sheen: { value: 0 },
+			sheenColor: { value: /*@__PURE__*/ new Color( 0x000000 ) },
+			sheenColorMap: { value: null },
+			sheenColorMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			sheenRoughness: { value: 1 },
+			sheenRoughnessMap: { value: null },
+			sheenRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			transmission: { value: 0 },
+			transmissionMap: { value: null },
+			transmissionMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			transmissionSamplerSize: { value: /*@__PURE__*/ new Vector2() },
+			transmissionSamplerMap: { value: null },
+			thickness: { value: 0 },
+			thicknessMap: { value: null },
+			thicknessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			attenuationDistance: { value: 0 },
+			attenuationColor: { value: /*@__PURE__*/ new Color( 0x000000 ) },
+			specularColor: { value: /*@__PURE__*/ new Color( 1, 1, 1 ) },
+			specularColorMap: { value: null },
+			specularColorMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			specularIntensity: { value: 1 },
+			specularIntensityMap: { value: null },
+			specularIntensityMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			anisotropyVector: { value: /*@__PURE__*/ new Vector2() },
+			anisotropyMap: { value: null },
+			anisotropyMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+		}
+	] ),
+
+	vertexShader: ShaderChunk.meshphysical_vert,
+	fragmentShader: ShaderChunk.meshphysical_frag
+
+};
+
+const _rgb = { r: 0, b: 0, g: 0 };
+
+function WebGLBackground( renderer, cubemaps, cubeuvmaps, state, objects, alpha, premultipliedAlpha ) {
+
+	const clearColor = new Color( 0x000000 );
+	let clearAlpha = alpha === true ? 0 : 1;
+
+	let planeMesh;
+	let boxMesh;
+
+	let currentBackground = null;
+	let currentBackgroundVersion = 0;
+	let currentTonemapping = null;
+
+	function render( renderList, scene ) {
+
+		let forceClear = false;
+		let background = scene.isScene === true ? scene.background : null;
+
+		if ( background && background.isTexture ) {
+
+			const usePMREM = scene.backgroundBlurriness > 0; // use PMREM if the user wants to blur the background
+			background = ( usePMREM ? cubeuvmaps : cubemaps ).get( background );
+
+		}
+
+		if ( background === null ) {
+
+			setClear( clearColor, clearAlpha );
+
+		} else if ( background && background.isColor ) {
+
+			setClear( background, 1 );
+			forceClear = true;
+
+		}
+
+		const environmentBlendMode = renderer.xr.getEnvironmentBlendMode();
+
+		if ( environmentBlendMode === 'additive' ) {
+
+			state.buffers.color.setClear( 0, 0, 0, 1, premultipliedAlpha );
+
+		} else if ( environmentBlendMode === 'alpha-blend' ) {
+
+			state.buffers.color.setClear( 0, 0, 0, 0, premultipliedAlpha );
+
+		}
+
+		if ( renderer.autoClear || forceClear ) {
+
+			renderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );
+
+		}
+
+		if ( background && ( background.isCubeTexture || background.mapping === CubeUVReflectionMapping ) ) {
+
+			if ( boxMesh === undefined ) {
+
+				boxMesh = new Mesh(
+					new BoxGeometry( 1, 1, 1 ),
+					new ShaderMaterial( {
+						name: 'BackgroundCubeMaterial',
+						uniforms: cloneUniforms( ShaderLib.backgroundCube.uniforms ),
+						vertexShader: ShaderLib.backgroundCube.vertexShader,
+						fragmentShader: ShaderLib.backgroundCube.fragmentShader,
+						side: BackSide,
+						depthTest: false,
+						depthWrite: false,
+						fog: false
+					} )
+				);
+
+				boxMesh.geometry.deleteAttribute( 'normal' );
+				boxMesh.geometry.deleteAttribute( 'uv' );
+
+				boxMesh.onBeforeRender = function ( renderer, scene, camera ) {
+
+					this.matrixWorld.copyPosition( camera.matrixWorld );
+
+				};
+
+				// add "envMap" material property so the renderer can evaluate it like for built-in materials
+				Object.defineProperty( boxMesh.material, 'envMap', {
+
+					get: function () {
+
+						return this.uniforms.envMap.value;
+
+					}
+
+				} );
+
+				objects.update( boxMesh );
+
+			}
+
+			boxMesh.material.uniforms.envMap.value = background;
+			boxMesh.material.uniforms.flipEnvMap.value = ( background.isCubeTexture && background.isRenderTargetTexture === false ) ? - 1 : 1;
+			boxMesh.material.uniforms.backgroundBlurriness.value = scene.backgroundBlurriness;
+			boxMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;
+			boxMesh.material.toneMapped = ColorManagement.getTransfer( background.colorSpace ) !== SRGBTransfer;
+
+			if ( currentBackground !== background ||
+				currentBackgroundVersion !== background.version ||
+				currentTonemapping !== renderer.toneMapping ) {
+
+				boxMesh.material.needsUpdate = true;
+
+				currentBackground = background;
+				currentBackgroundVersion = background.version;
+				currentTonemapping = renderer.toneMapping;
+
+			}
+
+			boxMesh.layers.enableAll();
+
+			// push to the pre-sorted opaque render list
+			renderList.unshift( boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null );
+
+		} else if ( background && background.isTexture ) {
+
+			if ( planeMesh === undefined ) {
+
+				planeMesh = new Mesh(
+					new PlaneGeometry( 2, 2 ),
+					new ShaderMaterial( {
+						name: 'BackgroundMaterial',
+						uniforms: cloneUniforms( ShaderLib.background.uniforms ),
+						vertexShader: ShaderLib.background.vertexShader,
+						fragmentShader: ShaderLib.background.fragmentShader,
+						side: FrontSide,
+						depthTest: false,
+						depthWrite: false,
+						fog: false
+					} )
+				);
+
+				planeMesh.geometry.deleteAttribute( 'normal' );
+
+				// add "map" material property so the renderer can evaluate it like for built-in materials
+				Object.defineProperty( planeMesh.material, 'map', {
+
+					get: function () {
+
+						return this.uniforms.t2D.value;
+
+					}
+
+				} );
+
+				objects.update( planeMesh );
+
+			}
+
+			planeMesh.material.uniforms.t2D.value = background;
+			planeMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;
+			planeMesh.material.toneMapped = ColorManagement.getTransfer( background.colorSpace ) !== SRGBTransfer;
+
+			if ( background.matrixAutoUpdate === true ) {
+
+				background.updateMatrix();
+
+			}
+
+			planeMesh.material.uniforms.uvTransform.value.copy( background.matrix );
+
+			if ( currentBackground !== background ||
+				currentBackgroundVersion !== background.version ||
+				currentTonemapping !== renderer.toneMapping ) {
+
+				planeMesh.material.needsUpdate = true;
+
+				currentBackground = background;
+				currentBackgroundVersion = background.version;
+				currentTonemapping = renderer.toneMapping;
+
+			}
+
+			planeMesh.layers.enableAll();
+
+			// push to the pre-sorted opaque render list
+			renderList.unshift( planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null );
+
+		}
+
+	}
+
+	function setClear( color, alpha ) {
+
+		color.getRGB( _rgb, getUnlitUniformColorSpace( renderer ) );
+
+		state.buffers.color.setClear( _rgb.r, _rgb.g, _rgb.b, alpha, premultipliedAlpha );
+
+	}
+
+	return {
+
+		getClearColor: function () {
+
+			return clearColor;
+
+		},
+		setClearColor: function ( color, alpha = 1 ) {
+
+			clearColor.set( color );
+			clearAlpha = alpha;
+			setClear( clearColor, clearAlpha );
+
+		},
+		getClearAlpha: function () {
+
+			return clearAlpha;
+
+		},
+		setClearAlpha: function ( alpha ) {
+
+			clearAlpha = alpha;
+			setClear( clearColor, clearAlpha );
+
+		},
+		render: render
+
+	};
+
+}
+
+function WebGLBindingStates( gl, extensions, attributes, capabilities ) {
+
+	const maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );
+
+	const extension = capabilities.isWebGL2 ? null : extensions.get( 'OES_vertex_array_object' );
+	const vaoAvailable = capabilities.isWebGL2 || extension !== null;
+
+	const bindingStates = {};
+
+	const defaultState = createBindingState( null );
+	let currentState = defaultState;
+	let forceUpdate = false;
+
+	function setup( object, material, program, geometry, index ) {
+
+		let updateBuffers = false;
+
+		if ( vaoAvailable ) {
+
+			const state = getBindingState( geometry, program, material );
+
+			if ( currentState !== state ) {
+
+				currentState = state;
+				bindVertexArrayObject( currentState.object );
+
+			}
+
+			updateBuffers = needsUpdate( object, geometry, program, index );
+
+			if ( updateBuffers ) saveCache( object, geometry, program, index );
+
+		} else {
+
+			const wireframe = ( material.wireframe === true );
+
+			if ( currentState.geometry !== geometry.id ||
+				currentState.program !== program.id ||
+				currentState.wireframe !== wireframe ) {
+
+				currentState.geometry = geometry.id;
+				currentState.program = program.id;
+				currentState.wireframe = wireframe;
+
+				updateBuffers = true;
+
+			}
+
+		}
+
+		if ( index !== null ) {
+
+			attributes.update( index, gl.ELEMENT_ARRAY_BUFFER );
+
+		}
+
+		if ( updateBuffers || forceUpdate ) {
+
+			forceUpdate = false;
+
+			setupVertexAttributes( object, material, program, geometry );
+
+			if ( index !== null ) {
+
+				gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, attributes.get( index ).buffer );
+
+			}
+
+		}
+
+	}
+
+	function createVertexArrayObject() {
+
+		if ( capabilities.isWebGL2 ) return gl.createVertexArray();
+
+		return extension.createVertexArrayOES();
+
+	}
+
+	function bindVertexArrayObject( vao ) {
+
+		if ( capabilities.isWebGL2 ) return gl.bindVertexArray( vao );
+
+		return extension.bindVertexArrayOES( vao );
+
+	}
+
+	function deleteVertexArrayObject( vao ) {
+
+		if ( capabilities.isWebGL2 ) return gl.deleteVertexArray( vao );
+
+		return extension.deleteVertexArrayOES( vao );
+
+	}
+
+	function getBindingState( geometry, program, material ) {
+
+		const wireframe = ( material.wireframe === true );
+
+		let programMap = bindingStates[ geometry.id ];
+
+		if ( programMap === undefined ) {
+
+			programMap = {};
+			bindingStates[ geometry.id ] = programMap;
+
+		}
+
+		let stateMap = programMap[ program.id ];
+
+		if ( stateMap === undefined ) {
+
+			stateMap = {};
+			programMap[ program.id ] = stateMap;
+
+		}
+
+		let state = stateMap[ wireframe ];
+
+		if ( state === undefined ) {
+
+			state = createBindingState( createVertexArrayObject() );
+			stateMap[ wireframe ] = state;
+
+		}
+
+		return state;
+
+	}
+
+	function createBindingState( vao ) {
+
+		const newAttributes = [];
+		const enabledAttributes = [];
+		const attributeDivisors = [];
+
+		for ( let i = 0; i < maxVertexAttributes; i ++ ) {
+
+			newAttributes[ i ] = 0;
+			enabledAttributes[ i ] = 0;
+			attributeDivisors[ i ] = 0;
+
+		}
+
+		return {
+
+			// for backward compatibility on non-VAO support browser
+			geometry: null,
+			program: null,
+			wireframe: false,
+
+			newAttributes: newAttributes,
+			enabledAttributes: enabledAttributes,
+			attributeDivisors: attributeDivisors,
+			object: vao,
+			attributes: {},
+			index: null
+
+		};
+
+	}
+
+	function needsUpdate( object, geometry, program, index ) {
+
+		const cachedAttributes = currentState.attributes;
+		const geometryAttributes = geometry.attributes;
+
+		let attributesNum = 0;
+
+		const programAttributes = program.getAttributes();
+
+		for ( const name in programAttributes ) {
+
+			const programAttribute = programAttributes[ name ];
+
+			if ( programAttribute.location >= 0 ) {
+
+				const cachedAttribute = cachedAttributes[ name ];
+				let geometryAttribute = geometryAttributes[ name ];
+
+				if ( geometryAttribute === undefined ) {
+
+					if ( name === 'instanceMatrix' && object.instanceMatrix ) geometryAttribute = object.instanceMatrix;
+					if ( name === 'instanceColor' && object.instanceColor ) geometryAttribute = object.instanceColor;
+
+				}
+
+				if ( cachedAttribute === undefined ) return true;
+
+				if ( cachedAttribute.attribute !== geometryAttribute ) return true;
+
+				if ( geometryAttribute && cachedAttribute.data !== geometryAttribute.data ) return true;
+
+				attributesNum ++;
+
+			}
+
+		}
+
+		if ( currentState.attributesNum !== attributesNum ) return true;
+
+		if ( currentState.index !== index ) return true;
+
+		return false;
+
+	}
+
+	function saveCache( object, geometry, program, index ) {
+
+		const cache = {};
+		const attributes = geometry.attributes;
+		let attributesNum = 0;
+
+		const programAttributes = program.getAttributes();
+
+		for ( const name in programAttributes ) {
+
+			const programAttribute = programAttributes[ name ];
+
+			if ( programAttribute.location >= 0 ) {
+
+				let attribute = attributes[ name ];
+
+				if ( attribute === undefined ) {
+
+					if ( name === 'instanceMatrix' && object.instanceMatrix ) attribute = object.instanceMatrix;
+					if ( name === 'instanceColor' && object.instanceColor ) attribute = object.instanceColor;
+
+				}
+
+				const data = {};
+				data.attribute = attribute;
+
+				if ( attribute && attribute.data ) {
+
+					data.data = attribute.data;
+
+				}
+
+				cache[ name ] = data;
+
+				attributesNum ++;
+
+			}
+
+		}
+
+		currentState.attributes = cache;
+		currentState.attributesNum = attributesNum;
+
+		currentState.index = index;
+
+	}
+
+	function initAttributes() {
+
+		const newAttributes = currentState.newAttributes;
+
+		for ( let i = 0, il = newAttributes.length; i < il; i ++ ) {
+
+			newAttributes[ i ] = 0;
+
+		}
+
+	}
+
+	function enableAttribute( attribute ) {
+
+		enableAttributeAndDivisor( attribute, 0 );
+
+	}
+
+	function enableAttributeAndDivisor( attribute, meshPerAttribute ) {
+
+		const newAttributes = currentState.newAttributes;
+		const enabledAttributes = currentState.enabledAttributes;
+		const attributeDivisors = currentState.attributeDivisors;
+
+		newAttributes[ attribute ] = 1;
+
+		if ( enabledAttributes[ attribute ] === 0 ) {
+
+			gl.enableVertexAttribArray( attribute );
+			enabledAttributes[ attribute ] = 1;
+
+		}
+
+		if ( attributeDivisors[ attribute ] !== meshPerAttribute ) {
+
+			const extension = capabilities.isWebGL2 ? gl : extensions.get( 'ANGLE_instanced_arrays' );
+
+			extension[ capabilities.isWebGL2 ? 'vertexAttribDivisor' : 'vertexAttribDivisorANGLE' ]( attribute, meshPerAttribute );
+			attributeDivisors[ attribute ] = meshPerAttribute;
+
+		}
+
+	}
+
+	function disableUnusedAttributes() {
+
+		const newAttributes = currentState.newAttributes;
+		const enabledAttributes = currentState.enabledAttributes;
+
+		for ( let i = 0, il = enabledAttributes.length; i < il; i ++ ) {
+
+			if ( enabledAttributes[ i ] !== newAttributes[ i ] ) {
+
+				gl.disableVertexAttribArray( i );
+				enabledAttributes[ i ] = 0;
+
+			}
+
+		}
+
+	}
+
+	function vertexAttribPointer( index, size, type, normalized, stride, offset, integer ) {
+
+		if ( integer === true ) {
+
+			gl.vertexAttribIPointer( index, size, type, stride, offset );
+
+		} else {
+
+			gl.vertexAttribPointer( index, size, type, normalized, stride, offset );
+
+		}
+
+	}
+
+	function setupVertexAttributes( object, material, program, geometry ) {
+
+		if ( capabilities.isWebGL2 === false && ( object.isInstancedMesh || geometry.isInstancedBufferGeometry ) ) {
+
+			if ( extensions.get( 'ANGLE_instanced_arrays' ) === null ) return;
+
+		}
+
+		initAttributes();
+
+		const geometryAttributes = geometry.attributes;
+
+		const programAttributes = program.getAttributes();
+
+		const materialDefaultAttributeValues = material.defaultAttributeValues;
+
+		for ( const name in programAttributes ) {
+
+			const programAttribute = programAttributes[ name ];
+
+			if ( programAttribute.location >= 0 ) {
+
+				let geometryAttribute = geometryAttributes[ name ];
+
+				if ( geometryAttribute === undefined ) {
+
+					if ( name === 'instanceMatrix' && object.instanceMatrix ) geometryAttribute = object.instanceMatrix;
+					if ( name === 'instanceColor' && object.instanceColor ) geometryAttribute = object.instanceColor;
+
+				}
+
+				if ( geometryAttribute !== undefined ) {
+
+					const normalized = geometryAttribute.normalized;
+					const size = geometryAttribute.itemSize;
+
+					const attribute = attributes.get( geometryAttribute );
+
+					// TODO Attribute may not be available on context restore
+
+					if ( attribute === undefined ) continue;
+
+					const buffer = attribute.buffer;
+					const type = attribute.type;
+					const bytesPerElement = attribute.bytesPerElement;
+
+					// check for integer attributes (WebGL 2 only)
+
+					const integer = ( capabilities.isWebGL2 === true && ( type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType ) );
+
+					if ( geometryAttribute.isInterleavedBufferAttribute ) {
+
+						const data = geometryAttribute.data;
+						const stride = data.stride;
+						const offset = geometryAttribute.offset;
+
+						if ( data.isInstancedInterleavedBuffer ) {
+
+							for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
+
+								enableAttributeAndDivisor( programAttribute.location + i, data.meshPerAttribute );
+
+							}
+
+							if ( object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined ) {
+
+								geometry._maxInstanceCount = data.meshPerAttribute * data.count;
+
+							}
+
+						} else {
+
+							for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
+
+								enableAttribute( programAttribute.location + i );
+
+							}
+
+						}
+
+						gl.bindBuffer( gl.ARRAY_BUFFER, buffer );
+
+						for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
+
+							vertexAttribPointer(
+								programAttribute.location + i,
+								size / programAttribute.locationSize,
+								type,
+								normalized,
+								stride * bytesPerElement,
+								( offset + ( size / programAttribute.locationSize ) * i ) * bytesPerElement,
+								integer
+							);
+
+						}
+
+					} else {
+
+						if ( geometryAttribute.isInstancedBufferAttribute ) {
+
+							for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
+
+								enableAttributeAndDivisor( programAttribute.location + i, geometryAttribute.meshPerAttribute );
+
+							}
+
+							if ( object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined ) {
+
+								geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
+
+							}
+
+						} else {
+
+							for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
+
+								enableAttribute( programAttribute.location + i );
+
+							}
+
+						}
+
+						gl.bindBuffer( gl.ARRAY_BUFFER, buffer );
+
+						for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
+
+							vertexAttribPointer(
+								programAttribute.location + i,
+								size / programAttribute.locationSize,
+								type,
+								normalized,
+								size * bytesPerElement,
+								( size / programAttribute.locationSize ) * i * bytesPerElement,
+								integer
+							);
+
+						}
+
+					}
+
+				} else if ( materialDefaultAttributeValues !== undefined ) {
+
+					const value = materialDefaultAttributeValues[ name ];
+
+					if ( value !== undefined ) {
+
+						switch ( value.length ) {
+
+							case 2:
+								gl.vertexAttrib2fv( programAttribute.location, value );
+								break;
+
+							case 3:
+								gl.vertexAttrib3fv( programAttribute.location, value );
+								break;
+
+							case 4:
+								gl.vertexAttrib4fv( programAttribute.location, value );
+								break;
+
+							default:
+								gl.vertexAttrib1fv( programAttribute.location, value );
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		disableUnusedAttributes();
+
+	}
+
+	function dispose() {
+
+		reset();
+
+		for ( const geometryId in bindingStates ) {
+
+			const programMap = bindingStates[ geometryId ];
+
+			for ( const programId in programMap ) {
+
+				const stateMap = programMap[ programId ];
+
+				for ( const wireframe in stateMap ) {
+
+					deleteVertexArrayObject( stateMap[ wireframe ].object );
+
+					delete stateMap[ wireframe ];
+
+				}
+
+				delete programMap[ programId ];
+
+			}
+
+			delete bindingStates[ geometryId ];
+
+		}
+
+	}
+
+	function releaseStatesOfGeometry( geometry ) {
+
+		if ( bindingStates[ geometry.id ] === undefined ) return;
+
+		const programMap = bindingStates[ geometry.id ];
+
+		for ( const programId in programMap ) {
+
+			const stateMap = programMap[ programId ];
+
+			for ( const wireframe in stateMap ) {
+
+				deleteVertexArrayObject( stateMap[ wireframe ].object );
+
+				delete stateMap[ wireframe ];
+
+			}
+
+			delete programMap[ programId ];
+
+		}
+
+		delete bindingStates[ geometry.id ];
+
+	}
+
+	function releaseStatesOfProgram( program ) {
+
+		for ( const geometryId in bindingStates ) {
+
+			const programMap = bindingStates[ geometryId ];
+
+			if ( programMap[ program.id ] === undefined ) continue;
+
+			const stateMap = programMap[ program.id ];
+
+			for ( const wireframe in stateMap ) {
+
+				deleteVertexArrayObject( stateMap[ wireframe ].object );
+
+				delete stateMap[ wireframe ];
+
+			}
+
+			delete programMap[ program.id ];
+
+		}
+
+	}
+
+	function reset() {
+
+		resetDefaultState();
+		forceUpdate = true;
+
+		if ( currentState === defaultState ) return;
+
+		currentState = defaultState;
+		bindVertexArrayObject( currentState.object );
+
+	}
+
+	// for backward-compatibility
+
+	function resetDefaultState() {
+
+		defaultState.geometry = null;
+		defaultState.program = null;
+		defaultState.wireframe = false;
+
+	}
+
+	return {
+
+		setup: setup,
+		reset: reset,
+		resetDefaultState: resetDefaultState,
+		dispose: dispose,
+		releaseStatesOfGeometry: releaseStatesOfGeometry,
+		releaseStatesOfProgram: releaseStatesOfProgram,
+
+		initAttributes: initAttributes,
+		enableAttribute: enableAttribute,
+		disableUnusedAttributes: disableUnusedAttributes
+
+	};
+
+}
+
+function WebGLBufferRenderer( gl, extensions, info, capabilities ) {
+
+	const isWebGL2 = capabilities.isWebGL2;
+
+	let mode;
+
+	function setMode( value ) {
+
+		mode = value;
+
+	}
+
+	function render( start, count ) {
+
+		gl.drawArrays( mode, start, count );
+
+		info.update( count, mode, 1 );
+
+	}
+
+	function renderInstances( start, count, primcount ) {
+
+		if ( primcount === 0 ) return;
+
+		let extension, methodName;
+
+		if ( isWebGL2 ) {
+
+			extension = gl;
+			methodName = 'drawArraysInstanced';
+
+		} else {
+
+			extension = extensions.get( 'ANGLE_instanced_arrays' );
+			methodName = 'drawArraysInstancedANGLE';
+
+			if ( extension === null ) {
+
+				console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
+				return;
+
+			}
+
+		}
+
+		extension[ methodName ]( mode, start, count, primcount );
+
+		info.update( count, mode, primcount );
+
+	}
+
+	function renderMultiDraw( starts, counts, drawCount ) {
+
+		if ( drawCount === 0 ) return;
+
+		const extension = extensions.get( 'WEBGL_multi_draw' );
+		if ( extension === null ) {
+
+			for ( let i = 0; i < drawCount; i ++ ) {
+
+				this.render( starts[ i ], counts[ i ] );
+
+			}
+
+		} else {
+
+			extension.multiDrawArraysWEBGL( mode, starts, 0, counts, 0, drawCount );
+
+			let elementCount = 0;
+			for ( let i = 0; i < drawCount; i ++ ) {
+
+				elementCount += counts[ i ];
+
+			}
+
+			info.update( elementCount, mode, 1 );
+
+		}
+
+	}
+
+	//
+
+	this.setMode = setMode;
+	this.render = render;
+	this.renderInstances = renderInstances;
+	this.renderMultiDraw = renderMultiDraw;
+
+}
+
+function WebGLCapabilities( gl, extensions, parameters ) {
+
+	let maxAnisotropy;
+
+	function getMaxAnisotropy() {
+
+		if ( maxAnisotropy !== undefined ) return maxAnisotropy;
+
+		if ( extensions.has( 'EXT_texture_filter_anisotropic' ) === true ) {
+
+			const extension = extensions.get( 'EXT_texture_filter_anisotropic' );
+
+			maxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );
+
+		} else {
+
+			maxAnisotropy = 0;
+
+		}
+
+		return maxAnisotropy;
+
+	}
+
+	function getMaxPrecision( precision ) {
+
+		if ( precision === 'highp' ) {
+
+			if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 &&
+				gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) {
+
+				return 'highp';
+
+			}
+
+			precision = 'mediump';
+
+		}
+
+		if ( precision === 'mediump' ) {
+
+			if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 &&
+				gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) {
+
+				return 'mediump';
+
+			}
+
+		}
+
+		return 'lowp';
+
+	}
+
+	const isWebGL2 = typeof WebGL2RenderingContext !== 'undefined' && gl.constructor.name === 'WebGL2RenderingContext';
+
+	let precision = parameters.precision !== undefined ? parameters.precision : 'highp';
+	const maxPrecision = getMaxPrecision( precision );
+
+	if ( maxPrecision !== precision ) {
+
+		console.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' );
+		precision = maxPrecision;
+
+	}
+
+	const drawBuffers = isWebGL2 || extensions.has( 'WEBGL_draw_buffers' );
+
+	const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;
+
+	const maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
+	const maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );
+	const maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );
+	const maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE );
+
+	const maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );
+	const maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS );
+	const maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS );
+	const maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS );
+
+	const vertexTextures = maxVertexTextures > 0;
+	const floatFragmentTextures = isWebGL2 || extensions.has( 'OES_texture_float' );
+	const floatVertexTextures = vertexTextures && floatFragmentTextures;
+
+	const maxSamples = isWebGL2 ? gl.getParameter( gl.MAX_SAMPLES ) : 0;
+
+	return {
+
+		isWebGL2: isWebGL2,
+
+		drawBuffers: drawBuffers,
+
+		getMaxAnisotropy: getMaxAnisotropy,
+		getMaxPrecision: getMaxPrecision,
+
+		precision: precision,
+		logarithmicDepthBuffer: logarithmicDepthBuffer,
+
+		maxTextures: maxTextures,
+		maxVertexTextures: maxVertexTextures,
+		maxTextureSize: maxTextureSize,
+		maxCubemapSize: maxCubemapSize,
+
+		maxAttributes: maxAttributes,
+		maxVertexUniforms: maxVertexUniforms,
+		maxVaryings: maxVaryings,
+		maxFragmentUniforms: maxFragmentUniforms,
+
+		vertexTextures: vertexTextures,
+		floatFragmentTextures: floatFragmentTextures,
+		floatVertexTextures: floatVertexTextures,
+
+		maxSamples: maxSamples
+
+	};
+
+}
+
+function WebGLClipping( properties ) {
+
+	const scope = this;
+
+	let globalState = null,
+		numGlobalPlanes = 0,
+		localClippingEnabled = false,
+		renderingShadows = false;
+
+	const plane = new Plane(),
+		viewNormalMatrix = new Matrix3(),
+
+		uniform = { value: null, needsUpdate: false };
+
+	this.uniform = uniform;
+	this.numPlanes = 0;
+	this.numIntersection = 0;
+
+	this.init = function ( planes, enableLocalClipping ) {
+
+		const enabled =
+			planes.length !== 0 ||
+			enableLocalClipping ||
+			// enable state of previous frame - the clipping code has to
+			// run another frame in order to reset the state:
+			numGlobalPlanes !== 0 ||
+			localClippingEnabled;
+
+		localClippingEnabled = enableLocalClipping;
+
+		numGlobalPlanes = planes.length;
+
+		return enabled;
+
+	};
+
+	this.beginShadows = function () {
+
+		renderingShadows = true;
+		projectPlanes( null );
+
+	};
+
+	this.endShadows = function () {
+
+		renderingShadows = false;
+
+	};
+
+	this.setGlobalState = function ( planes, camera ) {
+
+		globalState = projectPlanes( planes, camera, 0 );
+
+	};
+
+	this.setState = function ( material, camera, useCache ) {
+
+		const planes = material.clippingPlanes,
+			clipIntersection = material.clipIntersection,
+			clipShadows = material.clipShadows;
+
+		const materialProperties = properties.get( material );
+
+		if ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) {
+
+			// there's no local clipping
+
+			if ( renderingShadows ) {
+
+				// there's no global clipping
+
+				projectPlanes( null );
+
+			} else {
+
+				resetGlobalState();
+
+			}
+
+		} else {
+
+			const nGlobal = renderingShadows ? 0 : numGlobalPlanes,
+				lGlobal = nGlobal * 4;
+
+			let dstArray = materialProperties.clippingState || null;
+
+			uniform.value = dstArray; // ensure unique state
+
+			dstArray = projectPlanes( planes, camera, lGlobal, useCache );
+
+			for ( let i = 0; i !== lGlobal; ++ i ) {
+
+				dstArray[ i ] = globalState[ i ];
+
+			}
+
+			materialProperties.clippingState = dstArray;
+			this.numIntersection = clipIntersection ? this.numPlanes : 0;
+			this.numPlanes += nGlobal;
+
+		}
+
+
+	};
+
+	function resetGlobalState() {
+
+		if ( uniform.value !== globalState ) {
+
+			uniform.value = globalState;
+			uniform.needsUpdate = numGlobalPlanes > 0;
+
+		}
+
+		scope.numPlanes = numGlobalPlanes;
+		scope.numIntersection = 0;
+
+	}
+
+	function projectPlanes( planes, camera, dstOffset, skipTransform ) {
+
+		const nPlanes = planes !== null ? planes.length : 0;
+		let dstArray = null;
+
+		if ( nPlanes !== 0 ) {
+
+			dstArray = uniform.value;
+
+			if ( skipTransform !== true || dstArray === null ) {
+
+				const flatSize = dstOffset + nPlanes * 4,
+					viewMatrix = camera.matrixWorldInverse;
+
+				viewNormalMatrix.getNormalMatrix( viewMatrix );
+
+				if ( dstArray === null || dstArray.length < flatSize ) {
+
+					dstArray = new Float32Array( flatSize );
+
+				}
+
+				for ( let i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {
+
+					plane.copy( planes[ i ] ).applyMatrix4( viewMatrix, viewNormalMatrix );
+
+					plane.normal.toArray( dstArray, i4 );
+					dstArray[ i4 + 3 ] = plane.constant;
+
+				}
+
+			}
+
+			uniform.value = dstArray;
+			uniform.needsUpdate = true;
+
+		}
+
+		scope.numPlanes = nPlanes;
+		scope.numIntersection = 0;
+
+		return dstArray;
+
+	}
+
+}
+
+function WebGLCubeMaps( renderer ) {
+
+	let cubemaps = new WeakMap();
+
+	function mapTextureMapping( texture, mapping ) {
+
+		if ( mapping === EquirectangularReflectionMapping ) {
+
+			texture.mapping = CubeReflectionMapping;
+
+		} else if ( mapping === EquirectangularRefractionMapping ) {
+
+			texture.mapping = CubeRefractionMapping;
+
+		}
+
+		return texture;
+
+	}
+
+	function get( texture ) {
+
+		if ( texture && texture.isTexture ) {
+
+			const mapping = texture.mapping;
+
+			if ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping ) {
+
+				if ( cubemaps.has( texture ) ) {
+
+					const cubemap = cubemaps.get( texture ).texture;
+					return mapTextureMapping( cubemap, texture.mapping );
+
+				} else {
+
+					const image = texture.image;
+
+					if ( image && image.height > 0 ) {
+
+						const renderTarget = new WebGLCubeRenderTarget( image.height / 2 );
+						renderTarget.fromEquirectangularTexture( renderer, texture );
+						cubemaps.set( texture, renderTarget );
+
+						texture.addEventListener( 'dispose', onTextureDispose );
+
+						return mapTextureMapping( renderTarget.texture, texture.mapping );
+
+					} else {
+
+						// image not yet ready. try the conversion next frame
+
+						return null;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		return texture;
+
+	}
+
+	function onTextureDispose( event ) {
+
+		const texture = event.target;
+
+		texture.removeEventListener( 'dispose', onTextureDispose );
+
+		const cubemap = cubemaps.get( texture );
+
+		if ( cubemap !== undefined ) {
+
+			cubemaps.delete( texture );
+			cubemap.dispose();
+
+		}
+
+	}
+
+	function dispose() {
+
+		cubemaps = new WeakMap();
+
+	}
+
+	return {
+		get: get,
+		dispose: dispose
+	};
+
+}
+
+class OrthographicCamera extends Camera {
+
+	constructor( left = - 1, right = 1, top = 1, bottom = - 1, near = 0.1, far = 2000 ) {
+
+		super();
+
+		this.isOrthographicCamera = true;
+
+		this.type = 'OrthographicCamera';
+
+		this.zoom = 1;
+		this.view = null;
+
+		this.left = left;
+		this.right = right;
+		this.top = top;
+		this.bottom = bottom;
+
+		this.near = near;
+		this.far = far;
+
+		this.updateProjectionMatrix();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.left = source.left;
+		this.right = source.right;
+		this.top = source.top;
+		this.bottom = source.bottom;
+		this.near = source.near;
+		this.far = source.far;
+
+		this.zoom = source.zoom;
+		this.view = source.view === null ? null : Object.assign( {}, source.view );
+
+		return this;
+
+	}
+
+	setViewOffset( fullWidth, fullHeight, x, y, width, height ) {
+
+		if ( this.view === null ) {
+
+			this.view = {
+				enabled: true,
+				fullWidth: 1,
+				fullHeight: 1,
+				offsetX: 0,
+				offsetY: 0,
+				width: 1,
+				height: 1
+			};
+
+		}
+
+		this.view.enabled = true;
+		this.view.fullWidth = fullWidth;
+		this.view.fullHeight = fullHeight;
+		this.view.offsetX = x;
+		this.view.offsetY = y;
+		this.view.width = width;
+		this.view.height = height;
+
+		this.updateProjectionMatrix();
+
+	}
+
+	clearViewOffset() {
+
+		if ( this.view !== null ) {
+
+			this.view.enabled = false;
+
+		}
+
+		this.updateProjectionMatrix();
+
+	}
+
+	updateProjectionMatrix() {
+
+		const dx = ( this.right - this.left ) / ( 2 * this.zoom );
+		const dy = ( this.top - this.bottom ) / ( 2 * this.zoom );
+		const cx = ( this.right + this.left ) / 2;
+		const cy = ( this.top + this.bottom ) / 2;
+
+		let left = cx - dx;
+		let right = cx + dx;
+		let top = cy + dy;
+		let bottom = cy - dy;
+
+		if ( this.view !== null && this.view.enabled ) {
+
+			const scaleW = ( this.right - this.left ) / this.view.fullWidth / this.zoom;
+			const scaleH = ( this.top - this.bottom ) / this.view.fullHeight / this.zoom;
+
+			left += scaleW * this.view.offsetX;
+			right = left + scaleW * this.view.width;
+			top -= scaleH * this.view.offsetY;
+			bottom = top - scaleH * this.view.height;
+
+		}
+
+		this.projectionMatrix.makeOrthographic( left, right, top, bottom, this.near, this.far, this.coordinateSystem );
+
+		this.projectionMatrixInverse.copy( this.projectionMatrix ).invert();
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		data.object.zoom = this.zoom;
+		data.object.left = this.left;
+		data.object.right = this.right;
+		data.object.top = this.top;
+		data.object.bottom = this.bottom;
+		data.object.near = this.near;
+		data.object.far = this.far;
+
+		if ( this.view !== null ) data.object.view = Object.assign( {}, this.view );
+
+		return data;
+
+	}
+
+}
+
+const LOD_MIN = 4;
+
+// The standard deviations (radians) associated with the extra mips. These are
+// chosen to approximate a Trowbridge-Reitz distribution function times the
+// geometric shadowing function. These sigma values squared must match the
+// variance #defines in cube_uv_reflection_fragment.glsl.js.
+const EXTRA_LOD_SIGMA = [ 0.125, 0.215, 0.35, 0.446, 0.526, 0.582 ];
+
+// The maximum length of the blur for loop. Smaller sigmas will use fewer
+// samples and exit early, but not recompile the shader.
+const MAX_SAMPLES = 20;
+
+const _flatCamera = /*@__PURE__*/ new OrthographicCamera();
+const _clearColor = /*@__PURE__*/ new Color();
+let _oldTarget = null;
+let _oldActiveCubeFace = 0;
+let _oldActiveMipmapLevel = 0;
+
+// Golden Ratio
+const PHI = ( 1 + Math.sqrt( 5 ) ) / 2;
+const INV_PHI = 1 / PHI;
+
+// Vertices of a dodecahedron (except the opposites, which represent the
+// same axis), used as axis directions evenly spread on a sphere.
+const _axisDirections = [
+	/*@__PURE__*/ new Vector3( 1, 1, 1 ),
+	/*@__PURE__*/ new Vector3( - 1, 1, 1 ),
+	/*@__PURE__*/ new Vector3( 1, 1, - 1 ),
+	/*@__PURE__*/ new Vector3( - 1, 1, - 1 ),
+	/*@__PURE__*/ new Vector3( 0, PHI, INV_PHI ),
+	/*@__PURE__*/ new Vector3( 0, PHI, - INV_PHI ),
+	/*@__PURE__*/ new Vector3( INV_PHI, 0, PHI ),
+	/*@__PURE__*/ new Vector3( - INV_PHI, 0, PHI ),
+	/*@__PURE__*/ new Vector3( PHI, INV_PHI, 0 ),
+	/*@__PURE__*/ new Vector3( - PHI, INV_PHI, 0 ) ];
+
+/**
+ * This class generates a Prefiltered, Mipmapped Radiance Environment Map
+ * (PMREM) from a cubeMap environment texture. This allows different levels of
+ * blur to be quickly accessed based on material roughness. It is packed into a
+ * special CubeUV format that allows us to perform custom interpolation so that
+ * we can support nonlinear formats such as RGBE. Unlike a traditional mipmap
+ * chain, it only goes down to the LOD_MIN level (above), and then creates extra
+ * even more filtered 'mips' at the same LOD_MIN resolution, associated with
+ * higher roughness levels. In this way we maintain resolution to smoothly
+ * interpolate diffuse lighting while limiting sampling computation.
+ *
+ * Paper: Fast, Accurate Image-Based Lighting
+ * https://drive.google.com/file/d/15y8r_UpKlU9SvV4ILb0C3qCPecS8pvLz/view
+*/
+
+class PMREMGenerator {
+
+	constructor( renderer ) {
+
+		this._renderer = renderer;
+		this._pingPongRenderTarget = null;
+
+		this._lodMax = 0;
+		this._cubeSize = 0;
+		this._lodPlanes = [];
+		this._sizeLods = [];
+		this._sigmas = [];
+
+		this._blurMaterial = null;
+		this._cubemapMaterial = null;
+		this._equirectMaterial = null;
+
+		this._compileMaterial( this._blurMaterial );
+
+	}
+
+	/**
+	 * Generates a PMREM from a supplied Scene, which can be faster than using an
+	 * image if networking bandwidth is low. Optional sigma specifies a blur radius
+	 * in radians to be applied to the scene before PMREM generation. Optional near
+	 * and far planes ensure the scene is rendered in its entirety (the cubeCamera
+	 * is placed at the origin).
+	 */
+	fromScene( scene, sigma = 0, near = 0.1, far = 100 ) {
+
+		_oldTarget = this._renderer.getRenderTarget();
+		_oldActiveCubeFace = this._renderer.getActiveCubeFace();
+		_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
+
+		this._setSize( 256 );
+
+		const cubeUVRenderTarget = this._allocateTargets();
+		cubeUVRenderTarget.depthBuffer = true;
+
+		this._sceneToCubeUV( scene, near, far, cubeUVRenderTarget );
+
+		if ( sigma > 0 ) {
+
+			this._blur( cubeUVRenderTarget, 0, 0, sigma );
+
+		}
+
+		this._applyPMREM( cubeUVRenderTarget );
+		this._cleanup( cubeUVRenderTarget );
+
+		return cubeUVRenderTarget;
+
+	}
+
+	/**
+	 * Generates a PMREM from an equirectangular texture, which can be either LDR
+	 * or HDR. The ideal input image size is 1k (1024 x 512),
+	 * as this matches best with the 256 x 256 cubemap output.
+	 */
+	fromEquirectangular( equirectangular, renderTarget = null ) {
+
+		return this._fromTexture( equirectangular, renderTarget );
+
+	}
+
+	/**
+	 * Generates a PMREM from an cubemap texture, which can be either LDR
+	 * or HDR. The ideal input cube size is 256 x 256,
+	 * as this matches best with the 256 x 256 cubemap output.
+	 */
+	fromCubemap( cubemap, renderTarget = null ) {
+
+		return this._fromTexture( cubemap, renderTarget );
+
+	}
+
+	/**
+	 * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during
+	 * your texture's network fetch for increased concurrency.
+	 */
+	compileCubemapShader() {
+
+		if ( this._cubemapMaterial === null ) {
+
+			this._cubemapMaterial = _getCubemapMaterial();
+			this._compileMaterial( this._cubemapMaterial );
+
+		}
+
+	}
+
+	/**
+	 * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during
+	 * your texture's network fetch for increased concurrency.
+	 */
+	compileEquirectangularShader() {
+
+		if ( this._equirectMaterial === null ) {
+
+			this._equirectMaterial = _getEquirectMaterial();
+			this._compileMaterial( this._equirectMaterial );
+
+		}
+
+	}
+
+	/**
+	 * Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class,
+	 * so you should not need more than one PMREMGenerator object. If you do, calling dispose() on
+	 * one of them will cause any others to also become unusable.
+	 */
+	dispose() {
+
+		this._dispose();
+
+		if ( this._cubemapMaterial !== null ) this._cubemapMaterial.dispose();
+		if ( this._equirectMaterial !== null ) this._equirectMaterial.dispose();
+
+	}
+
+	// private interface
+
+	_setSize( cubeSize ) {
+
+		this._lodMax = Math.floor( Math.log2( cubeSize ) );
+		this._cubeSize = Math.pow( 2, this._lodMax );
+
+	}
+
+	_dispose() {
+
+		if ( this._blurMaterial !== null ) this._blurMaterial.dispose();
+
+		if ( this._pingPongRenderTarget !== null ) this._pingPongRenderTarget.dispose();
+
+		for ( let i = 0; i < this._lodPlanes.length; i ++ ) {
+
+			this._lodPlanes[ i ].dispose();
+
+		}
+
+	}
+
+	_cleanup( outputTarget ) {
+
+		this._renderer.setRenderTarget( _oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel );
+		outputTarget.scissorTest = false;
+		_setViewport( outputTarget, 0, 0, outputTarget.width, outputTarget.height );
+
+	}
+
+	_fromTexture( texture, renderTarget ) {
+
+		if ( texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping ) {
+
+			this._setSize( texture.image.length === 0 ? 16 : ( texture.image[ 0 ].width || texture.image[ 0 ].image.width ) );
+
+		} else { // Equirectangular
+
+			this._setSize( texture.image.width / 4 );
+
+		}
+
+		_oldTarget = this._renderer.getRenderTarget();
+		_oldActiveCubeFace = this._renderer.getActiveCubeFace();
+		_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
+
+		const cubeUVRenderTarget = renderTarget || this._allocateTargets();
+		this._textureToCubeUV( texture, cubeUVRenderTarget );
+		this._applyPMREM( cubeUVRenderTarget );
+		this._cleanup( cubeUVRenderTarget );
+
+		return cubeUVRenderTarget;
+
+	}
+
+	_allocateTargets() {
+
+		const width = 3 * Math.max( this._cubeSize, 16 * 7 );
+		const height = 4 * this._cubeSize;
+
+		const params = {
+			magFilter: LinearFilter,
+			minFilter: LinearFilter,
+			generateMipmaps: false,
+			type: HalfFloatType,
+			format: RGBAFormat,
+			colorSpace: LinearSRGBColorSpace,
+			depthBuffer: false
+		};
+
+		const cubeUVRenderTarget = _createRenderTarget( width, height, params );
+
+		if ( this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== width || this._pingPongRenderTarget.height !== height ) {
+
+			if ( this._pingPongRenderTarget !== null ) {
+
+				this._dispose();
+
+			}
+
+			this._pingPongRenderTarget = _createRenderTarget( width, height, params );
+
+			const { _lodMax } = this;
+			( { sizeLods: this._sizeLods, lodPlanes: this._lodPlanes, sigmas: this._sigmas } = _createPlanes( _lodMax ) );
+
+			this._blurMaterial = _getBlurShader( _lodMax, width, height );
+
+		}
+
+		return cubeUVRenderTarget;
+
+	}
+
+	_compileMaterial( material ) {
+
+		const tmpMesh = new Mesh( this._lodPlanes[ 0 ], material );
+		this._renderer.compile( tmpMesh, _flatCamera );
+
+	}
+
+	_sceneToCubeUV( scene, near, far, cubeUVRenderTarget ) {
+
+		const fov = 90;
+		const aspect = 1;
+		const cubeCamera = new PerspectiveCamera( fov, aspect, near, far );
+		const upSign = [ 1, - 1, 1, 1, 1, 1 ];
+		const forwardSign = [ 1, 1, 1, - 1, - 1, - 1 ];
+		const renderer = this._renderer;
+
+		const originalAutoClear = renderer.autoClear;
+		const toneMapping = renderer.toneMapping;
+		renderer.getClearColor( _clearColor );
+
+		renderer.toneMapping = NoToneMapping;
+		renderer.autoClear = false;
+
+		const backgroundMaterial = new MeshBasicMaterial( {
+			name: 'PMREM.Background',
+			side: BackSide,
+			depthWrite: false,
+			depthTest: false,
+		} );
+
+		const backgroundBox = new Mesh( new BoxGeometry(), backgroundMaterial );
+
+		let useSolidColor = false;
+		const background = scene.background;
+
+		if ( background ) {
+
+			if ( background.isColor ) {
+
+				backgroundMaterial.color.copy( background );
+				scene.background = null;
+				useSolidColor = true;
+
+			}
+
+		} else {
+
+			backgroundMaterial.color.copy( _clearColor );
+			useSolidColor = true;
+
+		}
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const col = i % 3;
+
+			if ( col === 0 ) {
+
+				cubeCamera.up.set( 0, upSign[ i ], 0 );
+				cubeCamera.lookAt( forwardSign[ i ], 0, 0 );
+
+			} else if ( col === 1 ) {
+
+				cubeCamera.up.set( 0, 0, upSign[ i ] );
+				cubeCamera.lookAt( 0, forwardSign[ i ], 0 );
+
+			} else {
+
+				cubeCamera.up.set( 0, upSign[ i ], 0 );
+				cubeCamera.lookAt( 0, 0, forwardSign[ i ] );
+
+			}
+
+			const size = this._cubeSize;
+
+			_setViewport( cubeUVRenderTarget, col * size, i > 2 ? size : 0, size, size );
+
+			renderer.setRenderTarget( cubeUVRenderTarget );
+
+			if ( useSolidColor ) {
+
+				renderer.render( backgroundBox, cubeCamera );
+
+			}
+
+			renderer.render( scene, cubeCamera );
+
+		}
+
+		backgroundBox.geometry.dispose();
+		backgroundBox.material.dispose();
+
+		renderer.toneMapping = toneMapping;
+		renderer.autoClear = originalAutoClear;
+		scene.background = background;
+
+	}
+
+	_textureToCubeUV( texture, cubeUVRenderTarget ) {
+
+		const renderer = this._renderer;
+
+		const isCubeTexture = ( texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping );
+
+		if ( isCubeTexture ) {
+
+			if ( this._cubemapMaterial === null ) {
+
+				this._cubemapMaterial = _getCubemapMaterial();
+
+			}
+
+			this._cubemapMaterial.uniforms.flipEnvMap.value = ( texture.isRenderTargetTexture === false ) ? - 1 : 1;
+
+		} else {
+
+			if ( this._equirectMaterial === null ) {
+
+				this._equirectMaterial = _getEquirectMaterial();
+
+			}
+
+		}
+
+		const material = isCubeTexture ? this._cubemapMaterial : this._equirectMaterial;
+		const mesh = new Mesh( this._lodPlanes[ 0 ], material );
+
+		const uniforms = material.uniforms;
+
+		uniforms[ 'envMap' ].value = texture;
+
+		const size = this._cubeSize;
+
+		_setViewport( cubeUVRenderTarget, 0, 0, 3 * size, 2 * size );
+
+		renderer.setRenderTarget( cubeUVRenderTarget );
+		renderer.render( mesh, _flatCamera );
+
+	}
+
+	_applyPMREM( cubeUVRenderTarget ) {
+
+		const renderer = this._renderer;
+		const autoClear = renderer.autoClear;
+		renderer.autoClear = false;
+
+		for ( let i = 1; i < this._lodPlanes.length; i ++ ) {
+
+			const sigma = Math.sqrt( this._sigmas[ i ] * this._sigmas[ i ] - this._sigmas[ i - 1 ] * this._sigmas[ i - 1 ] );
+
+			const poleAxis = _axisDirections[ ( i - 1 ) % _axisDirections.length ];
+
+			this._blur( cubeUVRenderTarget, i - 1, i, sigma, poleAxis );
+
+		}
+
+		renderer.autoClear = autoClear;
+
+	}
+
+	/**
+	 * This is a two-pass Gaussian blur for a cubemap. Normally this is done
+	 * vertically and horizontally, but this breaks down on a cube. Here we apply
+	 * the blur latitudinally (around the poles), and then longitudinally (towards
+	 * the poles) to approximate the orthogonally-separable blur. It is least
+	 * accurate at the poles, but still does a decent job.
+	 */
+	_blur( cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis ) {
+
+		const pingPongRenderTarget = this._pingPongRenderTarget;
+
+		this._halfBlur(
+			cubeUVRenderTarget,
+			pingPongRenderTarget,
+			lodIn,
+			lodOut,
+			sigma,
+			'latitudinal',
+			poleAxis );
+
+		this._halfBlur(
+			pingPongRenderTarget,
+			cubeUVRenderTarget,
+			lodOut,
+			lodOut,
+			sigma,
+			'longitudinal',
+			poleAxis );
+
+	}
+
+	_halfBlur( targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis ) {
+
+		const renderer = this._renderer;
+		const blurMaterial = this._blurMaterial;
+
+		if ( direction !== 'latitudinal' && direction !== 'longitudinal' ) {
+
+			console.error(
+				'blur direction must be either latitudinal or longitudinal!' );
+
+		}
+
+		// Number of standard deviations at which to cut off the discrete approximation.
+		const STANDARD_DEVIATIONS = 3;
+
+		const blurMesh = new Mesh( this._lodPlanes[ lodOut ], blurMaterial );
+		const blurUniforms = blurMaterial.uniforms;
+
+		const pixels = this._sizeLods[ lodIn ] - 1;
+		const radiansPerPixel = isFinite( sigmaRadians ) ? Math.PI / ( 2 * pixels ) : 2 * Math.PI / ( 2 * MAX_SAMPLES - 1 );
+		const sigmaPixels = sigmaRadians / radiansPerPixel;
+		const samples = isFinite( sigmaRadians ) ? 1 + Math.floor( STANDARD_DEVIATIONS * sigmaPixels ) : MAX_SAMPLES;
+
+		if ( samples > MAX_SAMPLES ) {
+
+			console.warn( `sigmaRadians, ${
+				sigmaRadians}, is too large and will clip, as it requested ${
+				samples} samples when the maximum is set to ${MAX_SAMPLES}` );
+
+		}
+
+		const weights = [];
+		let sum = 0;
+
+		for ( let i = 0; i < MAX_SAMPLES; ++ i ) {
+
+			const x = i / sigmaPixels;
+			const weight = Math.exp( - x * x / 2 );
+			weights.push( weight );
+
+			if ( i === 0 ) {
+
+				sum += weight;
+
+			} else if ( i < samples ) {
+
+				sum += 2 * weight;
+
+			}
+
+		}
+
+		for ( let i = 0; i < weights.length; i ++ ) {
+
+			weights[ i ] = weights[ i ] / sum;
+
+		}
+
+		blurUniforms[ 'envMap' ].value = targetIn.texture;
+		blurUniforms[ 'samples' ].value = samples;
+		blurUniforms[ 'weights' ].value = weights;
+		blurUniforms[ 'latitudinal' ].value = direction === 'latitudinal';
+
+		if ( poleAxis ) {
+
+			blurUniforms[ 'poleAxis' ].value = poleAxis;
+
+		}
+
+		const { _lodMax } = this;
+		blurUniforms[ 'dTheta' ].value = radiansPerPixel;
+		blurUniforms[ 'mipInt' ].value = _lodMax - lodIn;
+
+		const outputSize = this._sizeLods[ lodOut ];
+		const x = 3 * outputSize * ( lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0 );
+		const y = 4 * ( this._cubeSize - outputSize );
+
+		_setViewport( targetOut, x, y, 3 * outputSize, 2 * outputSize );
+		renderer.setRenderTarget( targetOut );
+		renderer.render( blurMesh, _flatCamera );
+
+	}
+
+}
+
+
+
+function _createPlanes( lodMax ) {
+
+	const lodPlanes = [];
+	const sizeLods = [];
+	const sigmas = [];
+
+	let lod = lodMax;
+
+	const totalLods = lodMax - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length;
+
+	for ( let i = 0; i < totalLods; i ++ ) {
+
+		const sizeLod = Math.pow( 2, lod );
+		sizeLods.push( sizeLod );
+		let sigma = 1.0 / sizeLod;
+
+		if ( i > lodMax - LOD_MIN ) {
+
+			sigma = EXTRA_LOD_SIGMA[ i - lodMax + LOD_MIN - 1 ];
+
+		} else if ( i === 0 ) {
+
+			sigma = 0;
+
+		}
+
+		sigmas.push( sigma );
+
+		const texelSize = 1.0 / ( sizeLod - 2 );
+		const min = - texelSize;
+		const max = 1 + texelSize;
+		const uv1 = [ min, min, max, min, max, max, min, min, max, max, min, max ];
+
+		const cubeFaces = 6;
+		const vertices = 6;
+		const positionSize = 3;
+		const uvSize = 2;
+		const faceIndexSize = 1;
+
+		const position = new Float32Array( positionSize * vertices * cubeFaces );
+		const uv = new Float32Array( uvSize * vertices * cubeFaces );
+		const faceIndex = new Float32Array( faceIndexSize * vertices * cubeFaces );
+
+		for ( let face = 0; face < cubeFaces; face ++ ) {
+
+			const x = ( face % 3 ) * 2 / 3 - 1;
+			const y = face > 2 ? 0 : - 1;
+			const coordinates = [
+				x, y, 0,
+				x + 2 / 3, y, 0,
+				x + 2 / 3, y + 1, 0,
+				x, y, 0,
+				x + 2 / 3, y + 1, 0,
+				x, y + 1, 0
+			];
+			position.set( coordinates, positionSize * vertices * face );
+			uv.set( uv1, uvSize * vertices * face );
+			const fill = [ face, face, face, face, face, face ];
+			faceIndex.set( fill, faceIndexSize * vertices * face );
+
+		}
+
+		const planes = new BufferGeometry();
+		planes.setAttribute( 'position', new BufferAttribute( position, positionSize ) );
+		planes.setAttribute( 'uv', new BufferAttribute( uv, uvSize ) );
+		planes.setAttribute( 'faceIndex', new BufferAttribute( faceIndex, faceIndexSize ) );
+		lodPlanes.push( planes );
+
+		if ( lod > LOD_MIN ) {
+
+			lod --;
+
+		}
+
+	}
+
+	return { lodPlanes, sizeLods, sigmas };
+
+}
+
+function _createRenderTarget( width, height, params ) {
+
+	const cubeUVRenderTarget = new WebGLRenderTarget( width, height, params );
+	cubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping;
+	cubeUVRenderTarget.texture.name = 'PMREM.cubeUv';
+	cubeUVRenderTarget.scissorTest = true;
+	return cubeUVRenderTarget;
+
+}
+
+function _setViewport( target, x, y, width, height ) {
+
+	target.viewport.set( x, y, width, height );
+	target.scissor.set( x, y, width, height );
+
+}
+
+function _getBlurShader( lodMax, width, height ) {
+
+	const weights = new Float32Array( MAX_SAMPLES );
+	const poleAxis = new Vector3( 0, 1, 0 );
+	const shaderMaterial = new ShaderMaterial( {
+
+		name: 'SphericalGaussianBlur',
+
+		defines: {
+			'n': MAX_SAMPLES,
+			'CUBEUV_TEXEL_WIDTH': 1.0 / width,
+			'CUBEUV_TEXEL_HEIGHT': 1.0 / height,
+			'CUBEUV_MAX_MIP': `${lodMax}.0`,
+		},
+
+		uniforms: {
+			'envMap': { value: null },
+			'samples': { value: 1 },
+			'weights': { value: weights },
+			'latitudinal': { value: false },
+			'dTheta': { value: 0 },
+			'mipInt': { value: 0 },
+			'poleAxis': { value: poleAxis }
+		},
+
+		vertexShader: _getCommonVertexShader(),
+
+		fragmentShader: /* glsl */`
+
+			precision mediump float;
+			precision mediump int;
+
+			varying vec3 vOutputDirection;
+
+			uniform sampler2D envMap;
+			uniform int samples;
+			uniform float weights[ n ];
+			uniform bool latitudinal;
+			uniform float dTheta;
+			uniform float mipInt;
+			uniform vec3 poleAxis;
+
+			#define ENVMAP_TYPE_CUBE_UV
+			#include <cube_uv_reflection_fragment>
+
+			vec3 getSample( float theta, vec3 axis ) {
+
+				float cosTheta = cos( theta );
+				// Rodrigues' axis-angle rotation
+				vec3 sampleDirection = vOutputDirection * cosTheta
+					+ cross( axis, vOutputDirection ) * sin( theta )
+					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );
+
+				return bilinearCubeUV( envMap, sampleDirection, mipInt );
+
+			}
+
+			void main() {
+
+				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );
+
+				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {
+
+					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );
+
+				}
+
+				axis = normalize( axis );
+
+				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
+				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );
+
+				for ( int i = 1; i < n; i++ ) {
+
+					if ( i >= samples ) {
+
+						break;
+
+					}
+
+					float theta = dTheta * float( i );
+					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
+					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );
+
+				}
+
+			}
+		`,
+
+		blending: NoBlending,
+		depthTest: false,
+		depthWrite: false
+
+	} );
+
+	return shaderMaterial;
+
+}
+
+function _getEquirectMaterial() {
+
+	return new ShaderMaterial( {
+
+		name: 'EquirectangularToCubeUV',
+
+		uniforms: {
+			'envMap': { value: null }
+		},
+
+		vertexShader: _getCommonVertexShader(),
+
+		fragmentShader: /* glsl */`
+
+			precision mediump float;
+			precision mediump int;
+
+			varying vec3 vOutputDirection;
+
+			uniform sampler2D envMap;
+
+			#include <common>
+
+			void main() {
+
+				vec3 outputDirection = normalize( vOutputDirection );
+				vec2 uv = equirectUv( outputDirection );
+
+				gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );
+
+			}
+		`,
+
+		blending: NoBlending,
+		depthTest: false,
+		depthWrite: false
+
+	} );
+
+}
+
+function _getCubemapMaterial() {
+
+	return new ShaderMaterial( {
+
+		name: 'CubemapToCubeUV',
+
+		uniforms: {
+			'envMap': { value: null },
+			'flipEnvMap': { value: - 1 }
+		},
+
+		vertexShader: _getCommonVertexShader(),
+
+		fragmentShader: /* glsl */`
+
+			precision mediump float;
+			precision mediump int;
+
+			uniform float flipEnvMap;
+
+			varying vec3 vOutputDirection;
+
+			uniform samplerCube envMap;
+
+			void main() {
+
+				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );
+
+			}
+		`,
+
+		blending: NoBlending,
+		depthTest: false,
+		depthWrite: false
+
+	} );
+
+}
+
+function _getCommonVertexShader() {
+
+	return /* glsl */`
+
+		precision mediump float;
+		precision mediump int;
+
+		attribute float faceIndex;
+
+		varying vec3 vOutputDirection;
+
+		// RH coordinate system; PMREM face-indexing convention
+		vec3 getDirection( vec2 uv, float face ) {
+
+			uv = 2.0 * uv - 1.0;
+
+			vec3 direction = vec3( uv, 1.0 );
+
+			if ( face == 0.0 ) {
+
+				direction = direction.zyx; // ( 1, v, u ) pos x
+
+			} else if ( face == 1.0 ) {
+
+				direction = direction.xzy;
+				direction.xz *= -1.0; // ( -u, 1, -v ) pos y
+
+			} else if ( face == 2.0 ) {
+
+				direction.x *= -1.0; // ( -u, v, 1 ) pos z
+
+			} else if ( face == 3.0 ) {
+
+				direction = direction.zyx;
+				direction.xz *= -1.0; // ( -1, v, -u ) neg x
+
+			} else if ( face == 4.0 ) {
+
+				direction = direction.xzy;
+				direction.xy *= -1.0; // ( -u, -1, v ) neg y
+
+			} else if ( face == 5.0 ) {
+
+				direction.z *= -1.0; // ( u, v, -1 ) neg z
+
+			}
+
+			return direction;
+
+		}
+
+		void main() {
+
+			vOutputDirection = getDirection( uv, faceIndex );
+			gl_Position = vec4( position, 1.0 );
+
+		}
+	`;
+
+}
+
+function WebGLCubeUVMaps( renderer ) {
+
+	let cubeUVmaps = new WeakMap();
+
+	let pmremGenerator = null;
+
+	function get( texture ) {
+
+		if ( texture && texture.isTexture ) {
+
+			const mapping = texture.mapping;
+
+			const isEquirectMap = ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping );
+			const isCubeMap = ( mapping === CubeReflectionMapping || mapping === CubeRefractionMapping );
+
+			// equirect/cube map to cubeUV conversion
+
+			if ( isEquirectMap || isCubeMap ) {
+
+				if ( texture.isRenderTargetTexture && texture.needsPMREMUpdate === true ) {
+
+					texture.needsPMREMUpdate = false;
+
+					let renderTarget = cubeUVmaps.get( texture );
+
+					if ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );
+
+					renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture, renderTarget ) : pmremGenerator.fromCubemap( texture, renderTarget );
+					cubeUVmaps.set( texture, renderTarget );
+
+					return renderTarget.texture;
+
+				} else {
+
+					if ( cubeUVmaps.has( texture ) ) {
+
+						return cubeUVmaps.get( texture ).texture;
+
+					} else {
+
+						const image = texture.image;
+
+						if ( ( isEquirectMap && image && image.height > 0 ) || ( isCubeMap && image && isCubeTextureComplete( image ) ) ) {
+
+							if ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );
+
+							const renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture ) : pmremGenerator.fromCubemap( texture );
+							cubeUVmaps.set( texture, renderTarget );
+
+							texture.addEventListener( 'dispose', onTextureDispose );
+
+							return renderTarget.texture;
+
+						} else {
+
+							// image not yet ready. try the conversion next frame
+
+							return null;
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		return texture;
+
+	}
+
+	function isCubeTextureComplete( image ) {
+
+		let count = 0;
+		const length = 6;
+
+		for ( let i = 0; i < length; i ++ ) {
+
+			if ( image[ i ] !== undefined ) count ++;
+
+		}
+
+		return count === length;
+
+
+	}
+
+	function onTextureDispose( event ) {
+
+		const texture = event.target;
+
+		texture.removeEventListener( 'dispose', onTextureDispose );
+
+		const cubemapUV = cubeUVmaps.get( texture );
+
+		if ( cubemapUV !== undefined ) {
+
+			cubeUVmaps.delete( texture );
+			cubemapUV.dispose();
+
+		}
+
+	}
+
+	function dispose() {
+
+		cubeUVmaps = new WeakMap();
+
+		if ( pmremGenerator !== null ) {
+
+			pmremGenerator.dispose();
+			pmremGenerator = null;
+
+		}
+
+	}
+
+	return {
+		get: get,
+		dispose: dispose
+	};
+
+}
+
+function WebGLExtensions( gl ) {
+
+	const extensions = {};
+
+	function getExtension( name ) {
+
+		if ( extensions[ name ] !== undefined ) {
+
+			return extensions[ name ];
+
+		}
+
+		let extension;
+
+		switch ( name ) {
+
+			case 'WEBGL_depth_texture':
+				extension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );
+				break;
+
+			case 'EXT_texture_filter_anisotropic':
+				extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );
+				break;
+
+			case 'WEBGL_compressed_texture_s3tc':
+				extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );
+				break;
+
+			case 'WEBGL_compressed_texture_pvrtc':
+				extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );
+				break;
+
+			default:
+				extension = gl.getExtension( name );
+
+		}
+
+		extensions[ name ] = extension;
+
+		return extension;
+
+	}
+
+	return {
+
+		has: function ( name ) {
+
+			return getExtension( name ) !== null;
+
+		},
+
+		init: function ( capabilities ) {
+
+			if ( capabilities.isWebGL2 ) {
+
+				getExtension( 'EXT_color_buffer_float' );
+				getExtension( 'WEBGL_clip_cull_distance' );
+
+			} else {
+
+				getExtension( 'WEBGL_depth_texture' );
+				getExtension( 'OES_texture_float' );
+				getExtension( 'OES_texture_half_float' );
+				getExtension( 'OES_texture_half_float_linear' );
+				getExtension( 'OES_standard_derivatives' );
+				getExtension( 'OES_element_index_uint' );
+				getExtension( 'OES_vertex_array_object' );
+				getExtension( 'ANGLE_instanced_arrays' );
+
+			}
+
+			getExtension( 'OES_texture_float_linear' );
+			getExtension( 'EXT_color_buffer_half_float' );
+			getExtension( 'WEBGL_multisampled_render_to_texture' );
+
+		},
+
+		get: function ( name ) {
+
+			const extension = getExtension( name );
+
+			if ( extension === null ) {
+
+				console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );
+
+			}
+
+			return extension;
+
+		}
+
+	};
+
+}
+
+function WebGLGeometries( gl, attributes, info, bindingStates ) {
+
+	const geometries = {};
+	const wireframeAttributes = new WeakMap();
+
+	function onGeometryDispose( event ) {
+
+		const geometry = event.target;
+
+		if ( geometry.index !== null ) {
+
+			attributes.remove( geometry.index );
+
+		}
+
+		for ( const name in geometry.attributes ) {
+
+			attributes.remove( geometry.attributes[ name ] );
+
+		}
+
+		for ( const name in geometry.morphAttributes ) {
+
+			const array = geometry.morphAttributes[ name ];
+
+			for ( let i = 0, l = array.length; i < l; i ++ ) {
+
+				attributes.remove( array[ i ] );
+
+			}
+
+		}
+
+		geometry.removeEventListener( 'dispose', onGeometryDispose );
+
+		delete geometries[ geometry.id ];
+
+		const attribute = wireframeAttributes.get( geometry );
+
+		if ( attribute ) {
+
+			attributes.remove( attribute );
+			wireframeAttributes.delete( geometry );
+
+		}
+
+		bindingStates.releaseStatesOfGeometry( geometry );
+
+		if ( geometry.isInstancedBufferGeometry === true ) {
+
+			delete geometry._maxInstanceCount;
+
+		}
+
+		//
+
+		info.memory.geometries --;
+
+	}
+
+	function get( object, geometry ) {
+
+		if ( geometries[ geometry.id ] === true ) return geometry;
+
+		geometry.addEventListener( 'dispose', onGeometryDispose );
+
+		geometries[ geometry.id ] = true;
+
+		info.memory.geometries ++;
+
+		return geometry;
+
+	}
+
+	function update( geometry ) {
+
+		const geometryAttributes = geometry.attributes;
+
+		// Updating index buffer in VAO now. See WebGLBindingStates.
+
+		for ( const name in geometryAttributes ) {
+
+			attributes.update( geometryAttributes[ name ], gl.ARRAY_BUFFER );
+
+		}
+
+		// morph targets
+
+		const morphAttributes = geometry.morphAttributes;
+
+		for ( const name in morphAttributes ) {
+
+			const array = morphAttributes[ name ];
+
+			for ( let i = 0, l = array.length; i < l; i ++ ) {
+
+				attributes.update( array[ i ], gl.ARRAY_BUFFER );
+
+			}
+
+		}
+
+	}
+
+	function updateWireframeAttribute( geometry ) {
+
+		const indices = [];
+
+		const geometryIndex = geometry.index;
+		const geometryPosition = geometry.attributes.position;
+		let version = 0;
+
+		if ( geometryIndex !== null ) {
+
+			const array = geometryIndex.array;
+			version = geometryIndex.version;
+
+			for ( let i = 0, l = array.length; i < l; i += 3 ) {
+
+				const a = array[ i + 0 ];
+				const b = array[ i + 1 ];
+				const c = array[ i + 2 ];
+
+				indices.push( a, b, b, c, c, a );
+
+			}
+
+		} else if ( geometryPosition !== undefined ) {
+
+			const array = geometryPosition.array;
+			version = geometryPosition.version;
+
+			for ( let i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {
+
+				const a = i + 0;
+				const b = i + 1;
+				const c = i + 2;
+
+				indices.push( a, b, b, c, c, a );
+
+			}
+
+		} else {
+
+			return;
+
+		}
+
+		const attribute = new ( arrayNeedsUint32( indices ) ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );
+		attribute.version = version;
+
+		// Updating index buffer in VAO now. See WebGLBindingStates
+
+		//
+
+		const previousAttribute = wireframeAttributes.get( geometry );
+
+		if ( previousAttribute ) attributes.remove( previousAttribute );
+
+		//
+
+		wireframeAttributes.set( geometry, attribute );
+
+	}
+
+	function getWireframeAttribute( geometry ) {
+
+		const currentAttribute = wireframeAttributes.get( geometry );
+
+		if ( currentAttribute ) {
+
+			const geometryIndex = geometry.index;
+
+			if ( geometryIndex !== null ) {
+
+				// if the attribute is obsolete, create a new one
+
+				if ( currentAttribute.version < geometryIndex.version ) {
+
+					updateWireframeAttribute( geometry );
+
+				}
+
+			}
+
+		} else {
+
+			updateWireframeAttribute( geometry );
+
+		}
+
+		return wireframeAttributes.get( geometry );
+
+	}
+
+	return {
+
+		get: get,
+		update: update,
+
+		getWireframeAttribute: getWireframeAttribute
+
+	};
+
+}
+
+function WebGLIndexedBufferRenderer( gl, extensions, info, capabilities ) {
+
+	const isWebGL2 = capabilities.isWebGL2;
+
+	let mode;
+
+	function setMode( value ) {
+
+		mode = value;
+
+	}
+
+	let type, bytesPerElement;
+
+	function setIndex( value ) {
+
+		type = value.type;
+		bytesPerElement = value.bytesPerElement;
+
+	}
+
+	function render( start, count ) {
+
+		gl.drawElements( mode, count, type, start * bytesPerElement );
+
+		info.update( count, mode, 1 );
+
+	}
+
+	function renderInstances( start, count, primcount ) {
+
+		if ( primcount === 0 ) return;
+
+		let extension, methodName;
+
+		if ( isWebGL2 ) {
+
+			extension = gl;
+			methodName = 'drawElementsInstanced';
+
+		} else {
+
+			extension = extensions.get( 'ANGLE_instanced_arrays' );
+			methodName = 'drawElementsInstancedANGLE';
+
+			if ( extension === null ) {
+
+				console.error( 'THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
+				return;
+
+			}
+
+		}
+
+		extension[ methodName ]( mode, count, type, start * bytesPerElement, primcount );
+
+		info.update( count, mode, primcount );
+
+	}
+
+	function renderMultiDraw( starts, counts, drawCount ) {
+
+		if ( drawCount === 0 ) return;
+
+		const extension = extensions.get( 'WEBGL_multi_draw' );
+		if ( extension === null ) {
+
+			for ( let i = 0; i < drawCount; i ++ ) {
+
+				this.render( starts[ i ] / bytesPerElement, counts[ i ] );
+
+			}
+
+		} else {
+
+			extension.multiDrawElementsWEBGL( mode, counts, 0, type, starts, 0, drawCount );
+
+			let elementCount = 0;
+			for ( let i = 0; i < drawCount; i ++ ) {
+
+				elementCount += counts[ i ];
+
+			}
+
+			info.update( elementCount, mode, 1 );
+
+		}
+
+	}
+
+	//
+
+	this.setMode = setMode;
+	this.setIndex = setIndex;
+	this.render = render;
+	this.renderInstances = renderInstances;
+	this.renderMultiDraw = renderMultiDraw;
+
+}
+
+function WebGLInfo( gl ) {
+
+	const memory = {
+		geometries: 0,
+		textures: 0
+	};
+
+	const render = {
+		frame: 0,
+		calls: 0,
+		triangles: 0,
+		points: 0,
+		lines: 0
+	};
+
+	function update( count, mode, instanceCount ) {
+
+		render.calls ++;
+
+		switch ( mode ) {
+
+			case gl.TRIANGLES:
+				render.triangles += instanceCount * ( count / 3 );
+				break;
+
+			case gl.LINES:
+				render.lines += instanceCount * ( count / 2 );
+				break;
+
+			case gl.LINE_STRIP:
+				render.lines += instanceCount * ( count - 1 );
+				break;
+
+			case gl.LINE_LOOP:
+				render.lines += instanceCount * count;
+				break;
+
+			case gl.POINTS:
+				render.points += instanceCount * count;
+				break;
+
+			default:
+				console.error( 'THREE.WebGLInfo: Unknown draw mode:', mode );
+				break;
+
+		}
+
+	}
+
+	function reset() {
+
+		render.calls = 0;
+		render.triangles = 0;
+		render.points = 0;
+		render.lines = 0;
+
+	}
+
+	return {
+		memory: memory,
+		render: render,
+		programs: null,
+		autoReset: true,
+		reset: reset,
+		update: update
+	};
+
+}
+
+function numericalSort( a, b ) {
+
+	return a[ 0 ] - b[ 0 ];
+
+}
+
+function absNumericalSort( a, b ) {
+
+	return Math.abs( b[ 1 ] ) - Math.abs( a[ 1 ] );
+
+}
+
+function WebGLMorphtargets( gl, capabilities, textures ) {
+
+	const influencesList = {};
+	const morphInfluences = new Float32Array( 8 );
+	const morphTextures = new WeakMap();
+	const morph = new Vector4();
+
+	const workInfluences = [];
+
+	for ( let i = 0; i < 8; i ++ ) {
+
+		workInfluences[ i ] = [ i, 0 ];
+
+	}
+
+	function update( object, geometry, program ) {
+
+		const objectInfluences = object.morphTargetInfluences;
+
+		if ( capabilities.isWebGL2 === true ) {
+
+			// instead of using attributes, the WebGL 2 code path encodes morph targets
+			// into an array of data textures. Each layer represents a single morph target.
+
+			const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
+			const morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;
+
+			let entry = morphTextures.get( geometry );
+
+			if ( entry === undefined || entry.count !== morphTargetsCount ) {
+
+				if ( entry !== undefined ) entry.texture.dispose();
+
+				const hasMorphPosition = geometry.morphAttributes.position !== undefined;
+				const hasMorphNormals = geometry.morphAttributes.normal !== undefined;
+				const hasMorphColors = geometry.morphAttributes.color !== undefined;
+
+				const morphTargets = geometry.morphAttributes.position || [];
+				const morphNormals = geometry.morphAttributes.normal || [];
+				const morphColors = geometry.morphAttributes.color || [];
+
+				let vertexDataCount = 0;
+
+				if ( hasMorphPosition === true ) vertexDataCount = 1;
+				if ( hasMorphNormals === true ) vertexDataCount = 2;
+				if ( hasMorphColors === true ) vertexDataCount = 3;
+
+				let width = geometry.attributes.position.count * vertexDataCount;
+				let height = 1;
+
+				if ( width > capabilities.maxTextureSize ) {
+
+					height = Math.ceil( width / capabilities.maxTextureSize );
+					width = capabilities.maxTextureSize;
+
+				}
+
+				const buffer = new Float32Array( width * height * 4 * morphTargetsCount );
+
+				const texture = new DataArrayTexture( buffer, width, height, morphTargetsCount );
+				texture.type = FloatType;
+				texture.needsUpdate = true;
+
+				// fill buffer
+
+				const vertexDataStride = vertexDataCount * 4;
+
+				for ( let i = 0; i < morphTargetsCount; i ++ ) {
+
+					const morphTarget = morphTargets[ i ];
+					const morphNormal = morphNormals[ i ];
+					const morphColor = morphColors[ i ];
+
+					const offset = width * height * 4 * i;
+
+					for ( let j = 0; j < morphTarget.count; j ++ ) {
+
+						const stride = j * vertexDataStride;
+
+						if ( hasMorphPosition === true ) {
+
+							morph.fromBufferAttribute( morphTarget, j );
+
+							buffer[ offset + stride + 0 ] = morph.x;
+							buffer[ offset + stride + 1 ] = morph.y;
+							buffer[ offset + stride + 2 ] = morph.z;
+							buffer[ offset + stride + 3 ] = 0;
+
+						}
+
+						if ( hasMorphNormals === true ) {
+
+							morph.fromBufferAttribute( morphNormal, j );
+
+							buffer[ offset + stride + 4 ] = morph.x;
+							buffer[ offset + stride + 5 ] = morph.y;
+							buffer[ offset + stride + 6 ] = morph.z;
+							buffer[ offset + stride + 7 ] = 0;
+
+						}
+
+						if ( hasMorphColors === true ) {
+
+							morph.fromBufferAttribute( morphColor, j );
+
+							buffer[ offset + stride + 8 ] = morph.x;
+							buffer[ offset + stride + 9 ] = morph.y;
+							buffer[ offset + stride + 10 ] = morph.z;
+							buffer[ offset + stride + 11 ] = ( morphColor.itemSize === 4 ) ? morph.w : 1;
+
+						}
+
+					}
+
+				}
+
+				entry = {
+					count: morphTargetsCount,
+					texture: texture,
+					size: new Vector2( width, height )
+				};
+
+				morphTextures.set( geometry, entry );
+
+				function disposeTexture() {
+
+					texture.dispose();
+
+					morphTextures.delete( geometry );
+
+					geometry.removeEventListener( 'dispose', disposeTexture );
+
+				}
+
+				geometry.addEventListener( 'dispose', disposeTexture );
+
+			}
+
+			//
+
+			let morphInfluencesSum = 0;
+
+			for ( let i = 0; i < objectInfluences.length; i ++ ) {
+
+				morphInfluencesSum += objectInfluences[ i ];
+
+			}
+
+			const morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;
+
+			program.getUniforms().setValue( gl, 'morphTargetBaseInfluence', morphBaseInfluence );
+			program.getUniforms().setValue( gl, 'morphTargetInfluences', objectInfluences );
+
+			program.getUniforms().setValue( gl, 'morphTargetsTexture', entry.texture, textures );
+			program.getUniforms().setValue( gl, 'morphTargetsTextureSize', entry.size );
+
+
+		} else {
+
+			// When object doesn't have morph target influences defined, we treat it as a 0-length array
+			// This is important to make sure we set up morphTargetBaseInfluence / morphTargetInfluences
+
+			const length = objectInfluences === undefined ? 0 : objectInfluences.length;
+
+			let influences = influencesList[ geometry.id ];
+
+			if ( influences === undefined || influences.length !== length ) {
+
+				// initialise list
+
+				influences = [];
+
+				for ( let i = 0; i < length; i ++ ) {
+
+					influences[ i ] = [ i, 0 ];
+
+				}
+
+				influencesList[ geometry.id ] = influences;
+
+			}
+
+			// Collect influences
+
+			for ( let i = 0; i < length; i ++ ) {
+
+				const influence = influences[ i ];
+
+				influence[ 0 ] = i;
+				influence[ 1 ] = objectInfluences[ i ];
+
+			}
+
+			influences.sort( absNumericalSort );
+
+			for ( let i = 0; i < 8; i ++ ) {
+
+				if ( i < length && influences[ i ][ 1 ] ) {
+
+					workInfluences[ i ][ 0 ] = influences[ i ][ 0 ];
+					workInfluences[ i ][ 1 ] = influences[ i ][ 1 ];
+
+				} else {
+
+					workInfluences[ i ][ 0 ] = Number.MAX_SAFE_INTEGER;
+					workInfluences[ i ][ 1 ] = 0;
+
+				}
+
+			}
+
+			workInfluences.sort( numericalSort );
+
+			const morphTargets = geometry.morphAttributes.position;
+			const morphNormals = geometry.morphAttributes.normal;
+
+			let morphInfluencesSum = 0;
+
+			for ( let i = 0; i < 8; i ++ ) {
+
+				const influence = workInfluences[ i ];
+				const index = influence[ 0 ];
+				const value = influence[ 1 ];
+
+				if ( index !== Number.MAX_SAFE_INTEGER && value ) {
+
+					if ( morphTargets && geometry.getAttribute( 'morphTarget' + i ) !== morphTargets[ index ] ) {
+
+						geometry.setAttribute( 'morphTarget' + i, morphTargets[ index ] );
+
+					}
+
+					if ( morphNormals && geometry.getAttribute( 'morphNormal' + i ) !== morphNormals[ index ] ) {
+
+						geometry.setAttribute( 'morphNormal' + i, morphNormals[ index ] );
+
+					}
+
+					morphInfluences[ i ] = value;
+					morphInfluencesSum += value;
+
+				} else {
+
+					if ( morphTargets && geometry.hasAttribute( 'morphTarget' + i ) === true ) {
+
+						geometry.deleteAttribute( 'morphTarget' + i );
+
+					}
+
+					if ( morphNormals && geometry.hasAttribute( 'morphNormal' + i ) === true ) {
+
+						geometry.deleteAttribute( 'morphNormal' + i );
+
+					}
+
+					morphInfluences[ i ] = 0;
+
+				}
+
+			}
+
+			// GLSL shader uses formula baseinfluence * base + sum(target * influence)
+			// This allows us to switch between absolute morphs and relative morphs without changing shader code
+			// When baseinfluence = 1 - sum(influence), the above is equivalent to sum((target - base) * influence)
+			const morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;
+
+			program.getUniforms().setValue( gl, 'morphTargetBaseInfluence', morphBaseInfluence );
+			program.getUniforms().setValue( gl, 'morphTargetInfluences', morphInfluences );
+
+		}
+
+	}
+
+	return {
+
+		update: update
+
+	};
+
+}
+
+function WebGLObjects( gl, geometries, attributes, info ) {
+
+	let updateMap = new WeakMap();
+
+	function update( object ) {
+
+		const frame = info.render.frame;
+
+		const geometry = object.geometry;
+		const buffergeometry = geometries.get( object, geometry );
+
+		// Update once per frame
+
+		if ( updateMap.get( buffergeometry ) !== frame ) {
+
+			geometries.update( buffergeometry );
+
+			updateMap.set( buffergeometry, frame );
+
+		}
+
+		if ( object.isInstancedMesh ) {
+
+			if ( object.hasEventListener( 'dispose', onInstancedMeshDispose ) === false ) {
+
+				object.addEventListener( 'dispose', onInstancedMeshDispose );
+
+			}
+
+			if ( updateMap.get( object ) !== frame ) {
+
+				attributes.update( object.instanceMatrix, gl.ARRAY_BUFFER );
+
+				if ( object.instanceColor !== null ) {
+
+					attributes.update( object.instanceColor, gl.ARRAY_BUFFER );
+
+				}
+
+				updateMap.set( object, frame );
+
+			}
+
+		}
+
+		if ( object.isSkinnedMesh ) {
+
+			const skeleton = object.skeleton;
+
+			if ( updateMap.get( skeleton ) !== frame ) {
+
+				skeleton.update();
+
+				updateMap.set( skeleton, frame );
+
+			}
+
+		}
+
+		return buffergeometry;
+
+	}
+
+	function dispose() {
+
+		updateMap = new WeakMap();
+
+	}
+
+	function onInstancedMeshDispose( event ) {
+
+		const instancedMesh = event.target;
+
+		instancedMesh.removeEventListener( 'dispose', onInstancedMeshDispose );
+
+		attributes.remove( instancedMesh.instanceMatrix );
+
+		if ( instancedMesh.instanceColor !== null ) attributes.remove( instancedMesh.instanceColor );
+
+	}
+
+	return {
+
+		update: update,
+		dispose: dispose
+
+	};
+
+}
+
+class DepthTexture extends Texture {
+
+	constructor( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {
+
+		format = format !== undefined ? format : DepthFormat;
+
+		if ( format !== DepthFormat && format !== DepthStencilFormat ) {
+
+			throw new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' );
+
+		}
+
+		if ( type === undefined && format === DepthFormat ) type = UnsignedIntType;
+		if ( type === undefined && format === DepthStencilFormat ) type = UnsignedInt248Type;
+
+		super( null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+
+		this.isDepthTexture = true;
+
+		this.image = { width: width, height: height };
+
+		this.magFilter = magFilter !== undefined ? magFilter : NearestFilter;
+		this.minFilter = minFilter !== undefined ? minFilter : NearestFilter;
+
+		this.flipY = false;
+		this.generateMipmaps = false;
+
+		this.compareFunction = null;
+
+	}
+
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.compareFunction = source.compareFunction;
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		if ( this.compareFunction !== null ) data.compareFunction = this.compareFunction;
+
+		return data;
+
+	}
+
+}
+
+/**
+ * Uniforms of a program.
+ * Those form a tree structure with a special top-level container for the root,
+ * which you get by calling 'new WebGLUniforms( gl, program )'.
+ *
+ *
+ * Properties of inner nodes including the top-level container:
+ *
+ * .seq - array of nested uniforms
+ * .map - nested uniforms by name
+ *
+ *
+ * Methods of all nodes except the top-level container:
+ *
+ * .setValue( gl, value, [textures] )
+ *
+ * 		uploads a uniform value(s)
+ *  	the 'textures' parameter is needed for sampler uniforms
+ *
+ *
+ * Static methods of the top-level container (textures factorizations):
+ *
+ * .upload( gl, seq, values, textures )
+ *
+ * 		sets uniforms in 'seq' to 'values[id].value'
+ *
+ * .seqWithValue( seq, values ) : filteredSeq
+ *
+ * 		filters 'seq' entries with corresponding entry in values
+ *
+ *
+ * Methods of the top-level container (textures factorizations):
+ *
+ * .setValue( gl, name, value, textures )
+ *
+ * 		sets uniform with  name 'name' to 'value'
+ *
+ * .setOptional( gl, obj, prop )
+ *
+ * 		like .set for an optional property of the object
+ *
+ */
+
+
+const emptyTexture = /*@__PURE__*/ new Texture();
+
+const emptyShadowTexture = /*@__PURE__*/ new DepthTexture( 1, 1 );
+emptyShadowTexture.compareFunction = LessEqualCompare;
+
+const emptyArrayTexture = /*@__PURE__*/ new DataArrayTexture();
+const empty3dTexture = /*@__PURE__*/ new Data3DTexture();
+const emptyCubeTexture = /*@__PURE__*/ new CubeTexture();
+
+// --- Utilities ---
+
+// Array Caches (provide typed arrays for temporary by size)
+
+const arrayCacheF32 = [];
+const arrayCacheI32 = [];
+
+// Float32Array caches used for uploading Matrix uniforms
+
+const mat4array = new Float32Array( 16 );
+const mat3array = new Float32Array( 9 );
+const mat2array = new Float32Array( 4 );
+
+// Flattening for arrays of vectors and matrices
+
+function flatten( array, nBlocks, blockSize ) {
+
+	const firstElem = array[ 0 ];
+
+	if ( firstElem <= 0 || firstElem > 0 ) return array;
+	// unoptimized: ! isNaN( firstElem )
+	// see http://jacksondunstan.com/articles/983
+
+	const n = nBlocks * blockSize;
+	let r = arrayCacheF32[ n ];
+
+	if ( r === undefined ) {
+
+		r = new Float32Array( n );
+		arrayCacheF32[ n ] = r;
+
+	}
+
+	if ( nBlocks !== 0 ) {
+
+		firstElem.toArray( r, 0 );
+
+		for ( let i = 1, offset = 0; i !== nBlocks; ++ i ) {
+
+			offset += blockSize;
+			array[ i ].toArray( r, offset );
+
+		}
+
+	}
+
+	return r;
+
+}
+
+function arraysEqual( a, b ) {
+
+	if ( a.length !== b.length ) return false;
+
+	for ( let i = 0, l = a.length; i < l; i ++ ) {
+
+		if ( a[ i ] !== b[ i ] ) return false;
+
+	}
+
+	return true;
+
+}
+
+function copyArray( a, b ) {
+
+	for ( let i = 0, l = b.length; i < l; i ++ ) {
+
+		a[ i ] = b[ i ];
+
+	}
+
+}
+
+// Texture unit allocation
+
+function allocTexUnits( textures, n ) {
+
+	let r = arrayCacheI32[ n ];
+
+	if ( r === undefined ) {
+
+		r = new Int32Array( n );
+		arrayCacheI32[ n ] = r;
+
+	}
+
+	for ( let i = 0; i !== n; ++ i ) {
+
+		r[ i ] = textures.allocateTextureUnit();
+
+	}
+
+	return r;
+
+}
+
+// --- Setters ---
+
+// Note: Defining these methods externally, because they come in a bunch
+// and this way their names minify.
+
+// Single scalar
+
+function setValueV1f( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( cache[ 0 ] === v ) return;
+
+	gl.uniform1f( this.addr, v );
+
+	cache[ 0 ] = v;
+
+}
+
+// Single float vector (from flat array or THREE.VectorN)
+
+function setValueV2f( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {
+
+			gl.uniform2f( this.addr, v.x, v.y );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform2fv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+function setValueV3f( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {
+
+			gl.uniform3f( this.addr, v.x, v.y, v.z );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+
+		}
+
+	} else if ( v.r !== undefined ) {
+
+		if ( cache[ 0 ] !== v.r || cache[ 1 ] !== v.g || cache[ 2 ] !== v.b ) {
+
+			gl.uniform3f( this.addr, v.r, v.g, v.b );
+
+			cache[ 0 ] = v.r;
+			cache[ 1 ] = v.g;
+			cache[ 2 ] = v.b;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform3fv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+function setValueV4f( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {
+
+			gl.uniform4f( this.addr, v.x, v.y, v.z, v.w );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+			cache[ 3 ] = v.w;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform4fv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+// Single matrix (from flat array or THREE.MatrixN)
+
+function setValueM2( gl, v ) {
+
+	const cache = this.cache;
+	const elements = v.elements;
+
+	if ( elements === undefined ) {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniformMatrix2fv( this.addr, false, v );
+
+		copyArray( cache, v );
+
+	} else {
+
+		if ( arraysEqual( cache, elements ) ) return;
+
+		mat2array.set( elements );
+
+		gl.uniformMatrix2fv( this.addr, false, mat2array );
+
+		copyArray( cache, elements );
+
+	}
+
+}
+
+function setValueM3( gl, v ) {
+
+	const cache = this.cache;
+	const elements = v.elements;
+
+	if ( elements === undefined ) {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniformMatrix3fv( this.addr, false, v );
+
+		copyArray( cache, v );
+
+	} else {
+
+		if ( arraysEqual( cache, elements ) ) return;
+
+		mat3array.set( elements );
+
+		gl.uniformMatrix3fv( this.addr, false, mat3array );
+
+		copyArray( cache, elements );
+
+	}
+
+}
+
+function setValueM4( gl, v ) {
+
+	const cache = this.cache;
+	const elements = v.elements;
+
+	if ( elements === undefined ) {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniformMatrix4fv( this.addr, false, v );
+
+		copyArray( cache, v );
+
+	} else {
+
+		if ( arraysEqual( cache, elements ) ) return;
+
+		mat4array.set( elements );
+
+		gl.uniformMatrix4fv( this.addr, false, mat4array );
+
+		copyArray( cache, elements );
+
+	}
+
+}
+
+// Single integer / boolean
+
+function setValueV1i( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( cache[ 0 ] === v ) return;
+
+	gl.uniform1i( this.addr, v );
+
+	cache[ 0 ] = v;
+
+}
+
+// Single integer / boolean vector (from flat array or THREE.VectorN)
+
+function setValueV2i( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {
+
+			gl.uniform2i( this.addr, v.x, v.y );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform2iv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+function setValueV3i( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {
+
+			gl.uniform3i( this.addr, v.x, v.y, v.z );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform3iv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+function setValueV4i( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {
+
+			gl.uniform4i( this.addr, v.x, v.y, v.z, v.w );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+			cache[ 3 ] = v.w;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform4iv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+// Single unsigned integer
+
+function setValueV1ui( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( cache[ 0 ] === v ) return;
+
+	gl.uniform1ui( this.addr, v );
+
+	cache[ 0 ] = v;
+
+}
+
+// Single unsigned integer vector (from flat array or THREE.VectorN)
+
+function setValueV2ui( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {
+
+			gl.uniform2ui( this.addr, v.x, v.y );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform2uiv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+function setValueV3ui( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {
+
+			gl.uniform3ui( this.addr, v.x, v.y, v.z );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform3uiv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+function setValueV4ui( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( v.x !== undefined ) {
+
+		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {
+
+			gl.uniform4ui( this.addr, v.x, v.y, v.z, v.w );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+			cache[ 3 ] = v.w;
+
+		}
+
+	} else {
+
+		if ( arraysEqual( cache, v ) ) return;
+
+		gl.uniform4uiv( this.addr, v );
+
+		copyArray( cache, v );
+
+	}
+
+}
+
+
+// Single texture (2D / Cube)
+
+function setValueT1( gl, v, textures ) {
+
+	const cache = this.cache;
+	const unit = textures.allocateTextureUnit();
+
+	if ( cache[ 0 ] !== unit ) {
+
+		gl.uniform1i( this.addr, unit );
+		cache[ 0 ] = unit;
+
+	}
+
+	const emptyTexture2D = ( this.type === gl.SAMPLER_2D_SHADOW ) ? emptyShadowTexture : emptyTexture;
+
+	textures.setTexture2D( v || emptyTexture2D, unit );
+
+}
+
+function setValueT3D1( gl, v, textures ) {
+
+	const cache = this.cache;
+	const unit = textures.allocateTextureUnit();
+
+	if ( cache[ 0 ] !== unit ) {
+
+		gl.uniform1i( this.addr, unit );
+		cache[ 0 ] = unit;
+
+	}
+
+	textures.setTexture3D( v || empty3dTexture, unit );
+
+}
+
+function setValueT6( gl, v, textures ) {
+
+	const cache = this.cache;
+	const unit = textures.allocateTextureUnit();
+
+	if ( cache[ 0 ] !== unit ) {
+
+		gl.uniform1i( this.addr, unit );
+		cache[ 0 ] = unit;
+
+	}
+
+	textures.setTextureCube( v || emptyCubeTexture, unit );
+
+}
+
+function setValueT2DArray1( gl, v, textures ) {
+
+	const cache = this.cache;
+	const unit = textures.allocateTextureUnit();
+
+	if ( cache[ 0 ] !== unit ) {
+
+		gl.uniform1i( this.addr, unit );
+		cache[ 0 ] = unit;
+
+	}
+
+	textures.setTexture2DArray( v || emptyArrayTexture, unit );
+
+}
+
+// Helper to pick the right setter for the singular case
+
+function getSingularSetter( type ) {
+
+	switch ( type ) {
+
+		case 0x1406: return setValueV1f; // FLOAT
+		case 0x8b50: return setValueV2f; // _VEC2
+		case 0x8b51: return setValueV3f; // _VEC3
+		case 0x8b52: return setValueV4f; // _VEC4
+
+		case 0x8b5a: return setValueM2; // _MAT2
+		case 0x8b5b: return setValueM3; // _MAT3
+		case 0x8b5c: return setValueM4; // _MAT4
+
+		case 0x1404: case 0x8b56: return setValueV1i; // INT, BOOL
+		case 0x8b53: case 0x8b57: return setValueV2i; // _VEC2
+		case 0x8b54: case 0x8b58: return setValueV3i; // _VEC3
+		case 0x8b55: case 0x8b59: return setValueV4i; // _VEC4
+
+		case 0x1405: return setValueV1ui; // UINT
+		case 0x8dc6: return setValueV2ui; // _VEC2
+		case 0x8dc7: return setValueV3ui; // _VEC3
+		case 0x8dc8: return setValueV4ui; // _VEC4
+
+		case 0x8b5e: // SAMPLER_2D
+		case 0x8d66: // SAMPLER_EXTERNAL_OES
+		case 0x8dca: // INT_SAMPLER_2D
+		case 0x8dd2: // UNSIGNED_INT_SAMPLER_2D
+		case 0x8b62: // SAMPLER_2D_SHADOW
+			return setValueT1;
+
+		case 0x8b5f: // SAMPLER_3D
+		case 0x8dcb: // INT_SAMPLER_3D
+		case 0x8dd3: // UNSIGNED_INT_SAMPLER_3D
+			return setValueT3D1;
+
+		case 0x8b60: // SAMPLER_CUBE
+		case 0x8dcc: // INT_SAMPLER_CUBE
+		case 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE
+		case 0x8dc5: // SAMPLER_CUBE_SHADOW
+			return setValueT6;
+
+		case 0x8dc1: // SAMPLER_2D_ARRAY
+		case 0x8dcf: // INT_SAMPLER_2D_ARRAY
+		case 0x8dd7: // UNSIGNED_INT_SAMPLER_2D_ARRAY
+		case 0x8dc4: // SAMPLER_2D_ARRAY_SHADOW
+			return setValueT2DArray1;
+
+	}
+
+}
+
+
+// Array of scalars
+
+function setValueV1fArray( gl, v ) {
+
+	gl.uniform1fv( this.addr, v );
+
+}
+
+// Array of vectors (from flat array or array of THREE.VectorN)
+
+function setValueV2fArray( gl, v ) {
+
+	const data = flatten( v, this.size, 2 );
+
+	gl.uniform2fv( this.addr, data );
+
+}
+
+function setValueV3fArray( gl, v ) {
+
+	const data = flatten( v, this.size, 3 );
+
+	gl.uniform3fv( this.addr, data );
+
+}
+
+function setValueV4fArray( gl, v ) {
+
+	const data = flatten( v, this.size, 4 );
+
+	gl.uniform4fv( this.addr, data );
+
+}
+
+// Array of matrices (from flat array or array of THREE.MatrixN)
+
+function setValueM2Array( gl, v ) {
+
+	const data = flatten( v, this.size, 4 );
+
+	gl.uniformMatrix2fv( this.addr, false, data );
+
+}
+
+function setValueM3Array( gl, v ) {
+
+	const data = flatten( v, this.size, 9 );
+
+	gl.uniformMatrix3fv( this.addr, false, data );
+
+}
+
+function setValueM4Array( gl, v ) {
+
+	const data = flatten( v, this.size, 16 );
+
+	gl.uniformMatrix4fv( this.addr, false, data );
+
+}
+
+// Array of integer / boolean
+
+function setValueV1iArray( gl, v ) {
+
+	gl.uniform1iv( this.addr, v );
+
+}
+
+// Array of integer / boolean vectors (from flat array)
+
+function setValueV2iArray( gl, v ) {
+
+	gl.uniform2iv( this.addr, v );
+
+}
+
+function setValueV3iArray( gl, v ) {
+
+	gl.uniform3iv( this.addr, v );
+
+}
+
+function setValueV4iArray( gl, v ) {
+
+	gl.uniform4iv( this.addr, v );
+
+}
+
+// Array of unsigned integer
+
+function setValueV1uiArray( gl, v ) {
+
+	gl.uniform1uiv( this.addr, v );
+
+}
+
+// Array of unsigned integer vectors (from flat array)
+
+function setValueV2uiArray( gl, v ) {
+
+	gl.uniform2uiv( this.addr, v );
+
+}
+
+function setValueV3uiArray( gl, v ) {
+
+	gl.uniform3uiv( this.addr, v );
+
+}
+
+function setValueV4uiArray( gl, v ) {
+
+	gl.uniform4uiv( this.addr, v );
+
+}
+
+
+// Array of textures (2D / 3D / Cube / 2DArray)
+
+function setValueT1Array( gl, v, textures ) {
+
+	const cache = this.cache;
+
+	const n = v.length;
+
+	const units = allocTexUnits( textures, n );
+
+	if ( ! arraysEqual( cache, units ) ) {
+
+		gl.uniform1iv( this.addr, units );
+
+		copyArray( cache, units );
+
+	}
+
+	for ( let i = 0; i !== n; ++ i ) {
+
+		textures.setTexture2D( v[ i ] || emptyTexture, units[ i ] );
+
+	}
+
+}
+
+function setValueT3DArray( gl, v, textures ) {
+
+	const cache = this.cache;
+
+	const n = v.length;
+
+	const units = allocTexUnits( textures, n );
+
+	if ( ! arraysEqual( cache, units ) ) {
+
+		gl.uniform1iv( this.addr, units );
+
+		copyArray( cache, units );
+
+	}
+
+	for ( let i = 0; i !== n; ++ i ) {
+
+		textures.setTexture3D( v[ i ] || empty3dTexture, units[ i ] );
+
+	}
+
+}
+
+function setValueT6Array( gl, v, textures ) {
+
+	const cache = this.cache;
+
+	const n = v.length;
+
+	const units = allocTexUnits( textures, n );
+
+	if ( ! arraysEqual( cache, units ) ) {
+
+		gl.uniform1iv( this.addr, units );
+
+		copyArray( cache, units );
+
+	}
+
+	for ( let i = 0; i !== n; ++ i ) {
+
+		textures.setTextureCube( v[ i ] || emptyCubeTexture, units[ i ] );
+
+	}
+
+}
+
+function setValueT2DArrayArray( gl, v, textures ) {
+
+	const cache = this.cache;
+
+	const n = v.length;
+
+	const units = allocTexUnits( textures, n );
+
+	if ( ! arraysEqual( cache, units ) ) {
+
+		gl.uniform1iv( this.addr, units );
+
+		copyArray( cache, units );
+
+	}
+
+	for ( let i = 0; i !== n; ++ i ) {
+
+		textures.setTexture2DArray( v[ i ] || emptyArrayTexture, units[ i ] );
+
+	}
+
+}
+
+
+// Helper to pick the right setter for a pure (bottom-level) array
+
+function getPureArraySetter( type ) {
+
+	switch ( type ) {
+
+		case 0x1406: return setValueV1fArray; // FLOAT
+		case 0x8b50: return setValueV2fArray; // _VEC2
+		case 0x8b51: return setValueV3fArray; // _VEC3
+		case 0x8b52: return setValueV4fArray; // _VEC4
+
+		case 0x8b5a: return setValueM2Array; // _MAT2
+		case 0x8b5b: return setValueM3Array; // _MAT3
+		case 0x8b5c: return setValueM4Array; // _MAT4
+
+		case 0x1404: case 0x8b56: return setValueV1iArray; // INT, BOOL
+		case 0x8b53: case 0x8b57: return setValueV2iArray; // _VEC2
+		case 0x8b54: case 0x8b58: return setValueV3iArray; // _VEC3
+		case 0x8b55: case 0x8b59: return setValueV4iArray; // _VEC4
+
+		case 0x1405: return setValueV1uiArray; // UINT
+		case 0x8dc6: return setValueV2uiArray; // _VEC2
+		case 0x8dc7: return setValueV3uiArray; // _VEC3
+		case 0x8dc8: return setValueV4uiArray; // _VEC4
+
+		case 0x8b5e: // SAMPLER_2D
+		case 0x8d66: // SAMPLER_EXTERNAL_OES
+		case 0x8dca: // INT_SAMPLER_2D
+		case 0x8dd2: // UNSIGNED_INT_SAMPLER_2D
+		case 0x8b62: // SAMPLER_2D_SHADOW
+			return setValueT1Array;
+
+		case 0x8b5f: // SAMPLER_3D
+		case 0x8dcb: // INT_SAMPLER_3D
+		case 0x8dd3: // UNSIGNED_INT_SAMPLER_3D
+			return setValueT3DArray;
+
+		case 0x8b60: // SAMPLER_CUBE
+		case 0x8dcc: // INT_SAMPLER_CUBE
+		case 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE
+		case 0x8dc5: // SAMPLER_CUBE_SHADOW
+			return setValueT6Array;
+
+		case 0x8dc1: // SAMPLER_2D_ARRAY
+		case 0x8dcf: // INT_SAMPLER_2D_ARRAY
+		case 0x8dd7: // UNSIGNED_INT_SAMPLER_2D_ARRAY
+		case 0x8dc4: // SAMPLER_2D_ARRAY_SHADOW
+			return setValueT2DArrayArray;
+
+	}
+
+}
+
+// --- Uniform Classes ---
+
+class SingleUniform {
+
+	constructor( id, activeInfo, addr ) {
+
+		this.id = id;
+		this.addr = addr;
+		this.cache = [];
+		this.type = activeInfo.type;
+		this.setValue = getSingularSetter( activeInfo.type );
+
+		// this.path = activeInfo.name; // DEBUG
+
+	}
+
+}
+
+class PureArrayUniform {
+
+	constructor( id, activeInfo, addr ) {
+
+		this.id = id;
+		this.addr = addr;
+		this.cache = [];
+		this.type = activeInfo.type;
+		this.size = activeInfo.size;
+		this.setValue = getPureArraySetter( activeInfo.type );
+
+		// this.path = activeInfo.name; // DEBUG
+
+	}
+
+}
+
+class StructuredUniform {
+
+	constructor( id ) {
+
+		this.id = id;
+
+		this.seq = [];
+		this.map = {};
+
+	}
+
+	setValue( gl, value, textures ) {
+
+		const seq = this.seq;
+
+		for ( let i = 0, n = seq.length; i !== n; ++ i ) {
+
+			const u = seq[ i ];
+			u.setValue( gl, value[ u.id ], textures );
+
+		}
+
+	}
+
+}
+
+// --- Top-level ---
+
+// Parser - builds up the property tree from the path strings
+
+const RePathPart = /(\w+)(\])?(\[|\.)?/g;
+
+// extracts
+// 	- the identifier (member name or array index)
+//  - followed by an optional right bracket (found when array index)
+//  - followed by an optional left bracket or dot (type of subscript)
+//
+// Note: These portions can be read in a non-overlapping fashion and
+// allow straightforward parsing of the hierarchy that WebGL encodes
+// in the uniform names.
+
+function addUniform( container, uniformObject ) {
+
+	container.seq.push( uniformObject );
+	container.map[ uniformObject.id ] = uniformObject;
+
+}
+
+function parseUniform( activeInfo, addr, container ) {
+
+	const path = activeInfo.name,
+		pathLength = path.length;
+
+	// reset RegExp object, because of the early exit of a previous run
+	RePathPart.lastIndex = 0;
+
+	while ( true ) {
+
+		const match = RePathPart.exec( path ),
+			matchEnd = RePathPart.lastIndex;
+
+		let id = match[ 1 ];
+		const idIsIndex = match[ 2 ] === ']',
+			subscript = match[ 3 ];
+
+		if ( idIsIndex ) id = id | 0; // convert to integer
+
+		if ( subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength ) {
+
+			// bare name or "pure" bottom-level array "[0]" suffix
+
+			addUniform( container, subscript === undefined ?
+				new SingleUniform( id, activeInfo, addr ) :
+				new PureArrayUniform( id, activeInfo, addr ) );
+
+			break;
+
+		} else {
+
+			// step into inner node / create it in case it doesn't exist
+
+			const map = container.map;
+			let next = map[ id ];
+
+			if ( next === undefined ) {
+
+				next = new StructuredUniform( id );
+				addUniform( container, next );
+
+			}
+
+			container = next;
+
+		}
+
+	}
+
+}
+
+// Root Container
+
+class WebGLUniforms {
+
+	constructor( gl, program ) {
+
+		this.seq = [];
+		this.map = {};
+
+		const n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS );
+
+		for ( let i = 0; i < n; ++ i ) {
+
+			const info = gl.getActiveUniform( program, i ),
+				addr = gl.getUniformLocation( program, info.name );
+
+			parseUniform( info, addr, this );
+
+		}
+
+	}
+
+	setValue( gl, name, value, textures ) {
+
+		const u = this.map[ name ];
+
+		if ( u !== undefined ) u.setValue( gl, value, textures );
+
+	}
+
+	setOptional( gl, object, name ) {
+
+		const v = object[ name ];
+
+		if ( v !== undefined ) this.setValue( gl, name, v );
+
+	}
+
+	static upload( gl, seq, values, textures ) {
+
+		for ( let i = 0, n = seq.length; i !== n; ++ i ) {
+
+			const u = seq[ i ],
+				v = values[ u.id ];
+
+			if ( v.needsUpdate !== false ) {
+
+				// note: always updating when .needsUpdate is undefined
+				u.setValue( gl, v.value, textures );
+
+			}
+
+		}
+
+	}
+
+	static seqWithValue( seq, values ) {
+
+		const r = [];
+
+		for ( let i = 0, n = seq.length; i !== n; ++ i ) {
+
+			const u = seq[ i ];
+			if ( u.id in values ) r.push( u );
+
+		}
+
+		return r;
+
+	}
+
+}
+
+function WebGLShader( gl, type, string ) {
+
+	const shader = gl.createShader( type );
+
+	gl.shaderSource( shader, string );
+	gl.compileShader( shader );
+
+	return shader;
+
+}
+
+// From https://www.khronos.org/registry/webgl/extensions/KHR_parallel_shader_compile/
+const COMPLETION_STATUS_KHR = 0x91B1;
+
+let programIdCount = 0;
+
+function handleSource( string, errorLine ) {
+
+	const lines = string.split( '\n' );
+	const lines2 = [];
+
+	const from = Math.max( errorLine - 6, 0 );
+	const to = Math.min( errorLine + 6, lines.length );
+
+	for ( let i = from; i < to; i ++ ) {
+
+		const line = i + 1;
+		lines2.push( `${line === errorLine ? '>' : ' '} ${line}: ${lines[ i ]}` );
+
+	}
+
+	return lines2.join( '\n' );
+
+}
+
+function getEncodingComponents( colorSpace ) {
+
+	const workingPrimaries = ColorManagement.getPrimaries( ColorManagement.workingColorSpace );
+	const encodingPrimaries = ColorManagement.getPrimaries( colorSpace );
+
+	let gamutMapping;
+
+	if ( workingPrimaries === encodingPrimaries ) {
+
+		gamutMapping = '';
+
+	} else if ( workingPrimaries === P3Primaries && encodingPrimaries === Rec709Primaries ) {
+
+		gamutMapping = 'LinearDisplayP3ToLinearSRGB';
+
+	} else if ( workingPrimaries === Rec709Primaries && encodingPrimaries === P3Primaries ) {
+
+		gamutMapping = 'LinearSRGBToLinearDisplayP3';
+
+	}
+
+	switch ( colorSpace ) {
+
+		case LinearSRGBColorSpace:
+		case LinearDisplayP3ColorSpace:
+			return [ gamutMapping, 'LinearTransferOETF' ];
+
+		case SRGBColorSpace:
+		case DisplayP3ColorSpace:
+			return [ gamutMapping, 'sRGBTransferOETF' ];
+
+		default:
+			console.warn( 'THREE.WebGLProgram: Unsupported color space:', colorSpace );
+			return [ gamutMapping, 'LinearTransferOETF' ];
+
+	}
+
+}
+
+function getShaderErrors( gl, shader, type ) {
+
+	const status = gl.getShaderParameter( shader, gl.COMPILE_STATUS );
+	const errors = gl.getShaderInfoLog( shader ).trim();
+
+	if ( status && errors === '' ) return '';
+
+	const errorMatches = /ERROR: 0:(\d+)/.exec( errors );
+	if ( errorMatches ) {
+
+		// --enable-privileged-webgl-extension
+		// console.log( '**' + type + '**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );
+
+		const errorLine = parseInt( errorMatches[ 1 ] );
+		return type.toUpperCase() + '\n\n' + errors + '\n\n' + handleSource( gl.getShaderSource( shader ), errorLine );
+
+	} else {
+
+		return errors;
+
+	}
+
+}
+
+function getTexelEncodingFunction( functionName, colorSpace ) {
+
+	const components = getEncodingComponents( colorSpace );
+	return `vec4 ${functionName}( vec4 value ) { return ${components[ 0 ]}( ${components[ 1 ]}( value ) ); }`;
+
+}
+
+function getToneMappingFunction( functionName, toneMapping ) {
+
+	let toneMappingName;
+
+	switch ( toneMapping ) {
+
+		case LinearToneMapping:
+			toneMappingName = 'Linear';
+			break;
+
+		case ReinhardToneMapping:
+			toneMappingName = 'Reinhard';
+			break;
+
+		case CineonToneMapping:
+			toneMappingName = 'OptimizedCineon';
+			break;
+
+		case ACESFilmicToneMapping:
+			toneMappingName = 'ACESFilmic';
+			break;
+
+		case AgXToneMapping:
+			toneMappingName = 'AgX';
+			break;
+
+		case CustomToneMapping:
+			toneMappingName = 'Custom';
+			break;
+
+		default:
+			console.warn( 'THREE.WebGLProgram: Unsupported toneMapping:', toneMapping );
+			toneMappingName = 'Linear';
+
+	}
+
+	return 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';
+
+}
+
+function generateExtensions( parameters ) {
+
+	const chunks = [
+		( parameters.extensionDerivatives || !! parameters.envMapCubeUVHeight || parameters.bumpMap || parameters.normalMapTangentSpace || parameters.clearcoatNormalMap || parameters.flatShading || parameters.shaderID === 'physical' ) ? '#extension GL_OES_standard_derivatives : enable' : '',
+		( parameters.extensionFragDepth || parameters.logarithmicDepthBuffer ) && parameters.rendererExtensionFragDepth ? '#extension GL_EXT_frag_depth : enable' : '',
+		( parameters.extensionDrawBuffers && parameters.rendererExtensionDrawBuffers ) ? '#extension GL_EXT_draw_buffers : require' : '',
+		( parameters.extensionShaderTextureLOD || parameters.envMap || parameters.transmission ) && parameters.rendererExtensionShaderTextureLod ? '#extension GL_EXT_shader_texture_lod : enable' : ''
+	];
+
+	return chunks.filter( filterEmptyLine ).join( '\n' );
+
+}
+
+function generateVertexExtensions( parameters ) {
+
+	const chunks = [
+		parameters.extensionClipCullDistance ? '#extension GL_ANGLE_clip_cull_distance : require' : ''
+	];
+
+	return chunks.filter( filterEmptyLine ).join( '\n' );
+
+}
+
+function generateDefines( defines ) {
+
+	const chunks = [];
+
+	for ( const name in defines ) {
+
+		const value = defines[ name ];
+
+		if ( value === false ) continue;
+
+		chunks.push( '#define ' + name + ' ' + value );
+
+	}
+
+	return chunks.join( '\n' );
+
+}
+
+function fetchAttributeLocations( gl, program ) {
+
+	const attributes = {};
+
+	const n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES );
+
+	for ( let i = 0; i < n; i ++ ) {
+
+		const info = gl.getActiveAttrib( program, i );
+		const name = info.name;
+
+		let locationSize = 1;
+		if ( info.type === gl.FLOAT_MAT2 ) locationSize = 2;
+		if ( info.type === gl.FLOAT_MAT3 ) locationSize = 3;
+		if ( info.type === gl.FLOAT_MAT4 ) locationSize = 4;
+
+		// console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );
+
+		attributes[ name ] = {
+			type: info.type,
+			location: gl.getAttribLocation( program, name ),
+			locationSize: locationSize
+		};
+
+	}
+
+	return attributes;
+
+}
+
+function filterEmptyLine( string ) {
+
+	return string !== '';
+
+}
+
+function replaceLightNums( string, parameters ) {
+
+	const numSpotLightCoords = parameters.numSpotLightShadows + parameters.numSpotLightMaps - parameters.numSpotLightShadowsWithMaps;
+
+	return string
+		.replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )
+		.replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )
+		.replace( /NUM_SPOT_LIGHT_MAPS/g, parameters.numSpotLightMaps )
+		.replace( /NUM_SPOT_LIGHT_COORDS/g, numSpotLightCoords )
+		.replace( /NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights )
+		.replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )
+		.replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights )
+		.replace( /NUM_DIR_LIGHT_SHADOWS/g, parameters.numDirLightShadows )
+		.replace( /NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g, parameters.numSpotLightShadowsWithMaps )
+		.replace( /NUM_SPOT_LIGHT_SHADOWS/g, parameters.numSpotLightShadows )
+		.replace( /NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows );
+
+}
+
+function replaceClippingPlaneNums( string, parameters ) {
+
+	return string
+		.replace( /NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes )
+		.replace( /UNION_CLIPPING_PLANES/g, ( parameters.numClippingPlanes - parameters.numClipIntersection ) );
+
+}
+
+// Resolve Includes
+
+const includePattern = /^[ \t]*#include +<([\w\d./]+)>/gm;
+
+function resolveIncludes( string ) {
+
+	return string.replace( includePattern, includeReplacer );
+
+}
+
+const shaderChunkMap = new Map( [
+	[ 'encodings_fragment', 'colorspace_fragment' ], // @deprecated, r154
+	[ 'encodings_pars_fragment', 'colorspace_pars_fragment' ], // @deprecated, r154
+	[ 'output_fragment', 'opaque_fragment' ], // @deprecated, r154
+] );
+
+function includeReplacer( match, include ) {
+
+	let string = ShaderChunk[ include ];
+
+	if ( string === undefined ) {
+
+		const newInclude = shaderChunkMap.get( include );
+
+		if ( newInclude !== undefined ) {
+
+			string = ShaderChunk[ newInclude ];
+			console.warn( 'THREE.WebGLRenderer: Shader chunk "%s" has been deprecated. Use "%s" instead.', include, newInclude );
+
+		} else {
+
+			throw new Error( 'Can not resolve #include <' + include + '>' );
+
+		}
+
+	}
+
+	return resolveIncludes( string );
+
+}
+
+// Unroll Loops
+
+const unrollLoopPattern = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
+
+function unrollLoops( string ) {
+
+	return string.replace( unrollLoopPattern, loopReplacer );
+
+}
+
+function loopReplacer( match, start, end, snippet ) {
+
+	let string = '';
+
+	for ( let i = parseInt( start ); i < parseInt( end ); i ++ ) {
+
+		string += snippet
+			.replace( /\[\s*i\s*\]/g, '[ ' + i + ' ]' )
+			.replace( /UNROLLED_LOOP_INDEX/g, i );
+
+	}
+
+	return string;
+
+}
+
+//
+
+function generatePrecision( parameters ) {
+
+	let precisionstring = 'precision ' + parameters.precision + ' float;\nprecision ' + parameters.precision + ' int;';
+
+	if ( parameters.precision === 'highp' ) {
+
+		precisionstring += '\n#define HIGH_PRECISION';
+
+	} else if ( parameters.precision === 'mediump' ) {
+
+		precisionstring += '\n#define MEDIUM_PRECISION';
+
+	} else if ( parameters.precision === 'lowp' ) {
+
+		precisionstring += '\n#define LOW_PRECISION';
+
+	}
+
+	return precisionstring;
+
+}
+
+function generateShadowMapTypeDefine( parameters ) {
+
+	let shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';
+
+	if ( parameters.shadowMapType === PCFShadowMap ) {
+
+		shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';
+
+	} else if ( parameters.shadowMapType === PCFSoftShadowMap ) {
+
+		shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';
+
+	} else if ( parameters.shadowMapType === VSMShadowMap ) {
+
+		shadowMapTypeDefine = 'SHADOWMAP_TYPE_VSM';
+
+	}
+
+	return shadowMapTypeDefine;
+
+}
+
+function generateEnvMapTypeDefine( parameters ) {
+
+	let envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
+
+	if ( parameters.envMap ) {
+
+		switch ( parameters.envMapMode ) {
+
+			case CubeReflectionMapping:
+			case CubeRefractionMapping:
+				envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
+				break;
+
+			case CubeUVReflectionMapping:
+				envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
+				break;
+
+		}
+
+	}
+
+	return envMapTypeDefine;
+
+}
+
+function generateEnvMapModeDefine( parameters ) {
+
+	let envMapModeDefine = 'ENVMAP_MODE_REFLECTION';
+
+	if ( parameters.envMap ) {
+
+		switch ( parameters.envMapMode ) {
+
+			case CubeRefractionMapping:
+
+				envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
+				break;
+
+		}
+
+	}
+
+	return envMapModeDefine;
+
+}
+
+function generateEnvMapBlendingDefine( parameters ) {
+
+	let envMapBlendingDefine = 'ENVMAP_BLENDING_NONE';
+
+	if ( parameters.envMap ) {
+
+		switch ( parameters.combine ) {
+
+			case MultiplyOperation:
+				envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
+				break;
+
+			case MixOperation:
+				envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
+				break;
+
+			case AddOperation:
+				envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
+				break;
+
+		}
+
+	}
+
+	return envMapBlendingDefine;
+
+}
+
+function generateCubeUVSize( parameters ) {
+
+	const imageHeight = parameters.envMapCubeUVHeight;
+
+	if ( imageHeight === null ) return null;
+
+	const maxMip = Math.log2( imageHeight ) - 2;
+
+	const texelHeight = 1.0 / imageHeight;
+
+	const texelWidth = 1.0 / ( 3 * Math.max( Math.pow( 2, maxMip ), 7 * 16 ) );
+
+	return { texelWidth, texelHeight, maxMip };
+
+}
+
+function WebGLProgram( renderer, cacheKey, parameters, bindingStates ) {
+
+	// TODO Send this event to Three.js DevTools
+	// console.log( 'WebGLProgram', cacheKey );
+
+	const gl = renderer.getContext();
+
+	const defines = parameters.defines;
+
+	let vertexShader = parameters.vertexShader;
+	let fragmentShader = parameters.fragmentShader;
+
+	const shadowMapTypeDefine = generateShadowMapTypeDefine( parameters );
+	const envMapTypeDefine = generateEnvMapTypeDefine( parameters );
+	const envMapModeDefine = generateEnvMapModeDefine( parameters );
+	const envMapBlendingDefine = generateEnvMapBlendingDefine( parameters );
+	const envMapCubeUVSize = generateCubeUVSize( parameters );
+
+	const customExtensions = parameters.isWebGL2 ? '' : generateExtensions( parameters );
+
+	const customVertexExtensions = generateVertexExtensions( parameters );
+
+	const customDefines = generateDefines( defines );
+
+	const program = gl.createProgram();
+
+	let prefixVertex, prefixFragment;
+	let versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\n' : '';
+
+	if ( parameters.isRawShaderMaterial ) {
+
+		prefixVertex = [
+
+			'#define SHADER_TYPE ' + parameters.shaderType,
+			'#define SHADER_NAME ' + parameters.shaderName,
+
+			customDefines
+
+		].filter( filterEmptyLine ).join( '\n' );
+
+		if ( prefixVertex.length > 0 ) {
+
+			prefixVertex += '\n';
+
+		}
+
+		prefixFragment = [
+
+			customExtensions,
+
+			'#define SHADER_TYPE ' + parameters.shaderType,
+			'#define SHADER_NAME ' + parameters.shaderName,
+
+			customDefines
+
+		].filter( filterEmptyLine ).join( '\n' );
+
+		if ( prefixFragment.length > 0 ) {
+
+			prefixFragment += '\n';
+
+		}
+
+	} else {
+
+		prefixVertex = [
+
+			generatePrecision( parameters ),
+
+			'#define SHADER_TYPE ' + parameters.shaderType,
+			'#define SHADER_NAME ' + parameters.shaderName,
+
+			customDefines,
+
+			parameters.extensionClipCullDistance ? '#define USE_CLIP_DISTANCE' : '',
+			parameters.batching ? '#define USE_BATCHING' : '',
+			parameters.instancing ? '#define USE_INSTANCING' : '',
+			parameters.instancingColor ? '#define USE_INSTANCING_COLOR' : '',
+
+			parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
+			parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
+
+			parameters.map ? '#define USE_MAP' : '',
+			parameters.envMap ? '#define USE_ENVMAP' : '',
+			parameters.envMap ? '#define ' + envMapModeDefine : '',
+			parameters.lightMap ? '#define USE_LIGHTMAP' : '',
+			parameters.aoMap ? '#define USE_AOMAP' : '',
+			parameters.bumpMap ? '#define USE_BUMPMAP' : '',
+			parameters.normalMap ? '#define USE_NORMALMAP' : '',
+			parameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',
+			parameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',
+			parameters.displacementMap ? '#define USE_DISPLACEMENTMAP' : '',
+			parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
+
+			parameters.anisotropy ? '#define USE_ANISOTROPY' : '',
+			parameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',
+
+			parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
+			parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
+			parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
+
+			parameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',
+			parameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',
+
+			parameters.specularMap ? '#define USE_SPECULARMAP' : '',
+			parameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',
+			parameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',
+
+			parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
+			parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
+			parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
+			parameters.alphaHash ? '#define USE_ALPHAHASH' : '',
+
+			parameters.transmission ? '#define USE_TRANSMISSION' : '',
+			parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
+			parameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',
+
+			parameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',
+			parameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',
+
+			//
+
+			parameters.mapUv ? '#define MAP_UV ' + parameters.mapUv : '',
+			parameters.alphaMapUv ? '#define ALPHAMAP_UV ' + parameters.alphaMapUv : '',
+			parameters.lightMapUv ? '#define LIGHTMAP_UV ' + parameters.lightMapUv : '',
+			parameters.aoMapUv ? '#define AOMAP_UV ' + parameters.aoMapUv : '',
+			parameters.emissiveMapUv ? '#define EMISSIVEMAP_UV ' + parameters.emissiveMapUv : '',
+			parameters.bumpMapUv ? '#define BUMPMAP_UV ' + parameters.bumpMapUv : '',
+			parameters.normalMapUv ? '#define NORMALMAP_UV ' + parameters.normalMapUv : '',
+			parameters.displacementMapUv ? '#define DISPLACEMENTMAP_UV ' + parameters.displacementMapUv : '',
+
+			parameters.metalnessMapUv ? '#define METALNESSMAP_UV ' + parameters.metalnessMapUv : '',
+			parameters.roughnessMapUv ? '#define ROUGHNESSMAP_UV ' + parameters.roughnessMapUv : '',
+
+			parameters.anisotropyMapUv ? '#define ANISOTROPYMAP_UV ' + parameters.anisotropyMapUv : '',
+
+			parameters.clearcoatMapUv ? '#define CLEARCOATMAP_UV ' + parameters.clearcoatMapUv : '',
+			parameters.clearcoatNormalMapUv ? '#define CLEARCOAT_NORMALMAP_UV ' + parameters.clearcoatNormalMapUv : '',
+			parameters.clearcoatRoughnessMapUv ? '#define CLEARCOAT_ROUGHNESSMAP_UV ' + parameters.clearcoatRoughnessMapUv : '',
+
+			parameters.iridescenceMapUv ? '#define IRIDESCENCEMAP_UV ' + parameters.iridescenceMapUv : '',
+			parameters.iridescenceThicknessMapUv ? '#define IRIDESCENCE_THICKNESSMAP_UV ' + parameters.iridescenceThicknessMapUv : '',
+
+			parameters.sheenColorMapUv ? '#define SHEEN_COLORMAP_UV ' + parameters.sheenColorMapUv : '',
+			parameters.sheenRoughnessMapUv ? '#define SHEEN_ROUGHNESSMAP_UV ' + parameters.sheenRoughnessMapUv : '',
+
+			parameters.specularMapUv ? '#define SPECULARMAP_UV ' + parameters.specularMapUv : '',
+			parameters.specularColorMapUv ? '#define SPECULAR_COLORMAP_UV ' + parameters.specularColorMapUv : '',
+			parameters.specularIntensityMapUv ? '#define SPECULAR_INTENSITYMAP_UV ' + parameters.specularIntensityMapUv : '',
+
+			parameters.transmissionMapUv ? '#define TRANSMISSIONMAP_UV ' + parameters.transmissionMapUv : '',
+			parameters.thicknessMapUv ? '#define THICKNESSMAP_UV ' + parameters.thicknessMapUv : '',
+
+			//
+
+			parameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',
+			parameters.vertexColors ? '#define USE_COLOR' : '',
+			parameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',
+			parameters.vertexUv1s ? '#define USE_UV1' : '',
+			parameters.vertexUv2s ? '#define USE_UV2' : '',
+			parameters.vertexUv3s ? '#define USE_UV3' : '',
+
+			parameters.pointsUvs ? '#define USE_POINTS_UV' : '',
+
+			parameters.flatShading ? '#define FLAT_SHADED' : '',
+
+			parameters.skinning ? '#define USE_SKINNING' : '',
+
+			parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
+			parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',
+			( parameters.morphColors && parameters.isWebGL2 ) ? '#define USE_MORPHCOLORS' : '',
+			( parameters.morphTargetsCount > 0 && parameters.isWebGL2 ) ? '#define MORPHTARGETS_TEXTURE' : '',
+			( parameters.morphTargetsCount > 0 && parameters.isWebGL2 ) ? '#define MORPHTARGETS_TEXTURE_STRIDE ' + parameters.morphTextureStride : '',
+			( parameters.morphTargetsCount > 0 && parameters.isWebGL2 ) ? '#define MORPHTARGETS_COUNT ' + parameters.morphTargetsCount : '',
+			parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
+			parameters.flipSided ? '#define FLIP_SIDED' : '',
+
+			parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
+			parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
+
+			parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',
+
+			parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
+
+			parameters.useLegacyLights ? '#define LEGACY_LIGHTS' : '',
+
+			parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
+			( parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+			'uniform mat4 modelMatrix;',
+			'uniform mat4 modelViewMatrix;',
+			'uniform mat4 projectionMatrix;',
+			'uniform mat4 viewMatrix;',
+			'uniform mat3 normalMatrix;',
+			'uniform vec3 cameraPosition;',
+			'uniform bool isOrthographic;',
+
+			'#ifdef USE_INSTANCING',
+
+			'	attribute mat4 instanceMatrix;',
+
+			'#endif',
+
+			'#ifdef USE_INSTANCING_COLOR',
+
+			'	attribute vec3 instanceColor;',
+
+			'#endif',
+
+			'attribute vec3 position;',
+			'attribute vec3 normal;',
+			'attribute vec2 uv;',
+
+			'#ifdef USE_UV1',
+
+			'	attribute vec2 uv1;',
+
+			'#endif',
+
+			'#ifdef USE_UV2',
+
+			'	attribute vec2 uv2;',
+
+			'#endif',
+
+			'#ifdef USE_UV3',
+
+			'	attribute vec2 uv3;',
+
+			'#endif',
+
+			'#ifdef USE_TANGENT',
+
+			'	attribute vec4 tangent;',
+
+			'#endif',
+
+			'#if defined( USE_COLOR_ALPHA )',
+
+			'	attribute vec4 color;',
+
+			'#elif defined( USE_COLOR )',
+
+			'	attribute vec3 color;',
+
+			'#endif',
+
+			'#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )',
+
+			'	attribute vec3 morphTarget0;',
+			'	attribute vec3 morphTarget1;',
+			'	attribute vec3 morphTarget2;',
+			'	attribute vec3 morphTarget3;',
+
+			'	#ifdef USE_MORPHNORMALS',
+
+			'		attribute vec3 morphNormal0;',
+			'		attribute vec3 morphNormal1;',
+			'		attribute vec3 morphNormal2;',
+			'		attribute vec3 morphNormal3;',
+
+			'	#else',
+
+			'		attribute vec3 morphTarget4;',
+			'		attribute vec3 morphTarget5;',
+			'		attribute vec3 morphTarget6;',
+			'		attribute vec3 morphTarget7;',
+
+			'	#endif',
+
+			'#endif',
+
+			'#ifdef USE_SKINNING',
+
+			'	attribute vec4 skinIndex;',
+			'	attribute vec4 skinWeight;',
+
+			'#endif',
+
+			'\n'
+
+		].filter( filterEmptyLine ).join( '\n' );
+
+		prefixFragment = [
+
+			customExtensions,
+
+			generatePrecision( parameters ),
+
+			'#define SHADER_TYPE ' + parameters.shaderType,
+			'#define SHADER_NAME ' + parameters.shaderName,
+
+			customDefines,
+
+			parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
+			parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
+
+			parameters.map ? '#define USE_MAP' : '',
+			parameters.matcap ? '#define USE_MATCAP' : '',
+			parameters.envMap ? '#define USE_ENVMAP' : '',
+			parameters.envMap ? '#define ' + envMapTypeDefine : '',
+			parameters.envMap ? '#define ' + envMapModeDefine : '',
+			parameters.envMap ? '#define ' + envMapBlendingDefine : '',
+			envMapCubeUVSize ? '#define CUBEUV_TEXEL_WIDTH ' + envMapCubeUVSize.texelWidth : '',
+			envMapCubeUVSize ? '#define CUBEUV_TEXEL_HEIGHT ' + envMapCubeUVSize.texelHeight : '',
+			envMapCubeUVSize ? '#define CUBEUV_MAX_MIP ' + envMapCubeUVSize.maxMip + '.0' : '',
+			parameters.lightMap ? '#define USE_LIGHTMAP' : '',
+			parameters.aoMap ? '#define USE_AOMAP' : '',
+			parameters.bumpMap ? '#define USE_BUMPMAP' : '',
+			parameters.normalMap ? '#define USE_NORMALMAP' : '',
+			parameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',
+			parameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',
+			parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
+
+			parameters.anisotropy ? '#define USE_ANISOTROPY' : '',
+			parameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',
+
+			parameters.clearcoat ? '#define USE_CLEARCOAT' : '',
+			parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
+			parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
+			parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
+
+			parameters.iridescence ? '#define USE_IRIDESCENCE' : '',
+			parameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',
+			parameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',
+
+			parameters.specularMap ? '#define USE_SPECULARMAP' : '',
+			parameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',
+			parameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',
+
+			parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
+			parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
+
+			parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
+			parameters.alphaTest ? '#define USE_ALPHATEST' : '',
+			parameters.alphaHash ? '#define USE_ALPHAHASH' : '',
+
+			parameters.sheen ? '#define USE_SHEEN' : '',
+			parameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',
+			parameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',
+
+			parameters.transmission ? '#define USE_TRANSMISSION' : '',
+			parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
+			parameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',
+
+			parameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',
+			parameters.vertexColors || parameters.instancingColor ? '#define USE_COLOR' : '',
+			parameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',
+			parameters.vertexUv1s ? '#define USE_UV1' : '',
+			parameters.vertexUv2s ? '#define USE_UV2' : '',
+			parameters.vertexUv3s ? '#define USE_UV3' : '',
+
+			parameters.pointsUvs ? '#define USE_POINTS_UV' : '',
+
+			parameters.gradientMap ? '#define USE_GRADIENTMAP' : '',
+
+			parameters.flatShading ? '#define FLAT_SHADED' : '',
+
+			parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
+			parameters.flipSided ? '#define FLIP_SIDED' : '',
+
+			parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
+			parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
+
+			parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',
+
+			parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
+
+			parameters.useLegacyLights ? '#define LEGACY_LIGHTS' : '',
+
+			parameters.decodeVideoTexture ? '#define DECODE_VIDEO_TEXTURE' : '',
+
+			parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
+			( parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+			'uniform mat4 viewMatrix;',
+			'uniform vec3 cameraPosition;',
+			'uniform bool isOrthographic;',
+
+			( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '',
+			( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below
+			( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '',
+
+			parameters.dithering ? '#define DITHERING' : '',
+			parameters.opaque ? '#define OPAQUE' : '',
+
+			ShaderChunk[ 'colorspace_pars_fragment' ], // this code is required here because it is used by the various encoding/decoding function defined below
+			getTexelEncodingFunction( 'linearToOutputTexel', parameters.outputColorSpace ),
+
+			parameters.useDepthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',
+
+			'\n'
+
+		].filter( filterEmptyLine ).join( '\n' );
+
+	}
+
+	vertexShader = resolveIncludes( vertexShader );
+	vertexShader = replaceLightNums( vertexShader, parameters );
+	vertexShader = replaceClippingPlaneNums( vertexShader, parameters );
+
+	fragmentShader = resolveIncludes( fragmentShader );
+	fragmentShader = replaceLightNums( fragmentShader, parameters );
+	fragmentShader = replaceClippingPlaneNums( fragmentShader, parameters );
+
+	vertexShader = unrollLoops( vertexShader );
+	fragmentShader = unrollLoops( fragmentShader );
+
+	if ( parameters.isWebGL2 && parameters.isRawShaderMaterial !== true ) {
+
+		// GLSL 3.0 conversion for built-in materials and ShaderMaterial
+
+		versionString = '#version 300 es\n';
+
+		prefixVertex = [
+			customVertexExtensions,
+			'precision mediump sampler2DArray;',
+			'#define attribute in',
+			'#define varying out',
+			'#define texture2D texture'
+		].join( '\n' ) + '\n' + prefixVertex;
+
+		prefixFragment = [
+			'precision mediump sampler2DArray;',
+			'#define varying in',
+			( parameters.glslVersion === GLSL3 ) ? '' : 'layout(location = 0) out highp vec4 pc_fragColor;',
+			( parameters.glslVersion === GLSL3 ) ? '' : '#define gl_FragColor pc_fragColor',
+			'#define gl_FragDepthEXT gl_FragDepth',
+			'#define texture2D texture',
+			'#define textureCube texture',
+			'#define texture2DProj textureProj',
+			'#define texture2DLodEXT textureLod',
+			'#define texture2DProjLodEXT textureProjLod',
+			'#define textureCubeLodEXT textureLod',
+			'#define texture2DGradEXT textureGrad',
+			'#define texture2DProjGradEXT textureProjGrad',
+			'#define textureCubeGradEXT textureGrad'
+		].join( '\n' ) + '\n' + prefixFragment;
+
+	}
+
+	const vertexGlsl = versionString + prefixVertex + vertexShader;
+	const fragmentGlsl = versionString + prefixFragment + fragmentShader;
+
+	// console.log( '*VERTEX*', vertexGlsl );
+	// console.log( '*FRAGMENT*', fragmentGlsl );
+
+	const glVertexShader = WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl );
+	const glFragmentShader = WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl );
+
+	gl.attachShader( program, glVertexShader );
+	gl.attachShader( program, glFragmentShader );
+
+	// Force a particular attribute to index 0.
+
+	if ( parameters.index0AttributeName !== undefined ) {
+
+		gl.bindAttribLocation( program, 0, parameters.index0AttributeName );
+
+	} else if ( parameters.morphTargets === true ) {
+
+		// programs with morphTargets displace position out of attribute 0
+		gl.bindAttribLocation( program, 0, 'position' );
+
+	}
+
+	gl.linkProgram( program );
+
+	function onFirstUse( self ) {
+
+		// check for link errors
+		if ( renderer.debug.checkShaderErrors ) {
+
+			const programLog = gl.getProgramInfoLog( program ).trim();
+			const vertexLog = gl.getShaderInfoLog( glVertexShader ).trim();
+			const fragmentLog = gl.getShaderInfoLog( glFragmentShader ).trim();
+
+			let runnable = true;
+			let haveDiagnostics = true;
+
+			if ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) {
+
+				runnable = false;
+
+				if ( typeof renderer.debug.onShaderError === 'function' ) {
+
+					renderer.debug.onShaderError( gl, program, glVertexShader, glFragmentShader );
+
+				} else {
+
+					// default error reporting
+
+					const vertexErrors = getShaderErrors( gl, glVertexShader, 'vertex' );
+					const fragmentErrors = getShaderErrors( gl, glFragmentShader, 'fragment' );
+
+					console.error(
+						'THREE.WebGLProgram: Shader Error ' + gl.getError() + ' - ' +
+						'VALIDATE_STATUS ' + gl.getProgramParameter( program, gl.VALIDATE_STATUS ) + '\n\n' +
+						'Program Info Log: ' + programLog + '\n' +
+						vertexErrors + '\n' +
+						fragmentErrors
+					);
+
+				}
+
+			} else if ( programLog !== '' ) {
+
+				console.warn( 'THREE.WebGLProgram: Program Info Log:', programLog );
+
+			} else if ( vertexLog === '' || fragmentLog === '' ) {
+
+				haveDiagnostics = false;
+
+			}
+
+			if ( haveDiagnostics ) {
+
+				self.diagnostics = {
+
+					runnable: runnable,
+
+					programLog: programLog,
+
+					vertexShader: {
+
+						log: vertexLog,
+						prefix: prefixVertex
+
+					},
+
+					fragmentShader: {
+
+						log: fragmentLog,
+						prefix: prefixFragment
+
+					}
+
+				};
+
+			}
+
+		}
+
+		// Clean up
+
+		// Crashes in iOS9 and iOS10. #18402
+		// gl.detachShader( program, glVertexShader );
+		// gl.detachShader( program, glFragmentShader );
+
+		gl.deleteShader( glVertexShader );
+		gl.deleteShader( glFragmentShader );
+
+		cachedUniforms = new WebGLUniforms( gl, program );
+		cachedAttributes = fetchAttributeLocations( gl, program );
+
+	}
+
+	// set up caching for uniform locations
+
+	let cachedUniforms;
+
+	this.getUniforms = function () {
+
+		if ( cachedUniforms === undefined ) {
+
+			// Populates cachedUniforms and cachedAttributes
+			onFirstUse( this );
+
+		}
+
+		return cachedUniforms;
+
+	};
+
+	// set up caching for attribute locations
+
+	let cachedAttributes;
+
+	this.getAttributes = function () {
+
+		if ( cachedAttributes === undefined ) {
+
+			// Populates cachedAttributes and cachedUniforms
+			onFirstUse( this );
+
+		}
+
+		return cachedAttributes;
+
+	};
+
+	// indicate when the program is ready to be used. if the KHR_parallel_shader_compile extension isn't supported,
+	// flag the program as ready immediately. It may cause a stall when it's first used.
+
+	let programReady = ( parameters.rendererExtensionParallelShaderCompile === false );
+
+	this.isReady = function () {
+
+		if ( programReady === false ) {
+
+			programReady = gl.getProgramParameter( program, COMPLETION_STATUS_KHR );
+
+		}
+
+		return programReady;
+
+	};
+
+	// free resource
+
+	this.destroy = function () {
+
+		bindingStates.releaseStatesOfProgram( this );
+
+		gl.deleteProgram( program );
+		this.program = undefined;
+
+	};
+
+	//
+
+	this.type = parameters.shaderType;
+	this.name = parameters.shaderName;
+	this.id = programIdCount ++;
+	this.cacheKey = cacheKey;
+	this.usedTimes = 1;
+	this.program = program;
+	this.vertexShader = glVertexShader;
+	this.fragmentShader = glFragmentShader;
+
+	return this;
+
+}
+
+let _id$1 = 0;
+
+class WebGLShaderCache {
+
+	constructor() {
+
+		this.shaderCache = new Map();
+		this.materialCache = new Map();
+
+	}
+
+	update( material ) {
+
+		const vertexShader = material.vertexShader;
+		const fragmentShader = material.fragmentShader;
+
+		const vertexShaderStage = this._getShaderStage( vertexShader );
+		const fragmentShaderStage = this._getShaderStage( fragmentShader );
+
+		const materialShaders = this._getShaderCacheForMaterial( material );
+
+		if ( materialShaders.has( vertexShaderStage ) === false ) {
+
+			materialShaders.add( vertexShaderStage );
+			vertexShaderStage.usedTimes ++;
+
+		}
+
+		if ( materialShaders.has( fragmentShaderStage ) === false ) {
+
+			materialShaders.add( fragmentShaderStage );
+			fragmentShaderStage.usedTimes ++;
+
+		}
+
+		return this;
+
+	}
+
+	remove( material ) {
+
+		const materialShaders = this.materialCache.get( material );
+
+		for ( const shaderStage of materialShaders ) {
+
+			shaderStage.usedTimes --;
+
+			if ( shaderStage.usedTimes === 0 ) this.shaderCache.delete( shaderStage.code );
+
+		}
+
+		this.materialCache.delete( material );
+
+		return this;
+
+	}
+
+	getVertexShaderID( material ) {
+
+		return this._getShaderStage( material.vertexShader ).id;
+
+	}
+
+	getFragmentShaderID( material ) {
+
+		return this._getShaderStage( material.fragmentShader ).id;
+
+	}
+
+	dispose() {
+
+		this.shaderCache.clear();
+		this.materialCache.clear();
+
+	}
+
+	_getShaderCacheForMaterial( material ) {
+
+		const cache = this.materialCache;
+		let set = cache.get( material );
+
+		if ( set === undefined ) {
+
+			set = new Set();
+			cache.set( material, set );
+
+		}
+
+		return set;
+
+	}
+
+	_getShaderStage( code ) {
+
+		const cache = this.shaderCache;
+		let stage = cache.get( code );
+
+		if ( stage === undefined ) {
+
+			stage = new WebGLShaderStage( code );
+			cache.set( code, stage );
+
+		}
+
+		return stage;
+
+	}
+
+}
+
+class WebGLShaderStage {
+
+	constructor( code ) {
+
+		this.id = _id$1 ++;
+
+		this.code = code;
+		this.usedTimes = 0;
+
+	}
+
+}
+
+function WebGLPrograms( renderer, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping ) {
+
+	const _programLayers = new Layers();
+	const _customShaders = new WebGLShaderCache();
+	const programs = [];
+
+	const IS_WEBGL2 = capabilities.isWebGL2;
+	const logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;
+	const SUPPORTS_VERTEX_TEXTURES = capabilities.vertexTextures;
+
+	let precision = capabilities.precision;
+
+	const shaderIDs = {
+		MeshDepthMaterial: 'depth',
+		MeshDistanceMaterial: 'distanceRGBA',
+		MeshNormalMaterial: 'normal',
+		MeshBasicMaterial: 'basic',
+		MeshLambertMaterial: 'lambert',
+		MeshPhongMaterial: 'phong',
+		MeshToonMaterial: 'toon',
+		MeshStandardMaterial: 'physical',
+		MeshPhysicalMaterial: 'physical',
+		MeshMatcapMaterial: 'matcap',
+		LineBasicMaterial: 'basic',
+		LineDashedMaterial: 'dashed',
+		PointsMaterial: 'points',
+		ShadowMaterial: 'shadow',
+		SpriteMaterial: 'sprite'
+	};
+
+	function getChannel( value ) {
+
+		if ( value === 0 ) return 'uv';
+
+		return `uv${ value }`;
+
+	}
+
+	function getParameters( material, lights, shadows, scene, object ) {
+
+		const fog = scene.fog;
+		const geometry = object.geometry;
+		const environment = material.isMeshStandardMaterial ? scene.environment : null;
+
+		const envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || environment );
+		const envMapCubeUVHeight = ( !! envMap ) && ( envMap.mapping === CubeUVReflectionMapping ) ? envMap.image.height : null;
+
+		const shaderID = shaderIDs[ material.type ];
+
+		// heuristics to create shader parameters according to lights in the scene
+		// (not to blow over maxLights budget)
+
+		if ( material.precision !== null ) {
+
+			precision = capabilities.getMaxPrecision( material.precision );
+
+			if ( precision !== material.precision ) {
+
+				console.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );
+
+			}
+
+		}
+
+		//
+
+		const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
+		const morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;
+
+		let morphTextureStride = 0;
+
+		if ( geometry.morphAttributes.position !== undefined ) morphTextureStride = 1;
+		if ( geometry.morphAttributes.normal !== undefined ) morphTextureStride = 2;
+		if ( geometry.morphAttributes.color !== undefined ) morphTextureStride = 3;
+
+		//
+
+		let vertexShader, fragmentShader;
+		let customVertexShaderID, customFragmentShaderID;
+
+		if ( shaderID ) {
+
+			const shader = ShaderLib[ shaderID ];
+
+			vertexShader = shader.vertexShader;
+			fragmentShader = shader.fragmentShader;
+
+		} else {
+
+			vertexShader = material.vertexShader;
+			fragmentShader = material.fragmentShader;
+
+			_customShaders.update( material );
+
+			customVertexShaderID = _customShaders.getVertexShaderID( material );
+			customFragmentShaderID = _customShaders.getFragmentShaderID( material );
+
+		}
+
+		const currentRenderTarget = renderer.getRenderTarget();
+
+		const IS_INSTANCEDMESH = object.isInstancedMesh === true;
+		const IS_BATCHEDMESH = object.isBatchedMesh === true;
+
+		const HAS_MAP = !! material.map;
+		const HAS_MATCAP = !! material.matcap;
+		const HAS_ENVMAP = !! envMap;
+		const HAS_AOMAP = !! material.aoMap;
+		const HAS_LIGHTMAP = !! material.lightMap;
+		const HAS_BUMPMAP = !! material.bumpMap;
+		const HAS_NORMALMAP = !! material.normalMap;
+		const HAS_DISPLACEMENTMAP = !! material.displacementMap;
+		const HAS_EMISSIVEMAP = !! material.emissiveMap;
+
+		const HAS_METALNESSMAP = !! material.metalnessMap;
+		const HAS_ROUGHNESSMAP = !! material.roughnessMap;
+
+		const HAS_ANISOTROPY = material.anisotropy > 0;
+		const HAS_CLEARCOAT = material.clearcoat > 0;
+		const HAS_IRIDESCENCE = material.iridescence > 0;
+		const HAS_SHEEN = material.sheen > 0;
+		const HAS_TRANSMISSION = material.transmission > 0;
+
+		const HAS_ANISOTROPYMAP = HAS_ANISOTROPY && !! material.anisotropyMap;
+
+		const HAS_CLEARCOATMAP = HAS_CLEARCOAT && !! material.clearcoatMap;
+		const HAS_CLEARCOAT_NORMALMAP = HAS_CLEARCOAT && !! material.clearcoatNormalMap;
+		const HAS_CLEARCOAT_ROUGHNESSMAP = HAS_CLEARCOAT && !! material.clearcoatRoughnessMap;
+
+		const HAS_IRIDESCENCEMAP = HAS_IRIDESCENCE && !! material.iridescenceMap;
+		const HAS_IRIDESCENCE_THICKNESSMAP = HAS_IRIDESCENCE && !! material.iridescenceThicknessMap;
+
+		const HAS_SHEEN_COLORMAP = HAS_SHEEN && !! material.sheenColorMap;
+		const HAS_SHEEN_ROUGHNESSMAP = HAS_SHEEN && !! material.sheenRoughnessMap;
+
+		const HAS_SPECULARMAP = !! material.specularMap;
+		const HAS_SPECULAR_COLORMAP = !! material.specularColorMap;
+		const HAS_SPECULAR_INTENSITYMAP = !! material.specularIntensityMap;
+
+		const HAS_TRANSMISSIONMAP = HAS_TRANSMISSION && !! material.transmissionMap;
+		const HAS_THICKNESSMAP = HAS_TRANSMISSION && !! material.thicknessMap;
+
+		const HAS_GRADIENTMAP = !! material.gradientMap;
+
+		const HAS_ALPHAMAP = !! material.alphaMap;
+
+		const HAS_ALPHATEST = material.alphaTest > 0;
+
+		const HAS_ALPHAHASH = !! material.alphaHash;
+
+		const HAS_EXTENSIONS = !! material.extensions;
+
+		const HAS_ATTRIBUTE_UV1 = !! geometry.attributes.uv1;
+		const HAS_ATTRIBUTE_UV2 = !! geometry.attributes.uv2;
+		const HAS_ATTRIBUTE_UV3 = !! geometry.attributes.uv3;
+
+		let toneMapping = NoToneMapping;
+
+		if ( material.toneMapped ) {
+
+			if ( currentRenderTarget === null || currentRenderTarget.isXRRenderTarget === true ) {
+
+				toneMapping = renderer.toneMapping;
+
+			}
+
+		}
+
+		const parameters = {
+
+			isWebGL2: IS_WEBGL2,
+
+			shaderID: shaderID,
+			shaderType: material.type,
+			shaderName: material.name,
+
+			vertexShader: vertexShader,
+			fragmentShader: fragmentShader,
+			defines: material.defines,
+
+			customVertexShaderID: customVertexShaderID,
+			customFragmentShaderID: customFragmentShaderID,
+
+			isRawShaderMaterial: material.isRawShaderMaterial === true,
+			glslVersion: material.glslVersion,
+
+			precision: precision,
+
+			batching: IS_BATCHEDMESH,
+			instancing: IS_INSTANCEDMESH,
+			instancingColor: IS_INSTANCEDMESH && object.instanceColor !== null,
+
+			supportsVertexTextures: SUPPORTS_VERTEX_TEXTURES,
+			outputColorSpace: ( currentRenderTarget === null ) ? renderer.outputColorSpace : ( currentRenderTarget.isXRRenderTarget === true ? currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace ),
+
+			map: HAS_MAP,
+			matcap: HAS_MATCAP,
+			envMap: HAS_ENVMAP,
+			envMapMode: HAS_ENVMAP && envMap.mapping,
+			envMapCubeUVHeight: envMapCubeUVHeight,
+			aoMap: HAS_AOMAP,
+			lightMap: HAS_LIGHTMAP,
+			bumpMap: HAS_BUMPMAP,
+			normalMap: HAS_NORMALMAP,
+			displacementMap: SUPPORTS_VERTEX_TEXTURES && HAS_DISPLACEMENTMAP,
+			emissiveMap: HAS_EMISSIVEMAP,
+
+			normalMapObjectSpace: HAS_NORMALMAP && material.normalMapType === ObjectSpaceNormalMap,
+			normalMapTangentSpace: HAS_NORMALMAP && material.normalMapType === TangentSpaceNormalMap,
+
+			metalnessMap: HAS_METALNESSMAP,
+			roughnessMap: HAS_ROUGHNESSMAP,
+
+			anisotropy: HAS_ANISOTROPY,
+			anisotropyMap: HAS_ANISOTROPYMAP,
+
+			clearcoat: HAS_CLEARCOAT,
+			clearcoatMap: HAS_CLEARCOATMAP,
+			clearcoatNormalMap: HAS_CLEARCOAT_NORMALMAP,
+			clearcoatRoughnessMap: HAS_CLEARCOAT_ROUGHNESSMAP,
+
+			iridescence: HAS_IRIDESCENCE,
+			iridescenceMap: HAS_IRIDESCENCEMAP,
+			iridescenceThicknessMap: HAS_IRIDESCENCE_THICKNESSMAP,
+
+			sheen: HAS_SHEEN,
+			sheenColorMap: HAS_SHEEN_COLORMAP,
+			sheenRoughnessMap: HAS_SHEEN_ROUGHNESSMAP,
+
+			specularMap: HAS_SPECULARMAP,
+			specularColorMap: HAS_SPECULAR_COLORMAP,
+			specularIntensityMap: HAS_SPECULAR_INTENSITYMAP,
+
+			transmission: HAS_TRANSMISSION,
+			transmissionMap: HAS_TRANSMISSIONMAP,
+			thicknessMap: HAS_THICKNESSMAP,
+
+			gradientMap: HAS_GRADIENTMAP,
+
+			opaque: material.transparent === false && material.blending === NormalBlending,
+
+			alphaMap: HAS_ALPHAMAP,
+			alphaTest: HAS_ALPHATEST,
+			alphaHash: HAS_ALPHAHASH,
+
+			combine: material.combine,
+
+			//
+
+			mapUv: HAS_MAP && getChannel( material.map.channel ),
+			aoMapUv: HAS_AOMAP && getChannel( material.aoMap.channel ),
+			lightMapUv: HAS_LIGHTMAP && getChannel( material.lightMap.channel ),
+			bumpMapUv: HAS_BUMPMAP && getChannel( material.bumpMap.channel ),
+			normalMapUv: HAS_NORMALMAP && getChannel( material.normalMap.channel ),
+			displacementMapUv: HAS_DISPLACEMENTMAP && getChannel( material.displacementMap.channel ),
+			emissiveMapUv: HAS_EMISSIVEMAP && getChannel( material.emissiveMap.channel ),
+
+			metalnessMapUv: HAS_METALNESSMAP && getChannel( material.metalnessMap.channel ),
+			roughnessMapUv: HAS_ROUGHNESSMAP && getChannel( material.roughnessMap.channel ),
+
+			anisotropyMapUv: HAS_ANISOTROPYMAP && getChannel( material.anisotropyMap.channel ),
+
+			clearcoatMapUv: HAS_CLEARCOATMAP && getChannel( material.clearcoatMap.channel ),
+			clearcoatNormalMapUv: HAS_CLEARCOAT_NORMALMAP && getChannel( material.clearcoatNormalMap.channel ),
+			clearcoatRoughnessMapUv: HAS_CLEARCOAT_ROUGHNESSMAP && getChannel( material.clearcoatRoughnessMap.channel ),
+
+			iridescenceMapUv: HAS_IRIDESCENCEMAP && getChannel( material.iridescenceMap.channel ),
+			iridescenceThicknessMapUv: HAS_IRIDESCENCE_THICKNESSMAP && getChannel( material.iridescenceThicknessMap.channel ),
+
+			sheenColorMapUv: HAS_SHEEN_COLORMAP && getChannel( material.sheenColorMap.channel ),
+			sheenRoughnessMapUv: HAS_SHEEN_ROUGHNESSMAP && getChannel( material.sheenRoughnessMap.channel ),
+
+			specularMapUv: HAS_SPECULARMAP && getChannel( material.specularMap.channel ),
+			specularColorMapUv: HAS_SPECULAR_COLORMAP && getChannel( material.specularColorMap.channel ),
+			specularIntensityMapUv: HAS_SPECULAR_INTENSITYMAP && getChannel( material.specularIntensityMap.channel ),
+
+			transmissionMapUv: HAS_TRANSMISSIONMAP && getChannel( material.transmissionMap.channel ),
+			thicknessMapUv: HAS_THICKNESSMAP && getChannel( material.thicknessMap.channel ),
+
+			alphaMapUv: HAS_ALPHAMAP && getChannel( material.alphaMap.channel ),
+
+			//
+
+			vertexTangents: !! geometry.attributes.tangent && ( HAS_NORMALMAP || HAS_ANISOTROPY ),
+			vertexColors: material.vertexColors,
+			vertexAlphas: material.vertexColors === true && !! geometry.attributes.color && geometry.attributes.color.itemSize === 4,
+			vertexUv1s: HAS_ATTRIBUTE_UV1,
+			vertexUv2s: HAS_ATTRIBUTE_UV2,
+			vertexUv3s: HAS_ATTRIBUTE_UV3,
+
+			pointsUvs: object.isPoints === true && !! geometry.attributes.uv && ( HAS_MAP || HAS_ALPHAMAP ),
+
+			fog: !! fog,
+			useFog: material.fog === true,
+			fogExp2: ( fog && fog.isFogExp2 ),
+
+			flatShading: material.flatShading === true,
+
+			sizeAttenuation: material.sizeAttenuation === true,
+			logarithmicDepthBuffer: logarithmicDepthBuffer,
+
+			skinning: object.isSkinnedMesh === true,
+
+			morphTargets: geometry.morphAttributes.position !== undefined,
+			morphNormals: geometry.morphAttributes.normal !== undefined,
+			morphColors: geometry.morphAttributes.color !== undefined,
+			morphTargetsCount: morphTargetsCount,
+			morphTextureStride: morphTextureStride,
+
+			numDirLights: lights.directional.length,
+			numPointLights: lights.point.length,
+			numSpotLights: lights.spot.length,
+			numSpotLightMaps: lights.spotLightMap.length,
+			numRectAreaLights: lights.rectArea.length,
+			numHemiLights: lights.hemi.length,
+
+			numDirLightShadows: lights.directionalShadowMap.length,
+			numPointLightShadows: lights.pointShadowMap.length,
+			numSpotLightShadows: lights.spotShadowMap.length,
+			numSpotLightShadowsWithMaps: lights.numSpotLightShadowsWithMaps,
+
+			numLightProbes: lights.numLightProbes,
+
+			numClippingPlanes: clipping.numPlanes,
+			numClipIntersection: clipping.numIntersection,
+
+			dithering: material.dithering,
+
+			shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,
+			shadowMapType: renderer.shadowMap.type,
+
+			toneMapping: toneMapping,
+			useLegacyLights: renderer._useLegacyLights,
+
+			decodeVideoTexture: HAS_MAP && ( material.map.isVideoTexture === true ) && ( ColorManagement.getTransfer( material.map.colorSpace ) === SRGBTransfer ),
+
+			premultipliedAlpha: material.premultipliedAlpha,
+
+			doubleSided: material.side === DoubleSide,
+			flipSided: material.side === BackSide,
+
+			useDepthPacking: material.depthPacking >= 0,
+			depthPacking: material.depthPacking || 0,
+
+			index0AttributeName: material.index0AttributeName,
+
+			extensionDerivatives: HAS_EXTENSIONS && material.extensions.derivatives === true,
+			extensionFragDepth: HAS_EXTENSIONS && material.extensions.fragDepth === true,
+			extensionDrawBuffers: HAS_EXTENSIONS && material.extensions.drawBuffers === true,
+			extensionShaderTextureLOD: HAS_EXTENSIONS && material.extensions.shaderTextureLOD === true,
+			extensionClipCullDistance: HAS_EXTENSIONS && material.extensions.clipCullDistance && extensions.has( 'WEBGL_clip_cull_distance' ),
+
+			rendererExtensionFragDepth: IS_WEBGL2 || extensions.has( 'EXT_frag_depth' ),
+			rendererExtensionDrawBuffers: IS_WEBGL2 || extensions.has( 'WEBGL_draw_buffers' ),
+			rendererExtensionShaderTextureLod: IS_WEBGL2 || extensions.has( 'EXT_shader_texture_lod' ),
+			rendererExtensionParallelShaderCompile: extensions.has( 'KHR_parallel_shader_compile' ),
+
+			customProgramCacheKey: material.customProgramCacheKey()
+
+		};
+
+		return parameters;
+
+	}
+
+	function getProgramCacheKey( parameters ) {
+
+		const array = [];
+
+		if ( parameters.shaderID ) {
+
+			array.push( parameters.shaderID );
+
+		} else {
+
+			array.push( parameters.customVertexShaderID );
+			array.push( parameters.customFragmentShaderID );
+
+		}
+
+		if ( parameters.defines !== undefined ) {
+
+			for ( const name in parameters.defines ) {
+
+				array.push( name );
+				array.push( parameters.defines[ name ] );
+
+			}
+
+		}
+
+		if ( parameters.isRawShaderMaterial === false ) {
+
+			getProgramCacheKeyParameters( array, parameters );
+			getProgramCacheKeyBooleans( array, parameters );
+			array.push( renderer.outputColorSpace );
+
+		}
+
+		array.push( parameters.customProgramCacheKey );
+
+		return array.join();
+
+	}
+
+	function getProgramCacheKeyParameters( array, parameters ) {
+
+		array.push( parameters.precision );
+		array.push( parameters.outputColorSpace );
+		array.push( parameters.envMapMode );
+		array.push( parameters.envMapCubeUVHeight );
+		array.push( parameters.mapUv );
+		array.push( parameters.alphaMapUv );
+		array.push( parameters.lightMapUv );
+		array.push( parameters.aoMapUv );
+		array.push( parameters.bumpMapUv );
+		array.push( parameters.normalMapUv );
+		array.push( parameters.displacementMapUv );
+		array.push( parameters.emissiveMapUv );
+		array.push( parameters.metalnessMapUv );
+		array.push( parameters.roughnessMapUv );
+		array.push( parameters.anisotropyMapUv );
+		array.push( parameters.clearcoatMapUv );
+		array.push( parameters.clearcoatNormalMapUv );
+		array.push( parameters.clearcoatRoughnessMapUv );
+		array.push( parameters.iridescenceMapUv );
+		array.push( parameters.iridescenceThicknessMapUv );
+		array.push( parameters.sheenColorMapUv );
+		array.push( parameters.sheenRoughnessMapUv );
+		array.push( parameters.specularMapUv );
+		array.push( parameters.specularColorMapUv );
+		array.push( parameters.specularIntensityMapUv );
+		array.push( parameters.transmissionMapUv );
+		array.push( parameters.thicknessMapUv );
+		array.push( parameters.combine );
+		array.push( parameters.fogExp2 );
+		array.push( parameters.sizeAttenuation );
+		array.push( parameters.morphTargetsCount );
+		array.push( parameters.morphAttributeCount );
+		array.push( parameters.numDirLights );
+		array.push( parameters.numPointLights );
+		array.push( parameters.numSpotLights );
+		array.push( parameters.numSpotLightMaps );
+		array.push( parameters.numHemiLights );
+		array.push( parameters.numRectAreaLights );
+		array.push( parameters.numDirLightShadows );
+		array.push( parameters.numPointLightShadows );
+		array.push( parameters.numSpotLightShadows );
+		array.push( parameters.numSpotLightShadowsWithMaps );
+		array.push( parameters.numLightProbes );
+		array.push( parameters.shadowMapType );
+		array.push( parameters.toneMapping );
+		array.push( parameters.numClippingPlanes );
+		array.push( parameters.numClipIntersection );
+		array.push( parameters.depthPacking );
+
+	}
+
+	function getProgramCacheKeyBooleans( array, parameters ) {
+
+		_programLayers.disableAll();
+
+		if ( parameters.isWebGL2 )
+			_programLayers.enable( 0 );
+		if ( parameters.supportsVertexTextures )
+			_programLayers.enable( 1 );
+		if ( parameters.instancing )
+			_programLayers.enable( 2 );
+		if ( parameters.instancingColor )
+			_programLayers.enable( 3 );
+		if ( parameters.matcap )
+			_programLayers.enable( 4 );
+		if ( parameters.envMap )
+			_programLayers.enable( 5 );
+		if ( parameters.normalMapObjectSpace )
+			_programLayers.enable( 6 );
+		if ( parameters.normalMapTangentSpace )
+			_programLayers.enable( 7 );
+		if ( parameters.clearcoat )
+			_programLayers.enable( 8 );
+		if ( parameters.iridescence )
+			_programLayers.enable( 9 );
+		if ( parameters.alphaTest )
+			_programLayers.enable( 10 );
+		if ( parameters.vertexColors )
+			_programLayers.enable( 11 );
+		if ( parameters.vertexAlphas )
+			_programLayers.enable( 12 );
+		if ( parameters.vertexUv1s )
+			_programLayers.enable( 13 );
+		if ( parameters.vertexUv2s )
+			_programLayers.enable( 14 );
+		if ( parameters.vertexUv3s )
+			_programLayers.enable( 15 );
+		if ( parameters.vertexTangents )
+			_programLayers.enable( 16 );
+		if ( parameters.anisotropy )
+			_programLayers.enable( 17 );
+		if ( parameters.alphaHash )
+			_programLayers.enable( 18 );
+		if ( parameters.batching )
+			_programLayers.enable( 19 );
+
+		array.push( _programLayers.mask );
+		_programLayers.disableAll();
+
+		if ( parameters.fog )
+			_programLayers.enable( 0 );
+		if ( parameters.useFog )
+			_programLayers.enable( 1 );
+		if ( parameters.flatShading )
+			_programLayers.enable( 2 );
+		if ( parameters.logarithmicDepthBuffer )
+			_programLayers.enable( 3 );
+		if ( parameters.skinning )
+			_programLayers.enable( 4 );
+		if ( parameters.morphTargets )
+			_programLayers.enable( 5 );
+		if ( parameters.morphNormals )
+			_programLayers.enable( 6 );
+		if ( parameters.morphColors )
+			_programLayers.enable( 7 );
+		if ( parameters.premultipliedAlpha )
+			_programLayers.enable( 8 );
+		if ( parameters.shadowMapEnabled )
+			_programLayers.enable( 9 );
+		if ( parameters.useLegacyLights )
+			_programLayers.enable( 10 );
+		if ( parameters.doubleSided )
+			_programLayers.enable( 11 );
+		if ( parameters.flipSided )
+			_programLayers.enable( 12 );
+		if ( parameters.useDepthPacking )
+			_programLayers.enable( 13 );
+		if ( parameters.dithering )
+			_programLayers.enable( 14 );
+		if ( parameters.transmission )
+			_programLayers.enable( 15 );
+		if ( parameters.sheen )
+			_programLayers.enable( 16 );
+		if ( parameters.opaque )
+			_programLayers.enable( 17 );
+		if ( parameters.pointsUvs )
+			_programLayers.enable( 18 );
+		if ( parameters.decodeVideoTexture )
+			_programLayers.enable( 19 );
+
+		array.push( _programLayers.mask );
+
+	}
+
+	function getUniforms( material ) {
+
+		const shaderID = shaderIDs[ material.type ];
+		let uniforms;
+
+		if ( shaderID ) {
+
+			const shader = ShaderLib[ shaderID ];
+			uniforms = UniformsUtils.clone( shader.uniforms );
+
+		} else {
+
+			uniforms = material.uniforms;
+
+		}
+
+		return uniforms;
+
+	}
+
+	function acquireProgram( parameters, cacheKey ) {
+
+		let program;
+
+		// Check if code has been already compiled
+		for ( let p = 0, pl = programs.length; p < pl; p ++ ) {
+
+			const preexistingProgram = programs[ p ];
+
+			if ( preexistingProgram.cacheKey === cacheKey ) {
+
+				program = preexistingProgram;
+				++ program.usedTimes;
+
+				break;
+
+			}
+
+		}
+
+		if ( program === undefined ) {
+
+			program = new WebGLProgram( renderer, cacheKey, parameters, bindingStates );
+			programs.push( program );
+
+		}
+
+		return program;
+
+	}
+
+	function releaseProgram( program ) {
+
+		if ( -- program.usedTimes === 0 ) {
+
+			// Remove from unordered set
+			const i = programs.indexOf( program );
+			programs[ i ] = programs[ programs.length - 1 ];
+			programs.pop();
+
+			// Free WebGL resources
+			program.destroy();
+
+		}
+
+	}
+
+	function releaseShaderCache( material ) {
+
+		_customShaders.remove( material );
+
+	}
+
+	function dispose() {
+
+		_customShaders.dispose();
+
+	}
+
+	return {
+		getParameters: getParameters,
+		getProgramCacheKey: getProgramCacheKey,
+		getUniforms: getUniforms,
+		acquireProgram: acquireProgram,
+		releaseProgram: releaseProgram,
+		releaseShaderCache: releaseShaderCache,
+		// Exposed for resource monitoring & error feedback via renderer.info:
+		programs: programs,
+		dispose: dispose
+	};
+
+}
+
+function WebGLProperties() {
+
+	let properties = new WeakMap();
+
+	function get( object ) {
+
+		let map = properties.get( object );
+
+		if ( map === undefined ) {
+
+			map = {};
+			properties.set( object, map );
+
+		}
+
+		return map;
+
+	}
+
+	function remove( object ) {
+
+		properties.delete( object );
+
+	}
+
+	function update( object, key, value ) {
+
+		properties.get( object )[ key ] = value;
+
+	}
+
+	function dispose() {
+
+		properties = new WeakMap();
+
+	}
+
+	return {
+		get: get,
+		remove: remove,
+		update: update,
+		dispose: dispose
+	};
+
+}
+
+function painterSortStable( a, b ) {
+
+	if ( a.groupOrder !== b.groupOrder ) {
+
+		return a.groupOrder - b.groupOrder;
+
+	} else if ( a.renderOrder !== b.renderOrder ) {
+
+		return a.renderOrder - b.renderOrder;
+
+	} else if ( a.material.id !== b.material.id ) {
+
+		return a.material.id - b.material.id;
+
+	} else if ( a.z !== b.z ) {
+
+		return a.z - b.z;
+
+	} else {
+
+		return a.id - b.id;
+
+	}
+
+}
+
+function reversePainterSortStable( a, b ) {
+
+	if ( a.groupOrder !== b.groupOrder ) {
+
+		return a.groupOrder - b.groupOrder;
+
+	} else if ( a.renderOrder !== b.renderOrder ) {
+
+		return a.renderOrder - b.renderOrder;
+
+	} else if ( a.z !== b.z ) {
+
+		return b.z - a.z;
+
+	} else {
+
+		return a.id - b.id;
+
+	}
+
+}
+
+
+function WebGLRenderList() {
+
+	const renderItems = [];
+	let renderItemsIndex = 0;
+
+	const opaque = [];
+	const transmissive = [];
+	const transparent = [];
+
+	function init() {
+
+		renderItemsIndex = 0;
+
+		opaque.length = 0;
+		transmissive.length = 0;
+		transparent.length = 0;
+
+	}
+
+	function getNextRenderItem( object, geometry, material, groupOrder, z, group ) {
+
+		let renderItem = renderItems[ renderItemsIndex ];
+
+		if ( renderItem === undefined ) {
+
+			renderItem = {
+				id: object.id,
+				object: object,
+				geometry: geometry,
+				material: material,
+				groupOrder: groupOrder,
+				renderOrder: object.renderOrder,
+				z: z,
+				group: group
+			};
+
+			renderItems[ renderItemsIndex ] = renderItem;
+
+		} else {
+
+			renderItem.id = object.id;
+			renderItem.object = object;
+			renderItem.geometry = geometry;
+			renderItem.material = material;
+			renderItem.groupOrder = groupOrder;
+			renderItem.renderOrder = object.renderOrder;
+			renderItem.z = z;
+			renderItem.group = group;
+
+		}
+
+		renderItemsIndex ++;
+
+		return renderItem;
+
+	}
+
+	function push( object, geometry, material, groupOrder, z, group ) {
+
+		const renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );
+
+		if ( material.transmission > 0.0 ) {
+
+			transmissive.push( renderItem );
+
+		} else if ( material.transparent === true ) {
+
+			transparent.push( renderItem );
+
+		} else {
+
+			opaque.push( renderItem );
+
+		}
+
+	}
+
+	function unshift( object, geometry, material, groupOrder, z, group ) {
+
+		const renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );
+
+		if ( material.transmission > 0.0 ) {
+
+			transmissive.unshift( renderItem );
+
+		} else if ( material.transparent === true ) {
+
+			transparent.unshift( renderItem );
+
+		} else {
+
+			opaque.unshift( renderItem );
+
+		}
+
+	}
+
+	function sort( customOpaqueSort, customTransparentSort ) {
+
+		if ( opaque.length > 1 ) opaque.sort( customOpaqueSort || painterSortStable );
+		if ( transmissive.length > 1 ) transmissive.sort( customTransparentSort || reversePainterSortStable );
+		if ( transparent.length > 1 ) transparent.sort( customTransparentSort || reversePainterSortStable );
+
+	}
+
+	function finish() {
+
+		// Clear references from inactive renderItems in the list
+
+		for ( let i = renderItemsIndex, il = renderItems.length; i < il; i ++ ) {
+
+			const renderItem = renderItems[ i ];
+
+			if ( renderItem.id === null ) break;
+
+			renderItem.id = null;
+			renderItem.object = null;
+			renderItem.geometry = null;
+			renderItem.material = null;
+			renderItem.group = null;
+
+		}
+
+	}
+
+	return {
+
+		opaque: opaque,
+		transmissive: transmissive,
+		transparent: transparent,
+
+		init: init,
+		push: push,
+		unshift: unshift,
+		finish: finish,
+
+		sort: sort
+	};
+
+}
+
+function WebGLRenderLists() {
+
+	let lists = new WeakMap();
+
+	function get( scene, renderCallDepth ) {
+
+		const listArray = lists.get( scene );
+		let list;
+
+		if ( listArray === undefined ) {
+
+			list = new WebGLRenderList();
+			lists.set( scene, [ list ] );
+
+		} else {
+
+			if ( renderCallDepth >= listArray.length ) {
+
+				list = new WebGLRenderList();
+				listArray.push( list );
+
+			} else {
+
+				list = listArray[ renderCallDepth ];
+
+			}
+
+		}
+
+		return list;
+
+	}
+
+	function dispose() {
+
+		lists = new WeakMap();
+
+	}
+
+	return {
+		get: get,
+		dispose: dispose
+	};
+
+}
+
+function UniformsCache() {
+
+	const lights = {};
+
+	return {
+
+		get: function ( light ) {
+
+			if ( lights[ light.id ] !== undefined ) {
+
+				return lights[ light.id ];
+
+			}
+
+			let uniforms;
+
+			switch ( light.type ) {
+
+				case 'DirectionalLight':
+					uniforms = {
+						direction: new Vector3(),
+						color: new Color()
+					};
+					break;
+
+				case 'SpotLight':
+					uniforms = {
+						position: new Vector3(),
+						direction: new Vector3(),
+						color: new Color(),
+						distance: 0,
+						coneCos: 0,
+						penumbraCos: 0,
+						decay: 0
+					};
+					break;
+
+				case 'PointLight':
+					uniforms = {
+						position: new Vector3(),
+						color: new Color(),
+						distance: 0,
+						decay: 0
+					};
+					break;
+
+				case 'HemisphereLight':
+					uniforms = {
+						direction: new Vector3(),
+						skyColor: new Color(),
+						groundColor: new Color()
+					};
+					break;
+
+				case 'RectAreaLight':
+					uniforms = {
+						color: new Color(),
+						position: new Vector3(),
+						halfWidth: new Vector3(),
+						halfHeight: new Vector3()
+					};
+					break;
+
+			}
+
+			lights[ light.id ] = uniforms;
+
+			return uniforms;
+
+		}
+
+	};
+
+}
+
+function ShadowUniformsCache() {
+
+	const lights = {};
+
+	return {
+
+		get: function ( light ) {
+
+			if ( lights[ light.id ] !== undefined ) {
+
+				return lights[ light.id ];
+
+			}
+
+			let uniforms;
+
+			switch ( light.type ) {
+
+				case 'DirectionalLight':
+					uniforms = {
+						shadowBias: 0,
+						shadowNormalBias: 0,
+						shadowRadius: 1,
+						shadowMapSize: new Vector2()
+					};
+					break;
+
+				case 'SpotLight':
+					uniforms = {
+						shadowBias: 0,
+						shadowNormalBias: 0,
+						shadowRadius: 1,
+						shadowMapSize: new Vector2()
+					};
+					break;
+
+				case 'PointLight':
+					uniforms = {
+						shadowBias: 0,
+						shadowNormalBias: 0,
+						shadowRadius: 1,
+						shadowMapSize: new Vector2(),
+						shadowCameraNear: 1,
+						shadowCameraFar: 1000
+					};
+					break;
+
+				// TODO (abelnation): set RectAreaLight shadow uniforms
+
+			}
+
+			lights[ light.id ] = uniforms;
+
+			return uniforms;
+
+		}
+
+	};
+
+}
+
+
+
+let nextVersion = 0;
+
+function shadowCastingAndTexturingLightsFirst( lightA, lightB ) {
+
+	return ( lightB.castShadow ? 2 : 0 ) - ( lightA.castShadow ? 2 : 0 ) + ( lightB.map ? 1 : 0 ) - ( lightA.map ? 1 : 0 );
+
+}
+
+function WebGLLights( extensions, capabilities ) {
+
+	const cache = new UniformsCache();
+
+	const shadowCache = ShadowUniformsCache();
+
+	const state = {
+
+		version: 0,
+
+		hash: {
+			directionalLength: - 1,
+			pointLength: - 1,
+			spotLength: - 1,
+			rectAreaLength: - 1,
+			hemiLength: - 1,
+
+			numDirectionalShadows: - 1,
+			numPointShadows: - 1,
+			numSpotShadows: - 1,
+			numSpotMaps: - 1,
+
+			numLightProbes: - 1
+		},
+
+		ambient: [ 0, 0, 0 ],
+		probe: [],
+		directional: [],
+		directionalShadow: [],
+		directionalShadowMap: [],
+		directionalShadowMatrix: [],
+		spot: [],
+		spotLightMap: [],
+		spotShadow: [],
+		spotShadowMap: [],
+		spotLightMatrix: [],
+		rectArea: [],
+		rectAreaLTC1: null,
+		rectAreaLTC2: null,
+		point: [],
+		pointShadow: [],
+		pointShadowMap: [],
+		pointShadowMatrix: [],
+		hemi: [],
+		numSpotLightShadowsWithMaps: 0,
+		numLightProbes: 0
+
+	};
+
+	for ( let i = 0; i < 9; i ++ ) state.probe.push( new Vector3() );
+
+	const vector3 = new Vector3();
+	const matrix4 = new Matrix4();
+	const matrix42 = new Matrix4();
+
+	function setup( lights, useLegacyLights ) {
+
+		let r = 0, g = 0, b = 0;
+
+		for ( let i = 0; i < 9; i ++ ) state.probe[ i ].set( 0, 0, 0 );
+
+		let directionalLength = 0;
+		let pointLength = 0;
+		let spotLength = 0;
+		let rectAreaLength = 0;
+		let hemiLength = 0;
+
+		let numDirectionalShadows = 0;
+		let numPointShadows = 0;
+		let numSpotShadows = 0;
+		let numSpotMaps = 0;
+		let numSpotShadowsWithMaps = 0;
+
+		let numLightProbes = 0;
+
+		// ordering : [shadow casting + map texturing, map texturing, shadow casting, none ]
+		lights.sort( shadowCastingAndTexturingLightsFirst );
+
+		// artist-friendly light intensity scaling factor
+		const scaleFactor = ( useLegacyLights === true ) ? Math.PI : 1;
+
+		for ( let i = 0, l = lights.length; i < l; i ++ ) {
+
+			const light = lights[ i ];
+
+			const color = light.color;
+			const intensity = light.intensity;
+			const distance = light.distance;
+
+			const shadowMap = ( light.shadow && light.shadow.map ) ? light.shadow.map.texture : null;
+
+			if ( light.isAmbientLight ) {
+
+				r += color.r * intensity * scaleFactor;
+				g += color.g * intensity * scaleFactor;
+				b += color.b * intensity * scaleFactor;
+
+			} else if ( light.isLightProbe ) {
+
+				for ( let j = 0; j < 9; j ++ ) {
+
+					state.probe[ j ].addScaledVector( light.sh.coefficients[ j ], intensity );
+
+				}
+
+				numLightProbes ++;
+
+			} else if ( light.isDirectionalLight ) {
+
+				const uniforms = cache.get( light );
+
+				uniforms.color.copy( light.color ).multiplyScalar( light.intensity * scaleFactor );
+
+				if ( light.castShadow ) {
+
+					const shadow = light.shadow;
+
+					const shadowUniforms = shadowCache.get( light );
+
+					shadowUniforms.shadowBias = shadow.bias;
+					shadowUniforms.shadowNormalBias = shadow.normalBias;
+					shadowUniforms.shadowRadius = shadow.radius;
+					shadowUniforms.shadowMapSize = shadow.mapSize;
+
+					state.directionalShadow[ directionalLength ] = shadowUniforms;
+					state.directionalShadowMap[ directionalLength ] = shadowMap;
+					state.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;
+
+					numDirectionalShadows ++;
+
+				}
+
+				state.directional[ directionalLength ] = uniforms;
+
+				directionalLength ++;
+
+			} else if ( light.isSpotLight ) {
+
+				const uniforms = cache.get( light );
+
+				uniforms.position.setFromMatrixPosition( light.matrixWorld );
+
+				uniforms.color.copy( color ).multiplyScalar( intensity * scaleFactor );
+				uniforms.distance = distance;
+
+				uniforms.coneCos = Math.cos( light.angle );
+				uniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );
+				uniforms.decay = light.decay;
+
+				state.spot[ spotLength ] = uniforms;
+
+				const shadow = light.shadow;
+
+				if ( light.map ) {
+
+					state.spotLightMap[ numSpotMaps ] = light.map;
+					numSpotMaps ++;
+
+					// make sure the lightMatrix is up to date
+					// TODO : do it if required only
+					shadow.updateMatrices( light );
+
+					if ( light.castShadow ) numSpotShadowsWithMaps ++;
+
+				}
+
+				state.spotLightMatrix[ spotLength ] = shadow.matrix;
+
+				if ( light.castShadow ) {
+
+					const shadowUniforms = shadowCache.get( light );
+
+					shadowUniforms.shadowBias = shadow.bias;
+					shadowUniforms.shadowNormalBias = shadow.normalBias;
+					shadowUniforms.shadowRadius = shadow.radius;
+					shadowUniforms.shadowMapSize = shadow.mapSize;
+
+					state.spotShadow[ spotLength ] = shadowUniforms;
+					state.spotShadowMap[ spotLength ] = shadowMap;
+
+					numSpotShadows ++;
+
+				}
+
+				spotLength ++;
+
+			} else if ( light.isRectAreaLight ) {
+
+				const uniforms = cache.get( light );
+
+				uniforms.color.copy( color ).multiplyScalar( intensity );
+
+				uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );
+				uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );
+
+				state.rectArea[ rectAreaLength ] = uniforms;
+
+				rectAreaLength ++;
+
+			} else if ( light.isPointLight ) {
+
+				const uniforms = cache.get( light );
+
+				uniforms.color.copy( light.color ).multiplyScalar( light.intensity * scaleFactor );
+				uniforms.distance = light.distance;
+				uniforms.decay = light.decay;
+
+				if ( light.castShadow ) {
+
+					const shadow = light.shadow;
+
+					const shadowUniforms = shadowCache.get( light );
+
+					shadowUniforms.shadowBias = shadow.bias;
+					shadowUniforms.shadowNormalBias = shadow.normalBias;
+					shadowUniforms.shadowRadius = shadow.radius;
+					shadowUniforms.shadowMapSize = shadow.mapSize;
+					shadowUniforms.shadowCameraNear = shadow.camera.near;
+					shadowUniforms.shadowCameraFar = shadow.camera.far;
+
+					state.pointShadow[ pointLength ] = shadowUniforms;
+					state.pointShadowMap[ pointLength ] = shadowMap;
+					state.pointShadowMatrix[ pointLength ] = light.shadow.matrix;
+
+					numPointShadows ++;
+
+				}
+
+				state.point[ pointLength ] = uniforms;
+
+				pointLength ++;
+
+			} else if ( light.isHemisphereLight ) {
+
+				const uniforms = cache.get( light );
+
+				uniforms.skyColor.copy( light.color ).multiplyScalar( intensity * scaleFactor );
+				uniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity * scaleFactor );
+
+				state.hemi[ hemiLength ] = uniforms;
+
+				hemiLength ++;
+
+			}
+
+		}
+
+		if ( rectAreaLength > 0 ) {
+
+			if ( capabilities.isWebGL2 ) {
+
+				// WebGL 2
+
+				if ( extensions.has( 'OES_texture_float_linear' ) === true ) {
+
+					state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1;
+					state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2;
+
+				} else {
+
+					state.rectAreaLTC1 = UniformsLib.LTC_HALF_1;
+					state.rectAreaLTC2 = UniformsLib.LTC_HALF_2;
+
+				}
+
+			} else {
+
+				// WebGL 1
+
+				if ( extensions.has( 'OES_texture_float_linear' ) === true ) {
+
+					state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1;
+					state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2;
+
+				} else if ( extensions.has( 'OES_texture_half_float_linear' ) === true ) {
+
+					state.rectAreaLTC1 = UniformsLib.LTC_HALF_1;
+					state.rectAreaLTC2 = UniformsLib.LTC_HALF_2;
+
+				} else {
+
+					console.error( 'THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.' );
+
+				}
+
+			}
+
+		}
+
+		state.ambient[ 0 ] = r;
+		state.ambient[ 1 ] = g;
+		state.ambient[ 2 ] = b;
+
+		const hash = state.hash;
+
+		if ( hash.directionalLength !== directionalLength ||
+			hash.pointLength !== pointLength ||
+			hash.spotLength !== spotLength ||
+			hash.rectAreaLength !== rectAreaLength ||
+			hash.hemiLength !== hemiLength ||
+			hash.numDirectionalShadows !== numDirectionalShadows ||
+			hash.numPointShadows !== numPointShadows ||
+			hash.numSpotShadows !== numSpotShadows ||
+			hash.numSpotMaps !== numSpotMaps ||
+			hash.numLightProbes !== numLightProbes ) {
+
+			state.directional.length = directionalLength;
+			state.spot.length = spotLength;
+			state.rectArea.length = rectAreaLength;
+			state.point.length = pointLength;
+			state.hemi.length = hemiLength;
+
+			state.directionalShadow.length = numDirectionalShadows;
+			state.directionalShadowMap.length = numDirectionalShadows;
+			state.pointShadow.length = numPointShadows;
+			state.pointShadowMap.length = numPointShadows;
+			state.spotShadow.length = numSpotShadows;
+			state.spotShadowMap.length = numSpotShadows;
+			state.directionalShadowMatrix.length = numDirectionalShadows;
+			state.pointShadowMatrix.length = numPointShadows;
+			state.spotLightMatrix.length = numSpotShadows + numSpotMaps - numSpotShadowsWithMaps;
+			state.spotLightMap.length = numSpotMaps;
+			state.numSpotLightShadowsWithMaps = numSpotShadowsWithMaps;
+			state.numLightProbes = numLightProbes;
+
+			hash.directionalLength = directionalLength;
+			hash.pointLength = pointLength;
+			hash.spotLength = spotLength;
+			hash.rectAreaLength = rectAreaLength;
+			hash.hemiLength = hemiLength;
+
+			hash.numDirectionalShadows = numDirectionalShadows;
+			hash.numPointShadows = numPointShadows;
+			hash.numSpotShadows = numSpotShadows;
+			hash.numSpotMaps = numSpotMaps;
+
+			hash.numLightProbes = numLightProbes;
+
+			state.version = nextVersion ++;
+
+		}
+
+	}
+
+	function setupView( lights, camera ) {
+
+		let directionalLength = 0;
+		let pointLength = 0;
+		let spotLength = 0;
+		let rectAreaLength = 0;
+		let hemiLength = 0;
+
+		const viewMatrix = camera.matrixWorldInverse;
+
+		for ( let i = 0, l = lights.length; i < l; i ++ ) {
+
+			const light = lights[ i ];
+
+			if ( light.isDirectionalLight ) {
+
+				const uniforms = state.directional[ directionalLength ];
+
+				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
+				vector3.setFromMatrixPosition( light.target.matrixWorld );
+				uniforms.direction.sub( vector3 );
+				uniforms.direction.transformDirection( viewMatrix );
+
+				directionalLength ++;
+
+			} else if ( light.isSpotLight ) {
+
+				const uniforms = state.spot[ spotLength ];
+
+				uniforms.position.setFromMatrixPosition( light.matrixWorld );
+				uniforms.position.applyMatrix4( viewMatrix );
+
+				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
+				vector3.setFromMatrixPosition( light.target.matrixWorld );
+				uniforms.direction.sub( vector3 );
+				uniforms.direction.transformDirection( viewMatrix );
+
+				spotLength ++;
+
+			} else if ( light.isRectAreaLight ) {
+
+				const uniforms = state.rectArea[ rectAreaLength ];
+
+				uniforms.position.setFromMatrixPosition( light.matrixWorld );
+				uniforms.position.applyMatrix4( viewMatrix );
+
+				// extract local rotation of light to derive width/height half vectors
+				matrix42.identity();
+				matrix4.copy( light.matrixWorld );
+				matrix4.premultiply( viewMatrix );
+				matrix42.extractRotation( matrix4 );
+
+				uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );
+				uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );
+
+				uniforms.halfWidth.applyMatrix4( matrix42 );
+				uniforms.halfHeight.applyMatrix4( matrix42 );
+
+				rectAreaLength ++;
+
+			} else if ( light.isPointLight ) {
+
+				const uniforms = state.point[ pointLength ];
+
+				uniforms.position.setFromMatrixPosition( light.matrixWorld );
+				uniforms.position.applyMatrix4( viewMatrix );
+
+				pointLength ++;
+
+			} else if ( light.isHemisphereLight ) {
+
+				const uniforms = state.hemi[ hemiLength ];
+
+				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
+				uniforms.direction.transformDirection( viewMatrix );
+
+				hemiLength ++;
+
+			}
+
+		}
+
+	}
+
+	return {
+		setup: setup,
+		setupView: setupView,
+		state: state
+	};
+
+}
+
+function WebGLRenderState( extensions, capabilities ) {
+
+	const lights = new WebGLLights( extensions, capabilities );
+
+	const lightsArray = [];
+	const shadowsArray = [];
+
+	function init() {
+
+		lightsArray.length = 0;
+		shadowsArray.length = 0;
+
+	}
+
+	function pushLight( light ) {
+
+		lightsArray.push( light );
+
+	}
+
+	function pushShadow( shadowLight ) {
+
+		shadowsArray.push( shadowLight );
+
+	}
+
+	function setupLights( useLegacyLights ) {
+
+		lights.setup( lightsArray, useLegacyLights );
+
+	}
+
+	function setupLightsView( camera ) {
+
+		lights.setupView( lightsArray, camera );
+
+	}
+
+	const state = {
+		lightsArray: lightsArray,
+		shadowsArray: shadowsArray,
+
+		lights: lights
+	};
+
+	return {
+		init: init,
+		state: state,
+		setupLights: setupLights,
+		setupLightsView: setupLightsView,
+
+		pushLight: pushLight,
+		pushShadow: pushShadow
+	};
+
+}
+
+function WebGLRenderStates( extensions, capabilities ) {
+
+	let renderStates = new WeakMap();
+
+	function get( scene, renderCallDepth = 0 ) {
+
+		const renderStateArray = renderStates.get( scene );
+		let renderState;
+
+		if ( renderStateArray === undefined ) {
+
+			renderState = new WebGLRenderState( extensions, capabilities );
+			renderStates.set( scene, [ renderState ] );
+
+		} else {
+
+			if ( renderCallDepth >= renderStateArray.length ) {
+
+				renderState = new WebGLRenderState( extensions, capabilities );
+				renderStateArray.push( renderState );
+
+			} else {
+
+				renderState = renderStateArray[ renderCallDepth ];
+
+			}
+
+		}
+
+		return renderState;
+
+	}
+
+	function dispose() {
+
+		renderStates = new WeakMap();
+
+	}
+
+	return {
+		get: get,
+		dispose: dispose
+	};
+
+}
+
+class MeshDepthMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshDepthMaterial = true;
+
+		this.type = 'MeshDepthMaterial';
+
+		this.depthPacking = BasicDepthPacking;
+
+		this.map = null;
+
+		this.alphaMap = null;
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.depthPacking = source.depthPacking;
+
+		this.map = source.map;
+
+		this.alphaMap = source.alphaMap;
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+
+		return this;
+
+	}
+
+}
+
+class MeshDistanceMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshDistanceMaterial = true;
+
+		this.type = 'MeshDistanceMaterial';
+
+		this.map = null;
+
+		this.alphaMap = null;
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.map = source.map;
+
+		this.alphaMap = source.alphaMap;
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		return this;
+
+	}
+
+}
+
+const vertex = "void main() {\n\tgl_Position = vec4( position, 1.0 );\n}";
+
+const fragment = "uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";
+
+function WebGLShadowMap( _renderer, _objects, _capabilities ) {
+
+	let _frustum = new Frustum();
+
+	const _shadowMapSize = new Vector2(),
+		_viewportSize = new Vector2(),
+
+		_viewport = new Vector4(),
+
+		_depthMaterial = new MeshDepthMaterial( { depthPacking: RGBADepthPacking } ),
+		_distanceMaterial = new MeshDistanceMaterial(),
+
+		_materialCache = {},
+
+		_maxTextureSize = _capabilities.maxTextureSize;
+
+	const shadowSide = { [ FrontSide ]: BackSide, [ BackSide ]: FrontSide, [ DoubleSide ]: DoubleSide };
+
+	const shadowMaterialVertical = new ShaderMaterial( {
+		defines: {
+			VSM_SAMPLES: 8
+		},
+		uniforms: {
+			shadow_pass: { value: null },
+			resolution: { value: new Vector2() },
+			radius: { value: 4.0 }
+		},
+
+		vertexShader: vertex,
+		fragmentShader: fragment
+
+	} );
+
+	const shadowMaterialHorizontal = shadowMaterialVertical.clone();
+	shadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1;
+
+	const fullScreenTri = new BufferGeometry();
+	fullScreenTri.setAttribute(
+		'position',
+		new BufferAttribute(
+			new Float32Array( [ - 1, - 1, 0.5, 3, - 1, 0.5, - 1, 3, 0.5 ] ),
+			3
+		)
+	);
+
+	const fullScreenMesh = new Mesh( fullScreenTri, shadowMaterialVertical );
+
+	const scope = this;
+
+	this.enabled = false;
+
+	this.autoUpdate = true;
+	this.needsUpdate = false;
+
+	this.type = PCFShadowMap;
+	let _previousType = this.type;
+
+	this.render = function ( lights, scene, camera ) {
+
+		if ( scope.enabled === false ) return;
+		if ( scope.autoUpdate === false && scope.needsUpdate === false ) return;
+
+		if ( lights.length === 0 ) return;
+
+		const currentRenderTarget = _renderer.getRenderTarget();
+		const activeCubeFace = _renderer.getActiveCubeFace();
+		const activeMipmapLevel = _renderer.getActiveMipmapLevel();
+
+		const _state = _renderer.state;
+
+		// Set GL state for depth map.
+		_state.setBlending( NoBlending );
+		_state.buffers.color.setClear( 1, 1, 1, 1 );
+		_state.buffers.depth.setTest( true );
+		_state.setScissorTest( false );
+
+		// check for shadow map type changes
+
+		const toVSM = ( _previousType !== VSMShadowMap && this.type === VSMShadowMap );
+		const fromVSM = ( _previousType === VSMShadowMap && this.type !== VSMShadowMap );
+
+		// render depth map
+
+		for ( let i = 0, il = lights.length; i < il; i ++ ) {
+
+			const light = lights[ i ];
+			const shadow = light.shadow;
+
+			if ( shadow === undefined ) {
+
+				console.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' );
+				continue;
+
+			}
+
+			if ( shadow.autoUpdate === false && shadow.needsUpdate === false ) continue;
+
+			_shadowMapSize.copy( shadow.mapSize );
+
+			const shadowFrameExtents = shadow.getFrameExtents();
+
+			_shadowMapSize.multiply( shadowFrameExtents );
+
+			_viewportSize.copy( shadow.mapSize );
+
+			if ( _shadowMapSize.x > _maxTextureSize || _shadowMapSize.y > _maxTextureSize ) {
+
+				if ( _shadowMapSize.x > _maxTextureSize ) {
+
+					_viewportSize.x = Math.floor( _maxTextureSize / shadowFrameExtents.x );
+					_shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x;
+					shadow.mapSize.x = _viewportSize.x;
+
+				}
+
+				if ( _shadowMapSize.y > _maxTextureSize ) {
+
+					_viewportSize.y = Math.floor( _maxTextureSize / shadowFrameExtents.y );
+					_shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y;
+					shadow.mapSize.y = _viewportSize.y;
+
+				}
+
+			}
+
+			if ( shadow.map === null || toVSM === true || fromVSM === true ) {
+
+				const pars = ( this.type !== VSMShadowMap ) ? { minFilter: NearestFilter, magFilter: NearestFilter } : {};
+
+				if ( shadow.map !== null ) {
+
+					shadow.map.dispose();
+
+				}
+
+				shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
+				shadow.map.texture.name = light.name + '.shadowMap';
+
+				shadow.camera.updateProjectionMatrix();
+
+			}
+
+			_renderer.setRenderTarget( shadow.map );
+			_renderer.clear();
+
+			const viewportCount = shadow.getViewportCount();
+
+			for ( let vp = 0; vp < viewportCount; vp ++ ) {
+
+				const viewport = shadow.getViewport( vp );
+
+				_viewport.set(
+					_viewportSize.x * viewport.x,
+					_viewportSize.y * viewport.y,
+					_viewportSize.x * viewport.z,
+					_viewportSize.y * viewport.w
+				);
+
+				_state.viewport( _viewport );
+
+				shadow.updateMatrices( light, vp );
+
+				_frustum = shadow.getFrustum();
+
+				renderObject( scene, camera, shadow.camera, light, this.type );
+
+			}
+
+			// do blur pass for VSM
+
+			if ( shadow.isPointLightShadow !== true && this.type === VSMShadowMap ) {
+
+				VSMPass( shadow, camera );
+
+			}
+
+			shadow.needsUpdate = false;
+
+		}
+
+		_previousType = this.type;
+
+		scope.needsUpdate = false;
+
+		_renderer.setRenderTarget( currentRenderTarget, activeCubeFace, activeMipmapLevel );
+
+	};
+
+	function VSMPass( shadow, camera ) {
+
+		const geometry = _objects.update( fullScreenMesh );
+
+		if ( shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples ) {
+
+			shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples;
+			shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;
+
+			shadowMaterialVertical.needsUpdate = true;
+			shadowMaterialHorizontal.needsUpdate = true;
+
+		}
+
+		if ( shadow.mapPass === null ) {
+
+			shadow.mapPass = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y );
+
+		}
+
+		// vertical pass
+
+		shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture;
+		shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize;
+		shadowMaterialVertical.uniforms.radius.value = shadow.radius;
+		_renderer.setRenderTarget( shadow.mapPass );
+		_renderer.clear();
+		_renderer.renderBufferDirect( camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null );
+
+		// horizontal pass
+
+		shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture;
+		shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize;
+		shadowMaterialHorizontal.uniforms.radius.value = shadow.radius;
+		_renderer.setRenderTarget( shadow.map );
+		_renderer.clear();
+		_renderer.renderBufferDirect( camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null );
+
+	}
+
+	function getDepthMaterial( object, material, light, type ) {
+
+		let result = null;
+
+		const customMaterial = ( light.isPointLight === true ) ? object.customDistanceMaterial : object.customDepthMaterial;
+
+		if ( customMaterial !== undefined ) {
+
+			result = customMaterial;
+
+		} else {
+
+			result = ( light.isPointLight === true ) ? _distanceMaterial : _depthMaterial;
+
+			if ( ( _renderer.localClippingEnabled && material.clipShadows === true && Array.isArray( material.clippingPlanes ) && material.clippingPlanes.length !== 0 ) ||
+				( material.displacementMap && material.displacementScale !== 0 ) ||
+				( material.alphaMap && material.alphaTest > 0 ) ||
+				( material.map && material.alphaTest > 0 ) ) {
+
+				// in this case we need a unique material instance reflecting the
+				// appropriate state
+
+				const keyA = result.uuid, keyB = material.uuid;
+
+				let materialsForVariant = _materialCache[ keyA ];
+
+				if ( materialsForVariant === undefined ) {
+
+					materialsForVariant = {};
+					_materialCache[ keyA ] = materialsForVariant;
+
+				}
+
+				let cachedMaterial = materialsForVariant[ keyB ];
+
+				if ( cachedMaterial === undefined ) {
+
+					cachedMaterial = result.clone();
+					materialsForVariant[ keyB ] = cachedMaterial;
+					material.addEventListener( 'dispose', onMaterialDispose );
+
+				}
+
+				result = cachedMaterial;
+
+			}
+
+		}
+
+		result.visible = material.visible;
+		result.wireframe = material.wireframe;
+
+		if ( type === VSMShadowMap ) {
+
+			result.side = ( material.shadowSide !== null ) ? material.shadowSide : material.side;
+
+		} else {
+
+			result.side = ( material.shadowSide !== null ) ? material.shadowSide : shadowSide[ material.side ];
+
+		}
+
+		result.alphaMap = material.alphaMap;
+		result.alphaTest = material.alphaTest;
+		result.map = material.map;
+
+		result.clipShadows = material.clipShadows;
+		result.clippingPlanes = material.clippingPlanes;
+		result.clipIntersection = material.clipIntersection;
+
+		result.displacementMap = material.displacementMap;
+		result.displacementScale = material.displacementScale;
+		result.displacementBias = material.displacementBias;
+
+		result.wireframeLinewidth = material.wireframeLinewidth;
+		result.linewidth = material.linewidth;
+
+		if ( light.isPointLight === true && result.isMeshDistanceMaterial === true ) {
+
+			const materialProperties = _renderer.properties.get( result );
+			materialProperties.light = light;
+
+		}
+
+		return result;
+
+	}
+
+	function renderObject( object, camera, shadowCamera, light, type ) {
+
+		if ( object.visible === false ) return;
+
+		const visible = object.layers.test( camera.layers );
+
+		if ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {
+
+			if ( ( object.castShadow || ( object.receiveShadow && type === VSMShadowMap ) ) && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {
+
+				object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );
+
+				const geometry = _objects.update( object );
+				const material = object.material;
+
+				if ( Array.isArray( material ) ) {
+
+					const groups = geometry.groups;
+
+					for ( let k = 0, kl = groups.length; k < kl; k ++ ) {
+
+						const group = groups[ k ];
+						const groupMaterial = material[ group.materialIndex ];
+
+						if ( groupMaterial && groupMaterial.visible ) {
+
+							const depthMaterial = getDepthMaterial( object, groupMaterial, light, type );
+
+							object.onBeforeShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, group );
+
+							_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );
+
+							object.onAfterShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, group );
+
+						}
+
+					}
+
+				} else if ( material.visible ) {
+
+					const depthMaterial = getDepthMaterial( object, material, light, type );
+
+					object.onBeforeShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, null );
+
+					_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );
+
+					object.onAfterShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, null );
+
+				}
+
+			}
+
+		}
+
+		const children = object.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			renderObject( children[ i ], camera, shadowCamera, light, type );
+
+		}
+
+	}
+
+	function onMaterialDispose( event ) {
+
+		const material = event.target;
+
+		material.removeEventListener( 'dispose', onMaterialDispose );
+
+		// make sure to remove the unique distance/depth materials used for shadow map rendering
+
+		for ( const id in _materialCache ) {
+
+			const cache = _materialCache[ id ];
+
+			const uuid = event.target.uuid;
+
+			if ( uuid in cache ) {
+
+				const shadowMaterial = cache[ uuid ];
+				shadowMaterial.dispose();
+				delete cache[ uuid ];
+
+			}
+
+		}
+
+	}
+
+}
+
+function WebGLState( gl, extensions, capabilities ) {
+
+	const isWebGL2 = capabilities.isWebGL2;
+
+	function ColorBuffer() {
+
+		let locked = false;
+
+		const color = new Vector4();
+		let currentColorMask = null;
+		const currentColorClear = new Vector4( 0, 0, 0, 0 );
+
+		return {
+
+			setMask: function ( colorMask ) {
+
+				if ( currentColorMask !== colorMask && ! locked ) {
+
+					gl.colorMask( colorMask, colorMask, colorMask, colorMask );
+					currentColorMask = colorMask;
+
+				}
+
+			},
+
+			setLocked: function ( lock ) {
+
+				locked = lock;
+
+			},
+
+			setClear: function ( r, g, b, a, premultipliedAlpha ) {
+
+				if ( premultipliedAlpha === true ) {
+
+					r *= a; g *= a; b *= a;
+
+				}
+
+				color.set( r, g, b, a );
+
+				if ( currentColorClear.equals( color ) === false ) {
+
+					gl.clearColor( r, g, b, a );
+					currentColorClear.copy( color );
+
+				}
+
+			},
+
+			reset: function () {
+
+				locked = false;
+
+				currentColorMask = null;
+				currentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state
+
+			}
+
+		};
+
+	}
+
+	function DepthBuffer() {
+
+		let locked = false;
+
+		let currentDepthMask = null;
+		let currentDepthFunc = null;
+		let currentDepthClear = null;
+
+		return {
+
+			setTest: function ( depthTest ) {
+
+				if ( depthTest ) {
+
+					enable( gl.DEPTH_TEST );
+
+				} else {
+
+					disable( gl.DEPTH_TEST );
+
+				}
+
+			},
+
+			setMask: function ( depthMask ) {
+
+				if ( currentDepthMask !== depthMask && ! locked ) {
+
+					gl.depthMask( depthMask );
+					currentDepthMask = depthMask;
+
+				}
+
+			},
+
+			setFunc: function ( depthFunc ) {
+
+				if ( currentDepthFunc !== depthFunc ) {
+
+					switch ( depthFunc ) {
+
+						case NeverDepth:
+
+							gl.depthFunc( gl.NEVER );
+							break;
+
+						case AlwaysDepth:
+
+							gl.depthFunc( gl.ALWAYS );
+							break;
+
+						case LessDepth:
+
+							gl.depthFunc( gl.LESS );
+							break;
+
+						case LessEqualDepth:
+
+							gl.depthFunc( gl.LEQUAL );
+							break;
+
+						case EqualDepth:
+
+							gl.depthFunc( gl.EQUAL );
+							break;
+
+						case GreaterEqualDepth:
+
+							gl.depthFunc( gl.GEQUAL );
+							break;
+
+						case GreaterDepth:
+
+							gl.depthFunc( gl.GREATER );
+							break;
+
+						case NotEqualDepth:
+
+							gl.depthFunc( gl.NOTEQUAL );
+							break;
+
+						default:
+
+							gl.depthFunc( gl.LEQUAL );
+
+					}
+
+					currentDepthFunc = depthFunc;
+
+				}
+
+			},
+
+			setLocked: function ( lock ) {
+
+				locked = lock;
+
+			},
+
+			setClear: function ( depth ) {
+
+				if ( currentDepthClear !== depth ) {
+
+					gl.clearDepth( depth );
+					currentDepthClear = depth;
+
+				}
+
+			},
+
+			reset: function () {
+
+				locked = false;
+
+				currentDepthMask = null;
+				currentDepthFunc = null;
+				currentDepthClear = null;
+
+			}
+
+		};
+
+	}
+
+	function StencilBuffer() {
+
+		let locked = false;
+
+		let currentStencilMask = null;
+		let currentStencilFunc = null;
+		let currentStencilRef = null;
+		let currentStencilFuncMask = null;
+		let currentStencilFail = null;
+		let currentStencilZFail = null;
+		let currentStencilZPass = null;
+		let currentStencilClear = null;
+
+		return {
+
+			setTest: function ( stencilTest ) {
+
+				if ( ! locked ) {
+
+					if ( stencilTest ) {
+
+						enable( gl.STENCIL_TEST );
+
+					} else {
+
+						disable( gl.STENCIL_TEST );
+
+					}
+
+				}
+
+			},
+
+			setMask: function ( stencilMask ) {
+
+				if ( currentStencilMask !== stencilMask && ! locked ) {
+
+					gl.stencilMask( stencilMask );
+					currentStencilMask = stencilMask;
+
+				}
+
+			},
+
+			setFunc: function ( stencilFunc, stencilRef, stencilMask ) {
+
+				if ( currentStencilFunc !== stencilFunc ||
+				     currentStencilRef !== stencilRef ||
+				     currentStencilFuncMask !== stencilMask ) {
+
+					gl.stencilFunc( stencilFunc, stencilRef, stencilMask );
+
+					currentStencilFunc = stencilFunc;
+					currentStencilRef = stencilRef;
+					currentStencilFuncMask = stencilMask;
+
+				}
+
+			},
+
+			setOp: function ( stencilFail, stencilZFail, stencilZPass ) {
+
+				if ( currentStencilFail !== stencilFail ||
+				     currentStencilZFail !== stencilZFail ||
+				     currentStencilZPass !== stencilZPass ) {
+
+					gl.stencilOp( stencilFail, stencilZFail, stencilZPass );
+
+					currentStencilFail = stencilFail;
+					currentStencilZFail = stencilZFail;
+					currentStencilZPass = stencilZPass;
+
+				}
+
+			},
+
+			setLocked: function ( lock ) {
+
+				locked = lock;
+
+			},
+
+			setClear: function ( stencil ) {
+
+				if ( currentStencilClear !== stencil ) {
+
+					gl.clearStencil( stencil );
+					currentStencilClear = stencil;
+
+				}
+
+			},
+
+			reset: function () {
+
+				locked = false;
+
+				currentStencilMask = null;
+				currentStencilFunc = null;
+				currentStencilRef = null;
+				currentStencilFuncMask = null;
+				currentStencilFail = null;
+				currentStencilZFail = null;
+				currentStencilZPass = null;
+				currentStencilClear = null;
+
+			}
+
+		};
+
+	}
+
+	//
+
+	const colorBuffer = new ColorBuffer();
+	const depthBuffer = new DepthBuffer();
+	const stencilBuffer = new StencilBuffer();
+
+	const uboBindings = new WeakMap();
+	const uboProgramMap = new WeakMap();
+
+	let enabledCapabilities = {};
+
+	let currentBoundFramebuffers = {};
+	let currentDrawbuffers = new WeakMap();
+	let defaultDrawbuffers = [];
+
+	let currentProgram = null;
+
+	let currentBlendingEnabled = false;
+	let currentBlending = null;
+	let currentBlendEquation = null;
+	let currentBlendSrc = null;
+	let currentBlendDst = null;
+	let currentBlendEquationAlpha = null;
+	let currentBlendSrcAlpha = null;
+	let currentBlendDstAlpha = null;
+	let currentBlendColor = new Color( 0, 0, 0 );
+	let currentBlendAlpha = 0;
+	let currentPremultipledAlpha = false;
+
+	let currentFlipSided = null;
+	let currentCullFace = null;
+
+	let currentLineWidth = null;
+
+	let currentPolygonOffsetFactor = null;
+	let currentPolygonOffsetUnits = null;
+
+	const maxTextures = gl.getParameter( gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS );
+
+	let lineWidthAvailable = false;
+	let version = 0;
+	const glVersion = gl.getParameter( gl.VERSION );
+
+	if ( glVersion.indexOf( 'WebGL' ) !== - 1 ) {
+
+		version = parseFloat( /^WebGL (\d)/.exec( glVersion )[ 1 ] );
+		lineWidthAvailable = ( version >= 1.0 );
+
+	} else if ( glVersion.indexOf( 'OpenGL ES' ) !== - 1 ) {
+
+		version = parseFloat( /^OpenGL ES (\d)/.exec( glVersion )[ 1 ] );
+		lineWidthAvailable = ( version >= 2.0 );
+
+	}
+
+	let currentTextureSlot = null;
+	let currentBoundTextures = {};
+
+	const scissorParam = gl.getParameter( gl.SCISSOR_BOX );
+	const viewportParam = gl.getParameter( gl.VIEWPORT );
+
+	const currentScissor = new Vector4().fromArray( scissorParam );
+	const currentViewport = new Vector4().fromArray( viewportParam );
+
+	function createTexture( type, target, count, dimensions ) {
+
+		const data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4.
+		const texture = gl.createTexture();
+
+		gl.bindTexture( type, texture );
+		gl.texParameteri( type, gl.TEXTURE_MIN_FILTER, gl.NEAREST );
+		gl.texParameteri( type, gl.TEXTURE_MAG_FILTER, gl.NEAREST );
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			if ( isWebGL2 && ( type === gl.TEXTURE_3D || type === gl.TEXTURE_2D_ARRAY ) ) {
+
+				gl.texImage3D( target, 0, gl.RGBA, 1, 1, dimensions, 0, gl.RGBA, gl.UNSIGNED_BYTE, data );
+
+			} else {
+
+				gl.texImage2D( target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data );
+
+			}
+
+		}
+
+		return texture;
+
+	}
+
+	const emptyTextures = {};
+	emptyTextures[ gl.TEXTURE_2D ] = createTexture( gl.TEXTURE_2D, gl.TEXTURE_2D, 1 );
+	emptyTextures[ gl.TEXTURE_CUBE_MAP ] = createTexture( gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6 );
+
+	if ( isWebGL2 ) {
+
+		emptyTextures[ gl.TEXTURE_2D_ARRAY ] = createTexture( gl.TEXTURE_2D_ARRAY, gl.TEXTURE_2D_ARRAY, 1, 1 );
+		emptyTextures[ gl.TEXTURE_3D ] = createTexture( gl.TEXTURE_3D, gl.TEXTURE_3D, 1, 1 );
+
+	}
+
+	// init
+
+	colorBuffer.setClear( 0, 0, 0, 1 );
+	depthBuffer.setClear( 1 );
+	stencilBuffer.setClear( 0 );
+
+	enable( gl.DEPTH_TEST );
+	depthBuffer.setFunc( LessEqualDepth );
+
+	setFlipSided( false );
+	setCullFace( CullFaceBack );
+	enable( gl.CULL_FACE );
+
+	setBlending( NoBlending );
+
+	//
+
+	function enable( id ) {
+
+		if ( enabledCapabilities[ id ] !== true ) {
+
+			gl.enable( id );
+			enabledCapabilities[ id ] = true;
+
+		}
+
+	}
+
+	function disable( id ) {
+
+		if ( enabledCapabilities[ id ] !== false ) {
+
+			gl.disable( id );
+			enabledCapabilities[ id ] = false;
+
+		}
+
+	}
+
+	function bindFramebuffer( target, framebuffer ) {
+
+		if ( currentBoundFramebuffers[ target ] !== framebuffer ) {
+
+			gl.bindFramebuffer( target, framebuffer );
+
+			currentBoundFramebuffers[ target ] = framebuffer;
+
+			if ( isWebGL2 ) {
+
+				// gl.DRAW_FRAMEBUFFER is equivalent to gl.FRAMEBUFFER
+
+				if ( target === gl.DRAW_FRAMEBUFFER ) {
+
+					currentBoundFramebuffers[ gl.FRAMEBUFFER ] = framebuffer;
+
+				}
+
+				if ( target === gl.FRAMEBUFFER ) {
+
+					currentBoundFramebuffers[ gl.DRAW_FRAMEBUFFER ] = framebuffer;
+
+				}
+
+			}
+
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+	function drawBuffers( renderTarget, framebuffer ) {
+
+		let drawBuffers = defaultDrawbuffers;
+
+		let needsUpdate = false;
+
+		if ( renderTarget ) {
+
+			drawBuffers = currentDrawbuffers.get( framebuffer );
+
+			if ( drawBuffers === undefined ) {
+
+				drawBuffers = [];
+				currentDrawbuffers.set( framebuffer, drawBuffers );
+
+			}
+
+			if ( renderTarget.isWebGLMultipleRenderTargets ) {
+
+				const textures = renderTarget.texture;
+
+				if ( drawBuffers.length !== textures.length || drawBuffers[ 0 ] !== gl.COLOR_ATTACHMENT0 ) {
+
+					for ( let i = 0, il = textures.length; i < il; i ++ ) {
+
+						drawBuffers[ i ] = gl.COLOR_ATTACHMENT0 + i;
+
+					}
+
+					drawBuffers.length = textures.length;
+
+					needsUpdate = true;
+
+				}
+
+			} else {
+
+				if ( drawBuffers[ 0 ] !== gl.COLOR_ATTACHMENT0 ) {
+
+					drawBuffers[ 0 ] = gl.COLOR_ATTACHMENT0;
+
+					needsUpdate = true;
+
+				}
+
+			}
+
+		} else {
+
+			if ( drawBuffers[ 0 ] !== gl.BACK ) {
+
+				drawBuffers[ 0 ] = gl.BACK;
+
+				needsUpdate = true;
+
+			}
+
+		}
+
+		if ( needsUpdate ) {
+
+			if ( capabilities.isWebGL2 ) {
+
+				gl.drawBuffers( drawBuffers );
+
+			} else {
+
+				extensions.get( 'WEBGL_draw_buffers' ).drawBuffersWEBGL( drawBuffers );
+
+			}
+
+		}
+
+
+	}
+
+	function useProgram( program ) {
+
+		if ( currentProgram !== program ) {
+
+			gl.useProgram( program );
+
+			currentProgram = program;
+
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+	const equationToGL = {
+		[ AddEquation ]: gl.FUNC_ADD,
+		[ SubtractEquation ]: gl.FUNC_SUBTRACT,
+		[ ReverseSubtractEquation ]: gl.FUNC_REVERSE_SUBTRACT
+	};
+
+	if ( isWebGL2 ) {
+
+		equationToGL[ MinEquation ] = gl.MIN;
+		equationToGL[ MaxEquation ] = gl.MAX;
+
+	} else {
+
+		const extension = extensions.get( 'EXT_blend_minmax' );
+
+		if ( extension !== null ) {
+
+			equationToGL[ MinEquation ] = extension.MIN_EXT;
+			equationToGL[ MaxEquation ] = extension.MAX_EXT;
+
+		}
+
+	}
+
+	const factorToGL = {
+		[ ZeroFactor ]: gl.ZERO,
+		[ OneFactor ]: gl.ONE,
+		[ SrcColorFactor ]: gl.SRC_COLOR,
+		[ SrcAlphaFactor ]: gl.SRC_ALPHA,
+		[ SrcAlphaSaturateFactor ]: gl.SRC_ALPHA_SATURATE,
+		[ DstColorFactor ]: gl.DST_COLOR,
+		[ DstAlphaFactor ]: gl.DST_ALPHA,
+		[ OneMinusSrcColorFactor ]: gl.ONE_MINUS_SRC_COLOR,
+		[ OneMinusSrcAlphaFactor ]: gl.ONE_MINUS_SRC_ALPHA,
+		[ OneMinusDstColorFactor ]: gl.ONE_MINUS_DST_COLOR,
+		[ OneMinusDstAlphaFactor ]: gl.ONE_MINUS_DST_ALPHA,
+		[ ConstantColorFactor ]: gl.CONSTANT_COLOR,
+		[ OneMinusConstantColorFactor ]: gl.ONE_MINUS_CONSTANT_COLOR,
+		[ ConstantAlphaFactor ]: gl.CONSTANT_ALPHA,
+		[ OneMinusConstantAlphaFactor ]: gl.ONE_MINUS_CONSTANT_ALPHA
+	};
+
+	function setBlending( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, blendColor, blendAlpha, premultipliedAlpha ) {
+
+		if ( blending === NoBlending ) {
+
+			if ( currentBlendingEnabled === true ) {
+
+				disable( gl.BLEND );
+				currentBlendingEnabled = false;
+
+			}
+
+			return;
+
+		}
+
+		if ( currentBlendingEnabled === false ) {
+
+			enable( gl.BLEND );
+			currentBlendingEnabled = true;
+
+		}
+
+		if ( blending !== CustomBlending ) {
+
+			if ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {
+
+				if ( currentBlendEquation !== AddEquation || currentBlendEquationAlpha !== AddEquation ) {
+
+					gl.blendEquation( gl.FUNC_ADD );
+
+					currentBlendEquation = AddEquation;
+					currentBlendEquationAlpha = AddEquation;
+
+				}
+
+				if ( premultipliedAlpha ) {
+
+					switch ( blending ) {
+
+						case NormalBlending:
+							gl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );
+							break;
+
+						case AdditiveBlending:
+							gl.blendFunc( gl.ONE, gl.ONE );
+							break;
+
+						case SubtractiveBlending:
+							gl.blendFuncSeparate( gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE );
+							break;
+
+						case MultiplyBlending:
+							gl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA );
+							break;
+
+						default:
+							console.error( 'THREE.WebGLState: Invalid blending: ', blending );
+							break;
+
+					}
+
+				} else {
+
+					switch ( blending ) {
+
+						case NormalBlending:
+							gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );
+							break;
+
+						case AdditiveBlending:
+							gl.blendFunc( gl.SRC_ALPHA, gl.ONE );
+							break;
+
+						case SubtractiveBlending:
+							gl.blendFuncSeparate( gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE );
+							break;
+
+						case MultiplyBlending:
+							gl.blendFunc( gl.ZERO, gl.SRC_COLOR );
+							break;
+
+						default:
+							console.error( 'THREE.WebGLState: Invalid blending: ', blending );
+							break;
+
+					}
+
+				}
+
+				currentBlendSrc = null;
+				currentBlendDst = null;
+				currentBlendSrcAlpha = null;
+				currentBlendDstAlpha = null;
+				currentBlendColor.set( 0, 0, 0 );
+				currentBlendAlpha = 0;
+
+				currentBlending = blending;
+				currentPremultipledAlpha = premultipliedAlpha;
+
+			}
+
+			return;
+
+		}
+
+		// custom blending
+
+		blendEquationAlpha = blendEquationAlpha || blendEquation;
+		blendSrcAlpha = blendSrcAlpha || blendSrc;
+		blendDstAlpha = blendDstAlpha || blendDst;
+
+		if ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {
+
+			gl.blendEquationSeparate( equationToGL[ blendEquation ], equationToGL[ blendEquationAlpha ] );
+
+			currentBlendEquation = blendEquation;
+			currentBlendEquationAlpha = blendEquationAlpha;
+
+		}
+
+		if ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {
+
+			gl.blendFuncSeparate( factorToGL[ blendSrc ], factorToGL[ blendDst ], factorToGL[ blendSrcAlpha ], factorToGL[ blendDstAlpha ] );
+
+			currentBlendSrc = blendSrc;
+			currentBlendDst = blendDst;
+			currentBlendSrcAlpha = blendSrcAlpha;
+			currentBlendDstAlpha = blendDstAlpha;
+
+		}
+
+		if ( blendColor.equals( currentBlendColor ) === false || blendAlpha !== currentBlendAlpha ) {
+
+			gl.blendColor( blendColor.r, blendColor.g, blendColor.b, blendAlpha );
+
+			currentBlendColor.copy( blendColor );
+			currentBlendAlpha = blendAlpha;
+
+		}
+
+		currentBlending = blending;
+		currentPremultipledAlpha = false;
+
+	}
+
+	function setMaterial( material, frontFaceCW ) {
+
+		material.side === DoubleSide
+			? disable( gl.CULL_FACE )
+			: enable( gl.CULL_FACE );
+
+		let flipSided = ( material.side === BackSide );
+		if ( frontFaceCW ) flipSided = ! flipSided;
+
+		setFlipSided( flipSided );
+
+		( material.blending === NormalBlending && material.transparent === false )
+			? setBlending( NoBlending )
+			: setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha );
+
+		depthBuffer.setFunc( material.depthFunc );
+		depthBuffer.setTest( material.depthTest );
+		depthBuffer.setMask( material.depthWrite );
+		colorBuffer.setMask( material.colorWrite );
+
+		const stencilWrite = material.stencilWrite;
+		stencilBuffer.setTest( stencilWrite );
+		if ( stencilWrite ) {
+
+			stencilBuffer.setMask( material.stencilWriteMask );
+			stencilBuffer.setFunc( material.stencilFunc, material.stencilRef, material.stencilFuncMask );
+			stencilBuffer.setOp( material.stencilFail, material.stencilZFail, material.stencilZPass );
+
+		}
+
+		setPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );
+
+		material.alphaToCoverage === true
+			? enable( gl.SAMPLE_ALPHA_TO_COVERAGE )
+			: disable( gl.SAMPLE_ALPHA_TO_COVERAGE );
+
+	}
+
+	//
+
+	function setFlipSided( flipSided ) {
+
+		if ( currentFlipSided !== flipSided ) {
+
+			if ( flipSided ) {
+
+				gl.frontFace( gl.CW );
+
+			} else {
+
+				gl.frontFace( gl.CCW );
+
+			}
+
+			currentFlipSided = flipSided;
+
+		}
+
+	}
+
+	function setCullFace( cullFace ) {
+
+		if ( cullFace !== CullFaceNone ) {
+
+			enable( gl.CULL_FACE );
+
+			if ( cullFace !== currentCullFace ) {
+
+				if ( cullFace === CullFaceBack ) {
+
+					gl.cullFace( gl.BACK );
+
+				} else if ( cullFace === CullFaceFront ) {
+
+					gl.cullFace( gl.FRONT );
+
+				} else {
+
+					gl.cullFace( gl.FRONT_AND_BACK );
+
+				}
+
+			}
+
+		} else {
+
+			disable( gl.CULL_FACE );
+
+		}
+
+		currentCullFace = cullFace;
+
+	}
+
+	function setLineWidth( width ) {
+
+		if ( width !== currentLineWidth ) {
+
+			if ( lineWidthAvailable ) gl.lineWidth( width );
+
+			currentLineWidth = width;
+
+		}
+
+	}
+
+	function setPolygonOffset( polygonOffset, factor, units ) {
+
+		if ( polygonOffset ) {
+
+			enable( gl.POLYGON_OFFSET_FILL );
+
+			if ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) {
+
+				gl.polygonOffset( factor, units );
+
+				currentPolygonOffsetFactor = factor;
+				currentPolygonOffsetUnits = units;
+
+			}
+
+		} else {
+
+			disable( gl.POLYGON_OFFSET_FILL );
+
+		}
+
+	}
+
+	function setScissorTest( scissorTest ) {
+
+		if ( scissorTest ) {
+
+			enable( gl.SCISSOR_TEST );
+
+		} else {
+
+			disable( gl.SCISSOR_TEST );
+
+		}
+
+	}
+
+	// texture
+
+	function activeTexture( webglSlot ) {
+
+		if ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1;
+
+		if ( currentTextureSlot !== webglSlot ) {
+
+			gl.activeTexture( webglSlot );
+			currentTextureSlot = webglSlot;
+
+		}
+
+	}
+
+	function bindTexture( webglType, webglTexture, webglSlot ) {
+
+		if ( webglSlot === undefined ) {
+
+			if ( currentTextureSlot === null ) {
+
+				webglSlot = gl.TEXTURE0 + maxTextures - 1;
+
+			} else {
+
+				webglSlot = currentTextureSlot;
+
+			}
+
+		}
+
+		let boundTexture = currentBoundTextures[ webglSlot ];
+
+		if ( boundTexture === undefined ) {
+
+			boundTexture = { type: undefined, texture: undefined };
+			currentBoundTextures[ webglSlot ] = boundTexture;
+
+		}
+
+		if ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {
+
+			if ( currentTextureSlot !== webglSlot ) {
+
+				gl.activeTexture( webglSlot );
+				currentTextureSlot = webglSlot;
+
+			}
+
+			gl.bindTexture( webglType, webglTexture || emptyTextures[ webglType ] );
+
+			boundTexture.type = webglType;
+			boundTexture.texture = webglTexture;
+
+		}
+
+	}
+
+	function unbindTexture() {
+
+		const boundTexture = currentBoundTextures[ currentTextureSlot ];
+
+		if ( boundTexture !== undefined && boundTexture.type !== undefined ) {
+
+			gl.bindTexture( boundTexture.type, null );
+
+			boundTexture.type = undefined;
+			boundTexture.texture = undefined;
+
+		}
+
+	}
+
+	function compressedTexImage2D() {
+
+		try {
+
+			gl.compressedTexImage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function compressedTexImage3D() {
+
+		try {
+
+			gl.compressedTexImage3D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function texSubImage2D() {
+
+		try {
+
+			gl.texSubImage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function texSubImage3D() {
+
+		try {
+
+			gl.texSubImage3D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function compressedTexSubImage2D() {
+
+		try {
+
+			gl.compressedTexSubImage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function compressedTexSubImage3D() {
+
+		try {
+
+			gl.compressedTexSubImage3D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function texStorage2D() {
+
+		try {
+
+			gl.texStorage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function texStorage3D() {
+
+		try {
+
+			gl.texStorage3D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function texImage2D() {
+
+		try {
+
+			gl.texImage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	function texImage3D() {
+
+		try {
+
+			gl.texImage3D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLState:', error );
+
+		}
+
+	}
+
+	//
+
+	function scissor( scissor ) {
+
+		if ( currentScissor.equals( scissor ) === false ) {
+
+			gl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );
+			currentScissor.copy( scissor );
+
+		}
+
+	}
+
+	function viewport( viewport ) {
+
+		if ( currentViewport.equals( viewport ) === false ) {
+
+			gl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );
+			currentViewport.copy( viewport );
+
+		}
+
+	}
+
+	function updateUBOMapping( uniformsGroup, program ) {
+
+		let mapping = uboProgramMap.get( program );
+
+		if ( mapping === undefined ) {
+
+			mapping = new WeakMap();
+
+			uboProgramMap.set( program, mapping );
+
+		}
+
+		let blockIndex = mapping.get( uniformsGroup );
+
+		if ( blockIndex === undefined ) {
+
+			blockIndex = gl.getUniformBlockIndex( program, uniformsGroup.name );
+
+			mapping.set( uniformsGroup, blockIndex );
+
+		}
+
+	}
+
+	function uniformBlockBinding( uniformsGroup, program ) {
+
+		const mapping = uboProgramMap.get( program );
+		const blockIndex = mapping.get( uniformsGroup );
+
+		if ( uboBindings.get( program ) !== blockIndex ) {
+
+			// bind shader specific block index to global block point
+			gl.uniformBlockBinding( program, blockIndex, uniformsGroup.__bindingPointIndex );
+
+			uboBindings.set( program, blockIndex );
+
+		}
+
+	}
+
+	//
+
+	function reset() {
+
+		// reset state
+
+		gl.disable( gl.BLEND );
+		gl.disable( gl.CULL_FACE );
+		gl.disable( gl.DEPTH_TEST );
+		gl.disable( gl.POLYGON_OFFSET_FILL );
+		gl.disable( gl.SCISSOR_TEST );
+		gl.disable( gl.STENCIL_TEST );
+		gl.disable( gl.SAMPLE_ALPHA_TO_COVERAGE );
+
+		gl.blendEquation( gl.FUNC_ADD );
+		gl.blendFunc( gl.ONE, gl.ZERO );
+		gl.blendFuncSeparate( gl.ONE, gl.ZERO, gl.ONE, gl.ZERO );
+		gl.blendColor( 0, 0, 0, 0 );
+
+		gl.colorMask( true, true, true, true );
+		gl.clearColor( 0, 0, 0, 0 );
+
+		gl.depthMask( true );
+		gl.depthFunc( gl.LESS );
+		gl.clearDepth( 1 );
+
+		gl.stencilMask( 0xffffffff );
+		gl.stencilFunc( gl.ALWAYS, 0, 0xffffffff );
+		gl.stencilOp( gl.KEEP, gl.KEEP, gl.KEEP );
+		gl.clearStencil( 0 );
+
+		gl.cullFace( gl.BACK );
+		gl.frontFace( gl.CCW );
+
+		gl.polygonOffset( 0, 0 );
+
+		gl.activeTexture( gl.TEXTURE0 );
+
+		gl.bindFramebuffer( gl.FRAMEBUFFER, null );
+
+		if ( isWebGL2 === true ) {
+
+			gl.bindFramebuffer( gl.DRAW_FRAMEBUFFER, null );
+			gl.bindFramebuffer( gl.READ_FRAMEBUFFER, null );
+
+		}
+
+		gl.useProgram( null );
+
+		gl.lineWidth( 1 );
+
+		gl.scissor( 0, 0, gl.canvas.width, gl.canvas.height );
+		gl.viewport( 0, 0, gl.canvas.width, gl.canvas.height );
+
+		// reset internals
+
+		enabledCapabilities = {};
+
+		currentTextureSlot = null;
+		currentBoundTextures = {};
+
+		currentBoundFramebuffers = {};
+		currentDrawbuffers = new WeakMap();
+		defaultDrawbuffers = [];
+
+		currentProgram = null;
+
+		currentBlendingEnabled = false;
+		currentBlending = null;
+		currentBlendEquation = null;
+		currentBlendSrc = null;
+		currentBlendDst = null;
+		currentBlendEquationAlpha = null;
+		currentBlendSrcAlpha = null;
+		currentBlendDstAlpha = null;
+		currentBlendColor = new Color( 0, 0, 0 );
+		currentBlendAlpha = 0;
+		currentPremultipledAlpha = false;
+
+		currentFlipSided = null;
+		currentCullFace = null;
+
+		currentLineWidth = null;
+
+		currentPolygonOffsetFactor = null;
+		currentPolygonOffsetUnits = null;
+
+		currentScissor.set( 0, 0, gl.canvas.width, gl.canvas.height );
+		currentViewport.set( 0, 0, gl.canvas.width, gl.canvas.height );
+
+		colorBuffer.reset();
+		depthBuffer.reset();
+		stencilBuffer.reset();
+
+	}
+
+	return {
+
+		buffers: {
+			color: colorBuffer,
+			depth: depthBuffer,
+			stencil: stencilBuffer
+		},
+
+		enable: enable,
+		disable: disable,
+
+		bindFramebuffer: bindFramebuffer,
+		drawBuffers: drawBuffers,
+
+		useProgram: useProgram,
+
+		setBlending: setBlending,
+		setMaterial: setMaterial,
+
+		setFlipSided: setFlipSided,
+		setCullFace: setCullFace,
+
+		setLineWidth: setLineWidth,
+		setPolygonOffset: setPolygonOffset,
+
+		setScissorTest: setScissorTest,
+
+		activeTexture: activeTexture,
+		bindTexture: bindTexture,
+		unbindTexture: unbindTexture,
+		compressedTexImage2D: compressedTexImage2D,
+		compressedTexImage3D: compressedTexImage3D,
+		texImage2D: texImage2D,
+		texImage3D: texImage3D,
+
+		updateUBOMapping: updateUBOMapping,
+		uniformBlockBinding: uniformBlockBinding,
+
+		texStorage2D: texStorage2D,
+		texStorage3D: texStorage3D,
+		texSubImage2D: texSubImage2D,
+		texSubImage3D: texSubImage3D,
+		compressedTexSubImage2D: compressedTexSubImage2D,
+		compressedTexSubImage3D: compressedTexSubImage3D,
+
+		scissor: scissor,
+		viewport: viewport,
+
+		reset: reset
+
+	};
+
+}
+
+function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info ) {
+
+	const isWebGL2 = capabilities.isWebGL2;
+	const multisampledRTTExt = extensions.has( 'WEBGL_multisampled_render_to_texture' ) ? extensions.get( 'WEBGL_multisampled_render_to_texture' ) : null;
+	const supportsInvalidateFramebuffer = typeof navigator === 'undefined' ? false : /OculusBrowser/g.test( navigator.userAgent );
+
+	const _videoTextures = new WeakMap();
+	let _canvas;
+
+	const _sources = new WeakMap(); // maps WebglTexture objects to instances of Source
+
+	// cordova iOS (as of 5.0) still uses UIWebView, which provides OffscreenCanvas,
+	// also OffscreenCanvas.getContext("webgl"), but not OffscreenCanvas.getContext("2d")!
+	// Some implementations may only implement OffscreenCanvas partially (e.g. lacking 2d).
+
+	let useOffscreenCanvas = false;
+
+	try {
+
+		useOffscreenCanvas = typeof OffscreenCanvas !== 'undefined'
+			// eslint-disable-next-line compat/compat
+			&& ( new OffscreenCanvas( 1, 1 ).getContext( '2d' ) ) !== null;
+
+	} catch ( err ) {
+
+		// Ignore any errors
+
+	}
+
+	function createCanvas( width, height ) {
+
+		// Use OffscreenCanvas when available. Specially needed in web workers
+
+		return useOffscreenCanvas ?
+			// eslint-disable-next-line compat/compat
+			new OffscreenCanvas( width, height ) : createElementNS( 'canvas' );
+
+	}
+
+	function resizeImage( image, needsPowerOfTwo, needsNewCanvas, maxSize ) {
+
+		let scale = 1;
+
+		// handle case if texture exceeds max size
+
+		if ( image.width > maxSize || image.height > maxSize ) {
+
+			scale = maxSize / Math.max( image.width, image.height );
+
+		}
+
+		// only perform resize if necessary
+
+		if ( scale < 1 || needsPowerOfTwo === true ) {
+
+			// only perform resize for certain image types
+
+			if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
+				( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
+				( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
+
+				const floor = needsPowerOfTwo ? floorPowerOfTwo : Math.floor;
+
+				const width = floor( scale * image.width );
+				const height = floor( scale * image.height );
+
+				if ( _canvas === undefined ) _canvas = createCanvas( width, height );
+
+				// cube textures can't reuse the same canvas
+
+				const canvas = needsNewCanvas ? createCanvas( width, height ) : _canvas;
+
+				canvas.width = width;
+				canvas.height = height;
+
+				const context = canvas.getContext( '2d' );
+				context.drawImage( image, 0, 0, width, height );
+
+				console.warn( 'THREE.WebGLRenderer: Texture has been resized from (' + image.width + 'x' + image.height + ') to (' + width + 'x' + height + ').' );
+
+				return canvas;
+
+			} else {
+
+				if ( 'data' in image ) {
+
+					console.warn( 'THREE.WebGLRenderer: Image in DataTexture is too big (' + image.width + 'x' + image.height + ').' );
+
+				}
+
+				return image;
+
+			}
+
+		}
+
+		return image;
+
+	}
+
+	function isPowerOfTwo$1( image ) {
+
+		return isPowerOfTwo( image.width ) && isPowerOfTwo( image.height );
+
+	}
+
+	function textureNeedsPowerOfTwo( texture ) {
+
+		if ( isWebGL2 ) return false;
+
+		return ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) ||
+			( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter );
+
+	}
+
+	function textureNeedsGenerateMipmaps( texture, supportsMips ) {
+
+		return texture.generateMipmaps && supportsMips &&
+			texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;
+
+	}
+
+	function generateMipmap( target ) {
+
+		_gl.generateMipmap( target );
+
+	}
+
+	function getInternalFormat( internalFormatName, glFormat, glType, colorSpace, forceLinearTransfer = false ) {
+
+		if ( isWebGL2 === false ) return glFormat;
+
+		if ( internalFormatName !== null ) {
+
+			if ( _gl[ internalFormatName ] !== undefined ) return _gl[ internalFormatName ];
+
+			console.warn( 'THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format \'' + internalFormatName + '\'' );
+
+		}
+
+		let internalFormat = glFormat;
+
+		if ( glFormat === _gl.RED ) {
+
+			if ( glType === _gl.FLOAT ) internalFormat = _gl.R32F;
+			if ( glType === _gl.HALF_FLOAT ) internalFormat = _gl.R16F;
+			if ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.R8;
+
+		}
+
+		if ( glFormat === _gl.RED_INTEGER ) {
+
+			if ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.R8UI;
+			if ( glType === _gl.UNSIGNED_SHORT ) internalFormat = _gl.R16UI;
+			if ( glType === _gl.UNSIGNED_INT ) internalFormat = _gl.R32UI;
+			if ( glType === _gl.BYTE ) internalFormat = _gl.R8I;
+			if ( glType === _gl.SHORT ) internalFormat = _gl.R16I;
+			if ( glType === _gl.INT ) internalFormat = _gl.R32I;
+
+		}
+
+		if ( glFormat === _gl.RG ) {
+
+			if ( glType === _gl.FLOAT ) internalFormat = _gl.RG32F;
+			if ( glType === _gl.HALF_FLOAT ) internalFormat = _gl.RG16F;
+			if ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.RG8;
+
+		}
+
+		if ( glFormat === _gl.RGBA ) {
+
+			const transfer = forceLinearTransfer ? LinearTransfer : ColorManagement.getTransfer( colorSpace );
+
+			if ( glType === _gl.FLOAT ) internalFormat = _gl.RGBA32F;
+			if ( glType === _gl.HALF_FLOAT ) internalFormat = _gl.RGBA16F;
+			if ( glType === _gl.UNSIGNED_BYTE ) internalFormat = ( transfer === SRGBTransfer ) ? _gl.SRGB8_ALPHA8 : _gl.RGBA8;
+			if ( glType === _gl.UNSIGNED_SHORT_4_4_4_4 ) internalFormat = _gl.RGBA4;
+			if ( glType === _gl.UNSIGNED_SHORT_5_5_5_1 ) internalFormat = _gl.RGB5_A1;
+
+		}
+
+		if ( internalFormat === _gl.R16F || internalFormat === _gl.R32F ||
+			internalFormat === _gl.RG16F || internalFormat === _gl.RG32F ||
+			internalFormat === _gl.RGBA16F || internalFormat === _gl.RGBA32F ) {
+
+			extensions.get( 'EXT_color_buffer_float' );
+
+		}
+
+		return internalFormat;
+
+	}
+
+	function getMipLevels( texture, image, supportsMips ) {
+
+		if ( textureNeedsGenerateMipmaps( texture, supportsMips ) === true || ( texture.isFramebufferTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) ) {
+
+			return Math.log2( Math.max( image.width, image.height ) ) + 1;
+
+		} else if ( texture.mipmaps !== undefined && texture.mipmaps.length > 0 ) {
+
+			// user-defined mipmaps
+
+			return texture.mipmaps.length;
+
+		} else if ( texture.isCompressedTexture && Array.isArray( texture.image ) ) {
+
+			return image.mipmaps.length;
+
+		} else {
+
+			// texture without mipmaps (only base level)
+
+			return 1;
+
+		}
+
+	}
+
+	// Fallback filters for non-power-of-2 textures
+
+	function filterFallback( f ) {
+
+		if ( f === NearestFilter || f === NearestMipmapNearestFilter || f === NearestMipmapLinearFilter ) {
+
+			return _gl.NEAREST;
+
+		}
+
+		return _gl.LINEAR;
+
+	}
+
+	//
+
+	function onTextureDispose( event ) {
+
+		const texture = event.target;
+
+		texture.removeEventListener( 'dispose', onTextureDispose );
+
+		deallocateTexture( texture );
+
+		if ( texture.isVideoTexture ) {
+
+			_videoTextures.delete( texture );
+
+		}
+
+	}
+
+	function onRenderTargetDispose( event ) {
+
+		const renderTarget = event.target;
+
+		renderTarget.removeEventListener( 'dispose', onRenderTargetDispose );
+
+		deallocateRenderTarget( renderTarget );
+
+	}
+
+	//
+
+	function deallocateTexture( texture ) {
+
+		const textureProperties = properties.get( texture );
+
+		if ( textureProperties.__webglInit === undefined ) return;
+
+		// check if it's necessary to remove the WebGLTexture object
+
+		const source = texture.source;
+		const webglTextures = _sources.get( source );
+
+		if ( webglTextures ) {
+
+			const webglTexture = webglTextures[ textureProperties.__cacheKey ];
+			webglTexture.usedTimes --;
+
+			// the WebGLTexture object is not used anymore, remove it
+
+			if ( webglTexture.usedTimes === 0 ) {
+
+				deleteTexture( texture );
+
+			}
+
+			// remove the weak map entry if no WebGLTexture uses the source anymore
+
+			if ( Object.keys( webglTextures ).length === 0 ) {
+
+				_sources.delete( source );
+
+			}
+
+		}
+
+		properties.remove( texture );
+
+	}
+
+	function deleteTexture( texture ) {
+
+		const textureProperties = properties.get( texture );
+		_gl.deleteTexture( textureProperties.__webglTexture );
+
+		const source = texture.source;
+		const webglTextures = _sources.get( source );
+		delete webglTextures[ textureProperties.__cacheKey ];
+
+		info.memory.textures --;
+
+	}
+
+	function deallocateRenderTarget( renderTarget ) {
+
+		const texture = renderTarget.texture;
+
+		const renderTargetProperties = properties.get( renderTarget );
+		const textureProperties = properties.get( texture );
+
+		if ( textureProperties.__webglTexture !== undefined ) {
+
+			_gl.deleteTexture( textureProperties.__webglTexture );
+
+			info.memory.textures --;
+
+		}
+
+		if ( renderTarget.depthTexture ) {
+
+			renderTarget.depthTexture.dispose();
+
+		}
+
+		if ( renderTarget.isWebGLCubeRenderTarget ) {
+
+			for ( let i = 0; i < 6; i ++ ) {
+
+				if ( Array.isArray( renderTargetProperties.__webglFramebuffer[ i ] ) ) {
+
+					for ( let level = 0; level < renderTargetProperties.__webglFramebuffer[ i ].length; level ++ ) _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ][ level ] );
+
+				} else {
+
+					_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );
+
+				}
+
+				if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );
+
+			}
+
+		} else {
+
+			if ( Array.isArray( renderTargetProperties.__webglFramebuffer ) ) {
+
+				for ( let level = 0; level < renderTargetProperties.__webglFramebuffer.length; level ++ ) _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ level ] );
+
+			} else {
+
+				_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );
+
+			}
+
+			if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );
+			if ( renderTargetProperties.__webglMultisampledFramebuffer ) _gl.deleteFramebuffer( renderTargetProperties.__webglMultisampledFramebuffer );
+
+			if ( renderTargetProperties.__webglColorRenderbuffer ) {
+
+				for ( let i = 0; i < renderTargetProperties.__webglColorRenderbuffer.length; i ++ ) {
+
+					if ( renderTargetProperties.__webglColorRenderbuffer[ i ] ) _gl.deleteRenderbuffer( renderTargetProperties.__webglColorRenderbuffer[ i ] );
+
+				}
+
+			}
+
+			if ( renderTargetProperties.__webglDepthRenderbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthRenderbuffer );
+
+		}
+
+		if ( renderTarget.isWebGLMultipleRenderTargets ) {
+
+			for ( let i = 0, il = texture.length; i < il; i ++ ) {
+
+				const attachmentProperties = properties.get( texture[ i ] );
+
+				if ( attachmentProperties.__webglTexture ) {
+
+					_gl.deleteTexture( attachmentProperties.__webglTexture );
+
+					info.memory.textures --;
+
+				}
+
+				properties.remove( texture[ i ] );
+
+			}
+
+		}
+
+		properties.remove( texture );
+		properties.remove( renderTarget );
+
+	}
+
+	//
+
+	let textureUnits = 0;
+
+	function resetTextureUnits() {
+
+		textureUnits = 0;
+
+	}
+
+	function allocateTextureUnit() {
+
+		const textureUnit = textureUnits;
+
+		if ( textureUnit >= capabilities.maxTextures ) {
+
+			console.warn( 'THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures );
+
+		}
+
+		textureUnits += 1;
+
+		return textureUnit;
+
+	}
+
+	function getTextureCacheKey( texture ) {
+
+		const array = [];
+
+		array.push( texture.wrapS );
+		array.push( texture.wrapT );
+		array.push( texture.wrapR || 0 );
+		array.push( texture.magFilter );
+		array.push( texture.minFilter );
+		array.push( texture.anisotropy );
+		array.push( texture.internalFormat );
+		array.push( texture.format );
+		array.push( texture.type );
+		array.push( texture.generateMipmaps );
+		array.push( texture.premultiplyAlpha );
+		array.push( texture.flipY );
+		array.push( texture.unpackAlignment );
+		array.push( texture.colorSpace );
+
+		return array.join();
+
+	}
+
+	//
+
+	function setTexture2D( texture, slot ) {
+
+		const textureProperties = properties.get( texture );
+
+		if ( texture.isVideoTexture ) updateVideoTexture( texture );
+
+		if ( texture.isRenderTargetTexture === false && texture.version > 0 && textureProperties.__version !== texture.version ) {
+
+			const image = texture.image;
+
+			if ( image === null ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture marked for update but no image data found.' );
+
+			} else if ( image.complete === false ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete' );
+
+			} else {
+
+				uploadTexture( textureProperties, texture, slot );
+				return;
+
+			}
+
+		}
+
+		state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );
+
+	}
+
+	function setTexture2DArray( texture, slot ) {
+
+		const textureProperties = properties.get( texture );
+
+		if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
+
+			uploadTexture( textureProperties, texture, slot );
+			return;
+
+		}
+
+		state.bindTexture( _gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );
+
+	}
+
+	function setTexture3D( texture, slot ) {
+
+		const textureProperties = properties.get( texture );
+
+		if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
+
+			uploadTexture( textureProperties, texture, slot );
+			return;
+
+		}
+
+		state.bindTexture( _gl.TEXTURE_3D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );
+
+	}
+
+	function setTextureCube( texture, slot ) {
+
+		const textureProperties = properties.get( texture );
+
+		if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
+
+			uploadCubeTexture( textureProperties, texture, slot );
+			return;
+
+		}
+
+		state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );
+
+	}
+
+	const wrappingToGL = {
+		[ RepeatWrapping ]: _gl.REPEAT,
+		[ ClampToEdgeWrapping ]: _gl.CLAMP_TO_EDGE,
+		[ MirroredRepeatWrapping ]: _gl.MIRRORED_REPEAT
+	};
+
+	const filterToGL = {
+		[ NearestFilter ]: _gl.NEAREST,
+		[ NearestMipmapNearestFilter ]: _gl.NEAREST_MIPMAP_NEAREST,
+		[ NearestMipmapLinearFilter ]: _gl.NEAREST_MIPMAP_LINEAR,
+
+		[ LinearFilter ]: _gl.LINEAR,
+		[ LinearMipmapNearestFilter ]: _gl.LINEAR_MIPMAP_NEAREST,
+		[ LinearMipmapLinearFilter ]: _gl.LINEAR_MIPMAP_LINEAR
+	};
+
+	const compareToGL = {
+		[ NeverCompare ]: _gl.NEVER,
+		[ AlwaysCompare ]: _gl.ALWAYS,
+		[ LessCompare ]: _gl.LESS,
+		[ LessEqualCompare ]: _gl.LEQUAL,
+		[ EqualCompare ]: _gl.EQUAL,
+		[ GreaterEqualCompare ]: _gl.GEQUAL,
+		[ GreaterCompare ]: _gl.GREATER,
+		[ NotEqualCompare ]: _gl.NOTEQUAL
+	};
+
+	function setTextureParameters( textureType, texture, supportsMips ) {
+
+		if ( supportsMips ) {
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, wrappingToGL[ texture.wrapS ] );
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, wrappingToGL[ texture.wrapT ] );
+
+			if ( textureType === _gl.TEXTURE_3D || textureType === _gl.TEXTURE_2D_ARRAY ) {
+
+				_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_R, wrappingToGL[ texture.wrapR ] );
+
+			}
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterToGL[ texture.magFilter ] );
+			_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterToGL[ texture.minFilter ] );
+
+		} else {
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE );
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE );
+
+			if ( textureType === _gl.TEXTURE_3D || textureType === _gl.TEXTURE_2D_ARRAY ) {
+
+				_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_R, _gl.CLAMP_TO_EDGE );
+
+			}
+
+			if ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.' );
+
+			}
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) );
+			_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) );
+
+			if ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.' );
+
+			}
+
+		}
+
+		if ( texture.compareFunction ) {
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_COMPARE_MODE, _gl.COMPARE_REF_TO_TEXTURE );
+			_gl.texParameteri( textureType, _gl.TEXTURE_COMPARE_FUNC, compareToGL[ texture.compareFunction ] );
+
+		}
+
+		if ( extensions.has( 'EXT_texture_filter_anisotropic' ) === true ) {
+
+			const extension = extensions.get( 'EXT_texture_filter_anisotropic' );
+
+			if ( texture.magFilter === NearestFilter ) return;
+			if ( texture.minFilter !== NearestMipmapLinearFilter && texture.minFilter !== LinearMipmapLinearFilter ) return;
+			if ( texture.type === FloatType && extensions.has( 'OES_texture_float_linear' ) === false ) return; // verify extension for WebGL 1 and WebGL 2
+			if ( isWebGL2 === false && ( texture.type === HalfFloatType && extensions.has( 'OES_texture_half_float_linear' ) === false ) ) return; // verify extension for WebGL 1 only
+
+			if ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {
+
+				_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) );
+				properties.get( texture ).__currentAnisotropy = texture.anisotropy;
+
+			}
+
+		}
+
+	}
+
+	function initTexture( textureProperties, texture ) {
+
+		let forceUpload = false;
+
+		if ( textureProperties.__webglInit === undefined ) {
+
+			textureProperties.__webglInit = true;
+
+			texture.addEventListener( 'dispose', onTextureDispose );
+
+		}
+
+		// create Source <-> WebGLTextures mapping if necessary
+
+		const source = texture.source;
+		let webglTextures = _sources.get( source );
+
+		if ( webglTextures === undefined ) {
+
+			webglTextures = {};
+			_sources.set( source, webglTextures );
+
+		}
+
+		// check if there is already a WebGLTexture object for the given texture parameters
+
+		const textureCacheKey = getTextureCacheKey( texture );
+
+		if ( textureCacheKey !== textureProperties.__cacheKey ) {
+
+			// if not, create a new instance of WebGLTexture
+
+			if ( webglTextures[ textureCacheKey ] === undefined ) {
+
+				// create new entry
+
+				webglTextures[ textureCacheKey ] = {
+					texture: _gl.createTexture(),
+					usedTimes: 0
+				};
+
+				info.memory.textures ++;
+
+				// when a new instance of WebGLTexture was created, a texture upload is required
+				// even if the image contents are identical
+
+				forceUpload = true;
+
+			}
+
+			webglTextures[ textureCacheKey ].usedTimes ++;
+
+			// every time the texture cache key changes, it's necessary to check if an instance of
+			// WebGLTexture can be deleted in order to avoid a memory leak.
+
+			const webglTexture = webglTextures[ textureProperties.__cacheKey ];
+
+			if ( webglTexture !== undefined ) {
+
+				webglTextures[ textureProperties.__cacheKey ].usedTimes --;
+
+				if ( webglTexture.usedTimes === 0 ) {
+
+					deleteTexture( texture );
+
+				}
+
+			}
+
+			// store references to cache key and WebGLTexture object
+
+			textureProperties.__cacheKey = textureCacheKey;
+			textureProperties.__webglTexture = webglTextures[ textureCacheKey ].texture;
+
+		}
+
+		return forceUpload;
+
+	}
+
+	function uploadTexture( textureProperties, texture, slot ) {
+
+		let textureType = _gl.TEXTURE_2D;
+
+		if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) textureType = _gl.TEXTURE_2D_ARRAY;
+		if ( texture.isData3DTexture ) textureType = _gl.TEXTURE_3D;
+
+		const forceUpload = initTexture( textureProperties, texture );
+		const source = texture.source;
+
+		state.bindTexture( textureType, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );
+
+		const sourceProperties = properties.get( source );
+
+		if ( source.version !== sourceProperties.__version || forceUpload === true ) {
+
+			state.activeTexture( _gl.TEXTURE0 + slot );
+
+			const workingPrimaries = ColorManagement.getPrimaries( ColorManagement.workingColorSpace );
+			const texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries( texture.colorSpace );
+			const unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;
+
+			_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );
+			_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );
+			_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );
+			_gl.pixelStorei( _gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion );
+
+			const needsPowerOfTwo = textureNeedsPowerOfTwo( texture ) && isPowerOfTwo$1( texture.image ) === false;
+			let image = resizeImage( texture.image, needsPowerOfTwo, false, capabilities.maxTextureSize );
+			image = verifyColorSpace( texture, image );
+
+			const supportsMips = isPowerOfTwo$1( image ) || isWebGL2,
+				glFormat = utils.convert( texture.format, texture.colorSpace );
+
+			let glType = utils.convert( texture.type ),
+				glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace, texture.isVideoTexture );
+
+			setTextureParameters( textureType, texture, supportsMips );
+
+			let mipmap;
+			const mipmaps = texture.mipmaps;
+
+			const useTexStorage = ( isWebGL2 && texture.isVideoTexture !== true && glInternalFormat !== RGB_ETC1_Format );
+			const allocateMemory = ( sourceProperties.__version === undefined ) || ( forceUpload === true );
+			const levels = getMipLevels( texture, image, supportsMips );
+
+			if ( texture.isDepthTexture ) {
+
+				// populate depth texture with dummy data
+
+				glInternalFormat = _gl.DEPTH_COMPONENT;
+
+				if ( isWebGL2 ) {
+
+					if ( texture.type === FloatType ) {
+
+						glInternalFormat = _gl.DEPTH_COMPONENT32F;
+
+					} else if ( texture.type === UnsignedIntType ) {
+
+						glInternalFormat = _gl.DEPTH_COMPONENT24;
+
+					} else if ( texture.type === UnsignedInt248Type ) {
+
+						glInternalFormat = _gl.DEPTH24_STENCIL8;
+
+					} else {
+
+						glInternalFormat = _gl.DEPTH_COMPONENT16; // WebGL2 requires sized internalformat for glTexImage2D
+
+					}
+
+				} else {
+
+					if ( texture.type === FloatType ) {
+
+						console.error( 'WebGLRenderer: Floating point depth texture requires WebGL2.' );
+
+					}
+
+				}
+
+				// validation checks for WebGL 1
+
+				if ( texture.format === DepthFormat && glInternalFormat === _gl.DEPTH_COMPONENT ) {
+
+					// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
+					// DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT
+					// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
+					if ( texture.type !== UnsignedShortType && texture.type !== UnsignedIntType ) {
+
+						console.warn( 'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.' );
+
+						texture.type = UnsignedIntType;
+						glType = utils.convert( texture.type );
+
+					}
+
+				}
+
+				if ( texture.format === DepthStencilFormat && glInternalFormat === _gl.DEPTH_COMPONENT ) {
+
+					// Depth stencil textures need the DEPTH_STENCIL internal format
+					// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
+					glInternalFormat = _gl.DEPTH_STENCIL;
+
+					// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
+					// DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.
+					// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
+					if ( texture.type !== UnsignedInt248Type ) {
+
+						console.warn( 'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.' );
+
+						texture.type = UnsignedInt248Type;
+						glType = utils.convert( texture.type );
+
+					}
+
+				}
+
+				//
+
+				if ( allocateMemory ) {
+
+					if ( useTexStorage ) {
+
+						state.texStorage2D( _gl.TEXTURE_2D, 1, glInternalFormat, image.width, image.height );
+
+					} else {
+
+						state.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null );
+
+					}
+
+				}
+
+			} else if ( texture.isDataTexture ) {
+
+				// use manually created mipmaps if available
+				// if there are no manual mipmaps
+				// set 0 level mipmap and then use GL to generate other mipmap levels
+
+				if ( mipmaps.length > 0 && supportsMips ) {
+
+					if ( useTexStorage && allocateMemory ) {
+
+						state.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height );
+
+					}
+
+					for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+						mipmap = mipmaps[ i ];
+
+						if ( useTexStorage ) {
+
+							state.texSubImage2D( _gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data );
+
+						} else {
+
+							state.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+
+						}
+
+					}
+
+					texture.generateMipmaps = false;
+
+				} else {
+
+					if ( useTexStorage ) {
+
+						if ( allocateMemory ) {
+
+							state.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height );
+
+						}
+
+						state.texSubImage2D( _gl.TEXTURE_2D, 0, 0, 0, image.width, image.height, glFormat, glType, image.data );
+
+					} else {
+
+						state.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data );
+
+					}
+
+				}
+
+			} else if ( texture.isCompressedTexture ) {
+
+				if ( texture.isCompressedArrayTexture ) {
+
+					if ( useTexStorage && allocateMemory ) {
+
+						state.texStorage3D( _gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height, image.depth );
+
+					}
+
+					for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+						mipmap = mipmaps[ i ];
+
+						if ( texture.format !== RGBAFormat ) {
+
+							if ( glFormat !== null ) {
+
+								if ( useTexStorage ) {
+
+									state.compressedTexSubImage3D( _gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, mipmap.data, 0, 0 );
+
+								} else {
+
+									state.compressedTexImage3D( _gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, mipmap.data, 0, 0 );
+
+								}
+
+							} else {
+
+								console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );
+
+							}
+
+						} else {
+
+							if ( useTexStorage ) {
+
+								state.texSubImage3D( _gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, glType, mipmap.data );
+
+							} else {
+
+								state.texImage3D( _gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, glFormat, glType, mipmap.data );
+
+							}
+
+						}
+
+					}
+
+				} else {
+
+					if ( useTexStorage && allocateMemory ) {
+
+						state.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height );
+
+					}
+
+					for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+						mipmap = mipmaps[ i ];
+
+						if ( texture.format !== RGBAFormat ) {
+
+							if ( glFormat !== null ) {
+
+								if ( useTexStorage ) {
+
+									state.compressedTexSubImage2D( _gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data );
+
+								} else {
+
+									state.compressedTexImage2D( _gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );
+
+								}
+
+							} else {
+
+								console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );
+
+							}
+
+						} else {
+
+							if ( useTexStorage ) {
+
+								state.texSubImage2D( _gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data );
+
+							} else {
+
+								state.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+
+							}
+
+						}
+
+					}
+
+				}
+
+			} else if ( texture.isDataArrayTexture ) {
+
+				if ( useTexStorage ) {
+
+					if ( allocateMemory ) {
+
+						state.texStorage3D( _gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, image.width, image.height, image.depth );
+
+					}
+
+					state.texSubImage3D( _gl.TEXTURE_2D_ARRAY, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data );
+
+				} else {
+
+					state.texImage3D( _gl.TEXTURE_2D_ARRAY, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data );
+
+				}
+
+			} else if ( texture.isData3DTexture ) {
+
+				if ( useTexStorage ) {
+
+					if ( allocateMemory ) {
+
+						state.texStorage3D( _gl.TEXTURE_3D, levels, glInternalFormat, image.width, image.height, image.depth );
+
+					}
+
+					state.texSubImage3D( _gl.TEXTURE_3D, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data );
+
+				} else {
+
+					state.texImage3D( _gl.TEXTURE_3D, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data );
+
+				}
+
+			} else if ( texture.isFramebufferTexture ) {
+
+				if ( allocateMemory ) {
+
+					if ( useTexStorage ) {
+
+						state.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height );
+
+					} else {
+
+						let width = image.width, height = image.height;
+
+						for ( let i = 0; i < levels; i ++ ) {
+
+							state.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, width, height, 0, glFormat, glType, null );
+
+							width >>= 1;
+							height >>= 1;
+
+						}
+
+					}
+
+				}
+
+			} else {
+
+				// regular Texture (image, video, canvas)
+
+				// use manually created mipmaps if available
+				// if there are no manual mipmaps
+				// set 0 level mipmap and then use GL to generate other mipmap levels
+
+				if ( mipmaps.length > 0 && supportsMips ) {
+
+					if ( useTexStorage && allocateMemory ) {
+
+						state.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height );
+
+					}
+
+					for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+						mipmap = mipmaps[ i ];
+
+						if ( useTexStorage ) {
+
+							state.texSubImage2D( _gl.TEXTURE_2D, i, 0, 0, glFormat, glType, mipmap );
+
+						} else {
+
+							state.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, glFormat, glType, mipmap );
+
+						}
+
+					}
+
+					texture.generateMipmaps = false;
+
+				} else {
+
+					if ( useTexStorage ) {
+
+						if ( allocateMemory ) {
+
+							state.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height );
+
+						}
+
+						state.texSubImage2D( _gl.TEXTURE_2D, 0, 0, 0, glFormat, glType, image );
+
+					} else {
+
+						state.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, glFormat, glType, image );
+
+					}
+
+				}
+
+			}
+
+			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
+
+				generateMipmap( textureType );
+
+			}
+
+			sourceProperties.__version = source.version;
+
+			if ( texture.onUpdate ) texture.onUpdate( texture );
+
+		}
+
+		textureProperties.__version = texture.version;
+
+	}
+
+	function uploadCubeTexture( textureProperties, texture, slot ) {
+
+		if ( texture.image.length !== 6 ) return;
+
+		const forceUpload = initTexture( textureProperties, texture );
+		const source = texture.source;
+
+		state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );
+
+		const sourceProperties = properties.get( source );
+
+		if ( source.version !== sourceProperties.__version || forceUpload === true ) {
+
+			state.activeTexture( _gl.TEXTURE0 + slot );
+
+			const workingPrimaries = ColorManagement.getPrimaries( ColorManagement.workingColorSpace );
+			const texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries( texture.colorSpace );
+			const unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;
+
+			_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );
+			_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );
+			_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );
+			_gl.pixelStorei( _gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion );
+
+			const isCompressed = ( texture.isCompressedTexture || texture.image[ 0 ].isCompressedTexture );
+			const isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture );
+
+			const cubeImage = [];
+
+			for ( let i = 0; i < 6; i ++ ) {
+
+				if ( ! isCompressed && ! isDataTexture ) {
+
+					cubeImage[ i ] = resizeImage( texture.image[ i ], false, true, capabilities.maxCubemapSize );
+
+				} else {
+
+					cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];
+
+				}
+
+				cubeImage[ i ] = verifyColorSpace( texture, cubeImage[ i ] );
+
+			}
+
+			const image = cubeImage[ 0 ],
+				supportsMips = isPowerOfTwo$1( image ) || isWebGL2,
+				glFormat = utils.convert( texture.format, texture.colorSpace ),
+				glType = utils.convert( texture.type ),
+				glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace );
+
+			const useTexStorage = ( isWebGL2 && texture.isVideoTexture !== true );
+			const allocateMemory = ( sourceProperties.__version === undefined ) || ( forceUpload === true );
+			let levels = getMipLevels( texture, image, supportsMips );
+
+			setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, supportsMips );
+
+			let mipmaps;
+
+			if ( isCompressed ) {
+
+				if ( useTexStorage && allocateMemory ) {
+
+					state.texStorage2D( _gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, image.width, image.height );
+
+				}
+
+				for ( let i = 0; i < 6; i ++ ) {
+
+					mipmaps = cubeImage[ i ].mipmaps;
+
+					for ( let j = 0; j < mipmaps.length; j ++ ) {
+
+						const mipmap = mipmaps[ j ];
+
+						if ( texture.format !== RGBAFormat ) {
+
+							if ( glFormat !== null ) {
+
+								if ( useTexStorage ) {
+
+									state.compressedTexSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data );
+
+								} else {
+
+									state.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );
+
+								}
+
+							} else {
+
+								console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()' );
+
+							}
+
+						} else {
+
+							if ( useTexStorage ) {
+
+								state.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data );
+
+							} else {
+
+								state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+
+							}
+
+						}
+
+					}
+
+				}
+
+			} else {
+
+				mipmaps = texture.mipmaps;
+
+				if ( useTexStorage && allocateMemory ) {
+
+					// TODO: Uniformly handle mipmap definitions
+					// Normal textures and compressed cube textures define base level + mips with their mipmap array
+					// Uncompressed cube textures use their mipmap array only for mips (no base level)
+
+					if ( mipmaps.length > 0 ) levels ++;
+
+					state.texStorage2D( _gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, cubeImage[ 0 ].width, cubeImage[ 0 ].height );
+
+				}
+
+				for ( let i = 0; i < 6; i ++ ) {
+
+					if ( isDataTexture ) {
+
+						if ( useTexStorage ) {
+
+							state.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, cubeImage[ i ].width, cubeImage[ i ].height, glFormat, glType, cubeImage[ i ].data );
+
+						} else {
+
+							state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );
+
+						}
+
+						for ( let j = 0; j < mipmaps.length; j ++ ) {
+
+							const mipmap = mipmaps[ j ];
+							const mipmapImage = mipmap.image[ i ].image;
+
+							if ( useTexStorage ) {
+
+								state.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, mipmapImage.width, mipmapImage.height, glFormat, glType, mipmapImage.data );
+
+							} else {
+
+								state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data );
+
+							}
+
+						}
+
+					} else {
+
+						if ( useTexStorage ) {
+
+							state.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, glFormat, glType, cubeImage[ i ] );
+
+						} else {
+
+							state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, glFormat, glType, cubeImage[ i ] );
+
+						}
+
+						for ( let j = 0; j < mipmaps.length; j ++ ) {
+
+							const mipmap = mipmaps[ j ];
+
+							if ( useTexStorage ) {
+
+								state.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, glFormat, glType, mipmap.image[ i ] );
+
+							} else {
+
+								state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[ i ] );
+
+							}
+
+						}
+
+					}
+
+				}
+
+			}
+
+			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
+
+				// We assume images for cube map have the same size.
+				generateMipmap( _gl.TEXTURE_CUBE_MAP );
+
+			}
+
+			sourceProperties.__version = source.version;
+
+			if ( texture.onUpdate ) texture.onUpdate( texture );
+
+		}
+
+		textureProperties.__version = texture.version;
+
+	}
+
+	// Render targets
+
+	// Setup storage for target texture and bind it to correct framebuffer
+	function setupFrameBufferTexture( framebuffer, renderTarget, texture, attachment, textureTarget, level ) {
+
+		const glFormat = utils.convert( texture.format, texture.colorSpace );
+		const glType = utils.convert( texture.type );
+		const glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace );
+		const renderTargetProperties = properties.get( renderTarget );
+
+		if ( ! renderTargetProperties.__hasExternalTextures ) {
+
+			const width = Math.max( 1, renderTarget.width >> level );
+			const height = Math.max( 1, renderTarget.height >> level );
+
+			if ( textureTarget === _gl.TEXTURE_3D || textureTarget === _gl.TEXTURE_2D_ARRAY ) {
+
+				state.texImage3D( textureTarget, level, glInternalFormat, width, height, renderTarget.depth, 0, glFormat, glType, null );
+
+			} else {
+
+				state.texImage2D( textureTarget, level, glInternalFormat, width, height, 0, glFormat, glType, null );
+
+			}
+
+		}
+
+		state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+		if ( useMultisampledRTT( renderTarget ) ) {
+
+			multisampledRTTExt.framebufferTexture2DMultisampleEXT( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( texture ).__webglTexture, 0, getRenderTargetSamples( renderTarget ) );
+
+		} else if ( textureTarget === _gl.TEXTURE_2D || ( textureTarget >= _gl.TEXTURE_CUBE_MAP_POSITIVE_X && textureTarget <= _gl.TEXTURE_CUBE_MAP_NEGATIVE_Z ) ) { // see #24753
+
+			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( texture ).__webglTexture, level );
+
+		}
+
+		state.bindFramebuffer( _gl.FRAMEBUFFER, null );
+
+	}
+
+
+	// Setup storage for internal depth/stencil buffers and bind to correct framebuffer
+	function setupRenderBufferStorage( renderbuffer, renderTarget, isMultisample ) {
+
+		_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );
+
+		if ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {
+
+			let glInternalFormat = ( isWebGL2 === true ) ? _gl.DEPTH_COMPONENT24 : _gl.DEPTH_COMPONENT16;
+
+			if ( isMultisample || useMultisampledRTT( renderTarget ) ) {
+
+				const depthTexture = renderTarget.depthTexture;
+
+				if ( depthTexture && depthTexture.isDepthTexture ) {
+
+					if ( depthTexture.type === FloatType ) {
+
+						glInternalFormat = _gl.DEPTH_COMPONENT32F;
+
+					} else if ( depthTexture.type === UnsignedIntType ) {
+
+						glInternalFormat = _gl.DEPTH_COMPONENT24;
+
+					}
+
+				}
+
+				const samples = getRenderTargetSamples( renderTarget );
+
+				if ( useMultisampledRTT( renderTarget ) ) {
+
+					multisampledRTTExt.renderbufferStorageMultisampleEXT( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );
+
+				} else {
+
+					_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );
+
+				}
+
+			} else {
+
+				_gl.renderbufferStorage( _gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height );
+
+			}
+
+			_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
+
+		} else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {
+
+			const samples = getRenderTargetSamples( renderTarget );
+
+			if ( isMultisample && useMultisampledRTT( renderTarget ) === false ) {
+
+				_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, _gl.DEPTH24_STENCIL8, renderTarget.width, renderTarget.height );
+
+			} else if ( useMultisampledRTT( renderTarget ) ) {
+
+				multisampledRTTExt.renderbufferStorageMultisampleEXT( _gl.RENDERBUFFER, samples, _gl.DEPTH24_STENCIL8, renderTarget.width, renderTarget.height );
+
+			} else {
+
+				_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height );
+
+			}
+
+
+			_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
+
+		} else {
+
+			const textures = renderTarget.isWebGLMultipleRenderTargets === true ? renderTarget.texture : [ renderTarget.texture ];
+
+			for ( let i = 0; i < textures.length; i ++ ) {
+
+				const texture = textures[ i ];
+
+				const glFormat = utils.convert( texture.format, texture.colorSpace );
+				const glType = utils.convert( texture.type );
+				const glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace );
+				const samples = getRenderTargetSamples( renderTarget );
+
+				if ( isMultisample && useMultisampledRTT( renderTarget ) === false ) {
+
+					_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );
+
+				} else if ( useMultisampledRTT( renderTarget ) ) {
+
+					multisampledRTTExt.renderbufferStorageMultisampleEXT( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );
+
+				} else {
+
+					_gl.renderbufferStorage( _gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height );
+
+				}
+
+			}
+
+		}
+
+		_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );
+
+	}
+
+	// Setup resources for a Depth Texture for a FBO (needs an extension)
+	function setupDepthTexture( framebuffer, renderTarget ) {
+
+		const isCube = ( renderTarget && renderTarget.isWebGLCubeRenderTarget );
+		if ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' );
+
+		state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+		if ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) {
+
+			throw new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' );
+
+		}
+
+		// upload an empty depth texture with framebuffer size
+		if ( ! properties.get( renderTarget.depthTexture ).__webglTexture ||
+				renderTarget.depthTexture.image.width !== renderTarget.width ||
+				renderTarget.depthTexture.image.height !== renderTarget.height ) {
+
+			renderTarget.depthTexture.image.width = renderTarget.width;
+			renderTarget.depthTexture.image.height = renderTarget.height;
+			renderTarget.depthTexture.needsUpdate = true;
+
+		}
+
+		setTexture2D( renderTarget.depthTexture, 0 );
+
+		const webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;
+		const samples = getRenderTargetSamples( renderTarget );
+
+		if ( renderTarget.depthTexture.format === DepthFormat ) {
+
+			if ( useMultisampledRTT( renderTarget ) ) {
+
+				multisampledRTTExt.framebufferTexture2DMultisampleEXT( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples );
+
+			} else {
+
+				_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );
+
+			}
+
+		} else if ( renderTarget.depthTexture.format === DepthStencilFormat ) {
+
+			if ( useMultisampledRTT( renderTarget ) ) {
+
+				multisampledRTTExt.framebufferTexture2DMultisampleEXT( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples );
+
+			} else {
+
+				_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );
+
+			}
+
+		} else {
+
+			throw new Error( 'Unknown depthTexture format' );
+
+		}
+
+	}
+
+	// Setup GL resources for a non-texture depth buffer
+	function setupDepthRenderbuffer( renderTarget ) {
+
+		const renderTargetProperties = properties.get( renderTarget );
+		const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );
+
+		if ( renderTarget.depthTexture && ! renderTargetProperties.__autoAllocateDepthBuffer ) {
+
+			if ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );
+
+			setupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );
+
+		} else {
+
+			if ( isCube ) {
+
+				renderTargetProperties.__webglDepthbuffer = [];
+
+				for ( let i = 0; i < 6; i ++ ) {
+
+					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );
+					renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
+					setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget, false );
+
+				}
+
+			} else {
+
+				state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
+				renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
+				setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );
+
+			}
+
+		}
+
+		state.bindFramebuffer( _gl.FRAMEBUFFER, null );
+
+	}
+
+	// rebind framebuffer with external textures
+	function rebindTextures( renderTarget, colorTexture, depthTexture ) {
+
+		const renderTargetProperties = properties.get( renderTarget );
+
+		if ( colorTexture !== undefined ) {
+
+			setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, renderTarget.texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, 0 );
+
+		}
+
+		if ( depthTexture !== undefined ) {
+
+			setupDepthRenderbuffer( renderTarget );
+
+		}
+
+	}
+
+	// Set up GL resources for the render target
+	function setupRenderTarget( renderTarget ) {
+
+		const texture = renderTarget.texture;
+
+		const renderTargetProperties = properties.get( renderTarget );
+		const textureProperties = properties.get( texture );
+
+		renderTarget.addEventListener( 'dispose', onRenderTargetDispose );
+
+		if ( renderTarget.isWebGLMultipleRenderTargets !== true ) {
+
+			if ( textureProperties.__webglTexture === undefined ) {
+
+				textureProperties.__webglTexture = _gl.createTexture();
+
+			}
+
+			textureProperties.__version = texture.version;
+			info.memory.textures ++;
+
+		}
+
+		const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );
+		const isMultipleRenderTargets = ( renderTarget.isWebGLMultipleRenderTargets === true );
+		const supportsMips = isPowerOfTwo$1( renderTarget ) || isWebGL2;
+
+		// Setup framebuffer
+
+		if ( isCube ) {
+
+			renderTargetProperties.__webglFramebuffer = [];
+
+			for ( let i = 0; i < 6; i ++ ) {
+
+				if ( isWebGL2 && texture.mipmaps && texture.mipmaps.length > 0 ) {
+
+					renderTargetProperties.__webglFramebuffer[ i ] = [];
+
+					for ( let level = 0; level < texture.mipmaps.length; level ++ ) {
+
+						renderTargetProperties.__webglFramebuffer[ i ][ level ] = _gl.createFramebuffer();
+
+					}
+
+				} else {
+
+					renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();
+
+				}
+
+			}
+
+		} else {
+
+			if ( isWebGL2 && texture.mipmaps && texture.mipmaps.length > 0 ) {
+
+				renderTargetProperties.__webglFramebuffer = [];
+
+				for ( let level = 0; level < texture.mipmaps.length; level ++ ) {
+
+					renderTargetProperties.__webglFramebuffer[ level ] = _gl.createFramebuffer();
+
+				}
+
+			} else {
+
+				renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();
+
+			}
+
+			if ( isMultipleRenderTargets ) {
+
+				if ( capabilities.drawBuffers ) {
+
+					const textures = renderTarget.texture;
+
+					for ( let i = 0, il = textures.length; i < il; i ++ ) {
+
+						const attachmentProperties = properties.get( textures[ i ] );
+
+						if ( attachmentProperties.__webglTexture === undefined ) {
+
+							attachmentProperties.__webglTexture = _gl.createTexture();
+
+							info.memory.textures ++;
+
+						}
+
+					}
+
+				} else {
+
+					console.warn( 'THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.' );
+
+				}
+
+			}
+
+			if ( ( isWebGL2 && renderTarget.samples > 0 ) && useMultisampledRTT( renderTarget ) === false ) {
+
+				const textures = isMultipleRenderTargets ? texture : [ texture ];
+
+				renderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer();
+				renderTargetProperties.__webglColorRenderbuffer = [];
+
+				state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );
+
+				for ( let i = 0; i < textures.length; i ++ ) {
+
+					const texture = textures[ i ];
+					renderTargetProperties.__webglColorRenderbuffer[ i ] = _gl.createRenderbuffer();
+
+					_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );
+
+					const glFormat = utils.convert( texture.format, texture.colorSpace );
+					const glType = utils.convert( texture.type );
+					const glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace, renderTarget.isXRRenderTarget === true );
+					const samples = getRenderTargetSamples( renderTarget );
+					_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );
+
+					_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );
+
+				}
+
+				_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );
+
+				if ( renderTarget.depthBuffer ) {
+
+					renderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer();
+					setupRenderBufferStorage( renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true );
+
+				}
+
+				state.bindFramebuffer( _gl.FRAMEBUFFER, null );
+
+			}
+
+		}
+
+		// Setup color buffer
+
+		if ( isCube ) {
+
+			state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );
+			setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, supportsMips );
+
+			for ( let i = 0; i < 6; i ++ ) {
+
+				if ( isWebGL2 && texture.mipmaps && texture.mipmaps.length > 0 ) {
+
+					for ( let level = 0; level < texture.mipmaps.length; level ++ ) {
+
+						setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ][ level ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, level );
+
+					}
+
+				} else {
+
+					setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0 );
+
+				}
+
+			}
+
+			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
+
+				generateMipmap( _gl.TEXTURE_CUBE_MAP );
+
+			}
+
+			state.unbindTexture();
+
+		} else if ( isMultipleRenderTargets ) {
+
+			const textures = renderTarget.texture;
+
+			for ( let i = 0, il = textures.length; i < il; i ++ ) {
+
+				const attachment = textures[ i ];
+				const attachmentProperties = properties.get( attachment );
+
+				state.bindTexture( _gl.TEXTURE_2D, attachmentProperties.__webglTexture );
+				setTextureParameters( _gl.TEXTURE_2D, attachment, supportsMips );
+				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, attachment, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, 0 );
+
+				if ( textureNeedsGenerateMipmaps( attachment, supportsMips ) ) {
+
+					generateMipmap( _gl.TEXTURE_2D );
+
+				}
+
+			}
+
+			state.unbindTexture();
+
+		} else {
+
+			let glTextureType = _gl.TEXTURE_2D;
+
+			if ( renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget ) {
+
+				if ( isWebGL2 ) {
+
+					glTextureType = renderTarget.isWebGL3DRenderTarget ? _gl.TEXTURE_3D : _gl.TEXTURE_2D_ARRAY;
+
+				} else {
+
+					console.error( 'THREE.WebGLTextures: THREE.Data3DTexture and THREE.DataArrayTexture only supported with WebGL2.' );
+
+				}
+
+			}
+
+			state.bindTexture( glTextureType, textureProperties.__webglTexture );
+			setTextureParameters( glTextureType, texture, supportsMips );
+
+			if ( isWebGL2 && texture.mipmaps && texture.mipmaps.length > 0 ) {
+
+				for ( let level = 0; level < texture.mipmaps.length; level ++ ) {
+
+					setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ level ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, level );
+
+				}
+
+			} else {
+
+				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, 0 );
+
+			}
+
+			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
+
+				generateMipmap( glTextureType );
+
+			}
+
+			state.unbindTexture();
+
+		}
+
+		// Setup depth and stencil buffers
+
+		if ( renderTarget.depthBuffer ) {
+
+			setupDepthRenderbuffer( renderTarget );
+
+		}
+
+	}
+
+	function updateRenderTargetMipmap( renderTarget ) {
+
+		const supportsMips = isPowerOfTwo$1( renderTarget ) || isWebGL2;
+
+		const textures = renderTarget.isWebGLMultipleRenderTargets === true ? renderTarget.texture : [ renderTarget.texture ];
+
+		for ( let i = 0, il = textures.length; i < il; i ++ ) {
+
+			const texture = textures[ i ];
+
+			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
+
+				const target = renderTarget.isWebGLCubeRenderTarget ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;
+				const webglTexture = properties.get( texture ).__webglTexture;
+
+				state.bindTexture( target, webglTexture );
+				generateMipmap( target );
+				state.unbindTexture();
+
+			}
+
+		}
+
+	}
+
+	function updateMultisampleRenderTarget( renderTarget ) {
+
+		if ( ( isWebGL2 && renderTarget.samples > 0 ) && useMultisampledRTT( renderTarget ) === false ) {
+
+			const textures = renderTarget.isWebGLMultipleRenderTargets ? renderTarget.texture : [ renderTarget.texture ];
+			const width = renderTarget.width;
+			const height = renderTarget.height;
+			let mask = _gl.COLOR_BUFFER_BIT;
+			const invalidationArray = [];
+			const depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
+			const renderTargetProperties = properties.get( renderTarget );
+			const isMultipleRenderTargets = ( renderTarget.isWebGLMultipleRenderTargets === true );
+
+			// If MRT we need to remove FBO attachments
+			if ( isMultipleRenderTargets ) {
+
+				for ( let i = 0; i < textures.length; i ++ ) {
+
+					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );
+					_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, null );
+
+					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
+					_gl.framebufferTexture2D( _gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, null, 0 );
+
+				}
+
+			}
+
+			state.bindFramebuffer( _gl.READ_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );
+			state.bindFramebuffer( _gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
+
+			for ( let i = 0; i < textures.length; i ++ ) {
+
+				invalidationArray.push( _gl.COLOR_ATTACHMENT0 + i );
+
+				if ( renderTarget.depthBuffer ) {
+
+					invalidationArray.push( depthStyle );
+
+				}
+
+				const ignoreDepthValues = ( renderTargetProperties.__ignoreDepthValues !== undefined ) ? renderTargetProperties.__ignoreDepthValues : false;
+
+				if ( ignoreDepthValues === false ) {
+
+					if ( renderTarget.depthBuffer ) mask |= _gl.DEPTH_BUFFER_BIT;
+					if ( renderTarget.stencilBuffer ) mask |= _gl.STENCIL_BUFFER_BIT;
+
+				}
+
+				if ( isMultipleRenderTargets ) {
+
+					_gl.framebufferRenderbuffer( _gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );
+
+				}
+
+				if ( ignoreDepthValues === true ) {
+
+					_gl.invalidateFramebuffer( _gl.READ_FRAMEBUFFER, [ depthStyle ] );
+					_gl.invalidateFramebuffer( _gl.DRAW_FRAMEBUFFER, [ depthStyle ] );
+
+				}
+
+				if ( isMultipleRenderTargets ) {
+
+					const webglTexture = properties.get( textures[ i ] ).__webglTexture;
+					_gl.framebufferTexture2D( _gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, webglTexture, 0 );
+
+				}
+
+				_gl.blitFramebuffer( 0, 0, width, height, 0, 0, width, height, mask, _gl.NEAREST );
+
+				if ( supportsInvalidateFramebuffer ) {
+
+					_gl.invalidateFramebuffer( _gl.READ_FRAMEBUFFER, invalidationArray );
+
+				}
+
+
+			}
+
+			state.bindFramebuffer( _gl.READ_FRAMEBUFFER, null );
+			state.bindFramebuffer( _gl.DRAW_FRAMEBUFFER, null );
+
+			// If MRT since pre-blit we removed the FBO we need to reconstruct the attachments
+			if ( isMultipleRenderTargets ) {
+
+				for ( let i = 0; i < textures.length; i ++ ) {
+
+					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );
+					_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );
+
+					const webglTexture = properties.get( textures[ i ] ).__webglTexture;
+
+					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
+					_gl.framebufferTexture2D( _gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, webglTexture, 0 );
+
+				}
+
+			}
+
+			state.bindFramebuffer( _gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );
+
+		}
+
+	}
+
+	function getRenderTargetSamples( renderTarget ) {
+
+		return Math.min( capabilities.maxSamples, renderTarget.samples );
+
+	}
+
+	function useMultisampledRTT( renderTarget ) {
+
+		const renderTargetProperties = properties.get( renderTarget );
+
+		return isWebGL2 && renderTarget.samples > 0 && extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true && renderTargetProperties.__useRenderToTexture !== false;
+
+	}
+
+	function updateVideoTexture( texture ) {
+
+		const frame = info.render.frame;
+
+		// Check the last frame we updated the VideoTexture
+
+		if ( _videoTextures.get( texture ) !== frame ) {
+
+			_videoTextures.set( texture, frame );
+			texture.update();
+
+		}
+
+	}
+
+	function verifyColorSpace( texture, image ) {
+
+		const colorSpace = texture.colorSpace;
+		const format = texture.format;
+		const type = texture.type;
+
+		if ( texture.isCompressedTexture === true || texture.isVideoTexture === true || texture.format === _SRGBAFormat ) return image;
+
+		if ( colorSpace !== LinearSRGBColorSpace && colorSpace !== NoColorSpace ) {
+
+			// sRGB
+
+			if ( ColorManagement.getTransfer( colorSpace ) === SRGBTransfer ) {
+
+				if ( isWebGL2 === false ) {
+
+					// in WebGL 1, try to use EXT_sRGB extension and unsized formats
+
+					if ( extensions.has( 'EXT_sRGB' ) === true && format === RGBAFormat ) {
+
+						texture.format = _SRGBAFormat;
+
+						// it's not possible to generate mips in WebGL 1 with this extension
+
+						texture.minFilter = LinearFilter;
+						texture.generateMipmaps = false;
+
+					} else {
+
+						// slow fallback (CPU decode)
+
+						image = ImageUtils.sRGBToLinear( image );
+
+					}
+
+				} else {
+
+					// in WebGL 2 uncompressed textures can only be sRGB encoded if they have the RGBA8 format
+
+					if ( format !== RGBAFormat || type !== UnsignedByteType ) {
+
+						console.warn( 'THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType.' );
+
+					}
+
+				}
+
+			} else {
+
+				console.error( 'THREE.WebGLTextures: Unsupported texture color space:', colorSpace );
+
+			}
+
+		}
+
+		return image;
+
+	}
+
+	//
+
+	this.allocateTextureUnit = allocateTextureUnit;
+	this.resetTextureUnits = resetTextureUnits;
+
+	this.setTexture2D = setTexture2D;
+	this.setTexture2DArray = setTexture2DArray;
+	this.setTexture3D = setTexture3D;
+	this.setTextureCube = setTextureCube;
+	this.rebindTextures = rebindTextures;
+	this.setupRenderTarget = setupRenderTarget;
+	this.updateRenderTargetMipmap = updateRenderTargetMipmap;
+	this.updateMultisampleRenderTarget = updateMultisampleRenderTarget;
+	this.setupDepthRenderbuffer = setupDepthRenderbuffer;
+	this.setupFrameBufferTexture = setupFrameBufferTexture;
+	this.useMultisampledRTT = useMultisampledRTT;
+
+}
+
+function WebGLUtils( gl, extensions, capabilities ) {
+
+	const isWebGL2 = capabilities.isWebGL2;
+
+	function convert( p, colorSpace = NoColorSpace ) {
+
+		let extension;
+
+		const transfer = ColorManagement.getTransfer( colorSpace );
+
+		if ( p === UnsignedByteType ) return gl.UNSIGNED_BYTE;
+		if ( p === UnsignedShort4444Type ) return gl.UNSIGNED_SHORT_4_4_4_4;
+		if ( p === UnsignedShort5551Type ) return gl.UNSIGNED_SHORT_5_5_5_1;
+
+		if ( p === ByteType ) return gl.BYTE;
+		if ( p === ShortType ) return gl.SHORT;
+		if ( p === UnsignedShortType ) return gl.UNSIGNED_SHORT;
+		if ( p === IntType ) return gl.INT;
+		if ( p === UnsignedIntType ) return gl.UNSIGNED_INT;
+		if ( p === FloatType ) return gl.FLOAT;
+
+		if ( p === HalfFloatType ) {
+
+			if ( isWebGL2 ) return gl.HALF_FLOAT;
+
+			extension = extensions.get( 'OES_texture_half_float' );
+
+			if ( extension !== null ) {
+
+				return extension.HALF_FLOAT_OES;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		if ( p === AlphaFormat ) return gl.ALPHA;
+		if ( p === RGBAFormat ) return gl.RGBA;
+		if ( p === LuminanceFormat ) return gl.LUMINANCE;
+		if ( p === LuminanceAlphaFormat ) return gl.LUMINANCE_ALPHA;
+		if ( p === DepthFormat ) return gl.DEPTH_COMPONENT;
+		if ( p === DepthStencilFormat ) return gl.DEPTH_STENCIL;
+
+		// WebGL 1 sRGB fallback
+
+		if ( p === _SRGBAFormat ) {
+
+			extension = extensions.get( 'EXT_sRGB' );
+
+			if ( extension !== null ) {
+
+				return extension.SRGB_ALPHA_EXT;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// WebGL2 formats.
+
+		if ( p === RedFormat ) return gl.RED;
+		if ( p === RedIntegerFormat ) return gl.RED_INTEGER;
+		if ( p === RGFormat ) return gl.RG;
+		if ( p === RGIntegerFormat ) return gl.RG_INTEGER;
+		if ( p === RGBAIntegerFormat ) return gl.RGBA_INTEGER;
+
+		// S3TC
+
+		if ( p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format ) {
+
+			if ( transfer === SRGBTransfer ) {
+
+				extension = extensions.get( 'WEBGL_compressed_texture_s3tc_srgb' );
+
+				if ( extension !== null ) {
+
+					if ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_SRGB_S3TC_DXT1_EXT;
+					if ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
+					if ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
+					if ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
+
+				} else {
+
+					return null;
+
+				}
+
+			} else {
+
+				extension = extensions.get( 'WEBGL_compressed_texture_s3tc' );
+
+				if ( extension !== null ) {
+
+					if ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
+					if ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
+					if ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
+					if ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
+
+				} else {
+
+					return null;
+
+				}
+
+			}
+
+		}
+
+		// PVRTC
+
+		if ( p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format ) {
+
+			extension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );
+
+			if ( extension !== null ) {
+
+				if ( p === RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+				if ( p === RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
+				if ( p === RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+				if ( p === RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// ETC1
+
+		if ( p === RGB_ETC1_Format ) {
+
+			extension = extensions.get( 'WEBGL_compressed_texture_etc1' );
+
+			if ( extension !== null ) {
+
+				return extension.COMPRESSED_RGB_ETC1_WEBGL;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// ETC2
+
+		if ( p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format ) {
+
+			extension = extensions.get( 'WEBGL_compressed_texture_etc' );
+
+			if ( extension !== null ) {
+
+				if ( p === RGB_ETC2_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ETC2 : extension.COMPRESSED_RGB8_ETC2;
+				if ( p === RGBA_ETC2_EAC_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : extension.COMPRESSED_RGBA8_ETC2_EAC;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// ASTC
+
+		if ( p === RGBA_ASTC_4x4_Format || p === RGBA_ASTC_5x4_Format || p === RGBA_ASTC_5x5_Format ||
+			p === RGBA_ASTC_6x5_Format || p === RGBA_ASTC_6x6_Format || p === RGBA_ASTC_8x5_Format ||
+			p === RGBA_ASTC_8x6_Format || p === RGBA_ASTC_8x8_Format || p === RGBA_ASTC_10x5_Format ||
+			p === RGBA_ASTC_10x6_Format || p === RGBA_ASTC_10x8_Format || p === RGBA_ASTC_10x10_Format ||
+			p === RGBA_ASTC_12x10_Format || p === RGBA_ASTC_12x12_Format ) {
+
+			extension = extensions.get( 'WEBGL_compressed_texture_astc' );
+
+			if ( extension !== null ) {
+
+				if ( p === RGBA_ASTC_4x4_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : extension.COMPRESSED_RGBA_ASTC_4x4_KHR;
+				if ( p === RGBA_ASTC_5x4_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : extension.COMPRESSED_RGBA_ASTC_5x4_KHR;
+				if ( p === RGBA_ASTC_5x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : extension.COMPRESSED_RGBA_ASTC_5x5_KHR;
+				if ( p === RGBA_ASTC_6x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : extension.COMPRESSED_RGBA_ASTC_6x5_KHR;
+				if ( p === RGBA_ASTC_6x6_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : extension.COMPRESSED_RGBA_ASTC_6x6_KHR;
+				if ( p === RGBA_ASTC_8x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : extension.COMPRESSED_RGBA_ASTC_8x5_KHR;
+				if ( p === RGBA_ASTC_8x6_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : extension.COMPRESSED_RGBA_ASTC_8x6_KHR;
+				if ( p === RGBA_ASTC_8x8_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : extension.COMPRESSED_RGBA_ASTC_8x8_KHR;
+				if ( p === RGBA_ASTC_10x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : extension.COMPRESSED_RGBA_ASTC_10x5_KHR;
+				if ( p === RGBA_ASTC_10x6_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : extension.COMPRESSED_RGBA_ASTC_10x6_KHR;
+				if ( p === RGBA_ASTC_10x8_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : extension.COMPRESSED_RGBA_ASTC_10x8_KHR;
+				if ( p === RGBA_ASTC_10x10_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : extension.COMPRESSED_RGBA_ASTC_10x10_KHR;
+				if ( p === RGBA_ASTC_12x10_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : extension.COMPRESSED_RGBA_ASTC_12x10_KHR;
+				if ( p === RGBA_ASTC_12x12_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : extension.COMPRESSED_RGBA_ASTC_12x12_KHR;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// BPTC
+
+		if ( p === RGBA_BPTC_Format || p === RGB_BPTC_SIGNED_Format || p === RGB_BPTC_UNSIGNED_Format ) {
+
+			extension = extensions.get( 'EXT_texture_compression_bptc' );
+
+			if ( extension !== null ) {
+
+				if ( p === RGBA_BPTC_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT : extension.COMPRESSED_RGBA_BPTC_UNORM_EXT;
+				if ( p === RGB_BPTC_SIGNED_Format ) return extension.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT;
+				if ( p === RGB_BPTC_UNSIGNED_Format ) return extension.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// RGTC
+
+		if ( p === RED_RGTC1_Format || p === SIGNED_RED_RGTC1_Format || p === RED_GREEN_RGTC2_Format || p === SIGNED_RED_GREEN_RGTC2_Format ) {
+
+			extension = extensions.get( 'EXT_texture_compression_rgtc' );
+
+			if ( extension !== null ) {
+
+				if ( p === RGBA_BPTC_Format ) return extension.COMPRESSED_RED_RGTC1_EXT;
+				if ( p === SIGNED_RED_RGTC1_Format ) return extension.COMPRESSED_SIGNED_RED_RGTC1_EXT;
+				if ( p === RED_GREEN_RGTC2_Format ) return extension.COMPRESSED_RED_GREEN_RGTC2_EXT;
+				if ( p === SIGNED_RED_GREEN_RGTC2_Format ) return extension.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		//
+
+		if ( p === UnsignedInt248Type ) {
+
+			if ( isWebGL2 ) return gl.UNSIGNED_INT_24_8;
+
+			extension = extensions.get( 'WEBGL_depth_texture' );
+
+			if ( extension !== null ) {
+
+				return extension.UNSIGNED_INT_24_8_WEBGL;
+
+			} else {
+
+				return null;
+
+			}
+
+		}
+
+		// if "p" can't be resolved, assume the user defines a WebGL constant as a string (fallback/workaround for packed RGB formats)
+
+		return ( gl[ p ] !== undefined ) ? gl[ p ] : null;
+
+	}
+
+	return { convert: convert };
+
+}
+
+class ArrayCamera extends PerspectiveCamera {
+
+	constructor( array = [] ) {
+
+		super();
+
+		this.isArrayCamera = true;
+
+		this.cameras = array;
+
+	}
+
+}
+
+class Group extends Object3D {
+
+	constructor() {
+
+		super();
+
+		this.isGroup = true;
+
+		this.type = 'Group';
+
+	}
+
+}
+
+const _moveEvent = { type: 'move' };
+
+class WebXRController {
+
+	constructor() {
+
+		this._targetRay = null;
+		this._grip = null;
+		this._hand = null;
+
+	}
+
+	getHandSpace() {
+
+		if ( this._hand === null ) {
+
+			this._hand = new Group();
+			this._hand.matrixAutoUpdate = false;
+			this._hand.visible = false;
+
+			this._hand.joints = {};
+			this._hand.inputState = { pinching: false };
+
+		}
+
+		return this._hand;
+
+	}
+
+	getTargetRaySpace() {
+
+		if ( this._targetRay === null ) {
+
+			this._targetRay = new Group();
+			this._targetRay.matrixAutoUpdate = false;
+			this._targetRay.visible = false;
+			this._targetRay.hasLinearVelocity = false;
+			this._targetRay.linearVelocity = new Vector3();
+			this._targetRay.hasAngularVelocity = false;
+			this._targetRay.angularVelocity = new Vector3();
+
+		}
+
+		return this._targetRay;
+
+	}
+
+	getGripSpace() {
+
+		if ( this._grip === null ) {
+
+			this._grip = new Group();
+			this._grip.matrixAutoUpdate = false;
+			this._grip.visible = false;
+			this._grip.hasLinearVelocity = false;
+			this._grip.linearVelocity = new Vector3();
+			this._grip.hasAngularVelocity = false;
+			this._grip.angularVelocity = new Vector3();
+
+		}
+
+		return this._grip;
+
+	}
+
+	dispatchEvent( event ) {
+
+		if ( this._targetRay !== null ) {
+
+			this._targetRay.dispatchEvent( event );
+
+		}
+
+		if ( this._grip !== null ) {
+
+			this._grip.dispatchEvent( event );
+
+		}
+
+		if ( this._hand !== null ) {
+
+			this._hand.dispatchEvent( event );
+
+		}
+
+		return this;
+
+	}
+
+	connect( inputSource ) {
+
+		if ( inputSource && inputSource.hand ) {
+
+			const hand = this._hand;
+
+			if ( hand ) {
+
+				for ( const inputjoint of inputSource.hand.values() ) {
+
+					// Initialize hand with joints when connected
+					this._getHandJoint( hand, inputjoint );
+
+				}
+
+			}
+
+		}
+
+		this.dispatchEvent( { type: 'connected', data: inputSource } );
+
+		return this;
+
+	}
+
+	disconnect( inputSource ) {
+
+		this.dispatchEvent( { type: 'disconnected', data: inputSource } );
+
+		if ( this._targetRay !== null ) {
+
+			this._targetRay.visible = false;
+
+		}
+
+		if ( this._grip !== null ) {
+
+			this._grip.visible = false;
+
+		}
+
+		if ( this._hand !== null ) {
+
+			this._hand.visible = false;
+
+		}
+
+		return this;
+
+	}
+
+	update( inputSource, frame, referenceSpace ) {
+
+		let inputPose = null;
+		let gripPose = null;
+		let handPose = null;
+
+		const targetRay = this._targetRay;
+		const grip = this._grip;
+		const hand = this._hand;
+
+		if ( inputSource && frame.session.visibilityState !== 'visible-blurred' ) {
+
+			if ( hand && inputSource.hand ) {
+
+				handPose = true;
+
+				for ( const inputjoint of inputSource.hand.values() ) {
+
+					// Update the joints groups with the XRJoint poses
+					const jointPose = frame.getJointPose( inputjoint, referenceSpace );
+
+					// The transform of this joint will be updated with the joint pose on each frame
+					const joint = this._getHandJoint( hand, inputjoint );
+
+					if ( jointPose !== null ) {
+
+						joint.matrix.fromArray( jointPose.transform.matrix );
+						joint.matrix.decompose( joint.position, joint.rotation, joint.scale );
+						joint.matrixWorldNeedsUpdate = true;
+						joint.jointRadius = jointPose.radius;
+
+					}
+
+					joint.visible = jointPose !== null;
+
+				}
+
+				// Custom events
+
+				// Check pinchz
+				const indexTip = hand.joints[ 'index-finger-tip' ];
+				const thumbTip = hand.joints[ 'thumb-tip' ];
+				const distance = indexTip.position.distanceTo( thumbTip.position );
+
+				const distanceToPinch = 0.02;
+				const threshold = 0.005;
+
+				if ( hand.inputState.pinching && distance > distanceToPinch + threshold ) {
+
+					hand.inputState.pinching = false;
+					this.dispatchEvent( {
+						type: 'pinchend',
+						handedness: inputSource.handedness,
+						target: this
+					} );
+
+				} else if ( ! hand.inputState.pinching && distance <= distanceToPinch - threshold ) {
+
+					hand.inputState.pinching = true;
+					this.dispatchEvent( {
+						type: 'pinchstart',
+						handedness: inputSource.handedness,
+						target: this
+					} );
+
+				}
+
+			} else {
+
+				if ( grip !== null && inputSource.gripSpace ) {
+
+					gripPose = frame.getPose( inputSource.gripSpace, referenceSpace );
+
+					if ( gripPose !== null ) {
+
+						grip.matrix.fromArray( gripPose.transform.matrix );
+						grip.matrix.decompose( grip.position, grip.rotation, grip.scale );
+						grip.matrixWorldNeedsUpdate = true;
+
+						if ( gripPose.linearVelocity ) {
+
+							grip.hasLinearVelocity = true;
+							grip.linearVelocity.copy( gripPose.linearVelocity );
+
+						} else {
+
+							grip.hasLinearVelocity = false;
+
+						}
+
+						if ( gripPose.angularVelocity ) {
+
+							grip.hasAngularVelocity = true;
+							grip.angularVelocity.copy( gripPose.angularVelocity );
+
+						} else {
+
+							grip.hasAngularVelocity = false;
+
+						}
+
+					}
+
+				}
+
+			}
+
+			if ( targetRay !== null ) {
+
+				inputPose = frame.getPose( inputSource.targetRaySpace, referenceSpace );
+
+				// Some runtimes (namely Vive Cosmos with Vive OpenXR Runtime) have only grip space and ray space is equal to it
+				if ( inputPose === null && gripPose !== null ) {
+
+					inputPose = gripPose;
+
+				}
+
+				if ( inputPose !== null ) {
+
+					targetRay.matrix.fromArray( inputPose.transform.matrix );
+					targetRay.matrix.decompose( targetRay.position, targetRay.rotation, targetRay.scale );
+					targetRay.matrixWorldNeedsUpdate = true;
+
+					if ( inputPose.linearVelocity ) {
+
+						targetRay.hasLinearVelocity = true;
+						targetRay.linearVelocity.copy( inputPose.linearVelocity );
+
+					} else {
+
+						targetRay.hasLinearVelocity = false;
+
+					}
+
+					if ( inputPose.angularVelocity ) {
+
+						targetRay.hasAngularVelocity = true;
+						targetRay.angularVelocity.copy( inputPose.angularVelocity );
+
+					} else {
+
+						targetRay.hasAngularVelocity = false;
+
+					}
+
+					this.dispatchEvent( _moveEvent );
+
+				}
+
+			}
+
+
+		}
+
+		if ( targetRay !== null ) {
+
+			targetRay.visible = ( inputPose !== null );
+
+		}
+
+		if ( grip !== null ) {
+
+			grip.visible = ( gripPose !== null );
+
+		}
+
+		if ( hand !== null ) {
+
+			hand.visible = ( handPose !== null );
+
+		}
+
+		return this;
+
+	}
+
+	// private method
+
+	_getHandJoint( hand, inputjoint ) {
+
+		if ( hand.joints[ inputjoint.jointName ] === undefined ) {
+
+			const joint = new Group();
+			joint.matrixAutoUpdate = false;
+			joint.visible = false;
+			hand.joints[ inputjoint.jointName ] = joint;
+
+			hand.add( joint );
+
+		}
+
+		return hand.joints[ inputjoint.jointName ];
+
+	}
+
+}
+
+class WebXRManager extends EventDispatcher {
+
+	constructor( renderer, gl ) {
+
+		super();
+
+		const scope = this;
+
+		let session = null;
+
+		let framebufferScaleFactor = 1.0;
+
+		let referenceSpace = null;
+		let referenceSpaceType = 'local-floor';
+		// Set default foveation to maximum.
+		let foveation = 1.0;
+		let customReferenceSpace = null;
+
+		let pose = null;
+		let glBinding = null;
+		let glProjLayer = null;
+		let glBaseLayer = null;
+		let xrFrame = null;
+		const attributes = gl.getContextAttributes();
+		let initialRenderTarget = null;
+		let newRenderTarget = null;
+
+		const controllers = [];
+		const controllerInputSources = [];
+
+		const currentSize = new Vector2();
+		let currentPixelRatio = null;
+
+		//
+
+		const cameraL = new PerspectiveCamera();
+		cameraL.layers.enable( 1 );
+		cameraL.viewport = new Vector4();
+
+		const cameraR = new PerspectiveCamera();
+		cameraR.layers.enable( 2 );
+		cameraR.viewport = new Vector4();
+
+		const cameras = [ cameraL, cameraR ];
+
+		const cameraXR = new ArrayCamera();
+		cameraXR.layers.enable( 1 );
+		cameraXR.layers.enable( 2 );
+
+		let _currentDepthNear = null;
+		let _currentDepthFar = null;
+
+		//
+
+		this.cameraAutoUpdate = true;
+		this.enabled = false;
+
+		this.isPresenting = false;
+
+		this.getController = function ( index ) {
+
+			let controller = controllers[ index ];
+
+			if ( controller === undefined ) {
+
+				controller = new WebXRController();
+				controllers[ index ] = controller;
+
+			}
+
+			return controller.getTargetRaySpace();
+
+		};
+
+		this.getControllerGrip = function ( index ) {
+
+			let controller = controllers[ index ];
+
+			if ( controller === undefined ) {
+
+				controller = new WebXRController();
+				controllers[ index ] = controller;
+
+			}
+
+			return controller.getGripSpace();
+
+		};
+
+		this.getHand = function ( index ) {
+
+			let controller = controllers[ index ];
+
+			if ( controller === undefined ) {
+
+				controller = new WebXRController();
+				controllers[ index ] = controller;
+
+			}
+
+			return controller.getHandSpace();
+
+		};
+
+		//
+
+		function onSessionEvent( event ) {
+
+			const controllerIndex = controllerInputSources.indexOf( event.inputSource );
+
+			if ( controllerIndex === - 1 ) {
+
+				return;
+
+			}
+
+			const controller = controllers[ controllerIndex ];
+
+			if ( controller !== undefined ) {
+
+				controller.update( event.inputSource, event.frame, customReferenceSpace || referenceSpace );
+				controller.dispatchEvent( { type: event.type, data: event.inputSource } );
+
+			}
+
+		}
+
+		function onSessionEnd() {
+
+			session.removeEventListener( 'select', onSessionEvent );
+			session.removeEventListener( 'selectstart', onSessionEvent );
+			session.removeEventListener( 'selectend', onSessionEvent );
+			session.removeEventListener( 'squeeze', onSessionEvent );
+			session.removeEventListener( 'squeezestart', onSessionEvent );
+			session.removeEventListener( 'squeezeend', onSessionEvent );
+			session.removeEventListener( 'end', onSessionEnd );
+			session.removeEventListener( 'inputsourceschange', onInputSourcesChange );
+
+			for ( let i = 0; i < controllers.length; i ++ ) {
+
+				const inputSource = controllerInputSources[ i ];
+
+				if ( inputSource === null ) continue;
+
+				controllerInputSources[ i ] = null;
+
+				controllers[ i ].disconnect( inputSource );
+
+			}
+
+			_currentDepthNear = null;
+			_currentDepthFar = null;
+
+			// restore framebuffer/rendering state
+
+			renderer.setRenderTarget( initialRenderTarget );
+
+			glBaseLayer = null;
+			glProjLayer = null;
+			glBinding = null;
+			session = null;
+			newRenderTarget = null;
+
+			//
+
+			animation.stop();
+
+			scope.isPresenting = false;
+
+			renderer.setPixelRatio( currentPixelRatio );
+			renderer.setSize( currentSize.width, currentSize.height, false );
+
+			scope.dispatchEvent( { type: 'sessionend' } );
+
+		}
+
+		this.setFramebufferScaleFactor = function ( value ) {
+
+			framebufferScaleFactor = value;
+
+			if ( scope.isPresenting === true ) {
+
+				console.warn( 'THREE.WebXRManager: Cannot change framebuffer scale while presenting.' );
+
+			}
+
+		};
+
+		this.setReferenceSpaceType = function ( value ) {
+
+			referenceSpaceType = value;
+
+			if ( scope.isPresenting === true ) {
+
+				console.warn( 'THREE.WebXRManager: Cannot change reference space type while presenting.' );
+
+			}
+
+		};
+
+		this.getReferenceSpace = function () {
+
+			return customReferenceSpace || referenceSpace;
+
+		};
+
+		this.setReferenceSpace = function ( space ) {
+
+			customReferenceSpace = space;
+
+		};
+
+		this.getBaseLayer = function () {
+
+			return glProjLayer !== null ? glProjLayer : glBaseLayer;
+
+		};
+
+		this.getBinding = function () {
+
+			return glBinding;
+
+		};
+
+		this.getFrame = function () {
+
+			return xrFrame;
+
+		};
+
+		this.getSession = function () {
+
+			return session;
+
+		};
+
+		this.setSession = async function ( value ) {
+
+			session = value;
+
+			if ( session !== null ) {
+
+				initialRenderTarget = renderer.getRenderTarget();
+
+				session.addEventListener( 'select', onSessionEvent );
+				session.addEventListener( 'selectstart', onSessionEvent );
+				session.addEventListener( 'selectend', onSessionEvent );
+				session.addEventListener( 'squeeze', onSessionEvent );
+				session.addEventListener( 'squeezestart', onSessionEvent );
+				session.addEventListener( 'squeezeend', onSessionEvent );
+				session.addEventListener( 'end', onSessionEnd );
+				session.addEventListener( 'inputsourceschange', onInputSourcesChange );
+
+				if ( attributes.xrCompatible !== true ) {
+
+					await gl.makeXRCompatible();
+
+				}
+
+				currentPixelRatio = renderer.getPixelRatio();
+				renderer.getSize( currentSize );
+
+				if ( ( session.renderState.layers === undefined ) || ( renderer.capabilities.isWebGL2 === false ) ) {
+
+					const layerInit = {
+						antialias: ( session.renderState.layers === undefined ) ? attributes.antialias : true,
+						alpha: true,
+						depth: attributes.depth,
+						stencil: attributes.stencil,
+						framebufferScaleFactor: framebufferScaleFactor
+					};
+
+					glBaseLayer = new XRWebGLLayer( session, gl, layerInit );
+
+					session.updateRenderState( { baseLayer: glBaseLayer } );
+
+					renderer.setPixelRatio( 1 );
+					renderer.setSize( glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, false );
+
+					newRenderTarget = new WebGLRenderTarget(
+						glBaseLayer.framebufferWidth,
+						glBaseLayer.framebufferHeight,
+						{
+							format: RGBAFormat,
+							type: UnsignedByteType,
+							colorSpace: renderer.outputColorSpace,
+							stencilBuffer: attributes.stencil
+						}
+					);
+
+				} else {
+
+					let depthFormat = null;
+					let depthType = null;
+					let glDepthFormat = null;
+
+					if ( attributes.depth ) {
+
+						glDepthFormat = attributes.stencil ? gl.DEPTH24_STENCIL8 : gl.DEPTH_COMPONENT24;
+						depthFormat = attributes.stencil ? DepthStencilFormat : DepthFormat;
+						depthType = attributes.stencil ? UnsignedInt248Type : UnsignedIntType;
+
+					}
+
+					const projectionlayerInit = {
+						colorFormat: gl.RGBA8,
+						depthFormat: glDepthFormat,
+						scaleFactor: framebufferScaleFactor
+					};
+
+					glBinding = new XRWebGLBinding( session, gl );
+
+					glProjLayer = glBinding.createProjectionLayer( projectionlayerInit );
+
+					session.updateRenderState( { layers: [ glProjLayer ] } );
+
+					renderer.setPixelRatio( 1 );
+					renderer.setSize( glProjLayer.textureWidth, glProjLayer.textureHeight, false );
+
+					newRenderTarget = new WebGLRenderTarget(
+						glProjLayer.textureWidth,
+						glProjLayer.textureHeight,
+						{
+							format: RGBAFormat,
+							type: UnsignedByteType,
+							depthTexture: new DepthTexture( glProjLayer.textureWidth, glProjLayer.textureHeight, depthType, undefined, undefined, undefined, undefined, undefined, undefined, depthFormat ),
+							stencilBuffer: attributes.stencil,
+							colorSpace: renderer.outputColorSpace,
+							samples: attributes.antialias ? 4 : 0
+						} );
+
+					const renderTargetProperties = renderer.properties.get( newRenderTarget );
+					renderTargetProperties.__ignoreDepthValues = glProjLayer.ignoreDepthValues;
+
+				}
+
+				newRenderTarget.isXRRenderTarget = true; // TODO Remove this when possible, see #23278
+
+				this.setFoveation( foveation );
+
+				customReferenceSpace = null;
+				referenceSpace = await session.requestReferenceSpace( referenceSpaceType );
+
+				animation.setContext( session );
+				animation.start();
+
+				scope.isPresenting = true;
+
+				scope.dispatchEvent( { type: 'sessionstart' } );
+
+			}
+
+		};
+
+		this.getEnvironmentBlendMode = function () {
+
+			if ( session !== null ) {
+
+				return session.environmentBlendMode;
+
+			}
+
+		};
+
+		function onInputSourcesChange( event ) {
+
+			// Notify disconnected
+
+			for ( let i = 0; i < event.removed.length; i ++ ) {
+
+				const inputSource = event.removed[ i ];
+				const index = controllerInputSources.indexOf( inputSource );
+
+				if ( index >= 0 ) {
+
+					controllerInputSources[ index ] = null;
+					controllers[ index ].disconnect( inputSource );
+
+				}
+
+			}
+
+			// Notify connected
+
+			for ( let i = 0; i < event.added.length; i ++ ) {
+
+				const inputSource = event.added[ i ];
+
+				let controllerIndex = controllerInputSources.indexOf( inputSource );
+
+				if ( controllerIndex === - 1 ) {
+
+					// Assign input source a controller that currently has no input source
+
+					for ( let i = 0; i < controllers.length; i ++ ) {
+
+						if ( i >= controllerInputSources.length ) {
+
+							controllerInputSources.push( inputSource );
+							controllerIndex = i;
+							break;
+
+						} else if ( controllerInputSources[ i ] === null ) {
+
+							controllerInputSources[ i ] = inputSource;
+							controllerIndex = i;
+							break;
+
+						}
+
+					}
+
+					// If all controllers do currently receive input we ignore new ones
+
+					if ( controllerIndex === - 1 ) break;
+
+				}
+
+				const controller = controllers[ controllerIndex ];
+
+				if ( controller ) {
+
+					controller.connect( inputSource );
+
+				}
+
+			}
+
+		}
+
+		//
+
+		const cameraLPos = new Vector3();
+		const cameraRPos = new Vector3();
+
+		/**
+		 * Assumes 2 cameras that are parallel and share an X-axis, and that
+		 * the cameras' projection and world matrices have already been set.
+		 * And that near and far planes are identical for both cameras.
+		 * Visualization of this technique: https://computergraphics.stackexchange.com/a/4765
+		 */
+		function setProjectionFromUnion( camera, cameraL, cameraR ) {
+
+			cameraLPos.setFromMatrixPosition( cameraL.matrixWorld );
+			cameraRPos.setFromMatrixPosition( cameraR.matrixWorld );
+
+			const ipd = cameraLPos.distanceTo( cameraRPos );
+
+			const projL = cameraL.projectionMatrix.elements;
+			const projR = cameraR.projectionMatrix.elements;
+
+			// VR systems will have identical far and near planes, and
+			// most likely identical top and bottom frustum extents.
+			// Use the left camera for these values.
+			const near = projL[ 14 ] / ( projL[ 10 ] - 1 );
+			const far = projL[ 14 ] / ( projL[ 10 ] + 1 );
+			const topFov = ( projL[ 9 ] + 1 ) / projL[ 5 ];
+			const bottomFov = ( projL[ 9 ] - 1 ) / projL[ 5 ];
+
+			const leftFov = ( projL[ 8 ] - 1 ) / projL[ 0 ];
+			const rightFov = ( projR[ 8 ] + 1 ) / projR[ 0 ];
+			const left = near * leftFov;
+			const right = near * rightFov;
+
+			// Calculate the new camera's position offset from the
+			// left camera. xOffset should be roughly half `ipd`.
+			const zOffset = ipd / ( - leftFov + rightFov );
+			const xOffset = zOffset * - leftFov;
+
+			// TODO: Better way to apply this offset?
+			cameraL.matrixWorld.decompose( camera.position, camera.quaternion, camera.scale );
+			camera.translateX( xOffset );
+			camera.translateZ( zOffset );
+			camera.matrixWorld.compose( camera.position, camera.quaternion, camera.scale );
+			camera.matrixWorldInverse.copy( camera.matrixWorld ).invert();
+
+			// Find the union of the frustum values of the cameras and scale
+			// the values so that the near plane's position does not change in world space,
+			// although must now be relative to the new union camera.
+			const near2 = near + zOffset;
+			const far2 = far + zOffset;
+			const left2 = left - xOffset;
+			const right2 = right + ( ipd - xOffset );
+			const top2 = topFov * far / far2 * near2;
+			const bottom2 = bottomFov * far / far2 * near2;
+
+			camera.projectionMatrix.makePerspective( left2, right2, top2, bottom2, near2, far2 );
+			camera.projectionMatrixInverse.copy( camera.projectionMatrix ).invert();
+
+		}
+
+		function updateCamera( camera, parent ) {
+
+			if ( parent === null ) {
+
+				camera.matrixWorld.copy( camera.matrix );
+
+			} else {
+
+				camera.matrixWorld.multiplyMatrices( parent.matrixWorld, camera.matrix );
+
+			}
+
+			camera.matrixWorldInverse.copy( camera.matrixWorld ).invert();
+
+		}
+
+		this.updateCamera = function ( camera ) {
+
+			if ( session === null ) return;
+
+			cameraXR.near = cameraR.near = cameraL.near = camera.near;
+			cameraXR.far = cameraR.far = cameraL.far = camera.far;
+
+			if ( _currentDepthNear !== cameraXR.near || _currentDepthFar !== cameraXR.far ) {
+
+				// Note that the new renderState won't apply until the next frame. See #18320
+
+				session.updateRenderState( {
+					depthNear: cameraXR.near,
+					depthFar: cameraXR.far
+				} );
+
+				_currentDepthNear = cameraXR.near;
+				_currentDepthFar = cameraXR.far;
+
+			}
+
+			const parent = camera.parent;
+			const cameras = cameraXR.cameras;
+
+			updateCamera( cameraXR, parent );
+
+			for ( let i = 0; i < cameras.length; i ++ ) {
+
+				updateCamera( cameras[ i ], parent );
+
+			}
+
+			// update projection matrix for proper view frustum culling
+
+			if ( cameras.length === 2 ) {
+
+				setProjectionFromUnion( cameraXR, cameraL, cameraR );
+
+			} else {
+
+				// assume single camera setup (AR)
+
+				cameraXR.projectionMatrix.copy( cameraL.projectionMatrix );
+
+			}
+
+			// update user camera and its children
+
+			updateUserCamera( camera, cameraXR, parent );
+
+		};
+
+		function updateUserCamera( camera, cameraXR, parent ) {
+
+			if ( parent === null ) {
+
+				camera.matrix.copy( cameraXR.matrixWorld );
+
+			} else {
+
+				camera.matrix.copy( parent.matrixWorld );
+				camera.matrix.invert();
+				camera.matrix.multiply( cameraXR.matrixWorld );
+
+			}
+
+			camera.matrix.decompose( camera.position, camera.quaternion, camera.scale );
+			camera.updateMatrixWorld( true );
+
+			camera.projectionMatrix.copy( cameraXR.projectionMatrix );
+			camera.projectionMatrixInverse.copy( cameraXR.projectionMatrixInverse );
+
+			if ( camera.isPerspectiveCamera ) {
+
+				camera.fov = RAD2DEG * 2 * Math.atan( 1 / camera.projectionMatrix.elements[ 5 ] );
+				camera.zoom = 1;
+
+			}
+
+		}
+
+		this.getCamera = function () {
+
+			return cameraXR;
+
+		};
+
+		this.getFoveation = function () {
+
+			if ( glProjLayer === null && glBaseLayer === null ) {
+
+				return undefined;
+
+			}
+
+			return foveation;
+
+		};
+
+		this.setFoveation = function ( value ) {
+
+			// 0 = no foveation = full resolution
+			// 1 = maximum foveation = the edges render at lower resolution
+
+			foveation = value;
+
+			if ( glProjLayer !== null ) {
+
+				glProjLayer.fixedFoveation = value;
+
+			}
+
+			if ( glBaseLayer !== null && glBaseLayer.fixedFoveation !== undefined ) {
+
+				glBaseLayer.fixedFoveation = value;
+
+			}
+
+		};
+
+		// Animation Loop
+
+		let onAnimationFrameCallback = null;
+
+		function onAnimationFrame( time, frame ) {
+
+			pose = frame.getViewerPose( customReferenceSpace || referenceSpace );
+			xrFrame = frame;
+
+			if ( pose !== null ) {
+
+				const views = pose.views;
+
+				if ( glBaseLayer !== null ) {
+
+					renderer.setRenderTargetFramebuffer( newRenderTarget, glBaseLayer.framebuffer );
+					renderer.setRenderTarget( newRenderTarget );
+
+				}
+
+				let cameraXRNeedsUpdate = false;
+
+				// check if it's necessary to rebuild cameraXR's camera list
+
+				if ( views.length !== cameraXR.cameras.length ) {
+
+					cameraXR.cameras.length = 0;
+					cameraXRNeedsUpdate = true;
+
+				}
+
+				for ( let i = 0; i < views.length; i ++ ) {
+
+					const view = views[ i ];
+
+					let viewport = null;
+
+					if ( glBaseLayer !== null ) {
+
+						viewport = glBaseLayer.getViewport( view );
+
+					} else {
+
+						const glSubImage = glBinding.getViewSubImage( glProjLayer, view );
+						viewport = glSubImage.viewport;
+
+						// For side-by-side projection, we only produce a single texture for both eyes.
+						if ( i === 0 ) {
+
+							renderer.setRenderTargetTextures(
+								newRenderTarget,
+								glSubImage.colorTexture,
+								glProjLayer.ignoreDepthValues ? undefined : glSubImage.depthStencilTexture );
+
+							renderer.setRenderTarget( newRenderTarget );
+
+						}
+
+					}
+
+					let camera = cameras[ i ];
+
+					if ( camera === undefined ) {
+
+						camera = new PerspectiveCamera();
+						camera.layers.enable( i );
+						camera.viewport = new Vector4();
+						cameras[ i ] = camera;
+
+					}
+
+					camera.matrix.fromArray( view.transform.matrix );
+					camera.matrix.decompose( camera.position, camera.quaternion, camera.scale );
+					camera.projectionMatrix.fromArray( view.projectionMatrix );
+					camera.projectionMatrixInverse.copy( camera.projectionMatrix ).invert();
+					camera.viewport.set( viewport.x, viewport.y, viewport.width, viewport.height );
+
+					if ( i === 0 ) {
+
+						cameraXR.matrix.copy( camera.matrix );
+						cameraXR.matrix.decompose( cameraXR.position, cameraXR.quaternion, cameraXR.scale );
+
+					}
+
+					if ( cameraXRNeedsUpdate === true ) {
+
+						cameraXR.cameras.push( camera );
+
+					}
+
+				}
+
+			}
+
+			//
+
+			for ( let i = 0; i < controllers.length; i ++ ) {
+
+				const inputSource = controllerInputSources[ i ];
+				const controller = controllers[ i ];
+
+				if ( inputSource !== null && controller !== undefined ) {
+
+					controller.update( inputSource, frame, customReferenceSpace || referenceSpace );
+
+				}
+
+			}
+
+			if ( onAnimationFrameCallback ) onAnimationFrameCallback( time, frame );
+
+			if ( frame.detectedPlanes ) {
+
+				scope.dispatchEvent( { type: 'planesdetected', data: frame } );
+
+			}
+
+			xrFrame = null;
+
+		}
+
+		const animation = new WebGLAnimation();
+
+		animation.setAnimationLoop( onAnimationFrame );
+
+		this.setAnimationLoop = function ( callback ) {
+
+			onAnimationFrameCallback = callback;
+
+		};
+
+		this.dispose = function () {};
+
+	}
+
+}
+
+function WebGLMaterials( renderer, properties ) {
+
+	function refreshTransformUniform( map, uniform ) {
+
+		if ( map.matrixAutoUpdate === true ) {
+
+			map.updateMatrix();
+
+		}
+
+		uniform.value.copy( map.matrix );
+
+	}
+
+	function refreshFogUniforms( uniforms, fog ) {
+
+		fog.color.getRGB( uniforms.fogColor.value, getUnlitUniformColorSpace( renderer ) );
+
+		if ( fog.isFog ) {
+
+			uniforms.fogNear.value = fog.near;
+			uniforms.fogFar.value = fog.far;
+
+		} else if ( fog.isFogExp2 ) {
+
+			uniforms.fogDensity.value = fog.density;
+
+		}
+
+	}
+
+	function refreshMaterialUniforms( uniforms, material, pixelRatio, height, transmissionRenderTarget ) {
+
+		if ( material.isMeshBasicMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+
+		} else if ( material.isMeshLambertMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+
+		} else if ( material.isMeshToonMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+			refreshUniformsToon( uniforms, material );
+
+		} else if ( material.isMeshPhongMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+			refreshUniformsPhong( uniforms, material );
+
+		} else if ( material.isMeshStandardMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+			refreshUniformsStandard( uniforms, material );
+
+			if ( material.isMeshPhysicalMaterial ) {
+
+				refreshUniformsPhysical( uniforms, material, transmissionRenderTarget );
+
+			}
+
+		} else if ( material.isMeshMatcapMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+			refreshUniformsMatcap( uniforms, material );
+
+		} else if ( material.isMeshDepthMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+
+		} else if ( material.isMeshDistanceMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+			refreshUniformsDistance( uniforms, material );
+
+		} else if ( material.isMeshNormalMaterial ) {
+
+			refreshUniformsCommon( uniforms, material );
+
+		} else if ( material.isLineBasicMaterial ) {
+
+			refreshUniformsLine( uniforms, material );
+
+			if ( material.isLineDashedMaterial ) {
+
+				refreshUniformsDash( uniforms, material );
+
+			}
+
+		} else if ( material.isPointsMaterial ) {
+
+			refreshUniformsPoints( uniforms, material, pixelRatio, height );
+
+		} else if ( material.isSpriteMaterial ) {
+
+			refreshUniformsSprites( uniforms, material );
+
+		} else if ( material.isShadowMaterial ) {
+
+			uniforms.color.value.copy( material.color );
+			uniforms.opacity.value = material.opacity;
+
+		} else if ( material.isShaderMaterial ) {
+
+			material.uniformsNeedUpdate = false; // #15581
+
+		}
+
+	}
+
+	function refreshUniformsCommon( uniforms, material ) {
+
+		uniforms.opacity.value = material.opacity;
+
+		if ( material.color ) {
+
+			uniforms.diffuse.value.copy( material.color );
+
+		}
+
+		if ( material.emissive ) {
+
+			uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );
+
+		}
+
+		if ( material.map ) {
+
+			uniforms.map.value = material.map;
+
+			refreshTransformUniform( material.map, uniforms.mapTransform );
+
+		}
+
+		if ( material.alphaMap ) {
+
+			uniforms.alphaMap.value = material.alphaMap;
+
+			refreshTransformUniform( material.alphaMap, uniforms.alphaMapTransform );
+
+		}
+
+		if ( material.bumpMap ) {
+
+			uniforms.bumpMap.value = material.bumpMap;
+
+			refreshTransformUniform( material.bumpMap, uniforms.bumpMapTransform );
+
+			uniforms.bumpScale.value = material.bumpScale;
+
+			if ( material.side === BackSide ) {
+
+				uniforms.bumpScale.value *= - 1;
+
+			}
+
+		}
+
+		if ( material.normalMap ) {
+
+			uniforms.normalMap.value = material.normalMap;
+
+			refreshTransformUniform( material.normalMap, uniforms.normalMapTransform );
+
+			uniforms.normalScale.value.copy( material.normalScale );
+
+			if ( material.side === BackSide ) {
+
+				uniforms.normalScale.value.negate();
+
+			}
+
+		}
+
+		if ( material.displacementMap ) {
+
+			uniforms.displacementMap.value = material.displacementMap;
+
+			refreshTransformUniform( material.displacementMap, uniforms.displacementMapTransform );
+
+			uniforms.displacementScale.value = material.displacementScale;
+			uniforms.displacementBias.value = material.displacementBias;
+
+		}
+
+		if ( material.emissiveMap ) {
+
+			uniforms.emissiveMap.value = material.emissiveMap;
+
+			refreshTransformUniform( material.emissiveMap, uniforms.emissiveMapTransform );
+
+		}
+
+		if ( material.specularMap ) {
+
+			uniforms.specularMap.value = material.specularMap;
+
+			refreshTransformUniform( material.specularMap, uniforms.specularMapTransform );
+
+		}
+
+		if ( material.alphaTest > 0 ) {
+
+			uniforms.alphaTest.value = material.alphaTest;
+
+		}
+
+		const envMap = properties.get( material ).envMap;
+
+		if ( envMap ) {
+
+			uniforms.envMap.value = envMap;
+
+			uniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) ? - 1 : 1;
+
+			uniforms.reflectivity.value = material.reflectivity;
+			uniforms.ior.value = material.ior;
+			uniforms.refractionRatio.value = material.refractionRatio;
+
+		}
+
+		if ( material.lightMap ) {
+
+			uniforms.lightMap.value = material.lightMap;
+
+			// artist-friendly light intensity scaling factor
+			const scaleFactor = ( renderer._useLegacyLights === true ) ? Math.PI : 1;
+
+			uniforms.lightMapIntensity.value = material.lightMapIntensity * scaleFactor;
+
+			refreshTransformUniform( material.lightMap, uniforms.lightMapTransform );
+
+		}
+
+		if ( material.aoMap ) {
+
+			uniforms.aoMap.value = material.aoMap;
+			uniforms.aoMapIntensity.value = material.aoMapIntensity;
+
+			refreshTransformUniform( material.aoMap, uniforms.aoMapTransform );
+
+		}
+
+	}
+
+	function refreshUniformsLine( uniforms, material ) {
+
+		uniforms.diffuse.value.copy( material.color );
+		uniforms.opacity.value = material.opacity;
+
+		if ( material.map ) {
+
+			uniforms.map.value = material.map;
+
+			refreshTransformUniform( material.map, uniforms.mapTransform );
+
+		}
+
+	}
+
+	function refreshUniformsDash( uniforms, material ) {
+
+		uniforms.dashSize.value = material.dashSize;
+		uniforms.totalSize.value = material.dashSize + material.gapSize;
+		uniforms.scale.value = material.scale;
+
+	}
+
+	function refreshUniformsPoints( uniforms, material, pixelRatio, height ) {
+
+		uniforms.diffuse.value.copy( material.color );
+		uniforms.opacity.value = material.opacity;
+		uniforms.size.value = material.size * pixelRatio;
+		uniforms.scale.value = height * 0.5;
+
+		if ( material.map ) {
+
+			uniforms.map.value = material.map;
+
+			refreshTransformUniform( material.map, uniforms.uvTransform );
+
+		}
+
+		if ( material.alphaMap ) {
+
+			uniforms.alphaMap.value = material.alphaMap;
+
+			refreshTransformUniform( material.alphaMap, uniforms.alphaMapTransform );
+
+		}
+
+		if ( material.alphaTest > 0 ) {
+
+			uniforms.alphaTest.value = material.alphaTest;
+
+		}
+
+	}
+
+	function refreshUniformsSprites( uniforms, material ) {
+
+		uniforms.diffuse.value.copy( material.color );
+		uniforms.opacity.value = material.opacity;
+		uniforms.rotation.value = material.rotation;
+
+		if ( material.map ) {
+
+			uniforms.map.value = material.map;
+
+			refreshTransformUniform( material.map, uniforms.mapTransform );
+
+		}
+
+		if ( material.alphaMap ) {
+
+			uniforms.alphaMap.value = material.alphaMap;
+
+			refreshTransformUniform( material.alphaMap, uniforms.alphaMapTransform );
+
+		}
+
+		if ( material.alphaTest > 0 ) {
+
+			uniforms.alphaTest.value = material.alphaTest;
+
+		}
+
+	}
+
+	function refreshUniformsPhong( uniforms, material ) {
+
+		uniforms.specular.value.copy( material.specular );
+		uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )
+
+	}
+
+	function refreshUniformsToon( uniforms, material ) {
+
+		if ( material.gradientMap ) {
+
+			uniforms.gradientMap.value = material.gradientMap;
+
+		}
+
+	}
+
+	function refreshUniformsStandard( uniforms, material ) {
+
+		uniforms.metalness.value = material.metalness;
+
+		if ( material.metalnessMap ) {
+
+			uniforms.metalnessMap.value = material.metalnessMap;
+
+			refreshTransformUniform( material.metalnessMap, uniforms.metalnessMapTransform );
+
+		}
+
+		uniforms.roughness.value = material.roughness;
+
+		if ( material.roughnessMap ) {
+
+			uniforms.roughnessMap.value = material.roughnessMap;
+
+			refreshTransformUniform( material.roughnessMap, uniforms.roughnessMapTransform );
+
+		}
+
+		const envMap = properties.get( material ).envMap;
+
+		if ( envMap ) {
+
+			//uniforms.envMap.value = material.envMap; // part of uniforms common
+			uniforms.envMapIntensity.value = material.envMapIntensity;
+
+		}
+
+	}
+
+	function refreshUniformsPhysical( uniforms, material, transmissionRenderTarget ) {
+
+		uniforms.ior.value = material.ior; // also part of uniforms common
+
+		if ( material.sheen > 0 ) {
+
+			uniforms.sheenColor.value.copy( material.sheenColor ).multiplyScalar( material.sheen );
+
+			uniforms.sheenRoughness.value = material.sheenRoughness;
+
+			if ( material.sheenColorMap ) {
+
+				uniforms.sheenColorMap.value = material.sheenColorMap;
+
+				refreshTransformUniform( material.sheenColorMap, uniforms.sheenColorMapTransform );
+
+			}
+
+			if ( material.sheenRoughnessMap ) {
+
+				uniforms.sheenRoughnessMap.value = material.sheenRoughnessMap;
+
+				refreshTransformUniform( material.sheenRoughnessMap, uniforms.sheenRoughnessMapTransform );
+
+			}
+
+		}
+
+		if ( material.clearcoat > 0 ) {
+
+			uniforms.clearcoat.value = material.clearcoat;
+			uniforms.clearcoatRoughness.value = material.clearcoatRoughness;
+
+			if ( material.clearcoatMap ) {
+
+				uniforms.clearcoatMap.value = material.clearcoatMap;
+
+				refreshTransformUniform( material.clearcoatMap, uniforms.clearcoatMapTransform );
+
+			}
+
+			if ( material.clearcoatRoughnessMap ) {
+
+				uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap;
+
+				refreshTransformUniform( material.clearcoatRoughnessMap, uniforms.clearcoatRoughnessMapTransform );
+
+			}
+
+			if ( material.clearcoatNormalMap ) {
+
+				uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap;
+
+				refreshTransformUniform( material.clearcoatNormalMap, uniforms.clearcoatNormalMapTransform );
+
+				uniforms.clearcoatNormalScale.value.copy( material.clearcoatNormalScale );
+
+				if ( material.side === BackSide ) {
+
+					uniforms.clearcoatNormalScale.value.negate();
+
+				}
+
+			}
+
+		}
+
+		if ( material.iridescence > 0 ) {
+
+			uniforms.iridescence.value = material.iridescence;
+			uniforms.iridescenceIOR.value = material.iridescenceIOR;
+			uniforms.iridescenceThicknessMinimum.value = material.iridescenceThicknessRange[ 0 ];
+			uniforms.iridescenceThicknessMaximum.value = material.iridescenceThicknessRange[ 1 ];
+
+			if ( material.iridescenceMap ) {
+
+				uniforms.iridescenceMap.value = material.iridescenceMap;
+
+				refreshTransformUniform( material.iridescenceMap, uniforms.iridescenceMapTransform );
+
+			}
+
+			if ( material.iridescenceThicknessMap ) {
+
+				uniforms.iridescenceThicknessMap.value = material.iridescenceThicknessMap;
+
+				refreshTransformUniform( material.iridescenceThicknessMap, uniforms.iridescenceThicknessMapTransform );
+
+			}
+
+		}
+
+		if ( material.transmission > 0 ) {
+
+			uniforms.transmission.value = material.transmission;
+			uniforms.transmissionSamplerMap.value = transmissionRenderTarget.texture;
+			uniforms.transmissionSamplerSize.value.set( transmissionRenderTarget.width, transmissionRenderTarget.height );
+
+			if ( material.transmissionMap ) {
+
+				uniforms.transmissionMap.value = material.transmissionMap;
+
+				refreshTransformUniform( material.transmissionMap, uniforms.transmissionMapTransform );
+
+			}
+
+			uniforms.thickness.value = material.thickness;
+
+			if ( material.thicknessMap ) {
+
+				uniforms.thicknessMap.value = material.thicknessMap;
+
+				refreshTransformUniform( material.thicknessMap, uniforms.thicknessMapTransform );
+
+			}
+
+			uniforms.attenuationDistance.value = material.attenuationDistance;
+			uniforms.attenuationColor.value.copy( material.attenuationColor );
+
+		}
+
+		if ( material.anisotropy > 0 ) {
+
+			uniforms.anisotropyVector.value.set( material.anisotropy * Math.cos( material.anisotropyRotation ), material.anisotropy * Math.sin( material.anisotropyRotation ) );
+
+			if ( material.anisotropyMap ) {
+
+				uniforms.anisotropyMap.value = material.anisotropyMap;
+
+				refreshTransformUniform( material.anisotropyMap, uniforms.anisotropyMapTransform );
+
+			}
+
+		}
+
+		uniforms.specularIntensity.value = material.specularIntensity;
+		uniforms.specularColor.value.copy( material.specularColor );
+
+		if ( material.specularColorMap ) {
+
+			uniforms.specularColorMap.value = material.specularColorMap;
+
+			refreshTransformUniform( material.specularColorMap, uniforms.specularColorMapTransform );
+
+		}
+
+		if ( material.specularIntensityMap ) {
+
+			uniforms.specularIntensityMap.value = material.specularIntensityMap;
+
+			refreshTransformUniform( material.specularIntensityMap, uniforms.specularIntensityMapTransform );
+
+		}
+
+	}
+
+	function refreshUniformsMatcap( uniforms, material ) {
+
+		if ( material.matcap ) {
+
+			uniforms.matcap.value = material.matcap;
+
+		}
+
+	}
+
+	function refreshUniformsDistance( uniforms, material ) {
+
+		const light = properties.get( material ).light;
+
+		uniforms.referencePosition.value.setFromMatrixPosition( light.matrixWorld );
+		uniforms.nearDistance.value = light.shadow.camera.near;
+		uniforms.farDistance.value = light.shadow.camera.far;
+
+	}
+
+	return {
+		refreshFogUniforms: refreshFogUniforms,
+		refreshMaterialUniforms: refreshMaterialUniforms
+	};
+
+}
+
+function WebGLUniformsGroups( gl, info, capabilities, state ) {
+
+	let buffers = {};
+	let updateList = {};
+	let allocatedBindingPoints = [];
+
+	const maxBindingPoints = ( capabilities.isWebGL2 ) ? gl.getParameter( gl.MAX_UNIFORM_BUFFER_BINDINGS ) : 0; // binding points are global whereas block indices are per shader program
+
+	function bind( uniformsGroup, program ) {
+
+		const webglProgram = program.program;
+		state.uniformBlockBinding( uniformsGroup, webglProgram );
+
+	}
+
+	function update( uniformsGroup, program ) {
+
+		let buffer = buffers[ uniformsGroup.id ];
+
+		if ( buffer === undefined ) {
+
+			prepareUniformsGroup( uniformsGroup );
+
+			buffer = createBuffer( uniformsGroup );
+			buffers[ uniformsGroup.id ] = buffer;
+
+			uniformsGroup.addEventListener( 'dispose', onUniformsGroupsDispose );
+
+		}
+
+		// ensure to update the binding points/block indices mapping for this program
+
+		const webglProgram = program.program;
+		state.updateUBOMapping( uniformsGroup, webglProgram );
+
+		// update UBO once per frame
+
+		const frame = info.render.frame;
+
+		if ( updateList[ uniformsGroup.id ] !== frame ) {
+
+			updateBufferData( uniformsGroup );
+
+			updateList[ uniformsGroup.id ] = frame;
+
+		}
+
+	}
+
+	function createBuffer( uniformsGroup ) {
+
+		// the setup of an UBO is independent of a particular shader program but global
+
+		const bindingPointIndex = allocateBindingPointIndex();
+		uniformsGroup.__bindingPointIndex = bindingPointIndex;
+
+		const buffer = gl.createBuffer();
+		const size = uniformsGroup.__size;
+		const usage = uniformsGroup.usage;
+
+		gl.bindBuffer( gl.UNIFORM_BUFFER, buffer );
+		gl.bufferData( gl.UNIFORM_BUFFER, size, usage );
+		gl.bindBuffer( gl.UNIFORM_BUFFER, null );
+		gl.bindBufferBase( gl.UNIFORM_BUFFER, bindingPointIndex, buffer );
+
+		return buffer;
+
+	}
+
+	function allocateBindingPointIndex() {
+
+		for ( let i = 0; i < maxBindingPoints; i ++ ) {
+
+			if ( allocatedBindingPoints.indexOf( i ) === - 1 ) {
+
+				allocatedBindingPoints.push( i );
+				return i;
+
+			}
+
+		}
+
+		console.error( 'THREE.WebGLRenderer: Maximum number of simultaneously usable uniforms groups reached.' );
+
+		return 0;
+
+	}
+
+	function updateBufferData( uniformsGroup ) {
+
+		const buffer = buffers[ uniformsGroup.id ];
+		const uniforms = uniformsGroup.uniforms;
+		const cache = uniformsGroup.__cache;
+
+		gl.bindBuffer( gl.UNIFORM_BUFFER, buffer );
+
+		for ( let i = 0, il = uniforms.length; i < il; i ++ ) {
+
+			const uniformArray = Array.isArray( uniforms[ i ] ) ? uniforms[ i ] : [ uniforms[ i ] ];
+
+			for ( let j = 0, jl = uniformArray.length; j < jl; j ++ ) {
+
+				const uniform = uniformArray[ j ];
+
+				if ( hasUniformChanged( uniform, i, j, cache ) === true ) {
+
+					const offset = uniform.__offset;
+
+					const values = Array.isArray( uniform.value ) ? uniform.value : [ uniform.value ];
+
+					let arrayOffset = 0;
+
+					for ( let k = 0; k < values.length; k ++ ) {
+
+						const value = values[ k ];
+
+						const info = getUniformSize( value );
+
+						// TODO add integer and struct support
+						if ( typeof value === 'number' || typeof value === 'boolean' ) {
+
+							uniform.__data[ 0 ] = value;
+							gl.bufferSubData( gl.UNIFORM_BUFFER, offset + arrayOffset, uniform.__data );
+
+						} else if ( value.isMatrix3 ) {
+
+							// manually converting 3x3 to 3x4
+
+							uniform.__data[ 0 ] = value.elements[ 0 ];
+							uniform.__data[ 1 ] = value.elements[ 1 ];
+							uniform.__data[ 2 ] = value.elements[ 2 ];
+							uniform.__data[ 3 ] = 0;
+							uniform.__data[ 4 ] = value.elements[ 3 ];
+							uniform.__data[ 5 ] = value.elements[ 4 ];
+							uniform.__data[ 6 ] = value.elements[ 5 ];
+							uniform.__data[ 7 ] = 0;
+							uniform.__data[ 8 ] = value.elements[ 6 ];
+							uniform.__data[ 9 ] = value.elements[ 7 ];
+							uniform.__data[ 10 ] = value.elements[ 8 ];
+							uniform.__data[ 11 ] = 0;
+
+						} else {
+
+							value.toArray( uniform.__data, arrayOffset );
+
+							arrayOffset += info.storage / Float32Array.BYTES_PER_ELEMENT;
+
+						}
+
+					}
+
+					gl.bufferSubData( gl.UNIFORM_BUFFER, offset, uniform.__data );
+
+				}
+
+			}
+
+		}
+
+		gl.bindBuffer( gl.UNIFORM_BUFFER, null );
+
+	}
+
+	function hasUniformChanged( uniform, index, indexArray, cache ) {
+
+		const value = uniform.value;
+		const indexString = index + '_' + indexArray;
+
+		if ( cache[ indexString ] === undefined ) {
+
+			// cache entry does not exist so far
+
+			if ( typeof value === 'number' || typeof value === 'boolean' ) {
+
+				cache[ indexString ] = value;
+
+			} else {
+
+				cache[ indexString ] = value.clone();
+
+			}
+
+			return true;
+
+		} else {
+
+			const cachedObject = cache[ indexString ];
+
+			// compare current value with cached entry
+
+			if ( typeof value === 'number' || typeof value === 'boolean' ) {
+
+				if ( cachedObject !== value ) {
+
+					cache[ indexString ] = value;
+					return true;
+
+				}
+
+			} else {
+
+				if ( cachedObject.equals( value ) === false ) {
+
+					cachedObject.copy( value );
+					return true;
+
+				}
+
+			}
+
+		}
+
+		return false;
+
+	}
+
+	function prepareUniformsGroup( uniformsGroup ) {
+
+		// determine total buffer size according to the STD140 layout
+		// Hint: STD140 is the only supported layout in WebGL 2
+
+		const uniforms = uniformsGroup.uniforms;
+
+		let offset = 0; // global buffer offset in bytes
+		const chunkSize = 16; // size of a chunk in bytes
+
+		for ( let i = 0, l = uniforms.length; i < l; i ++ ) {
+
+			const uniformArray = Array.isArray( uniforms[ i ] ) ? uniforms[ i ] : [ uniforms[ i ] ];
+
+			for ( let j = 0, jl = uniformArray.length; j < jl; j ++ ) {
+
+				const uniform = uniformArray[ j ];
+
+				const values = Array.isArray( uniform.value ) ? uniform.value : [ uniform.value ];
+
+				for ( let k = 0, kl = values.length; k < kl; k ++ ) {
+
+					const value = values[ k ];
+
+					const info = getUniformSize( value );
+
+					// Calculate the chunk offset
+					const chunkOffsetUniform = offset % chunkSize;
+
+					// Check for chunk overflow
+					if ( chunkOffsetUniform !== 0 && ( chunkSize - chunkOffsetUniform ) < info.boundary ) {
+
+						// Add padding and adjust offset
+						offset += ( chunkSize - chunkOffsetUniform );
+
+					}
+
+					// the following two properties will be used for partial buffer updates
+
+					uniform.__data = new Float32Array( info.storage / Float32Array.BYTES_PER_ELEMENT );
+					uniform.__offset = offset;
+
+
+					// Update the global offset
+					offset += info.storage;
+
+
+				}
+
+			}
+
+		}
+
+		// ensure correct final padding
+
+		const chunkOffset = offset % chunkSize;
+
+		if ( chunkOffset > 0 ) offset += ( chunkSize - chunkOffset );
+
+		//
+
+		uniformsGroup.__size = offset;
+		uniformsGroup.__cache = {};
+
+		return this;
+
+	}
+
+	function getUniformSize( value ) {
+
+		const info = {
+			boundary: 0, // bytes
+			storage: 0 // bytes
+		};
+
+		// determine sizes according to STD140
+
+		if ( typeof value === 'number' || typeof value === 'boolean' ) {
+
+			// float/int/bool
+
+			info.boundary = 4;
+			info.storage = 4;
+
+		} else if ( value.isVector2 ) {
+
+			// vec2
+
+			info.boundary = 8;
+			info.storage = 8;
+
+		} else if ( value.isVector3 || value.isColor ) {
+
+			// vec3
+
+			info.boundary = 16;
+			info.storage = 12; // evil: vec3 must start on a 16-byte boundary but it only consumes 12 bytes
+
+		} else if ( value.isVector4 ) {
+
+			// vec4
+
+			info.boundary = 16;
+			info.storage = 16;
+
+		} else if ( value.isMatrix3 ) {
+
+			// mat3 (in STD140 a 3x3 matrix is represented as 3x4)
+
+			info.boundary = 48;
+			info.storage = 48;
+
+		} else if ( value.isMatrix4 ) {
+
+			// mat4
+
+			info.boundary = 64;
+			info.storage = 64;
+
+		} else if ( value.isTexture ) {
+
+			console.warn( 'THREE.WebGLRenderer: Texture samplers can not be part of an uniforms group.' );
+
+		} else {
+
+			console.warn( 'THREE.WebGLRenderer: Unsupported uniform value type.', value );
+
+		}
+
+		return info;
+
+	}
+
+	function onUniformsGroupsDispose( event ) {
+
+		const uniformsGroup = event.target;
+
+		uniformsGroup.removeEventListener( 'dispose', onUniformsGroupsDispose );
+
+		const index = allocatedBindingPoints.indexOf( uniformsGroup.__bindingPointIndex );
+		allocatedBindingPoints.splice( index, 1 );
+
+		gl.deleteBuffer( buffers[ uniformsGroup.id ] );
+
+		delete buffers[ uniformsGroup.id ];
+		delete updateList[ uniformsGroup.id ];
+
+	}
+
+	function dispose() {
+
+		for ( const id in buffers ) {
+
+			gl.deleteBuffer( buffers[ id ] );
+
+		}
+
+		allocatedBindingPoints = [];
+		buffers = {};
+		updateList = {};
+
+	}
+
+	return {
+
+		bind: bind,
+		update: update,
+
+		dispose: dispose
+
+	};
+
+}
+
+class WebGLRenderer {
+
+	constructor( parameters = {} ) {
+
+		const {
+			canvas = createCanvasElement(),
+			context = null,
+			depth = true,
+			stencil = true,
+			alpha = false,
+			antialias = false,
+			premultipliedAlpha = true,
+			preserveDrawingBuffer = false,
+			powerPreference = 'default',
+			failIfMajorPerformanceCaveat = false,
+		} = parameters;
+
+		this.isWebGLRenderer = true;
+
+		let _alpha;
+
+		if ( context !== null ) {
+
+			_alpha = context.getContextAttributes().alpha;
+
+		} else {
+
+			_alpha = alpha;
+
+		}
+
+		const uintClearColor = new Uint32Array( 4 );
+		const intClearColor = new Int32Array( 4 );
+
+		let currentRenderList = null;
+		let currentRenderState = null;
+
+		// render() can be called from within a callback triggered by another render.
+		// We track this so that the nested render call gets its list and state isolated from the parent render call.
+
+		const renderListStack = [];
+		const renderStateStack = [];
+
+		// public properties
+
+		this.domElement = canvas;
+
+		// Debug configuration container
+		this.debug = {
+
+			/**
+			 * Enables error checking and reporting when shader programs are being compiled
+			 * @type {boolean}
+			 */
+			checkShaderErrors: true,
+			/**
+			 * Callback for custom error reporting.
+			 * @type {?Function}
+			 */
+			onShaderError: null
+		};
+
+		// clearing
+
+		this.autoClear = true;
+		this.autoClearColor = true;
+		this.autoClearDepth = true;
+		this.autoClearStencil = true;
+
+		// scene graph
+
+		this.sortObjects = true;
+
+		// user-defined clipping
+
+		this.clippingPlanes = [];
+		this.localClippingEnabled = false;
+
+		// physically based shading
+
+		this._outputColorSpace = SRGBColorSpace;
+
+		// physical lights
+
+		this._useLegacyLights = false;
+
+		// tone mapping
+
+		this.toneMapping = NoToneMapping;
+		this.toneMappingExposure = 1.0;
+
+		// internal properties
+
+		const _this = this;
+
+		let _isContextLost = false;
+
+		// internal state cache
+
+		let _currentActiveCubeFace = 0;
+		let _currentActiveMipmapLevel = 0;
+		let _currentRenderTarget = null;
+		let _currentMaterialId = - 1;
+
+		let _currentCamera = null;
+
+		const _currentViewport = new Vector4();
+		const _currentScissor = new Vector4();
+		let _currentScissorTest = null;
+
+		const _currentClearColor = new Color( 0x000000 );
+		let _currentClearAlpha = 0;
+
+		//
+
+		let _width = canvas.width;
+		let _height = canvas.height;
+
+		let _pixelRatio = 1;
+		let _opaqueSort = null;
+		let _transparentSort = null;
+
+		const _viewport = new Vector4( 0, 0, _width, _height );
+		const _scissor = new Vector4( 0, 0, _width, _height );
+		let _scissorTest = false;
+
+		// frustum
+
+		const _frustum = new Frustum();
+
+		// clipping
+
+		let _clippingEnabled = false;
+		let _localClippingEnabled = false;
+
+		// transmission
+
+		let _transmissionRenderTarget = null;
+
+		// camera matrices cache
+
+		const _projScreenMatrix = new Matrix4();
+
+		const _vector2 = new Vector2();
+		const _vector3 = new Vector3();
+
+		const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };
+
+		function getTargetPixelRatio() {
+
+			return _currentRenderTarget === null ? _pixelRatio : 1;
+
+		}
+
+		// initialize
+
+		let _gl = context;
+
+		function getContext( contextNames, contextAttributes ) {
+
+			for ( let i = 0; i < contextNames.length; i ++ ) {
+
+				const contextName = contextNames[ i ];
+				const context = canvas.getContext( contextName, contextAttributes );
+				if ( context !== null ) return context;
+
+			}
+
+			return null;
+
+		}
+
+		try {
+
+			const contextAttributes = {
+				alpha: true,
+				depth,
+				stencil,
+				antialias,
+				premultipliedAlpha,
+				preserveDrawingBuffer,
+				powerPreference,
+				failIfMajorPerformanceCaveat,
+			};
+
+			// OffscreenCanvas does not have setAttribute, see #22811
+			if ( 'setAttribute' in canvas ) canvas.setAttribute( 'data-engine', `three.js r${REVISION}` );
+
+			// event listeners must be registered before WebGL context is created, see #12753
+			canvas.addEventListener( 'webglcontextlost', onContextLost, false );
+			canvas.addEventListener( 'webglcontextrestored', onContextRestore, false );
+			canvas.addEventListener( 'webglcontextcreationerror', onContextCreationError, false );
+
+			if ( _gl === null ) {
+
+				const contextNames = [ 'webgl2', 'webgl', 'experimental-webgl' ];
+
+				if ( _this.isWebGL1Renderer === true ) {
+
+					contextNames.shift();
+
+				}
+
+				_gl = getContext( contextNames, contextAttributes );
+
+				if ( _gl === null ) {
+
+					if ( getContext( contextNames ) ) {
+
+						throw new Error( 'Error creating WebGL context with your selected attributes.' );
+
+					} else {
+
+						throw new Error( 'Error creating WebGL context.' );
+
+					}
+
+				}
+
+			}
+
+			if ( typeof WebGLRenderingContext !== 'undefined' && _gl instanceof WebGLRenderingContext ) { // @deprecated, r153
+
+				console.warn( 'THREE.WebGLRenderer: WebGL 1 support was deprecated in r153 and will be removed in r163.' );
+
+			}
+
+			// Some experimental-webgl implementations do not have getShaderPrecisionFormat
+
+			if ( _gl.getShaderPrecisionFormat === undefined ) {
+
+				_gl.getShaderPrecisionFormat = function () {
+
+					return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };
+
+				};
+
+			}
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLRenderer: ' + error.message );
+			throw error;
+
+		}
+
+		let extensions, capabilities, state, info;
+		let properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects;
+		let programCache, materials, renderLists, renderStates, clipping, shadowMap;
+
+		let background, morphtargets, bufferRenderer, indexedBufferRenderer;
+
+		let utils, bindingStates, uniformsGroups;
+
+		function initGLContext() {
+
+			extensions = new WebGLExtensions( _gl );
+
+			capabilities = new WebGLCapabilities( _gl, extensions, parameters );
+
+			extensions.init( capabilities );
+
+			utils = new WebGLUtils( _gl, extensions, capabilities );
+
+			state = new WebGLState( _gl, extensions, capabilities );
+
+			info = new WebGLInfo( _gl );
+			properties = new WebGLProperties();
+			textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info );
+			cubemaps = new WebGLCubeMaps( _this );
+			cubeuvmaps = new WebGLCubeUVMaps( _this );
+			attributes = new WebGLAttributes( _gl, capabilities );
+			bindingStates = new WebGLBindingStates( _gl, extensions, attributes, capabilities );
+			geometries = new WebGLGeometries( _gl, attributes, info, bindingStates );
+			objects = new WebGLObjects( _gl, geometries, attributes, info );
+			morphtargets = new WebGLMorphtargets( _gl, capabilities, textures );
+			clipping = new WebGLClipping( properties );
+			programCache = new WebGLPrograms( _this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping );
+			materials = new WebGLMaterials( _this, properties );
+			renderLists = new WebGLRenderLists();
+			renderStates = new WebGLRenderStates( extensions, capabilities );
+			background = new WebGLBackground( _this, cubemaps, cubeuvmaps, state, objects, _alpha, premultipliedAlpha );
+			shadowMap = new WebGLShadowMap( _this, objects, capabilities );
+			uniformsGroups = new WebGLUniformsGroups( _gl, info, capabilities, state );
+
+			bufferRenderer = new WebGLBufferRenderer( _gl, extensions, info, capabilities );
+			indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, info, capabilities );
+
+			info.programs = programCache.programs;
+
+			_this.capabilities = capabilities;
+			_this.extensions = extensions;
+			_this.properties = properties;
+			_this.renderLists = renderLists;
+			_this.shadowMap = shadowMap;
+			_this.state = state;
+			_this.info = info;
+
+		}
+
+		initGLContext();
+
+		// xr
+
+		const xr = new WebXRManager( _this, _gl );
+
+		this.xr = xr;
+
+		// API
+
+		this.getContext = function () {
+
+			return _gl;
+
+		};
+
+		this.getContextAttributes = function () {
+
+			return _gl.getContextAttributes();
+
+		};
+
+		this.forceContextLoss = function () {
+
+			const extension = extensions.get( 'WEBGL_lose_context' );
+			if ( extension ) extension.loseContext();
+
+		};
+
+		this.forceContextRestore = function () {
+
+			const extension = extensions.get( 'WEBGL_lose_context' );
+			if ( extension ) extension.restoreContext();
+
+		};
+
+		this.getPixelRatio = function () {
+
+			return _pixelRatio;
+
+		};
+
+		this.setPixelRatio = function ( value ) {
+
+			if ( value === undefined ) return;
+
+			_pixelRatio = value;
+
+			this.setSize( _width, _height, false );
+
+		};
+
+		this.getSize = function ( target ) {
+
+			return target.set( _width, _height );
+
+		};
+
+		this.setSize = function ( width, height, updateStyle = true ) {
+
+			if ( xr.isPresenting ) {
+
+				console.warn( 'THREE.WebGLRenderer: Can\'t change size while VR device is presenting.' );
+				return;
+
+			}
+
+			_width = width;
+			_height = height;
+
+			canvas.width = Math.floor( width * _pixelRatio );
+			canvas.height = Math.floor( height * _pixelRatio );
+
+			if ( updateStyle === true ) {
+
+				canvas.style.width = width + 'px';
+				canvas.style.height = height + 'px';
+
+			}
+
+			this.setViewport( 0, 0, width, height );
+
+		};
+
+		this.getDrawingBufferSize = function ( target ) {
+
+			return target.set( _width * _pixelRatio, _height * _pixelRatio ).floor();
+
+		};
+
+		this.setDrawingBufferSize = function ( width, height, pixelRatio ) {
+
+			_width = width;
+			_height = height;
+
+			_pixelRatio = pixelRatio;
+
+			canvas.width = Math.floor( width * pixelRatio );
+			canvas.height = Math.floor( height * pixelRatio );
+
+			this.setViewport( 0, 0, width, height );
+
+		};
+
+		this.getCurrentViewport = function ( target ) {
+
+			return target.copy( _currentViewport );
+
+		};
+
+		this.getViewport = function ( target ) {
+
+			return target.copy( _viewport );
+
+		};
+
+		this.setViewport = function ( x, y, width, height ) {
+
+			if ( x.isVector4 ) {
+
+				_viewport.set( x.x, x.y, x.z, x.w );
+
+			} else {
+
+				_viewport.set( x, y, width, height );
+
+			}
+
+			state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor() );
+
+		};
+
+		this.getScissor = function ( target ) {
+
+			return target.copy( _scissor );
+
+		};
+
+		this.setScissor = function ( x, y, width, height ) {
+
+			if ( x.isVector4 ) {
+
+				_scissor.set( x.x, x.y, x.z, x.w );
+
+			} else {
+
+				_scissor.set( x, y, width, height );
+
+			}
+
+			state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor() );
+
+		};
+
+		this.getScissorTest = function () {
+
+			return _scissorTest;
+
+		};
+
+		this.setScissorTest = function ( boolean ) {
+
+			state.setScissorTest( _scissorTest = boolean );
+
+		};
+
+		this.setOpaqueSort = function ( method ) {
+
+			_opaqueSort = method;
+
+		};
+
+		this.setTransparentSort = function ( method ) {
+
+			_transparentSort = method;
+
+		};
+
+		// Clearing
+
+		this.getClearColor = function ( target ) {
+
+			return target.copy( background.getClearColor() );
+
+		};
+
+		this.setClearColor = function () {
+
+			background.setClearColor.apply( background, arguments );
+
+		};
+
+		this.getClearAlpha = function () {
+
+			return background.getClearAlpha();
+
+		};
+
+		this.setClearAlpha = function () {
+
+			background.setClearAlpha.apply( background, arguments );
+
+		};
+
+		this.clear = function ( color = true, depth = true, stencil = true ) {
+
+			let bits = 0;
+
+			if ( color ) {
+
+				// check if we're trying to clear an integer target
+				let isIntegerFormat = false;
+				if ( _currentRenderTarget !== null ) {
+
+					const targetFormat = _currentRenderTarget.texture.format;
+					isIntegerFormat = targetFormat === RGBAIntegerFormat ||
+						targetFormat === RGIntegerFormat ||
+						targetFormat === RedIntegerFormat;
+
+				}
+
+				// use the appropriate clear functions to clear the target if it's a signed
+				// or unsigned integer target
+				if ( isIntegerFormat ) {
+
+					const targetType = _currentRenderTarget.texture.type;
+					const isUnsignedType = targetType === UnsignedByteType ||
+						targetType === UnsignedIntType ||
+						targetType === UnsignedShortType ||
+						targetType === UnsignedInt248Type ||
+						targetType === UnsignedShort4444Type ||
+						targetType === UnsignedShort5551Type;
+
+					const clearColor = background.getClearColor();
+					const a = background.getClearAlpha();
+					const r = clearColor.r;
+					const g = clearColor.g;
+					const b = clearColor.b;
+
+					if ( isUnsignedType ) {
+
+						uintClearColor[ 0 ] = r;
+						uintClearColor[ 1 ] = g;
+						uintClearColor[ 2 ] = b;
+						uintClearColor[ 3 ] = a;
+						_gl.clearBufferuiv( _gl.COLOR, 0, uintClearColor );
+
+					} else {
+
+						intClearColor[ 0 ] = r;
+						intClearColor[ 1 ] = g;
+						intClearColor[ 2 ] = b;
+						intClearColor[ 3 ] = a;
+						_gl.clearBufferiv( _gl.COLOR, 0, intClearColor );
+
+					}
+
+				} else {
+
+					bits |= _gl.COLOR_BUFFER_BIT;
+
+				}
+
+			}
+
+			if ( depth ) bits |= _gl.DEPTH_BUFFER_BIT;
+			if ( stencil ) {
+
+				bits |= _gl.STENCIL_BUFFER_BIT;
+				this.state.buffers.stencil.setMask( 0xffffffff );
+
+			}
+
+			_gl.clear( bits );
+
+		};
+
+		this.clearColor = function () {
+
+			this.clear( true, false, false );
+
+		};
+
+		this.clearDepth = function () {
+
+			this.clear( false, true, false );
+
+		};
+
+		this.clearStencil = function () {
+
+			this.clear( false, false, true );
+
+		};
+
+		//
+
+		this.dispose = function () {
+
+			canvas.removeEventListener( 'webglcontextlost', onContextLost, false );
+			canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );
+			canvas.removeEventListener( 'webglcontextcreationerror', onContextCreationError, false );
+
+			renderLists.dispose();
+			renderStates.dispose();
+			properties.dispose();
+			cubemaps.dispose();
+			cubeuvmaps.dispose();
+			objects.dispose();
+			bindingStates.dispose();
+			uniformsGroups.dispose();
+			programCache.dispose();
+
+			xr.dispose();
+
+			xr.removeEventListener( 'sessionstart', onXRSessionStart );
+			xr.removeEventListener( 'sessionend', onXRSessionEnd );
+
+			if ( _transmissionRenderTarget ) {
+
+				_transmissionRenderTarget.dispose();
+				_transmissionRenderTarget = null;
+
+			}
+
+			animation.stop();
+
+		};
+
+		// Events
+
+		function onContextLost( event ) {
+
+			event.preventDefault();
+
+			console.log( 'THREE.WebGLRenderer: Context Lost.' );
+
+			_isContextLost = true;
+
+		}
+
+		function onContextRestore( /* event */ ) {
+
+			console.log( 'THREE.WebGLRenderer: Context Restored.' );
+
+			_isContextLost = false;
+
+			const infoAutoReset = info.autoReset;
+			const shadowMapEnabled = shadowMap.enabled;
+			const shadowMapAutoUpdate = shadowMap.autoUpdate;
+			const shadowMapNeedsUpdate = shadowMap.needsUpdate;
+			const shadowMapType = shadowMap.type;
+
+			initGLContext();
+
+			info.autoReset = infoAutoReset;
+			shadowMap.enabled = shadowMapEnabled;
+			shadowMap.autoUpdate = shadowMapAutoUpdate;
+			shadowMap.needsUpdate = shadowMapNeedsUpdate;
+			shadowMap.type = shadowMapType;
+
+		}
+
+		function onContextCreationError( event ) {
+
+			console.error( 'THREE.WebGLRenderer: A WebGL context could not be created. Reason: ', event.statusMessage );
+
+		}
+
+		function onMaterialDispose( event ) {
+
+			const material = event.target;
+
+			material.removeEventListener( 'dispose', onMaterialDispose );
+
+			deallocateMaterial( material );
+
+		}
+
+		// Buffer deallocation
+
+		function deallocateMaterial( material ) {
+
+			releaseMaterialProgramReferences( material );
+
+			properties.remove( material );
+
+		}
+
+
+		function releaseMaterialProgramReferences( material ) {
+
+			const programs = properties.get( material ).programs;
+
+			if ( programs !== undefined ) {
+
+				programs.forEach( function ( program ) {
+
+					programCache.releaseProgram( program );
+
+				} );
+
+				if ( material.isShaderMaterial ) {
+
+					programCache.releaseShaderCache( material );
+
+				}
+
+			}
+
+		}
+
+		// Buffer rendering
+
+		this.renderBufferDirect = function ( camera, scene, geometry, material, object, group ) {
+
+			if ( scene === null ) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)
+
+			const frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );
+
+			const program = setProgram( camera, scene, geometry, material, object );
+
+			state.setMaterial( material, frontFaceCW );
+
+			//
+
+			let index = geometry.index;
+			let rangeFactor = 1;
+
+			if ( material.wireframe === true ) {
+
+				index = geometries.getWireframeAttribute( geometry );
+
+				if ( index === undefined ) return;
+
+				rangeFactor = 2;
+
+			}
+
+			//
+
+			const drawRange = geometry.drawRange;
+			const position = geometry.attributes.position;
+
+			let drawStart = drawRange.start * rangeFactor;
+			let drawEnd = ( drawRange.start + drawRange.count ) * rangeFactor;
+
+			if ( group !== null ) {
+
+				drawStart = Math.max( drawStart, group.start * rangeFactor );
+				drawEnd = Math.min( drawEnd, ( group.start + group.count ) * rangeFactor );
+
+			}
+
+			if ( index !== null ) {
+
+				drawStart = Math.max( drawStart, 0 );
+				drawEnd = Math.min( drawEnd, index.count );
+
+			} else if ( position !== undefined && position !== null ) {
+
+				drawStart = Math.max( drawStart, 0 );
+				drawEnd = Math.min( drawEnd, position.count );
+
+			}
+
+			const drawCount = drawEnd - drawStart;
+
+			if ( drawCount < 0 || drawCount === Infinity ) return;
+
+			//
+
+			bindingStates.setup( object, material, program, geometry, index );
+
+			let attribute;
+			let renderer = bufferRenderer;
+
+			if ( index !== null ) {
+
+				attribute = attributes.get( index );
+
+				renderer = indexedBufferRenderer;
+				renderer.setIndex( attribute );
+
+			}
+
+			//
+
+			if ( object.isMesh ) {
+
+				if ( material.wireframe === true ) {
+
+					state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );
+					renderer.setMode( _gl.LINES );
+
+				} else {
+
+					renderer.setMode( _gl.TRIANGLES );
+
+				}
+
+			} else if ( object.isLine ) {
+
+				let lineWidth = material.linewidth;
+
+				if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material
+
+				state.setLineWidth( lineWidth * getTargetPixelRatio() );
+
+				if ( object.isLineSegments ) {
+
+					renderer.setMode( _gl.LINES );
+
+				} else if ( object.isLineLoop ) {
+
+					renderer.setMode( _gl.LINE_LOOP );
+
+				} else {
+
+					renderer.setMode( _gl.LINE_STRIP );
+
+				}
+
+			} else if ( object.isPoints ) {
+
+				renderer.setMode( _gl.POINTS );
+
+			} else if ( object.isSprite ) {
+
+				renderer.setMode( _gl.TRIANGLES );
+
+			}
+
+			if ( object.isBatchedMesh ) {
+
+				renderer.renderMultiDraw( object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount );
+
+			} else if ( object.isInstancedMesh ) {
+
+				renderer.renderInstances( drawStart, drawCount, object.count );
+
+			} else if ( geometry.isInstancedBufferGeometry ) {
+
+				const maxInstanceCount = geometry._maxInstanceCount !== undefined ? geometry._maxInstanceCount : Infinity;
+				const instanceCount = Math.min( geometry.instanceCount, maxInstanceCount );
+
+				renderer.renderInstances( drawStart, drawCount, instanceCount );
+
+			} else {
+
+				renderer.render( drawStart, drawCount );
+
+			}
+
+		};
+
+		// Compile
+
+		function prepareMaterial( material, scene, object ) {
+
+			if ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {
+
+				material.side = BackSide;
+				material.needsUpdate = true;
+				getProgram( material, scene, object );
+
+				material.side = FrontSide;
+				material.needsUpdate = true;
+				getProgram( material, scene, object );
+
+				material.side = DoubleSide;
+
+			} else {
+
+				getProgram( material, scene, object );
+
+			}
+
+		}
+
+		this.compile = function ( scene, camera, targetScene = null ) {
+
+			if ( targetScene === null ) targetScene = scene;
+
+			currentRenderState = renderStates.get( targetScene );
+			currentRenderState.init();
+
+			renderStateStack.push( currentRenderState );
+
+			// gather lights from both the target scene and the new object that will be added to the scene.
+
+			targetScene.traverseVisible( function ( object ) {
+
+				if ( object.isLight && object.layers.test( camera.layers ) ) {
+
+					currentRenderState.pushLight( object );
+
+					if ( object.castShadow ) {
+
+						currentRenderState.pushShadow( object );
+
+					}
+
+				}
+
+			} );
+
+			if ( scene !== targetScene ) {
+
+				scene.traverseVisible( function ( object ) {
+
+					if ( object.isLight && object.layers.test( camera.layers ) ) {
+
+						currentRenderState.pushLight( object );
+
+						if ( object.castShadow ) {
+
+							currentRenderState.pushShadow( object );
+
+						}
+
+					}
+
+				} );
+
+			}
+
+			currentRenderState.setupLights( _this._useLegacyLights );
+
+			// Only initialize materials in the new scene, not the targetScene.
+
+			const materials = new Set();
+
+			scene.traverse( function ( object ) {
+
+				const material = object.material;
+
+				if ( material ) {
+
+					if ( Array.isArray( material ) ) {
+
+						for ( let i = 0; i < material.length; i ++ ) {
+
+							const material2 = material[ i ];
+
+							prepareMaterial( material2, targetScene, object );
+							materials.add( material2 );
+
+						}
+
+					} else {
+
+						prepareMaterial( material, targetScene, object );
+						materials.add( material );
+
+					}
+
+				}
+
+			} );
+
+			renderStateStack.pop();
+			currentRenderState = null;
+
+			return materials;
+
+		};
+
+		// compileAsync
+
+		this.compileAsync = function ( scene, camera, targetScene = null ) {
+
+			const materials = this.compile( scene, camera, targetScene );
+
+			// Wait for all the materials in the new object to indicate that they're
+			// ready to be used before resolving the promise.
+
+			return new Promise( ( resolve ) => {
+
+				function checkMaterialsReady() {
+
+					materials.forEach( function ( material ) {
+
+						const materialProperties = properties.get( material );
+						const program = materialProperties.currentProgram;
+
+						if ( program.isReady() ) {
+
+							// remove any programs that report they're ready to use from the list
+							materials.delete( material );
+
+						}
+
+					} );
+
+					// once the list of compiling materials is empty, call the callback
+
+					if ( materials.size === 0 ) {
+
+						resolve( scene );
+						return;
+
+					}
+
+					// if some materials are still not ready, wait a bit and check again
+
+					setTimeout( checkMaterialsReady, 10 );
+
+				}
+
+				if ( extensions.get( 'KHR_parallel_shader_compile' ) !== null ) {
+
+					// If we can check the compilation status of the materials without
+					// blocking then do so right away.
+
+					checkMaterialsReady();
+
+				} else {
+
+					// Otherwise start by waiting a bit to give the materials we just
+					// initialized a chance to finish.
+
+					setTimeout( checkMaterialsReady, 10 );
+
+				}
+
+			} );
+
+		};
+
+		// Animation Loop
+
+		let onAnimationFrameCallback = null;
+
+		function onAnimationFrame( time ) {
+
+			if ( onAnimationFrameCallback ) onAnimationFrameCallback( time );
+
+		}
+
+		function onXRSessionStart() {
+
+			animation.stop();
+
+		}
+
+		function onXRSessionEnd() {
+
+			animation.start();
+
+		}
+
+		const animation = new WebGLAnimation();
+		animation.setAnimationLoop( onAnimationFrame );
+
+		if ( typeof self !== 'undefined' ) animation.setContext( self );
+
+		this.setAnimationLoop = function ( callback ) {
+
+			onAnimationFrameCallback = callback;
+			xr.setAnimationLoop( callback );
+
+			( callback === null ) ? animation.stop() : animation.start();
+
+		};
+
+		xr.addEventListener( 'sessionstart', onXRSessionStart );
+		xr.addEventListener( 'sessionend', onXRSessionEnd );
+
+		// Rendering
+
+		this.render = function ( scene, camera ) {
+
+			if ( camera !== undefined && camera.isCamera !== true ) {
+
+				console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );
+				return;
+
+			}
+
+			if ( _isContextLost === true ) return;
+
+			// update scene graph
+
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+
+			// update camera matrices and frustum
+
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+
+			if ( xr.enabled === true && xr.isPresenting === true ) {
+
+				if ( xr.cameraAutoUpdate === true ) xr.updateCamera( camera );
+
+				camera = xr.getCamera(); // use XR camera for rendering
+
+			}
+
+			//
+			if ( scene.isScene === true ) scene.onBeforeRender( _this, scene, camera, _currentRenderTarget );
+
+			currentRenderState = renderStates.get( scene, renderStateStack.length );
+			currentRenderState.init();
+
+			renderStateStack.push( currentRenderState );
+
+			_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
+			_frustum.setFromProjectionMatrix( _projScreenMatrix );
+
+			_localClippingEnabled = this.localClippingEnabled;
+			_clippingEnabled = clipping.init( this.clippingPlanes, _localClippingEnabled );
+
+			currentRenderList = renderLists.get( scene, renderListStack.length );
+			currentRenderList.init();
+
+			renderListStack.push( currentRenderList );
+
+			projectObject( scene, camera, 0, _this.sortObjects );
+
+			currentRenderList.finish();
+
+			if ( _this.sortObjects === true ) {
+
+				currentRenderList.sort( _opaqueSort, _transparentSort );
+
+			}
+
+			//
+
+			this.info.render.frame ++;
+
+			if ( _clippingEnabled === true ) clipping.beginShadows();
+
+			const shadowsArray = currentRenderState.state.shadowsArray;
+
+			shadowMap.render( shadowsArray, scene, camera );
+
+			if ( _clippingEnabled === true ) clipping.endShadows();
+
+			//
+
+			if ( this.info.autoReset === true ) this.info.reset();
+
+
+			//
+
+			background.render( currentRenderList, scene );
+
+			// render scene
+
+			currentRenderState.setupLights( _this._useLegacyLights );
+
+			if ( camera.isArrayCamera ) {
+
+				const cameras = camera.cameras;
+
+				for ( let i = 0, l = cameras.length; i < l; i ++ ) {
+
+					const camera2 = cameras[ i ];
+
+					renderScene( currentRenderList, scene, camera2, camera2.viewport );
+
+				}
+
+			} else {
+
+				renderScene( currentRenderList, scene, camera );
+
+			}
+
+			//
+
+			if ( _currentRenderTarget !== null ) {
+
+				// resolve multisample renderbuffers to a single-sample texture if necessary
+
+				textures.updateMultisampleRenderTarget( _currentRenderTarget );
+
+				// Generate mipmap if we're using any kind of mipmap filtering
+
+				textures.updateRenderTargetMipmap( _currentRenderTarget );
+
+			}
+
+			//
+
+			if ( scene.isScene === true ) scene.onAfterRender( _this, scene, camera );
+
+			// _gl.finish();
+
+			bindingStates.resetDefaultState();
+			_currentMaterialId = - 1;
+			_currentCamera = null;
+
+			renderStateStack.pop();
+
+			if ( renderStateStack.length > 0 ) {
+
+				currentRenderState = renderStateStack[ renderStateStack.length - 1 ];
+
+			} else {
+
+				currentRenderState = null;
+
+			}
+
+			renderListStack.pop();
+
+			if ( renderListStack.length > 0 ) {
+
+				currentRenderList = renderListStack[ renderListStack.length - 1 ];
+
+			} else {
+
+				currentRenderList = null;
+
+			}
+
+		};
+
+		function projectObject( object, camera, groupOrder, sortObjects ) {
+
+			if ( object.visible === false ) return;
+
+			const visible = object.layers.test( camera.layers );
+
+			if ( visible ) {
+
+				if ( object.isGroup ) {
+
+					groupOrder = object.renderOrder;
+
+				} else if ( object.isLOD ) {
+
+					if ( object.autoUpdate === true ) object.update( camera );
+
+				} else if ( object.isLight ) {
+
+					currentRenderState.pushLight( object );
+
+					if ( object.castShadow ) {
+
+						currentRenderState.pushShadow( object );
+
+					}
+
+				} else if ( object.isSprite ) {
+
+					if ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {
+
+						if ( sortObjects ) {
+
+							_vector3.setFromMatrixPosition( object.matrixWorld )
+								.applyMatrix4( _projScreenMatrix );
+
+						}
+
+						const geometry = objects.update( object );
+						const material = object.material;
+
+						if ( material.visible ) {
+
+							currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+
+						}
+
+					}
+
+				} else if ( object.isMesh || object.isLine || object.isPoints ) {
+
+					if ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {
+
+						const geometry = objects.update( object );
+						const material = object.material;
+
+						if ( sortObjects ) {
+
+							if ( object.boundingSphere !== undefined ) {
+
+								if ( object.boundingSphere === null ) object.computeBoundingSphere();
+								_vector3.copy( object.boundingSphere.center );
+
+							} else {
+
+								if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+								_vector3.copy( geometry.boundingSphere.center );
+
+							}
+
+							_vector3
+								.applyMatrix4( object.matrixWorld )
+								.applyMatrix4( _projScreenMatrix );
+
+						}
+
+						if ( Array.isArray( material ) ) {
+
+							const groups = geometry.groups;
+
+							for ( let i = 0, l = groups.length; i < l; i ++ ) {
+
+								const group = groups[ i ];
+								const groupMaterial = material[ group.materialIndex ];
+
+								if ( groupMaterial && groupMaterial.visible ) {
+
+									currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector3.z, group );
+
+								}
+
+							}
+
+						} else if ( material.visible ) {
+
+							currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			const children = object.children;
+
+			for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+				projectObject( children[ i ], camera, groupOrder, sortObjects );
+
+			}
+
+		}
+
+		function renderScene( currentRenderList, scene, camera, viewport ) {
+
+			const opaqueObjects = currentRenderList.opaque;
+			const transmissiveObjects = currentRenderList.transmissive;
+			const transparentObjects = currentRenderList.transparent;
+
+			currentRenderState.setupLightsView( camera );
+
+			if ( _clippingEnabled === true ) clipping.setGlobalState( _this.clippingPlanes, camera );
+
+			if ( transmissiveObjects.length > 0 ) renderTransmissionPass( opaqueObjects, transmissiveObjects, scene, camera );
+
+			if ( viewport ) state.viewport( _currentViewport.copy( viewport ) );
+
+			if ( opaqueObjects.length > 0 ) renderObjects( opaqueObjects, scene, camera );
+			if ( transmissiveObjects.length > 0 ) renderObjects( transmissiveObjects, scene, camera );
+			if ( transparentObjects.length > 0 ) renderObjects( transparentObjects, scene, camera );
+
+			// Ensure depth buffer writing is enabled so it can be cleared on next render
+
+			state.buffers.depth.setTest( true );
+			state.buffers.depth.setMask( true );
+			state.buffers.color.setMask( true );
+
+			state.setPolygonOffset( false );
+
+		}
+
+		function renderTransmissionPass( opaqueObjects, transmissiveObjects, scene, camera ) {
+
+			const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
+
+			if ( overrideMaterial !== null ) {
+
+				return;
+
+			}
+
+			const isWebGL2 = capabilities.isWebGL2;
+
+			if ( _transmissionRenderTarget === null ) {
+
+				_transmissionRenderTarget = new WebGLRenderTarget( 1, 1, {
+					generateMipmaps: true,
+					type: extensions.has( 'EXT_color_buffer_half_float' ) ? HalfFloatType : UnsignedByteType,
+					minFilter: LinearMipmapLinearFilter,
+					samples: ( isWebGL2 ) ? 4 : 0
+				} );
+
+				// debug
+
+				/*
+				const geometry = new PlaneGeometry();
+				const material = new MeshBasicMaterial( { map: _transmissionRenderTarget.texture } );
+
+				const mesh = new Mesh( geometry, material );
+				scene.add( mesh );
+				*/
+
+			}
+
+			_this.getDrawingBufferSize( _vector2 );
+
+			if ( isWebGL2 ) {
+
+				_transmissionRenderTarget.setSize( _vector2.x, _vector2.y );
+
+			} else {
+
+				_transmissionRenderTarget.setSize( floorPowerOfTwo( _vector2.x ), floorPowerOfTwo( _vector2.y ) );
+
+			}
+
+			//
+
+			const currentRenderTarget = _this.getRenderTarget();
+			_this.setRenderTarget( _transmissionRenderTarget );
+
+			_this.getClearColor( _currentClearColor );
+			_currentClearAlpha = _this.getClearAlpha();
+			if ( _currentClearAlpha < 1 ) _this.setClearColor( 0xffffff, 0.5 );
+
+			_this.clear();
+
+			// Turn off the features which can affect the frag color for opaque objects pass.
+			// Otherwise they are applied twice in opaque objects pass and transmission objects pass.
+			const currentToneMapping = _this.toneMapping;
+			_this.toneMapping = NoToneMapping;
+
+			renderObjects( opaqueObjects, scene, camera );
+
+			textures.updateMultisampleRenderTarget( _transmissionRenderTarget );
+			textures.updateRenderTargetMipmap( _transmissionRenderTarget );
+
+			let renderTargetNeedsUpdate = false;
+
+			for ( let i = 0, l = transmissiveObjects.length; i < l; i ++ ) {
+
+				const renderItem = transmissiveObjects[ i ];
+
+				const object = renderItem.object;
+				const geometry = renderItem.geometry;
+				const material = renderItem.material;
+				const group = renderItem.group;
+
+				if ( material.side === DoubleSide && object.layers.test( camera.layers ) ) {
+
+					const currentSide = material.side;
+
+					material.side = BackSide;
+					material.needsUpdate = true;
+
+					renderObject( object, scene, camera, geometry, material, group );
+
+					material.side = currentSide;
+					material.needsUpdate = true;
+
+					renderTargetNeedsUpdate = true;
+
+				}
+
+			}
+
+			if ( renderTargetNeedsUpdate === true ) {
+
+				textures.updateMultisampleRenderTarget( _transmissionRenderTarget );
+				textures.updateRenderTargetMipmap( _transmissionRenderTarget );
+
+			}
+
+			_this.setRenderTarget( currentRenderTarget );
+
+			_this.setClearColor( _currentClearColor, _currentClearAlpha );
+
+			_this.toneMapping = currentToneMapping;
+
+		}
+
+		function renderObjects( renderList, scene, camera ) {
+
+			const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
+
+			for ( let i = 0, l = renderList.length; i < l; i ++ ) {
+
+				const renderItem = renderList[ i ];
+
+				const object = renderItem.object;
+				const geometry = renderItem.geometry;
+				const material = overrideMaterial === null ? renderItem.material : overrideMaterial;
+				const group = renderItem.group;
+
+				if ( object.layers.test( camera.layers ) ) {
+
+					renderObject( object, scene, camera, geometry, material, group );
+
+				}
+
+			}
+
+		}
+
+		function renderObject( object, scene, camera, geometry, material, group ) {
+
+			object.onBeforeRender( _this, scene, camera, geometry, material, group );
+
+			object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
+			object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
+
+			material.onBeforeRender( _this, scene, camera, geometry, object, group );
+
+			if ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {
+
+				material.side = BackSide;
+				material.needsUpdate = true;
+				_this.renderBufferDirect( camera, scene, geometry, material, object, group );
+
+				material.side = FrontSide;
+				material.needsUpdate = true;
+				_this.renderBufferDirect( camera, scene, geometry, material, object, group );
+
+				material.side = DoubleSide;
+
+			} else {
+
+				_this.renderBufferDirect( camera, scene, geometry, material, object, group );
+
+			}
+
+			object.onAfterRender( _this, scene, camera, geometry, material, group );
+
+		}
+
+		function getProgram( material, scene, object ) {
+
+			if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
+
+			const materialProperties = properties.get( material );
+
+			const lights = currentRenderState.state.lights;
+			const shadowsArray = currentRenderState.state.shadowsArray;
+
+			const lightsStateVersion = lights.state.version;
+
+			const parameters = programCache.getParameters( material, lights.state, shadowsArray, scene, object );
+			const programCacheKey = programCache.getProgramCacheKey( parameters );
+
+			let programs = materialProperties.programs;
+
+			// always update environment and fog - changing these trigger an getProgram call, but it's possible that the program doesn't change
+
+			materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
+			materialProperties.fog = scene.fog;
+			materialProperties.envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || materialProperties.environment );
+
+			if ( programs === undefined ) {
+
+				// new material
+
+				material.addEventListener( 'dispose', onMaterialDispose );
+
+				programs = new Map();
+				materialProperties.programs = programs;
+
+			}
+
+			let program = programs.get( programCacheKey );
+
+			if ( program !== undefined ) {
+
+				// early out if program and light state is identical
+
+				if ( materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion ) {
+
+					updateCommonMaterialProperties( material, parameters );
+
+					return program;
+
+				}
+
+			} else {
+
+				parameters.uniforms = programCache.getUniforms( material );
+
+				material.onBuild( object, parameters, _this );
+
+				material.onBeforeCompile( parameters, _this );
+
+				program = programCache.acquireProgram( parameters, programCacheKey );
+				programs.set( programCacheKey, program );
+
+				materialProperties.uniforms = parameters.uniforms;
+
+			}
+
+			const uniforms = materialProperties.uniforms;
+
+			if ( ( ! material.isShaderMaterial && ! material.isRawShaderMaterial ) || material.clipping === true ) {
+
+				uniforms.clippingPlanes = clipping.uniform;
+
+			}
+
+			updateCommonMaterialProperties( material, parameters );
+
+			// store the light setup it was created for
+
+			materialProperties.needsLights = materialNeedsLights( material );
+			materialProperties.lightsStateVersion = lightsStateVersion;
+
+			if ( materialProperties.needsLights ) {
+
+				// wire up the material to this renderer's lighting state
+
+				uniforms.ambientLightColor.value = lights.state.ambient;
+				uniforms.lightProbe.value = lights.state.probe;
+				uniforms.directionalLights.value = lights.state.directional;
+				uniforms.directionalLightShadows.value = lights.state.directionalShadow;
+				uniforms.spotLights.value = lights.state.spot;
+				uniforms.spotLightShadows.value = lights.state.spotShadow;
+				uniforms.rectAreaLights.value = lights.state.rectArea;
+				uniforms.ltc_1.value = lights.state.rectAreaLTC1;
+				uniforms.ltc_2.value = lights.state.rectAreaLTC2;
+				uniforms.pointLights.value = lights.state.point;
+				uniforms.pointLightShadows.value = lights.state.pointShadow;
+				uniforms.hemisphereLights.value = lights.state.hemi;
+
+				uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
+				uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
+				uniforms.spotShadowMap.value = lights.state.spotShadowMap;
+				uniforms.spotLightMatrix.value = lights.state.spotLightMatrix;
+				uniforms.spotLightMap.value = lights.state.spotLightMap;
+				uniforms.pointShadowMap.value = lights.state.pointShadowMap;
+				uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
+				// TODO (abelnation): add area lights shadow info to uniforms
+
+			}
+
+			materialProperties.currentProgram = program;
+			materialProperties.uniformsList = null;
+
+			return program;
+
+		}
+
+		function getUniformList( materialProperties ) {
+
+			if ( materialProperties.uniformsList === null ) {
+
+				const progUniforms = materialProperties.currentProgram.getUniforms();
+				materialProperties.uniformsList = WebGLUniforms.seqWithValue( progUniforms.seq, materialProperties.uniforms );
+
+			}
+
+			return materialProperties.uniformsList;
+
+		}
+
+		function updateCommonMaterialProperties( material, parameters ) {
+
+			const materialProperties = properties.get( material );
+
+			materialProperties.outputColorSpace = parameters.outputColorSpace;
+			materialProperties.batching = parameters.batching;
+			materialProperties.instancing = parameters.instancing;
+			materialProperties.instancingColor = parameters.instancingColor;
+			materialProperties.skinning = parameters.skinning;
+			materialProperties.morphTargets = parameters.morphTargets;
+			materialProperties.morphNormals = parameters.morphNormals;
+			materialProperties.morphColors = parameters.morphColors;
+			materialProperties.morphTargetsCount = parameters.morphTargetsCount;
+			materialProperties.numClippingPlanes = parameters.numClippingPlanes;
+			materialProperties.numIntersection = parameters.numClipIntersection;
+			materialProperties.vertexAlphas = parameters.vertexAlphas;
+			materialProperties.vertexTangents = parameters.vertexTangents;
+			materialProperties.toneMapping = parameters.toneMapping;
+
+		}
+
+		function setProgram( camera, scene, geometry, material, object ) {
+
+			if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
+
+			textures.resetTextureUnits();
+
+			const fog = scene.fog;
+			const environment = material.isMeshStandardMaterial ? scene.environment : null;
+			const colorSpace = ( _currentRenderTarget === null ) ? _this.outputColorSpace : ( _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace );
+			const envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || environment );
+			const vertexAlphas = material.vertexColors === true && !! geometry.attributes.color && geometry.attributes.color.itemSize === 4;
+			const vertexTangents = !! geometry.attributes.tangent && ( !! material.normalMap || material.anisotropy > 0 );
+			const morphTargets = !! geometry.morphAttributes.position;
+			const morphNormals = !! geometry.morphAttributes.normal;
+			const morphColors = !! geometry.morphAttributes.color;
+
+			let toneMapping = NoToneMapping;
+
+			if ( material.toneMapped ) {
+
+				if ( _currentRenderTarget === null || _currentRenderTarget.isXRRenderTarget === true ) {
+
+					toneMapping = _this.toneMapping;
+
+				}
+
+			}
+
+			const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
+			const morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;
+
+			const materialProperties = properties.get( material );
+			const lights = currentRenderState.state.lights;
+
+			if ( _clippingEnabled === true ) {
+
+				if ( _localClippingEnabled === true || camera !== _currentCamera ) {
+
+					const useCache =
+						camera === _currentCamera &&
+						material.id === _currentMaterialId;
+
+					// we might want to call this function with some ClippingGroup
+					// object instead of the material, once it becomes feasible
+					// (#8465, #8379)
+					clipping.setState( material, camera, useCache );
+
+				}
+
+			}
+
+			//
+
+			let needsProgramChange = false;
+
+			if ( material.version === materialProperties.__version ) {
+
+				if ( materialProperties.needsLights && ( materialProperties.lightsStateVersion !== lights.state.version ) ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.outputColorSpace !== colorSpace ) {
+
+					needsProgramChange = true;
+
+				} else if ( object.isBatchedMesh && materialProperties.batching === false ) {
+
+					needsProgramChange = true;
+
+				} else if ( ! object.isBatchedMesh && materialProperties.batching === true ) {
+
+					needsProgramChange = true;
+
+				} else if ( object.isInstancedMesh && materialProperties.instancing === false ) {
+
+					needsProgramChange = true;
+
+				} else if ( ! object.isInstancedMesh && materialProperties.instancing === true ) {
+
+					needsProgramChange = true;
+
+				} else if ( object.isSkinnedMesh && materialProperties.skinning === false ) {
+
+					needsProgramChange = true;
+
+				} else if ( ! object.isSkinnedMesh && materialProperties.skinning === true ) {
+
+					needsProgramChange = true;
+
+				} else if ( object.isInstancedMesh && materialProperties.instancingColor === true && object.instanceColor === null ) {
+
+					needsProgramChange = true;
+
+				} else if ( object.isInstancedMesh && materialProperties.instancingColor === false && object.instanceColor !== null ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.envMap !== envMap ) {
+
+					needsProgramChange = true;
+
+				} else if ( material.fog === true && materialProperties.fog !== fog ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.numClippingPlanes !== undefined &&
+					( materialProperties.numClippingPlanes !== clipping.numPlanes ||
+					materialProperties.numIntersection !== clipping.numIntersection ) ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.vertexAlphas !== vertexAlphas ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.vertexTangents !== vertexTangents ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.morphTargets !== morphTargets ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.morphNormals !== morphNormals ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.morphColors !== morphColors ) {
+
+					needsProgramChange = true;
+
+				} else if ( materialProperties.toneMapping !== toneMapping ) {
+
+					needsProgramChange = true;
+
+				} else if ( capabilities.isWebGL2 === true && materialProperties.morphTargetsCount !== morphTargetsCount ) {
+
+					needsProgramChange = true;
+
+				}
+
+			} else {
+
+				needsProgramChange = true;
+				materialProperties.__version = material.version;
+
+			}
+
+			//
+
+			let program = materialProperties.currentProgram;
+
+			if ( needsProgramChange === true ) {
+
+				program = getProgram( material, scene, object );
+
+			}
+
+			let refreshProgram = false;
+			let refreshMaterial = false;
+			let refreshLights = false;
+
+			const p_uniforms = program.getUniforms(),
+				m_uniforms = materialProperties.uniforms;
+
+			if ( state.useProgram( program.program ) ) {
+
+				refreshProgram = true;
+				refreshMaterial = true;
+				refreshLights = true;
+
+			}
+
+			if ( material.id !== _currentMaterialId ) {
+
+				_currentMaterialId = material.id;
+
+				refreshMaterial = true;
+
+			}
+
+			if ( refreshProgram || _currentCamera !== camera ) {
+
+				// common camera uniforms
+
+				p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );
+				p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
+
+				const uCamPos = p_uniforms.map.cameraPosition;
+
+				if ( uCamPos !== undefined ) {
+
+					uCamPos.setValue( _gl, _vector3.setFromMatrixPosition( camera.matrixWorld ) );
+
+				}
+
+				if ( capabilities.logarithmicDepthBuffer ) {
+
+					p_uniforms.setValue( _gl, 'logDepthBufFC',
+						2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
+
+				}
+
+				// consider moving isOrthographic to UniformLib and WebGLMaterials, see https://github.com/mrdoob/three.js/pull/26467#issuecomment-1645185067
+
+				if ( material.isMeshPhongMaterial ||
+					material.isMeshToonMaterial ||
+					material.isMeshLambertMaterial ||
+					material.isMeshBasicMaterial ||
+					material.isMeshStandardMaterial ||
+					material.isShaderMaterial ) {
+
+					p_uniforms.setValue( _gl, 'isOrthographic', camera.isOrthographicCamera === true );
+
+				}
+
+				if ( _currentCamera !== camera ) {
+
+					_currentCamera = camera;
+
+					// lighting uniforms depend on the camera so enforce an update
+					// now, in case this material supports lights - or later, when
+					// the next material that does gets activated:
+
+					refreshMaterial = true;		// set to true on material change
+					refreshLights = true;		// remains set until update done
+
+				}
+
+			}
+
+			// skinning and morph target uniforms must be set even if material didn't change
+			// auto-setting of texture unit for bone and morph texture must go before other textures
+			// otherwise textures used for skinning and morphing can take over texture units reserved for other material textures
+
+			if ( object.isSkinnedMesh ) {
+
+				p_uniforms.setOptional( _gl, object, 'bindMatrix' );
+				p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );
+
+				const skeleton = object.skeleton;
+
+				if ( skeleton ) {
+
+					if ( capabilities.floatVertexTextures ) {
+
+						if ( skeleton.boneTexture === null ) skeleton.computeBoneTexture();
+
+						p_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture, textures );
+
+					} else {
+
+						console.warn( 'THREE.WebGLRenderer: SkinnedMesh can only be used with WebGL 2. With WebGL 1 OES_texture_float and vertex textures support is required.' );
+
+					}
+
+				}
+
+			}
+
+			if ( object.isBatchedMesh ) {
+
+				p_uniforms.setOptional( _gl, object, 'batchingTexture' );
+				p_uniforms.setValue( _gl, 'batchingTexture', object._matricesTexture, textures );
+
+			}
+
+			const morphAttributes = geometry.morphAttributes;
+
+			if ( morphAttributes.position !== undefined || morphAttributes.normal !== undefined || ( morphAttributes.color !== undefined && capabilities.isWebGL2 === true ) ) {
+
+				morphtargets.update( object, geometry, program );
+
+			}
+
+			if ( refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow ) {
+
+				materialProperties.receiveShadow = object.receiveShadow;
+				p_uniforms.setValue( _gl, 'receiveShadow', object.receiveShadow );
+
+			}
+
+			// https://github.com/mrdoob/three.js/pull/24467#issuecomment-1209031512
+
+			if ( material.isMeshGouraudMaterial && material.envMap !== null ) {
+
+				m_uniforms.envMap.value = envMap;
+
+				m_uniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) ? - 1 : 1;
+
+			}
+
+			if ( refreshMaterial ) {
+
+				p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );
+
+				if ( materialProperties.needsLights ) {
+
+					// the current material requires lighting info
+
+					// note: all lighting uniforms are always set correctly
+					// they simply reference the renderer's state for their
+					// values
+					//
+					// use the current material's .needsUpdate flags to set
+					// the GL state when required
+
+					markUniformsLightsNeedsUpdate( m_uniforms, refreshLights );
+
+				}
+
+				// refresh uniforms common to several materials
+
+				if ( fog && material.fog === true ) {
+
+					materials.refreshFogUniforms( m_uniforms, fog );
+
+				}
+
+				materials.refreshMaterialUniforms( m_uniforms, material, _pixelRatio, _height, _transmissionRenderTarget );
+
+				WebGLUniforms.upload( _gl, getUniformList( materialProperties ), m_uniforms, textures );
+
+			}
+
+			if ( material.isShaderMaterial && material.uniformsNeedUpdate === true ) {
+
+				WebGLUniforms.upload( _gl, getUniformList( materialProperties ), m_uniforms, textures );
+				material.uniformsNeedUpdate = false;
+
+			}
+
+			if ( material.isSpriteMaterial ) {
+
+				p_uniforms.setValue( _gl, 'center', object.center );
+
+			}
+
+			// common matrices
+
+			p_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );
+			p_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );
+			p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );
+
+			// UBOs
+
+			if ( material.isShaderMaterial || material.isRawShaderMaterial ) {
+
+				const groups = material.uniformsGroups;
+
+				for ( let i = 0, l = groups.length; i < l; i ++ ) {
+
+					if ( capabilities.isWebGL2 ) {
+
+						const group = groups[ i ];
+
+						uniformsGroups.update( group, program );
+						uniformsGroups.bind( group, program );
+
+					} else {
+
+						console.warn( 'THREE.WebGLRenderer: Uniform Buffer Objects can only be used with WebGL 2.' );
+
+					}
+
+				}
+
+			}
+
+			return program;
+
+		}
+
+		// If uniforms are marked as clean, they don't need to be loaded to the GPU.
+
+		function markUniformsLightsNeedsUpdate( uniforms, value ) {
+
+			uniforms.ambientLightColor.needsUpdate = value;
+			uniforms.lightProbe.needsUpdate = value;
+
+			uniforms.directionalLights.needsUpdate = value;
+			uniforms.directionalLightShadows.needsUpdate = value;
+			uniforms.pointLights.needsUpdate = value;
+			uniforms.pointLightShadows.needsUpdate = value;
+			uniforms.spotLights.needsUpdate = value;
+			uniforms.spotLightShadows.needsUpdate = value;
+			uniforms.rectAreaLights.needsUpdate = value;
+			uniforms.hemisphereLights.needsUpdate = value;
+
+		}
+
+		function materialNeedsLights( material ) {
+
+			return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial ||
+				material.isMeshStandardMaterial || material.isShadowMaterial ||
+				( material.isShaderMaterial && material.lights === true );
+
+		}
+
+		this.getActiveCubeFace = function () {
+
+			return _currentActiveCubeFace;
+
+		};
+
+		this.getActiveMipmapLevel = function () {
+
+			return _currentActiveMipmapLevel;
+
+		};
+
+		this.getRenderTarget = function () {
+
+			return _currentRenderTarget;
+
+		};
+
+		this.setRenderTargetTextures = function ( renderTarget, colorTexture, depthTexture ) {
+
+			properties.get( renderTarget.texture ).__webglTexture = colorTexture;
+			properties.get( renderTarget.depthTexture ).__webglTexture = depthTexture;
+
+			const renderTargetProperties = properties.get( renderTarget );
+			renderTargetProperties.__hasExternalTextures = true;
+
+			if ( renderTargetProperties.__hasExternalTextures ) {
+
+				renderTargetProperties.__autoAllocateDepthBuffer = depthTexture === undefined;
+
+				if ( ! renderTargetProperties.__autoAllocateDepthBuffer ) {
+
+					// The multisample_render_to_texture extension doesn't work properly if there
+					// are midframe flushes and an external depth buffer. Disable use of the extension.
+					if ( extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true ) {
+
+						console.warn( 'THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided' );
+						renderTargetProperties.__useRenderToTexture = false;
+
+					}
+
+				}
+
+			}
+
+		};
+
+		this.setRenderTargetFramebuffer = function ( renderTarget, defaultFramebuffer ) {
+
+			const renderTargetProperties = properties.get( renderTarget );
+			renderTargetProperties.__webglFramebuffer = defaultFramebuffer;
+			renderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === undefined;
+
+		};
+
+		this.setRenderTarget = function ( renderTarget, activeCubeFace = 0, activeMipmapLevel = 0 ) {
+
+			_currentRenderTarget = renderTarget;
+			_currentActiveCubeFace = activeCubeFace;
+			_currentActiveMipmapLevel = activeMipmapLevel;
+
+			let useDefaultFramebuffer = true;
+			let framebuffer = null;
+			let isCube = false;
+			let isRenderTarget3D = false;
+
+			if ( renderTarget ) {
+
+				const renderTargetProperties = properties.get( renderTarget );
+
+				if ( renderTargetProperties.__useDefaultFramebuffer !== undefined ) {
+
+					// We need to make sure to rebind the framebuffer.
+					state.bindFramebuffer( _gl.FRAMEBUFFER, null );
+					useDefaultFramebuffer = false;
+
+				} else if ( renderTargetProperties.__webglFramebuffer === undefined ) {
+
+					textures.setupRenderTarget( renderTarget );
+
+				} else if ( renderTargetProperties.__hasExternalTextures ) {
+
+					// Color and depth texture must be rebound in order for the swapchain to update.
+					textures.rebindTextures( renderTarget, properties.get( renderTarget.texture ).__webglTexture, properties.get( renderTarget.depthTexture ).__webglTexture );
+
+				}
+
+				const texture = renderTarget.texture;
+
+				if ( texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+					isRenderTarget3D = true;
+
+				}
+
+				const __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;
+
+				if ( renderTarget.isWebGLCubeRenderTarget ) {
+
+					if ( Array.isArray( __webglFramebuffer[ activeCubeFace ] ) ) {
+
+						framebuffer = __webglFramebuffer[ activeCubeFace ][ activeMipmapLevel ];
+
+					} else {
+
+						framebuffer = __webglFramebuffer[ activeCubeFace ];
+
+					}
+
+					isCube = true;
+
+				} else if ( ( capabilities.isWebGL2 && renderTarget.samples > 0 ) && textures.useMultisampledRTT( renderTarget ) === false ) {
+
+					framebuffer = properties.get( renderTarget ).__webglMultisampledFramebuffer;
+
+				} else {
+
+					if ( Array.isArray( __webglFramebuffer ) ) {
+
+						framebuffer = __webglFramebuffer[ activeMipmapLevel ];
+
+					} else {
+
+						framebuffer = __webglFramebuffer;
+
+					}
+
+				}
+
+				_currentViewport.copy( renderTarget.viewport );
+				_currentScissor.copy( renderTarget.scissor );
+				_currentScissorTest = renderTarget.scissorTest;
+
+			} else {
+
+				_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor();
+				_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor();
+				_currentScissorTest = _scissorTest;
+
+			}
+
+			const framebufferBound = state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+			if ( framebufferBound && capabilities.drawBuffers && useDefaultFramebuffer ) {
+
+				state.drawBuffers( renderTarget, framebuffer );
+
+			}
+
+			state.viewport( _currentViewport );
+			state.scissor( _currentScissor );
+			state.setScissorTest( _currentScissorTest );
+
+			if ( isCube ) {
+
+				const textureProperties = properties.get( renderTarget.texture );
+				_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel );
+
+			} else if ( isRenderTarget3D ) {
+
+				const textureProperties = properties.get( renderTarget.texture );
+				const layer = activeCubeFace || 0;
+				_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel || 0, layer );
+
+			}
+
+			_currentMaterialId = - 1; // reset current material to ensure correct uniform bindings
+
+		};
+
+		this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {
+
+			if ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {
+
+				console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
+				return;
+
+			}
+
+			let framebuffer = properties.get( renderTarget ).__webglFramebuffer;
+
+			if ( renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined ) {
+
+				framebuffer = framebuffer[ activeCubeFaceIndex ];
+
+			}
+
+			if ( framebuffer ) {
+
+				state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+				try {
+
+					const texture = renderTarget.texture;
+					const textureFormat = texture.format;
+					const textureType = texture.type;
+
+					if ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {
+
+						console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
+						return;
+
+					}
+
+					const halfFloatSupportedByExt = ( textureType === HalfFloatType ) && ( extensions.has( 'EXT_color_buffer_half_float' ) || ( capabilities.isWebGL2 && extensions.has( 'EXT_color_buffer_float' ) ) );
+
+					if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // Edge and Chrome Mac < 52 (#9513)
+						! ( textureType === FloatType && ( capabilities.isWebGL2 || extensions.has( 'OES_texture_float' ) || extensions.has( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox
+						! halfFloatSupportedByExt ) {
+
+						console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );
+						return;
+
+					}
+
+					// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
+
+					if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {
+
+						_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );
+
+					}
+
+				} finally {
+
+					// restore framebuffer of current render target if necessary
+
+					const framebuffer = ( _currentRenderTarget !== null ) ? properties.get( _currentRenderTarget ).__webglFramebuffer : null;
+					state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+				}
+
+			}
+
+		};
+
+		this.copyFramebufferToTexture = function ( position, texture, level = 0 ) {
+
+			const levelScale = Math.pow( 2, - level );
+			const width = Math.floor( texture.image.width * levelScale );
+			const height = Math.floor( texture.image.height * levelScale );
+
+			textures.setTexture2D( texture, 0 );
+
+			_gl.copyTexSubImage2D( _gl.TEXTURE_2D, level, 0, 0, position.x, position.y, width, height );
+
+			state.unbindTexture();
+
+		};
+
+		this.copyTextureToTexture = function ( position, srcTexture, dstTexture, level = 0 ) {
+
+			const width = srcTexture.image.width;
+			const height = srcTexture.image.height;
+			const glFormat = utils.convert( dstTexture.format );
+			const glType = utils.convert( dstTexture.type );
+
+			textures.setTexture2D( dstTexture, 0 );
+
+			// As another texture upload may have changed pixelStorei
+			// parameters, make sure they are correct for the dstTexture
+			_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );
+			_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );
+			_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );
+
+			if ( srcTexture.isDataTexture ) {
+
+				_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data );
+
+			} else {
+
+				if ( srcTexture.isCompressedTexture ) {
+
+					_gl.compressedTexSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, srcTexture.mipmaps[ 0 ].width, srcTexture.mipmaps[ 0 ].height, glFormat, srcTexture.mipmaps[ 0 ].data );
+
+				} else {
+
+					_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, glFormat, glType, srcTexture.image );
+
+				}
+
+			}
+
+			// Generate mipmaps only when copying level 0
+			if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( _gl.TEXTURE_2D );
+
+			state.unbindTexture();
+
+		};
+
+		this.copyTextureToTexture3D = function ( sourceBox, position, srcTexture, dstTexture, level = 0 ) {
+
+			if ( _this.isWebGL1Renderer ) {
+
+				console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.' );
+				return;
+
+			}
+
+			const width = sourceBox.max.x - sourceBox.min.x + 1;
+			const height = sourceBox.max.y - sourceBox.min.y + 1;
+			const depth = sourceBox.max.z - sourceBox.min.z + 1;
+			const glFormat = utils.convert( dstTexture.format );
+			const glType = utils.convert( dstTexture.type );
+			let glTarget;
+
+			if ( dstTexture.isData3DTexture ) {
+
+				textures.setTexture3D( dstTexture, 0 );
+				glTarget = _gl.TEXTURE_3D;
+
+			} else if ( dstTexture.isDataArrayTexture || dstTexture.isCompressedArrayTexture ) {
+
+				textures.setTexture2DArray( dstTexture, 0 );
+				glTarget = _gl.TEXTURE_2D_ARRAY;
+
+			} else {
+
+				console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.' );
+				return;
+
+			}
+
+			_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );
+			_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );
+			_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );
+
+			const unpackRowLen = _gl.getParameter( _gl.UNPACK_ROW_LENGTH );
+			const unpackImageHeight = _gl.getParameter( _gl.UNPACK_IMAGE_HEIGHT );
+			const unpackSkipPixels = _gl.getParameter( _gl.UNPACK_SKIP_PIXELS );
+			const unpackSkipRows = _gl.getParameter( _gl.UNPACK_SKIP_ROWS );
+			const unpackSkipImages = _gl.getParameter( _gl.UNPACK_SKIP_IMAGES );
+
+			const image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[ level ] : srcTexture.image;
+
+			_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, image.width );
+			_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, image.height );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, sourceBox.min.x );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, sourceBox.min.y );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, sourceBox.min.z );
+
+			if ( srcTexture.isDataTexture || srcTexture.isData3DTexture ) {
+
+				_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image.data );
+
+			} else {
+
+				if ( srcTexture.isCompressedArrayTexture ) {
+
+					console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture.' );
+					_gl.compressedTexSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, image.data );
+
+				} else {
+
+					_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image );
+
+				}
+
+			}
+
+			_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, unpackRowLen );
+			_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, unpackImageHeight );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, unpackSkipPixels );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, unpackSkipRows );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, unpackSkipImages );
+
+			// Generate mipmaps only when copying level 0
+			if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( glTarget );
+
+			state.unbindTexture();
+
+		};
+
+		this.initTexture = function ( texture ) {
+
+			if ( texture.isCubeTexture ) {
+
+				textures.setTextureCube( texture, 0 );
+
+			} else if ( texture.isData3DTexture ) {
+
+				textures.setTexture3D( texture, 0 );
+
+			} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+				textures.setTexture2DArray( texture, 0 );
+
+			} else {
+
+				textures.setTexture2D( texture, 0 );
+
+			}
+
+			state.unbindTexture();
+
+		};
+
+		this.resetState = function () {
+
+			_currentActiveCubeFace = 0;
+			_currentActiveMipmapLevel = 0;
+			_currentRenderTarget = null;
+
+			state.reset();
+			bindingStates.reset();
+
+		};
+
+		if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
+
+			__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );
+
+		}
+
+	}
+
+	get coordinateSystem() {
+
+		return WebGLCoordinateSystem;
+
+	}
+
+	get outputColorSpace() {
+
+		return this._outputColorSpace;
+
+	}
+
+	set outputColorSpace( colorSpace ) {
+
+		this._outputColorSpace = colorSpace;
+
+		const gl = this.getContext();
+		gl.drawingBufferColorSpace = colorSpace === DisplayP3ColorSpace ? 'display-p3' : 'srgb';
+		gl.unpackColorSpace = ColorManagement.workingColorSpace === LinearDisplayP3ColorSpace ? 'display-p3' : 'srgb';
+
+	}
+
+	get outputEncoding() { // @deprecated, r152
+
+		console.warn( 'THREE.WebGLRenderer: Property .outputEncoding has been removed. Use .outputColorSpace instead.' );
+		return this.outputColorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
+
+	}
+
+	set outputEncoding( encoding ) { // @deprecated, r152
+
+		console.warn( 'THREE.WebGLRenderer: Property .outputEncoding has been removed. Use .outputColorSpace instead.' );
+		this.outputColorSpace = encoding === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
+
+	}
+
+	get useLegacyLights() { // @deprecated, r155
+
+		console.warn( 'THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733.' );
+		return this._useLegacyLights;
+
+	}
+
+	set useLegacyLights( value ) { // @deprecated, r155
+
+		console.warn( 'THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733.' );
+		this._useLegacyLights = value;
+
+	}
+
+}
+
+class WebGL1Renderer extends WebGLRenderer {}
+
+WebGL1Renderer.prototype.isWebGL1Renderer = true;
+
+class FogExp2 {
+
+	constructor( color, density = 0.00025 ) {
+
+		this.isFogExp2 = true;
+
+		this.name = '';
+
+		this.color = new Color( color );
+		this.density = density;
+
+	}
+
+	clone() {
+
+		return new FogExp2( this.color, this.density );
+
+	}
+
+	toJSON( /* meta */ ) {
+
+		return {
+			type: 'FogExp2',
+			name: this.name,
+			color: this.color.getHex(),
+			density: this.density
+		};
+
+	}
+
+}
+
+class Fog {
+
+	constructor( color, near = 1, far = 1000 ) {
+
+		this.isFog = true;
+
+		this.name = '';
+
+		this.color = new Color( color );
+
+		this.near = near;
+		this.far = far;
+
+	}
+
+	clone() {
+
+		return new Fog( this.color, this.near, this.far );
+
+	}
+
+	toJSON( /* meta */ ) {
+
+		return {
+			type: 'Fog',
+			name: this.name,
+			color: this.color.getHex(),
+			near: this.near,
+			far: this.far
+		};
+
+	}
+
+}
+
+class Scene extends Object3D {
+
+	constructor() {
+
+		super();
+
+		this.isScene = true;
+
+		this.type = 'Scene';
+
+		this.background = null;
+		this.environment = null;
+		this.fog = null;
+
+		this.backgroundBlurriness = 0;
+		this.backgroundIntensity = 1;
+
+		this.overrideMaterial = null;
+
+		if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
+
+			__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );
+
+		}
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		if ( source.background !== null ) this.background = source.background.clone();
+		if ( source.environment !== null ) this.environment = source.environment.clone();
+		if ( source.fog !== null ) this.fog = source.fog.clone();
+
+		this.backgroundBlurriness = source.backgroundBlurriness;
+		this.backgroundIntensity = source.backgroundIntensity;
+
+		if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();
+
+		this.matrixAutoUpdate = source.matrixAutoUpdate;
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		if ( this.fog !== null ) data.object.fog = this.fog.toJSON();
+		if ( this.backgroundBlurriness > 0 ) data.object.backgroundBlurriness = this.backgroundBlurriness;
+		if ( this.backgroundIntensity !== 1 ) data.object.backgroundIntensity = this.backgroundIntensity;
+
+		return data;
+
+	}
+
+}
+
+class InterleavedBuffer {
+
+	constructor( array, stride ) {
+
+		this.isInterleavedBuffer = true;
+
+		this.array = array;
+		this.stride = stride;
+		this.count = array !== undefined ? array.length / stride : 0;
+
+		this.usage = StaticDrawUsage;
+		this._updateRange = { offset: 0, count: - 1 };
+		this.updateRanges = [];
+
+		this.version = 0;
+
+		this.uuid = generateUUID();
+
+	}
+
+	onUploadCallback() {}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+	get updateRange() {
+
+		console.warn( 'THREE.InterleavedBuffer: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159
+		return this._updateRange;
+
+	}
+
+	setUsage( value ) {
+
+		this.usage = value;
+
+		return this;
+
+	}
+
+	addUpdateRange( start, count ) {
+
+		this.updateRanges.push( { start, count } );
+
+	}
+
+	clearUpdateRanges() {
+
+		this.updateRanges.length = 0;
+
+	}
+
+	copy( source ) {
+
+		this.array = new source.array.constructor( source.array );
+		this.count = source.count;
+		this.stride = source.stride;
+		this.usage = source.usage;
+
+		return this;
+
+	}
+
+	copyAt( index1, attribute, index2 ) {
+
+		index1 *= this.stride;
+		index2 *= attribute.stride;
+
+		for ( let i = 0, l = this.stride; i < l; i ++ ) {
+
+			this.array[ index1 + i ] = attribute.array[ index2 + i ];
+
+		}
+
+		return this;
+
+	}
+
+	set( value, offset = 0 ) {
+
+		this.array.set( value, offset );
+
+		return this;
+
+	}
+
+	clone( data ) {
+
+		if ( data.arrayBuffers === undefined ) {
+
+			data.arrayBuffers = {};
+
+		}
+
+		if ( this.array.buffer._uuid === undefined ) {
+
+			this.array.buffer._uuid = generateUUID();
+
+		}
+
+		if ( data.arrayBuffers[ this.array.buffer._uuid ] === undefined ) {
+
+			data.arrayBuffers[ this.array.buffer._uuid ] = this.array.slice( 0 ).buffer;
+
+		}
+
+		const array = new this.array.constructor( data.arrayBuffers[ this.array.buffer._uuid ] );
+
+		const ib = new this.constructor( array, this.stride );
+		ib.setUsage( this.usage );
+
+		return ib;
+
+	}
+
+	onUpload( callback ) {
+
+		this.onUploadCallback = callback;
+
+		return this;
+
+	}
+
+	toJSON( data ) {
+
+		if ( data.arrayBuffers === undefined ) {
+
+			data.arrayBuffers = {};
+
+		}
+
+		// generate UUID for array buffer if necessary
+
+		if ( this.array.buffer._uuid === undefined ) {
+
+			this.array.buffer._uuid = generateUUID();
+
+		}
+
+		if ( data.arrayBuffers[ this.array.buffer._uuid ] === undefined ) {
+
+			data.arrayBuffers[ this.array.buffer._uuid ] = Array.from( new Uint32Array( this.array.buffer ) );
+
+		}
+
+		//
+
+		return {
+			uuid: this.uuid,
+			buffer: this.array.buffer._uuid,
+			type: this.array.constructor.name,
+			stride: this.stride
+		};
+
+	}
+
+}
+
+const _vector$6 = /*@__PURE__*/ new Vector3();
+
+class InterleavedBufferAttribute {
+
+	constructor( interleavedBuffer, itemSize, offset, normalized = false ) {
+
+		this.isInterleavedBufferAttribute = true;
+
+		this.name = '';
+
+		this.data = interleavedBuffer;
+		this.itemSize = itemSize;
+		this.offset = offset;
+
+		this.normalized = normalized;
+
+	}
+
+	get count() {
+
+		return this.data.count;
+
+	}
+
+	get array() {
+
+		return this.data.array;
+
+	}
+
+	set needsUpdate( value ) {
+
+		this.data.needsUpdate = value;
+
+	}
+
+	applyMatrix4( m ) {
+
+		for ( let i = 0, l = this.data.count; i < l; i ++ ) {
+
+			_vector$6.fromBufferAttribute( this, i );
+
+			_vector$6.applyMatrix4( m );
+
+			this.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );
+
+		}
+
+		return this;
+
+	}
+
+	applyNormalMatrix( m ) {
+
+		for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+			_vector$6.fromBufferAttribute( this, i );
+
+			_vector$6.applyNormalMatrix( m );
+
+			this.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );
+
+		}
+
+		return this;
+
+	}
+
+	transformDirection( m ) {
+
+		for ( let i = 0, l = this.count; i < l; i ++ ) {
+
+			_vector$6.fromBufferAttribute( this, i );
+
+			_vector$6.transformDirection( m );
+
+			this.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );
+
+		}
+
+		return this;
+
+	}
+
+	setX( index, x ) {
+
+		if ( this.normalized ) x = normalize( x, this.array );
+
+		this.data.array[ index * this.data.stride + this.offset ] = x;
+
+		return this;
+
+	}
+
+	setY( index, y ) {
+
+		if ( this.normalized ) y = normalize( y, this.array );
+
+		this.data.array[ index * this.data.stride + this.offset + 1 ] = y;
+
+		return this;
+
+	}
+
+	setZ( index, z ) {
+
+		if ( this.normalized ) z = normalize( z, this.array );
+
+		this.data.array[ index * this.data.stride + this.offset + 2 ] = z;
+
+		return this;
+
+	}
+
+	setW( index, w ) {
+
+		if ( this.normalized ) w = normalize( w, this.array );
+
+		this.data.array[ index * this.data.stride + this.offset + 3 ] = w;
+
+		return this;
+
+	}
+
+	getX( index ) {
+
+		let x = this.data.array[ index * this.data.stride + this.offset ];
+
+		if ( this.normalized ) x = denormalize( x, this.array );
+
+		return x;
+
+	}
+
+	getY( index ) {
+
+		let y = this.data.array[ index * this.data.stride + this.offset + 1 ];
+
+		if ( this.normalized ) y = denormalize( y, this.array );
+
+		return y;
+
+	}
+
+	getZ( index ) {
+
+		let z = this.data.array[ index * this.data.stride + this.offset + 2 ];
+
+		if ( this.normalized ) z = denormalize( z, this.array );
+
+		return z;
+
+	}
+
+	getW( index ) {
+
+		let w = this.data.array[ index * this.data.stride + this.offset + 3 ];
+
+		if ( this.normalized ) w = denormalize( w, this.array );
+
+		return w;
+
+	}
+
+	setXY( index, x, y ) {
+
+		index = index * this.data.stride + this.offset;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+
+		}
+
+		this.data.array[ index + 0 ] = x;
+		this.data.array[ index + 1 ] = y;
+
+		return this;
+
+	}
+
+	setXYZ( index, x, y, z ) {
+
+		index = index * this.data.stride + this.offset;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+			z = normalize( z, this.array );
+
+		}
+
+		this.data.array[ index + 0 ] = x;
+		this.data.array[ index + 1 ] = y;
+		this.data.array[ index + 2 ] = z;
+
+		return this;
+
+	}
+
+	setXYZW( index, x, y, z, w ) {
+
+		index = index * this.data.stride + this.offset;
+
+		if ( this.normalized ) {
+
+			x = normalize( x, this.array );
+			y = normalize( y, this.array );
+			z = normalize( z, this.array );
+			w = normalize( w, this.array );
+
+		}
+
+		this.data.array[ index + 0 ] = x;
+		this.data.array[ index + 1 ] = y;
+		this.data.array[ index + 2 ] = z;
+		this.data.array[ index + 3 ] = w;
+
+		return this;
+
+	}
+
+	clone( data ) {
+
+		if ( data === undefined ) {
+
+			console.log( 'THREE.InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data.' );
+
+			const array = [];
+
+			for ( let i = 0; i < this.count; i ++ ) {
+
+				const index = i * this.data.stride + this.offset;
+
+				for ( let j = 0; j < this.itemSize; j ++ ) {
+
+					array.push( this.data.array[ index + j ] );
+
+				}
+
+			}
+
+			return new BufferAttribute( new this.array.constructor( array ), this.itemSize, this.normalized );
+
+		} else {
+
+			if ( data.interleavedBuffers === undefined ) {
+
+				data.interleavedBuffers = {};
+
+			}
+
+			if ( data.interleavedBuffers[ this.data.uuid ] === undefined ) {
+
+				data.interleavedBuffers[ this.data.uuid ] = this.data.clone( data );
+
+			}
+
+			return new InterleavedBufferAttribute( data.interleavedBuffers[ this.data.uuid ], this.itemSize, this.offset, this.normalized );
+
+		}
+
+	}
+
+	toJSON( data ) {
+
+		if ( data === undefined ) {
+
+			console.log( 'THREE.InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data.' );
+
+			const array = [];
+
+			for ( let i = 0; i < this.count; i ++ ) {
+
+				const index = i * this.data.stride + this.offset;
+
+				for ( let j = 0; j < this.itemSize; j ++ ) {
+
+					array.push( this.data.array[ index + j ] );
+
+				}
+
+			}
+
+			// de-interleave data and save it as an ordinary buffer attribute for now
+
+			return {
+				itemSize: this.itemSize,
+				type: this.array.constructor.name,
+				array: array,
+				normalized: this.normalized
+			};
+
+		} else {
+
+			// save as true interleaved attribute
+
+			if ( data.interleavedBuffers === undefined ) {
+
+				data.interleavedBuffers = {};
+
+			}
+
+			if ( data.interleavedBuffers[ this.data.uuid ] === undefined ) {
+
+				data.interleavedBuffers[ this.data.uuid ] = this.data.toJSON( data );
+
+			}
+
+			return {
+				isInterleavedBufferAttribute: true,
+				itemSize: this.itemSize,
+				data: this.data.uuid,
+				offset: this.offset,
+				normalized: this.normalized
+			};
+
+		}
+
+	}
+
+}
+
+class SpriteMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isSpriteMaterial = true;
+
+		this.type = 'SpriteMaterial';
+
+		this.color = new Color( 0xffffff );
+
+		this.map = null;
+
+		this.alphaMap = null;
+
+		this.rotation = 0;
+
+		this.sizeAttenuation = true;
+
+		this.transparent = true;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+
+		this.alphaMap = source.alphaMap;
+
+		this.rotation = source.rotation;
+
+		this.sizeAttenuation = source.sizeAttenuation;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+let _geometry;
+
+const _intersectPoint = /*@__PURE__*/ new Vector3();
+const _worldScale = /*@__PURE__*/ new Vector3();
+const _mvPosition = /*@__PURE__*/ new Vector3();
+
+const _alignedPosition = /*@__PURE__*/ new Vector2();
+const _rotatedPosition = /*@__PURE__*/ new Vector2();
+const _viewWorldMatrix = /*@__PURE__*/ new Matrix4();
+
+const _vA = /*@__PURE__*/ new Vector3();
+const _vB = /*@__PURE__*/ new Vector3();
+const _vC = /*@__PURE__*/ new Vector3();
+
+const _uvA = /*@__PURE__*/ new Vector2();
+const _uvB = /*@__PURE__*/ new Vector2();
+const _uvC = /*@__PURE__*/ new Vector2();
+
+class Sprite extends Object3D {
+
+	constructor( material = new SpriteMaterial() ) {
+
+		super();
+
+		this.isSprite = true;
+
+		this.type = 'Sprite';
+
+		if ( _geometry === undefined ) {
+
+			_geometry = new BufferGeometry();
+
+			const float32Array = new Float32Array( [
+				- 0.5, - 0.5, 0, 0, 0,
+				0.5, - 0.5, 0, 1, 0,
+				0.5, 0.5, 0, 1, 1,
+				- 0.5, 0.5, 0, 0, 1
+			] );
+
+			const interleavedBuffer = new InterleavedBuffer( float32Array, 5 );
+
+			_geometry.setIndex( [ 0, 1, 2,	0, 2, 3 ] );
+			_geometry.setAttribute( 'position', new InterleavedBufferAttribute( interleavedBuffer, 3, 0, false ) );
+			_geometry.setAttribute( 'uv', new InterleavedBufferAttribute( interleavedBuffer, 2, 3, false ) );
+
+		}
+
+		this.geometry = _geometry;
+		this.material = material;
+
+		this.center = new Vector2( 0.5, 0.5 );
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		if ( raycaster.camera === null ) {
+
+			console.error( 'THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.' );
+
+		}
+
+		_worldScale.setFromMatrixScale( this.matrixWorld );
+
+		_viewWorldMatrix.copy( raycaster.camera.matrixWorld );
+		this.modelViewMatrix.multiplyMatrices( raycaster.camera.matrixWorldInverse, this.matrixWorld );
+
+		_mvPosition.setFromMatrixPosition( this.modelViewMatrix );
+
+		if ( raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false ) {
+
+			_worldScale.multiplyScalar( - _mvPosition.z );
+
+		}
+
+		const rotation = this.material.rotation;
+		let sin, cos;
+
+		if ( rotation !== 0 ) {
+
+			cos = Math.cos( rotation );
+			sin = Math.sin( rotation );
+
+		}
+
+		const center = this.center;
+
+		transformVertex( _vA.set( - 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
+		transformVertex( _vB.set( 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
+		transformVertex( _vC.set( 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
+
+		_uvA.set( 0, 0 );
+		_uvB.set( 1, 0 );
+		_uvC.set( 1, 1 );
+
+		// check first triangle
+		let intersect = raycaster.ray.intersectTriangle( _vA, _vB, _vC, false, _intersectPoint );
+
+		if ( intersect === null ) {
+
+			// check second triangle
+			transformVertex( _vB.set( - 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
+			_uvB.set( 0, 1 );
+
+			intersect = raycaster.ray.intersectTriangle( _vA, _vC, _vB, false, _intersectPoint );
+			if ( intersect === null ) {
+
+				return;
+
+			}
+
+		}
+
+		const distance = raycaster.ray.origin.distanceTo( _intersectPoint );
+
+		if ( distance < raycaster.near || distance > raycaster.far ) return;
+
+		intersects.push( {
+
+			distance: distance,
+			point: _intersectPoint.clone(),
+			uv: Triangle.getInterpolation( _intersectPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2() ),
+			face: null,
+			object: this
+
+		} );
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		if ( source.center !== undefined ) this.center.copy( source.center );
+
+		this.material = source.material;
+
+		return this;
+
+	}
+
+}
+
+function transformVertex( vertexPosition, mvPosition, center, scale, sin, cos ) {
+
+	// compute position in camera space
+	_alignedPosition.subVectors( vertexPosition, center ).addScalar( 0.5 ).multiply( scale );
+
+	// to check if rotation is not zero
+	if ( sin !== undefined ) {
+
+		_rotatedPosition.x = ( cos * _alignedPosition.x ) - ( sin * _alignedPosition.y );
+		_rotatedPosition.y = ( sin * _alignedPosition.x ) + ( cos * _alignedPosition.y );
+
+	} else {
+
+		_rotatedPosition.copy( _alignedPosition );
+
+	}
+
+
+	vertexPosition.copy( mvPosition );
+	vertexPosition.x += _rotatedPosition.x;
+	vertexPosition.y += _rotatedPosition.y;
+
+	// transform to world space
+	vertexPosition.applyMatrix4( _viewWorldMatrix );
+
+}
+
+const _v1$2 = /*@__PURE__*/ new Vector3();
+const _v2$1 = /*@__PURE__*/ new Vector3();
+
+class LOD extends Object3D {
+
+	constructor() {
+
+		super();
+
+		this._currentLevel = 0;
+
+		this.type = 'LOD';
+
+		Object.defineProperties( this, {
+			levels: {
+				enumerable: true,
+				value: []
+			},
+			isLOD: {
+				value: true,
+			}
+		} );
+
+		this.autoUpdate = true;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source, false );
+
+		const levels = source.levels;
+
+		for ( let i = 0, l = levels.length; i < l; i ++ ) {
+
+			const level = levels[ i ];
+
+			this.addLevel( level.object.clone(), level.distance, level.hysteresis );
+
+		}
+
+		this.autoUpdate = source.autoUpdate;
+
+		return this;
+
+	}
+
+	addLevel( object, distance = 0, hysteresis = 0 ) {
+
+		distance = Math.abs( distance );
+
+		const levels = this.levels;
+
+		let l;
+
+		for ( l = 0; l < levels.length; l ++ ) {
+
+			if ( distance < levels[ l ].distance ) {
+
+				break;
+
+			}
+
+		}
+
+		levels.splice( l, 0, { distance: distance, hysteresis: hysteresis, object: object } );
+
+		this.add( object );
+
+		return this;
+
+	}
+
+	getCurrentLevel() {
+
+		return this._currentLevel;
+
+	}
+
+
+
+	getObjectForDistance( distance ) {
+
+		const levels = this.levels;
+
+		if ( levels.length > 0 ) {
+
+			let i, l;
+
+			for ( i = 1, l = levels.length; i < l; i ++ ) {
+
+				let levelDistance = levels[ i ].distance;
+
+				if ( levels[ i ].object.visible ) {
+
+					levelDistance -= levelDistance * levels[ i ].hysteresis;
+
+				}
+
+				if ( distance < levelDistance ) {
+
+					break;
+
+				}
+
+			}
+
+			return levels[ i - 1 ].object;
+
+		}
+
+		return null;
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const levels = this.levels;
+
+		if ( levels.length > 0 ) {
+
+			_v1$2.setFromMatrixPosition( this.matrixWorld );
+
+			const distance = raycaster.ray.origin.distanceTo( _v1$2 );
+
+			this.getObjectForDistance( distance ).raycast( raycaster, intersects );
+
+		}
+
+	}
+
+	update( camera ) {
+
+		const levels = this.levels;
+
+		if ( levels.length > 1 ) {
+
+			_v1$2.setFromMatrixPosition( camera.matrixWorld );
+			_v2$1.setFromMatrixPosition( this.matrixWorld );
+
+			const distance = _v1$2.distanceTo( _v2$1 ) / camera.zoom;
+
+			levels[ 0 ].object.visible = true;
+
+			let i, l;
+
+			for ( i = 1, l = levels.length; i < l; i ++ ) {
+
+				let levelDistance = levels[ i ].distance;
+
+				if ( levels[ i ].object.visible ) {
+
+					levelDistance -= levelDistance * levels[ i ].hysteresis;
+
+				}
+
+				if ( distance >= levelDistance ) {
+
+					levels[ i - 1 ].object.visible = false;
+					levels[ i ].object.visible = true;
+
+				} else {
+
+					break;
+
+				}
+
+			}
+
+			this._currentLevel = i - 1;
+
+			for ( ; i < l; i ++ ) {
+
+				levels[ i ].object.visible = false;
+
+			}
+
+		}
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		if ( this.autoUpdate === false ) data.object.autoUpdate = false;
+
+		data.object.levels = [];
+
+		const levels = this.levels;
+
+		for ( let i = 0, l = levels.length; i < l; i ++ ) {
+
+			const level = levels[ i ];
+
+			data.object.levels.push( {
+				object: level.object.uuid,
+				distance: level.distance,
+				hysteresis: level.hysteresis
+			} );
+
+		}
+
+		return data;
+
+	}
+
+}
+
+const _basePosition = /*@__PURE__*/ new Vector3();
+
+const _skinIndex = /*@__PURE__*/ new Vector4();
+const _skinWeight = /*@__PURE__*/ new Vector4();
+
+const _vector3 = /*@__PURE__*/ new Vector3();
+const _matrix4 = /*@__PURE__*/ new Matrix4();
+const _vertex = /*@__PURE__*/ new Vector3();
+
+const _sphere$4 = /*@__PURE__*/ new Sphere();
+const _inverseMatrix$2 = /*@__PURE__*/ new Matrix4();
+const _ray$2 = /*@__PURE__*/ new Ray();
+
+class SkinnedMesh extends Mesh {
+
+	constructor( geometry, material ) {
+
+		super( geometry, material );
+
+		this.isSkinnedMesh = true;
+
+		this.type = 'SkinnedMesh';
+
+		this.bindMode = AttachedBindMode;
+		this.bindMatrix = new Matrix4();
+		this.bindMatrixInverse = new Matrix4();
+
+		this.boundingBox = null;
+		this.boundingSphere = null;
+
+	}
+
+	computeBoundingBox() {
+
+		const geometry = this.geometry;
+
+		if ( this.boundingBox === null ) {
+
+			this.boundingBox = new Box3();
+
+		}
+
+		this.boundingBox.makeEmpty();
+
+		const positionAttribute = geometry.getAttribute( 'position' );
+
+		for ( let i = 0; i < positionAttribute.count; i ++ ) {
+
+			this.getVertexPosition( i, _vertex );
+			this.boundingBox.expandByPoint( _vertex );
+
+		}
+
+	}
+
+	computeBoundingSphere() {
+
+		const geometry = this.geometry;
+
+		if ( this.boundingSphere === null ) {
+
+			this.boundingSphere = new Sphere();
+
+		}
+
+		this.boundingSphere.makeEmpty();
+
+		const positionAttribute = geometry.getAttribute( 'position' );
+
+		for ( let i = 0; i < positionAttribute.count; i ++ ) {
+
+			this.getVertexPosition( i, _vertex );
+			this.boundingSphere.expandByPoint( _vertex );
+
+		}
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.bindMode = source.bindMode;
+		this.bindMatrix.copy( source.bindMatrix );
+		this.bindMatrixInverse.copy( source.bindMatrixInverse );
+
+		this.skeleton = source.skeleton;
+
+		if ( source.boundingBox !== null ) this.boundingBox = source.boundingBox.clone();
+		if ( source.boundingSphere !== null ) this.boundingSphere = source.boundingSphere.clone();
+
+		return this;
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const material = this.material;
+		const matrixWorld = this.matrixWorld;
+
+		if ( material === undefined ) return;
+
+		// test with bounding sphere in world space
+
+		if ( this.boundingSphere === null ) this.computeBoundingSphere();
+
+		_sphere$4.copy( this.boundingSphere );
+		_sphere$4.applyMatrix4( matrixWorld );
+
+		if ( raycaster.ray.intersectsSphere( _sphere$4 ) === false ) return;
+
+		// convert ray to local space of skinned mesh
+
+		_inverseMatrix$2.copy( matrixWorld ).invert();
+		_ray$2.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$2 );
+
+		// test with bounding box in local space
+
+		if ( this.boundingBox !== null ) {
+
+			if ( _ray$2.intersectsBox( this.boundingBox ) === false ) return;
+
+		}
+
+		// test for intersections with geometry
+
+		this._computeIntersections( raycaster, intersects, _ray$2 );
+
+	}
+
+	getVertexPosition( index, target ) {
+
+		super.getVertexPosition( index, target );
+
+		this.applyBoneTransform( index, target );
+
+		return target;
+
+	}
+
+	bind( skeleton, bindMatrix ) {
+
+		this.skeleton = skeleton;
+
+		if ( bindMatrix === undefined ) {
+
+			this.updateMatrixWorld( true );
+
+			this.skeleton.calculateInverses();
+
+			bindMatrix = this.matrixWorld;
+
+		}
+
+		this.bindMatrix.copy( bindMatrix );
+		this.bindMatrixInverse.copy( bindMatrix ).invert();
+
+	}
+
+	pose() {
+
+		this.skeleton.pose();
+
+	}
+
+	normalizeSkinWeights() {
+
+		const vector = new Vector4();
+
+		const skinWeight = this.geometry.attributes.skinWeight;
+
+		for ( let i = 0, l = skinWeight.count; i < l; i ++ ) {
+
+			vector.fromBufferAttribute( skinWeight, i );
+
+			const scale = 1.0 / vector.manhattanLength();
+
+			if ( scale !== Infinity ) {
+
+				vector.multiplyScalar( scale );
+
+			} else {
+
+				vector.set( 1, 0, 0, 0 ); // do something reasonable
+
+			}
+
+			skinWeight.setXYZW( i, vector.x, vector.y, vector.z, vector.w );
+
+		}
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		super.updateMatrixWorld( force );
+
+		if ( this.bindMode === AttachedBindMode ) {
+
+			this.bindMatrixInverse.copy( this.matrixWorld ).invert();
+
+		} else if ( this.bindMode === DetachedBindMode ) {
+
+			this.bindMatrixInverse.copy( this.bindMatrix ).invert();
+
+		} else {
+
+			console.warn( 'THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode );
+
+		}
+
+	}
+
+	applyBoneTransform( index, vector ) {
+
+		const skeleton = this.skeleton;
+		const geometry = this.geometry;
+
+		_skinIndex.fromBufferAttribute( geometry.attributes.skinIndex, index );
+		_skinWeight.fromBufferAttribute( geometry.attributes.skinWeight, index );
+
+		_basePosition.copy( vector ).applyMatrix4( this.bindMatrix );
+
+		vector.set( 0, 0, 0 );
+
+		for ( let i = 0; i < 4; i ++ ) {
+
+			const weight = _skinWeight.getComponent( i );
+
+			if ( weight !== 0 ) {
+
+				const boneIndex = _skinIndex.getComponent( i );
+
+				_matrix4.multiplyMatrices( skeleton.bones[ boneIndex ].matrixWorld, skeleton.boneInverses[ boneIndex ] );
+
+				vector.addScaledVector( _vector3.copy( _basePosition ).applyMatrix4( _matrix4 ), weight );
+
+			}
+
+		}
+
+		return vector.applyMatrix4( this.bindMatrixInverse );
+
+	}
+
+	boneTransform( index, vector ) { // @deprecated, r151
+
+		console.warn( 'THREE.SkinnedMesh: .boneTransform() was renamed to .applyBoneTransform() in r151.' );
+		return this.applyBoneTransform( index, vector );
+
+	}
+
+
+}
+
+class Bone extends Object3D {
+
+	constructor() {
+
+		super();
+
+		this.isBone = true;
+
+		this.type = 'Bone';
+
+	}
+
+}
+
+class DataTexture extends Texture {
+
+	constructor( data = null, width = 1, height = 1, format, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace ) {
+
+		super( null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace );
+
+		this.isDataTexture = true;
+
+		this.image = { data: data, width: width, height: height };
+
+		this.generateMipmaps = false;
+		this.flipY = false;
+		this.unpackAlignment = 1;
+
+	}
+
+}
+
+const _offsetMatrix = /*@__PURE__*/ new Matrix4();
+const _identityMatrix$1 = /*@__PURE__*/ new Matrix4();
+
+class Skeleton {
+
+	constructor( bones = [], boneInverses = [] ) {
+
+		this.uuid = generateUUID();
+
+		this.bones = bones.slice( 0 );
+		this.boneInverses = boneInverses;
+		this.boneMatrices = null;
+
+		this.boneTexture = null;
+
+		this.init();
+
+	}
+
+	init() {
+
+		const bones = this.bones;
+		const boneInverses = this.boneInverses;
+
+		this.boneMatrices = new Float32Array( bones.length * 16 );
+
+		// calculate inverse bone matrices if necessary
+
+		if ( boneInverses.length === 0 ) {
+
+			this.calculateInverses();
+
+		} else {
+
+			// handle special case
+
+			if ( bones.length !== boneInverses.length ) {
+
+				console.warn( 'THREE.Skeleton: Number of inverse bone matrices does not match amount of bones.' );
+
+				this.boneInverses = [];
+
+				for ( let i = 0, il = this.bones.length; i < il; i ++ ) {
+
+					this.boneInverses.push( new Matrix4() );
+
+				}
+
+			}
+
+		}
+
+	}
+
+	calculateInverses() {
+
+		this.boneInverses.length = 0;
+
+		for ( let i = 0, il = this.bones.length; i < il; i ++ ) {
+
+			const inverse = new Matrix4();
+
+			if ( this.bones[ i ] ) {
+
+				inverse.copy( this.bones[ i ].matrixWorld ).invert();
+
+			}
+
+			this.boneInverses.push( inverse );
+
+		}
+
+	}
+
+	pose() {
+
+		// recover the bind-time world matrices
+
+		for ( let i = 0, il = this.bones.length; i < il; i ++ ) {
+
+			const bone = this.bones[ i ];
+
+			if ( bone ) {
+
+				bone.matrixWorld.copy( this.boneInverses[ i ] ).invert();
+
+			}
+
+		}
+
+		// compute the local matrices, positions, rotations and scales
+
+		for ( let i = 0, il = this.bones.length; i < il; i ++ ) {
+
+			const bone = this.bones[ i ];
+
+			if ( bone ) {
+
+				if ( bone.parent && bone.parent.isBone ) {
+
+					bone.matrix.copy( bone.parent.matrixWorld ).invert();
+					bone.matrix.multiply( bone.matrixWorld );
+
+				} else {
+
+					bone.matrix.copy( bone.matrixWorld );
+
+				}
+
+				bone.matrix.decompose( bone.position, bone.quaternion, bone.scale );
+
+			}
+
+		}
+
+	}
+
+	update() {
+
+		const bones = this.bones;
+		const boneInverses = this.boneInverses;
+		const boneMatrices = this.boneMatrices;
+		const boneTexture = this.boneTexture;
+
+		// flatten bone matrices to array
+
+		for ( let i = 0, il = bones.length; i < il; i ++ ) {
+
+			// compute the offset between the current and the original transform
+
+			const matrix = bones[ i ] ? bones[ i ].matrixWorld : _identityMatrix$1;
+
+			_offsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] );
+			_offsetMatrix.toArray( boneMatrices, i * 16 );
+
+		}
+
+		if ( boneTexture !== null ) {
+
+			boneTexture.needsUpdate = true;
+
+		}
+
+	}
+
+	clone() {
+
+		return new Skeleton( this.bones, this.boneInverses );
+
+	}
+
+	computeBoneTexture() {
+
+		// layout (1 matrix = 4 pixels)
+		//      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
+		//  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)
+		//       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)
+		//       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)
+		//       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)
+
+		let size = Math.sqrt( this.bones.length * 4 ); // 4 pixels needed for 1 matrix
+		size = Math.ceil( size / 4 ) * 4;
+		size = Math.max( size, 4 );
+
+		const boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel
+		boneMatrices.set( this.boneMatrices ); // copy current values
+
+		const boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType );
+		boneTexture.needsUpdate = true;
+
+		this.boneMatrices = boneMatrices;
+		this.boneTexture = boneTexture;
+
+		return this;
+
+	}
+
+	getBoneByName( name ) {
+
+		for ( let i = 0, il = this.bones.length; i < il; i ++ ) {
+
+			const bone = this.bones[ i ];
+
+			if ( bone.name === name ) {
+
+				return bone;
+
+			}
+
+		}
+
+		return undefined;
+
+	}
+
+	dispose( ) {
+
+		if ( this.boneTexture !== null ) {
+
+			this.boneTexture.dispose();
+
+			this.boneTexture = null;
+
+		}
+
+	}
+
+	fromJSON( json, bones ) {
+
+		this.uuid = json.uuid;
+
+		for ( let i = 0, l = json.bones.length; i < l; i ++ ) {
+
+			const uuid = json.bones[ i ];
+			let bone = bones[ uuid ];
+
+			if ( bone === undefined ) {
+
+				console.warn( 'THREE.Skeleton: No bone found with UUID:', uuid );
+				bone = new Bone();
+
+			}
+
+			this.bones.push( bone );
+			this.boneInverses.push( new Matrix4().fromArray( json.boneInverses[ i ] ) );
+
+		}
+
+		this.init();
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = {
+			metadata: {
+				version: 4.6,
+				type: 'Skeleton',
+				generator: 'Skeleton.toJSON'
+			},
+			bones: [],
+			boneInverses: []
+		};
+
+		data.uuid = this.uuid;
+
+		const bones = this.bones;
+		const boneInverses = this.boneInverses;
+
+		for ( let i = 0, l = bones.length; i < l; i ++ ) {
+
+			const bone = bones[ i ];
+			data.bones.push( bone.uuid );
+
+			const boneInverse = boneInverses[ i ];
+			data.boneInverses.push( boneInverse.toArray() );
+
+		}
+
+		return data;
+
+	}
+
+}
+
+class InstancedBufferAttribute extends BufferAttribute {
+
+	constructor( array, itemSize, normalized, meshPerAttribute = 1 ) {
+
+		super( array, itemSize, normalized );
+
+		this.isInstancedBufferAttribute = true;
+
+		this.meshPerAttribute = meshPerAttribute;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.meshPerAttribute = source.meshPerAttribute;
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.meshPerAttribute = this.meshPerAttribute;
+
+		data.isInstancedBufferAttribute = true;
+
+		return data;
+
+	}
+
+}
+
+const _instanceLocalMatrix = /*@__PURE__*/ new Matrix4();
+const _instanceWorldMatrix = /*@__PURE__*/ new Matrix4();
+
+const _instanceIntersects = [];
+
+const _box3 = /*@__PURE__*/ new Box3();
+const _identity = /*@__PURE__*/ new Matrix4();
+const _mesh$1 = /*@__PURE__*/ new Mesh();
+const _sphere$3 = /*@__PURE__*/ new Sphere();
+
+class InstancedMesh extends Mesh {
+
+	constructor( geometry, material, count ) {
+
+		super( geometry, material );
+
+		this.isInstancedMesh = true;
+
+		this.instanceMatrix = new InstancedBufferAttribute( new Float32Array( count * 16 ), 16 );
+		this.instanceColor = null;
+
+		this.count = count;
+
+		this.boundingBox = null;
+		this.boundingSphere = null;
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			this.setMatrixAt( i, _identity );
+
+		}
+
+	}
+
+	computeBoundingBox() {
+
+		const geometry = this.geometry;
+		const count = this.count;
+
+		if ( this.boundingBox === null ) {
+
+			this.boundingBox = new Box3();
+
+		}
+
+		if ( geometry.boundingBox === null ) {
+
+			geometry.computeBoundingBox();
+
+		}
+
+		this.boundingBox.makeEmpty();
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			this.getMatrixAt( i, _instanceLocalMatrix );
+
+			_box3.copy( geometry.boundingBox ).applyMatrix4( _instanceLocalMatrix );
+
+			this.boundingBox.union( _box3 );
+
+		}
+
+	}
+
+	computeBoundingSphere() {
+
+		const geometry = this.geometry;
+		const count = this.count;
+
+		if ( this.boundingSphere === null ) {
+
+			this.boundingSphere = new Sphere();
+
+		}
+
+		if ( geometry.boundingSphere === null ) {
+
+			geometry.computeBoundingSphere();
+
+		}
+
+		this.boundingSphere.makeEmpty();
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			this.getMatrixAt( i, _instanceLocalMatrix );
+
+			_sphere$3.copy( geometry.boundingSphere ).applyMatrix4( _instanceLocalMatrix );
+
+			this.boundingSphere.union( _sphere$3 );
+
+		}
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.instanceMatrix.copy( source.instanceMatrix );
+
+		if ( source.instanceColor !== null ) this.instanceColor = source.instanceColor.clone();
+
+		this.count = source.count;
+
+		if ( source.boundingBox !== null ) this.boundingBox = source.boundingBox.clone();
+		if ( source.boundingSphere !== null ) this.boundingSphere = source.boundingSphere.clone();
+
+		return this;
+
+	}
+
+	getColorAt( index, color ) {
+
+		color.fromArray( this.instanceColor.array, index * 3 );
+
+	}
+
+	getMatrixAt( index, matrix ) {
+
+		matrix.fromArray( this.instanceMatrix.array, index * 16 );
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const matrixWorld = this.matrixWorld;
+		const raycastTimes = this.count;
+
+		_mesh$1.geometry = this.geometry;
+		_mesh$1.material = this.material;
+
+		if ( _mesh$1.material === undefined ) return;
+
+		// test with bounding sphere first
+
+		if ( this.boundingSphere === null ) this.computeBoundingSphere();
+
+		_sphere$3.copy( this.boundingSphere );
+		_sphere$3.applyMatrix4( matrixWorld );
+
+		if ( raycaster.ray.intersectsSphere( _sphere$3 ) === false ) return;
+
+		// now test each instance
+
+		for ( let instanceId = 0; instanceId < raycastTimes; instanceId ++ ) {
+
+			// calculate the world matrix for each instance
+
+			this.getMatrixAt( instanceId, _instanceLocalMatrix );
+
+			_instanceWorldMatrix.multiplyMatrices( matrixWorld, _instanceLocalMatrix );
+
+			// the mesh represents this single instance
+
+			_mesh$1.matrixWorld = _instanceWorldMatrix;
+
+			_mesh$1.raycast( raycaster, _instanceIntersects );
+
+			// process the result of raycast
+
+			for ( let i = 0, l = _instanceIntersects.length; i < l; i ++ ) {
+
+				const intersect = _instanceIntersects[ i ];
+				intersect.instanceId = instanceId;
+				intersect.object = this;
+				intersects.push( intersect );
+
+			}
+
+			_instanceIntersects.length = 0;
+
+		}
+
+	}
+
+	setColorAt( index, color ) {
+
+		if ( this.instanceColor === null ) {
+
+			this.instanceColor = new InstancedBufferAttribute( new Float32Array( this.instanceMatrix.count * 3 ), 3 );
+
+		}
+
+		color.toArray( this.instanceColor.array, index * 3 );
+
+	}
+
+	setMatrixAt( index, matrix ) {
+
+		matrix.toArray( this.instanceMatrix.array, index * 16 );
+
+	}
+
+	updateMorphTargets() {
+
+	}
+
+	dispose() {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+}
+
+function sortOpaque( a, b ) {
+
+	return a.z - b.z;
+
+}
+
+function sortTransparent( a, b ) {
+
+	return b.z - a.z;
+
+}
+
+class MultiDrawRenderList {
+
+	constructor() {
+
+		this.index = 0;
+		this.pool = [];
+		this.list = [];
+
+	}
+
+	push( drawRange, z ) {
+
+		const pool = this.pool;
+		const list = this.list;
+		if ( this.index >= pool.length ) {
+
+			pool.push( {
+
+				start: - 1,
+				count: - 1,
+				z: - 1,
+
+			} );
+
+		}
+
+		const item = pool[ this.index ];
+		list.push( item );
+		this.index ++;
+
+		item.start = drawRange.start;
+		item.count = drawRange.count;
+		item.z = z;
+
+	}
+
+	reset() {
+
+		this.list.length = 0;
+		this.index = 0;
+
+	}
+
+}
+
+const ID_ATTR_NAME = 'batchId';
+const _matrix = /*@__PURE__*/ new Matrix4();
+const _invMatrixWorld = /*@__PURE__*/ new Matrix4();
+const _identityMatrix = /*@__PURE__*/ new Matrix4();
+const _projScreenMatrix$2 = /*@__PURE__*/ new Matrix4();
+const _frustum = /*@__PURE__*/ new Frustum();
+const _box$1 = /*@__PURE__*/ new Box3();
+const _sphere$2 = /*@__PURE__*/ new Sphere();
+const _vector$5 = /*@__PURE__*/ new Vector3();
+const _renderList = /*@__PURE__*/ new MultiDrawRenderList();
+const _mesh = /*@__PURE__*/ new Mesh();
+const _batchIntersects = [];
+
+// @TODO: SkinnedMesh support?
+// @TODO: geometry.groups support?
+// @TODO: geometry.drawRange support?
+// @TODO: geometry.morphAttributes support?
+// @TODO: Support uniform parameter per geometry
+// @TODO: Add an "optimize" function to pack geometry and remove data gaps
+
+// copies data from attribute "src" into "target" starting at "targetOffset"
+function copyAttributeData( src, target, targetOffset = 0 ) {
+
+	const itemSize = target.itemSize;
+	if ( src.isInterleavedBufferAttribute || src.array.constructor !== target.array.constructor ) {
+
+		// use the component getters and setters if the array data cannot
+		// be copied directly
+		const vertexCount = src.count;
+		for ( let i = 0; i < vertexCount; i ++ ) {
+
+			for ( let c = 0; c < itemSize; c ++ ) {
+
+				target.setComponent( i + targetOffset, c, src.getComponent( i, c ) );
+
+			}
+
+		}
+
+	} else {
+
+		// faster copy approach using typed array set function
+		target.array.set( src.array, targetOffset * itemSize );
+
+	}
+
+	target.needsUpdate = true;
+
+}
+
+class BatchedMesh extends Mesh {
+
+	get maxGeometryCount() {
+
+		return this._maxGeometryCount;
+
+	}
+
+	constructor( maxGeometryCount, maxVertexCount, maxIndexCount = maxVertexCount * 2, material ) {
+
+		super( new BufferGeometry(), material );
+
+		this.isBatchedMesh = true;
+		this.perObjectFrustumCulled = true;
+		this.sortObjects = true;
+		this.boundingBox = null;
+		this.boundingSphere = null;
+		this.customSort = null;
+
+		this._drawRanges = [];
+		this._reservedRanges = [];
+
+		this._visibility = [];
+		this._active = [];
+		this._bounds = [];
+
+		this._maxGeometryCount = maxGeometryCount;
+		this._maxVertexCount = maxVertexCount;
+		this._maxIndexCount = maxIndexCount;
+
+		this._geometryInitialized = false;
+		this._geometryCount = 0;
+		this._multiDrawCounts = new Int32Array( maxGeometryCount );
+		this._multiDrawStarts = new Int32Array( maxGeometryCount );
+		this._multiDrawCount = 0;
+		this._visibilityChanged = true;
+
+		// Local matrix per geometry by using data texture
+		this._matricesTexture = null;
+
+		this._initMatricesTexture();
+
+	}
+
+	_initMatricesTexture() {
+
+		// layout (1 matrix = 4 pixels)
+		//      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
+		//  with  8x8  pixel texture max   16 matrices * 4 pixels =  (8 * 8)
+		//       16x16 pixel texture max   64 matrices * 4 pixels = (16 * 16)
+		//       32x32 pixel texture max  256 matrices * 4 pixels = (32 * 32)
+		//       64x64 pixel texture max 1024 matrices * 4 pixels = (64 * 64)
+
+		let size = Math.sqrt( this._maxGeometryCount * 4 ); // 4 pixels needed for 1 matrix
+		size = Math.ceil( size / 4 ) * 4;
+		size = Math.max( size, 4 );
+
+		const matricesArray = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel
+		const matricesTexture = new DataTexture( matricesArray, size, size, RGBAFormat, FloatType );
+
+		this._matricesTexture = matricesTexture;
+
+	}
+
+	_initializeGeometry( reference ) {
+
+		const geometry = this.geometry;
+		const maxVertexCount = this._maxVertexCount;
+		const maxGeometryCount = this._maxGeometryCount;
+		const maxIndexCount = this._maxIndexCount;
+		if ( this._geometryInitialized === false ) {
+
+			for ( const attributeName in reference.attributes ) {
+
+				const srcAttribute = reference.getAttribute( attributeName );
+				const { array, itemSize, normalized } = srcAttribute;
+
+				const dstArray = new array.constructor( maxVertexCount * itemSize );
+				const dstAttribute = new srcAttribute.constructor( dstArray, itemSize, normalized );
+				dstAttribute.setUsage( srcAttribute.usage );
+
+				geometry.setAttribute( attributeName, dstAttribute );
+
+			}
+
+			if ( reference.getIndex() !== null ) {
+
+				const indexArray = maxVertexCount > 65536
+					? new Uint32Array( maxIndexCount )
+					: new Uint16Array( maxIndexCount );
+
+				geometry.setIndex( new BufferAttribute( indexArray, 1 ) );
+
+			}
+
+			const idArray = maxGeometryCount > 65536
+				? new Uint32Array( maxVertexCount )
+				: new Uint16Array( maxVertexCount );
+			geometry.setAttribute( ID_ATTR_NAME, new BufferAttribute( idArray, 1 ) );
+
+			this._geometryInitialized = true;
+
+		}
+
+	}
+
+	// Make sure the geometry is compatible with the existing combined geometry atributes
+	_validateGeometry( geometry ) {
+
+		// check that the geometry doesn't have a version of our reserved id attribute
+		if ( geometry.getAttribute( ID_ATTR_NAME ) ) {
+
+			throw new Error( `BatchedMesh: Geometry cannot use attribute "${ ID_ATTR_NAME }"` );
+
+		}
+
+		// check to ensure the geometries are using consistent attributes and indices
+		const batchGeometry = this.geometry;
+		if ( Boolean( geometry.getIndex() ) !== Boolean( batchGeometry.getIndex() ) ) {
+
+			throw new Error( 'BatchedMesh: All geometries must consistently have "index".' );
+
+		}
+
+		for ( const attributeName in batchGeometry.attributes ) {
+
+			if ( attributeName === ID_ATTR_NAME ) {
+
+				continue;
+
+			}
+
+			if ( ! geometry.hasAttribute( attributeName ) ) {
+
+				throw new Error( `BatchedMesh: Added geometry missing "${ attributeName }". All geometries must have consistent attributes.` );
+
+			}
+
+			const srcAttribute = geometry.getAttribute( attributeName );
+			const dstAttribute = batchGeometry.getAttribute( attributeName );
+			if ( srcAttribute.itemSize !== dstAttribute.itemSize || srcAttribute.normalized !== dstAttribute.normalized ) {
+
+				throw new Error( 'BatchedMesh: All attributes must have a consistent itemSize and normalized value.' );
+
+			}
+
+		}
+
+	}
+
+	setCustomSort( func ) {
+
+		this.customSort = func;
+		return this;
+
+	}
+
+	computeBoundingBox() {
+
+		if ( this.boundingBox === null ) {
+
+			this.boundingBox = new Box3();
+
+		}
+
+		const geometryCount = this._geometryCount;
+		const boundingBox = this.boundingBox;
+		const active = this._active;
+
+		boundingBox.makeEmpty();
+		for ( let i = 0; i < geometryCount; i ++ ) {
+
+			if ( active[ i ] === false ) continue;
+
+			this.getMatrixAt( i, _matrix );
+			this.getBoundingBoxAt( i, _box$1 ).applyMatrix4( _matrix );
+			boundingBox.union( _box$1 );
+
+		}
+
+	}
+
+	computeBoundingSphere() {
+
+		if ( this.boundingSphere === null ) {
+
+			this.boundingSphere = new Sphere();
+
+		}
+
+		const geometryCount = this._geometryCount;
+		const boundingSphere = this.boundingSphere;
+		const active = this._active;
+
+		boundingSphere.makeEmpty();
+		for ( let i = 0; i < geometryCount; i ++ ) {
+
+			if ( active[ i ] === false ) continue;
+
+			this.getMatrixAt( i, _matrix );
+			this.getBoundingSphereAt( i, _sphere$2 ).applyMatrix4( _matrix );
+			boundingSphere.union( _sphere$2 );
+
+		}
+
+	}
+
+	addGeometry( geometry, vertexCount = - 1, indexCount = - 1 ) {
+
+		this._initializeGeometry( geometry );
+
+		this._validateGeometry( geometry );
+
+		// ensure we're not over geometry
+		if ( this._geometryCount >= this._maxGeometryCount ) {
+
+			throw new Error( 'BatchedMesh: Maximum geometry count reached.' );
+
+		}
+
+		// get the necessary range fo the geometry
+		const reservedRange = {
+			vertexStart: - 1,
+			vertexCount: - 1,
+			indexStart: - 1,
+			indexCount: - 1,
+		};
+
+		let lastRange = null;
+		const reservedRanges = this._reservedRanges;
+		const drawRanges = this._drawRanges;
+		const bounds = this._bounds;
+		if ( this._geometryCount !== 0 ) {
+
+			lastRange = reservedRanges[ reservedRanges.length - 1 ];
+
+		}
+
+		if ( vertexCount === - 1 ) {
+
+			reservedRange.vertexCount = geometry.getAttribute( 'position' ).count;
+
+		} else {
+
+			reservedRange.vertexCount = vertexCount;
+
+		}
+
+		if ( lastRange === null ) {
+
+			reservedRange.vertexStart = 0;
+
+		} else {
+
+			reservedRange.vertexStart = lastRange.vertexStart + lastRange.vertexCount;
+
+		}
+
+		const index = geometry.getIndex();
+		const hasIndex = index !== null;
+		if ( hasIndex ) {
+
+			if ( indexCount	=== - 1 ) {
+
+				reservedRange.indexCount = index.count;
+
+			} else {
+
+				reservedRange.indexCount = indexCount;
+
+			}
+
+			if ( lastRange === null ) {
+
+				reservedRange.indexStart = 0;
+
+			} else {
+
+				reservedRange.indexStart = lastRange.indexStart + lastRange.indexCount;
+
+			}
+
+		}
+
+		if (
+			reservedRange.indexStart !== - 1 &&
+			reservedRange.indexStart + reservedRange.indexCount > this._maxIndexCount ||
+			reservedRange.vertexStart + reservedRange.vertexCount > this._maxVertexCount
+		) {
+
+			throw new Error( 'BatchedMesh: Reserved space request exceeds the maximum buffer size.' );
+
+		}
+
+		const visibility = this._visibility;
+		const active = this._active;
+		const matricesTexture = this._matricesTexture;
+		const matricesArray = this._matricesTexture.image.data;
+
+		// push new visibility states
+		visibility.push( true );
+		active.push( true );
+
+		// update id
+		const geometryId = this._geometryCount;
+		this._geometryCount ++;
+
+		// initialize matrix information
+		_identityMatrix.toArray( matricesArray, geometryId * 16 );
+		matricesTexture.needsUpdate = true;
+
+		// add the reserved range and draw range objects
+		reservedRanges.push( reservedRange );
+		drawRanges.push( {
+			start: hasIndex ? reservedRange.indexStart : reservedRange.vertexStart,
+			count: - 1
+		} );
+		bounds.push( {
+			boxInitialized: false,
+			box: new Box3(),
+
+			sphereInitialized: false,
+			sphere: new Sphere()
+		} );
+
+		// set the id for the geometry
+		const idAttribute = this.geometry.getAttribute( ID_ATTR_NAME );
+		for ( let i = 0; i < reservedRange.vertexCount; i ++ ) {
+
+			idAttribute.setX( reservedRange.vertexStart + i, geometryId );
+
+		}
+
+		idAttribute.needsUpdate = true;
+
+		// update the geometry
+		this.setGeometryAt( geometryId, geometry );
+
+		return geometryId;
+
+	}
+
+	setGeometryAt( id, geometry ) {
+
+		if ( id >= this._geometryCount ) {
+
+			throw new Error( 'BatchedMesh: Maximum geometry count reached.' );
+
+		}
+
+		this._validateGeometry( geometry );
+
+		const batchGeometry = this.geometry;
+		const hasIndex = batchGeometry.getIndex() !== null;
+		const dstIndex = batchGeometry.getIndex();
+		const srcIndex = geometry.getIndex();
+		const reservedRange = this._reservedRanges[ id ];
+		if (
+			hasIndex &&
+			srcIndex.count > reservedRange.indexCount ||
+			geometry.attributes.position.count > reservedRange.vertexCount
+		) {
+
+			throw new Error( 'BatchedMesh: Reserved space not large enough for provided geometry.' );
+
+		}
+
+		// copy geometry over
+		const vertexStart = reservedRange.vertexStart;
+		const vertexCount = reservedRange.vertexCount;
+		for ( const attributeName in batchGeometry.attributes ) {
+
+			if ( attributeName === ID_ATTR_NAME ) {
+
+				continue;
+
+			}
+
+			// copy attribute data
+			const srcAttribute = geometry.getAttribute( attributeName );
+			const dstAttribute = batchGeometry.getAttribute( attributeName );
+			copyAttributeData( srcAttribute, dstAttribute, vertexStart );
+
+			// fill the rest in with zeroes
+			const itemSize = srcAttribute.itemSize;
+			for ( let i = srcAttribute.count, l = vertexCount; i < l; i ++ ) {
+
+				const index = vertexStart + i;
+				for ( let c = 0; c < itemSize; c ++ ) {
+
+					dstAttribute.setComponent( index, c, 0 );
+
+				}
+
+			}
+
+			dstAttribute.needsUpdate = true;
+
+		}
+
+		// copy index
+		if ( hasIndex ) {
+
+			const indexStart = reservedRange.indexStart;
+
+			// copy index data over
+			for ( let i = 0; i < srcIndex.count; i ++ ) {
+
+				dstIndex.setX( indexStart + i, vertexStart + srcIndex.getX( i ) );
+
+			}
+
+			// fill the rest in with zeroes
+			for ( let i = srcIndex.count, l = reservedRange.indexCount; i < l; i ++ ) {
+
+				dstIndex.setX( indexStart + i, vertexStart );
+
+			}
+
+			dstIndex.needsUpdate = true;
+
+		}
+
+		// store the bounding boxes
+		const bound = this._bounds[ id ];
+		if ( geometry.boundingBox !== null ) {
+
+			bound.box.copy( geometry.boundingBox );
+			bound.boxInitialized = true;
+
+		} else {
+
+			bound.boxInitialized = false;
+
+		}
+
+		if ( geometry.boundingSphere !== null ) {
+
+			bound.sphere.copy( geometry.boundingSphere );
+			bound.sphereInitialized = true;
+
+		} else {
+
+			bound.sphereInitialized = false;
+
+		}
+
+		// set drawRange count
+		const drawRange = this._drawRanges[ id ];
+		const posAttr = geometry.getAttribute( 'position' );
+		drawRange.count = hasIndex ? srcIndex.count : posAttr.count;
+		this._visibilityChanged = true;
+
+		return id;
+
+	}
+
+	deleteGeometry( geometryId ) {
+
+		// Note: User needs to call optimize() afterward to pack the data.
+
+		const active = this._active;
+		if ( geometryId >= active.length || active[ geometryId ] === false ) {
+
+			return this;
+
+		}
+
+		active[ geometryId ] = false;
+		this._visibilityChanged = true;
+
+		return this;
+
+	}
+
+	// get bounding box and compute it if it doesn't exist
+	getBoundingBoxAt( id, target ) {
+
+		const active = this._active;
+		if ( active[ id ] === false ) {
+
+			return this;
+
+		}
+
+		// compute bounding box
+		const bound = this._bounds[ id ];
+		const box = bound.box;
+		const geometry = this.geometry;
+		if ( bound.boxInitialized === false ) {
+
+			box.makeEmpty();
+
+			const index = geometry.index;
+			const position = geometry.attributes.position;
+			const drawRange = this._drawRanges[ id ];
+			for ( let i = drawRange.start, l = drawRange.start + drawRange.count; i < l; i ++ ) {
+
+				let iv = i;
+				if ( index ) {
+
+					iv = index.getX( iv );
+
+				}
+
+				box.expandByPoint( _vector$5.fromBufferAttribute( position, iv ) );
+
+			}
+
+			bound.boxInitialized = true;
+
+		}
+
+		target.copy( box );
+		return target;
+
+	}
+
+	// get bounding sphere and compute it if it doesn't exist
+	getBoundingSphereAt( id, target ) {
+
+		const active = this._active;
+		if ( active[ id ] === false ) {
+
+			return this;
+
+		}
+
+		// compute bounding sphere
+		const bound = this._bounds[ id ];
+		const sphere = bound.sphere;
+		const geometry = this.geometry;
+		if ( bound.sphereInitialized === false ) {
+
+			sphere.makeEmpty();
+
+			this.getBoundingBoxAt( id, _box$1 );
+			_box$1.getCenter( sphere.center );
+
+			const index = geometry.index;
+			const position = geometry.attributes.position;
+			const drawRange = this._drawRanges[ id ];
+
+			let maxRadiusSq = 0;
+			for ( let i = drawRange.start, l = drawRange.start + drawRange.count; i < l; i ++ ) {
+
+				let iv = i;
+				if ( index ) {
+
+					iv = index.getX( iv );
+
+				}
+
+				_vector$5.fromBufferAttribute( position, iv );
+				maxRadiusSq = Math.max( maxRadiusSq, sphere.center.distanceToSquared( _vector$5 ) );
+
+			}
+
+			sphere.radius = Math.sqrt( maxRadiusSq );
+			bound.sphereInitialized = true;
+
+		}
+
+		target.copy( sphere );
+		return target;
+
+	}
+
+	setMatrixAt( geometryId, matrix ) {
+
+		// @TODO: Map geometryId to index of the arrays because
+		//        optimize() can make geometryId mismatch the index
+
+		const active = this._active;
+		const matricesTexture = this._matricesTexture;
+		const matricesArray = this._matricesTexture.image.data;
+		const geometryCount = this._geometryCount;
+		if ( geometryId >= geometryCount || active[ geometryId ] === false ) {
+
+			return this;
+
+		}
+
+		matrix.toArray( matricesArray, geometryId * 16 );
+		matricesTexture.needsUpdate = true;
+
+		return this;
+
+	}
+
+	getMatrixAt( geometryId, matrix ) {
+
+		const active = this._active;
+		const matricesArray = this._matricesTexture.image.data;
+		const geometryCount = this._geometryCount;
+		if ( geometryId >= geometryCount || active[ geometryId ] === false ) {
+
+			return null;
+
+		}
+
+		return matrix.fromArray( matricesArray, geometryId * 16 );
+
+	}
+
+	setVisibleAt( geometryId, value ) {
+
+		const visibility = this._visibility;
+		const active = this._active;
+		const geometryCount = this._geometryCount;
+
+		// if the geometry is out of range, not active, or visibility state
+		// does not change then return early
+		if (
+			geometryId >= geometryCount ||
+			active[ geometryId ] === false ||
+			visibility[ geometryId ] === value
+		) {
+
+			return this;
+
+		}
+
+		visibility[ geometryId ] = value;
+		this._visibilityChanged = true;
+
+		return this;
+
+	}
+
+	getVisibleAt( geometryId ) {
+
+		const visibility = this._visibility;
+		const active = this._active;
+		const geometryCount = this._geometryCount;
+
+		// return early if the geometry is out of range or not active
+		if ( geometryId >= geometryCount || active[ geometryId ] === false ) {
+
+			return false;
+
+		}
+
+		return visibility[ geometryId ];
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const visibility = this._visibility;
+		const active = this._active;
+		const drawRanges = this._drawRanges;
+		const geometryCount = this._geometryCount;
+		const matrixWorld = this.matrixWorld;
+		const batchGeometry = this.geometry;
+
+		// iterate over each geometry
+		_mesh.material = this.material;
+		_mesh.geometry.index = batchGeometry.index;
+		_mesh.geometry.attributes = batchGeometry.attributes;
+		if ( _mesh.geometry.boundingBox === null ) {
+
+			_mesh.geometry.boundingBox = new Box3();
+
+		}
+
+		if ( _mesh.geometry.boundingSphere === null ) {
+
+			_mesh.geometry.boundingSphere = new Sphere();
+
+		}
+
+		for ( let i = 0; i < geometryCount; i ++ ) {
+
+			if ( ! visibility[ i ] || ! active[ i ] ) {
+
+				continue;
+
+			}
+
+			const drawRange = drawRanges[ i ];
+			_mesh.geometry.setDrawRange( drawRange.start, drawRange.count );
+
+			// ge the intersects
+			this.getMatrixAt( i, _mesh.matrixWorld ).premultiply( matrixWorld );
+			this.getBoundingBoxAt( i, _mesh.geometry.boundingBox );
+			this.getBoundingSphereAt( i, _mesh.geometry.boundingSphere );
+			_mesh.raycast( raycaster, _batchIntersects );
+
+			// add batch id to the intersects
+			for ( let j = 0, l = _batchIntersects.length; j < l; j ++ ) {
+
+				const intersect = _batchIntersects[ j ];
+				intersect.object = this;
+				intersect.batchId = i;
+				intersects.push( intersect );
+
+			}
+
+			_batchIntersects.length = 0;
+
+		}
+
+		_mesh.material = null;
+		_mesh.geometry.index = null;
+		_mesh.geometry.attributes = {};
+		_mesh.geometry.setDrawRange( 0, Infinity );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.geometry = source.geometry.clone();
+		this.perObjectFrustumCulled = source.perObjectFrustumCulled;
+		this.sortObjects = source.sortObjects;
+		this.boundingBox = source.boundingBox !== null ? source.boundingBox.clone() : null;
+		this.boundingSphere = source.boundingSphere !== null ? source.boundingSphere.clone() : null;
+
+		this._drawRanges = source._drawRanges.map( range => ( { ...range } ) );
+		this._reservedRanges = source._reservedRanges.map( range => ( { ...range } ) );
+
+		this._visibility = source._visibility.slice();
+		this._active = source._active.slice();
+		this._bounds = source._bounds.map( bound => ( {
+			boxInitialized: bound.boxInitialized,
+			box: bound.box.clone(),
+
+			sphereInitialized: bound.sphereInitialized,
+			sphere: bound.sphere.clone()
+		} ) );
+
+		this._maxGeometryCount = source._maxGeometryCount;
+		this._maxVertexCount = source._maxVertexCount;
+		this._maxIndexCount = source._maxIndexCount;
+
+		this._geometryInitialized = source._geometryInitialized;
+		this._geometryCount = source._geometryCount;
+		this._multiDrawCounts = source._multiDrawCounts.slice();
+		this._multiDrawStarts = source._multiDrawStarts.slice();
+
+		this._matricesTexture = source._matricesTexture.clone();
+		this._matricesTexture.image.data = this._matricesTexture.image.slice();
+
+		return this;
+
+	}
+
+	dispose() {
+
+		// Assuming the geometry is not shared with other meshes
+		this.geometry.dispose();
+
+		this._matricesTexture.dispose();
+		this._matricesTexture = null;
+		return this;
+
+	}
+
+	onBeforeRender( renderer, scene, camera, geometry, material/*, _group*/ ) {
+
+		// if visibility has not changed and frustum culling and object sorting is not required
+		// then skip iterating over all items
+		if ( ! this._visibilityChanged && ! this.perObjectFrustumCulled && ! this.sortObjects ) {
+
+			return;
+
+		}
+
+		// the indexed version of the multi draw function requires specifying the start
+		// offset in bytes.
+		const index = geometry.getIndex();
+		const bytesPerElement = index === null ? 1 : index.array.BYTES_PER_ELEMENT;
+
+		const visibility = this._visibility;
+		const multiDrawStarts = this._multiDrawStarts;
+		const multiDrawCounts = this._multiDrawCounts;
+		const drawRanges = this._drawRanges;
+		const perObjectFrustumCulled = this.perObjectFrustumCulled;
+
+		// prepare the frustum in the local frame
+		if ( perObjectFrustumCulled ) {
+
+			_projScreenMatrix$2
+				.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse )
+				.multiply( this.matrixWorld );
+			_frustum.setFromProjectionMatrix(
+				_projScreenMatrix$2,
+				renderer.isWebGPURenderer ? WebGPUCoordinateSystem : WebGLCoordinateSystem
+			);
+
+		}
+
+		let count = 0;
+		if ( this.sortObjects ) {
+
+			// get the camera position in the local frame
+			_invMatrixWorld.copy( this.matrixWorld ).invert();
+			_vector$5.setFromMatrixPosition( camera.matrixWorld ).applyMatrix4( _invMatrixWorld );
+
+			for ( let i = 0, l = visibility.length; i < l; i ++ ) {
+
+				if ( visibility[ i ] ) {
+
+					// get the bounds in world space
+					this.getMatrixAt( i, _matrix );
+					this.getBoundingSphereAt( i, _sphere$2 ).applyMatrix4( _matrix );
+
+					// determine whether the batched geometry is within the frustum
+					let culled = false;
+					if ( perObjectFrustumCulled ) {
+
+						culled = ! _frustum.intersectsSphere( _sphere$2 );
+
+					}
+
+					if ( ! culled ) {
+
+						// get the distance from camera used for sorting
+						const z = _vector$5.distanceTo( _sphere$2.center );
+						_renderList.push( drawRanges[ i ], z );
+
+					}
+
+				}
+
+			}
+
+			// Sort the draw ranges and prep for rendering
+			const list = _renderList.list;
+			const customSort = this.customSort;
+			if ( customSort === null ) {
+
+				list.sort( material.transparent ? sortTransparent : sortOpaque );
+
+			} else {
+
+				customSort.call( this, list, camera );
+
+			}
+
+			for ( let i = 0, l = list.length; i < l; i ++ ) {
+
+				const item = list[ i ];
+				multiDrawStarts[ count ] = item.start * bytesPerElement;
+				multiDrawCounts[ count ] = item.count;
+				count ++;
+
+			}
+
+			_renderList.reset();
+
+		} else {
+
+			for ( let i = 0, l = visibility.length; i < l; i ++ ) {
+
+				if ( visibility[ i ] ) {
+
+					// determine whether the batched geometry is within the frustum
+					let culled = false;
+					if ( perObjectFrustumCulled ) {
+
+						// get the bounds in world space
+						this.getMatrixAt( i, _matrix );
+						this.getBoundingSphereAt( i, _sphere$2 ).applyMatrix4( _matrix );
+						culled = ! _frustum.intersectsSphere( _sphere$2 );
+
+					}
+
+					if ( ! culled ) {
+
+						const range = drawRanges[ i ];
+						multiDrawStarts[ count ] = range.start * bytesPerElement;
+						multiDrawCounts[ count ] = range.count;
+						count ++;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		this._multiDrawCount = count;
+		this._visibilityChanged = false;
+
+	}
+
+	onBeforeShadow( renderer, object, camera, shadowCamera, geometry, depthMaterial/* , group */ ) {
+
+		this.onBeforeRender( renderer, null, shadowCamera, geometry, depthMaterial );
+
+	}
+
+}
+
+class LineBasicMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isLineBasicMaterial = true;
+
+		this.type = 'LineBasicMaterial';
+
+		this.color = new Color( 0xffffff );
+
+		this.map = null;
+
+		this.linewidth = 1;
+		this.linecap = 'round';
+		this.linejoin = 'round';
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+
+		this.linewidth = source.linewidth;
+		this.linecap = source.linecap;
+		this.linejoin = source.linejoin;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+const _start$1 = /*@__PURE__*/ new Vector3();
+const _end$1 = /*@__PURE__*/ new Vector3();
+const _inverseMatrix$1 = /*@__PURE__*/ new Matrix4();
+const _ray$1 = /*@__PURE__*/ new Ray();
+const _sphere$1 = /*@__PURE__*/ new Sphere();
+
+class Line extends Object3D {
+
+	constructor( geometry = new BufferGeometry(), material = new LineBasicMaterial() ) {
+
+		super();
+
+		this.isLine = true;
+
+		this.type = 'Line';
+
+		this.geometry = geometry;
+		this.material = material;
+
+		this.updateMorphTargets();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.material = Array.isArray( source.material ) ? source.material.slice() : source.material;
+		this.geometry = source.geometry;
+
+		return this;
+
+	}
+
+	computeLineDistances() {
+
+		const geometry = this.geometry;
+
+		// we assume non-indexed geometry
+
+		if ( geometry.index === null ) {
+
+			const positionAttribute = geometry.attributes.position;
+			const lineDistances = [ 0 ];
+
+			for ( let i = 1, l = positionAttribute.count; i < l; i ++ ) {
+
+				_start$1.fromBufferAttribute( positionAttribute, i - 1 );
+				_end$1.fromBufferAttribute( positionAttribute, i );
+
+				lineDistances[ i ] = lineDistances[ i - 1 ];
+				lineDistances[ i ] += _start$1.distanceTo( _end$1 );
+
+			}
+
+			geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );
+
+		} else {
+
+			console.warn( 'THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );
+
+		}
+
+		return this;
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const geometry = this.geometry;
+		const matrixWorld = this.matrixWorld;
+		const threshold = raycaster.params.Line.threshold;
+		const drawRange = geometry.drawRange;
+
+		// Checking boundingSphere distance to ray
+
+		if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+
+		_sphere$1.copy( geometry.boundingSphere );
+		_sphere$1.applyMatrix4( matrixWorld );
+		_sphere$1.radius += threshold;
+
+		if ( raycaster.ray.intersectsSphere( _sphere$1 ) === false ) return;
+
+		//
+
+		_inverseMatrix$1.copy( matrixWorld ).invert();
+		_ray$1.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$1 );
+
+		const localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
+		const localThresholdSq = localThreshold * localThreshold;
+
+		const vStart = new Vector3();
+		const vEnd = new Vector3();
+		const interSegment = new Vector3();
+		const interRay = new Vector3();
+		const step = this.isLineSegments ? 2 : 1;
+
+		const index = geometry.index;
+		const attributes = geometry.attributes;
+		const positionAttribute = attributes.position;
+
+		if ( index !== null ) {
+
+			const start = Math.max( 0, drawRange.start );
+			const end = Math.min( index.count, ( drawRange.start + drawRange.count ) );
+
+			for ( let i = start, l = end - 1; i < l; i += step ) {
+
+				const a = index.getX( i );
+				const b = index.getX( i + 1 );
+
+				vStart.fromBufferAttribute( positionAttribute, a );
+				vEnd.fromBufferAttribute( positionAttribute, b );
+
+				const distSq = _ray$1.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
+
+				if ( distSq > localThresholdSq ) continue;
+
+				interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+
+				const distance = raycaster.ray.origin.distanceTo( interRay );
+
+				if ( distance < raycaster.near || distance > raycaster.far ) continue;
+
+				intersects.push( {
+
+					distance: distance,
+					// What do we want? intersection point on the ray or on the segment??
+					// point: raycaster.ray.at( distance ),
+					point: interSegment.clone().applyMatrix4( this.matrixWorld ),
+					index: i,
+					face: null,
+					faceIndex: null,
+					object: this
+
+				} );
+
+			}
+
+		} else {
+
+			const start = Math.max( 0, drawRange.start );
+			const end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );
+
+			for ( let i = start, l = end - 1; i < l; i += step ) {
+
+				vStart.fromBufferAttribute( positionAttribute, i );
+				vEnd.fromBufferAttribute( positionAttribute, i + 1 );
+
+				const distSq = _ray$1.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
+
+				if ( distSq > localThresholdSq ) continue;
+
+				interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+
+				const distance = raycaster.ray.origin.distanceTo( interRay );
+
+				if ( distance < raycaster.near || distance > raycaster.far ) continue;
+
+				intersects.push( {
+
+					distance: distance,
+					// What do we want? intersection point on the ray or on the segment??
+					// point: raycaster.ray.at( distance ),
+					point: interSegment.clone().applyMatrix4( this.matrixWorld ),
+					index: i,
+					face: null,
+					faceIndex: null,
+					object: this
+
+				} );
+
+			}
+
+		}
+
+	}
+
+	updateMorphTargets() {
+
+		const geometry = this.geometry;
+
+		const morphAttributes = geometry.morphAttributes;
+		const keys = Object.keys( morphAttributes );
+
+		if ( keys.length > 0 ) {
+
+			const morphAttribute = morphAttributes[ keys[ 0 ] ];
+
+			if ( morphAttribute !== undefined ) {
+
+				this.morphTargetInfluences = [];
+				this.morphTargetDictionary = {};
+
+				for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {
+
+					const name = morphAttribute[ m ].name || String( m );
+
+					this.morphTargetInfluences.push( 0 );
+					this.morphTargetDictionary[ name ] = m;
+
+				}
+
+			}
+
+		}
+
+	}
+
+}
+
+const _start = /*@__PURE__*/ new Vector3();
+const _end = /*@__PURE__*/ new Vector3();
+
+class LineSegments extends Line {
+
+	constructor( geometry, material ) {
+
+		super( geometry, material );
+
+		this.isLineSegments = true;
+
+		this.type = 'LineSegments';
+
+	}
+
+	computeLineDistances() {
+
+		const geometry = this.geometry;
+
+		// we assume non-indexed geometry
+
+		if ( geometry.index === null ) {
+
+			const positionAttribute = geometry.attributes.position;
+			const lineDistances = [];
+
+			for ( let i = 0, l = positionAttribute.count; i < l; i += 2 ) {
+
+				_start.fromBufferAttribute( positionAttribute, i );
+				_end.fromBufferAttribute( positionAttribute, i + 1 );
+
+				lineDistances[ i ] = ( i === 0 ) ? 0 : lineDistances[ i - 1 ];
+				lineDistances[ i + 1 ] = lineDistances[ i ] + _start.distanceTo( _end );
+
+			}
+
+			geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );
+
+		} else {
+
+			console.warn( 'THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );
+
+		}
+
+		return this;
+
+	}
+
+}
+
+class LineLoop extends Line {
+
+	constructor( geometry, material ) {
+
+		super( geometry, material );
+
+		this.isLineLoop = true;
+
+		this.type = 'LineLoop';
+
+	}
+
+}
+
+class PointsMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isPointsMaterial = true;
+
+		this.type = 'PointsMaterial';
+
+		this.color = new Color( 0xffffff );
+
+		this.map = null;
+
+		this.alphaMap = null;
+
+		this.size = 1;
+		this.sizeAttenuation = true;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+
+		this.alphaMap = source.alphaMap;
+
+		this.size = source.size;
+		this.sizeAttenuation = source.sizeAttenuation;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+const _inverseMatrix = /*@__PURE__*/ new Matrix4();
+const _ray = /*@__PURE__*/ new Ray();
+const _sphere = /*@__PURE__*/ new Sphere();
+const _position$2 = /*@__PURE__*/ new Vector3();
+
+class Points extends Object3D {
+
+	constructor( geometry = new BufferGeometry(), material = new PointsMaterial() ) {
+
+		super();
+
+		this.isPoints = true;
+
+		this.type = 'Points';
+
+		this.geometry = geometry;
+		this.material = material;
+
+		this.updateMorphTargets();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.material = Array.isArray( source.material ) ? source.material.slice() : source.material;
+		this.geometry = source.geometry;
+
+		return this;
+
+	}
+
+	raycast( raycaster, intersects ) {
+
+		const geometry = this.geometry;
+		const matrixWorld = this.matrixWorld;
+		const threshold = raycaster.params.Points.threshold;
+		const drawRange = geometry.drawRange;
+
+		// Checking boundingSphere distance to ray
+
+		if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+
+		_sphere.copy( geometry.boundingSphere );
+		_sphere.applyMatrix4( matrixWorld );
+		_sphere.radius += threshold;
+
+		if ( raycaster.ray.intersectsSphere( _sphere ) === false ) return;
+
+		//
+
+		_inverseMatrix.copy( matrixWorld ).invert();
+		_ray.copy( raycaster.ray ).applyMatrix4( _inverseMatrix );
+
+		const localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
+		const localThresholdSq = localThreshold * localThreshold;
+
+		const index = geometry.index;
+		const attributes = geometry.attributes;
+		const positionAttribute = attributes.position;
+
+		if ( index !== null ) {
+
+			const start = Math.max( 0, drawRange.start );
+			const end = Math.min( index.count, ( drawRange.start + drawRange.count ) );
+
+			for ( let i = start, il = end; i < il; i ++ ) {
+
+				const a = index.getX( i );
+
+				_position$2.fromBufferAttribute( positionAttribute, a );
+
+				testPoint( _position$2, a, localThresholdSq, matrixWorld, raycaster, intersects, this );
+
+			}
+
+		} else {
+
+			const start = Math.max( 0, drawRange.start );
+			const end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );
+
+			for ( let i = start, l = end; i < l; i ++ ) {
+
+				_position$2.fromBufferAttribute( positionAttribute, i );
+
+				testPoint( _position$2, i, localThresholdSq, matrixWorld, raycaster, intersects, this );
+
+			}
+
+		}
+
+	}
+
+	updateMorphTargets() {
+
+		const geometry = this.geometry;
+
+		const morphAttributes = geometry.morphAttributes;
+		const keys = Object.keys( morphAttributes );
+
+		if ( keys.length > 0 ) {
+
+			const morphAttribute = morphAttributes[ keys[ 0 ] ];
+
+			if ( morphAttribute !== undefined ) {
+
+				this.morphTargetInfluences = [];
+				this.morphTargetDictionary = {};
+
+				for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {
+
+					const name = morphAttribute[ m ].name || String( m );
+
+					this.morphTargetInfluences.push( 0 );
+					this.morphTargetDictionary[ name ] = m;
+
+				}
+
+			}
+
+		}
+
+	}
+
+}
+
+function testPoint( point, index, localThresholdSq, matrixWorld, raycaster, intersects, object ) {
+
+	const rayPointDistanceSq = _ray.distanceSqToPoint( point );
+
+	if ( rayPointDistanceSq < localThresholdSq ) {
+
+		const intersectPoint = new Vector3();
+
+		_ray.closestPointToPoint( point, intersectPoint );
+		intersectPoint.applyMatrix4( matrixWorld );
+
+		const distance = raycaster.ray.origin.distanceTo( intersectPoint );
+
+		if ( distance < raycaster.near || distance > raycaster.far ) return;
+
+		intersects.push( {
+
+			distance: distance,
+			distanceToRay: Math.sqrt( rayPointDistanceSq ),
+			point: intersectPoint,
+			index: index,
+			face: null,
+			object: object
+
+		} );
+
+	}
+
+}
+
+class VideoTexture extends Texture {
+
+	constructor( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
+
+		super( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+
+		this.isVideoTexture = true;
+
+		this.minFilter = minFilter !== undefined ? minFilter : LinearFilter;
+		this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;
+
+		this.generateMipmaps = false;
+
+		const scope = this;
+
+		function updateVideo() {
+
+			scope.needsUpdate = true;
+			video.requestVideoFrameCallback( updateVideo );
+
+		}
+
+		if ( 'requestVideoFrameCallback' in video ) {
+
+			video.requestVideoFrameCallback( updateVideo );
+
+		}
+
+	}
+
+	clone() {
+
+		return new this.constructor( this.image ).copy( this );
+
+	}
+
+	update() {
+
+		const video = this.image;
+		const hasVideoFrameCallback = 'requestVideoFrameCallback' in video;
+
+		if ( hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA ) {
+
+			this.needsUpdate = true;
+
+		}
+
+	}
+
+}
+
+class FramebufferTexture extends Texture {
+
+	constructor( width, height ) {
+
+		super( { width, height } );
+
+		this.isFramebufferTexture = true;
+
+		this.magFilter = NearestFilter;
+		this.minFilter = NearestFilter;
+
+		this.generateMipmaps = false;
+
+		this.needsUpdate = true;
+
+	}
+
+}
+
+class CompressedTexture extends Texture {
+
+	constructor( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace ) {
+
+		super( null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace );
+
+		this.isCompressedTexture = true;
+
+		this.image = { width: width, height: height };
+		this.mipmaps = mipmaps;
+
+		// no flipping for cube textures
+		// (also flipping doesn't work for compressed textures )
+
+		this.flipY = false;
+
+		// can't generate mipmaps for compressed textures
+		// mips must be embedded in DDS files
+
+		this.generateMipmaps = false;
+
+	}
+
+}
+
+class CompressedArrayTexture extends CompressedTexture {
+
+	constructor( mipmaps, width, height, depth, format, type ) {
+
+		super( mipmaps, width, height, format, type );
+
+		this.isCompressedArrayTexture = true;
+		this.image.depth = depth;
+		this.wrapR = ClampToEdgeWrapping;
+
+	}
+
+}
+
+class CompressedCubeTexture extends CompressedTexture {
+
+	constructor( images, format, type ) {
+
+		super( undefined, images[ 0 ].width, images[ 0 ].height, format, type, CubeReflectionMapping );
+
+		this.isCompressedCubeTexture = true;
+		this.isCubeTexture = true;
+
+		this.image = images;
+
+	}
+
+}
+
+class CanvasTexture extends Texture {
+
+	constructor( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
+
+		super( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+
+		this.isCanvasTexture = true;
+
+		this.needsUpdate = true;
+
+	}
+
+}
+
+/**
+ * Extensible curve object.
+ *
+ * Some common of curve methods:
+ * .getPoint( t, optionalTarget ), .getTangent( t, optionalTarget )
+ * .getPointAt( u, optionalTarget ), .getTangentAt( u, optionalTarget )
+ * .getPoints(), .getSpacedPoints()
+ * .getLength()
+ * .updateArcLengths()
+ *
+ * This following curves inherit from THREE.Curve:
+ *
+ * -- 2D curves --
+ * THREE.ArcCurve
+ * THREE.CubicBezierCurve
+ * THREE.EllipseCurve
+ * THREE.LineCurve
+ * THREE.QuadraticBezierCurve
+ * THREE.SplineCurve
+ *
+ * -- 3D curves --
+ * THREE.CatmullRomCurve3
+ * THREE.CubicBezierCurve3
+ * THREE.LineCurve3
+ * THREE.QuadraticBezierCurve3
+ *
+ * A series of curves can be represented as a THREE.CurvePath.
+ *
+ **/
+
+class Curve {
+
+	constructor() {
+
+		this.type = 'Curve';
+
+		this.arcLengthDivisions = 200;
+
+	}
+
+	// Virtual base class method to overwrite and implement in subclasses
+	//	- t [0 .. 1]
+
+	getPoint( /* t, optionalTarget */ ) {
+
+		console.warn( 'THREE.Curve: .getPoint() not implemented.' );
+		return null;
+
+	}
+
+	// Get point at relative position in curve according to arc length
+	// - u [0 .. 1]
+
+	getPointAt( u, optionalTarget ) {
+
+		const t = this.getUtoTmapping( u );
+		return this.getPoint( t, optionalTarget );
+
+	}
+
+	// Get sequence of points using getPoint( t )
+
+	getPoints( divisions = 5 ) {
+
+		const points = [];
+
+		for ( let d = 0; d <= divisions; d ++ ) {
+
+			points.push( this.getPoint( d / divisions ) );
+
+		}
+
+		return points;
+
+	}
+
+	// Get sequence of points using getPointAt( u )
+
+	getSpacedPoints( divisions = 5 ) {
+
+		const points = [];
+
+		for ( let d = 0; d <= divisions; d ++ ) {
+
+			points.push( this.getPointAt( d / divisions ) );
+
+		}
+
+		return points;
+
+	}
+
+	// Get total curve arc length
+
+	getLength() {
+
+		const lengths = this.getLengths();
+		return lengths[ lengths.length - 1 ];
+
+	}
+
+	// Get list of cumulative segment lengths
+
+	getLengths( divisions = this.arcLengthDivisions ) {
+
+		if ( this.cacheArcLengths &&
+			( this.cacheArcLengths.length === divisions + 1 ) &&
+			! this.needsUpdate ) {
+
+			return this.cacheArcLengths;
+
+		}
+
+		this.needsUpdate = false;
+
+		const cache = [];
+		let current, last = this.getPoint( 0 );
+		let sum = 0;
+
+		cache.push( 0 );
+
+		for ( let p = 1; p <= divisions; p ++ ) {
+
+			current = this.getPoint( p / divisions );
+			sum += current.distanceTo( last );
+			cache.push( sum );
+			last = current;
+
+		}
+
+		this.cacheArcLengths = cache;
+
+		return cache; // { sums: cache, sum: sum }; Sum is in the last element.
+
+	}
+
+	updateArcLengths() {
+
+		this.needsUpdate = true;
+		this.getLengths();
+
+	}
+
+	// Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
+
+	getUtoTmapping( u, distance ) {
+
+		const arcLengths = this.getLengths();
+
+		let i = 0;
+		const il = arcLengths.length;
+
+		let targetArcLength; // The targeted u distance value to get
+
+		if ( distance ) {
+
+			targetArcLength = distance;
+
+		} else {
+
+			targetArcLength = u * arcLengths[ il - 1 ];
+
+		}
+
+		// binary search for the index with largest value smaller than target u distance
+
+		let low = 0, high = il - 1, comparison;
+
+		while ( low <= high ) {
+
+			i = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
+
+			comparison = arcLengths[ i ] - targetArcLength;
+
+			if ( comparison < 0 ) {
+
+				low = i + 1;
+
+			} else if ( comparison > 0 ) {
+
+				high = i - 1;
+
+			} else {
+
+				high = i;
+				break;
+
+				// DONE
+
+			}
+
+		}
+
+		i = high;
+
+		if ( arcLengths[ i ] === targetArcLength ) {
+
+			return i / ( il - 1 );
+
+		}
+
+		// we could get finer grain at lengths, or use simple interpolation between two points
+
+		const lengthBefore = arcLengths[ i ];
+		const lengthAfter = arcLengths[ i + 1 ];
+
+		const segmentLength = lengthAfter - lengthBefore;
+
+		// determine where we are between the 'before' and 'after' points
+
+		const segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;
+
+		// add that fractional amount to t
+
+		const t = ( i + segmentFraction ) / ( il - 1 );
+
+		return t;
+
+	}
+
+	// Returns a unit vector tangent at t
+	// In case any sub curve does not implement its tangent derivation,
+	// 2 points a small delta apart will be used to find its gradient
+	// which seems to give a reasonable approximation
+
+	getTangent( t, optionalTarget ) {
+
+		const delta = 0.0001;
+		let t1 = t - delta;
+		let t2 = t + delta;
+
+		// Capping in case of danger
+
+		if ( t1 < 0 ) t1 = 0;
+		if ( t2 > 1 ) t2 = 1;
+
+		const pt1 = this.getPoint( t1 );
+		const pt2 = this.getPoint( t2 );
+
+		const tangent = optionalTarget || ( ( pt1.isVector2 ) ? new Vector2() : new Vector3() );
+
+		tangent.copy( pt2 ).sub( pt1 ).normalize();
+
+		return tangent;
+
+	}
+
+	getTangentAt( u, optionalTarget ) {
+
+		const t = this.getUtoTmapping( u );
+		return this.getTangent( t, optionalTarget );
+
+	}
+
+	computeFrenetFrames( segments, closed ) {
+
+		// see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
+
+		const normal = new Vector3();
+
+		const tangents = [];
+		const normals = [];
+		const binormals = [];
+
+		const vec = new Vector3();
+		const mat = new Matrix4();
+
+		// compute the tangent vectors for each segment on the curve
+
+		for ( let i = 0; i <= segments; i ++ ) {
+
+			const u = i / segments;
+
+			tangents[ i ] = this.getTangentAt( u, new Vector3() );
+
+		}
+
+		// select an initial normal vector perpendicular to the first tangent vector,
+		// and in the direction of the minimum tangent xyz component
+
+		normals[ 0 ] = new Vector3();
+		binormals[ 0 ] = new Vector3();
+		let min = Number.MAX_VALUE;
+		const tx = Math.abs( tangents[ 0 ].x );
+		const ty = Math.abs( tangents[ 0 ].y );
+		const tz = Math.abs( tangents[ 0 ].z );
+
+		if ( tx <= min ) {
+
+			min = tx;
+			normal.set( 1, 0, 0 );
+
+		}
+
+		if ( ty <= min ) {
+
+			min = ty;
+			normal.set( 0, 1, 0 );
+
+		}
+
+		if ( tz <= min ) {
+
+			normal.set( 0, 0, 1 );
+
+		}
+
+		vec.crossVectors( tangents[ 0 ], normal ).normalize();
+
+		normals[ 0 ].crossVectors( tangents[ 0 ], vec );
+		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );
+
+
+		// compute the slowly-varying normal and binormal vectors for each segment on the curve
+
+		for ( let i = 1; i <= segments; i ++ ) {
+
+			normals[ i ] = normals[ i - 1 ].clone();
+
+			binormals[ i ] = binormals[ i - 1 ].clone();
+
+			vec.crossVectors( tangents[ i - 1 ], tangents[ i ] );
+
+			if ( vec.length() > Number.EPSILON ) {
+
+				vec.normalize();
+
+				const theta = Math.acos( clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors
+
+				normals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );
+
+			}
+
+			binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );
+
+		}
+
+		// if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
+
+		if ( closed === true ) {
+
+			let theta = Math.acos( clamp( normals[ 0 ].dot( normals[ segments ] ), - 1, 1 ) );
+			theta /= segments;
+
+			if ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ segments ] ) ) > 0 ) {
+
+				theta = - theta;
+
+			}
+
+			for ( let i = 1; i <= segments; i ++ ) {
+
+				// twist a little...
+				normals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );
+				binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );
+
+			}
+
+		}
+
+		return {
+			tangents: tangents,
+			normals: normals,
+			binormals: binormals
+		};
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( source ) {
+
+		this.arcLengthDivisions = source.arcLengthDivisions;
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = {
+			metadata: {
+				version: 4.6,
+				type: 'Curve',
+				generator: 'Curve.toJSON'
+			}
+		};
+
+		data.arcLengthDivisions = this.arcLengthDivisions;
+		data.type = this.type;
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		this.arcLengthDivisions = json.arcLengthDivisions;
+
+		return this;
+
+	}
+
+}
+
+class EllipseCurve extends Curve {
+
+	constructor( aX = 0, aY = 0, xRadius = 1, yRadius = 1, aStartAngle = 0, aEndAngle = Math.PI * 2, aClockwise = false, aRotation = 0 ) {
+
+		super();
+
+		this.isEllipseCurve = true;
+
+		this.type = 'EllipseCurve';
+
+		this.aX = aX;
+		this.aY = aY;
+
+		this.xRadius = xRadius;
+		this.yRadius = yRadius;
+
+		this.aStartAngle = aStartAngle;
+		this.aEndAngle = aEndAngle;
+
+		this.aClockwise = aClockwise;
+
+		this.aRotation = aRotation;
+
+	}
+
+	getPoint( t, optionalTarget ) {
+
+		const point = optionalTarget || new Vector2();
+
+		const twoPi = Math.PI * 2;
+		let deltaAngle = this.aEndAngle - this.aStartAngle;
+		const samePoints = Math.abs( deltaAngle ) < Number.EPSILON;
+
+		// ensures that deltaAngle is 0 .. 2 PI
+		while ( deltaAngle < 0 ) deltaAngle += twoPi;
+		while ( deltaAngle > twoPi ) deltaAngle -= twoPi;
+
+		if ( deltaAngle < Number.EPSILON ) {
+
+			if ( samePoints ) {
+
+				deltaAngle = 0;
+
+			} else {
+
+				deltaAngle = twoPi;
+
+			}
+
+		}
+
+		if ( this.aClockwise === true && ! samePoints ) {
+
+			if ( deltaAngle === twoPi ) {
+
+				deltaAngle = - twoPi;
+
+			} else {
+
+				deltaAngle = deltaAngle - twoPi;
+
+			}
+
+		}
+
+		const angle = this.aStartAngle + t * deltaAngle;
+		let x = this.aX + this.xRadius * Math.cos( angle );
+		let y = this.aY + this.yRadius * Math.sin( angle );
+
+		if ( this.aRotation !== 0 ) {
+
+			const cos = Math.cos( this.aRotation );
+			const sin = Math.sin( this.aRotation );
+
+			const tx = x - this.aX;
+			const ty = y - this.aY;
+
+			// Rotate the point about the center of the ellipse.
+			x = tx * cos - ty * sin + this.aX;
+			y = tx * sin + ty * cos + this.aY;
+
+		}
+
+		return point.set( x, y );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.aX = source.aX;
+		this.aY = source.aY;
+
+		this.xRadius = source.xRadius;
+		this.yRadius = source.yRadius;
+
+		this.aStartAngle = source.aStartAngle;
+		this.aEndAngle = source.aEndAngle;
+
+		this.aClockwise = source.aClockwise;
+
+		this.aRotation = source.aRotation;
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.aX = this.aX;
+		data.aY = this.aY;
+
+		data.xRadius = this.xRadius;
+		data.yRadius = this.yRadius;
+
+		data.aStartAngle = this.aStartAngle;
+		data.aEndAngle = this.aEndAngle;
+
+		data.aClockwise = this.aClockwise;
+
+		data.aRotation = this.aRotation;
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.aX = json.aX;
+		this.aY = json.aY;
+
+		this.xRadius = json.xRadius;
+		this.yRadius = json.yRadius;
+
+		this.aStartAngle = json.aStartAngle;
+		this.aEndAngle = json.aEndAngle;
+
+		this.aClockwise = json.aClockwise;
+
+		this.aRotation = json.aRotation;
+
+		return this;
+
+	}
+
+}
+
+class ArcCurve extends EllipseCurve {
+
+	constructor( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
+
+		super( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );
+
+		this.isArcCurve = true;
+
+		this.type = 'ArcCurve';
+
+	}
+
+}
+
+/**
+ * Centripetal CatmullRom Curve - which is useful for avoiding
+ * cusps and self-intersections in non-uniform catmull rom curves.
+ * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
+ *
+ * curve.type accepts centripetal(default), chordal and catmullrom
+ * curve.tension is used for catmullrom which defaults to 0.5
+ */
+
+
+/*
+Based on an optimized c++ solution in
+ - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/
+ - http://ideone.com/NoEbVM
+
+This CubicPoly class could be used for reusing some variables and calculations,
+but for three.js curve use, it could be possible inlined and flatten into a single function call
+which can be placed in CurveUtils.
+*/
+
+function CubicPoly() {
+
+	let c0 = 0, c1 = 0, c2 = 0, c3 = 0;
+
+	/*
+	 * Compute coefficients for a cubic polynomial
+	 *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
+	 * such that
+	 *   p(0) = x0, p(1) = x1
+	 *  and
+	 *   p'(0) = t0, p'(1) = t1.
+	 */
+	function init( x0, x1, t0, t1 ) {
+
+		c0 = x0;
+		c1 = t0;
+		c2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;
+		c3 = 2 * x0 - 2 * x1 + t0 + t1;
+
+	}
+
+	return {
+
+		initCatmullRom: function ( x0, x1, x2, x3, tension ) {
+
+			init( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );
+
+		},
+
+		initNonuniformCatmullRom: function ( x0, x1, x2, x3, dt0, dt1, dt2 ) {
+
+			// compute tangents when parameterized in [t1,t2]
+			let t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;
+			let t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;
+
+			// rescale tangents for parametrization in [0,1]
+			t1 *= dt1;
+			t2 *= dt1;
+
+			init( x1, x2, t1, t2 );
+
+		},
+
+		calc: function ( t ) {
+
+			const t2 = t * t;
+			const t3 = t2 * t;
+			return c0 + c1 * t + c2 * t2 + c3 * t3;
+
+		}
+
+	};
+
+}
+
+//
+
+const tmp = /*@__PURE__*/ new Vector3();
+const px = /*@__PURE__*/ new CubicPoly();
+const py = /*@__PURE__*/ new CubicPoly();
+const pz = /*@__PURE__*/ new CubicPoly();
+
+class CatmullRomCurve3 extends Curve {
+
+	constructor( points = [], closed = false, curveType = 'centripetal', tension = 0.5 ) {
+
+		super();
+
+		this.isCatmullRomCurve3 = true;
+
+		this.type = 'CatmullRomCurve3';
+
+		this.points = points;
+		this.closed = closed;
+		this.curveType = curveType;
+		this.tension = tension;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector3() ) {
+
+		const point = optionalTarget;
+
+		const points = this.points;
+		const l = points.length;
+
+		const p = ( l - ( this.closed ? 0 : 1 ) ) * t;
+		let intPoint = Math.floor( p );
+		let weight = p - intPoint;
+
+		if ( this.closed ) {
+
+			intPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / l ) + 1 ) * l;
+
+		} else if ( weight === 0 && intPoint === l - 1 ) {
+
+			intPoint = l - 2;
+			weight = 1;
+
+		}
+
+		let p0, p3; // 4 points (p1 & p2 defined below)
+
+		if ( this.closed || intPoint > 0 ) {
+
+			p0 = points[ ( intPoint - 1 ) % l ];
+
+		} else {
+
+			// extrapolate first point
+			tmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );
+			p0 = tmp;
+
+		}
+
+		const p1 = points[ intPoint % l ];
+		const p2 = points[ ( intPoint + 1 ) % l ];
+
+		if ( this.closed || intPoint + 2 < l ) {
+
+			p3 = points[ ( intPoint + 2 ) % l ];
+
+		} else {
+
+			// extrapolate last point
+			tmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );
+			p3 = tmp;
+
+		}
+
+		if ( this.curveType === 'centripetal' || this.curveType === 'chordal' ) {
+
+			// init Centripetal / Chordal Catmull-Rom
+			const pow = this.curveType === 'chordal' ? 0.5 : 0.25;
+			let dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );
+			let dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );
+			let dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );
+
+			// safety check for repeated points
+			if ( dt1 < 1e-4 ) dt1 = 1.0;
+			if ( dt0 < 1e-4 ) dt0 = dt1;
+			if ( dt2 < 1e-4 ) dt2 = dt1;
+
+			px.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );
+			py.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );
+			pz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );
+
+		} else if ( this.curveType === 'catmullrom' ) {
+
+			px.initCatmullRom( p0.x, p1.x, p2.x, p3.x, this.tension );
+			py.initCatmullRom( p0.y, p1.y, p2.y, p3.y, this.tension );
+			pz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, this.tension );
+
+		}
+
+		point.set(
+			px.calc( weight ),
+			py.calc( weight ),
+			pz.calc( weight )
+		);
+
+		return point;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.points = [];
+
+		for ( let i = 0, l = source.points.length; i < l; i ++ ) {
+
+			const point = source.points[ i ];
+
+			this.points.push( point.clone() );
+
+		}
+
+		this.closed = source.closed;
+		this.curveType = source.curveType;
+		this.tension = source.tension;
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.points = [];
+
+		for ( let i = 0, l = this.points.length; i < l; i ++ ) {
+
+			const point = this.points[ i ];
+			data.points.push( point.toArray() );
+
+		}
+
+		data.closed = this.closed;
+		data.curveType = this.curveType;
+		data.tension = this.tension;
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.points = [];
+
+		for ( let i = 0, l = json.points.length; i < l; i ++ ) {
+
+			const point = json.points[ i ];
+			this.points.push( new Vector3().fromArray( point ) );
+
+		}
+
+		this.closed = json.closed;
+		this.curveType = json.curveType;
+		this.tension = json.tension;
+
+		return this;
+
+	}
+
+}
+
+/**
+ * Bezier Curves formulas obtained from
+ * https://en.wikipedia.org/wiki/B%C3%A9zier_curve
+ */
+
+function CatmullRom( t, p0, p1, p2, p3 ) {
+
+	const v0 = ( p2 - p0 ) * 0.5;
+	const v1 = ( p3 - p1 ) * 0.5;
+	const t2 = t * t;
+	const t3 = t * t2;
+	return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;
+
+}
+
+//
+
+function QuadraticBezierP0( t, p ) {
+
+	const k = 1 - t;
+	return k * k * p;
+
+}
+
+function QuadraticBezierP1( t, p ) {
+
+	return 2 * ( 1 - t ) * t * p;
+
+}
+
+function QuadraticBezierP2( t, p ) {
+
+	return t * t * p;
+
+}
+
+function QuadraticBezier( t, p0, p1, p2 ) {
+
+	return QuadraticBezierP0( t, p0 ) + QuadraticBezierP1( t, p1 ) +
+		QuadraticBezierP2( t, p2 );
+
+}
+
+//
+
+function CubicBezierP0( t, p ) {
+
+	const k = 1 - t;
+	return k * k * k * p;
+
+}
+
+function CubicBezierP1( t, p ) {
+
+	const k = 1 - t;
+	return 3 * k * k * t * p;
+
+}
+
+function CubicBezierP2( t, p ) {
+
+	return 3 * ( 1 - t ) * t * t * p;
+
+}
+
+function CubicBezierP3( t, p ) {
+
+	return t * t * t * p;
+
+}
+
+function CubicBezier( t, p0, p1, p2, p3 ) {
+
+	return CubicBezierP0( t, p0 ) + CubicBezierP1( t, p1 ) + CubicBezierP2( t, p2 ) +
+		CubicBezierP3( t, p3 );
+
+}
+
+class CubicBezierCurve extends Curve {
+
+	constructor( v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2(), v3 = new Vector2() ) {
+
+		super();
+
+		this.isCubicBezierCurve = true;
+
+		this.type = 'CubicBezierCurve';
+
+		this.v0 = v0;
+		this.v1 = v1;
+		this.v2 = v2;
+		this.v3 = v3;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector2() ) {
+
+		const point = optionalTarget;
+
+		const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;
+
+		point.set(
+			CubicBezier( t, v0.x, v1.x, v2.x, v3.x ),
+			CubicBezier( t, v0.y, v1.y, v2.y, v3.y )
+		);
+
+		return point;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.v0.copy( source.v0 );
+		this.v1.copy( source.v1 );
+		this.v2.copy( source.v2 );
+		this.v3.copy( source.v3 );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.v0 = this.v0.toArray();
+		data.v1 = this.v1.toArray();
+		data.v2 = this.v2.toArray();
+		data.v3 = this.v3.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.v0.fromArray( json.v0 );
+		this.v1.fromArray( json.v1 );
+		this.v2.fromArray( json.v2 );
+		this.v3.fromArray( json.v3 );
+
+		return this;
+
+	}
+
+}
+
+class CubicBezierCurve3 extends Curve {
+
+	constructor( v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3(), v3 = new Vector3() ) {
+
+		super();
+
+		this.isCubicBezierCurve3 = true;
+
+		this.type = 'CubicBezierCurve3';
+
+		this.v0 = v0;
+		this.v1 = v1;
+		this.v2 = v2;
+		this.v3 = v3;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector3() ) {
+
+		const point = optionalTarget;
+
+		const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;
+
+		point.set(
+			CubicBezier( t, v0.x, v1.x, v2.x, v3.x ),
+			CubicBezier( t, v0.y, v1.y, v2.y, v3.y ),
+			CubicBezier( t, v0.z, v1.z, v2.z, v3.z )
+		);
+
+		return point;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.v0.copy( source.v0 );
+		this.v1.copy( source.v1 );
+		this.v2.copy( source.v2 );
+		this.v3.copy( source.v3 );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.v0 = this.v0.toArray();
+		data.v1 = this.v1.toArray();
+		data.v2 = this.v2.toArray();
+		data.v3 = this.v3.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.v0.fromArray( json.v0 );
+		this.v1.fromArray( json.v1 );
+		this.v2.fromArray( json.v2 );
+		this.v3.fromArray( json.v3 );
+
+		return this;
+
+	}
+
+}
+
+class LineCurve extends Curve {
+
+	constructor( v1 = new Vector2(), v2 = new Vector2() ) {
+
+		super();
+
+		this.isLineCurve = true;
+
+		this.type = 'LineCurve';
+
+		this.v1 = v1;
+		this.v2 = v2;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector2() ) {
+
+		const point = optionalTarget;
+
+		if ( t === 1 ) {
+
+			point.copy( this.v2 );
+
+		} else {
+
+			point.copy( this.v2 ).sub( this.v1 );
+			point.multiplyScalar( t ).add( this.v1 );
+
+		}
+
+		return point;
+
+	}
+
+	// Line curve is linear, so we can overwrite default getPointAt
+	getPointAt( u, optionalTarget ) {
+
+		return this.getPoint( u, optionalTarget );
+
+	}
+
+	getTangent( t, optionalTarget = new Vector2() ) {
+
+		return optionalTarget.subVectors( this.v2, this.v1 ).normalize();
+
+	}
+
+	getTangentAt( u, optionalTarget ) {
+
+		return this.getTangent( u, optionalTarget );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.v1.copy( source.v1 );
+		this.v2.copy( source.v2 );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.v1 = this.v1.toArray();
+		data.v2 = this.v2.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.v1.fromArray( json.v1 );
+		this.v2.fromArray( json.v2 );
+
+		return this;
+
+	}
+
+}
+
+class LineCurve3 extends Curve {
+
+	constructor( v1 = new Vector3(), v2 = new Vector3() ) {
+
+		super();
+
+		this.isLineCurve3 = true;
+
+		this.type = 'LineCurve3';
+
+		this.v1 = v1;
+		this.v2 = v2;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector3() ) {
+
+		const point = optionalTarget;
+
+		if ( t === 1 ) {
+
+			point.copy( this.v2 );
+
+		} else {
+
+			point.copy( this.v2 ).sub( this.v1 );
+			point.multiplyScalar( t ).add( this.v1 );
+
+		}
+
+		return point;
+
+	}
+
+	// Line curve is linear, so we can overwrite default getPointAt
+	getPointAt( u, optionalTarget ) {
+
+		return this.getPoint( u, optionalTarget );
+
+	}
+
+	getTangent( t, optionalTarget = new Vector3() ) {
+
+		return optionalTarget.subVectors( this.v2, this.v1 ).normalize();
+
+	}
+
+	getTangentAt( u, optionalTarget ) {
+
+		return this.getTangent( u, optionalTarget );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.v1.copy( source.v1 );
+		this.v2.copy( source.v2 );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.v1 = this.v1.toArray();
+		data.v2 = this.v2.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.v1.fromArray( json.v1 );
+		this.v2.fromArray( json.v2 );
+
+		return this;
+
+	}
+
+}
+
+class QuadraticBezierCurve extends Curve {
+
+	constructor( v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2() ) {
+
+		super();
+
+		this.isQuadraticBezierCurve = true;
+
+		this.type = 'QuadraticBezierCurve';
+
+		this.v0 = v0;
+		this.v1 = v1;
+		this.v2 = v2;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector2() ) {
+
+		const point = optionalTarget;
+
+		const v0 = this.v0, v1 = this.v1, v2 = this.v2;
+
+		point.set(
+			QuadraticBezier( t, v0.x, v1.x, v2.x ),
+			QuadraticBezier( t, v0.y, v1.y, v2.y )
+		);
+
+		return point;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.v0.copy( source.v0 );
+		this.v1.copy( source.v1 );
+		this.v2.copy( source.v2 );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.v0 = this.v0.toArray();
+		data.v1 = this.v1.toArray();
+		data.v2 = this.v2.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.v0.fromArray( json.v0 );
+		this.v1.fromArray( json.v1 );
+		this.v2.fromArray( json.v2 );
+
+		return this;
+
+	}
+
+}
+
+class QuadraticBezierCurve3 extends Curve {
+
+	constructor( v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3() ) {
+
+		super();
+
+		this.isQuadraticBezierCurve3 = true;
+
+		this.type = 'QuadraticBezierCurve3';
+
+		this.v0 = v0;
+		this.v1 = v1;
+		this.v2 = v2;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector3() ) {
+
+		const point = optionalTarget;
+
+		const v0 = this.v0, v1 = this.v1, v2 = this.v2;
+
+		point.set(
+			QuadraticBezier( t, v0.x, v1.x, v2.x ),
+			QuadraticBezier( t, v0.y, v1.y, v2.y ),
+			QuadraticBezier( t, v0.z, v1.z, v2.z )
+		);
+
+		return point;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.v0.copy( source.v0 );
+		this.v1.copy( source.v1 );
+		this.v2.copy( source.v2 );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.v0 = this.v0.toArray();
+		data.v1 = this.v1.toArray();
+		data.v2 = this.v2.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.v0.fromArray( json.v0 );
+		this.v1.fromArray( json.v1 );
+		this.v2.fromArray( json.v2 );
+
+		return this;
+
+	}
+
+}
+
+class SplineCurve extends Curve {
+
+	constructor( points = [] ) {
+
+		super();
+
+		this.isSplineCurve = true;
+
+		this.type = 'SplineCurve';
+
+		this.points = points;
+
+	}
+
+	getPoint( t, optionalTarget = new Vector2() ) {
+
+		const point = optionalTarget;
+
+		const points = this.points;
+		const p = ( points.length - 1 ) * t;
+
+		const intPoint = Math.floor( p );
+		const weight = p - intPoint;
+
+		const p0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];
+		const p1 = points[ intPoint ];
+		const p2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];
+		const p3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];
+
+		point.set(
+			CatmullRom( weight, p0.x, p1.x, p2.x, p3.x ),
+			CatmullRom( weight, p0.y, p1.y, p2.y, p3.y )
+		);
+
+		return point;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.points = [];
+
+		for ( let i = 0, l = source.points.length; i < l; i ++ ) {
+
+			const point = source.points[ i ];
+
+			this.points.push( point.clone() );
+
+		}
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.points = [];
+
+		for ( let i = 0, l = this.points.length; i < l; i ++ ) {
+
+			const point = this.points[ i ];
+			data.points.push( point.toArray() );
+
+		}
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.points = [];
+
+		for ( let i = 0, l = json.points.length; i < l; i ++ ) {
+
+			const point = json.points[ i ];
+			this.points.push( new Vector2().fromArray( point ) );
+
+		}
+
+		return this;
+
+	}
+
+}
+
+var Curves = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	ArcCurve: ArcCurve,
+	CatmullRomCurve3: CatmullRomCurve3,
+	CubicBezierCurve: CubicBezierCurve,
+	CubicBezierCurve3: CubicBezierCurve3,
+	EllipseCurve: EllipseCurve,
+	LineCurve: LineCurve,
+	LineCurve3: LineCurve3,
+	QuadraticBezierCurve: QuadraticBezierCurve,
+	QuadraticBezierCurve3: QuadraticBezierCurve3,
+	SplineCurve: SplineCurve
+});
+
+/**************************************************************
+ *	Curved Path - a curve path is simply a array of connected
+ *  curves, but retains the api of a curve
+ **************************************************************/
+
+class CurvePath extends Curve {
+
+	constructor() {
+
+		super();
+
+		this.type = 'CurvePath';
+
+		this.curves = [];
+		this.autoClose = false; // Automatically closes the path
+
+	}
+
+	add( curve ) {
+
+		this.curves.push( curve );
+
+	}
+
+	closePath() {
+
+		// Add a line curve if start and end of lines are not connected
+		const startPoint = this.curves[ 0 ].getPoint( 0 );
+		const endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );
+
+		if ( ! startPoint.equals( endPoint ) ) {
+
+			const lineType = ( startPoint.isVector2 === true ) ? 'LineCurve' : 'LineCurve3';
+			this.curves.push( new Curves[ lineType ]( endPoint, startPoint ) );
+
+		}
+
+		return this;
+
+	}
+
+	// To get accurate point with reference to
+	// entire path distance at time t,
+	// following has to be done:
+
+	// 1. Length of each sub path have to be known
+	// 2. Locate and identify type of curve
+	// 3. Get t for the curve
+	// 4. Return curve.getPointAt(t')
+
+	getPoint( t, optionalTarget ) {
+
+		const d = t * this.getLength();
+		const curveLengths = this.getCurveLengths();
+		let i = 0;
+
+		// To think about boundaries points.
+
+		while ( i < curveLengths.length ) {
+
+			if ( curveLengths[ i ] >= d ) {
+
+				const diff = curveLengths[ i ] - d;
+				const curve = this.curves[ i ];
+
+				const segmentLength = curve.getLength();
+				const u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;
+
+				return curve.getPointAt( u, optionalTarget );
+
+			}
+
+			i ++;
+
+		}
+
+		return null;
+
+		// loop where sum != 0, sum > d , sum+1 <d
+
+	}
+
+	// We cannot use the default THREE.Curve getPoint() with getLength() because in
+	// THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
+	// getPoint() depends on getLength
+
+	getLength() {
+
+		const lens = this.getCurveLengths();
+		return lens[ lens.length - 1 ];
+
+	}
+
+	// cacheLengths must be recalculated.
+	updateArcLengths() {
+
+		this.needsUpdate = true;
+		this.cacheLengths = null;
+		this.getCurveLengths();
+
+	}
+
+	// Compute lengths and cache them
+	// We cannot overwrite getLengths() because UtoT mapping uses it.
+
+	getCurveLengths() {
+
+		// We use cache values if curves and cache array are same length
+
+		if ( this.cacheLengths && this.cacheLengths.length === this.curves.length ) {
+
+			return this.cacheLengths;
+
+		}
+
+		// Get length of sub-curve
+		// Push sums into cached array
+
+		const lengths = [];
+		let sums = 0;
+
+		for ( let i = 0, l = this.curves.length; i < l; i ++ ) {
+
+			sums += this.curves[ i ].getLength();
+			lengths.push( sums );
+
+		}
+
+		this.cacheLengths = lengths;
+
+		return lengths;
+
+	}
+
+	getSpacedPoints( divisions = 40 ) {
+
+		const points = [];
+
+		for ( let i = 0; i <= divisions; i ++ ) {
+
+			points.push( this.getPoint( i / divisions ) );
+
+		}
+
+		if ( this.autoClose ) {
+
+			points.push( points[ 0 ] );
+
+		}
+
+		return points;
+
+	}
+
+	getPoints( divisions = 12 ) {
+
+		const points = [];
+		let last;
+
+		for ( let i = 0, curves = this.curves; i < curves.length; i ++ ) {
+
+			const curve = curves[ i ];
+			const resolution = curve.isEllipseCurve ? divisions * 2
+				: ( curve.isLineCurve || curve.isLineCurve3 ) ? 1
+					: curve.isSplineCurve ? divisions * curve.points.length
+						: divisions;
+
+			const pts = curve.getPoints( resolution );
+
+			for ( let j = 0; j < pts.length; j ++ ) {
+
+				const point = pts[ j ];
+
+				if ( last && last.equals( point ) ) continue; // ensures no consecutive points are duplicates
+
+				points.push( point );
+				last = point;
+
+			}
+
+		}
+
+		if ( this.autoClose && points.length > 1 && ! points[ points.length - 1 ].equals( points[ 0 ] ) ) {
+
+			points.push( points[ 0 ] );
+
+		}
+
+		return points;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.curves = [];
+
+		for ( let i = 0, l = source.curves.length; i < l; i ++ ) {
+
+			const curve = source.curves[ i ];
+
+			this.curves.push( curve.clone() );
+
+		}
+
+		this.autoClose = source.autoClose;
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.autoClose = this.autoClose;
+		data.curves = [];
+
+		for ( let i = 0, l = this.curves.length; i < l; i ++ ) {
+
+			const curve = this.curves[ i ];
+			data.curves.push( curve.toJSON() );
+
+		}
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.autoClose = json.autoClose;
+		this.curves = [];
+
+		for ( let i = 0, l = json.curves.length; i < l; i ++ ) {
+
+			const curve = json.curves[ i ];
+			this.curves.push( new Curves[ curve.type ]().fromJSON( curve ) );
+
+		}
+
+		return this;
+
+	}
+
+}
+
+class Path extends CurvePath {
+
+	constructor( points ) {
+
+		super();
+
+		this.type = 'Path';
+
+		this.currentPoint = new Vector2();
+
+		if ( points ) {
+
+			this.setFromPoints( points );
+
+		}
+
+	}
+
+	setFromPoints( points ) {
+
+		this.moveTo( points[ 0 ].x, points[ 0 ].y );
+
+		for ( let i = 1, l = points.length; i < l; i ++ ) {
+
+			this.lineTo( points[ i ].x, points[ i ].y );
+
+		}
+
+		return this;
+
+	}
+
+	moveTo( x, y ) {
+
+		this.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying?
+
+		return this;
+
+	}
+
+	lineTo( x, y ) {
+
+		const curve = new LineCurve( this.currentPoint.clone(), new Vector2( x, y ) );
+		this.curves.push( curve );
+
+		this.currentPoint.set( x, y );
+
+		return this;
+
+	}
+
+	quadraticCurveTo( aCPx, aCPy, aX, aY ) {
+
+		const curve = new QuadraticBezierCurve(
+			this.currentPoint.clone(),
+			new Vector2( aCPx, aCPy ),
+			new Vector2( aX, aY )
+		);
+
+		this.curves.push( curve );
+
+		this.currentPoint.set( aX, aY );
+
+		return this;
+
+	}
+
+	bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {
+
+		const curve = new CubicBezierCurve(
+			this.currentPoint.clone(),
+			new Vector2( aCP1x, aCP1y ),
+			new Vector2( aCP2x, aCP2y ),
+			new Vector2( aX, aY )
+		);
+
+		this.curves.push( curve );
+
+		this.currentPoint.set( aX, aY );
+
+		return this;
+
+	}
+
+	splineThru( pts /*Array of Vector*/ ) {
+
+		const npts = [ this.currentPoint.clone() ].concat( pts );
+
+		const curve = new SplineCurve( npts );
+		this.curves.push( curve );
+
+		this.currentPoint.copy( pts[ pts.length - 1 ] );
+
+		return this;
+
+	}
+
+	arc( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
+
+		const x0 = this.currentPoint.x;
+		const y0 = this.currentPoint.y;
+
+		this.absarc( aX + x0, aY + y0, aRadius,
+			aStartAngle, aEndAngle, aClockwise );
+
+		return this;
+
+	}
+
+	absarc( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
+
+		this.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );
+
+		return this;
+
+	}
+
+	ellipse( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
+
+		const x0 = this.currentPoint.x;
+		const y0 = this.currentPoint.y;
+
+		this.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );
+
+		return this;
+
+	}
+
+	absellipse( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
+
+		const curve = new EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );
+
+		if ( this.curves.length > 0 ) {
+
+			// if a previous curve is present, attempt to join
+			const firstPoint = curve.getPoint( 0 );
+
+			if ( ! firstPoint.equals( this.currentPoint ) ) {
+
+				this.lineTo( firstPoint.x, firstPoint.y );
+
+			}
+
+		}
+
+		this.curves.push( curve );
+
+		const lastPoint = curve.getPoint( 1 );
+		this.currentPoint.copy( lastPoint );
+
+		return this;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.currentPoint.copy( source.currentPoint );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.currentPoint = this.currentPoint.toArray();
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.currentPoint.fromArray( json.currentPoint );
+
+		return this;
+
+	}
+
+}
+
+class LatheGeometry extends BufferGeometry {
+
+	constructor( points = [ new Vector2( 0, - 0.5 ), new Vector2( 0.5, 0 ), new Vector2( 0, 0.5 ) ], segments = 12, phiStart = 0, phiLength = Math.PI * 2 ) {
+
+		super();
+
+		this.type = 'LatheGeometry';
+
+		this.parameters = {
+			points: points,
+			segments: segments,
+			phiStart: phiStart,
+			phiLength: phiLength
+		};
+
+		segments = Math.floor( segments );
+
+		// clamp phiLength so it's in range of [ 0, 2PI ]
+
+		phiLength = clamp( phiLength, 0, Math.PI * 2 );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const uvs = [];
+		const initNormals = [];
+		const normals = [];
+
+		// helper variables
+
+		const inverseSegments = 1.0 / segments;
+		const vertex = new Vector3();
+		const uv = new Vector2();
+		const normal = new Vector3();
+		const curNormal = new Vector3();
+		const prevNormal = new Vector3();
+		let dx = 0;
+		let dy = 0;
+
+		// pre-compute normals for initial "meridian"
+
+		for ( let j = 0; j <= ( points.length - 1 ); j ++ ) {
+
+			switch ( j ) {
+
+				case 0:				// special handling for 1st vertex on path
+
+					dx = points[ j + 1 ].x - points[ j ].x;
+					dy = points[ j + 1 ].y - points[ j ].y;
+
+					normal.x = dy * 1.0;
+					normal.y = - dx;
+					normal.z = dy * 0.0;
+
+					prevNormal.copy( normal );
+
+					normal.normalize();
+
+					initNormals.push( normal.x, normal.y, normal.z );
+
+					break;
+
+				case ( points.length - 1 ):	// special handling for last Vertex on path
+
+					initNormals.push( prevNormal.x, prevNormal.y, prevNormal.z );
+
+					break;
+
+				default:			// default handling for all vertices in between
+
+					dx = points[ j + 1 ].x - points[ j ].x;
+					dy = points[ j + 1 ].y - points[ j ].y;
+
+					normal.x = dy * 1.0;
+					normal.y = - dx;
+					normal.z = dy * 0.0;
+
+					curNormal.copy( normal );
+
+					normal.x += prevNormal.x;
+					normal.y += prevNormal.y;
+					normal.z += prevNormal.z;
+
+					normal.normalize();
+
+					initNormals.push( normal.x, normal.y, normal.z );
+
+					prevNormal.copy( curNormal );
+
+			}
+
+		}
+
+		// generate vertices, uvs and normals
+
+		for ( let i = 0; i <= segments; i ++ ) {
+
+			const phi = phiStart + i * inverseSegments * phiLength;
+
+			const sin = Math.sin( phi );
+			const cos = Math.cos( phi );
+
+			for ( let j = 0; j <= ( points.length - 1 ); j ++ ) {
+
+				// vertex
+
+				vertex.x = points[ j ].x * sin;
+				vertex.y = points[ j ].y;
+				vertex.z = points[ j ].x * cos;
+
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+				// uv
+
+				uv.x = i / segments;
+				uv.y = j / ( points.length - 1 );
+
+				uvs.push( uv.x, uv.y );
+
+				// normal
+
+				const x = initNormals[ 3 * j + 0 ] * sin;
+				const y = initNormals[ 3 * j + 1 ];
+				const z = initNormals[ 3 * j + 0 ] * cos;
+
+				normals.push( x, y, z );
+
+			}
+
+		}
+
+		// indices
+
+		for ( let i = 0; i < segments; i ++ ) {
+
+			for ( let j = 0; j < ( points.length - 1 ); j ++ ) {
+
+				const base = j + i * points.length;
+
+				const a = base;
+				const b = base + points.length;
+				const c = base + points.length + 1;
+				const d = base + 1;
+
+				// faces
+
+				indices.push( a, b, d );
+				indices.push( c, d, b );
+
+			}
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new LatheGeometry( data.points, data.segments, data.phiStart, data.phiLength );
+
+	}
+
+}
+
+class CapsuleGeometry extends LatheGeometry {
+
+	constructor( radius = 1, length = 1, capSegments = 4, radialSegments = 8 ) {
+
+		const path = new Path();
+		path.absarc( 0, - length / 2, radius, Math.PI * 1.5, 0 );
+		path.absarc( 0, length / 2, radius, 0, Math.PI * 0.5 );
+
+		super( path.getPoints( capSegments ), radialSegments );
+
+		this.type = 'CapsuleGeometry';
+
+		this.parameters = {
+			radius: radius,
+			length: length,
+			capSegments: capSegments,
+			radialSegments: radialSegments,
+		};
+
+	}
+
+	static fromJSON( data ) {
+
+		return new CapsuleGeometry( data.radius, data.length, data.capSegments, data.radialSegments );
+
+	}
+
+}
+
+class CircleGeometry extends BufferGeometry {
+
+	constructor( radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2 ) {
+
+		super();
+
+		this.type = 'CircleGeometry';
+
+		this.parameters = {
+			radius: radius,
+			segments: segments,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
+
+		segments = Math.max( 3, segments );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// helper variables
+
+		const vertex = new Vector3();
+		const uv = new Vector2();
+
+		// center point
+
+		vertices.push( 0, 0, 0 );
+		normals.push( 0, 0, 1 );
+		uvs.push( 0.5, 0.5 );
+
+		for ( let s = 0, i = 3; s <= segments; s ++, i += 3 ) {
+
+			const segment = thetaStart + s / segments * thetaLength;
+
+			// vertex
+
+			vertex.x = radius * Math.cos( segment );
+			vertex.y = radius * Math.sin( segment );
+
+			vertices.push( vertex.x, vertex.y, vertex.z );
+
+			// normal
+
+			normals.push( 0, 0, 1 );
+
+			// uvs
+
+			uv.x = ( vertices[ i ] / radius + 1 ) / 2;
+			uv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;
+
+			uvs.push( uv.x, uv.y );
+
+		}
+
+		// indices
+
+		for ( let i = 1; i <= segments; i ++ ) {
+
+			indices.push( i, i + 1, 0 );
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new CircleGeometry( data.radius, data.segments, data.thetaStart, data.thetaLength );
+
+	}
+
+}
+
+class CylinderGeometry extends BufferGeometry {
+
+	constructor( radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2 ) {
+
+		super();
+
+		this.type = 'CylinderGeometry';
+
+		this.parameters = {
+			radiusTop: radiusTop,
+			radiusBottom: radiusBottom,
+			height: height,
+			radialSegments: radialSegments,
+			heightSegments: heightSegments,
+			openEnded: openEnded,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
+
+		const scope = this;
+
+		radialSegments = Math.floor( radialSegments );
+		heightSegments = Math.floor( heightSegments );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// helper variables
+
+		let index = 0;
+		const indexArray = [];
+		const halfHeight = height / 2;
+		let groupStart = 0;
+
+		// generate geometry
+
+		generateTorso();
+
+		if ( openEnded === false ) {
+
+			if ( radiusTop > 0 ) generateCap( true );
+			if ( radiusBottom > 0 ) generateCap( false );
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+		function generateTorso() {
+
+			const normal = new Vector3();
+			const vertex = new Vector3();
+
+			let groupCount = 0;
+
+			// this will be used to calculate the normal
+			const slope = ( radiusBottom - radiusTop ) / height;
+
+			// generate vertices, normals and uvs
+
+			for ( let y = 0; y <= heightSegments; y ++ ) {
+
+				const indexRow = [];
+
+				const v = y / heightSegments;
+
+				// calculate the radius of the current row
+
+				const radius = v * ( radiusBottom - radiusTop ) + radiusTop;
+
+				for ( let x = 0; x <= radialSegments; x ++ ) {
+
+					const u = x / radialSegments;
+
+					const theta = u * thetaLength + thetaStart;
+
+					const sinTheta = Math.sin( theta );
+					const cosTheta = Math.cos( theta );
+
+					// vertex
+
+					vertex.x = radius * sinTheta;
+					vertex.y = - v * height + halfHeight;
+					vertex.z = radius * cosTheta;
+					vertices.push( vertex.x, vertex.y, vertex.z );
+
+					// normal
+
+					normal.set( sinTheta, slope, cosTheta ).normalize();
+					normals.push( normal.x, normal.y, normal.z );
+
+					// uv
+
+					uvs.push( u, 1 - v );
+
+					// save index of vertex in respective row
+
+					indexRow.push( index ++ );
+
+				}
+
+				// now save vertices of the row in our index array
+
+				indexArray.push( indexRow );
+
+			}
+
+			// generate indices
+
+			for ( let x = 0; x < radialSegments; x ++ ) {
+
+				for ( let y = 0; y < heightSegments; y ++ ) {
+
+					// we use the index array to access the correct indices
+
+					const a = indexArray[ y ][ x ];
+					const b = indexArray[ y + 1 ][ x ];
+					const c = indexArray[ y + 1 ][ x + 1 ];
+					const d = indexArray[ y ][ x + 1 ];
+
+					// faces
+
+					indices.push( a, b, d );
+					indices.push( b, c, d );
+
+					// update group counter
+
+					groupCount += 6;
+
+				}
+
+			}
+
+			// add a group to the geometry. this will ensure multi material support
+
+			scope.addGroup( groupStart, groupCount, 0 );
+
+			// calculate new start value for groups
+
+			groupStart += groupCount;
+
+		}
+
+		function generateCap( top ) {
+
+			// save the index of the first center vertex
+			const centerIndexStart = index;
+
+			const uv = new Vector2();
+			const vertex = new Vector3();
+
+			let groupCount = 0;
+
+			const radius = ( top === true ) ? radiusTop : radiusBottom;
+			const sign = ( top === true ) ? 1 : - 1;
+
+			// first we generate the center vertex data of the cap.
+			// because the geometry needs one set of uvs per face,
+			// we must generate a center vertex per face/segment
+
+			for ( let x = 1; x <= radialSegments; x ++ ) {
+
+				// vertex
+
+				vertices.push( 0, halfHeight * sign, 0 );
+
+				// normal
+
+				normals.push( 0, sign, 0 );
+
+				// uv
+
+				uvs.push( 0.5, 0.5 );
+
+				// increase index
+
+				index ++;
+
+			}
+
+			// save the index of the last center vertex
+			const centerIndexEnd = index;
+
+			// now we generate the surrounding vertices, normals and uvs
+
+			for ( let x = 0; x <= radialSegments; x ++ ) {
+
+				const u = x / radialSegments;
+				const theta = u * thetaLength + thetaStart;
+
+				const cosTheta = Math.cos( theta );
+				const sinTheta = Math.sin( theta );
+
+				// vertex
+
+				vertex.x = radius * sinTheta;
+				vertex.y = halfHeight * sign;
+				vertex.z = radius * cosTheta;
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+				// normal
+
+				normals.push( 0, sign, 0 );
+
+				// uv
+
+				uv.x = ( cosTheta * 0.5 ) + 0.5;
+				uv.y = ( sinTheta * 0.5 * sign ) + 0.5;
+				uvs.push( uv.x, uv.y );
+
+				// increase index
+
+				index ++;
+
+			}
+
+			// generate indices
+
+			for ( let x = 0; x < radialSegments; x ++ ) {
+
+				const c = centerIndexStart + x;
+				const i = centerIndexEnd + x;
+
+				if ( top === true ) {
+
+					// face top
+
+					indices.push( i, i + 1, c );
+
+				} else {
+
+					// face bottom
+
+					indices.push( i + 1, i, c );
+
+				}
+
+				groupCount += 3;
+
+			}
+
+			// add a group to the geometry. this will ensure multi material support
+
+			scope.addGroup( groupStart, groupCount, top === true ? 1 : 2 );
+
+			// calculate new start value for groups
+
+			groupStart += groupCount;
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new CylinderGeometry( data.radiusTop, data.radiusBottom, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength );
+
+	}
+
+}
+
+class ConeGeometry extends CylinderGeometry {
+
+	constructor( radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2 ) {
+
+		super( 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );
+
+		this.type = 'ConeGeometry';
+
+		this.parameters = {
+			radius: radius,
+			height: height,
+			radialSegments: radialSegments,
+			heightSegments: heightSegments,
+			openEnded: openEnded,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
+
+	}
+
+	static fromJSON( data ) {
+
+		return new ConeGeometry( data.radius, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength );
+
+	}
+
+}
+
+class PolyhedronGeometry extends BufferGeometry {
+
+	constructor( vertices = [], indices = [], radius = 1, detail = 0 ) {
+
+		super();
+
+		this.type = 'PolyhedronGeometry';
+
+		this.parameters = {
+			vertices: vertices,
+			indices: indices,
+			radius: radius,
+			detail: detail
+		};
+
+		// default buffer data
+
+		const vertexBuffer = [];
+		const uvBuffer = [];
+
+		// the subdivision creates the vertex buffer data
+
+		subdivide( detail );
+
+		// all vertices should lie on a conceptual sphere with a given radius
+
+		applyRadius( radius );
+
+		// finally, create the uv data
+
+		generateUVs();
+
+		// build non-indexed geometry
+
+		this.setAttribute( 'position', new Float32BufferAttribute( vertexBuffer, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( vertexBuffer.slice(), 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvBuffer, 2 ) );
+
+		if ( detail === 0 ) {
+
+			this.computeVertexNormals(); // flat normals
+
+		} else {
+
+			this.normalizeNormals(); // smooth normals
+
+		}
+
+		// helper functions
+
+		function subdivide( detail ) {
+
+			const a = new Vector3();
+			const b = new Vector3();
+			const c = new Vector3();
+
+			// iterate over all faces and apply a subdivision with the given detail value
+
+			for ( let i = 0; i < indices.length; i += 3 ) {
+
+				// get the vertices of the face
+
+				getVertexByIndex( indices[ i + 0 ], a );
+				getVertexByIndex( indices[ i + 1 ], b );
+				getVertexByIndex( indices[ i + 2 ], c );
+
+				// perform subdivision
+
+				subdivideFace( a, b, c, detail );
+
+			}
+
+		}
+
+		function subdivideFace( a, b, c, detail ) {
+
+			const cols = detail + 1;
+
+			// we use this multidimensional array as a data structure for creating the subdivision
+
+			const v = [];
+
+			// construct all of the vertices for this subdivision
+
+			for ( let i = 0; i <= cols; i ++ ) {
+
+				v[ i ] = [];
+
+				const aj = a.clone().lerp( c, i / cols );
+				const bj = b.clone().lerp( c, i / cols );
+
+				const rows = cols - i;
+
+				for ( let j = 0; j <= rows; j ++ ) {
+
+					if ( j === 0 && i === cols ) {
+
+						v[ i ][ j ] = aj;
+
+					} else {
+
+						v[ i ][ j ] = aj.clone().lerp( bj, j / rows );
+
+					}
+
+				}
+
+			}
+
+			// construct all of the faces
+
+			for ( let i = 0; i < cols; i ++ ) {
+
+				for ( let j = 0; j < 2 * ( cols - i ) - 1; j ++ ) {
+
+					const k = Math.floor( j / 2 );
+
+					if ( j % 2 === 0 ) {
+
+						pushVertex( v[ i ][ k + 1 ] );
+						pushVertex( v[ i + 1 ][ k ] );
+						pushVertex( v[ i ][ k ] );
+
+					} else {
+
+						pushVertex( v[ i ][ k + 1 ] );
+						pushVertex( v[ i + 1 ][ k + 1 ] );
+						pushVertex( v[ i + 1 ][ k ] );
+
+					}
+
+				}
+
+			}
+
+		}
+
+		function applyRadius( radius ) {
+
+			const vertex = new Vector3();
+
+			// iterate over the entire buffer and apply the radius to each vertex
+
+			for ( let i = 0; i < vertexBuffer.length; i += 3 ) {
+
+				vertex.x = vertexBuffer[ i + 0 ];
+				vertex.y = vertexBuffer[ i + 1 ];
+				vertex.z = vertexBuffer[ i + 2 ];
+
+				vertex.normalize().multiplyScalar( radius );
+
+				vertexBuffer[ i + 0 ] = vertex.x;
+				vertexBuffer[ i + 1 ] = vertex.y;
+				vertexBuffer[ i + 2 ] = vertex.z;
+
+			}
+
+		}
+
+		function generateUVs() {
+
+			const vertex = new Vector3();
+
+			for ( let i = 0; i < vertexBuffer.length; i += 3 ) {
+
+				vertex.x = vertexBuffer[ i + 0 ];
+				vertex.y = vertexBuffer[ i + 1 ];
+				vertex.z = vertexBuffer[ i + 2 ];
+
+				const u = azimuth( vertex ) / 2 / Math.PI + 0.5;
+				const v = inclination( vertex ) / Math.PI + 0.5;
+				uvBuffer.push( u, 1 - v );
+
+			}
+
+			correctUVs();
+
+			correctSeam();
+
+		}
+
+		function correctSeam() {
+
+			// handle case when face straddles the seam, see #3269
+
+			for ( let i = 0; i < uvBuffer.length; i += 6 ) {
+
+				// uv data of a single face
+
+				const x0 = uvBuffer[ i + 0 ];
+				const x1 = uvBuffer[ i + 2 ];
+				const x2 = uvBuffer[ i + 4 ];
+
+				const max = Math.max( x0, x1, x2 );
+				const min = Math.min( x0, x1, x2 );
+
+				// 0.9 is somewhat arbitrary
+
+				if ( max > 0.9 && min < 0.1 ) {
+
+					if ( x0 < 0.2 ) uvBuffer[ i + 0 ] += 1;
+					if ( x1 < 0.2 ) uvBuffer[ i + 2 ] += 1;
+					if ( x2 < 0.2 ) uvBuffer[ i + 4 ] += 1;
+
+				}
+
+			}
+
+		}
+
+		function pushVertex( vertex ) {
+
+			vertexBuffer.push( vertex.x, vertex.y, vertex.z );
+
+		}
+
+		function getVertexByIndex( index, vertex ) {
+
+			const stride = index * 3;
+
+			vertex.x = vertices[ stride + 0 ];
+			vertex.y = vertices[ stride + 1 ];
+			vertex.z = vertices[ stride + 2 ];
+
+		}
+
+		function correctUVs() {
+
+			const a = new Vector3();
+			const b = new Vector3();
+			const c = new Vector3();
+
+			const centroid = new Vector3();
+
+			const uvA = new Vector2();
+			const uvB = new Vector2();
+			const uvC = new Vector2();
+
+			for ( let i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6 ) {
+
+				a.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] );
+				b.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );
+				c.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] );
+
+				uvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] );
+				uvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );
+				uvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] );
+
+				centroid.copy( a ).add( b ).add( c ).divideScalar( 3 );
+
+				const azi = azimuth( centroid );
+
+				correctUV( uvA, j + 0, a, azi );
+				correctUV( uvB, j + 2, b, azi );
+				correctUV( uvC, j + 4, c, azi );
+
+			}
+
+		}
+
+		function correctUV( uv, stride, vector, azimuth ) {
+
+			if ( ( azimuth < 0 ) && ( uv.x === 1 ) ) {
+
+				uvBuffer[ stride ] = uv.x - 1;
+
+			}
+
+			if ( ( vector.x === 0 ) && ( vector.z === 0 ) ) {
+
+				uvBuffer[ stride ] = azimuth / 2 / Math.PI + 0.5;
+
+			}
+
+		}
+
+		// Angle around the Y axis, counter-clockwise when looking from above.
+
+		function azimuth( vector ) {
+
+			return Math.atan2( vector.z, - vector.x );
+
+		}
+
+
+		// Angle above the XZ plane.
+
+		function inclination( vector ) {
+
+			return Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new PolyhedronGeometry( data.vertices, data.indices, data.radius, data.details );
+
+	}
+
+}
+
+class DodecahedronGeometry extends PolyhedronGeometry {
+
+	constructor( radius = 1, detail = 0 ) {
+
+		const t = ( 1 + Math.sqrt( 5 ) ) / 2;
+		const r = 1 / t;
+
+		const vertices = [
+
+			// (±1, ±1, ±1)
+			- 1, - 1, - 1,	- 1, - 1, 1,
+			- 1, 1, - 1, - 1, 1, 1,
+			1, - 1, - 1, 1, - 1, 1,
+			1, 1, - 1, 1, 1, 1,
+
+			// (0, ±1/φ, ±φ)
+			0, - r, - t, 0, - r, t,
+			0, r, - t, 0, r, t,
+
+			// (±1/φ, ±φ, 0)
+			- r, - t, 0, - r, t, 0,
+			r, - t, 0, r, t, 0,
+
+			// (±φ, 0, ±1/φ)
+			- t, 0, - r, t, 0, - r,
+			- t, 0, r, t, 0, r
+		];
+
+		const indices = [
+			3, 11, 7, 	3, 7, 15, 	3, 15, 13,
+			7, 19, 17, 	7, 17, 6, 	7, 6, 15,
+			17, 4, 8, 	17, 8, 10, 	17, 10, 6,
+			8, 0, 16, 	8, 16, 2, 	8, 2, 10,
+			0, 12, 1, 	0, 1, 18, 	0, 18, 16,
+			6, 10, 2, 	6, 2, 13, 	6, 13, 15,
+			2, 16, 18, 	2, 18, 3, 	2, 3, 13,
+			18, 1, 9, 	18, 9, 11, 	18, 11, 3,
+			4, 14, 12, 	4, 12, 0, 	4, 0, 8,
+			11, 9, 5, 	11, 5, 19, 	11, 19, 7,
+			19, 5, 14, 	19, 14, 4, 	19, 4, 17,
+			1, 12, 14, 	1, 14, 5, 	1, 5, 9
+		];
+
+		super( vertices, indices, radius, detail );
+
+		this.type = 'DodecahedronGeometry';
+
+		this.parameters = {
+			radius: radius,
+			detail: detail
+		};
+
+	}
+
+	static fromJSON( data ) {
+
+		return new DodecahedronGeometry( data.radius, data.detail );
+
+	}
+
+}
+
+const _v0 = /*@__PURE__*/ new Vector3();
+const _v1$1 = /*@__PURE__*/ new Vector3();
+const _normal = /*@__PURE__*/ new Vector3();
+const _triangle = /*@__PURE__*/ new Triangle();
+
+class EdgesGeometry extends BufferGeometry {
+
+	constructor( geometry = null, thresholdAngle = 1 ) {
+
+		super();
+
+		this.type = 'EdgesGeometry';
+
+		this.parameters = {
+			geometry: geometry,
+			thresholdAngle: thresholdAngle
+		};
+
+		if ( geometry !== null ) {
+
+			const precisionPoints = 4;
+			const precision = Math.pow( 10, precisionPoints );
+			const thresholdDot = Math.cos( DEG2RAD * thresholdAngle );
+
+			const indexAttr = geometry.getIndex();
+			const positionAttr = geometry.getAttribute( 'position' );
+			const indexCount = indexAttr ? indexAttr.count : positionAttr.count;
+
+			const indexArr = [ 0, 0, 0 ];
+			const vertKeys = [ 'a', 'b', 'c' ];
+			const hashes = new Array( 3 );
+
+			const edgeData = {};
+			const vertices = [];
+			for ( let i = 0; i < indexCount; i += 3 ) {
+
+				if ( indexAttr ) {
+
+					indexArr[ 0 ] = indexAttr.getX( i );
+					indexArr[ 1 ] = indexAttr.getX( i + 1 );
+					indexArr[ 2 ] = indexAttr.getX( i + 2 );
+
+				} else {
+
+					indexArr[ 0 ] = i;
+					indexArr[ 1 ] = i + 1;
+					indexArr[ 2 ] = i + 2;
+
+				}
+
+				const { a, b, c } = _triangle;
+				a.fromBufferAttribute( positionAttr, indexArr[ 0 ] );
+				b.fromBufferAttribute( positionAttr, indexArr[ 1 ] );
+				c.fromBufferAttribute( positionAttr, indexArr[ 2 ] );
+				_triangle.getNormal( _normal );
+
+				// create hashes for the edge from the vertices
+				hashes[ 0 ] = `${ Math.round( a.x * precision ) },${ Math.round( a.y * precision ) },${ Math.round( a.z * precision ) }`;
+				hashes[ 1 ] = `${ Math.round( b.x * precision ) },${ Math.round( b.y * precision ) },${ Math.round( b.z * precision ) }`;
+				hashes[ 2 ] = `${ Math.round( c.x * precision ) },${ Math.round( c.y * precision ) },${ Math.round( c.z * precision ) }`;
+
+				// skip degenerate triangles
+				if ( hashes[ 0 ] === hashes[ 1 ] || hashes[ 1 ] === hashes[ 2 ] || hashes[ 2 ] === hashes[ 0 ] ) {
+
+					continue;
+
+				}
+
+				// iterate over every edge
+				for ( let j = 0; j < 3; j ++ ) {
+
+					// get the first and next vertex making up the edge
+					const jNext = ( j + 1 ) % 3;
+					const vecHash0 = hashes[ j ];
+					const vecHash1 = hashes[ jNext ];
+					const v0 = _triangle[ vertKeys[ j ] ];
+					const v1 = _triangle[ vertKeys[ jNext ] ];
+
+					const hash = `${ vecHash0 }_${ vecHash1 }`;
+					const reverseHash = `${ vecHash1 }_${ vecHash0 }`;
+
+					if ( reverseHash in edgeData && edgeData[ reverseHash ] ) {
+
+						// if we found a sibling edge add it into the vertex array if
+						// it meets the angle threshold and delete the edge from the map.
+						if ( _normal.dot( edgeData[ reverseHash ].normal ) <= thresholdDot ) {
+
+							vertices.push( v0.x, v0.y, v0.z );
+							vertices.push( v1.x, v1.y, v1.z );
+
+						}
+
+						edgeData[ reverseHash ] = null;
+
+					} else if ( ! ( hash in edgeData ) ) {
+
+						// if we've already got an edge here then skip adding a new one
+						edgeData[ hash ] = {
+
+							index0: indexArr[ j ],
+							index1: indexArr[ jNext ],
+							normal: _normal.clone(),
+
+						};
+
+					}
+
+				}
+
+			}
+
+			// iterate over all remaining, unmatched edges and add them to the vertex array
+			for ( const key in edgeData ) {
+
+				if ( edgeData[ key ] ) {
+
+					const { index0, index1 } = edgeData[ key ];
+					_v0.fromBufferAttribute( positionAttr, index0 );
+					_v1$1.fromBufferAttribute( positionAttr, index1 );
+
+					vertices.push( _v0.x, _v0.y, _v0.z );
+					vertices.push( _v1$1.x, _v1$1.y, _v1$1.z );
+
+				}
+
+			}
+
+			this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+}
+
+class Shape extends Path {
+
+	constructor( points ) {
+
+		super( points );
+
+		this.uuid = generateUUID();
+
+		this.type = 'Shape';
+
+		this.holes = [];
+
+	}
+
+	getPointsHoles( divisions ) {
+
+		const holesPts = [];
+
+		for ( let i = 0, l = this.holes.length; i < l; i ++ ) {
+
+			holesPts[ i ] = this.holes[ i ].getPoints( divisions );
+
+		}
+
+		return holesPts;
+
+	}
+
+	// get points of shape and holes (keypoints based on segments parameter)
+
+	extractPoints( divisions ) {
+
+		return {
+
+			shape: this.getPoints( divisions ),
+			holes: this.getPointsHoles( divisions )
+
+		};
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.holes = [];
+
+		for ( let i = 0, l = source.holes.length; i < l; i ++ ) {
+
+			const hole = source.holes[ i ];
+
+			this.holes.push( hole.clone() );
+
+		}
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.uuid = this.uuid;
+		data.holes = [];
+
+		for ( let i = 0, l = this.holes.length; i < l; i ++ ) {
+
+			const hole = this.holes[ i ];
+			data.holes.push( hole.toJSON() );
+
+		}
+
+		return data;
+
+	}
+
+	fromJSON( json ) {
+
+		super.fromJSON( json );
+
+		this.uuid = json.uuid;
+		this.holes = [];
+
+		for ( let i = 0, l = json.holes.length; i < l; i ++ ) {
+
+			const hole = json.holes[ i ];
+			this.holes.push( new Path().fromJSON( hole ) );
+
+		}
+
+		return this;
+
+	}
+
+}
+
+/**
+ * Port from https://github.com/mapbox/earcut (v2.2.4)
+ */
+
+const Earcut = {
+
+	triangulate: function ( data, holeIndices, dim = 2 ) {
+
+		const hasHoles = holeIndices && holeIndices.length;
+		const outerLen = hasHoles ? holeIndices[ 0 ] * dim : data.length;
+		let outerNode = linkedList( data, 0, outerLen, dim, true );
+		const triangles = [];
+
+		if ( ! outerNode || outerNode.next === outerNode.prev ) return triangles;
+
+		let minX, minY, maxX, maxY, x, y, invSize;
+
+		if ( hasHoles ) outerNode = eliminateHoles( data, holeIndices, outerNode, dim );
+
+		// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+		if ( data.length > 80 * dim ) {
+
+			minX = maxX = data[ 0 ];
+			minY = maxY = data[ 1 ];
+
+			for ( let i = dim; i < outerLen; i += dim ) {
+
+				x = data[ i ];
+				y = data[ i + 1 ];
+				if ( x < minX ) minX = x;
+				if ( y < minY ) minY = y;
+				if ( x > maxX ) maxX = x;
+				if ( y > maxY ) maxY = y;
+
+			}
+
+			// minX, minY and invSize are later used to transform coords into integers for z-order calculation
+			invSize = Math.max( maxX - minX, maxY - minY );
+			invSize = invSize !== 0 ? 32767 / invSize : 0;
+
+		}
+
+		earcutLinked( outerNode, triangles, dim, minX, minY, invSize, 0 );
+
+		return triangles;
+
+	}
+
+};
+
+// create a circular doubly linked list from polygon points in the specified winding order
+function linkedList( data, start, end, dim, clockwise ) {
+
+	let i, last;
+
+	if ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) {
+
+		for ( i = start; i < end; i += dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );
+
+	} else {
+
+		for ( i = end - dim; i >= start; i -= dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );
+
+	}
+
+	if ( last && equals( last, last.next ) ) {
+
+		removeNode( last );
+		last = last.next;
+
+	}
+
+	return last;
+
+}
+
+// eliminate colinear or duplicate points
+function filterPoints( start, end ) {
+
+	if ( ! start ) return start;
+	if ( ! end ) end = start;
+
+	let p = start,
+		again;
+	do {
+
+		again = false;
+
+		if ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) {
+
+			removeNode( p );
+			p = end = p.prev;
+			if ( p === p.next ) break;
+			again = true;
+
+		} else {
+
+			p = p.next;
+
+		}
+
+	} while ( again || p !== end );
+
+	return end;
+
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+function earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {
+
+	if ( ! ear ) return;
+
+	// interlink polygon nodes in z-order
+	if ( ! pass && invSize ) indexCurve( ear, minX, minY, invSize );
+
+	let stop = ear,
+		prev, next;
+
+	// iterate through ears, slicing them one by one
+	while ( ear.prev !== ear.next ) {
+
+		prev = ear.prev;
+		next = ear.next;
+
+		if ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) {
+
+			// cut off the triangle
+			triangles.push( prev.i / dim | 0 );
+			triangles.push( ear.i / dim | 0 );
+			triangles.push( next.i / dim | 0 );
+
+			removeNode( ear );
+
+			// skipping the next vertex leads to less sliver triangles
+			ear = next.next;
+			stop = next.next;
+
+			continue;
+
+		}
+
+		ear = next;
+
+		// if we looped through the whole remaining polygon and can't find any more ears
+		if ( ear === stop ) {
+
+			// try filtering points and slicing again
+			if ( ! pass ) {
+
+				earcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 );
+
+				// if this didn't work, try curing all small self-intersections locally
+
+			} else if ( pass === 1 ) {
+
+				ear = cureLocalIntersections( filterPoints( ear ), triangles, dim );
+				earcutLinked( ear, triangles, dim, minX, minY, invSize, 2 );
+
+				// as a last resort, try splitting the remaining polygon into two
+
+			} else if ( pass === 2 ) {
+
+				splitEarcut( ear, triangles, dim, minX, minY, invSize );
+
+			}
+
+			break;
+
+		}
+
+	}
+
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+function isEar( ear ) {
+
+	const a = ear.prev,
+		b = ear,
+		c = ear.next;
+
+	if ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear
+
+	// now make sure we don't have other points inside the potential ear
+	const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+	// triangle bbox; min & max are calculated like this for speed
+	const x0 = ax < bx ? ( ax < cx ? ax : cx ) : ( bx < cx ? bx : cx ),
+		y0 = ay < by ? ( ay < cy ? ay : cy ) : ( by < cy ? by : cy ),
+		x1 = ax > bx ? ( ax > cx ? ax : cx ) : ( bx > cx ? bx : cx ),
+		y1 = ay > by ? ( ay > cy ? ay : cy ) : ( by > cy ? by : cy );
+
+	let p = c.next;
+	while ( p !== a ) {
+
+		if ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
+			pointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) &&
+			area( p.prev, p, p.next ) >= 0 ) return false;
+		p = p.next;
+
+	}
+
+	return true;
+
+}
+
+function isEarHashed( ear, minX, minY, invSize ) {
+
+	const a = ear.prev,
+		b = ear,
+		c = ear.next;
+
+	if ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear
+
+	const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+	// triangle bbox; min & max are calculated like this for speed
+	const x0 = ax < bx ? ( ax < cx ? ax : cx ) : ( bx < cx ? bx : cx ),
+		y0 = ay < by ? ( ay < cy ? ay : cy ) : ( by < cy ? by : cy ),
+		x1 = ax > bx ? ( ax > cx ? ax : cx ) : ( bx > cx ? bx : cx ),
+		y1 = ay > by ? ( ay > cy ? ay : cy ) : ( by > cy ? by : cy );
+
+	// z-order range for the current triangle bbox;
+	const minZ = zOrder( x0, y0, minX, minY, invSize ),
+		maxZ = zOrder( x1, y1, minX, minY, invSize );
+
+	let p = ear.prevZ,
+		n = ear.nextZ;
+
+	// look for points inside the triangle in both directions
+	while ( p && p.z >= minZ && n && n.z <= maxZ ) {
+
+		if ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+			pointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) return false;
+		p = p.prevZ;
+
+		if ( n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+			pointInTriangle( ax, ay, bx, by, cx, cy, n.x, n.y ) && area( n.prev, n, n.next ) >= 0 ) return false;
+		n = n.nextZ;
+
+	}
+
+	// look for remaining points in decreasing z-order
+	while ( p && p.z >= minZ ) {
+
+		if ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+			pointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) return false;
+		p = p.prevZ;
+
+	}
+
+	// look for remaining points in increasing z-order
+	while ( n && n.z <= maxZ ) {
+
+		if ( n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+			pointInTriangle( ax, ay, bx, by, cx, cy, n.x, n.y ) && area( n.prev, n, n.next ) >= 0 ) return false;
+		n = n.nextZ;
+
+	}
+
+	return true;
+
+}
+
+// go through all polygon nodes and cure small local self-intersections
+function cureLocalIntersections( start, triangles, dim ) {
+
+	let p = start;
+	do {
+
+		const a = p.prev,
+			b = p.next.next;
+
+		if ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) {
+
+			triangles.push( a.i / dim | 0 );
+			triangles.push( p.i / dim | 0 );
+			triangles.push( b.i / dim | 0 );
+
+			// remove two nodes involved
+			removeNode( p );
+			removeNode( p.next );
+
+			p = start = b;
+
+		}
+
+		p = p.next;
+
+	} while ( p !== start );
+
+	return filterPoints( p );
+
+}
+
+// try splitting polygon into two and triangulate them independently
+function splitEarcut( start, triangles, dim, minX, minY, invSize ) {
+
+	// look for a valid diagonal that divides the polygon into two
+	let a = start;
+	do {
+
+		let b = a.next.next;
+		while ( b !== a.prev ) {
+
+			if ( a.i !== b.i && isValidDiagonal( a, b ) ) {
+
+				// split the polygon in two by the diagonal
+				let c = splitPolygon( a, b );
+
+				// filter colinear points around the cuts
+				a = filterPoints( a, a.next );
+				c = filterPoints( c, c.next );
+
+				// run earcut on each half
+				earcutLinked( a, triangles, dim, minX, minY, invSize, 0 );
+				earcutLinked( c, triangles, dim, minX, minY, invSize, 0 );
+				return;
+
+			}
+
+			b = b.next;
+
+		}
+
+		a = a.next;
+
+	} while ( a !== start );
+
+}
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+function eliminateHoles( data, holeIndices, outerNode, dim ) {
+
+	const queue = [];
+	let i, len, start, end, list;
+
+	for ( i = 0, len = holeIndices.length; i < len; i ++ ) {
+
+		start = holeIndices[ i ] * dim;
+		end = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length;
+		list = linkedList( data, start, end, dim, false );
+		if ( list === list.next ) list.steiner = true;
+		queue.push( getLeftmost( list ) );
+
+	}
+
+	queue.sort( compareX );
+
+	// process holes from left to right
+	for ( i = 0; i < queue.length; i ++ ) {
+
+		outerNode = eliminateHole( queue[ i ], outerNode );
+
+	}
+
+	return outerNode;
+
+}
+
+function compareX( a, b ) {
+
+	return a.x - b.x;
+
+}
+
+// find a bridge between vertices that connects hole with an outer ring and link it
+function eliminateHole( hole, outerNode ) {
+
+	const bridge = findHoleBridge( hole, outerNode );
+	if ( ! bridge ) {
+
+		return outerNode;
+
+	}
+
+	const bridgeReverse = splitPolygon( bridge, hole );
+
+	// filter collinear points around the cuts
+	filterPoints( bridgeReverse, bridgeReverse.next );
+	return filterPoints( bridge, bridge.next );
+
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+function findHoleBridge( hole, outerNode ) {
+
+	let p = outerNode,
+		qx = - Infinity,
+		m;
+
+	const hx = hole.x, hy = hole.y;
+
+	// find a segment intersected by a ray from the hole's leftmost point to the left;
+	// segment's endpoint with lesser x will be potential connection point
+	do {
+
+		if ( hy <= p.y && hy >= p.next.y && p.next.y !== p.y ) {
+
+			const x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y );
+			if ( x <= hx && x > qx ) {
+
+				qx = x;
+				m = p.x < p.next.x ? p : p.next;
+				if ( x === hx ) return m; // hole touches outer segment; pick leftmost endpoint
+
+			}
+
+		}
+
+		p = p.next;
+
+	} while ( p !== outerNode );
+
+	if ( ! m ) return null;
+
+	// look for points inside the triangle of hole point, segment intersection and endpoint;
+	// if there are no points found, we have a valid connection;
+	// otherwise choose the point of the minimum angle with the ray as connection point
+
+	const stop = m,
+		mx = m.x,
+		my = m.y;
+	let tanMin = Infinity, tan;
+
+	p = m;
+
+	do {
+
+		if ( hx >= p.x && p.x >= mx && hx !== p.x &&
+				pointInTriangle( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {
+
+			tan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential
+
+			if ( locallyInside( p, hole ) && ( tan < tanMin || ( tan === tanMin && ( p.x > m.x || ( p.x === m.x && sectorContainsSector( m, p ) ) ) ) ) ) {
+
+				m = p;
+				tanMin = tan;
+
+			}
+
+		}
+
+		p = p.next;
+
+	} while ( p !== stop );
+
+	return m;
+
+}
+
+// whether sector in vertex m contains sector in vertex p in the same coordinates
+function sectorContainsSector( m, p ) {
+
+	return area( m.prev, m, p.prev ) < 0 && area( p.next, m, m.next ) < 0;
+
+}
+
+// interlink polygon nodes in z-order
+function indexCurve( start, minX, minY, invSize ) {
+
+	let p = start;
+	do {
+
+		if ( p.z === 0 ) p.z = zOrder( p.x, p.y, minX, minY, invSize );
+		p.prevZ = p.prev;
+		p.nextZ = p.next;
+		p = p.next;
+
+	} while ( p !== start );
+
+	p.prevZ.nextZ = null;
+	p.prevZ = null;
+
+	sortLinked( p );
+
+}
+
+// Simon Tatham's linked list merge sort algorithm
+// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+function sortLinked( list ) {
+
+	let i, p, q, e, tail, numMerges, pSize, qSize,
+		inSize = 1;
+
+	do {
+
+		p = list;
+		list = null;
+		tail = null;
+		numMerges = 0;
+
+		while ( p ) {
+
+			numMerges ++;
+			q = p;
+			pSize = 0;
+			for ( i = 0; i < inSize; i ++ ) {
+
+				pSize ++;
+				q = q.nextZ;
+				if ( ! q ) break;
+
+			}
+
+			qSize = inSize;
+
+			while ( pSize > 0 || ( qSize > 0 && q ) ) {
+
+				if ( pSize !== 0 && ( qSize === 0 || ! q || p.z <= q.z ) ) {
+
+					e = p;
+					p = p.nextZ;
+					pSize --;
+
+				} else {
+
+					e = q;
+					q = q.nextZ;
+					qSize --;
+
+				}
+
+				if ( tail ) tail.nextZ = e;
+				else list = e;
+
+				e.prevZ = tail;
+				tail = e;
+
+			}
+
+			p = q;
+
+		}
+
+		tail.nextZ = null;
+		inSize *= 2;
+
+	} while ( numMerges > 1 );
+
+	return list;
+
+}
+
+// z-order of a point given coords and inverse of the longer side of data bbox
+function zOrder( x, y, minX, minY, invSize ) {
+
+	// coords are transformed into non-negative 15-bit integer range
+	x = ( x - minX ) * invSize | 0;
+	y = ( y - minY ) * invSize | 0;
+
+	x = ( x | ( x << 8 ) ) & 0x00FF00FF;
+	x = ( x | ( x << 4 ) ) & 0x0F0F0F0F;
+	x = ( x | ( x << 2 ) ) & 0x33333333;
+	x = ( x | ( x << 1 ) ) & 0x55555555;
+
+	y = ( y | ( y << 8 ) ) & 0x00FF00FF;
+	y = ( y | ( y << 4 ) ) & 0x0F0F0F0F;
+	y = ( y | ( y << 2 ) ) & 0x33333333;
+	y = ( y | ( y << 1 ) ) & 0x55555555;
+
+	return x | ( y << 1 );
+
+}
+
+// find the leftmost node of a polygon ring
+function getLeftmost( start ) {
+
+	let p = start,
+		leftmost = start;
+	do {
+
+		if ( p.x < leftmost.x || ( p.x === leftmost.x && p.y < leftmost.y ) ) leftmost = p;
+		p = p.next;
+
+	} while ( p !== start );
+
+	return leftmost;
+
+}
+
+// check if a point lies within a convex triangle
+function pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {
+
+	return ( cx - px ) * ( ay - py ) >= ( ax - px ) * ( cy - py ) &&
+           ( ax - px ) * ( by - py ) >= ( bx - px ) * ( ay - py ) &&
+           ( bx - px ) * ( cy - py ) >= ( cx - px ) * ( by - py );
+
+}
+
+// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+function isValidDiagonal( a, b ) {
+
+	return a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) && // dones't intersect other edges
+           ( locallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b ) && // locally visible
+            ( area( a.prev, a, b.prev ) || area( a, b.prev, b ) ) || // does not create opposite-facing sectors
+            equals( a, b ) && area( a.prev, a, a.next ) > 0 && area( b.prev, b, b.next ) > 0 ); // special zero-length case
+
+}
+
+// signed area of a triangle
+function area( p, q, r ) {
+
+	return ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );
+
+}
+
+// check if two points are equal
+function equals( p1, p2 ) {
+
+	return p1.x === p2.x && p1.y === p2.y;
+
+}
+
+// check if two segments intersect
+function intersects( p1, q1, p2, q2 ) {
+
+	const o1 = sign( area( p1, q1, p2 ) );
+	const o2 = sign( area( p1, q1, q2 ) );
+	const o3 = sign( area( p2, q2, p1 ) );
+	const o4 = sign( area( p2, q2, q1 ) );
+
+	if ( o1 !== o2 && o3 !== o4 ) return true; // general case
+
+	if ( o1 === 0 && onSegment( p1, p2, q1 ) ) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
+	if ( o2 === 0 && onSegment( p1, q2, q1 ) ) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
+	if ( o3 === 0 && onSegment( p2, p1, q2 ) ) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
+	if ( o4 === 0 && onSegment( p2, q1, q2 ) ) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
+
+	return false;
+
+}
+
+// for collinear points p, q, r, check if point q lies on segment pr
+function onSegment( p, q, r ) {
+
+	return q.x <= Math.max( p.x, r.x ) && q.x >= Math.min( p.x, r.x ) && q.y <= Math.max( p.y, r.y ) && q.y >= Math.min( p.y, r.y );
+
+}
+
+function sign( num ) {
+
+	return num > 0 ? 1 : num < 0 ? - 1 : 0;
+
+}
+
+// check if a polygon diagonal intersects any polygon segments
+function intersectsPolygon( a, b ) {
+
+	let p = a;
+	do {
+
+		if ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+			intersects( p, p.next, a, b ) ) return true;
+		p = p.next;
+
+	} while ( p !== a );
+
+	return false;
+
+}
+
+// check if a polygon diagonal is locally inside the polygon
+function locallyInside( a, b ) {
+
+	return area( a.prev, a, a.next ) < 0 ?
+		area( a, b, a.next ) >= 0 && area( a, a.prev, b ) >= 0 :
+		area( a, b, a.prev ) < 0 || area( a, a.next, b ) < 0;
+
+}
+
+// check if the middle point of a polygon diagonal is inside the polygon
+function middleInside( a, b ) {
+
+	let p = a,
+		inside = false;
+	const px = ( a.x + b.x ) / 2,
+		py = ( a.y + b.y ) / 2;
+	do {
+
+		if ( ( ( p.y > py ) !== ( p.next.y > py ) ) && p.next.y !== p.y &&
+			( px < ( p.next.x - p.x ) * ( py - p.y ) / ( p.next.y - p.y ) + p.x ) )
+			inside = ! inside;
+		p = p.next;
+
+	} while ( p !== a );
+
+	return inside;
+
+}
+
+// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
+// if one belongs to the outer ring and another to a hole, it merges it into a single ring
+function splitPolygon( a, b ) {
+
+	const a2 = new Node( a.i, a.x, a.y ),
+		b2 = new Node( b.i, b.x, b.y ),
+		an = a.next,
+		bp = b.prev;
+
+	a.next = b;
+	b.prev = a;
+
+	a2.next = an;
+	an.prev = a2;
+
+	b2.next = a2;
+	a2.prev = b2;
+
+	bp.next = b2;
+	b2.prev = bp;
+
+	return b2;
+
+}
+
+// create a node and optionally link it with previous one (in a circular doubly linked list)
+function insertNode( i, x, y, last ) {
+
+	const p = new Node( i, x, y );
+
+	if ( ! last ) {
+
+		p.prev = p;
+		p.next = p;
+
+	} else {
+
+		p.next = last.next;
+		p.prev = last;
+		last.next.prev = p;
+		last.next = p;
+
+	}
+
+	return p;
+
+}
+
+function removeNode( p ) {
+
+	p.next.prev = p.prev;
+	p.prev.next = p.next;
+
+	if ( p.prevZ ) p.prevZ.nextZ = p.nextZ;
+	if ( p.nextZ ) p.nextZ.prevZ = p.prevZ;
+
+}
+
+function Node( i, x, y ) {
+
+	// vertex index in coordinates array
+	this.i = i;
+
+	// vertex coordinates
+	this.x = x;
+	this.y = y;
+
+	// previous and next vertex nodes in a polygon ring
+	this.prev = null;
+	this.next = null;
+
+	// z-order curve value
+	this.z = 0;
+
+	// previous and next nodes in z-order
+	this.prevZ = null;
+	this.nextZ = null;
+
+	// indicates whether this is a steiner point
+	this.steiner = false;
+
+}
+
+function signedArea( data, start, end, dim ) {
+
+	let sum = 0;
+	for ( let i = start, j = end - dim; i < end; i += dim ) {
+
+		sum += ( data[ j ] - data[ i ] ) * ( data[ i + 1 ] + data[ j + 1 ] );
+		j = i;
+
+	}
+
+	return sum;
+
+}
+
+class ShapeUtils {
+
+	// calculate area of the contour polygon
+
+	static area( contour ) {
+
+		const n = contour.length;
+		let a = 0.0;
+
+		for ( let p = n - 1, q = 0; q < n; p = q ++ ) {
+
+			a += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;
+
+		}
+
+		return a * 0.5;
+
+	}
+
+	static isClockWise( pts ) {
+
+		return ShapeUtils.area( pts ) < 0;
+
+	}
+
+	static triangulateShape( contour, holes ) {
+
+		const vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]
+		const holeIndices = []; // array of hole indices
+		const faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]
+
+		removeDupEndPts( contour );
+		addContour( vertices, contour );
+
+		//
+
+		let holeIndex = contour.length;
+
+		holes.forEach( removeDupEndPts );
+
+		for ( let i = 0; i < holes.length; i ++ ) {
+
+			holeIndices.push( holeIndex );
+			holeIndex += holes[ i ].length;
+			addContour( vertices, holes[ i ] );
+
+		}
+
+		//
+
+		const triangles = Earcut.triangulate( vertices, holeIndices );
+
+		//
+
+		for ( let i = 0; i < triangles.length; i += 3 ) {
+
+			faces.push( triangles.slice( i, i + 3 ) );
+
+		}
+
+		return faces;
+
+	}
+
+}
+
+function removeDupEndPts( points ) {
+
+	const l = points.length;
+
+	if ( l > 2 && points[ l - 1 ].equals( points[ 0 ] ) ) {
+
+		points.pop();
+
+	}
+
+}
+
+function addContour( vertices, contour ) {
+
+	for ( let i = 0; i < contour.length; i ++ ) {
+
+		vertices.push( contour[ i ].x );
+		vertices.push( contour[ i ].y );
+
+	}
+
+}
+
+/**
+ * Creates extruded geometry from a path shape.
+ *
+ * parameters = {
+ *
+ *  curveSegments: <int>, // number of points on the curves
+ *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too
+ *  depth: <float>, // Depth to extrude the shape
+ *
+ *  bevelEnabled: <bool>, // turn on bevel
+ *  bevelThickness: <float>, // how deep into the original shape bevel goes
+ *  bevelSize: <float>, // how far from shape outline (including bevelOffset) is bevel
+ *  bevelOffset: <float>, // how far from shape outline does bevel start
+ *  bevelSegments: <int>, // number of bevel layers
+ *
+ *  extrudePath: <THREE.Curve> // curve to extrude shape along
+ *
+ *  UVGenerator: <Object> // object that provides UV generator functions
+ *
+ * }
+ */
+
+
+class ExtrudeGeometry extends BufferGeometry {
+
+	constructor( shapes = new Shape( [ new Vector2( 0.5, 0.5 ), new Vector2( - 0.5, 0.5 ), new Vector2( - 0.5, - 0.5 ), new Vector2( 0.5, - 0.5 ) ] ), options = {} ) {
+
+		super();
+
+		this.type = 'ExtrudeGeometry';
+
+		this.parameters = {
+			shapes: shapes,
+			options: options
+		};
+
+		shapes = Array.isArray( shapes ) ? shapes : [ shapes ];
+
+		const scope = this;
+
+		const verticesArray = [];
+		const uvArray = [];
+
+		for ( let i = 0, l = shapes.length; i < l; i ++ ) {
+
+			const shape = shapes[ i ];
+			addShape( shape );
+
+		}
+
+		// build geometry
+
+		this.setAttribute( 'position', new Float32BufferAttribute( verticesArray, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvArray, 2 ) );
+
+		this.computeVertexNormals();
+
+		// functions
+
+		function addShape( shape ) {
+
+			const placeholder = [];
+
+			// options
+
+			const curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
+			const steps = options.steps !== undefined ? options.steps : 1;
+			const depth = options.depth !== undefined ? options.depth : 1;
+
+			let bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true;
+			let bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 0.2;
+			let bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 0.1;
+			let bevelOffset = options.bevelOffset !== undefined ? options.bevelOffset : 0;
+			let bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;
+
+			const extrudePath = options.extrudePath;
+
+			const uvgen = options.UVGenerator !== undefined ? options.UVGenerator : WorldUVGenerator;
+
+			//
+
+			let extrudePts, extrudeByPath = false;
+			let splineTube, binormal, normal, position2;
+
+			if ( extrudePath ) {
+
+				extrudePts = extrudePath.getSpacedPoints( steps );
+
+				extrudeByPath = true;
+				bevelEnabled = false; // bevels not supported for path extrusion
+
+				// SETUP TNB variables
+
+				// TODO1 - have a .isClosed in spline?
+
+				splineTube = extrudePath.computeFrenetFrames( steps, false );
+
+				// console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);
+
+				binormal = new Vector3();
+				normal = new Vector3();
+				position2 = new Vector3();
+
+			}
+
+			// Safeguards if bevels are not enabled
+
+			if ( ! bevelEnabled ) {
+
+				bevelSegments = 0;
+				bevelThickness = 0;
+				bevelSize = 0;
+				bevelOffset = 0;
+
+			}
+
+			// Variables initialization
+
+			const shapePoints = shape.extractPoints( curveSegments );
+
+			let vertices = shapePoints.shape;
+			const holes = shapePoints.holes;
+
+			const reverse = ! ShapeUtils.isClockWise( vertices );
+
+			if ( reverse ) {
+
+				vertices = vertices.reverse();
+
+				// Maybe we should also check if holes are in the opposite direction, just to be safe ...
+
+				for ( let h = 0, hl = holes.length; h < hl; h ++ ) {
+
+					const ahole = holes[ h ];
+
+					if ( ShapeUtils.isClockWise( ahole ) ) {
+
+						holes[ h ] = ahole.reverse();
+
+					}
+
+				}
+
+			}
+
+
+			const faces = ShapeUtils.triangulateShape( vertices, holes );
+
+			/* Vertices */
+
+			const contour = vertices; // vertices has all points but contour has only points of circumference
+
+			for ( let h = 0, hl = holes.length; h < hl; h ++ ) {
+
+				const ahole = holes[ h ];
+
+				vertices = vertices.concat( ahole );
+
+			}
+
+
+			function scalePt2( pt, vec, size ) {
+
+				if ( ! vec ) console.error( 'THREE.ExtrudeGeometry: vec does not exist' );
+
+				return pt.clone().addScaledVector( vec, size );
+
+			}
+
+			const vlen = vertices.length, flen = faces.length;
+
+
+			// Find directions for point movement
+
+
+			function getBevelVec( inPt, inPrev, inNext ) {
+
+				// computes for inPt the corresponding point inPt' on a new contour
+				//   shifted by 1 unit (length of normalized vector) to the left
+				// if we walk along contour clockwise, this new contour is outside the old one
+				//
+				// inPt' is the intersection of the two lines parallel to the two
+				//  adjacent edges of inPt at a distance of 1 unit on the left side.
+
+				let v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt
+
+				// good reading for geometry algorithms (here: line-line intersection)
+				// http://geomalgorithms.com/a05-_intersect-1.html
+
+				const v_prev_x = inPt.x - inPrev.x,
+					v_prev_y = inPt.y - inPrev.y;
+				const v_next_x = inNext.x - inPt.x,
+					v_next_y = inNext.y - inPt.y;
+
+				const v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );
+
+				// check for collinear edges
+				const collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );
+
+				if ( Math.abs( collinear0 ) > Number.EPSILON ) {
+
+					// not collinear
+
+					// length of vectors for normalizing
+
+					const v_prev_len = Math.sqrt( v_prev_lensq );
+					const v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y );
+
+					// shift adjacent points by unit vectors to the left
+
+					const ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len );
+					const ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len );
+
+					const ptNextShift_x = ( inNext.x - v_next_y / v_next_len );
+					const ptNextShift_y = ( inNext.y + v_next_x / v_next_len );
+
+					// scaling factor for v_prev to intersection point
+
+					const sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y -
+							( ptNextShift_y - ptPrevShift_y ) * v_next_x ) /
+						( v_prev_x * v_next_y - v_prev_y * v_next_x );
+
+					// vector from inPt to intersection point
+
+					v_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x );
+					v_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y );
+
+					// Don't normalize!, otherwise sharp corners become ugly
+					//  but prevent crazy spikes
+					const v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y );
+					if ( v_trans_lensq <= 2 ) {
+
+						return new Vector2( v_trans_x, v_trans_y );
+
+					} else {
+
+						shrink_by = Math.sqrt( v_trans_lensq / 2 );
+
+					}
+
+				} else {
+
+					// handle special case of collinear edges
+
+					let direction_eq = false; // assumes: opposite
+
+					if ( v_prev_x > Number.EPSILON ) {
+
+						if ( v_next_x > Number.EPSILON ) {
+
+							direction_eq = true;
+
+						}
+
+					} else {
+
+						if ( v_prev_x < - Number.EPSILON ) {
+
+							if ( v_next_x < - Number.EPSILON ) {
+
+								direction_eq = true;
+
+							}
+
+						} else {
+
+							if ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {
+
+								direction_eq = true;
+
+							}
+
+						}
+
+					}
+
+					if ( direction_eq ) {
+
+						// console.log("Warning: lines are a straight sequence");
+						v_trans_x = - v_prev_y;
+						v_trans_y = v_prev_x;
+						shrink_by = Math.sqrt( v_prev_lensq );
+
+					} else {
+
+						// console.log("Warning: lines are a straight spike");
+						v_trans_x = v_prev_x;
+						v_trans_y = v_prev_y;
+						shrink_by = Math.sqrt( v_prev_lensq / 2 );
+
+					}
+
+				}
+
+				return new Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );
+
+			}
+
+
+			const contourMovements = [];
+
+			for ( let i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {
+
+				if ( j === il ) j = 0;
+				if ( k === il ) k = 0;
+
+				//  (j)---(i)---(k)
+				// console.log('i,j,k', i, j , k)
+
+				contourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );
+
+			}
+
+			const holesMovements = [];
+			let oneHoleMovements, verticesMovements = contourMovements.concat();
+
+			for ( let h = 0, hl = holes.length; h < hl; h ++ ) {
+
+				const ahole = holes[ h ];
+
+				oneHoleMovements = [];
+
+				for ( let i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {
+
+					if ( j === il ) j = 0;
+					if ( k === il ) k = 0;
+
+					//  (j)---(i)---(k)
+					oneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );
+
+				}
+
+				holesMovements.push( oneHoleMovements );
+				verticesMovements = verticesMovements.concat( oneHoleMovements );
+
+			}
+
+
+			// Loop bevelSegments, 1 for the front, 1 for the back
+
+			for ( let b = 0; b < bevelSegments; b ++ ) {
+
+				//for ( b = bevelSegments; b > 0; b -- ) {
+
+				const t = b / bevelSegments;
+				const z = bevelThickness * Math.cos( t * Math.PI / 2 );
+				const bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;
+
+				// contract shape
+
+				for ( let i = 0, il = contour.length; i < il; i ++ ) {
+
+					const vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
+
+					v( vert.x, vert.y, - z );
+
+				}
+
+				// expand holes
+
+				for ( let h = 0, hl = holes.length; h < hl; h ++ ) {
+
+					const ahole = holes[ h ];
+					oneHoleMovements = holesMovements[ h ];
+
+					for ( let i = 0, il = ahole.length; i < il; i ++ ) {
+
+						const vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
+
+						v( vert.x, vert.y, - z );
+
+					}
+
+				}
+
+			}
+
+			const bs = bevelSize + bevelOffset;
+
+			// Back facing vertices
+
+			for ( let i = 0; i < vlen; i ++ ) {
+
+				const vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
+
+				if ( ! extrudeByPath ) {
+
+					v( vert.x, vert.y, 0 );
+
+				} else {
+
+					// v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );
+
+					normal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );
+					binormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );
+
+					position2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );
+
+					v( position2.x, position2.y, position2.z );
+
+				}
+
+			}
+
+			// Add stepped vertices...
+			// Including front facing vertices
+
+			for ( let s = 1; s <= steps; s ++ ) {
+
+				for ( let i = 0; i < vlen; i ++ ) {
+
+					const vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
+
+					if ( ! extrudeByPath ) {
+
+						v( vert.x, vert.y, depth / steps * s );
+
+					} else {
+
+						// v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );
+
+						normal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );
+						binormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );
+
+						position2.copy( extrudePts[ s ] ).add( normal ).add( binormal );
+
+						v( position2.x, position2.y, position2.z );
+
+					}
+
+				}
+
+			}
+
+
+			// Add bevel segments planes
+
+			//for ( b = 1; b <= bevelSegments; b ++ ) {
+			for ( let b = bevelSegments - 1; b >= 0; b -- ) {
+
+				const t = b / bevelSegments;
+				const z = bevelThickness * Math.cos( t * Math.PI / 2 );
+				const bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;
+
+				// contract shape
+
+				for ( let i = 0, il = contour.length; i < il; i ++ ) {
+
+					const vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
+					v( vert.x, vert.y, depth + z );
+
+				}
+
+				// expand holes
+
+				for ( let h = 0, hl = holes.length; h < hl; h ++ ) {
+
+					const ahole = holes[ h ];
+					oneHoleMovements = holesMovements[ h ];
+
+					for ( let i = 0, il = ahole.length; i < il; i ++ ) {
+
+						const vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
+
+						if ( ! extrudeByPath ) {
+
+							v( vert.x, vert.y, depth + z );
+
+						} else {
+
+							v( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			/* Faces */
+
+			// Top and bottom faces
+
+			buildLidFaces();
+
+			// Sides faces
+
+			buildSideFaces();
+
+
+			/////  Internal functions
+
+			function buildLidFaces() {
+
+				const start = verticesArray.length / 3;
+
+				if ( bevelEnabled ) {
+
+					let layer = 0; // steps + 1
+					let offset = vlen * layer;
+
+					// Bottom faces
+
+					for ( let i = 0; i < flen; i ++ ) {
+
+						const face = faces[ i ];
+						f3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );
+
+					}
+
+					layer = steps + bevelSegments * 2;
+					offset = vlen * layer;
+
+					// Top faces
+
+					for ( let i = 0; i < flen; i ++ ) {
+
+						const face = faces[ i ];
+						f3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );
+
+					}
+
+				} else {
+
+					// Bottom faces
+
+					for ( let i = 0; i < flen; i ++ ) {
+
+						const face = faces[ i ];
+						f3( face[ 2 ], face[ 1 ], face[ 0 ] );
+
+					}
+
+					// Top faces
+
+					for ( let i = 0; i < flen; i ++ ) {
+
+						const face = faces[ i ];
+						f3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );
+
+					}
+
+				}
+
+				scope.addGroup( start, verticesArray.length / 3 - start, 0 );
+
+			}
+
+			// Create faces for the z-sides of the shape
+
+			function buildSideFaces() {
+
+				const start = verticesArray.length / 3;
+				let layeroffset = 0;
+				sidewalls( contour, layeroffset );
+				layeroffset += contour.length;
+
+				for ( let h = 0, hl = holes.length; h < hl; h ++ ) {
+
+					const ahole = holes[ h ];
+					sidewalls( ahole, layeroffset );
+
+					//, true
+					layeroffset += ahole.length;
+
+				}
+
+
+				scope.addGroup( start, verticesArray.length / 3 - start, 1 );
+
+
+			}
+
+			function sidewalls( contour, layeroffset ) {
+
+				let i = contour.length;
+
+				while ( -- i >= 0 ) {
+
+					const j = i;
+					let k = i - 1;
+					if ( k < 0 ) k = contour.length - 1;
+
+					//console.log('b', i,j, i-1, k,vertices.length);
+
+					for ( let s = 0, sl = ( steps + bevelSegments * 2 ); s < sl; s ++ ) {
+
+						const slen1 = vlen * s;
+						const slen2 = vlen * ( s + 1 );
+
+						const a = layeroffset + j + slen1,
+							b = layeroffset + k + slen1,
+							c = layeroffset + k + slen2,
+							d = layeroffset + j + slen2;
+
+						f4( a, b, c, d );
+
+					}
+
+				}
+
+			}
+
+			function v( x, y, z ) {
+
+				placeholder.push( x );
+				placeholder.push( y );
+				placeholder.push( z );
+
+			}
+
+
+			function f3( a, b, c ) {
+
+				addVertex( a );
+				addVertex( b );
+				addVertex( c );
+
+				const nextIndex = verticesArray.length / 3;
+				const uvs = uvgen.generateTopUV( scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1 );
+
+				addUV( uvs[ 0 ] );
+				addUV( uvs[ 1 ] );
+				addUV( uvs[ 2 ] );
+
+			}
+
+			function f4( a, b, c, d ) {
+
+				addVertex( a );
+				addVertex( b );
+				addVertex( d );
+
+				addVertex( b );
+				addVertex( c );
+				addVertex( d );
+
+
+				const nextIndex = verticesArray.length / 3;
+				const uvs = uvgen.generateSideWallUV( scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1 );
+
+				addUV( uvs[ 0 ] );
+				addUV( uvs[ 1 ] );
+				addUV( uvs[ 3 ] );
+
+				addUV( uvs[ 1 ] );
+				addUV( uvs[ 2 ] );
+				addUV( uvs[ 3 ] );
+
+			}
+
+			function addVertex( index ) {
+
+				verticesArray.push( placeholder[ index * 3 + 0 ] );
+				verticesArray.push( placeholder[ index * 3 + 1 ] );
+				verticesArray.push( placeholder[ index * 3 + 2 ] );
+
+			}
+
+
+			function addUV( vector2 ) {
+
+				uvArray.push( vector2.x );
+				uvArray.push( vector2.y );
+
+			}
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		const shapes = this.parameters.shapes;
+		const options = this.parameters.options;
+
+		return toJSON$1( shapes, options, data );
+
+	}
+
+	static fromJSON( data, shapes ) {
+
+		const geometryShapes = [];
+
+		for ( let j = 0, jl = data.shapes.length; j < jl; j ++ ) {
+
+			const shape = shapes[ data.shapes[ j ] ];
+
+			geometryShapes.push( shape );
+
+		}
+
+		const extrudePath = data.options.extrudePath;
+
+		if ( extrudePath !== undefined ) {
+
+			data.options.extrudePath = new Curves[ extrudePath.type ]().fromJSON( extrudePath );
+
+		}
+
+		return new ExtrudeGeometry( geometryShapes, data.options );
+
+	}
+
+}
+
+const WorldUVGenerator = {
+
+	generateTopUV: function ( geometry, vertices, indexA, indexB, indexC ) {
+
+		const a_x = vertices[ indexA * 3 ];
+		const a_y = vertices[ indexA * 3 + 1 ];
+		const b_x = vertices[ indexB * 3 ];
+		const b_y = vertices[ indexB * 3 + 1 ];
+		const c_x = vertices[ indexC * 3 ];
+		const c_y = vertices[ indexC * 3 + 1 ];
+
+		return [
+			new Vector2( a_x, a_y ),
+			new Vector2( b_x, b_y ),
+			new Vector2( c_x, c_y )
+		];
+
+	},
+
+	generateSideWallUV: function ( geometry, vertices, indexA, indexB, indexC, indexD ) {
+
+		const a_x = vertices[ indexA * 3 ];
+		const a_y = vertices[ indexA * 3 + 1 ];
+		const a_z = vertices[ indexA * 3 + 2 ];
+		const b_x = vertices[ indexB * 3 ];
+		const b_y = vertices[ indexB * 3 + 1 ];
+		const b_z = vertices[ indexB * 3 + 2 ];
+		const c_x = vertices[ indexC * 3 ];
+		const c_y = vertices[ indexC * 3 + 1 ];
+		const c_z = vertices[ indexC * 3 + 2 ];
+		const d_x = vertices[ indexD * 3 ];
+		const d_y = vertices[ indexD * 3 + 1 ];
+		const d_z = vertices[ indexD * 3 + 2 ];
+
+		if ( Math.abs( a_y - b_y ) < Math.abs( a_x - b_x ) ) {
+
+			return [
+				new Vector2( a_x, 1 - a_z ),
+				new Vector2( b_x, 1 - b_z ),
+				new Vector2( c_x, 1 - c_z ),
+				new Vector2( d_x, 1 - d_z )
+			];
+
+		} else {
+
+			return [
+				new Vector2( a_y, 1 - a_z ),
+				new Vector2( b_y, 1 - b_z ),
+				new Vector2( c_y, 1 - c_z ),
+				new Vector2( d_y, 1 - d_z )
+			];
+
+		}
+
+	}
+
+};
+
+function toJSON$1( shapes, options, data ) {
+
+	data.shapes = [];
+
+	if ( Array.isArray( shapes ) ) {
+
+		for ( let i = 0, l = shapes.length; i < l; i ++ ) {
+
+			const shape = shapes[ i ];
+
+			data.shapes.push( shape.uuid );
+
+		}
+
+	} else {
+
+		data.shapes.push( shapes.uuid );
+
+	}
+
+	data.options = Object.assign( {}, options );
+
+	if ( options.extrudePath !== undefined ) data.options.extrudePath = options.extrudePath.toJSON();
+
+	return data;
+
+}
+
+class IcosahedronGeometry extends PolyhedronGeometry {
+
+	constructor( radius = 1, detail = 0 ) {
+
+		const t = ( 1 + Math.sqrt( 5 ) ) / 2;
+
+		const vertices = [
+			- 1, t, 0, 	1, t, 0, 	- 1, - t, 0, 	1, - t, 0,
+			0, - 1, t, 	0, 1, t,	0, - 1, - t, 	0, 1, - t,
+			t, 0, - 1, 	t, 0, 1, 	- t, 0, - 1, 	- t, 0, 1
+		];
+
+		const indices = [
+			0, 11, 5, 	0, 5, 1, 	0, 1, 7, 	0, 7, 10, 	0, 10, 11,
+			1, 5, 9, 	5, 11, 4,	11, 10, 2,	10, 7, 6,	7, 1, 8,
+			3, 9, 4, 	3, 4, 2,	3, 2, 6,	3, 6, 8,	3, 8, 9,
+			4, 9, 5, 	2, 4, 11,	6, 2, 10,	8, 6, 7,	9, 8, 1
+		];
+
+		super( vertices, indices, radius, detail );
+
+		this.type = 'IcosahedronGeometry';
+
+		this.parameters = {
+			radius: radius,
+			detail: detail
+		};
+
+	}
+
+	static fromJSON( data ) {
+
+		return new IcosahedronGeometry( data.radius, data.detail );
+
+	}
+
+}
+
+class OctahedronGeometry extends PolyhedronGeometry {
+
+	constructor( radius = 1, detail = 0 ) {
+
+		const vertices = [
+			1, 0, 0, 	- 1, 0, 0,	0, 1, 0,
+			0, - 1, 0, 	0, 0, 1,	0, 0, - 1
+		];
+
+		const indices = [
+			0, 2, 4,	0, 4, 3,	0, 3, 5,
+			0, 5, 2,	1, 2, 5,	1, 5, 3,
+			1, 3, 4,	1, 4, 2
+		];
+
+		super( vertices, indices, radius, detail );
+
+		this.type = 'OctahedronGeometry';
+
+		this.parameters = {
+			radius: radius,
+			detail: detail
+		};
+
+	}
+
+	static fromJSON( data ) {
+
+		return new OctahedronGeometry( data.radius, data.detail );
+
+	}
+
+}
+
+class RingGeometry extends BufferGeometry {
+
+	constructor( innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2 ) {
+
+		super();
+
+		this.type = 'RingGeometry';
+
+		this.parameters = {
+			innerRadius: innerRadius,
+			outerRadius: outerRadius,
+			thetaSegments: thetaSegments,
+			phiSegments: phiSegments,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
+
+		thetaSegments = Math.max( 3, thetaSegments );
+		phiSegments = Math.max( 1, phiSegments );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// some helper variables
+
+		let radius = innerRadius;
+		const radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );
+		const vertex = new Vector3();
+		const uv = new Vector2();
+
+		// generate vertices, normals and uvs
+
+		for ( let j = 0; j <= phiSegments; j ++ ) {
+
+			for ( let i = 0; i <= thetaSegments; i ++ ) {
+
+				// values are generate from the inside of the ring to the outside
+
+				const segment = thetaStart + i / thetaSegments * thetaLength;
+
+				// vertex
+
+				vertex.x = radius * Math.cos( segment );
+				vertex.y = radius * Math.sin( segment );
+
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+				// normal
+
+				normals.push( 0, 0, 1 );
+
+				// uv
+
+				uv.x = ( vertex.x / outerRadius + 1 ) / 2;
+				uv.y = ( vertex.y / outerRadius + 1 ) / 2;
+
+				uvs.push( uv.x, uv.y );
+
+			}
+
+			// increase the radius for next row of vertices
+
+			radius += radiusStep;
+
+		}
+
+		// indices
+
+		for ( let j = 0; j < phiSegments; j ++ ) {
+
+			const thetaSegmentLevel = j * ( thetaSegments + 1 );
+
+			for ( let i = 0; i < thetaSegments; i ++ ) {
+
+				const segment = i + thetaSegmentLevel;
+
+				const a = segment;
+				const b = segment + thetaSegments + 1;
+				const c = segment + thetaSegments + 2;
+				const d = segment + 1;
+
+				// faces
+
+				indices.push( a, b, d );
+				indices.push( b, c, d );
+
+			}
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new RingGeometry( data.innerRadius, data.outerRadius, data.thetaSegments, data.phiSegments, data.thetaStart, data.thetaLength );
+
+	}
+
+}
+
+class ShapeGeometry extends BufferGeometry {
+
+	constructor( shapes = new Shape( [ new Vector2( 0, 0.5 ), new Vector2( - 0.5, - 0.5 ), new Vector2( 0.5, - 0.5 ) ] ), curveSegments = 12 ) {
+
+		super();
+
+		this.type = 'ShapeGeometry';
+
+		this.parameters = {
+			shapes: shapes,
+			curveSegments: curveSegments
+		};
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// helper variables
+
+		let groupStart = 0;
+		let groupCount = 0;
+
+		// allow single and array values for "shapes" parameter
+
+		if ( Array.isArray( shapes ) === false ) {
+
+			addShape( shapes );
+
+		} else {
+
+			for ( let i = 0; i < shapes.length; i ++ ) {
+
+				addShape( shapes[ i ] );
+
+				this.addGroup( groupStart, groupCount, i ); // enables MultiMaterial support
+
+				groupStart += groupCount;
+				groupCount = 0;
+
+			}
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+
+		// helper functions
+
+		function addShape( shape ) {
+
+			const indexOffset = vertices.length / 3;
+			const points = shape.extractPoints( curveSegments );
+
+			let shapeVertices = points.shape;
+			const shapeHoles = points.holes;
+
+			// check direction of vertices
+
+			if ( ShapeUtils.isClockWise( shapeVertices ) === false ) {
+
+				shapeVertices = shapeVertices.reverse();
+
+			}
+
+			for ( let i = 0, l = shapeHoles.length; i < l; i ++ ) {
+
+				const shapeHole = shapeHoles[ i ];
+
+				if ( ShapeUtils.isClockWise( shapeHole ) === true ) {
+
+					shapeHoles[ i ] = shapeHole.reverse();
+
+				}
+
+			}
+
+			const faces = ShapeUtils.triangulateShape( shapeVertices, shapeHoles );
+
+			// join vertices of inner and outer paths to a single array
+
+			for ( let i = 0, l = shapeHoles.length; i < l; i ++ ) {
+
+				const shapeHole = shapeHoles[ i ];
+				shapeVertices = shapeVertices.concat( shapeHole );
+
+			}
+
+			// vertices, normals, uvs
+
+			for ( let i = 0, l = shapeVertices.length; i < l; i ++ ) {
+
+				const vertex = shapeVertices[ i ];
+
+				vertices.push( vertex.x, vertex.y, 0 );
+				normals.push( 0, 0, 1 );
+				uvs.push( vertex.x, vertex.y ); // world uvs
+
+			}
+
+			// indices
+
+			for ( let i = 0, l = faces.length; i < l; i ++ ) {
+
+				const face = faces[ i ];
+
+				const a = face[ 0 ] + indexOffset;
+				const b = face[ 1 ] + indexOffset;
+				const c = face[ 2 ] + indexOffset;
+
+				indices.push( a, b, c );
+				groupCount += 3;
+
+			}
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		const shapes = this.parameters.shapes;
+
+		return toJSON( shapes, data );
+
+	}
+
+	static fromJSON( data, shapes ) {
+
+		const geometryShapes = [];
+
+		for ( let j = 0, jl = data.shapes.length; j < jl; j ++ ) {
+
+			const shape = shapes[ data.shapes[ j ] ];
+
+			geometryShapes.push( shape );
+
+		}
+
+		return new ShapeGeometry( geometryShapes, data.curveSegments );
+
+	}
+
+}
+
+function toJSON( shapes, data ) {
+
+	data.shapes = [];
+
+	if ( Array.isArray( shapes ) ) {
+
+		for ( let i = 0, l = shapes.length; i < l; i ++ ) {
+
+			const shape = shapes[ i ];
+
+			data.shapes.push( shape.uuid );
+
+		}
+
+	} else {
+
+		data.shapes.push( shapes.uuid );
+
+	}
+
+	return data;
+
+}
+
+class SphereGeometry extends BufferGeometry {
+
+	constructor( radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI ) {
+
+		super();
+
+		this.type = 'SphereGeometry';
+
+		this.parameters = {
+			radius: radius,
+			widthSegments: widthSegments,
+			heightSegments: heightSegments,
+			phiStart: phiStart,
+			phiLength: phiLength,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
+
+		widthSegments = Math.max( 3, Math.floor( widthSegments ) );
+		heightSegments = Math.max( 2, Math.floor( heightSegments ) );
+
+		const thetaEnd = Math.min( thetaStart + thetaLength, Math.PI );
+
+		let index = 0;
+		const grid = [];
+
+		const vertex = new Vector3();
+		const normal = new Vector3();
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// generate vertices, normals and uvs
+
+		for ( let iy = 0; iy <= heightSegments; iy ++ ) {
+
+			const verticesRow = [];
+
+			const v = iy / heightSegments;
+
+			// special case for the poles
+
+			let uOffset = 0;
+
+			if ( iy === 0 && thetaStart === 0 ) {
+
+				uOffset = 0.5 / widthSegments;
+
+			} else if ( iy === heightSegments && thetaEnd === Math.PI ) {
+
+				uOffset = - 0.5 / widthSegments;
+
+			}
+
+			for ( let ix = 0; ix <= widthSegments; ix ++ ) {
+
+				const u = ix / widthSegments;
+
+				// vertex
+
+				vertex.x = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
+				vertex.y = radius * Math.cos( thetaStart + v * thetaLength );
+				vertex.z = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
+
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+				// normal
+
+				normal.copy( vertex ).normalize();
+				normals.push( normal.x, normal.y, normal.z );
+
+				// uv
+
+				uvs.push( u + uOffset, 1 - v );
+
+				verticesRow.push( index ++ );
+
+			}
+
+			grid.push( verticesRow );
+
+		}
+
+		// indices
+
+		for ( let iy = 0; iy < heightSegments; iy ++ ) {
+
+			for ( let ix = 0; ix < widthSegments; ix ++ ) {
+
+				const a = grid[ iy ][ ix + 1 ];
+				const b = grid[ iy ][ ix ];
+				const c = grid[ iy + 1 ][ ix ];
+				const d = grid[ iy + 1 ][ ix + 1 ];
+
+				if ( iy !== 0 || thetaStart > 0 ) indices.push( a, b, d );
+				if ( iy !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( b, c, d );
+
+			}
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new SphereGeometry( data.radius, data.widthSegments, data.heightSegments, data.phiStart, data.phiLength, data.thetaStart, data.thetaLength );
+
+	}
+
+}
+
+class TetrahedronGeometry extends PolyhedronGeometry {
+
+	constructor( radius = 1, detail = 0 ) {
+
+		const vertices = [
+			1, 1, 1, 	- 1, - 1, 1, 	- 1, 1, - 1, 	1, - 1, - 1
+		];
+
+		const indices = [
+			2, 1, 0, 	0, 3, 2,	1, 3, 0,	2, 3, 1
+		];
+
+		super( vertices, indices, radius, detail );
+
+		this.type = 'TetrahedronGeometry';
+
+		this.parameters = {
+			radius: radius,
+			detail: detail
+		};
+
+	}
+
+	static fromJSON( data ) {
+
+		return new TetrahedronGeometry( data.radius, data.detail );
+
+	}
+
+}
+
+class TorusGeometry extends BufferGeometry {
+
+	constructor( radius = 1, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2 ) {
+
+		super();
+
+		this.type = 'TorusGeometry';
+
+		this.parameters = {
+			radius: radius,
+			tube: tube,
+			radialSegments: radialSegments,
+			tubularSegments: tubularSegments,
+			arc: arc
+		};
+
+		radialSegments = Math.floor( radialSegments );
+		tubularSegments = Math.floor( tubularSegments );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// helper variables
+
+		const center = new Vector3();
+		const vertex = new Vector3();
+		const normal = new Vector3();
+
+		// generate vertices, normals and uvs
+
+		for ( let j = 0; j <= radialSegments; j ++ ) {
+
+			for ( let i = 0; i <= tubularSegments; i ++ ) {
+
+				const u = i / tubularSegments * arc;
+				const v = j / radialSegments * Math.PI * 2;
+
+				// vertex
+
+				vertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u );
+				vertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u );
+				vertex.z = tube * Math.sin( v );
+
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+				// normal
+
+				center.x = radius * Math.cos( u );
+				center.y = radius * Math.sin( u );
+				normal.subVectors( vertex, center ).normalize();
+
+				normals.push( normal.x, normal.y, normal.z );
+
+				// uv
+
+				uvs.push( i / tubularSegments );
+				uvs.push( j / radialSegments );
+
+			}
+
+		}
+
+		// generate indices
+
+		for ( let j = 1; j <= radialSegments; j ++ ) {
+
+			for ( let i = 1; i <= tubularSegments; i ++ ) {
+
+				// indices
+
+				const a = ( tubularSegments + 1 ) * j + i - 1;
+				const b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1;
+				const c = ( tubularSegments + 1 ) * ( j - 1 ) + i;
+				const d = ( tubularSegments + 1 ) * j + i;
+
+				// faces
+
+				indices.push( a, b, d );
+				indices.push( b, c, d );
+
+			}
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new TorusGeometry( data.radius, data.tube, data.radialSegments, data.tubularSegments, data.arc );
+
+	}
+
+}
+
+class TorusKnotGeometry extends BufferGeometry {
+
+	constructor( radius = 1, tube = 0.4, tubularSegments = 64, radialSegments = 8, p = 2, q = 3 ) {
+
+		super();
+
+		this.type = 'TorusKnotGeometry';
+
+		this.parameters = {
+			radius: radius,
+			tube: tube,
+			tubularSegments: tubularSegments,
+			radialSegments: radialSegments,
+			p: p,
+			q: q
+		};
+
+		tubularSegments = Math.floor( tubularSegments );
+		radialSegments = Math.floor( radialSegments );
+
+		// buffers
+
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+
+		// helper variables
+
+		const vertex = new Vector3();
+		const normal = new Vector3();
+
+		const P1 = new Vector3();
+		const P2 = new Vector3();
+
+		const B = new Vector3();
+		const T = new Vector3();
+		const N = new Vector3();
+
+		// generate vertices, normals and uvs
+
+		for ( let i = 0; i <= tubularSegments; ++ i ) {
+
+			// the radian "u" is used to calculate the position on the torus curve of the current tubular segment
+
+			const u = i / tubularSegments * p * Math.PI * 2;
+
+			// now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
+			// these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions
+
+			calculatePositionOnCurve( u, p, q, radius, P1 );
+			calculatePositionOnCurve( u + 0.01, p, q, radius, P2 );
+
+			// calculate orthonormal basis
+
+			T.subVectors( P2, P1 );
+			N.addVectors( P2, P1 );
+			B.crossVectors( T, N );
+			N.crossVectors( B, T );
+
+			// normalize B, N. T can be ignored, we don't use it
+
+			B.normalize();
+			N.normalize();
+
+			for ( let j = 0; j <= radialSegments; ++ j ) {
+
+				// now calculate the vertices. they are nothing more than an extrusion of the torus curve.
+				// because we extrude a shape in the xy-plane, there is no need to calculate a z-value.
+
+				const v = j / radialSegments * Math.PI * 2;
+				const cx = - tube * Math.cos( v );
+				const cy = tube * Math.sin( v );
+
+				// now calculate the final vertex position.
+				// first we orient the extrusion with our basis vectors, then we add it to the current position on the curve
+
+				vertex.x = P1.x + ( cx * N.x + cy * B.x );
+				vertex.y = P1.y + ( cx * N.y + cy * B.y );
+				vertex.z = P1.z + ( cx * N.z + cy * B.z );
+
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+				// normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)
+
+				normal.subVectors( vertex, P1 ).normalize();
+
+				normals.push( normal.x, normal.y, normal.z );
+
+				// uv
+
+				uvs.push( i / tubularSegments );
+				uvs.push( j / radialSegments );
+
+			}
+
+		}
+
+		// generate indices
+
+		for ( let j = 1; j <= tubularSegments; j ++ ) {
+
+			for ( let i = 1; i <= radialSegments; i ++ ) {
+
+				// indices
+
+				const a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );
+				const b = ( radialSegments + 1 ) * j + ( i - 1 );
+				const c = ( radialSegments + 1 ) * j + i;
+				const d = ( radialSegments + 1 ) * ( j - 1 ) + i;
+
+				// faces
+
+				indices.push( a, b, d );
+				indices.push( b, c, d );
+
+			}
+
+		}
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+		// this function calculates the current position on the torus curve
+
+		function calculatePositionOnCurve( u, p, q, radius, position ) {
+
+			const cu = Math.cos( u );
+			const su = Math.sin( u );
+			const quOverP = q / p * u;
+			const cs = Math.cos( quOverP );
+
+			position.x = radius * ( 2 + cs ) * 0.5 * cu;
+			position.y = radius * ( 2 + cs ) * su * 0.5;
+			position.z = radius * Math.sin( quOverP ) * 0.5;
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	static fromJSON( data ) {
+
+		return new TorusKnotGeometry( data.radius, data.tube, data.tubularSegments, data.radialSegments, data.p, data.q );
+
+	}
+
+}
+
+class TubeGeometry extends BufferGeometry {
+
+	constructor( path = new QuadraticBezierCurve3( new Vector3( - 1, - 1, 0 ), new Vector3( - 1, 1, 0 ), new Vector3( 1, 1, 0 ) ), tubularSegments = 64, radius = 1, radialSegments = 8, closed = false ) {
+
+		super();
+
+		this.type = 'TubeGeometry';
+
+		this.parameters = {
+			path: path,
+			tubularSegments: tubularSegments,
+			radius: radius,
+			radialSegments: radialSegments,
+			closed: closed
+		};
+
+		const frames = path.computeFrenetFrames( tubularSegments, closed );
+
+		// expose internals
+
+		this.tangents = frames.tangents;
+		this.normals = frames.normals;
+		this.binormals = frames.binormals;
+
+		// helper variables
+
+		const vertex = new Vector3();
+		const normal = new Vector3();
+		const uv = new Vector2();
+		let P = new Vector3();
+
+		// buffer
+
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+		const indices = [];
+
+		// create buffer data
+
+		generateBufferData();
+
+		// build geometry
+
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+		// functions
+
+		function generateBufferData() {
+
+			for ( let i = 0; i < tubularSegments; i ++ ) {
+
+				generateSegment( i );
+
+			}
+
+			// if the geometry is not closed, generate the last row of vertices and normals
+			// at the regular position on the given path
+			//
+			// if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
+
+			generateSegment( ( closed === false ) ? tubularSegments : 0 );
+
+			// uvs are generated in a separate function.
+			// this makes it easy compute correct values for closed geometries
+
+			generateUVs();
+
+			// finally create faces
+
+			generateIndices();
+
+		}
+
+		function generateSegment( i ) {
+
+			// we use getPointAt to sample evenly distributed points from the given path
+
+			P = path.getPointAt( i / tubularSegments, P );
+
+			// retrieve corresponding normal and binormal
+
+			const N = frames.normals[ i ];
+			const B = frames.binormals[ i ];
+
+			// generate normals and vertices for the current segment
+
+			for ( let j = 0; j <= radialSegments; j ++ ) {
+
+				const v = j / radialSegments * Math.PI * 2;
+
+				const sin = Math.sin( v );
+				const cos = - Math.cos( v );
+
+				// normal
+
+				normal.x = ( cos * N.x + sin * B.x );
+				normal.y = ( cos * N.y + sin * B.y );
+				normal.z = ( cos * N.z + sin * B.z );
+				normal.normalize();
+
+				normals.push( normal.x, normal.y, normal.z );
+
+				// vertex
+
+				vertex.x = P.x + radius * normal.x;
+				vertex.y = P.y + radius * normal.y;
+				vertex.z = P.z + radius * normal.z;
+
+				vertices.push( vertex.x, vertex.y, vertex.z );
+
+			}
+
+		}
+
+		function generateIndices() {
+
+			for ( let j = 1; j <= tubularSegments; j ++ ) {
+
+				for ( let i = 1; i <= radialSegments; i ++ ) {
+
+					const a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );
+					const b = ( radialSegments + 1 ) * j + ( i - 1 );
+					const c = ( radialSegments + 1 ) * j + i;
+					const d = ( radialSegments + 1 ) * ( j - 1 ) + i;
+
+					// faces
+
+					indices.push( a, b, d );
+					indices.push( b, c, d );
+
+				}
+
+			}
+
+		}
+
+		function generateUVs() {
+
+			for ( let i = 0; i <= tubularSegments; i ++ ) {
+
+				for ( let j = 0; j <= radialSegments; j ++ ) {
+
+					uv.x = i / tubularSegments;
+					uv.y = j / radialSegments;
+
+					uvs.push( uv.x, uv.y );
+
+				}
+
+			}
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.path = this.parameters.path.toJSON();
+
+		return data;
+
+	}
+
+	static fromJSON( data ) {
+
+		// This only works for built-in curves (e.g. CatmullRomCurve3).
+		// User defined curves or instances of CurvePath will not be deserialized.
+		return new TubeGeometry(
+			new Curves[ data.path.type ]().fromJSON( data.path ),
+			data.tubularSegments,
+			data.radius,
+			data.radialSegments,
+			data.closed
+		);
+
+	}
+
+}
+
+class WireframeGeometry extends BufferGeometry {
+
+	constructor( geometry = null ) {
+
+		super();
+
+		this.type = 'WireframeGeometry';
+
+		this.parameters = {
+			geometry: geometry
+		};
+
+		if ( geometry !== null ) {
+
+			// buffer
+
+			const vertices = [];
+			const edges = new Set();
+
+			// helper variables
+
+			const start = new Vector3();
+			const end = new Vector3();
+
+			if ( geometry.index !== null ) {
+
+				// indexed BufferGeometry
+
+				const position = geometry.attributes.position;
+				const indices = geometry.index;
+				let groups = geometry.groups;
+
+				if ( groups.length === 0 ) {
+
+					groups = [ { start: 0, count: indices.count, materialIndex: 0 } ];
+
+				}
+
+				// create a data structure that contains all edges without duplicates
+
+				for ( let o = 0, ol = groups.length; o < ol; ++ o ) {
+
+					const group = groups[ o ];
+
+					const groupStart = group.start;
+					const groupCount = group.count;
+
+					for ( let i = groupStart, l = ( groupStart + groupCount ); i < l; i += 3 ) {
+
+						for ( let j = 0; j < 3; j ++ ) {
+
+							const index1 = indices.getX( i + j );
+							const index2 = indices.getX( i + ( j + 1 ) % 3 );
+
+							start.fromBufferAttribute( position, index1 );
+							end.fromBufferAttribute( position, index2 );
+
+							if ( isUniqueEdge( start, end, edges ) === true ) {
+
+								vertices.push( start.x, start.y, start.z );
+								vertices.push( end.x, end.y, end.z );
+
+							}
+
+						}
+
+					}
+
+				}
+
+			} else {
+
+				// non-indexed BufferGeometry
+
+				const position = geometry.attributes.position;
+
+				for ( let i = 0, l = ( position.count / 3 ); i < l; i ++ ) {
+
+					for ( let j = 0; j < 3; j ++ ) {
+
+						// three edges per triangle, an edge is represented as (index1, index2)
+						// e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)
+
+						const index1 = 3 * i + j;
+						const index2 = 3 * i + ( ( j + 1 ) % 3 );
+
+						start.fromBufferAttribute( position, index1 );
+						end.fromBufferAttribute( position, index2 );
+
+						if ( isUniqueEdge( start, end, edges ) === true ) {
+
+							vertices.push( start.x, start.y, start.z );
+							vertices.push( end.x, end.y, end.z );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			// build geometry
+
+			this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+
+		}
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.parameters = Object.assign( {}, source.parameters );
+
+		return this;
+
+	}
+
+}
+
+function isUniqueEdge( start, end, edges ) {
+
+	const hash1 = `${start.x},${start.y},${start.z}-${end.x},${end.y},${end.z}`;
+	const hash2 = `${end.x},${end.y},${end.z}-${start.x},${start.y},${start.z}`; // coincident edge
+
+	if ( edges.has( hash1 ) === true || edges.has( hash2 ) === true ) {
+
+		return false;
+
+	} else {
+
+		edges.add( hash1 );
+		edges.add( hash2 );
+		return true;
+
+	}
+
+}
+
+var Geometries = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	BoxGeometry: BoxGeometry,
+	CapsuleGeometry: CapsuleGeometry,
+	CircleGeometry: CircleGeometry,
+	ConeGeometry: ConeGeometry,
+	CylinderGeometry: CylinderGeometry,
+	DodecahedronGeometry: DodecahedronGeometry,
+	EdgesGeometry: EdgesGeometry,
+	ExtrudeGeometry: ExtrudeGeometry,
+	IcosahedronGeometry: IcosahedronGeometry,
+	LatheGeometry: LatheGeometry,
+	OctahedronGeometry: OctahedronGeometry,
+	PlaneGeometry: PlaneGeometry,
+	PolyhedronGeometry: PolyhedronGeometry,
+	RingGeometry: RingGeometry,
+	ShapeGeometry: ShapeGeometry,
+	SphereGeometry: SphereGeometry,
+	TetrahedronGeometry: TetrahedronGeometry,
+	TorusGeometry: TorusGeometry,
+	TorusKnotGeometry: TorusKnotGeometry,
+	TubeGeometry: TubeGeometry,
+	WireframeGeometry: WireframeGeometry
+});
+
+class ShadowMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isShadowMaterial = true;
+
+		this.type = 'ShadowMaterial';
+
+		this.color = new Color( 0x000000 );
+		this.transparent = true;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+class RawShaderMaterial extends ShaderMaterial {
+
+	constructor( parameters ) {
+
+		super( parameters );
+
+		this.isRawShaderMaterial = true;
+
+		this.type = 'RawShaderMaterial';
+
+	}
+
+}
+
+class MeshStandardMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshStandardMaterial = true;
+
+		this.defines = { 'STANDARD': '' };
+
+		this.type = 'MeshStandardMaterial';
+
+		this.color = new Color( 0xffffff ); // diffuse
+		this.roughness = 1.0;
+		this.metalness = 0.0;
+
+		this.map = null;
+
+		this.lightMap = null;
+		this.lightMapIntensity = 1.0;
+
+		this.aoMap = null;
+		this.aoMapIntensity = 1.0;
+
+		this.emissive = new Color( 0x000000 );
+		this.emissiveIntensity = 1.0;
+		this.emissiveMap = null;
+
+		this.bumpMap = null;
+		this.bumpScale = 1;
+
+		this.normalMap = null;
+		this.normalMapType = TangentSpaceNormalMap;
+		this.normalScale = new Vector2( 1, 1 );
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.roughnessMap = null;
+
+		this.metalnessMap = null;
+
+		this.alphaMap = null;
+
+		this.envMap = null;
+		this.envMapIntensity = 1.0;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+		this.wireframeLinecap = 'round';
+		this.wireframeLinejoin = 'round';
+
+		this.flatShading = false;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.defines = { 'STANDARD': '' };
+
+		this.color.copy( source.color );
+		this.roughness = source.roughness;
+		this.metalness = source.metalness;
+
+		this.map = source.map;
+
+		this.lightMap = source.lightMap;
+		this.lightMapIntensity = source.lightMapIntensity;
+
+		this.aoMap = source.aoMap;
+		this.aoMapIntensity = source.aoMapIntensity;
+
+		this.emissive.copy( source.emissive );
+		this.emissiveMap = source.emissiveMap;
+		this.emissiveIntensity = source.emissiveIntensity;
+
+		this.bumpMap = source.bumpMap;
+		this.bumpScale = source.bumpScale;
+
+		this.normalMap = source.normalMap;
+		this.normalMapType = source.normalMapType;
+		this.normalScale.copy( source.normalScale );
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.roughnessMap = source.roughnessMap;
+
+		this.metalnessMap = source.metalnessMap;
+
+		this.alphaMap = source.alphaMap;
+
+		this.envMap = source.envMap;
+		this.envMapIntensity = source.envMapIntensity;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+		this.wireframeLinecap = source.wireframeLinecap;
+		this.wireframeLinejoin = source.wireframeLinejoin;
+
+		this.flatShading = source.flatShading;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+class MeshPhysicalMaterial extends MeshStandardMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshPhysicalMaterial = true;
+
+		this.defines = {
+
+			'STANDARD': '',
+			'PHYSICAL': ''
+
+		};
+
+		this.type = 'MeshPhysicalMaterial';
+
+		this.anisotropyRotation = 0;
+		this.anisotropyMap = null;
+
+		this.clearcoatMap = null;
+		this.clearcoatRoughness = 0.0;
+		this.clearcoatRoughnessMap = null;
+		this.clearcoatNormalScale = new Vector2( 1, 1 );
+		this.clearcoatNormalMap = null;
+
+		this.ior = 1.5;
+
+		Object.defineProperty( this, 'reflectivity', {
+			get: function () {
+
+				return ( clamp( 2.5 * ( this.ior - 1 ) / ( this.ior + 1 ), 0, 1 ) );
+
+			},
+			set: function ( reflectivity ) {
+
+				this.ior = ( 1 + 0.4 * reflectivity ) / ( 1 - 0.4 * reflectivity );
+
+			}
+		} );
+
+		this.iridescenceMap = null;
+		this.iridescenceIOR = 1.3;
+		this.iridescenceThicknessRange = [ 100, 400 ];
+		this.iridescenceThicknessMap = null;
+
+		this.sheenColor = new Color( 0x000000 );
+		this.sheenColorMap = null;
+		this.sheenRoughness = 1.0;
+		this.sheenRoughnessMap = null;
+
+		this.transmissionMap = null;
+
+		this.thickness = 0;
+		this.thicknessMap = null;
+		this.attenuationDistance = Infinity;
+		this.attenuationColor = new Color( 1, 1, 1 );
+
+		this.specularIntensity = 1.0;
+		this.specularIntensityMap = null;
+		this.specularColor = new Color( 1, 1, 1 );
+		this.specularColorMap = null;
+
+		this._anisotropy = 0;
+		this._clearcoat = 0;
+		this._iridescence = 0;
+		this._sheen = 0.0;
+		this._transmission = 0;
+
+		this.setValues( parameters );
+
+	}
+
+	get anisotropy() {
+
+		return this._anisotropy;
+
+	}
+
+	set anisotropy( value ) {
+
+		if ( this._anisotropy > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._anisotropy = value;
+
+	}
+
+	get clearcoat() {
+
+		return this._clearcoat;
+
+	}
+
+	set clearcoat( value ) {
+
+		if ( this._clearcoat > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._clearcoat = value;
+
+	}
+
+	get iridescence() {
+
+		return this._iridescence;
+
+	}
+
+	set iridescence( value ) {
+
+		if ( this._iridescence > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._iridescence = value;
+
+	}
+
+	get sheen() {
+
+		return this._sheen;
+
+	}
+
+	set sheen( value ) {
+
+		if ( this._sheen > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._sheen = value;
+
+	}
+
+	get transmission() {
+
+		return this._transmission;
+
+	}
+
+	set transmission( value ) {
+
+		if ( this._transmission > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._transmission = value;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.defines = {
+
+			'STANDARD': '',
+			'PHYSICAL': ''
+
+		};
+
+		this.anisotropy = source.anisotropy;
+		this.anisotropyRotation = source.anisotropyRotation;
+		this.anisotropyMap = source.anisotropyMap;
+
+		this.clearcoat = source.clearcoat;
+		this.clearcoatMap = source.clearcoatMap;
+		this.clearcoatRoughness = source.clearcoatRoughness;
+		this.clearcoatRoughnessMap = source.clearcoatRoughnessMap;
+		this.clearcoatNormalMap = source.clearcoatNormalMap;
+		this.clearcoatNormalScale.copy( source.clearcoatNormalScale );
+
+		this.ior = source.ior;
+
+		this.iridescence = source.iridescence;
+		this.iridescenceMap = source.iridescenceMap;
+		this.iridescenceIOR = source.iridescenceIOR;
+		this.iridescenceThicknessRange = [ ...source.iridescenceThicknessRange ];
+		this.iridescenceThicknessMap = source.iridescenceThicknessMap;
+
+		this.sheen = source.sheen;
+		this.sheenColor.copy( source.sheenColor );
+		this.sheenColorMap = source.sheenColorMap;
+		this.sheenRoughness = source.sheenRoughness;
+		this.sheenRoughnessMap = source.sheenRoughnessMap;
+
+		this.transmission = source.transmission;
+		this.transmissionMap = source.transmissionMap;
+
+		this.thickness = source.thickness;
+		this.thicknessMap = source.thicknessMap;
+		this.attenuationDistance = source.attenuationDistance;
+		this.attenuationColor.copy( source.attenuationColor );
+
+		this.specularIntensity = source.specularIntensity;
+		this.specularIntensityMap = source.specularIntensityMap;
+		this.specularColor.copy( source.specularColor );
+		this.specularColorMap = source.specularColorMap;
+
+		return this;
+
+	}
+
+}
+
+class MeshPhongMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshPhongMaterial = true;
+
+		this.type = 'MeshPhongMaterial';
+
+		this.color = new Color( 0xffffff ); // diffuse
+		this.specular = new Color( 0x111111 );
+		this.shininess = 30;
+
+		this.map = null;
+
+		this.lightMap = null;
+		this.lightMapIntensity = 1.0;
+
+		this.aoMap = null;
+		this.aoMapIntensity = 1.0;
+
+		this.emissive = new Color( 0x000000 );
+		this.emissiveIntensity = 1.0;
+		this.emissiveMap = null;
+
+		this.bumpMap = null;
+		this.bumpScale = 1;
+
+		this.normalMap = null;
+		this.normalMapType = TangentSpaceNormalMap;
+		this.normalScale = new Vector2( 1, 1 );
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.specularMap = null;
+
+		this.alphaMap = null;
+
+		this.envMap = null;
+		this.combine = MultiplyOperation;
+		this.reflectivity = 1;
+		this.refractionRatio = 0.98;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+		this.wireframeLinecap = 'round';
+		this.wireframeLinejoin = 'round';
+
+		this.flatShading = false;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+		this.specular.copy( source.specular );
+		this.shininess = source.shininess;
+
+		this.map = source.map;
+
+		this.lightMap = source.lightMap;
+		this.lightMapIntensity = source.lightMapIntensity;
+
+		this.aoMap = source.aoMap;
+		this.aoMapIntensity = source.aoMapIntensity;
+
+		this.emissive.copy( source.emissive );
+		this.emissiveMap = source.emissiveMap;
+		this.emissiveIntensity = source.emissiveIntensity;
+
+		this.bumpMap = source.bumpMap;
+		this.bumpScale = source.bumpScale;
+
+		this.normalMap = source.normalMap;
+		this.normalMapType = source.normalMapType;
+		this.normalScale.copy( source.normalScale );
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.specularMap = source.specularMap;
+
+		this.alphaMap = source.alphaMap;
+
+		this.envMap = source.envMap;
+		this.combine = source.combine;
+		this.reflectivity = source.reflectivity;
+		this.refractionRatio = source.refractionRatio;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+		this.wireframeLinecap = source.wireframeLinecap;
+		this.wireframeLinejoin = source.wireframeLinejoin;
+
+		this.flatShading = source.flatShading;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+class MeshToonMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshToonMaterial = true;
+
+		this.defines = { 'TOON': '' };
+
+		this.type = 'MeshToonMaterial';
+
+		this.color = new Color( 0xffffff );
+
+		this.map = null;
+		this.gradientMap = null;
+
+		this.lightMap = null;
+		this.lightMapIntensity = 1.0;
+
+		this.aoMap = null;
+		this.aoMapIntensity = 1.0;
+
+		this.emissive = new Color( 0x000000 );
+		this.emissiveIntensity = 1.0;
+		this.emissiveMap = null;
+
+		this.bumpMap = null;
+		this.bumpScale = 1;
+
+		this.normalMap = null;
+		this.normalMapType = TangentSpaceNormalMap;
+		this.normalScale = new Vector2( 1, 1 );
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.alphaMap = null;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+		this.wireframeLinecap = 'round';
+		this.wireframeLinejoin = 'round';
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+		this.gradientMap = source.gradientMap;
+
+		this.lightMap = source.lightMap;
+		this.lightMapIntensity = source.lightMapIntensity;
+
+		this.aoMap = source.aoMap;
+		this.aoMapIntensity = source.aoMapIntensity;
+
+		this.emissive.copy( source.emissive );
+		this.emissiveMap = source.emissiveMap;
+		this.emissiveIntensity = source.emissiveIntensity;
+
+		this.bumpMap = source.bumpMap;
+		this.bumpScale = source.bumpScale;
+
+		this.normalMap = source.normalMap;
+		this.normalMapType = source.normalMapType;
+		this.normalScale.copy( source.normalScale );
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.alphaMap = source.alphaMap;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+		this.wireframeLinecap = source.wireframeLinecap;
+		this.wireframeLinejoin = source.wireframeLinejoin;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+class MeshNormalMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshNormalMaterial = true;
+
+		this.type = 'MeshNormalMaterial';
+
+		this.bumpMap = null;
+		this.bumpScale = 1;
+
+		this.normalMap = null;
+		this.normalMapType = TangentSpaceNormalMap;
+		this.normalScale = new Vector2( 1, 1 );
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+
+		this.flatShading = false;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.bumpMap = source.bumpMap;
+		this.bumpScale = source.bumpScale;
+
+		this.normalMap = source.normalMap;
+		this.normalMapType = source.normalMapType;
+		this.normalScale.copy( source.normalScale );
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+
+		this.flatShading = source.flatShading;
+
+		return this;
+
+	}
+
+}
+
+class MeshLambertMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshLambertMaterial = true;
+
+		this.type = 'MeshLambertMaterial';
+
+		this.color = new Color( 0xffffff ); // diffuse
+
+		this.map = null;
+
+		this.lightMap = null;
+		this.lightMapIntensity = 1.0;
+
+		this.aoMap = null;
+		this.aoMapIntensity = 1.0;
+
+		this.emissive = new Color( 0x000000 );
+		this.emissiveIntensity = 1.0;
+		this.emissiveMap = null;
+
+		this.bumpMap = null;
+		this.bumpScale = 1;
+
+		this.normalMap = null;
+		this.normalMapType = TangentSpaceNormalMap;
+		this.normalScale = new Vector2( 1, 1 );
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.specularMap = null;
+
+		this.alphaMap = null;
+
+		this.envMap = null;
+		this.combine = MultiplyOperation;
+		this.reflectivity = 1;
+		this.refractionRatio = 0.98;
+
+		this.wireframe = false;
+		this.wireframeLinewidth = 1;
+		this.wireframeLinecap = 'round';
+		this.wireframeLinejoin = 'round';
+
+		this.flatShading = false;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+
+		this.lightMap = source.lightMap;
+		this.lightMapIntensity = source.lightMapIntensity;
+
+		this.aoMap = source.aoMap;
+		this.aoMapIntensity = source.aoMapIntensity;
+
+		this.emissive.copy( source.emissive );
+		this.emissiveMap = source.emissiveMap;
+		this.emissiveIntensity = source.emissiveIntensity;
+
+		this.bumpMap = source.bumpMap;
+		this.bumpScale = source.bumpScale;
+
+		this.normalMap = source.normalMap;
+		this.normalMapType = source.normalMapType;
+		this.normalScale.copy( source.normalScale );
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.specularMap = source.specularMap;
+
+		this.alphaMap = source.alphaMap;
+
+		this.envMap = source.envMap;
+		this.combine = source.combine;
+		this.reflectivity = source.reflectivity;
+		this.refractionRatio = source.refractionRatio;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+		this.wireframeLinecap = source.wireframeLinecap;
+		this.wireframeLinejoin = source.wireframeLinejoin;
+
+		this.flatShading = source.flatShading;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+class MeshMatcapMaterial extends Material {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshMatcapMaterial = true;
+
+		this.defines = { 'MATCAP': '' };
+
+		this.type = 'MeshMatcapMaterial';
+
+		this.color = new Color( 0xffffff ); // diffuse
+
+		this.matcap = null;
+
+		this.map = null;
+
+		this.bumpMap = null;
+		this.bumpScale = 1;
+
+		this.normalMap = null;
+		this.normalMapType = TangentSpaceNormalMap;
+		this.normalScale = new Vector2( 1, 1 );
+
+		this.displacementMap = null;
+		this.displacementScale = 1;
+		this.displacementBias = 0;
+
+		this.alphaMap = null;
+
+		this.flatShading = false;
+
+		this.fog = true;
+
+		this.setValues( parameters );
+
+	}
+
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.defines = { 'MATCAP': '' };
+
+		this.color.copy( source.color );
+
+		this.matcap = source.matcap;
+
+		this.map = source.map;
+
+		this.bumpMap = source.bumpMap;
+		this.bumpScale = source.bumpScale;
+
+		this.normalMap = source.normalMap;
+		this.normalMapType = source.normalMapType;
+		this.normalScale.copy( source.normalScale );
+
+		this.displacementMap = source.displacementMap;
+		this.displacementScale = source.displacementScale;
+		this.displacementBias = source.displacementBias;
+
+		this.alphaMap = source.alphaMap;
+
+		this.flatShading = source.flatShading;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+class LineDashedMaterial extends LineBasicMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isLineDashedMaterial = true;
+
+		this.type = 'LineDashedMaterial';
+
+		this.scale = 1;
+		this.dashSize = 3;
+		this.gapSize = 1;
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.scale = source.scale;
+		this.dashSize = source.dashSize;
+		this.gapSize = source.gapSize;
+
+		return this;
+
+	}
+
+}
+
+// converts an array to a specific type
+function convertArray( array, type, forceClone ) {
+
+	if ( ! array || // let 'undefined' and 'null' pass
+		! forceClone && array.constructor === type ) return array;
+
+	if ( typeof type.BYTES_PER_ELEMENT === 'number' ) {
+
+		return new type( array ); // create typed array
+
+	}
+
+	return Array.prototype.slice.call( array ); // create Array
+
+}
+
+function isTypedArray( object ) {
+
+	return ArrayBuffer.isView( object ) &&
+		! ( object instanceof DataView );
+
+}
+
+// returns an array by which times and values can be sorted
+function getKeyframeOrder( times ) {
+
+	function compareTime( i, j ) {
+
+		return times[ i ] - times[ j ];
+
+	}
+
+	const n = times.length;
+	const result = new Array( n );
+	for ( let i = 0; i !== n; ++ i ) result[ i ] = i;
+
+	result.sort( compareTime );
+
+	return result;
+
+}
+
+// uses the array previously returned by 'getKeyframeOrder' to sort data
+function sortedArray( values, stride, order ) {
+
+	const nValues = values.length;
+	const result = new values.constructor( nValues );
+
+	for ( let i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {
+
+		const srcOffset = order[ i ] * stride;
+
+		for ( let j = 0; j !== stride; ++ j ) {
+
+			result[ dstOffset ++ ] = values[ srcOffset + j ];
+
+		}
+
+	}
+
+	return result;
+
+}
+
+// function for parsing AOS keyframe formats
+function flattenJSON( jsonKeys, times, values, valuePropertyName ) {
+
+	let i = 1, key = jsonKeys[ 0 ];
+
+	while ( key !== undefined && key[ valuePropertyName ] === undefined ) {
+
+		key = jsonKeys[ i ++ ];
+
+	}
+
+	if ( key === undefined ) return; // no data
+
+	let value = key[ valuePropertyName ];
+	if ( value === undefined ) return; // no data
+
+	if ( Array.isArray( value ) ) {
+
+		do {
+
+			value = key[ valuePropertyName ];
+
+			if ( value !== undefined ) {
+
+				times.push( key.time );
+				values.push.apply( values, value ); // push all elements
+
+			}
+
+			key = jsonKeys[ i ++ ];
+
+		} while ( key !== undefined );
+
+	} else if ( value.toArray !== undefined ) {
+
+		// ...assume THREE.Math-ish
+
+		do {
+
+			value = key[ valuePropertyName ];
+
+			if ( value !== undefined ) {
+
+				times.push( key.time );
+				value.toArray( values, values.length );
+
+			}
+
+			key = jsonKeys[ i ++ ];
+
+		} while ( key !== undefined );
+
+	} else {
+
+		// otherwise push as-is
+
+		do {
+
+			value = key[ valuePropertyName ];
+
+			if ( value !== undefined ) {
+
+				times.push( key.time );
+				values.push( value );
+
+			}
+
+			key = jsonKeys[ i ++ ];
+
+		} while ( key !== undefined );
+
+	}
+
+}
+
+function subclip( sourceClip, name, startFrame, endFrame, fps = 30 ) {
+
+	const clip = sourceClip.clone();
+
+	clip.name = name;
+
+	const tracks = [];
+
+	for ( let i = 0; i < clip.tracks.length; ++ i ) {
+
+		const track = clip.tracks[ i ];
+		const valueSize = track.getValueSize();
+
+		const times = [];
+		const values = [];
+
+		for ( let j = 0; j < track.times.length; ++ j ) {
+
+			const frame = track.times[ j ] * fps;
+
+			if ( frame < startFrame || frame >= endFrame ) continue;
+
+			times.push( track.times[ j ] );
+
+			for ( let k = 0; k < valueSize; ++ k ) {
+
+				values.push( track.values[ j * valueSize + k ] );
+
+			}
+
+		}
+
+		if ( times.length === 0 ) continue;
+
+		track.times = convertArray( times, track.times.constructor );
+		track.values = convertArray( values, track.values.constructor );
+
+		tracks.push( track );
+
+	}
+
+	clip.tracks = tracks;
+
+	// find minimum .times value across all tracks in the trimmed clip
+
+	let minStartTime = Infinity;
+
+	for ( let i = 0; i < clip.tracks.length; ++ i ) {
+
+		if ( minStartTime > clip.tracks[ i ].times[ 0 ] ) {
+
+			minStartTime = clip.tracks[ i ].times[ 0 ];
+
+		}
+
+	}
+
+	// shift all tracks such that clip begins at t=0
+
+	for ( let i = 0; i < clip.tracks.length; ++ i ) {
+
+		clip.tracks[ i ].shift( - 1 * minStartTime );
+
+	}
+
+	clip.resetDuration();
+
+	return clip;
+
+}
+
+function makeClipAdditive( targetClip, referenceFrame = 0, referenceClip = targetClip, fps = 30 ) {
+
+	if ( fps <= 0 ) fps = 30;
+
+	const numTracks = referenceClip.tracks.length;
+	const referenceTime = referenceFrame / fps;
+
+	// Make each track's values relative to the values at the reference frame
+	for ( let i = 0; i < numTracks; ++ i ) {
+
+		const referenceTrack = referenceClip.tracks[ i ];
+		const referenceTrackType = referenceTrack.ValueTypeName;
+
+		// Skip this track if it's non-numeric
+		if ( referenceTrackType === 'bool' || referenceTrackType === 'string' ) continue;
+
+		// Find the track in the target clip whose name and type matches the reference track
+		const targetTrack = targetClip.tracks.find( function ( track ) {
+
+			return track.name === referenceTrack.name
+				&& track.ValueTypeName === referenceTrackType;
+
+		} );
+
+		if ( targetTrack === undefined ) continue;
+
+		let referenceOffset = 0;
+		const referenceValueSize = referenceTrack.getValueSize();
+
+		if ( referenceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {
+
+			referenceOffset = referenceValueSize / 3;
+
+		}
+
+		let targetOffset = 0;
+		const targetValueSize = targetTrack.getValueSize();
+
+		if ( targetTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {
+
+			targetOffset = targetValueSize / 3;
+
+		}
+
+		const lastIndex = referenceTrack.times.length - 1;
+		let referenceValue;
+
+		// Find the value to subtract out of the track
+		if ( referenceTime <= referenceTrack.times[ 0 ] ) {
+
+			// Reference frame is earlier than the first keyframe, so just use the first keyframe
+			const startIndex = referenceOffset;
+			const endIndex = referenceValueSize - referenceOffset;
+			referenceValue = referenceTrack.values.slice( startIndex, endIndex );
+
+		} else if ( referenceTime >= referenceTrack.times[ lastIndex ] ) {
+
+			// Reference frame is after the last keyframe, so just use the last keyframe
+			const startIndex = lastIndex * referenceValueSize + referenceOffset;
+			const endIndex = startIndex + referenceValueSize - referenceOffset;
+			referenceValue = referenceTrack.values.slice( startIndex, endIndex );
+
+		} else {
+
+			// Interpolate to the reference value
+			const interpolant = referenceTrack.createInterpolant();
+			const startIndex = referenceOffset;
+			const endIndex = referenceValueSize - referenceOffset;
+			interpolant.evaluate( referenceTime );
+			referenceValue = interpolant.resultBuffer.slice( startIndex, endIndex );
+
+		}
+
+		// Conjugate the quaternion
+		if ( referenceTrackType === 'quaternion' ) {
+
+			const referenceQuat = new Quaternion().fromArray( referenceValue ).normalize().conjugate();
+			referenceQuat.toArray( referenceValue );
+
+		}
+
+		// Subtract the reference value from all of the track values
+
+		const numTimes = targetTrack.times.length;
+		for ( let j = 0; j < numTimes; ++ j ) {
+
+			const valueStart = j * targetValueSize + targetOffset;
+
+			if ( referenceTrackType === 'quaternion' ) {
+
+				// Multiply the conjugate for quaternion track types
+				Quaternion.multiplyQuaternionsFlat(
+					targetTrack.values,
+					valueStart,
+					referenceValue,
+					0,
+					targetTrack.values,
+					valueStart
+				);
+
+			} else {
+
+				const valueEnd = targetValueSize - targetOffset * 2;
+
+				// Subtract each value for all other numeric track types
+				for ( let k = 0; k < valueEnd; ++ k ) {
+
+					targetTrack.values[ valueStart + k ] -= referenceValue[ k ];
+
+				}
+
+			}
+
+		}
+
+	}
+
+	targetClip.blendMode = AdditiveAnimationBlendMode;
+
+	return targetClip;
+
+}
+
+const AnimationUtils = {
+	convertArray: convertArray,
+	isTypedArray: isTypedArray,
+	getKeyframeOrder: getKeyframeOrder,
+	sortedArray: sortedArray,
+	flattenJSON: flattenJSON,
+	subclip: subclip,
+	makeClipAdditive: makeClipAdditive
+};
+
+/**
+ * Abstract base class of interpolants over parametric samples.
+ *
+ * The parameter domain is one dimensional, typically the time or a path
+ * along a curve defined by the data.
+ *
+ * The sample values can have any dimensionality and derived classes may
+ * apply special interpretations to the data.
+ *
+ * This class provides the interval seek in a Template Method, deferring
+ * the actual interpolation to derived classes.
+ *
+ * Time complexity is O(1) for linear access crossing at most two points
+ * and O(log N) for random access, where N is the number of positions.
+ *
+ * References:
+ *
+ * 		http://www.oodesign.com/template-method-pattern.html
+ *
+ */
+
+class Interpolant {
+
+	constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+		this.parameterPositions = parameterPositions;
+		this._cachedIndex = 0;
+
+		this.resultBuffer = resultBuffer !== undefined ?
+			resultBuffer : new sampleValues.constructor( sampleSize );
+		this.sampleValues = sampleValues;
+		this.valueSize = sampleSize;
+
+		this.settings = null;
+		this.DefaultSettings_ = {};
+
+	}
+
+	evaluate( t ) {
+
+		const pp = this.parameterPositions;
+		let i1 = this._cachedIndex,
+			t1 = pp[ i1 ],
+			t0 = pp[ i1 - 1 ];
+
+		validate_interval: {
+
+			seek: {
+
+				let right;
+
+				linear_scan: {
+
+					//- See http://jsperf.com/comparison-to-undefined/3
+					//- slower code:
+					//-
+					//- 				if ( t >= t1 || t1 === undefined ) {
+					forward_scan: if ( ! ( t < t1 ) ) {
+
+						for ( let giveUpAt = i1 + 2; ; ) {
+
+							if ( t1 === undefined ) {
+
+								if ( t < t0 ) break forward_scan;
+
+								// after end
+
+								i1 = pp.length;
+								this._cachedIndex = i1;
+								return this.copySampleValue_( i1 - 1 );
+
+							}
+
+							if ( i1 === giveUpAt ) break; // this loop
+
+							t0 = t1;
+							t1 = pp[ ++ i1 ];
+
+							if ( t < t1 ) {
+
+								// we have arrived at the sought interval
+								break seek;
+
+							}
+
+						}
+
+						// prepare binary search on the right side of the index
+						right = pp.length;
+						break linear_scan;
+
+					}
+
+					//- slower code:
+					//-					if ( t < t0 || t0 === undefined ) {
+					if ( ! ( t >= t0 ) ) {
+
+						// looping?
+
+						const t1global = pp[ 1 ];
+
+						if ( t < t1global ) {
+
+							i1 = 2; // + 1, using the scan for the details
+							t0 = t1global;
+
+						}
+
+						// linear reverse scan
+
+						for ( let giveUpAt = i1 - 2; ; ) {
+
+							if ( t0 === undefined ) {
+
+								// before start
+
+								this._cachedIndex = 0;
+								return this.copySampleValue_( 0 );
+
+							}
+
+							if ( i1 === giveUpAt ) break; // this loop
+
+							t1 = t0;
+							t0 = pp[ -- i1 - 1 ];
+
+							if ( t >= t0 ) {
+
+								// we have arrived at the sought interval
+								break seek;
+
+							}
+
+						}
+
+						// prepare binary search on the left side of the index
+						right = i1;
+						i1 = 0;
+						break linear_scan;
+
+					}
+
+					// the interval is valid
+
+					break validate_interval;
+
+				} // linear scan
+
+				// binary search
+
+				while ( i1 < right ) {
+
+					const mid = ( i1 + right ) >>> 1;
+
+					if ( t < pp[ mid ] ) {
+
+						right = mid;
+
+					} else {
+
+						i1 = mid + 1;
+
+					}
+
+				}
+
+				t1 = pp[ i1 ];
+				t0 = pp[ i1 - 1 ];
+
+				// check boundary cases, again
+
+				if ( t0 === undefined ) {
+
+					this._cachedIndex = 0;
+					return this.copySampleValue_( 0 );
+
+				}
+
+				if ( t1 === undefined ) {
+
+					i1 = pp.length;
+					this._cachedIndex = i1;
+					return this.copySampleValue_( i1 - 1 );
+
+				}
+
+			} // seek
+
+			this._cachedIndex = i1;
+
+			this.intervalChanged_( i1, t0, t1 );
+
+		} // validate_interval
+
+		return this.interpolate_( i1, t0, t, t1 );
+
+	}
+
+	getSettings_() {
+
+		return this.settings || this.DefaultSettings_;
+
+	}
+
+	copySampleValue_( index ) {
+
+		// copies a sample value to the result buffer
+
+		const result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+			offset = index * stride;
+
+		for ( let i = 0; i !== stride; ++ i ) {
+
+			result[ i ] = values[ offset + i ];
+
+		}
+
+		return result;
+
+	}
+
+	// Template methods for derived classes:
+
+	interpolate_( /* i1, t0, t, t1 */ ) {
+
+		throw new Error( 'call to abstract method' );
+		// implementations shall return this.resultBuffer
+
+	}
+
+	intervalChanged_( /* i1, t0, t1 */ ) {
+
+		// empty
+
+	}
+
+}
+
+/**
+ * Fast and simple cubic spline interpolant.
+ *
+ * It was derived from a Hermitian construction setting the first derivative
+ * at each sample position to the linear slope between neighboring positions
+ * over their parameter interval.
+ */
+
+class CubicInterpolant extends Interpolant {
+
+	constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+		super( parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+		this._weightPrev = - 0;
+		this._offsetPrev = - 0;
+		this._weightNext = - 0;
+		this._offsetNext = - 0;
+
+		this.DefaultSettings_ = {
+
+			endingStart: ZeroCurvatureEnding,
+			endingEnd: ZeroCurvatureEnding
+
+		};
+
+	}
+
+	intervalChanged_( i1, t0, t1 ) {
+
+		const pp = this.parameterPositions;
+		let iPrev = i1 - 2,
+			iNext = i1 + 1,
+
+			tPrev = pp[ iPrev ],
+			tNext = pp[ iNext ];
+
+		if ( tPrev === undefined ) {
+
+			switch ( this.getSettings_().endingStart ) {
+
+				case ZeroSlopeEnding:
+
+					// f'(t0) = 0
+					iPrev = i1;
+					tPrev = 2 * t0 - t1;
+
+					break;
+
+				case WrapAroundEnding:
+
+					// use the other end of the curve
+					iPrev = pp.length - 2;
+					tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];
+
+					break;
+
+				default: // ZeroCurvatureEnding
+
+					// f''(t0) = 0 a.k.a. Natural Spline
+					iPrev = i1;
+					tPrev = t1;
+
+			}
+
+		}
+
+		if ( tNext === undefined ) {
+
+			switch ( this.getSettings_().endingEnd ) {
+
+				case ZeroSlopeEnding:
+
+					// f'(tN) = 0
+					iNext = i1;
+					tNext = 2 * t1 - t0;
+
+					break;
+
+				case WrapAroundEnding:
+
+					// use the other end of the curve
+					iNext = 1;
+					tNext = t1 + pp[ 1 ] - pp[ 0 ];
+
+					break;
+
+				default: // ZeroCurvatureEnding
+
+					// f''(tN) = 0, a.k.a. Natural Spline
+					iNext = i1 - 1;
+					tNext = t0;
+
+			}
+
+		}
+
+		const halfDt = ( t1 - t0 ) * 0.5,
+			stride = this.valueSize;
+
+		this._weightPrev = halfDt / ( t0 - tPrev );
+		this._weightNext = halfDt / ( tNext - t1 );
+		this._offsetPrev = iPrev * stride;
+		this._offsetNext = iNext * stride;
+
+	}
+
+	interpolate_( i1, t0, t, t1 ) {
+
+		const result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+
+			o1 = i1 * stride,		o0 = o1 - stride,
+			oP = this._offsetPrev, 	oN = this._offsetNext,
+			wP = this._weightPrev,	wN = this._weightNext,
+
+			p = ( t - t0 ) / ( t1 - t0 ),
+			pp = p * p,
+			ppp = pp * p;
+
+		// evaluate polynomials
+
+		const sP = - wP * ppp + 2 * wP * pp - wP * p;
+		const s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1;
+		const s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p;
+		const sN = wN * ppp - wN * pp;
+
+		// combine data linearly
+
+		for ( let i = 0; i !== stride; ++ i ) {
+
+			result[ i ] =
+					sP * values[ oP + i ] +
+					s0 * values[ o0 + i ] +
+					s1 * values[ o1 + i ] +
+					sN * values[ oN + i ];
+
+		}
+
+		return result;
+
+	}
+
+}
+
+class LinearInterpolant extends Interpolant {
+
+	constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+		super( parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+	}
+
+	interpolate_( i1, t0, t, t1 ) {
+
+		const result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+
+			offset1 = i1 * stride,
+			offset0 = offset1 - stride,
+
+			weight1 = ( t - t0 ) / ( t1 - t0 ),
+			weight0 = 1 - weight1;
+
+		for ( let i = 0; i !== stride; ++ i ) {
+
+			result[ i ] =
+					values[ offset0 + i ] * weight0 +
+					values[ offset1 + i ] * weight1;
+
+		}
+
+		return result;
+
+	}
+
+}
+
+/**
+ *
+ * Interpolant that evaluates to the sample value at the position preceding
+ * the parameter.
+ */
+
+class DiscreteInterpolant extends Interpolant {
+
+	constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+		super( parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+	}
+
+	interpolate_( i1 /*, t0, t, t1 */ ) {
+
+		return this.copySampleValue_( i1 - 1 );
+
+	}
+
+}
+
+class KeyframeTrack {
+
+	constructor( name, times, values, interpolation ) {
+
+		if ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' );
+		if ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name );
+
+		this.name = name;
+
+		this.times = convertArray( times, this.TimeBufferType );
+		this.values = convertArray( values, this.ValueBufferType );
+
+		this.setInterpolation( interpolation || this.DefaultInterpolation );
+
+	}
+
+	// Serialization (in static context, because of constructor invocation
+	// and automatic invocation of .toJSON):
+
+	static toJSON( track ) {
+
+		const trackType = track.constructor;
+
+		let json;
+
+		// derived classes can define a static toJSON method
+		if ( trackType.toJSON !== this.toJSON ) {
+
+			json = trackType.toJSON( track );
+
+		} else {
+
+			// by default, we assume the data can be serialized as-is
+			json = {
+
+				'name': track.name,
+				'times': convertArray( track.times, Array ),
+				'values': convertArray( track.values, Array )
+
+			};
+
+			const interpolation = track.getInterpolation();
+
+			if ( interpolation !== track.DefaultInterpolation ) {
+
+				json.interpolation = interpolation;
+
+			}
+
+		}
+
+		json.type = track.ValueTypeName; // mandatory
+
+		return json;
+
+	}
+
+	InterpolantFactoryMethodDiscrete( result ) {
+
+		return new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );
+
+	}
+
+	InterpolantFactoryMethodLinear( result ) {
+
+		return new LinearInterpolant( this.times, this.values, this.getValueSize(), result );
+
+	}
+
+	InterpolantFactoryMethodSmooth( result ) {
+
+		return new CubicInterpolant( this.times, this.values, this.getValueSize(), result );
+
+	}
+
+	setInterpolation( interpolation ) {
+
+		let factoryMethod;
+
+		switch ( interpolation ) {
+
+			case InterpolateDiscrete:
+
+				factoryMethod = this.InterpolantFactoryMethodDiscrete;
+
+				break;
+
+			case InterpolateLinear:
+
+				factoryMethod = this.InterpolantFactoryMethodLinear;
+
+				break;
+
+			case InterpolateSmooth:
+
+				factoryMethod = this.InterpolantFactoryMethodSmooth;
+
+				break;
+
+		}
+
+		if ( factoryMethod === undefined ) {
+
+			const message = 'unsupported interpolation for ' +
+				this.ValueTypeName + ' keyframe track named ' + this.name;
+
+			if ( this.createInterpolant === undefined ) {
+
+				// fall back to default, unless the default itself is messed up
+				if ( interpolation !== this.DefaultInterpolation ) {
+
+					this.setInterpolation( this.DefaultInterpolation );
+
+				} else {
+
+					throw new Error( message ); // fatal, in this case
+
+				}
+
+			}
+
+			console.warn( 'THREE.KeyframeTrack:', message );
+			return this;
+
+		}
+
+		this.createInterpolant = factoryMethod;
+
+		return this;
+
+	}
+
+	getInterpolation() {
+
+		switch ( this.createInterpolant ) {
+
+			case this.InterpolantFactoryMethodDiscrete:
+
+				return InterpolateDiscrete;
+
+			case this.InterpolantFactoryMethodLinear:
+
+				return InterpolateLinear;
+
+			case this.InterpolantFactoryMethodSmooth:
+
+				return InterpolateSmooth;
+
+		}
+
+	}
+
+	getValueSize() {
+
+		return this.values.length / this.times.length;
+
+	}
+
+	// move all keyframes either forwards or backwards in time
+	shift( timeOffset ) {
+
+		if ( timeOffset !== 0.0 ) {
+
+			const times = this.times;
+
+			for ( let i = 0, n = times.length; i !== n; ++ i ) {
+
+				times[ i ] += timeOffset;
+
+			}
+
+		}
+
+		return this;
+
+	}
+
+	// scale all keyframe times by a factor (useful for frame <-> seconds conversions)
+	scale( timeScale ) {
+
+		if ( timeScale !== 1.0 ) {
+
+			const times = this.times;
+
+			for ( let i = 0, n = times.length; i !== n; ++ i ) {
+
+				times[ i ] *= timeScale;
+
+			}
+
+		}
+
+		return this;
+
+	}
+
+	// removes keyframes before and after animation without changing any values within the range [startTime, endTime].
+	// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
+	trim( startTime, endTime ) {
+
+		const times = this.times,
+			nKeys = times.length;
+
+		let from = 0,
+			to = nKeys - 1;
+
+		while ( from !== nKeys && times[ from ] < startTime ) {
+
+			++ from;
+
+		}
+
+		while ( to !== - 1 && times[ to ] > endTime ) {
+
+			-- to;
+
+		}
+
+		++ to; // inclusive -> exclusive bound
+
+		if ( from !== 0 || to !== nKeys ) {
+
+			// empty tracks are forbidden, so keep at least one keyframe
+			if ( from >= to ) {
+
+				to = Math.max( to, 1 );
+				from = to - 1;
+
+			}
+
+			const stride = this.getValueSize();
+			this.times = times.slice( from, to );
+			this.values = this.values.slice( from * stride, to * stride );
+
+		}
+
+		return this;
+
+	}
+
+	// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
+	validate() {
+
+		let valid = true;
+
+		const valueSize = this.getValueSize();
+		if ( valueSize - Math.floor( valueSize ) !== 0 ) {
+
+			console.error( 'THREE.KeyframeTrack: Invalid value size in track.', this );
+			valid = false;
+
+		}
+
+		const times = this.times,
+			values = this.values,
+
+			nKeys = times.length;
+
+		if ( nKeys === 0 ) {
+
+			console.error( 'THREE.KeyframeTrack: Track is empty.', this );
+			valid = false;
+
+		}
+
+		let prevTime = null;
+
+		for ( let i = 0; i !== nKeys; i ++ ) {
+
+			const currTime = times[ i ];
+
+			if ( typeof currTime === 'number' && isNaN( currTime ) ) {
+
+				console.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime );
+				valid = false;
+				break;
+
+			}
+
+			if ( prevTime !== null && prevTime > currTime ) {
+
+				console.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );
+				valid = false;
+				break;
+
+			}
+
+			prevTime = currTime;
+
+		}
+
+		if ( values !== undefined ) {
+
+			if ( isTypedArray( values ) ) {
+
+				for ( let i = 0, n = values.length; i !== n; ++ i ) {
+
+					const value = values[ i ];
+
+					if ( isNaN( value ) ) {
+
+						console.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value );
+						valid = false;
+						break;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		return valid;
+
+	}
+
+	// removes equivalent sequential keys as common in morph target sequences
+	// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
+	optimize() {
+
+		// times or values may be shared with other tracks, so overwriting is unsafe
+		const times = this.times.slice(),
+			values = this.values.slice(),
+			stride = this.getValueSize(),
+
+			smoothInterpolation = this.getInterpolation() === InterpolateSmooth,
+
+			lastIndex = times.length - 1;
+
+		let writeIndex = 1;
+
+		for ( let i = 1; i < lastIndex; ++ i ) {
+
+			let keep = false;
+
+			const time = times[ i ];
+			const timeNext = times[ i + 1 ];
+
+			// remove adjacent keyframes scheduled at the same time
+
+			if ( time !== timeNext && ( i !== 1 || time !== times[ 0 ] ) ) {
+
+				if ( ! smoothInterpolation ) {
+
+					// remove unnecessary keyframes same as their neighbors
+
+					const offset = i * stride,
+						offsetP = offset - stride,
+						offsetN = offset + stride;
+
+					for ( let j = 0; j !== stride; ++ j ) {
+
+						const value = values[ offset + j ];
+
+						if ( value !== values[ offsetP + j ] ||
+							value !== values[ offsetN + j ] ) {
+
+							keep = true;
+							break;
+
+						}
+
+					}
+
+				} else {
+
+					keep = true;
+
+				}
+
+			}
+
+			// in-place compaction
+
+			if ( keep ) {
+
+				if ( i !== writeIndex ) {
+
+					times[ writeIndex ] = times[ i ];
+
+					const readOffset = i * stride,
+						writeOffset = writeIndex * stride;
+
+					for ( let j = 0; j !== stride; ++ j ) {
+
+						values[ writeOffset + j ] = values[ readOffset + j ];
+
+					}
+
+				}
+
+				++ writeIndex;
+
+			}
+
+		}
+
+		// flush last keyframe (compaction looks ahead)
+
+		if ( lastIndex > 0 ) {
+
+			times[ writeIndex ] = times[ lastIndex ];
+
+			for ( let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {
+
+				values[ writeOffset + j ] = values[ readOffset + j ];
+
+			}
+
+			++ writeIndex;
+
+		}
+
+		if ( writeIndex !== times.length ) {
+
+			this.times = times.slice( 0, writeIndex );
+			this.values = values.slice( 0, writeIndex * stride );
+
+		} else {
+
+			this.times = times;
+			this.values = values;
+
+		}
+
+		return this;
+
+	}
+
+	clone() {
+
+		const times = this.times.slice();
+		const values = this.values.slice();
+
+		const TypedKeyframeTrack = this.constructor;
+		const track = new TypedKeyframeTrack( this.name, times, values );
+
+		// Interpolant argument to constructor is not saved, so copy the factory method directly.
+		track.createInterpolant = this.createInterpolant;
+
+		return track;
+
+	}
+
+}
+
+KeyframeTrack.prototype.TimeBufferType = Float32Array;
+KeyframeTrack.prototype.ValueBufferType = Float32Array;
+KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;
+
+/**
+ * A Track of Boolean keyframe values.
+ */
+class BooleanKeyframeTrack extends KeyframeTrack {}
+
+BooleanKeyframeTrack.prototype.ValueTypeName = 'bool';
+BooleanKeyframeTrack.prototype.ValueBufferType = Array;
+BooleanKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
+BooleanKeyframeTrack.prototype.InterpolantFactoryMethodLinear = undefined;
+BooleanKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;
+
+/**
+ * A Track of keyframe values that represent color.
+ */
+class ColorKeyframeTrack extends KeyframeTrack {}
+
+ColorKeyframeTrack.prototype.ValueTypeName = 'color';
+
+/**
+ * A Track of numeric keyframe values.
+ */
+class NumberKeyframeTrack extends KeyframeTrack {}
+
+NumberKeyframeTrack.prototype.ValueTypeName = 'number';
+
+/**
+ * Spherical linear unit quaternion interpolant.
+ */
+
+class QuaternionLinearInterpolant extends Interpolant {
+
+	constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+		super( parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+	}
+
+	interpolate_( i1, t0, t, t1 ) {
+
+		const result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+
+			alpha = ( t - t0 ) / ( t1 - t0 );
+
+		let offset = i1 * stride;
+
+		for ( let end = offset + stride; offset !== end; offset += 4 ) {
+
+			Quaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha );
+
+		}
+
+		return result;
+
+	}
+
+}
+
+/**
+ * A Track of quaternion keyframe values.
+ */
+class QuaternionKeyframeTrack extends KeyframeTrack {
+
+	InterpolantFactoryMethodLinear( result ) {
+
+		return new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result );
+
+	}
+
+}
+
+QuaternionKeyframeTrack.prototype.ValueTypeName = 'quaternion';
+// ValueBufferType is inherited
+QuaternionKeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;
+QuaternionKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;
+
+/**
+ * A Track that interpolates Strings
+ */
+class StringKeyframeTrack extends KeyframeTrack {}
+
+StringKeyframeTrack.prototype.ValueTypeName = 'string';
+StringKeyframeTrack.prototype.ValueBufferType = Array;
+StringKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
+StringKeyframeTrack.prototype.InterpolantFactoryMethodLinear = undefined;
+StringKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;
+
+/**
+ * A Track of vectored keyframe values.
+ */
+class VectorKeyframeTrack extends KeyframeTrack {}
+
+VectorKeyframeTrack.prototype.ValueTypeName = 'vector';
+
+class AnimationClip {
+
+	constructor( name, duration = - 1, tracks, blendMode = NormalAnimationBlendMode ) {
+
+		this.name = name;
+		this.tracks = tracks;
+		this.duration = duration;
+		this.blendMode = blendMode;
+
+		this.uuid = generateUUID();
+
+		// this means it should figure out its duration by scanning the tracks
+		if ( this.duration < 0 ) {
+
+			this.resetDuration();
+
+		}
+
+	}
+
+
+	static parse( json ) {
+
+		const tracks = [],
+			jsonTracks = json.tracks,
+			frameTime = 1.0 / ( json.fps || 1.0 );
+
+		for ( let i = 0, n = jsonTracks.length; i !== n; ++ i ) {
+
+			tracks.push( parseKeyframeTrack( jsonTracks[ i ] ).scale( frameTime ) );
+
+		}
+
+		const clip = new this( json.name, json.duration, tracks, json.blendMode );
+		clip.uuid = json.uuid;
+
+		return clip;
+
+	}
+
+	static toJSON( clip ) {
+
+		const tracks = [],
+			clipTracks = clip.tracks;
+
+		const json = {
+
+			'name': clip.name,
+			'duration': clip.duration,
+			'tracks': tracks,
+			'uuid': clip.uuid,
+			'blendMode': clip.blendMode
+
+		};
+
+		for ( let i = 0, n = clipTracks.length; i !== n; ++ i ) {
+
+			tracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) );
+
+		}
+
+		return json;
+
+	}
+
+	static CreateFromMorphTargetSequence( name, morphTargetSequence, fps, noLoop ) {
+
+		const numMorphTargets = morphTargetSequence.length;
+		const tracks = [];
+
+		for ( let i = 0; i < numMorphTargets; i ++ ) {
+
+			let times = [];
+			let values = [];
+
+			times.push(
+				( i + numMorphTargets - 1 ) % numMorphTargets,
+				i,
+				( i + 1 ) % numMorphTargets );
+
+			values.push( 0, 1, 0 );
+
+			const order = getKeyframeOrder( times );
+			times = sortedArray( times, 1, order );
+			values = sortedArray( values, 1, order );
+
+			// if there is a key at the first frame, duplicate it as the
+			// last frame as well for perfect loop.
+			if ( ! noLoop && times[ 0 ] === 0 ) {
+
+				times.push( numMorphTargets );
+				values.push( values[ 0 ] );
+
+			}
+
+			tracks.push(
+				new NumberKeyframeTrack(
+					'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',
+					times, values
+				).scale( 1.0 / fps ) );
+
+		}
+
+		return new this( name, - 1, tracks );
+
+	}
+
+	static findByName( objectOrClipArray, name ) {
+
+		let clipArray = objectOrClipArray;
+
+		if ( ! Array.isArray( objectOrClipArray ) ) {
+
+			const o = objectOrClipArray;
+			clipArray = o.geometry && o.geometry.animations || o.animations;
+
+		}
+
+		for ( let i = 0; i < clipArray.length; i ++ ) {
+
+			if ( clipArray[ i ].name === name ) {
+
+				return clipArray[ i ];
+
+			}
+
+		}
+
+		return null;
+
+	}
+
+	static CreateClipsFromMorphTargetSequences( morphTargets, fps, noLoop ) {
+
+		const animationToMorphTargets = {};
+
+		// tested with https://regex101.com/ on trick sequences
+		// such flamingo_flyA_003, flamingo_run1_003, crdeath0059
+		const pattern = /^([\w-]*?)([\d]+)$/;
+
+		// sort morph target names into animation groups based
+		// patterns like Walk_001, Walk_002, Run_001, Run_002
+		for ( let i = 0, il = morphTargets.length; i < il; i ++ ) {
+
+			const morphTarget = morphTargets[ i ];
+			const parts = morphTarget.name.match( pattern );
+
+			if ( parts && parts.length > 1 ) {
+
+				const name = parts[ 1 ];
+
+				let animationMorphTargets = animationToMorphTargets[ name ];
+
+				if ( ! animationMorphTargets ) {
+
+					animationToMorphTargets[ name ] = animationMorphTargets = [];
+
+				}
+
+				animationMorphTargets.push( morphTarget );
+
+			}
+
+		}
+
+		const clips = [];
+
+		for ( const name in animationToMorphTargets ) {
+
+			clips.push( this.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );
+
+		}
+
+		return clips;
+
+	}
+
+	// parse the animation.hierarchy format
+	static parseAnimation( animation, bones ) {
+
+		if ( ! animation ) {
+
+			console.error( 'THREE.AnimationClip: No animation in JSONLoader data.' );
+			return null;
+
+		}
+
+		const addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {
+
+			// only return track if there are actually keys.
+			if ( animationKeys.length !== 0 ) {
+
+				const times = [];
+				const values = [];
+
+				flattenJSON( animationKeys, times, values, propertyName );
+
+				// empty keys are filtered out, so check again
+				if ( times.length !== 0 ) {
+
+					destTracks.push( new trackType( trackName, times, values ) );
+
+				}
+
+			}
+
+		};
+
+		const tracks = [];
+
+		const clipName = animation.name || 'default';
+		const fps = animation.fps || 30;
+		const blendMode = animation.blendMode;
+
+		// automatic length determination in AnimationClip.
+		let duration = animation.length || - 1;
+
+		const hierarchyTracks = animation.hierarchy || [];
+
+		for ( let h = 0; h < hierarchyTracks.length; h ++ ) {
+
+			const animationKeys = hierarchyTracks[ h ].keys;
+
+			// skip empty tracks
+			if ( ! animationKeys || animationKeys.length === 0 ) continue;
+
+			// process morph targets
+			if ( animationKeys[ 0 ].morphTargets ) {
+
+				// figure out all morph targets used in this track
+				const morphTargetNames = {};
+
+				let k;
+
+				for ( k = 0; k < animationKeys.length; k ++ ) {
+
+					if ( animationKeys[ k ].morphTargets ) {
+
+						for ( let m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {
+
+							morphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;
+
+						}
+
+					}
+
+				}
+
+				// create a track for each morph target with all zero
+				// morphTargetInfluences except for the keys in which
+				// the morphTarget is named.
+				for ( const morphTargetName in morphTargetNames ) {
+
+					const times = [];
+					const values = [];
+
+					for ( let m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {
+
+						const animationKey = animationKeys[ k ];
+
+						times.push( animationKey.time );
+						values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );
+
+					}
+
+					tracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );
+
+				}
+
+				duration = morphTargetNames.length * fps;
+
+			} else {
+
+				// ...assume skeletal animation
+
+				const boneName = '.bones[' + bones[ h ].name + ']';
+
+				addNonemptyTrack(
+					VectorKeyframeTrack, boneName + '.position',
+					animationKeys, 'pos', tracks );
+
+				addNonemptyTrack(
+					QuaternionKeyframeTrack, boneName + '.quaternion',
+					animationKeys, 'rot', tracks );
+
+				addNonemptyTrack(
+					VectorKeyframeTrack, boneName + '.scale',
+					animationKeys, 'scl', tracks );
+
+			}
+
+		}
+
+		if ( tracks.length === 0 ) {
+
+			return null;
+
+		}
+
+		const clip = new this( clipName, duration, tracks, blendMode );
+
+		return clip;
+
+	}
+
+	resetDuration() {
+
+		const tracks = this.tracks;
+		let duration = 0;
+
+		for ( let i = 0, n = tracks.length; i !== n; ++ i ) {
+
+			const track = this.tracks[ i ];
+
+			duration = Math.max( duration, track.times[ track.times.length - 1 ] );
+
+		}
+
+		this.duration = duration;
+
+		return this;
+
+	}
+
+	trim() {
+
+		for ( let i = 0; i < this.tracks.length; i ++ ) {
+
+			this.tracks[ i ].trim( 0, this.duration );
+
+		}
+
+		return this;
+
+	}
+
+	validate() {
+
+		let valid = true;
+
+		for ( let i = 0; i < this.tracks.length; i ++ ) {
+
+			valid = valid && this.tracks[ i ].validate();
+
+		}
+
+		return valid;
+
+	}
+
+	optimize() {
+
+		for ( let i = 0; i < this.tracks.length; i ++ ) {
+
+			this.tracks[ i ].optimize();
+
+		}
+
+		return this;
+
+	}
+
+	clone() {
+
+		const tracks = [];
+
+		for ( let i = 0; i < this.tracks.length; i ++ ) {
+
+			tracks.push( this.tracks[ i ].clone() );
+
+		}
+
+		return new this.constructor( this.name, this.duration, tracks, this.blendMode );
+
+	}
+
+	toJSON() {
+
+		return this.constructor.toJSON( this );
+
+	}
+
+}
+
+function getTrackTypeForValueTypeName( typeName ) {
+
+	switch ( typeName.toLowerCase() ) {
+
+		case 'scalar':
+		case 'double':
+		case 'float':
+		case 'number':
+		case 'integer':
+
+			return NumberKeyframeTrack;
+
+		case 'vector':
+		case 'vector2':
+		case 'vector3':
+		case 'vector4':
+
+			return VectorKeyframeTrack;
+
+		case 'color':
+
+			return ColorKeyframeTrack;
+
+		case 'quaternion':
+
+			return QuaternionKeyframeTrack;
+
+		case 'bool':
+		case 'boolean':
+
+			return BooleanKeyframeTrack;
+
+		case 'string':
+
+			return StringKeyframeTrack;
+
+	}
+
+	throw new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName );
+
+}
+
+function parseKeyframeTrack( json ) {
+
+	if ( json.type === undefined ) {
+
+		throw new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' );
+
+	}
+
+	const trackType = getTrackTypeForValueTypeName( json.type );
+
+	if ( json.times === undefined ) {
+
+		const times = [], values = [];
+
+		flattenJSON( json.keys, times, values, 'value' );
+
+		json.times = times;
+		json.values = values;
+
+	}
+
+	// derived classes can define a static parse method
+	if ( trackType.parse !== undefined ) {
+
+		return trackType.parse( json );
+
+	} else {
+
+		// by default, we assume a constructor compatible with the base
+		return new trackType( json.name, json.times, json.values, json.interpolation );
+
+	}
+
+}
+
+const Cache = {
+
+	enabled: false,
+
+	files: {},
+
+	add: function ( key, file ) {
+
+		if ( this.enabled === false ) return;
+
+		// console.log( 'THREE.Cache', 'Adding key:', key );
+
+		this.files[ key ] = file;
+
+	},
+
+	get: function ( key ) {
+
+		if ( this.enabled === false ) return;
+
+		// console.log( 'THREE.Cache', 'Checking key:', key );
+
+		return this.files[ key ];
+
+	},
+
+	remove: function ( key ) {
+
+		delete this.files[ key ];
+
+	},
+
+	clear: function () {
+
+		this.files = {};
+
+	}
+
+};
+
+class LoadingManager {
+
+	constructor( onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		let isLoading = false;
+		let itemsLoaded = 0;
+		let itemsTotal = 0;
+		let urlModifier = undefined;
+		const handlers = [];
+
+		// Refer to #5689 for the reason why we don't set .onStart
+		// in the constructor
+
+		this.onStart = undefined;
+		this.onLoad = onLoad;
+		this.onProgress = onProgress;
+		this.onError = onError;
+
+		this.itemStart = function ( url ) {
+
+			itemsTotal ++;
+
+			if ( isLoading === false ) {
+
+				if ( scope.onStart !== undefined ) {
+
+					scope.onStart( url, itemsLoaded, itemsTotal );
+
+				}
+
+			}
+
+			isLoading = true;
+
+		};
+
+		this.itemEnd = function ( url ) {
+
+			itemsLoaded ++;
+
+			if ( scope.onProgress !== undefined ) {
+
+				scope.onProgress( url, itemsLoaded, itemsTotal );
+
+			}
+
+			if ( itemsLoaded === itemsTotal ) {
+
+				isLoading = false;
+
+				if ( scope.onLoad !== undefined ) {
+
+					scope.onLoad();
+
+				}
+
+			}
+
+		};
+
+		this.itemError = function ( url ) {
+
+			if ( scope.onError !== undefined ) {
+
+				scope.onError( url );
+
+			}
+
+		};
+
+		this.resolveURL = function ( url ) {
+
+			if ( urlModifier ) {
+
+				return urlModifier( url );
+
+			}
+
+			return url;
+
+		};
+
+		this.setURLModifier = function ( transform ) {
+
+			urlModifier = transform;
+
+			return this;
+
+		};
+
+		this.addHandler = function ( regex, loader ) {
+
+			handlers.push( regex, loader );
+
+			return this;
+
+		};
+
+		this.removeHandler = function ( regex ) {
+
+			const index = handlers.indexOf( regex );
+
+			if ( index !== - 1 ) {
+
+				handlers.splice( index, 2 );
+
+			}
+
+			return this;
+
+		};
+
+		this.getHandler = function ( file ) {
+
+			for ( let i = 0, l = handlers.length; i < l; i += 2 ) {
+
+				const regex = handlers[ i ];
+				const loader = handlers[ i + 1 ];
+
+				if ( regex.global ) regex.lastIndex = 0; // see #17920
+
+				if ( regex.test( file ) ) {
+
+					return loader;
+
+				}
+
+			}
+
+			return null;
+
+		};
+
+	}
+
+}
+
+const DefaultLoadingManager = /*@__PURE__*/ new LoadingManager();
+
+class Loader {
+
+	constructor( manager ) {
+
+		this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+
+		this.crossOrigin = 'anonymous';
+		this.withCredentials = false;
+		this.path = '';
+		this.resourcePath = '';
+		this.requestHeader = {};
+
+	}
+
+	load( /* url, onLoad, onProgress, onError */ ) {}
+
+	loadAsync( url, onProgress ) {
+
+		const scope = this;
+
+		return new Promise( function ( resolve, reject ) {
+
+			scope.load( url, resolve, onProgress, reject );
+
+		} );
+
+	}
+
+	parse( /* data */ ) {}
+
+	setCrossOrigin( crossOrigin ) {
+
+		this.crossOrigin = crossOrigin;
+		return this;
+
+	}
+
+	setWithCredentials( value ) {
+
+		this.withCredentials = value;
+		return this;
+
+	}
+
+	setPath( path ) {
+
+		this.path = path;
+		return this;
+
+	}
+
+	setResourcePath( resourcePath ) {
+
+		this.resourcePath = resourcePath;
+		return this;
+
+	}
+
+	setRequestHeader( requestHeader ) {
+
+		this.requestHeader = requestHeader;
+		return this;
+
+	}
+
+}
+
+Loader.DEFAULT_MATERIAL_NAME = '__DEFAULT';
+
+const loading = {};
+
+class HttpError extends Error {
+
+	constructor( message, response ) {
+
+		super( message );
+		this.response = response;
+
+	}
+
+}
+
+class FileLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		if ( url === undefined ) url = '';
+
+		if ( this.path !== undefined ) url = this.path + url;
+
+		url = this.manager.resolveURL( url );
+
+		const cached = Cache.get( url );
+
+		if ( cached !== undefined ) {
+
+			this.manager.itemStart( url );
+
+			setTimeout( () => {
+
+				if ( onLoad ) onLoad( cached );
+
+				this.manager.itemEnd( url );
+
+			}, 0 );
+
+			return cached;
+
+		}
+
+		// Check if request is duplicate
+
+		if ( loading[ url ] !== undefined ) {
+
+			loading[ url ].push( {
+
+				onLoad: onLoad,
+				onProgress: onProgress,
+				onError: onError
+
+			} );
+
+			return;
+
+		}
+
+		// Initialise array for duplicate requests
+		loading[ url ] = [];
+
+		loading[ url ].push( {
+			onLoad: onLoad,
+			onProgress: onProgress,
+			onError: onError,
+		} );
+
+		// create request
+		const req = new Request( url, {
+			headers: new Headers( this.requestHeader ),
+			credentials: this.withCredentials ? 'include' : 'same-origin',
+			// An abort controller could be added within a future PR
+		} );
+
+		// record states ( avoid data race )
+		const mimeType = this.mimeType;
+		const responseType = this.responseType;
+
+		// start the fetch
+		fetch( req )
+			.then( response => {
+
+				if ( response.status === 200 || response.status === 0 ) {
+
+					// Some browsers return HTTP Status 0 when using non-http protocol
+					// e.g. 'file://' or 'data://'. Handle as success.
+
+					if ( response.status === 0 ) {
+
+						console.warn( 'THREE.FileLoader: HTTP Status 0 received.' );
+
+					}
+
+					// Workaround: Checking if response.body === undefined for Alipay browser #23548
+
+					if ( typeof ReadableStream === 'undefined' || response.body === undefined || response.body.getReader === undefined ) {
+
+						return response;
+
+					}
+
+					const callbacks = loading[ url ];
+					const reader = response.body.getReader();
+
+					// Nginx needs X-File-Size check
+					// https://serverfault.com/questions/482875/why-does-nginx-remove-content-length-header-for-chunked-content
+					const contentLength = response.headers.get( 'Content-Length' ) || response.headers.get( 'X-File-Size' );
+					const total = contentLength ? parseInt( contentLength ) : 0;
+					const lengthComputable = total !== 0;
+					let loaded = 0;
+
+					// periodically read data into the new stream tracking while download progress
+					const stream = new ReadableStream( {
+						start( controller ) {
+
+							readData();
+
+							function readData() {
+
+								reader.read().then( ( { done, value } ) => {
+
+									if ( done ) {
+
+										controller.close();
+
+									} else {
+
+										loaded += value.byteLength;
+
+										const event = new ProgressEvent( 'progress', { lengthComputable, loaded, total } );
+										for ( let i = 0, il = callbacks.length; i < il; i ++ ) {
+
+											const callback = callbacks[ i ];
+											if ( callback.onProgress ) callback.onProgress( event );
+
+										}
+
+										controller.enqueue( value );
+										readData();
+
+									}
+
+								} );
+
+							}
+
+						}
+
+					} );
+
+					return new Response( stream );
+
+				} else {
+
+					throw new HttpError( `fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`, response );
+
+				}
+
+			} )
+			.then( response => {
+
+				switch ( responseType ) {
+
+					case 'arraybuffer':
+
+						return response.arrayBuffer();
+
+					case 'blob':
+
+						return response.blob();
+
+					case 'document':
+
+						return response.text()
+							.then( text => {
+
+								const parser = new DOMParser();
+								return parser.parseFromString( text, mimeType );
+
+							} );
+
+					case 'json':
+
+						return response.json();
+
+					default:
+
+						if ( mimeType === undefined ) {
+
+							return response.text();
+
+						} else {
+
+							// sniff encoding
+							const re = /charset="?([^;"\s]*)"?/i;
+							const exec = re.exec( mimeType );
+							const label = exec && exec[ 1 ] ? exec[ 1 ].toLowerCase() : undefined;
+							const decoder = new TextDecoder( label );
+							return response.arrayBuffer().then( ab => decoder.decode( ab ) );
+
+						}
+
+				}
+
+			} )
+			.then( data => {
+
+				// Add to cache only on HTTP success, so that we do not cache
+				// error response bodies as proper responses to requests.
+				Cache.add( url, data );
+
+				const callbacks = loading[ url ];
+				delete loading[ url ];
+
+				for ( let i = 0, il = callbacks.length; i < il; i ++ ) {
+
+					const callback = callbacks[ i ];
+					if ( callback.onLoad ) callback.onLoad( data );
+
+				}
+
+			} )
+			.catch( err => {
+
+				// Abort errors and other errors are handled the same
+
+				const callbacks = loading[ url ];
+
+				if ( callbacks === undefined ) {
+
+					// When onLoad was called and url was deleted in `loading`
+					this.manager.itemError( url );
+					throw err;
+
+				}
+
+				delete loading[ url ];
+
+				for ( let i = 0, il = callbacks.length; i < il; i ++ ) {
+
+					const callback = callbacks[ i ];
+					if ( callback.onError ) callback.onError( err );
+
+				}
+
+				this.manager.itemError( url );
+
+			} )
+			.finally( () => {
+
+				this.manager.itemEnd( url );
+
+			} );
+
+		this.manager.itemStart( url );
+
+	}
+
+	setResponseType( value ) {
+
+		this.responseType = value;
+		return this;
+
+	}
+
+	setMimeType( value ) {
+
+		this.mimeType = value;
+		return this;
+
+	}
+
+}
+
+class AnimationLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const loader = new FileLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+		loader.load( url, function ( text ) {
+
+			try {
+
+				onLoad( scope.parse( JSON.parse( text ) ) );
+
+			} catch ( e ) {
+
+				if ( onError ) {
+
+					onError( e );
+
+				} else {
+
+					console.error( e );
+
+				}
+
+				scope.manager.itemError( url );
+
+			}
+
+		}, onProgress, onError );
+
+	}
+
+	parse( json ) {
+
+		const animations = [];
+
+		for ( let i = 0; i < json.length; i ++ ) {
+
+			const clip = AnimationClip.parse( json[ i ] );
+
+			animations.push( clip );
+
+		}
+
+		return animations;
+
+	}
+
+}
+
+/**
+ * Abstract Base class to block based textures loader (dds, pvr, ...)
+ *
+ * Sub classes have to implement the parse() method which will be used in load().
+ */
+
+class CompressedTextureLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const images = [];
+
+		const texture = new CompressedTexture();
+
+		const loader = new FileLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( scope.withCredentials );
+
+		let loaded = 0;
+
+		function loadTexture( i ) {
+
+			loader.load( url[ i ], function ( buffer ) {
+
+				const texDatas = scope.parse( buffer, true );
+
+				images[ i ] = {
+					width: texDatas.width,
+					height: texDatas.height,
+					format: texDatas.format,
+					mipmaps: texDatas.mipmaps
+				};
+
+				loaded += 1;
+
+				if ( loaded === 6 ) {
+
+					if ( texDatas.mipmapCount === 1 ) texture.minFilter = LinearFilter;
+
+					texture.image = images;
+					texture.format = texDatas.format;
+					texture.needsUpdate = true;
+
+					if ( onLoad ) onLoad( texture );
+
+				}
+
+			}, onProgress, onError );
+
+		}
+
+		if ( Array.isArray( url ) ) {
+
+			for ( let i = 0, il = url.length; i < il; ++ i ) {
+
+				loadTexture( i );
+
+			}
+
+		} else {
+
+			// compressed cubemap texture stored in a single DDS file
+
+			loader.load( url, function ( buffer ) {
+
+				const texDatas = scope.parse( buffer, true );
+
+				if ( texDatas.isCubemap ) {
+
+					const faces = texDatas.mipmaps.length / texDatas.mipmapCount;
+
+					for ( let f = 0; f < faces; f ++ ) {
+
+						images[ f ] = { mipmaps: [] };
+
+						for ( let i = 0; i < texDatas.mipmapCount; i ++ ) {
+
+							images[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );
+							images[ f ].format = texDatas.format;
+							images[ f ].width = texDatas.width;
+							images[ f ].height = texDatas.height;
+
+						}
+
+					}
+
+					texture.image = images;
+
+				} else {
+
+					texture.image.width = texDatas.width;
+					texture.image.height = texDatas.height;
+					texture.mipmaps = texDatas.mipmaps;
+
+				}
+
+				if ( texDatas.mipmapCount === 1 ) {
+
+					texture.minFilter = LinearFilter;
+
+				}
+
+				texture.format = texDatas.format;
+				texture.needsUpdate = true;
+
+				if ( onLoad ) onLoad( texture );
+
+			}, onProgress, onError );
+
+		}
+
+		return texture;
+
+	}
+
+}
+
+class ImageLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		if ( this.path !== undefined ) url = this.path + url;
+
+		url = this.manager.resolveURL( url );
+
+		const scope = this;
+
+		const cached = Cache.get( url );
+
+		if ( cached !== undefined ) {
+
+			scope.manager.itemStart( url );
+
+			setTimeout( function () {
+
+				if ( onLoad ) onLoad( cached );
+
+				scope.manager.itemEnd( url );
+
+			}, 0 );
+
+			return cached;
+
+		}
+
+		const image = createElementNS( 'img' );
+
+		function onImageLoad() {
+
+			removeEventListeners();
+
+			Cache.add( url, this );
+
+			if ( onLoad ) onLoad( this );
+
+			scope.manager.itemEnd( url );
+
+		}
+
+		function onImageError( event ) {
+
+			removeEventListeners();
+
+			if ( onError ) onError( event );
+
+			scope.manager.itemError( url );
+			scope.manager.itemEnd( url );
+
+		}
+
+		function removeEventListeners() {
+
+			image.removeEventListener( 'load', onImageLoad, false );
+			image.removeEventListener( 'error', onImageError, false );
+
+		}
+
+		image.addEventListener( 'load', onImageLoad, false );
+		image.addEventListener( 'error', onImageError, false );
+
+		if ( url.slice( 0, 5 ) !== 'data:' ) {
+
+			if ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;
+
+		}
+
+		scope.manager.itemStart( url );
+
+		image.src = url;
+
+		return image;
+
+	}
+
+}
+
+class CubeTextureLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( urls, onLoad, onProgress, onError ) {
+
+		const texture = new CubeTexture();
+		texture.colorSpace = SRGBColorSpace;
+
+		const loader = new ImageLoader( this.manager );
+		loader.setCrossOrigin( this.crossOrigin );
+		loader.setPath( this.path );
+
+		let loaded = 0;
+
+		function loadTexture( i ) {
+
+			loader.load( urls[ i ], function ( image ) {
+
+				texture.images[ i ] = image;
+
+				loaded ++;
+
+				if ( loaded === 6 ) {
+
+					texture.needsUpdate = true;
+
+					if ( onLoad ) onLoad( texture );
+
+				}
+
+			}, undefined, onError );
+
+		}
+
+		for ( let i = 0; i < urls.length; ++ i ) {
+
+			loadTexture( i );
+
+		}
+
+		return texture;
+
+	}
+
+}
+
+/**
+ * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
+ *
+ * Sub classes have to implement the parse() method which will be used in load().
+ */
+
+class DataTextureLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const texture = new DataTexture();
+
+		const loader = new FileLoader( this.manager );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setPath( this.path );
+		loader.setWithCredentials( scope.withCredentials );
+		loader.load( url, function ( buffer ) {
+
+			let texData;
+
+			try {
+
+				texData = scope.parse( buffer );
+
+			} catch ( error ) {
+
+				if ( onError !== undefined ) {
+
+					onError( error );
+
+				} else {
+
+					console.error( error );
+					return;
+
+				}
+
+			}
+
+			if ( texData.image !== undefined ) {
+
+				texture.image = texData.image;
+
+			} else if ( texData.data !== undefined ) {
+
+				texture.image.width = texData.width;
+				texture.image.height = texData.height;
+				texture.image.data = texData.data;
+
+			}
+
+			texture.wrapS = texData.wrapS !== undefined ? texData.wrapS : ClampToEdgeWrapping;
+			texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : ClampToEdgeWrapping;
+
+			texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : LinearFilter;
+			texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : LinearFilter;
+
+			texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;
+
+			if ( texData.colorSpace !== undefined ) {
+
+				texture.colorSpace = texData.colorSpace;
+
+			} else if ( texData.encoding !== undefined ) { // @deprecated, r152
+
+				texture.encoding = texData.encoding;
+
+			}
+
+			if ( texData.flipY !== undefined ) {
+
+				texture.flipY = texData.flipY;
+
+			}
+
+			if ( texData.format !== undefined ) {
+
+				texture.format = texData.format;
+
+			}
+
+			if ( texData.type !== undefined ) {
+
+				texture.type = texData.type;
+
+			}
+
+			if ( texData.mipmaps !== undefined ) {
+
+				texture.mipmaps = texData.mipmaps;
+				texture.minFilter = LinearMipmapLinearFilter; // presumably...
+
+			}
+
+			if ( texData.mipmapCount === 1 ) {
+
+				texture.minFilter = LinearFilter;
+
+			}
+
+			if ( texData.generateMipmaps !== undefined ) {
+
+				texture.generateMipmaps = texData.generateMipmaps;
+
+			}
+
+			texture.needsUpdate = true;
+
+			if ( onLoad ) onLoad( texture, texData );
+
+		}, onProgress, onError );
+
+
+		return texture;
+
+	}
+
+}
+
+class TextureLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const texture = new Texture();
+
+		const loader = new ImageLoader( this.manager );
+		loader.setCrossOrigin( this.crossOrigin );
+		loader.setPath( this.path );
+
+		loader.load( url, function ( image ) {
+
+			texture.image = image;
+			texture.needsUpdate = true;
+
+			if ( onLoad !== undefined ) {
+
+				onLoad( texture );
+
+			}
+
+		}, onProgress, onError );
+
+		return texture;
+
+	}
+
+}
+
+class Light extends Object3D {
+
+	constructor( color, intensity = 1 ) {
+
+		super();
+
+		this.isLight = true;
+
+		this.type = 'Light';
+
+		this.color = new Color( color );
+		this.intensity = intensity;
+
+	}
+
+	dispose() {
+
+		// Empty here in base class; some subclasses override.
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.color.copy( source.color );
+		this.intensity = source.intensity;
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		data.object.color = this.color.getHex();
+		data.object.intensity = this.intensity;
+
+		if ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();
+
+		if ( this.distance !== undefined ) data.object.distance = this.distance;
+		if ( this.angle !== undefined ) data.object.angle = this.angle;
+		if ( this.decay !== undefined ) data.object.decay = this.decay;
+		if ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;
+
+		if ( this.shadow !== undefined ) data.object.shadow = this.shadow.toJSON();
+
+		return data;
+
+	}
+
+}
+
+class HemisphereLight extends Light {
+
+	constructor( skyColor, groundColor, intensity ) {
+
+		super( skyColor, intensity );
+
+		this.isHemisphereLight = true;
+
+		this.type = 'HemisphereLight';
+
+		this.position.copy( Object3D.DEFAULT_UP );
+		this.updateMatrix();
+
+		this.groundColor = new Color( groundColor );
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.groundColor.copy( source.groundColor );
+
+		return this;
+
+	}
+
+}
+
+const _projScreenMatrix$1 = /*@__PURE__*/ new Matrix4();
+const _lightPositionWorld$1 = /*@__PURE__*/ new Vector3();
+const _lookTarget$1 = /*@__PURE__*/ new Vector3();
+
+class LightShadow {
+
+	constructor( camera ) {
+
+		this.camera = camera;
+
+		this.bias = 0;
+		this.normalBias = 0;
+		this.radius = 1;
+		this.blurSamples = 8;
+
+		this.mapSize = new Vector2( 512, 512 );
+
+		this.map = null;
+		this.mapPass = null;
+		this.matrix = new Matrix4();
+
+		this.autoUpdate = true;
+		this.needsUpdate = false;
+
+		this._frustum = new Frustum();
+		this._frameExtents = new Vector2( 1, 1 );
+
+		this._viewportCount = 1;
+
+		this._viewports = [
+
+			new Vector4( 0, 0, 1, 1 )
+
+		];
+
+	}
+
+	getViewportCount() {
+
+		return this._viewportCount;
+
+	}
+
+	getFrustum() {
+
+		return this._frustum;
+
+	}
+
+	updateMatrices( light ) {
+
+		const shadowCamera = this.camera;
+		const shadowMatrix = this.matrix;
+
+		_lightPositionWorld$1.setFromMatrixPosition( light.matrixWorld );
+		shadowCamera.position.copy( _lightPositionWorld$1 );
+
+		_lookTarget$1.setFromMatrixPosition( light.target.matrixWorld );
+		shadowCamera.lookAt( _lookTarget$1 );
+		shadowCamera.updateMatrixWorld();
+
+		_projScreenMatrix$1.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );
+		this._frustum.setFromProjectionMatrix( _projScreenMatrix$1 );
+
+		shadowMatrix.set(
+			0.5, 0.0, 0.0, 0.5,
+			0.0, 0.5, 0.0, 0.5,
+			0.0, 0.0, 0.5, 0.5,
+			0.0, 0.0, 0.0, 1.0
+		);
+
+		shadowMatrix.multiply( _projScreenMatrix$1 );
+
+	}
+
+	getViewport( viewportIndex ) {
+
+		return this._viewports[ viewportIndex ];
+
+	}
+
+	getFrameExtents() {
+
+		return this._frameExtents;
+
+	}
+
+	dispose() {
+
+		if ( this.map ) {
+
+			this.map.dispose();
+
+		}
+
+		if ( this.mapPass ) {
+
+			this.mapPass.dispose();
+
+		}
+
+	}
+
+	copy( source ) {
+
+		this.camera = source.camera.clone();
+
+		this.bias = source.bias;
+		this.radius = source.radius;
+
+		this.mapSize.copy( source.mapSize );
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	toJSON() {
+
+		const object = {};
+
+		if ( this.bias !== 0 ) object.bias = this.bias;
+		if ( this.normalBias !== 0 ) object.normalBias = this.normalBias;
+		if ( this.radius !== 1 ) object.radius = this.radius;
+		if ( this.mapSize.x !== 512 || this.mapSize.y !== 512 ) object.mapSize = this.mapSize.toArray();
+
+		object.camera = this.camera.toJSON( false ).object;
+		delete object.camera.matrix;
+
+		return object;
+
+	}
+
+}
+
+class SpotLightShadow extends LightShadow {
+
+	constructor() {
+
+		super( new PerspectiveCamera( 50, 1, 0.5, 500 ) );
+
+		this.isSpotLightShadow = true;
+
+		this.focus = 1;
+
+	}
+
+	updateMatrices( light ) {
+
+		const camera = this.camera;
+
+		const fov = RAD2DEG * 2 * light.angle * this.focus;
+		const aspect = this.mapSize.width / this.mapSize.height;
+		const far = light.distance || camera.far;
+
+		if ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {
+
+			camera.fov = fov;
+			camera.aspect = aspect;
+			camera.far = far;
+			camera.updateProjectionMatrix();
+
+		}
+
+		super.updateMatrices( light );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.focus = source.focus;
+
+		return this;
+
+	}
+
+}
+
+class SpotLight extends Light {
+
+	constructor( color, intensity, distance = 0, angle = Math.PI / 3, penumbra = 0, decay = 2 ) {
+
+		super( color, intensity );
+
+		this.isSpotLight = true;
+
+		this.type = 'SpotLight';
+
+		this.position.copy( Object3D.DEFAULT_UP );
+		this.updateMatrix();
+
+		this.target = new Object3D();
+
+		this.distance = distance;
+		this.angle = angle;
+		this.penumbra = penumbra;
+		this.decay = decay;
+
+		this.map = null;
+
+		this.shadow = new SpotLightShadow();
+
+	}
+
+	get power() {
+
+		// compute the light's luminous power (in lumens) from its intensity (in candela)
+		// by convention for a spotlight, luminous power (lm) = π * luminous intensity (cd)
+		return this.intensity * Math.PI;
+
+	}
+
+	set power( power ) {
+
+		// set the light's intensity (in candela) from the desired luminous power (in lumens)
+		this.intensity = power / Math.PI;
+
+	}
+
+	dispose() {
+
+		this.shadow.dispose();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.distance = source.distance;
+		this.angle = source.angle;
+		this.penumbra = source.penumbra;
+		this.decay = source.decay;
+
+		this.target = source.target.clone();
+
+		this.shadow = source.shadow.clone();
+
+		return this;
+
+	}
+
+}
+
+const _projScreenMatrix = /*@__PURE__*/ new Matrix4();
+const _lightPositionWorld = /*@__PURE__*/ new Vector3();
+const _lookTarget = /*@__PURE__*/ new Vector3();
+
+class PointLightShadow extends LightShadow {
+
+	constructor() {
+
+		super( new PerspectiveCamera( 90, 1, 0.5, 500 ) );
+
+		this.isPointLightShadow = true;
+
+		this._frameExtents = new Vector2( 4, 2 );
+
+		this._viewportCount = 6;
+
+		this._viewports = [
+			// These viewports map a cube-map onto a 2D texture with the
+			// following orientation:
+			//
+			//  xzXZ
+			//   y Y
+			//
+			// X - Positive x direction
+			// x - Negative x direction
+			// Y - Positive y direction
+			// y - Negative y direction
+			// Z - Positive z direction
+			// z - Negative z direction
+
+			// positive X
+			new Vector4( 2, 1, 1, 1 ),
+			// negative X
+			new Vector4( 0, 1, 1, 1 ),
+			// positive Z
+			new Vector4( 3, 1, 1, 1 ),
+			// negative Z
+			new Vector4( 1, 1, 1, 1 ),
+			// positive Y
+			new Vector4( 3, 0, 1, 1 ),
+			// negative Y
+			new Vector4( 1, 0, 1, 1 )
+		];
+
+		this._cubeDirections = [
+			new Vector3( 1, 0, 0 ), new Vector3( - 1, 0, 0 ), new Vector3( 0, 0, 1 ),
+			new Vector3( 0, 0, - 1 ), new Vector3( 0, 1, 0 ), new Vector3( 0, - 1, 0 )
+		];
+
+		this._cubeUps = [
+			new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ),
+			new Vector3( 0, 1, 0 ), new Vector3( 0, 0, 1 ),	new Vector3( 0, 0, - 1 )
+		];
+
+	}
+
+	updateMatrices( light, viewportIndex = 0 ) {
+
+		const camera = this.camera;
+		const shadowMatrix = this.matrix;
+
+		const far = light.distance || camera.far;
+
+		if ( far !== camera.far ) {
+
+			camera.far = far;
+			camera.updateProjectionMatrix();
+
+		}
+
+		_lightPositionWorld.setFromMatrixPosition( light.matrixWorld );
+		camera.position.copy( _lightPositionWorld );
+
+		_lookTarget.copy( camera.position );
+		_lookTarget.add( this._cubeDirections[ viewportIndex ] );
+		camera.up.copy( this._cubeUps[ viewportIndex ] );
+		camera.lookAt( _lookTarget );
+		camera.updateMatrixWorld();
+
+		shadowMatrix.makeTranslation( - _lightPositionWorld.x, - _lightPositionWorld.y, - _lightPositionWorld.z );
+
+		_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
+		this._frustum.setFromProjectionMatrix( _projScreenMatrix );
+
+	}
+
+}
+
+class PointLight extends Light {
+
+	constructor( color, intensity, distance = 0, decay = 2 ) {
+
+		super( color, intensity );
+
+		this.isPointLight = true;
+
+		this.type = 'PointLight';
+
+		this.distance = distance;
+		this.decay = decay;
+
+		this.shadow = new PointLightShadow();
+
+	}
+
+	get power() {
+
+		// compute the light's luminous power (in lumens) from its intensity (in candela)
+		// for an isotropic light source, luminous power (lm) = 4 π luminous intensity (cd)
+		return this.intensity * 4 * Math.PI;
+
+	}
+
+	set power( power ) {
+
+		// set the light's intensity (in candela) from the desired luminous power (in lumens)
+		this.intensity = power / ( 4 * Math.PI );
+
+	}
+
+	dispose() {
+
+		this.shadow.dispose();
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.distance = source.distance;
+		this.decay = source.decay;
+
+		this.shadow = source.shadow.clone();
+
+		return this;
+
+	}
+
+}
+
+class DirectionalLightShadow extends LightShadow {
+
+	constructor() {
+
+		super( new OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );
+
+		this.isDirectionalLightShadow = true;
+
+	}
+
+}
+
+class DirectionalLight extends Light {
+
+	constructor( color, intensity ) {
+
+		super( color, intensity );
+
+		this.isDirectionalLight = true;
+
+		this.type = 'DirectionalLight';
+
+		this.position.copy( Object3D.DEFAULT_UP );
+		this.updateMatrix();
+
+		this.target = new Object3D();
+
+		this.shadow = new DirectionalLightShadow();
+
+	}
+
+	dispose() {
+
+		this.shadow.dispose();
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.target = source.target.clone();
+		this.shadow = source.shadow.clone();
+
+		return this;
+
+	}
+
+}
+
+class AmbientLight extends Light {
+
+	constructor( color, intensity ) {
+
+		super( color, intensity );
+
+		this.isAmbientLight = true;
+
+		this.type = 'AmbientLight';
+
+	}
+
+}
+
+class RectAreaLight extends Light {
+
+	constructor( color, intensity, width = 10, height = 10 ) {
+
+		super( color, intensity );
+
+		this.isRectAreaLight = true;
+
+		this.type = 'RectAreaLight';
+
+		this.width = width;
+		this.height = height;
+
+	}
+
+	get power() {
+
+		// compute the light's luminous power (in lumens) from its intensity (in nits)
+		return this.intensity * this.width * this.height * Math.PI;
+
+	}
+
+	set power( power ) {
+
+		// set the light's intensity (in nits) from the desired luminous power (in lumens)
+		this.intensity = power / ( this.width * this.height * Math.PI );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.width = source.width;
+		this.height = source.height;
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		data.object.width = this.width;
+		data.object.height = this.height;
+
+		return data;
+
+	}
+
+}
+
+/**
+ * Primary reference:
+ *   https://graphics.stanford.edu/papers/envmap/envmap.pdf
+ *
+ * Secondary reference:
+ *   https://www.ppsloan.org/publications/StupidSH36.pdf
+ */
+
+// 3-band SH defined by 9 coefficients
+
+class SphericalHarmonics3 {
+
+	constructor() {
+
+		this.isSphericalHarmonics3 = true;
+
+		this.coefficients = [];
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients.push( new Vector3() );
+
+		}
+
+	}
+
+	set( coefficients ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients[ i ].copy( coefficients[ i ] );
+
+		}
+
+		return this;
+
+	}
+
+	zero() {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients[ i ].set( 0, 0, 0 );
+
+		}
+
+		return this;
+
+	}
+
+	// get the radiance in the direction of the normal
+	// target is a Vector3
+	getAt( normal, target ) {
+
+		// normal is assumed to be unit length
+
+		const x = normal.x, y = normal.y, z = normal.z;
+
+		const coeff = this.coefficients;
+
+		// band 0
+		target.copy( coeff[ 0 ] ).multiplyScalar( 0.282095 );
+
+		// band 1
+		target.addScaledVector( coeff[ 1 ], 0.488603 * y );
+		target.addScaledVector( coeff[ 2 ], 0.488603 * z );
+		target.addScaledVector( coeff[ 3 ], 0.488603 * x );
+
+		// band 2
+		target.addScaledVector( coeff[ 4 ], 1.092548 * ( x * y ) );
+		target.addScaledVector( coeff[ 5 ], 1.092548 * ( y * z ) );
+		target.addScaledVector( coeff[ 6 ], 0.315392 * ( 3.0 * z * z - 1.0 ) );
+		target.addScaledVector( coeff[ 7 ], 1.092548 * ( x * z ) );
+		target.addScaledVector( coeff[ 8 ], 0.546274 * ( x * x - y * y ) );
+
+		return target;
+
+	}
+
+	// get the irradiance (radiance convolved with cosine lobe) in the direction of the normal
+	// target is a Vector3
+	// https://graphics.stanford.edu/papers/envmap/envmap.pdf
+	getIrradianceAt( normal, target ) {
+
+		// normal is assumed to be unit length
+
+		const x = normal.x, y = normal.y, z = normal.z;
+
+		const coeff = this.coefficients;
+
+		// band 0
+		target.copy( coeff[ 0 ] ).multiplyScalar( 0.886227 ); // π * 0.282095
+
+		// band 1
+		target.addScaledVector( coeff[ 1 ], 2.0 * 0.511664 * y ); // ( 2 * π / 3 ) * 0.488603
+		target.addScaledVector( coeff[ 2 ], 2.0 * 0.511664 * z );
+		target.addScaledVector( coeff[ 3 ], 2.0 * 0.511664 * x );
+
+		// band 2
+		target.addScaledVector( coeff[ 4 ], 2.0 * 0.429043 * x * y ); // ( π / 4 ) * 1.092548
+		target.addScaledVector( coeff[ 5 ], 2.0 * 0.429043 * y * z );
+		target.addScaledVector( coeff[ 6 ], 0.743125 * z * z - 0.247708 ); // ( π / 4 ) * 0.315392 * 3
+		target.addScaledVector( coeff[ 7 ], 2.0 * 0.429043 * x * z );
+		target.addScaledVector( coeff[ 8 ], 0.429043 * ( x * x - y * y ) ); // ( π / 4 ) * 0.546274
+
+		return target;
+
+	}
+
+	add( sh ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients[ i ].add( sh.coefficients[ i ] );
+
+		}
+
+		return this;
+
+	}
+
+	addScaledSH( sh, s ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients[ i ].addScaledVector( sh.coefficients[ i ], s );
+
+		}
+
+		return this;
+
+	}
+
+	scale( s ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients[ i ].multiplyScalar( s );
+
+		}
+
+		return this;
+
+	}
+
+	lerp( sh, alpha ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			this.coefficients[ i ].lerp( sh.coefficients[ i ], alpha );
+
+		}
+
+		return this;
+
+	}
+
+	equals( sh ) {
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			if ( ! this.coefficients[ i ].equals( sh.coefficients[ i ] ) ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	copy( sh ) {
+
+		return this.set( sh.coefficients );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		const coefficients = this.coefficients;
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			coefficients[ i ].fromArray( array, offset + ( i * 3 ) );
+
+		}
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		const coefficients = this.coefficients;
+
+		for ( let i = 0; i < 9; i ++ ) {
+
+			coefficients[ i ].toArray( array, offset + ( i * 3 ) );
+
+		}
+
+		return array;
+
+	}
+
+	// evaluate the basis functions
+	// shBasis is an Array[ 9 ]
+	static getBasisAt( normal, shBasis ) {
+
+		// normal is assumed to be unit length
+
+		const x = normal.x, y = normal.y, z = normal.z;
+
+		// band 0
+		shBasis[ 0 ] = 0.282095;
+
+		// band 1
+		shBasis[ 1 ] = 0.488603 * y;
+		shBasis[ 2 ] = 0.488603 * z;
+		shBasis[ 3 ] = 0.488603 * x;
+
+		// band 2
+		shBasis[ 4 ] = 1.092548 * x * y;
+		shBasis[ 5 ] = 1.092548 * y * z;
+		shBasis[ 6 ] = 0.315392 * ( 3 * z * z - 1 );
+		shBasis[ 7 ] = 1.092548 * x * z;
+		shBasis[ 8 ] = 0.546274 * ( x * x - y * y );
+
+	}
+
+}
+
+class LightProbe extends Light {
+
+	constructor( sh = new SphericalHarmonics3(), intensity = 1 ) {
+
+		super( undefined, intensity );
+
+		this.isLightProbe = true;
+
+		this.sh = sh;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.sh.copy( source.sh );
+
+		return this;
+
+	}
+
+	fromJSON( json ) {
+
+		this.intensity = json.intensity; // TODO: Move this bit to Light.fromJSON();
+		this.sh.fromArray( json.sh );
+
+		return this;
+
+	}
+
+	toJSON( meta ) {
+
+		const data = super.toJSON( meta );
+
+		data.object.sh = this.sh.toArray();
+
+		return data;
+
+	}
+
+}
+
+class MaterialLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+		this.textures = {};
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setRequestHeader( scope.requestHeader );
+		loader.setWithCredentials( scope.withCredentials );
+		loader.load( url, function ( text ) {
+
+			try {
+
+				onLoad( scope.parse( JSON.parse( text ) ) );
+
+			} catch ( e ) {
+
+				if ( onError ) {
+
+					onError( e );
+
+				} else {
+
+					console.error( e );
+
+				}
+
+				scope.manager.itemError( url );
+
+			}
+
+		}, onProgress, onError );
+
+	}
+
+	parse( json ) {
+
+		const textures = this.textures;
+
+		function getTexture( name ) {
+
+			if ( textures[ name ] === undefined ) {
+
+				console.warn( 'THREE.MaterialLoader: Undefined texture', name );
+
+			}
+
+			return textures[ name ];
+
+		}
+
+		const material = MaterialLoader.createMaterialFromType( json.type );
+
+		if ( json.uuid !== undefined ) material.uuid = json.uuid;
+		if ( json.name !== undefined ) material.name = json.name;
+		if ( json.color !== undefined && material.color !== undefined ) material.color.setHex( json.color );
+		if ( json.roughness !== undefined ) material.roughness = json.roughness;
+		if ( json.metalness !== undefined ) material.metalness = json.metalness;
+		if ( json.sheen !== undefined ) material.sheen = json.sheen;
+		if ( json.sheenColor !== undefined ) material.sheenColor = new Color().setHex( json.sheenColor );
+		if ( json.sheenRoughness !== undefined ) material.sheenRoughness = json.sheenRoughness;
+		if ( json.emissive !== undefined && material.emissive !== undefined ) material.emissive.setHex( json.emissive );
+		if ( json.specular !== undefined && material.specular !== undefined ) material.specular.setHex( json.specular );
+		if ( json.specularIntensity !== undefined ) material.specularIntensity = json.specularIntensity;
+		if ( json.specularColor !== undefined && material.specularColor !== undefined ) material.specularColor.setHex( json.specularColor );
+		if ( json.shininess !== undefined ) material.shininess = json.shininess;
+		if ( json.clearcoat !== undefined ) material.clearcoat = json.clearcoat;
+		if ( json.clearcoatRoughness !== undefined ) material.clearcoatRoughness = json.clearcoatRoughness;
+		if ( json.iridescence !== undefined ) material.iridescence = json.iridescence;
+		if ( json.iridescenceIOR !== undefined ) material.iridescenceIOR = json.iridescenceIOR;
+		if ( json.iridescenceThicknessRange !== undefined ) material.iridescenceThicknessRange = json.iridescenceThicknessRange;
+		if ( json.transmission !== undefined ) material.transmission = json.transmission;
+		if ( json.thickness !== undefined ) material.thickness = json.thickness;
+		if ( json.attenuationDistance !== undefined ) material.attenuationDistance = json.attenuationDistance;
+		if ( json.attenuationColor !== undefined && material.attenuationColor !== undefined ) material.attenuationColor.setHex( json.attenuationColor );
+		if ( json.anisotropy !== undefined ) material.anisotropy = json.anisotropy;
+		if ( json.anisotropyRotation !== undefined ) material.anisotropyRotation = json.anisotropyRotation;
+		if ( json.fog !== undefined ) material.fog = json.fog;
+		if ( json.flatShading !== undefined ) material.flatShading = json.flatShading;
+		if ( json.blending !== undefined ) material.blending = json.blending;
+		if ( json.combine !== undefined ) material.combine = json.combine;
+		if ( json.side !== undefined ) material.side = json.side;
+		if ( json.shadowSide !== undefined ) material.shadowSide = json.shadowSide;
+		if ( json.opacity !== undefined ) material.opacity = json.opacity;
+		if ( json.transparent !== undefined ) material.transparent = json.transparent;
+		if ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;
+		if ( json.alphaHash !== undefined ) material.alphaHash = json.alphaHash;
+		if ( json.depthFunc !== undefined ) material.depthFunc = json.depthFunc;
+		if ( json.depthTest !== undefined ) material.depthTest = json.depthTest;
+		if ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;
+		if ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;
+		if ( json.blendSrc !== undefined ) material.blendSrc = json.blendSrc;
+		if ( json.blendDst !== undefined ) material.blendDst = json.blendDst;
+		if ( json.blendEquation !== undefined ) material.blendEquation = json.blendEquation;
+		if ( json.blendSrcAlpha !== undefined ) material.blendSrcAlpha = json.blendSrcAlpha;
+		if ( json.blendDstAlpha !== undefined ) material.blendDstAlpha = json.blendDstAlpha;
+		if ( json.blendEquationAlpha !== undefined ) material.blendEquationAlpha = json.blendEquationAlpha;
+		if ( json.blendColor !== undefined && material.blendColor !== undefined ) material.blendColor.setHex( json.blendColor );
+		if ( json.blendAlpha !== undefined ) material.blendAlpha = json.blendAlpha;
+		if ( json.stencilWriteMask !== undefined ) material.stencilWriteMask = json.stencilWriteMask;
+		if ( json.stencilFunc !== undefined ) material.stencilFunc = json.stencilFunc;
+		if ( json.stencilRef !== undefined ) material.stencilRef = json.stencilRef;
+		if ( json.stencilFuncMask !== undefined ) material.stencilFuncMask = json.stencilFuncMask;
+		if ( json.stencilFail !== undefined ) material.stencilFail = json.stencilFail;
+		if ( json.stencilZFail !== undefined ) material.stencilZFail = json.stencilZFail;
+		if ( json.stencilZPass !== undefined ) material.stencilZPass = json.stencilZPass;
+		if ( json.stencilWrite !== undefined ) material.stencilWrite = json.stencilWrite;
+
+		if ( json.wireframe !== undefined ) material.wireframe = json.wireframe;
+		if ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;
+		if ( json.wireframeLinecap !== undefined ) material.wireframeLinecap = json.wireframeLinecap;
+		if ( json.wireframeLinejoin !== undefined ) material.wireframeLinejoin = json.wireframeLinejoin;
+
+		if ( json.rotation !== undefined ) material.rotation = json.rotation;
+
+		if ( json.linewidth !== undefined ) material.linewidth = json.linewidth;
+		if ( json.dashSize !== undefined ) material.dashSize = json.dashSize;
+		if ( json.gapSize !== undefined ) material.gapSize = json.gapSize;
+		if ( json.scale !== undefined ) material.scale = json.scale;
+
+		if ( json.polygonOffset !== undefined ) material.polygonOffset = json.polygonOffset;
+		if ( json.polygonOffsetFactor !== undefined ) material.polygonOffsetFactor = json.polygonOffsetFactor;
+		if ( json.polygonOffsetUnits !== undefined ) material.polygonOffsetUnits = json.polygonOffsetUnits;
+
+		if ( json.dithering !== undefined ) material.dithering = json.dithering;
+
+		if ( json.alphaToCoverage !== undefined ) material.alphaToCoverage = json.alphaToCoverage;
+		if ( json.premultipliedAlpha !== undefined ) material.premultipliedAlpha = json.premultipliedAlpha;
+		if ( json.forceSinglePass !== undefined ) material.forceSinglePass = json.forceSinglePass;
+
+		if ( json.visible !== undefined ) material.visible = json.visible;
+
+		if ( json.toneMapped !== undefined ) material.toneMapped = json.toneMapped;
+
+		if ( json.userData !== undefined ) material.userData = json.userData;
+
+		if ( json.vertexColors !== undefined ) {
+
+			if ( typeof json.vertexColors === 'number' ) {
+
+				material.vertexColors = ( json.vertexColors > 0 ) ? true : false;
+
+			} else {
+
+				material.vertexColors = json.vertexColors;
+
+			}
+
+		}
+
+		// Shader Material
+
+		if ( json.uniforms !== undefined ) {
+
+			for ( const name in json.uniforms ) {
+
+				const uniform = json.uniforms[ name ];
+
+				material.uniforms[ name ] = {};
+
+				switch ( uniform.type ) {
+
+					case 't':
+						material.uniforms[ name ].value = getTexture( uniform.value );
+						break;
+
+					case 'c':
+						material.uniforms[ name ].value = new Color().setHex( uniform.value );
+						break;
+
+					case 'v2':
+						material.uniforms[ name ].value = new Vector2().fromArray( uniform.value );
+						break;
+
+					case 'v3':
+						material.uniforms[ name ].value = new Vector3().fromArray( uniform.value );
+						break;
+
+					case 'v4':
+						material.uniforms[ name ].value = new Vector4().fromArray( uniform.value );
+						break;
+
+					case 'm3':
+						material.uniforms[ name ].value = new Matrix3().fromArray( uniform.value );
+						break;
+
+					case 'm4':
+						material.uniforms[ name ].value = new Matrix4().fromArray( uniform.value );
+						break;
+
+					default:
+						material.uniforms[ name ].value = uniform.value;
+
+				}
+
+			}
+
+		}
+
+		if ( json.defines !== undefined ) material.defines = json.defines;
+		if ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;
+		if ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;
+		if ( json.glslVersion !== undefined ) material.glslVersion = json.glslVersion;
+
+		if ( json.extensions !== undefined ) {
+
+			for ( const key in json.extensions ) {
+
+				material.extensions[ key ] = json.extensions[ key ];
+
+			}
+
+		}
+
+		if ( json.lights !== undefined ) material.lights = json.lights;
+		if ( json.clipping !== undefined ) material.clipping = json.clipping;
+
+		// for PointsMaterial
+
+		if ( json.size !== undefined ) material.size = json.size;
+		if ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;
+
+		// maps
+
+		if ( json.map !== undefined ) material.map = getTexture( json.map );
+		if ( json.matcap !== undefined ) material.matcap = getTexture( json.matcap );
+
+		if ( json.alphaMap !== undefined ) material.alphaMap = getTexture( json.alphaMap );
+
+		if ( json.bumpMap !== undefined ) material.bumpMap = getTexture( json.bumpMap );
+		if ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;
+
+		if ( json.normalMap !== undefined ) material.normalMap = getTexture( json.normalMap );
+		if ( json.normalMapType !== undefined ) material.normalMapType = json.normalMapType;
+		if ( json.normalScale !== undefined ) {
+
+			let normalScale = json.normalScale;
+
+			if ( Array.isArray( normalScale ) === false ) {
+
+				// Blender exporter used to export a scalar. See #7459
+
+				normalScale = [ normalScale, normalScale ];
+
+			}
+
+			material.normalScale = new Vector2().fromArray( normalScale );
+
+		}
+
+		if ( json.displacementMap !== undefined ) material.displacementMap = getTexture( json.displacementMap );
+		if ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;
+		if ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;
+
+		if ( json.roughnessMap !== undefined ) material.roughnessMap = getTexture( json.roughnessMap );
+		if ( json.metalnessMap !== undefined ) material.metalnessMap = getTexture( json.metalnessMap );
+
+		if ( json.emissiveMap !== undefined ) material.emissiveMap = getTexture( json.emissiveMap );
+		if ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;
+
+		if ( json.specularMap !== undefined ) material.specularMap = getTexture( json.specularMap );
+		if ( json.specularIntensityMap !== undefined ) material.specularIntensityMap = getTexture( json.specularIntensityMap );
+		if ( json.specularColorMap !== undefined ) material.specularColorMap = getTexture( json.specularColorMap );
+
+		if ( json.envMap !== undefined ) material.envMap = getTexture( json.envMap );
+		if ( json.envMapIntensity !== undefined ) material.envMapIntensity = json.envMapIntensity;
+
+		if ( json.reflectivity !== undefined ) material.reflectivity = json.reflectivity;
+		if ( json.refractionRatio !== undefined ) material.refractionRatio = json.refractionRatio;
+
+		if ( json.lightMap !== undefined ) material.lightMap = getTexture( json.lightMap );
+		if ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;
+
+		if ( json.aoMap !== undefined ) material.aoMap = getTexture( json.aoMap );
+		if ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;
+
+		if ( json.gradientMap !== undefined ) material.gradientMap = getTexture( json.gradientMap );
+
+		if ( json.clearcoatMap !== undefined ) material.clearcoatMap = getTexture( json.clearcoatMap );
+		if ( json.clearcoatRoughnessMap !== undefined ) material.clearcoatRoughnessMap = getTexture( json.clearcoatRoughnessMap );
+		if ( json.clearcoatNormalMap !== undefined ) material.clearcoatNormalMap = getTexture( json.clearcoatNormalMap );
+		if ( json.clearcoatNormalScale !== undefined ) material.clearcoatNormalScale = new Vector2().fromArray( json.clearcoatNormalScale );
+
+		if ( json.iridescenceMap !== undefined ) material.iridescenceMap = getTexture( json.iridescenceMap );
+		if ( json.iridescenceThicknessMap !== undefined ) material.iridescenceThicknessMap = getTexture( json.iridescenceThicknessMap );
+
+		if ( json.transmissionMap !== undefined ) material.transmissionMap = getTexture( json.transmissionMap );
+		if ( json.thicknessMap !== undefined ) material.thicknessMap = getTexture( json.thicknessMap );
+
+		if ( json.anisotropyMap !== undefined ) material.anisotropyMap = getTexture( json.anisotropyMap );
+
+		if ( json.sheenColorMap !== undefined ) material.sheenColorMap = getTexture( json.sheenColorMap );
+		if ( json.sheenRoughnessMap !== undefined ) material.sheenRoughnessMap = getTexture( json.sheenRoughnessMap );
+
+		return material;
+
+	}
+
+	setTextures( value ) {
+
+		this.textures = value;
+		return this;
+
+	}
+
+	static createMaterialFromType( type ) {
+
+		const materialLib = {
+			ShadowMaterial,
+			SpriteMaterial,
+			RawShaderMaterial,
+			ShaderMaterial,
+			PointsMaterial,
+			MeshPhysicalMaterial,
+			MeshStandardMaterial,
+			MeshPhongMaterial,
+			MeshToonMaterial,
+			MeshNormalMaterial,
+			MeshLambertMaterial,
+			MeshDepthMaterial,
+			MeshDistanceMaterial,
+			MeshBasicMaterial,
+			MeshMatcapMaterial,
+			LineDashedMaterial,
+			LineBasicMaterial,
+			Material
+		};
+
+		return new materialLib[ type ]();
+
+	}
+
+}
+
+class LoaderUtils {
+
+	static decodeText( array ) {
+
+		if ( typeof TextDecoder !== 'undefined' ) {
+
+			return new TextDecoder().decode( array );
+
+		}
+
+		// Avoid the String.fromCharCode.apply(null, array) shortcut, which
+		// throws a "maximum call stack size exceeded" error for large arrays.
+
+		let s = '';
+
+		for ( let i = 0, il = array.length; i < il; i ++ ) {
+
+			// Implicitly assumes little-endian.
+			s += String.fromCharCode( array[ i ] );
+
+		}
+
+		try {
+
+			// merges multi-byte utf-8 characters.
+
+			return decodeURIComponent( escape( s ) );
+
+		} catch ( e ) { // see #16358
+
+			return s;
+
+		}
+
+	}
+
+	static extractUrlBase( url ) {
+
+		const index = url.lastIndexOf( '/' );
+
+		if ( index === - 1 ) return './';
+
+		return url.slice( 0, index + 1 );
+
+	}
+
+	static resolveURL( url, path ) {
+
+		// Invalid URL
+		if ( typeof url !== 'string' || url === '' ) return '';
+
+		// Host Relative URL
+		if ( /^https?:\/\//i.test( path ) && /^\//.test( url ) ) {
+
+			path = path.replace( /(^https?:\/\/[^\/]+).*/i, '$1' );
+
+		}
+
+		// Absolute URL http://,https://,//
+		if ( /^(https?:)?\/\//i.test( url ) ) return url;
+
+		// Data URI
+		if ( /^data:.*,.*$/i.test( url ) ) return url;
+
+		// Blob URL
+		if ( /^blob:.*$/i.test( url ) ) return url;
+
+		// Relative URL
+		return path + url;
+
+	}
+
+}
+
+class InstancedBufferGeometry extends BufferGeometry {
+
+	constructor() {
+
+		super();
+
+		this.isInstancedBufferGeometry = true;
+
+		this.type = 'InstancedBufferGeometry';
+		this.instanceCount = Infinity;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.instanceCount = source.instanceCount;
+
+		return this;
+
+	}
+
+	toJSON() {
+
+		const data = super.toJSON();
+
+		data.instanceCount = this.instanceCount;
+
+		data.isInstancedBufferGeometry = true;
+
+		return data;
+
+	}
+
+}
+
+class BufferGeometryLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setRequestHeader( scope.requestHeader );
+		loader.setWithCredentials( scope.withCredentials );
+		loader.load( url, function ( text ) {
+
+			try {
+
+				onLoad( scope.parse( JSON.parse( text ) ) );
+
+			} catch ( e ) {
+
+				if ( onError ) {
+
+					onError( e );
+
+				} else {
+
+					console.error( e );
+
+				}
+
+				scope.manager.itemError( url );
+
+			}
+
+		}, onProgress, onError );
+
+	}
+
+	parse( json ) {
+
+		const interleavedBufferMap = {};
+		const arrayBufferMap = {};
+
+		function getInterleavedBuffer( json, uuid ) {
+
+			if ( interleavedBufferMap[ uuid ] !== undefined ) return interleavedBufferMap[ uuid ];
+
+			const interleavedBuffers = json.interleavedBuffers;
+			const interleavedBuffer = interleavedBuffers[ uuid ];
+
+			const buffer = getArrayBuffer( json, interleavedBuffer.buffer );
+
+			const array = getTypedArray( interleavedBuffer.type, buffer );
+			const ib = new InterleavedBuffer( array, interleavedBuffer.stride );
+			ib.uuid = interleavedBuffer.uuid;
+
+			interleavedBufferMap[ uuid ] = ib;
+
+			return ib;
+
+		}
+
+		function getArrayBuffer( json, uuid ) {
+
+			if ( arrayBufferMap[ uuid ] !== undefined ) return arrayBufferMap[ uuid ];
+
+			const arrayBuffers = json.arrayBuffers;
+			const arrayBuffer = arrayBuffers[ uuid ];
+
+			const ab = new Uint32Array( arrayBuffer ).buffer;
+
+			arrayBufferMap[ uuid ] = ab;
+
+			return ab;
+
+		}
+
+		const geometry = json.isInstancedBufferGeometry ? new InstancedBufferGeometry() : new BufferGeometry();
+
+		const index = json.data.index;
+
+		if ( index !== undefined ) {
+
+			const typedArray = getTypedArray( index.type, index.array );
+			geometry.setIndex( new BufferAttribute( typedArray, 1 ) );
+
+		}
+
+		const attributes = json.data.attributes;
+
+		for ( const key in attributes ) {
+
+			const attribute = attributes[ key ];
+			let bufferAttribute;
+
+			if ( attribute.isInterleavedBufferAttribute ) {
+
+				const interleavedBuffer = getInterleavedBuffer( json.data, attribute.data );
+				bufferAttribute = new InterleavedBufferAttribute( interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized );
+
+			} else {
+
+				const typedArray = getTypedArray( attribute.type, attribute.array );
+				const bufferAttributeConstr = attribute.isInstancedBufferAttribute ? InstancedBufferAttribute : BufferAttribute;
+				bufferAttribute = new bufferAttributeConstr( typedArray, attribute.itemSize, attribute.normalized );
+
+			}
+
+			if ( attribute.name !== undefined ) bufferAttribute.name = attribute.name;
+			if ( attribute.usage !== undefined ) bufferAttribute.setUsage( attribute.usage );
+
+			geometry.setAttribute( key, bufferAttribute );
+
+		}
+
+		const morphAttributes = json.data.morphAttributes;
+
+		if ( morphAttributes ) {
+
+			for ( const key in morphAttributes ) {
+
+				const attributeArray = morphAttributes[ key ];
+
+				const array = [];
+
+				for ( let i = 0, il = attributeArray.length; i < il; i ++ ) {
+
+					const attribute = attributeArray[ i ];
+					let bufferAttribute;
+
+					if ( attribute.isInterleavedBufferAttribute ) {
+
+						const interleavedBuffer = getInterleavedBuffer( json.data, attribute.data );
+						bufferAttribute = new InterleavedBufferAttribute( interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized );
+
+					} else {
+
+						const typedArray = getTypedArray( attribute.type, attribute.array );
+						bufferAttribute = new BufferAttribute( typedArray, attribute.itemSize, attribute.normalized );
+
+					}
+
+					if ( attribute.name !== undefined ) bufferAttribute.name = attribute.name;
+					array.push( bufferAttribute );
+
+				}
+
+				geometry.morphAttributes[ key ] = array;
+
+			}
+
+		}
+
+		const morphTargetsRelative = json.data.morphTargetsRelative;
+
+		if ( morphTargetsRelative ) {
+
+			geometry.morphTargetsRelative = true;
+
+		}
+
+		const groups = json.data.groups || json.data.drawcalls || json.data.offsets;
+
+		if ( groups !== undefined ) {
+
+			for ( let i = 0, n = groups.length; i !== n; ++ i ) {
+
+				const group = groups[ i ];
+
+				geometry.addGroup( group.start, group.count, group.materialIndex );
+
+			}
+
+		}
+
+		const boundingSphere = json.data.boundingSphere;
+
+		if ( boundingSphere !== undefined ) {
+
+			const center = new Vector3();
+
+			if ( boundingSphere.center !== undefined ) {
+
+				center.fromArray( boundingSphere.center );
+
+			}
+
+			geometry.boundingSphere = new Sphere( center, boundingSphere.radius );
+
+		}
+
+		if ( json.name ) geometry.name = json.name;
+		if ( json.userData ) geometry.userData = json.userData;
+
+		return geometry;
+
+	}
+
+}
+
+class ObjectLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;
+		this.resourcePath = this.resourcePath || path;
+
+		const loader = new FileLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+		loader.load( url, function ( text ) {
+
+			let json = null;
+
+			try {
+
+				json = JSON.parse( text );
+
+			} catch ( error ) {
+
+				if ( onError !== undefined ) onError( error );
+
+				console.error( 'THREE:ObjectLoader: Can\'t parse ' + url + '.', error.message );
+
+				return;
+
+			}
+
+			const metadata = json.metadata;
+
+			if ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {
+
+				if ( onError !== undefined ) onError( new Error( 'THREE.ObjectLoader: Can\'t load ' + url ) );
+
+				console.error( 'THREE.ObjectLoader: Can\'t load ' + url );
+				return;
+
+			}
+
+			scope.parse( json, onLoad );
+
+		}, onProgress, onError );
+
+	}
+
+	async loadAsync( url, onProgress ) {
+
+		const scope = this;
+
+		const path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;
+		this.resourcePath = this.resourcePath || path;
+
+		const loader = new FileLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+
+		const text = await loader.loadAsync( url, onProgress );
+
+		const json = JSON.parse( text );
+
+		const metadata = json.metadata;
+
+		if ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {
+
+			throw new Error( 'THREE.ObjectLoader: Can\'t load ' + url );
+
+		}
+
+		return await scope.parseAsync( json );
+
+	}
+
+	parse( json, onLoad ) {
+
+		const animations = this.parseAnimations( json.animations );
+		const shapes = this.parseShapes( json.shapes );
+		const geometries = this.parseGeometries( json.geometries, shapes );
+
+		const images = this.parseImages( json.images, function () {
+
+			if ( onLoad !== undefined ) onLoad( object );
+
+		} );
+
+		const textures = this.parseTextures( json.textures, images );
+		const materials = this.parseMaterials( json.materials, textures );
+
+		const object = this.parseObject( json.object, geometries, materials, textures, animations );
+		const skeletons = this.parseSkeletons( json.skeletons, object );
+
+		this.bindSkeletons( object, skeletons );
+
+		//
+
+		if ( onLoad !== undefined ) {
+
+			let hasImages = false;
+
+			for ( const uuid in images ) {
+
+				if ( images[ uuid ].data instanceof HTMLImageElement ) {
+
+					hasImages = true;
+					break;
+
+				}
+
+			}
+
+			if ( hasImages === false ) onLoad( object );
+
+		}
+
+		return object;
+
+	}
+
+	async parseAsync( json ) {
+
+		const animations = this.parseAnimations( json.animations );
+		const shapes = this.parseShapes( json.shapes );
+		const geometries = this.parseGeometries( json.geometries, shapes );
+
+		const images = await this.parseImagesAsync( json.images );
+
+		const textures = this.parseTextures( json.textures, images );
+		const materials = this.parseMaterials( json.materials, textures );
+
+		const object = this.parseObject( json.object, geometries, materials, textures, animations );
+		const skeletons = this.parseSkeletons( json.skeletons, object );
+
+		this.bindSkeletons( object, skeletons );
+
+		return object;
+
+	}
+
+	parseShapes( json ) {
+
+		const shapes = {};
+
+		if ( json !== undefined ) {
+
+			for ( let i = 0, l = json.length; i < l; i ++ ) {
+
+				const shape = new Shape().fromJSON( json[ i ] );
+
+				shapes[ shape.uuid ] = shape;
+
+			}
+
+		}
+
+		return shapes;
+
+	}
+
+	parseSkeletons( json, object ) {
+
+		const skeletons = {};
+		const bones = {};
+
+		// generate bone lookup table
+
+		object.traverse( function ( child ) {
+
+			if ( child.isBone ) bones[ child.uuid ] = child;
+
+		} );
+
+		// create skeletons
+
+		if ( json !== undefined ) {
+
+			for ( let i = 0, l = json.length; i < l; i ++ ) {
+
+				const skeleton = new Skeleton().fromJSON( json[ i ], bones );
+
+				skeletons[ skeleton.uuid ] = skeleton;
+
+			}
+
+		}
+
+		return skeletons;
+
+	}
+
+	parseGeometries( json, shapes ) {
+
+		const geometries = {};
+
+		if ( json !== undefined ) {
+
+			const bufferGeometryLoader = new BufferGeometryLoader();
+
+			for ( let i = 0, l = json.length; i < l; i ++ ) {
+
+				let geometry;
+				const data = json[ i ];
+
+				switch ( data.type ) {
+
+					case 'BufferGeometry':
+					case 'InstancedBufferGeometry':
+
+						geometry = bufferGeometryLoader.parse( data );
+						break;
+
+					default:
+
+						if ( data.type in Geometries ) {
+
+							geometry = Geometries[ data.type ].fromJSON( data, shapes );
+
+						} else {
+
+							console.warn( `THREE.ObjectLoader: Unsupported geometry type "${ data.type }"` );
+
+						}
+
+				}
+
+				geometry.uuid = data.uuid;
+
+				if ( data.name !== undefined ) geometry.name = data.name;
+				if ( data.userData !== undefined ) geometry.userData = data.userData;
+
+				geometries[ data.uuid ] = geometry;
+
+			}
+
+		}
+
+		return geometries;
+
+	}
+
+	parseMaterials( json, textures ) {
+
+		const cache = {}; // MultiMaterial
+		const materials = {};
+
+		if ( json !== undefined ) {
+
+			const loader = new MaterialLoader();
+			loader.setTextures( textures );
+
+			for ( let i = 0, l = json.length; i < l; i ++ ) {
+
+				const data = json[ i ];
+
+				if ( cache[ data.uuid ] === undefined ) {
+
+					cache[ data.uuid ] = loader.parse( data );
+
+				}
+
+				materials[ data.uuid ] = cache[ data.uuid ];
+
+			}
+
+		}
+
+		return materials;
+
+	}
+
+	parseAnimations( json ) {
+
+		const animations = {};
+
+		if ( json !== undefined ) {
+
+			for ( let i = 0; i < json.length; i ++ ) {
+
+				const data = json[ i ];
+
+				const clip = AnimationClip.parse( data );
+
+				animations[ clip.uuid ] = clip;
+
+			}
+
+		}
+
+		return animations;
+
+	}
+
+	parseImages( json, onLoad ) {
+
+		const scope = this;
+		const images = {};
+
+		let loader;
+
+		function loadImage( url ) {
+
+			scope.manager.itemStart( url );
+
+			return loader.load( url, function () {
+
+				scope.manager.itemEnd( url );
+
+			}, undefined, function () {
+
+				scope.manager.itemError( url );
+				scope.manager.itemEnd( url );
+
+			} );
+
+		}
+
+		function deserializeImage( image ) {
+
+			if ( typeof image === 'string' ) {
+
+				const url = image;
+
+				const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( url ) ? url : scope.resourcePath + url;
+
+				return loadImage( path );
+
+			} else {
+
+				if ( image.data ) {
+
+					return {
+						data: getTypedArray( image.type, image.data ),
+						width: image.width,
+						height: image.height
+					};
+
+				} else {
+
+					return null;
+
+				}
+
+			}
+
+		}
+
+		if ( json !== undefined && json.length > 0 ) {
+
+			const manager = new LoadingManager( onLoad );
+
+			loader = new ImageLoader( manager );
+			loader.setCrossOrigin( this.crossOrigin );
+
+			for ( let i = 0, il = json.length; i < il; i ++ ) {
+
+				const image = json[ i ];
+				const url = image.url;
+
+				if ( Array.isArray( url ) ) {
+
+					// load array of images e.g CubeTexture
+
+					const imageArray = [];
+
+					for ( let j = 0, jl = url.length; j < jl; j ++ ) {
+
+						const currentUrl = url[ j ];
+
+						const deserializedImage = deserializeImage( currentUrl );
+
+						if ( deserializedImage !== null ) {
+
+							if ( deserializedImage instanceof HTMLImageElement ) {
+
+								imageArray.push( deserializedImage );
+
+							} else {
+
+								// special case: handle array of data textures for cube textures
+
+								imageArray.push( new DataTexture( deserializedImage.data, deserializedImage.width, deserializedImage.height ) );
+
+							}
+
+						}
+
+					}
+
+					images[ image.uuid ] = new Source( imageArray );
+
+				} else {
+
+					// load single image
+
+					const deserializedImage = deserializeImage( image.url );
+					images[ image.uuid ] = new Source( deserializedImage );
+
+
+				}
+
+			}
+
+		}
+
+		return images;
+
+	}
+
+	async parseImagesAsync( json ) {
+
+		const scope = this;
+		const images = {};
+
+		let loader;
+
+		async function deserializeImage( image ) {
+
+			if ( typeof image === 'string' ) {
+
+				const url = image;
+
+				const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( url ) ? url : scope.resourcePath + url;
+
+				return await loader.loadAsync( path );
+
+			} else {
+
+				if ( image.data ) {
+
+					return {
+						data: getTypedArray( image.type, image.data ),
+						width: image.width,
+						height: image.height
+					};
+
+				} else {
+
+					return null;
+
+				}
+
+			}
+
+		}
+
+		if ( json !== undefined && json.length > 0 ) {
+
+			loader = new ImageLoader( this.manager );
+			loader.setCrossOrigin( this.crossOrigin );
+
+			for ( let i = 0, il = json.length; i < il; i ++ ) {
+
+				const image = json[ i ];
+				const url = image.url;
+
+				if ( Array.isArray( url ) ) {
+
+					// load array of images e.g CubeTexture
+
+					const imageArray = [];
+
+					for ( let j = 0, jl = url.length; j < jl; j ++ ) {
+
+						const currentUrl = url[ j ];
+
+						const deserializedImage = await deserializeImage( currentUrl );
+
+						if ( deserializedImage !== null ) {
+
+							if ( deserializedImage instanceof HTMLImageElement ) {
+
+								imageArray.push( deserializedImage );
+
+							} else {
+
+								// special case: handle array of data textures for cube textures
+
+								imageArray.push( new DataTexture( deserializedImage.data, deserializedImage.width, deserializedImage.height ) );
+
+							}
+
+						}
+
+					}
+
+					images[ image.uuid ] = new Source( imageArray );
+
+				} else {
+
+					// load single image
+
+					const deserializedImage = await deserializeImage( image.url );
+					images[ image.uuid ] = new Source( deserializedImage );
+
+				}
+
+			}
+
+		}
+
+		return images;
+
+	}
+
+	parseTextures( json, images ) {
+
+		function parseConstant( value, type ) {
+
+			if ( typeof value === 'number' ) return value;
+
+			console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );
+
+			return type[ value ];
+
+		}
+
+		const textures = {};
+
+		if ( json !== undefined ) {
+
+			for ( let i = 0, l = json.length; i < l; i ++ ) {
+
+				const data = json[ i ];
+
+				if ( data.image === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid );
+
+				}
+
+				if ( images[ data.image ] === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: Undefined image', data.image );
+
+				}
+
+				const source = images[ data.image ];
+				const image = source.data;
+
+				let texture;
+
+				if ( Array.isArray( image ) ) {
+
+					texture = new CubeTexture();
+
+					if ( image.length === 6 ) texture.needsUpdate = true;
+
+				} else {
+
+					if ( image && image.data ) {
+
+						texture = new DataTexture();
+
+					} else {
+
+						texture = new Texture();
+
+					}
+
+					if ( image ) texture.needsUpdate = true; // textures can have undefined image data
+
+				}
+
+				texture.source = source;
+
+				texture.uuid = data.uuid;
+
+				if ( data.name !== undefined ) texture.name = data.name;
+
+				if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING );
+				if ( data.channel !== undefined ) texture.channel = data.channel;
+
+				if ( data.offset !== undefined ) texture.offset.fromArray( data.offset );
+				if ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat );
+				if ( data.center !== undefined ) texture.center.fromArray( data.center );
+				if ( data.rotation !== undefined ) texture.rotation = data.rotation;
+
+				if ( data.wrap !== undefined ) {
+
+					texture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING );
+					texture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING );
+
+				}
+
+				if ( data.format !== undefined ) texture.format = data.format;
+				if ( data.internalFormat !== undefined ) texture.internalFormat = data.internalFormat;
+				if ( data.type !== undefined ) texture.type = data.type;
+				if ( data.colorSpace !== undefined ) texture.colorSpace = data.colorSpace;
+				if ( data.encoding !== undefined ) texture.encoding = data.encoding; // @deprecated, r152
+
+				if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER );
+				if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER );
+				if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;
+
+				if ( data.flipY !== undefined ) texture.flipY = data.flipY;
+
+				if ( data.generateMipmaps !== undefined ) texture.generateMipmaps = data.generateMipmaps;
+				if ( data.premultiplyAlpha !== undefined ) texture.premultiplyAlpha = data.premultiplyAlpha;
+				if ( data.unpackAlignment !== undefined ) texture.unpackAlignment = data.unpackAlignment;
+				if ( data.compareFunction !== undefined ) texture.compareFunction = data.compareFunction;
+
+				if ( data.userData !== undefined ) texture.userData = data.userData;
+
+				textures[ data.uuid ] = texture;
+
+			}
+
+		}
+
+		return textures;
+
+	}
+
+	parseObject( data, geometries, materials, textures, animations ) {
+
+		let object;
+
+		function getGeometry( name ) {
+
+			if ( geometries[ name ] === undefined ) {
+
+				console.warn( 'THREE.ObjectLoader: Undefined geometry', name );
+
+			}
+
+			return geometries[ name ];
+
+		}
+
+		function getMaterial( name ) {
+
+			if ( name === undefined ) return undefined;
+
+			if ( Array.isArray( name ) ) {
+
+				const array = [];
+
+				for ( let i = 0, l = name.length; i < l; i ++ ) {
+
+					const uuid = name[ i ];
+
+					if ( materials[ uuid ] === undefined ) {
+
+						console.warn( 'THREE.ObjectLoader: Undefined material', uuid );
+
+					}
+
+					array.push( materials[ uuid ] );
+
+				}
+
+				return array;
+
+			}
+
+			if ( materials[ name ] === undefined ) {
+
+				console.warn( 'THREE.ObjectLoader: Undefined material', name );
+
+			}
+
+			return materials[ name ];
+
+		}
+
+		function getTexture( uuid ) {
+
+			if ( textures[ uuid ] === undefined ) {
+
+				console.warn( 'THREE.ObjectLoader: Undefined texture', uuid );
+
+			}
+
+			return textures[ uuid ];
+
+		}
+
+		let geometry, material;
+
+		switch ( data.type ) {
+
+			case 'Scene':
+
+				object = new Scene();
+
+				if ( data.background !== undefined ) {
+
+					if ( Number.isInteger( data.background ) ) {
+
+						object.background = new Color( data.background );
+
+					} else {
+
+						object.background = getTexture( data.background );
+
+					}
+
+				}
+
+				if ( data.environment !== undefined ) {
+
+					object.environment = getTexture( data.environment );
+
+				}
+
+				if ( data.fog !== undefined ) {
+
+					if ( data.fog.type === 'Fog' ) {
+
+						object.fog = new Fog( data.fog.color, data.fog.near, data.fog.far );
+
+					} else if ( data.fog.type === 'FogExp2' ) {
+
+						object.fog = new FogExp2( data.fog.color, data.fog.density );
+
+					}
+
+					if ( data.fog.name !== '' ) {
+
+						object.fog.name = data.fog.name;
+
+					}
+
+				}
+
+				if ( data.backgroundBlurriness !== undefined ) object.backgroundBlurriness = data.backgroundBlurriness;
+				if ( data.backgroundIntensity !== undefined ) object.backgroundIntensity = data.backgroundIntensity;
+
+				break;
+
+			case 'PerspectiveCamera':
+
+				object = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far );
+
+				if ( data.focus !== undefined ) object.focus = data.focus;
+				if ( data.zoom !== undefined ) object.zoom = data.zoom;
+				if ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;
+				if ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;
+				if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
+
+				break;
+
+			case 'OrthographicCamera':
+
+				object = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );
+
+				if ( data.zoom !== undefined ) object.zoom = data.zoom;
+				if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
+
+				break;
+
+			case 'AmbientLight':
+
+				object = new AmbientLight( data.color, data.intensity );
+
+				break;
+
+			case 'DirectionalLight':
+
+				object = new DirectionalLight( data.color, data.intensity );
+
+				break;
+
+			case 'PointLight':
+
+				object = new PointLight( data.color, data.intensity, data.distance, data.decay );
+
+				break;
+
+			case 'RectAreaLight':
+
+				object = new RectAreaLight( data.color, data.intensity, data.width, data.height );
+
+				break;
+
+			case 'SpotLight':
+
+				object = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );
+
+				break;
+
+			case 'HemisphereLight':
+
+				object = new HemisphereLight( data.color, data.groundColor, data.intensity );
+
+				break;
+
+			case 'LightProbe':
+
+				object = new LightProbe().fromJSON( data );
+
+				break;
+
+			case 'SkinnedMesh':
+
+				geometry = getGeometry( data.geometry );
+			 	material = getMaterial( data.material );
+
+				object = new SkinnedMesh( geometry, material );
+
+				if ( data.bindMode !== undefined ) object.bindMode = data.bindMode;
+				if ( data.bindMatrix !== undefined ) object.bindMatrix.fromArray( data.bindMatrix );
+				if ( data.skeleton !== undefined ) object.skeleton = data.skeleton;
+
+				break;
+
+			case 'Mesh':
+
+				geometry = getGeometry( data.geometry );
+				material = getMaterial( data.material );
+
+				object = new Mesh( geometry, material );
+
+				break;
+
+			case 'InstancedMesh':
+
+				geometry = getGeometry( data.geometry );
+				material = getMaterial( data.material );
+				const count = data.count;
+				const instanceMatrix = data.instanceMatrix;
+				const instanceColor = data.instanceColor;
+
+				object = new InstancedMesh( geometry, material, count );
+				object.instanceMatrix = new InstancedBufferAttribute( new Float32Array( instanceMatrix.array ), 16 );
+				if ( instanceColor !== undefined ) object.instanceColor = new InstancedBufferAttribute( new Float32Array( instanceColor.array ), instanceColor.itemSize );
+
+				break;
+
+			case 'BatchedMesh':
+
+				geometry = getGeometry( data.geometry );
+				material = getMaterial( data.material );
+
+				object = new BatchedMesh( data.maxGeometryCount, data.maxVertexCount, data.maxIndexCount, material );
+				object.geometry = geometry;
+				object.perObjectFrustumCulled = data.perObjectFrustumCulled;
+				object.sortObjects = data.sortObjects;
+
+				object._drawRanges = data.drawRanges;
+				object._reservedRanges = data.reservedRanges;
+
+				object._visibility = data.visibility;
+				object._active = data.active;
+				object._bounds = data.bounds.map( bound => {
+
+					const box = new Box3();
+					box.min.fromArray( bound.boxMin );
+					box.max.fromArray( bound.boxMax );
+
+					const sphere = new Sphere();
+					sphere.radius = bound.sphereRadius;
+					sphere.center.fromArray( bound.sphereCenter );
+
+					return {
+						boxInitialized: bound.boxInitialized,
+						box: box,
+
+						sphereInitialized: bound.sphereInitialized,
+						sphere: sphere
+					};
+
+				} );
+
+				object._maxGeometryCount = data.maxGeometryCount;
+				object._maxVertexCount = data.maxVertexCount;
+				object._maxIndexCount = data.maxIndexCount;
+
+				object._geometryInitialized = data.geometryInitialized;
+				object._geometryCount = data.geometryCount;
+
+				object._matricesTexture = getTexture( data.matricesTexture.uuid );
+
+				break;
+
+			case 'LOD':
+
+				object = new LOD();
+
+				break;
+
+			case 'Line':
+
+				object = new Line( getGeometry( data.geometry ), getMaterial( data.material ) );
+
+				break;
+
+			case 'LineLoop':
+
+				object = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) );
+
+				break;
+
+			case 'LineSegments':
+
+				object = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) );
+
+				break;
+
+			case 'PointCloud':
+			case 'Points':
+
+				object = new Points( getGeometry( data.geometry ), getMaterial( data.material ) );
+
+				break;
+
+			case 'Sprite':
+
+				object = new Sprite( getMaterial( data.material ) );
+
+				break;
+
+			case 'Group':
+
+				object = new Group();
+
+				break;
+
+			case 'Bone':
+
+				object = new Bone();
+
+				break;
+
+			default:
+
+				object = new Object3D();
+
+		}
+
+		object.uuid = data.uuid;
+
+		if ( data.name !== undefined ) object.name = data.name;
+
+		if ( data.matrix !== undefined ) {
+
+			object.matrix.fromArray( data.matrix );
+
+			if ( data.matrixAutoUpdate !== undefined ) object.matrixAutoUpdate = data.matrixAutoUpdate;
+			if ( object.matrixAutoUpdate ) object.matrix.decompose( object.position, object.quaternion, object.scale );
+
+		} else {
+
+			if ( data.position !== undefined ) object.position.fromArray( data.position );
+			if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );
+			if ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion );
+			if ( data.scale !== undefined ) object.scale.fromArray( data.scale );
+
+		}
+
+		if ( data.up !== undefined ) object.up.fromArray( data.up );
+
+		if ( data.castShadow !== undefined ) object.castShadow = data.castShadow;
+		if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;
+
+		if ( data.shadow ) {
+
+			if ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias;
+			if ( data.shadow.normalBias !== undefined ) object.shadow.normalBias = data.shadow.normalBias;
+			if ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius;
+			if ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize );
+			if ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera );
+
+		}
+
+		if ( data.visible !== undefined ) object.visible = data.visible;
+		if ( data.frustumCulled !== undefined ) object.frustumCulled = data.frustumCulled;
+		if ( data.renderOrder !== undefined ) object.renderOrder = data.renderOrder;
+		if ( data.userData !== undefined ) object.userData = data.userData;
+		if ( data.layers !== undefined ) object.layers.mask = data.layers;
+
+		if ( data.children !== undefined ) {
+
+			const children = data.children;
+
+			for ( let i = 0; i < children.length; i ++ ) {
+
+				object.add( this.parseObject( children[ i ], geometries, materials, textures, animations ) );
+
+			}
+
+		}
+
+		if ( data.animations !== undefined ) {
+
+			const objectAnimations = data.animations;
+
+			for ( let i = 0; i < objectAnimations.length; i ++ ) {
+
+				const uuid = objectAnimations[ i ];
+
+				object.animations.push( animations[ uuid ] );
+
+			}
+
+		}
+
+		if ( data.type === 'LOD' ) {
+
+			if ( data.autoUpdate !== undefined ) object.autoUpdate = data.autoUpdate;
+
+			const levels = data.levels;
+
+			for ( let l = 0; l < levels.length; l ++ ) {
+
+				const level = levels[ l ];
+				const child = object.getObjectByProperty( 'uuid', level.object );
+
+				if ( child !== undefined ) {
+
+					object.addLevel( child, level.distance, level.hysteresis );
+
+				}
+
+			}
+
+		}
+
+		return object;
+
+	}
+
+	bindSkeletons( object, skeletons ) {
+
+		if ( Object.keys( skeletons ).length === 0 ) return;
+
+		object.traverse( function ( child ) {
+
+			if ( child.isSkinnedMesh === true && child.skeleton !== undefined ) {
+
+				const skeleton = skeletons[ child.skeleton ];
+
+				if ( skeleton === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: No skeleton found with UUID:', child.skeleton );
+
+				} else {
+
+					child.bind( skeleton, child.bindMatrix );
+
+				}
+
+			}
+
+		} );
+
+	}
+
+}
+
+const TEXTURE_MAPPING = {
+	UVMapping: UVMapping,
+	CubeReflectionMapping: CubeReflectionMapping,
+	CubeRefractionMapping: CubeRefractionMapping,
+	EquirectangularReflectionMapping: EquirectangularReflectionMapping,
+	EquirectangularRefractionMapping: EquirectangularRefractionMapping,
+	CubeUVReflectionMapping: CubeUVReflectionMapping
+};
+
+const TEXTURE_WRAPPING = {
+	RepeatWrapping: RepeatWrapping,
+	ClampToEdgeWrapping: ClampToEdgeWrapping,
+	MirroredRepeatWrapping: MirroredRepeatWrapping
+};
+
+const TEXTURE_FILTER = {
+	NearestFilter: NearestFilter,
+	NearestMipmapNearestFilter: NearestMipmapNearestFilter,
+	NearestMipmapLinearFilter: NearestMipmapLinearFilter,
+	LinearFilter: LinearFilter,
+	LinearMipmapNearestFilter: LinearMipmapNearestFilter,
+	LinearMipmapLinearFilter: LinearMipmapLinearFilter
+};
+
+class ImageBitmapLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+		this.isImageBitmapLoader = true;
+
+		if ( typeof createImageBitmap === 'undefined' ) {
+
+			console.warn( 'THREE.ImageBitmapLoader: createImageBitmap() not supported.' );
+
+		}
+
+		if ( typeof fetch === 'undefined' ) {
+
+			console.warn( 'THREE.ImageBitmapLoader: fetch() not supported.' );
+
+		}
+
+		this.options = { premultiplyAlpha: 'none' };
+
+	}
+
+	setOptions( options ) {
+
+		this.options = options;
+
+		return this;
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		if ( url === undefined ) url = '';
+
+		if ( this.path !== undefined ) url = this.path + url;
+
+		url = this.manager.resolveURL( url );
+
+		const scope = this;
+
+		const cached = Cache.get( url );
+
+		if ( cached !== undefined ) {
+
+			scope.manager.itemStart( url );
+
+			// If cached is a promise, wait for it to resolve
+			if ( cached.then ) {
+
+				cached.then( imageBitmap => {
+
+					if ( onLoad ) onLoad( imageBitmap );
+
+					scope.manager.itemEnd( url );
+
+				} ).catch( e => {
+
+					if ( onError ) onError( e );
+
+				} );
+				return;
+
+			}
+
+			// If cached is not a promise (i.e., it's already an imageBitmap)
+			setTimeout( function () {
+
+				if ( onLoad ) onLoad( cached );
+
+				scope.manager.itemEnd( url );
+
+			}, 0 );
+
+			return cached;
+
+		}
+
+		const fetchOptions = {};
+		fetchOptions.credentials = ( this.crossOrigin === 'anonymous' ) ? 'same-origin' : 'include';
+		fetchOptions.headers = this.requestHeader;
+
+		const promise = fetch( url, fetchOptions ).then( function ( res ) {
+
+			return res.blob();
+
+		} ).then( function ( blob ) {
+
+			return createImageBitmap( blob, Object.assign( scope.options, { colorSpaceConversion: 'none' } ) );
+
+		} ).then( function ( imageBitmap ) {
+
+			Cache.add( url, imageBitmap );
+
+			if ( onLoad ) onLoad( imageBitmap );
+
+			scope.manager.itemEnd( url );
+
+			return imageBitmap;
+
+		} ).catch( function ( e ) {
+
+			if ( onError ) onError( e );
+
+			Cache.remove( url );
+
+			scope.manager.itemError( url );
+			scope.manager.itemEnd( url );
+
+		} );
+
+		Cache.add( url, promise );
+		scope.manager.itemStart( url );
+
+	}
+
+}
+
+let _context;
+
+class AudioContext {
+
+	static getContext() {
+
+		if ( _context === undefined ) {
+
+			_context = new ( window.AudioContext || window.webkitAudioContext )();
+
+		}
+
+		return _context;
+
+	}
+
+	static setContext( value ) {
+
+		_context = value;
+
+	}
+
+}
+
+class AudioLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const loader = new FileLoader( this.manager );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+		loader.load( url, function ( buffer ) {
+
+			try {
+
+				// Create a copy of the buffer. The `decodeAudioData` method
+				// detaches the buffer when complete, preventing reuse.
+				const bufferCopy = buffer.slice( 0 );
+
+				const context = AudioContext.getContext();
+				context.decodeAudioData( bufferCopy, function ( audioBuffer ) {
+
+					onLoad( audioBuffer );
+
+				} ).catch( handleError );
+
+			} catch ( e ) {
+
+				handleError( e );
+
+			}
+
+		}, onProgress, onError );
+
+		function handleError( e ) {
+
+			if ( onError ) {
+
+				onError( e );
+
+			} else {
+
+				console.error( e );
+
+			}
+
+			scope.manager.itemError( url );
+
+		}
+
+	}
+
+}
+
+const _eyeRight = /*@__PURE__*/ new Matrix4();
+const _eyeLeft = /*@__PURE__*/ new Matrix4();
+const _projectionMatrix = /*@__PURE__*/ new Matrix4();
+
+class StereoCamera {
+
+	constructor() {
+
+		this.type = 'StereoCamera';
+
+		this.aspect = 1;
+
+		this.eyeSep = 0.064;
+
+		this.cameraL = new PerspectiveCamera();
+		this.cameraL.layers.enable( 1 );
+		this.cameraL.matrixAutoUpdate = false;
+
+		this.cameraR = new PerspectiveCamera();
+		this.cameraR.layers.enable( 2 );
+		this.cameraR.matrixAutoUpdate = false;
+
+		this._cache = {
+			focus: null,
+			fov: null,
+			aspect: null,
+			near: null,
+			far: null,
+			zoom: null,
+			eyeSep: null
+		};
+
+	}
+
+	update( camera ) {
+
+		const cache = this._cache;
+
+		const needsUpdate = cache.focus !== camera.focus || cache.fov !== camera.fov ||
+			cache.aspect !== camera.aspect * this.aspect || cache.near !== camera.near ||
+			cache.far !== camera.far || cache.zoom !== camera.zoom || cache.eyeSep !== this.eyeSep;
+
+		if ( needsUpdate ) {
+
+			cache.focus = camera.focus;
+			cache.fov = camera.fov;
+			cache.aspect = camera.aspect * this.aspect;
+			cache.near = camera.near;
+			cache.far = camera.far;
+			cache.zoom = camera.zoom;
+			cache.eyeSep = this.eyeSep;
+
+			// Off-axis stereoscopic effect based on
+			// http://paulbourke.net/stereographics/stereorender/
+
+			_projectionMatrix.copy( camera.projectionMatrix );
+			const eyeSepHalf = cache.eyeSep / 2;
+			const eyeSepOnProjection = eyeSepHalf * cache.near / cache.focus;
+			const ymax = ( cache.near * Math.tan( DEG2RAD * cache.fov * 0.5 ) ) / cache.zoom;
+			let xmin, xmax;
+
+			// translate xOffset
+
+			_eyeLeft.elements[ 12 ] = - eyeSepHalf;
+			_eyeRight.elements[ 12 ] = eyeSepHalf;
+
+			// for left eye
+
+			xmin = - ymax * cache.aspect + eyeSepOnProjection;
+			xmax = ymax * cache.aspect + eyeSepOnProjection;
+
+			_projectionMatrix.elements[ 0 ] = 2 * cache.near / ( xmax - xmin );
+			_projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );
+
+			this.cameraL.projectionMatrix.copy( _projectionMatrix );
+
+			// for right eye
+
+			xmin = - ymax * cache.aspect - eyeSepOnProjection;
+			xmax = ymax * cache.aspect - eyeSepOnProjection;
+
+			_projectionMatrix.elements[ 0 ] = 2 * cache.near / ( xmax - xmin );
+			_projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );
+
+			this.cameraR.projectionMatrix.copy( _projectionMatrix );
+
+		}
+
+		this.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( _eyeLeft );
+		this.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( _eyeRight );
+
+	}
+
+}
+
+class Clock {
+
+	constructor( autoStart = true ) {
+
+		this.autoStart = autoStart;
+
+		this.startTime = 0;
+		this.oldTime = 0;
+		this.elapsedTime = 0;
+
+		this.running = false;
+
+	}
+
+	start() {
+
+		this.startTime = now();
+
+		this.oldTime = this.startTime;
+		this.elapsedTime = 0;
+		this.running = true;
+
+	}
+
+	stop() {
+
+		this.getElapsedTime();
+		this.running = false;
+		this.autoStart = false;
+
+	}
+
+	getElapsedTime() {
+
+		this.getDelta();
+		return this.elapsedTime;
+
+	}
+
+	getDelta() {
+
+		let diff = 0;
+
+		if ( this.autoStart && ! this.running ) {
+
+			this.start();
+			return 0;
+
+		}
+
+		if ( this.running ) {
+
+			const newTime = now();
+
+			diff = ( newTime - this.oldTime ) / 1000;
+			this.oldTime = newTime;
+
+			this.elapsedTime += diff;
+
+		}
+
+		return diff;
+
+	}
+
+}
+
+function now() {
+
+	return ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732
+
+}
+
+const _position$1 = /*@__PURE__*/ new Vector3();
+const _quaternion$1 = /*@__PURE__*/ new Quaternion();
+const _scale$1 = /*@__PURE__*/ new Vector3();
+const _orientation$1 = /*@__PURE__*/ new Vector3();
+
+class AudioListener extends Object3D {
+
+	constructor() {
+
+		super();
+
+		this.type = 'AudioListener';
+
+		this.context = AudioContext.getContext();
+
+		this.gain = this.context.createGain();
+		this.gain.connect( this.context.destination );
+
+		this.filter = null;
+
+		this.timeDelta = 0;
+
+		// private
+
+		this._clock = new Clock();
+
+	}
+
+	getInput() {
+
+		return this.gain;
+
+	}
+
+	removeFilter() {
+
+		if ( this.filter !== null ) {
+
+			this.gain.disconnect( this.filter );
+			this.filter.disconnect( this.context.destination );
+			this.gain.connect( this.context.destination );
+			this.filter = null;
+
+		}
+
+		return this;
+
+	}
+
+	getFilter() {
+
+		return this.filter;
+
+	}
+
+	setFilter( value ) {
+
+		if ( this.filter !== null ) {
+
+			this.gain.disconnect( this.filter );
+			this.filter.disconnect( this.context.destination );
+
+		} else {
+
+			this.gain.disconnect( this.context.destination );
+
+		}
+
+		this.filter = value;
+		this.gain.connect( this.filter );
+		this.filter.connect( this.context.destination );
+
+		return this;
+
+	}
+
+	getMasterVolume() {
+
+		return this.gain.gain.value;
+
+	}
+
+	setMasterVolume( value ) {
+
+		this.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );
+
+		return this;
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		super.updateMatrixWorld( force );
+
+		const listener = this.context.listener;
+		const up = this.up;
+
+		this.timeDelta = this._clock.getDelta();
+
+		this.matrixWorld.decompose( _position$1, _quaternion$1, _scale$1 );
+
+		_orientation$1.set( 0, 0, - 1 ).applyQuaternion( _quaternion$1 );
+
+		if ( listener.positionX ) {
+
+			// code path for Chrome (see #14393)
+
+			const endTime = this.context.currentTime + this.timeDelta;
+
+			listener.positionX.linearRampToValueAtTime( _position$1.x, endTime );
+			listener.positionY.linearRampToValueAtTime( _position$1.y, endTime );
+			listener.positionZ.linearRampToValueAtTime( _position$1.z, endTime );
+			listener.forwardX.linearRampToValueAtTime( _orientation$1.x, endTime );
+			listener.forwardY.linearRampToValueAtTime( _orientation$1.y, endTime );
+			listener.forwardZ.linearRampToValueAtTime( _orientation$1.z, endTime );
+			listener.upX.linearRampToValueAtTime( up.x, endTime );
+			listener.upY.linearRampToValueAtTime( up.y, endTime );
+			listener.upZ.linearRampToValueAtTime( up.z, endTime );
+
+		} else {
+
+			listener.setPosition( _position$1.x, _position$1.y, _position$1.z );
+			listener.setOrientation( _orientation$1.x, _orientation$1.y, _orientation$1.z, up.x, up.y, up.z );
+
+		}
+
+	}
+
+}
+
+class Audio extends Object3D {
+
+	constructor( listener ) {
+
+		super();
+
+		this.type = 'Audio';
+
+		this.listener = listener;
+		this.context = listener.context;
+
+		this.gain = this.context.createGain();
+		this.gain.connect( listener.getInput() );
+
+		this.autoplay = false;
+
+		this.buffer = null;
+		this.detune = 0;
+		this.loop = false;
+		this.loopStart = 0;
+		this.loopEnd = 0;
+		this.offset = 0;
+		this.duration = undefined;
+		this.playbackRate = 1;
+		this.isPlaying = false;
+		this.hasPlaybackControl = true;
+		this.source = null;
+		this.sourceType = 'empty';
+
+		this._startedAt = 0;
+		this._progress = 0;
+		this._connected = false;
+
+		this.filters = [];
+
+	}
+
+	getOutput() {
+
+		return this.gain;
+
+	}
+
+	setNodeSource( audioNode ) {
+
+		this.hasPlaybackControl = false;
+		this.sourceType = 'audioNode';
+		this.source = audioNode;
+		this.connect();
+
+		return this;
+
+	}
+
+	setMediaElementSource( mediaElement ) {
+
+		this.hasPlaybackControl = false;
+		this.sourceType = 'mediaNode';
+		this.source = this.context.createMediaElementSource( mediaElement );
+		this.connect();
+
+		return this;
+
+	}
+
+	setMediaStreamSource( mediaStream ) {
+
+		this.hasPlaybackControl = false;
+		this.sourceType = 'mediaStreamNode';
+		this.source = this.context.createMediaStreamSource( mediaStream );
+		this.connect();
+
+		return this;
+
+	}
+
+	setBuffer( audioBuffer ) {
+
+		this.buffer = audioBuffer;
+		this.sourceType = 'buffer';
+
+		if ( this.autoplay ) this.play();
+
+		return this;
+
+	}
+
+	play( delay = 0 ) {
+
+		if ( this.isPlaying === true ) {
+
+			console.warn( 'THREE.Audio: Audio is already playing.' );
+			return;
+
+		}
+
+		if ( this.hasPlaybackControl === false ) {
+
+			console.warn( 'THREE.Audio: this Audio has no playback control.' );
+			return;
+
+		}
+
+		this._startedAt = this.context.currentTime + delay;
+
+		const source = this.context.createBufferSource();
+		source.buffer = this.buffer;
+		source.loop = this.loop;
+		source.loopStart = this.loopStart;
+		source.loopEnd = this.loopEnd;
+		source.onended = this.onEnded.bind( this );
+		source.start( this._startedAt, this._progress + this.offset, this.duration );
+
+		this.isPlaying = true;
+
+		this.source = source;
+
+		this.setDetune( this.detune );
+		this.setPlaybackRate( this.playbackRate );
+
+		return this.connect();
+
+	}
+
+	pause() {
+
+		if ( this.hasPlaybackControl === false ) {
+
+			console.warn( 'THREE.Audio: this Audio has no playback control.' );
+			return;
+
+		}
+
+		if ( this.isPlaying === true ) {
+
+			// update current progress
+
+			this._progress += Math.max( this.context.currentTime - this._startedAt, 0 ) * this.playbackRate;
+
+			if ( this.loop === true ) {
+
+				// ensure _progress does not exceed duration with looped audios
+
+				this._progress = this._progress % ( this.duration || this.buffer.duration );
+
+			}
+
+			this.source.stop();
+			this.source.onended = null;
+
+			this.isPlaying = false;
+
+		}
+
+		return this;
+
+	}
+
+	stop() {
+
+		if ( this.hasPlaybackControl === false ) {
+
+			console.warn( 'THREE.Audio: this Audio has no playback control.' );
+			return;
+
+		}
+
+		this._progress = 0;
+
+		if ( this.source !== null ) {
+
+			this.source.stop();
+			this.source.onended = null;
+
+		}
+
+		this.isPlaying = false;
+
+		return this;
+
+	}
+
+	connect() {
+
+		if ( this.filters.length > 0 ) {
+
+			this.source.connect( this.filters[ 0 ] );
+
+			for ( let i = 1, l = this.filters.length; i < l; i ++ ) {
+
+				this.filters[ i - 1 ].connect( this.filters[ i ] );
+
+			}
+
+			this.filters[ this.filters.length - 1 ].connect( this.getOutput() );
+
+		} else {
+
+			this.source.connect( this.getOutput() );
+
+		}
+
+		this._connected = true;
+
+		return this;
+
+	}
+
+	disconnect() {
+
+		if ( this._connected === false ) {
+
+			return;
+
+		}
+
+		if ( this.filters.length > 0 ) {
+
+			this.source.disconnect( this.filters[ 0 ] );
+
+			for ( let i = 1, l = this.filters.length; i < l; i ++ ) {
+
+				this.filters[ i - 1 ].disconnect( this.filters[ i ] );
+
+			}
+
+			this.filters[ this.filters.length - 1 ].disconnect( this.getOutput() );
+
+		} else {
+
+			this.source.disconnect( this.getOutput() );
+
+		}
+
+		this._connected = false;
+
+		return this;
+
+	}
+
+	getFilters() {
+
+		return this.filters;
+
+	}
+
+	setFilters( value ) {
+
+		if ( ! value ) value = [];
+
+		if ( this._connected === true ) {
+
+			this.disconnect();
+			this.filters = value.slice();
+			this.connect();
+
+		} else {
+
+			this.filters = value.slice();
+
+		}
+
+		return this;
+
+	}
+
+	setDetune( value ) {
+
+		this.detune = value;
+
+		if ( this.source.detune === undefined ) return; // only set detune when available
+
+		if ( this.isPlaying === true ) {
+
+			this.source.detune.setTargetAtTime( this.detune, this.context.currentTime, 0.01 );
+
+		}
+
+		return this;
+
+	}
+
+	getDetune() {
+
+		return this.detune;
+
+	}
+
+	getFilter() {
+
+		return this.getFilters()[ 0 ];
+
+	}
+
+	setFilter( filter ) {
+
+		return this.setFilters( filter ? [ filter ] : [] );
+
+	}
+
+	setPlaybackRate( value ) {
+
+		if ( this.hasPlaybackControl === false ) {
+
+			console.warn( 'THREE.Audio: this Audio has no playback control.' );
+			return;
+
+		}
+
+		this.playbackRate = value;
+
+		if ( this.isPlaying === true ) {
+
+			this.source.playbackRate.setTargetAtTime( this.playbackRate, this.context.currentTime, 0.01 );
+
+		}
+
+		return this;
+
+	}
+
+	getPlaybackRate() {
+
+		return this.playbackRate;
+
+	}
+
+	onEnded() {
+
+		this.isPlaying = false;
+
+	}
+
+	getLoop() {
+
+		if ( this.hasPlaybackControl === false ) {
+
+			console.warn( 'THREE.Audio: this Audio has no playback control.' );
+			return false;
+
+		}
+
+		return this.loop;
+
+	}
+
+	setLoop( value ) {
+
+		if ( this.hasPlaybackControl === false ) {
+
+			console.warn( 'THREE.Audio: this Audio has no playback control.' );
+			return;
+
+		}
+
+		this.loop = value;
+
+		if ( this.isPlaying === true ) {
+
+			this.source.loop = this.loop;
+
+		}
+
+		return this;
+
+	}
+
+	setLoopStart( value ) {
+
+		this.loopStart = value;
+
+		return this;
+
+	}
+
+	setLoopEnd( value ) {
+
+		this.loopEnd = value;
+
+		return this;
+
+	}
+
+	getVolume() {
+
+		return this.gain.gain.value;
+
+	}
+
+	setVolume( value ) {
+
+		this.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );
+
+		return this;
+
+	}
+
+}
+
+const _position = /*@__PURE__*/ new Vector3();
+const _quaternion = /*@__PURE__*/ new Quaternion();
+const _scale = /*@__PURE__*/ new Vector3();
+const _orientation = /*@__PURE__*/ new Vector3();
+
+class PositionalAudio extends Audio {
+
+	constructor( listener ) {
+
+		super( listener );
+
+		this.panner = this.context.createPanner();
+		this.panner.panningModel = 'HRTF';
+		this.panner.connect( this.gain );
+
+	}
+
+	connect() {
+
+		super.connect();
+
+		this.panner.connect( this.gain );
+
+	}
+
+	disconnect() {
+
+		super.disconnect();
+
+		this.panner.disconnect( this.gain );
+
+	}
+
+	getOutput() {
+
+		return this.panner;
+
+	}
+
+	getRefDistance() {
+
+		return this.panner.refDistance;
+
+	}
+
+	setRefDistance( value ) {
+
+		this.panner.refDistance = value;
+
+		return this;
+
+	}
+
+	getRolloffFactor() {
+
+		return this.panner.rolloffFactor;
+
+	}
+
+	setRolloffFactor( value ) {
+
+		this.panner.rolloffFactor = value;
+
+		return this;
+
+	}
+
+	getDistanceModel() {
+
+		return this.panner.distanceModel;
+
+	}
+
+	setDistanceModel( value ) {
+
+		this.panner.distanceModel = value;
+
+		return this;
+
+	}
+
+	getMaxDistance() {
+
+		return this.panner.maxDistance;
+
+	}
+
+	setMaxDistance( value ) {
+
+		this.panner.maxDistance = value;
+
+		return this;
+
+	}
+
+	setDirectionalCone( coneInnerAngle, coneOuterAngle, coneOuterGain ) {
+
+		this.panner.coneInnerAngle = coneInnerAngle;
+		this.panner.coneOuterAngle = coneOuterAngle;
+		this.panner.coneOuterGain = coneOuterGain;
+
+		return this;
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		super.updateMatrixWorld( force );
+
+		if ( this.hasPlaybackControl === true && this.isPlaying === false ) return;
+
+		this.matrixWorld.decompose( _position, _quaternion, _scale );
+
+		_orientation.set( 0, 0, 1 ).applyQuaternion( _quaternion );
+
+		const panner = this.panner;
+
+		if ( panner.positionX ) {
+
+			// code path for Chrome and Firefox (see #14393)
+
+			const endTime = this.context.currentTime + this.listener.timeDelta;
+
+			panner.positionX.linearRampToValueAtTime( _position.x, endTime );
+			panner.positionY.linearRampToValueAtTime( _position.y, endTime );
+			panner.positionZ.linearRampToValueAtTime( _position.z, endTime );
+			panner.orientationX.linearRampToValueAtTime( _orientation.x, endTime );
+			panner.orientationY.linearRampToValueAtTime( _orientation.y, endTime );
+			panner.orientationZ.linearRampToValueAtTime( _orientation.z, endTime );
+
+		} else {
+
+			panner.setPosition( _position.x, _position.y, _position.z );
+			panner.setOrientation( _orientation.x, _orientation.y, _orientation.z );
+
+		}
+
+	}
+
+}
+
+class AudioAnalyser {
+
+	constructor( audio, fftSize = 2048 ) {
+
+		this.analyser = audio.context.createAnalyser();
+		this.analyser.fftSize = fftSize;
+
+		this.data = new Uint8Array( this.analyser.frequencyBinCount );
+
+		audio.getOutput().connect( this.analyser );
+
+	}
+
+
+	getFrequencyData() {
+
+		this.analyser.getByteFrequencyData( this.data );
+
+		return this.data;
+
+	}
+
+	getAverageFrequency() {
+
+		let value = 0;
+		const data = this.getFrequencyData();
+
+		for ( let i = 0; i < data.length; i ++ ) {
+
+			value += data[ i ];
+
+		}
+
+		return value / data.length;
+
+	}
+
+}
+
+class PropertyMixer {
+
+	constructor( binding, typeName, valueSize ) {
+
+		this.binding = binding;
+		this.valueSize = valueSize;
+
+		let mixFunction,
+			mixFunctionAdditive,
+			setIdentity;
+
+		// buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ]
+		//
+		// interpolators can use .buffer as their .result
+		// the data then goes to 'incoming'
+		//
+		// 'accu0' and 'accu1' are used frame-interleaved for
+		// the cumulative result and are compared to detect
+		// changes
+		//
+		// 'orig' stores the original state of the property
+		//
+		// 'add' is used for additive cumulative results
+		//
+		// 'work' is optional and is only present for quaternion types. It is used
+		// to store intermediate quaternion multiplication results
+
+		switch ( typeName ) {
+
+			case 'quaternion':
+				mixFunction = this._slerp;
+				mixFunctionAdditive = this._slerpAdditive;
+				setIdentity = this._setAdditiveIdentityQuaternion;
+
+				this.buffer = new Float64Array( valueSize * 6 );
+				this._workIndex = 5;
+				break;
+
+			case 'string':
+			case 'bool':
+				mixFunction = this._select;
+
+				// Use the regular mix function and for additive on these types,
+				// additive is not relevant for non-numeric types
+				mixFunctionAdditive = this._select;
+
+				setIdentity = this._setAdditiveIdentityOther;
+
+				this.buffer = new Array( valueSize * 5 );
+				break;
+
+			default:
+				mixFunction = this._lerp;
+				mixFunctionAdditive = this._lerpAdditive;
+				setIdentity = this._setAdditiveIdentityNumeric;
+
+				this.buffer = new Float64Array( valueSize * 5 );
+
+		}
+
+		this._mixBufferRegion = mixFunction;
+		this._mixBufferRegionAdditive = mixFunctionAdditive;
+		this._setIdentity = setIdentity;
+		this._origIndex = 3;
+		this._addIndex = 4;
+
+		this.cumulativeWeight = 0;
+		this.cumulativeWeightAdditive = 0;
+
+		this.useCount = 0;
+		this.referenceCount = 0;
+
+	}
+
+	// accumulate data in the 'incoming' region into 'accu<i>'
+	accumulate( accuIndex, weight ) {
+
+		// note: happily accumulating nothing when weight = 0, the caller knows
+		// the weight and shouldn't have made the call in the first place
+
+		const buffer = this.buffer,
+			stride = this.valueSize,
+			offset = accuIndex * stride + stride;
+
+		let currentWeight = this.cumulativeWeight;
+
+		if ( currentWeight === 0 ) {
+
+			// accuN := incoming * weight
+
+			for ( let i = 0; i !== stride; ++ i ) {
+
+				buffer[ offset + i ] = buffer[ i ];
+
+			}
+
+			currentWeight = weight;
+
+		} else {
+
+			// accuN := accuN + incoming * weight
+
+			currentWeight += weight;
+			const mix = weight / currentWeight;
+			this._mixBufferRegion( buffer, offset, 0, mix, stride );
+
+		}
+
+		this.cumulativeWeight = currentWeight;
+
+	}
+
+	// accumulate data in the 'incoming' region into 'add'
+	accumulateAdditive( weight ) {
+
+		const buffer = this.buffer,
+			stride = this.valueSize,
+			offset = stride * this._addIndex;
+
+		if ( this.cumulativeWeightAdditive === 0 ) {
+
+			// add = identity
+
+			this._setIdentity();
+
+		}
+
+		// add := add + incoming * weight
+
+		this._mixBufferRegionAdditive( buffer, offset, 0, weight, stride );
+		this.cumulativeWeightAdditive += weight;
+
+	}
+
+	// apply the state of 'accu<i>' to the binding when accus differ
+	apply( accuIndex ) {
+
+		const stride = this.valueSize,
+			buffer = this.buffer,
+			offset = accuIndex * stride + stride,
+
+			weight = this.cumulativeWeight,
+			weightAdditive = this.cumulativeWeightAdditive,
+
+			binding = this.binding;
+
+		this.cumulativeWeight = 0;
+		this.cumulativeWeightAdditive = 0;
+
+		if ( weight < 1 ) {
+
+			// accuN := accuN + original * ( 1 - cumulativeWeight )
+
+			const originalValueOffset = stride * this._origIndex;
+
+			this._mixBufferRegion(
+				buffer, offset, originalValueOffset, 1 - weight, stride );
+
+		}
+
+		if ( weightAdditive > 0 ) {
+
+			// accuN := accuN + additive accuN
+
+			this._mixBufferRegionAdditive( buffer, offset, this._addIndex * stride, 1, stride );
+
+		}
+
+		for ( let i = stride, e = stride + stride; i !== e; ++ i ) {
+
+			if ( buffer[ i ] !== buffer[ i + stride ] ) {
+
+				// value has changed -> update scene graph
+
+				binding.setValue( buffer, offset );
+				break;
+
+			}
+
+		}
+
+	}
+
+	// remember the state of the bound property and copy it to both accus
+	saveOriginalState() {
+
+		const binding = this.binding;
+
+		const buffer = this.buffer,
+			stride = this.valueSize,
+
+			originalValueOffset = stride * this._origIndex;
+
+		binding.getValue( buffer, originalValueOffset );
+
+		// accu[0..1] := orig -- initially detect changes against the original
+		for ( let i = stride, e = originalValueOffset; i !== e; ++ i ) {
+
+			buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];
+
+		}
+
+		// Add to identity for additive
+		this._setIdentity();
+
+		this.cumulativeWeight = 0;
+		this.cumulativeWeightAdditive = 0;
+
+	}
+
+	// apply the state previously taken via 'saveOriginalState' to the binding
+	restoreOriginalState() {
+
+		const originalValueOffset = this.valueSize * 3;
+		this.binding.setValue( this.buffer, originalValueOffset );
+
+	}
+
+	_setAdditiveIdentityNumeric() {
+
+		const startIndex = this._addIndex * this.valueSize;
+		const endIndex = startIndex + this.valueSize;
+
+		for ( let i = startIndex; i < endIndex; i ++ ) {
+
+			this.buffer[ i ] = 0;
+
+		}
+
+	}
+
+	_setAdditiveIdentityQuaternion() {
+
+		this._setAdditiveIdentityNumeric();
+		this.buffer[ this._addIndex * this.valueSize + 3 ] = 1;
+
+	}
+
+	_setAdditiveIdentityOther() {
+
+		const startIndex = this._origIndex * this.valueSize;
+		const targetIndex = this._addIndex * this.valueSize;
+
+		for ( let i = 0; i < this.valueSize; i ++ ) {
+
+			this.buffer[ targetIndex + i ] = this.buffer[ startIndex + i ];
+
+		}
+
+	}
+
+
+	// mix functions
+
+	_select( buffer, dstOffset, srcOffset, t, stride ) {
+
+		if ( t >= 0.5 ) {
+
+			for ( let i = 0; i !== stride; ++ i ) {
+
+				buffer[ dstOffset + i ] = buffer[ srcOffset + i ];
+
+			}
+
+		}
+
+	}
+
+	_slerp( buffer, dstOffset, srcOffset, t ) {
+
+		Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t );
+
+	}
+
+	_slerpAdditive( buffer, dstOffset, srcOffset, t, stride ) {
+
+		const workOffset = this._workIndex * stride;
+
+		// Store result in intermediate buffer offset
+		Quaternion.multiplyQuaternionsFlat( buffer, workOffset, buffer, dstOffset, buffer, srcOffset );
+
+		// Slerp to the intermediate result
+		Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t );
+
+	}
+
+	_lerp( buffer, dstOffset, srcOffset, t, stride ) {
+
+		const s = 1 - t;
+
+		for ( let i = 0; i !== stride; ++ i ) {
+
+			const j = dstOffset + i;
+
+			buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;
+
+		}
+
+	}
+
+	_lerpAdditive( buffer, dstOffset, srcOffset, t, stride ) {
+
+		for ( let i = 0; i !== stride; ++ i ) {
+
+			const j = dstOffset + i;
+
+			buffer[ j ] = buffer[ j ] + buffer[ srcOffset + i ] * t;
+
+		}
+
+	}
+
+}
+
+// Characters [].:/ are reserved for track binding syntax.
+const _RESERVED_CHARS_RE = '\\[\\]\\.:\\/';
+const _reservedRe = new RegExp( '[' + _RESERVED_CHARS_RE + ']', 'g' );
+
+// Attempts to allow node names from any language. ES5's `\w` regexp matches
+// only latin characters, and the unicode \p{L} is not yet supported. So
+// instead, we exclude reserved characters and match everything else.
+const _wordChar = '[^' + _RESERVED_CHARS_RE + ']';
+const _wordCharOrDot = '[^' + _RESERVED_CHARS_RE.replace( '\\.', '' ) + ']';
+
+// Parent directories, delimited by '/' or ':'. Currently unused, but must
+// be matched to parse the rest of the track name.
+const _directoryRe = /*@__PURE__*/ /((?:WC+[\/:])*)/.source.replace( 'WC', _wordChar );
+
+// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.
+const _nodeRe = /*@__PURE__*/ /(WCOD+)?/.source.replace( 'WCOD', _wordCharOrDot );
+
+// Object on target node, and accessor. May not contain reserved
+// characters. Accessor may contain any character except closing bracket.
+const _objectRe = /*@__PURE__*/ /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace( 'WC', _wordChar );
+
+// Property and accessor. May not contain reserved characters. Accessor may
+// contain any non-bracket characters.
+const _propertyRe = /*@__PURE__*/ /\.(WC+)(?:\[(.+)\])?/.source.replace( 'WC', _wordChar );
+
+const _trackRe = new RegExp( ''
+	+ '^'
+	+ _directoryRe
+	+ _nodeRe
+	+ _objectRe
+	+ _propertyRe
+	+ '$'
+);
+
+const _supportedObjectNames = [ 'material', 'materials', 'bones', 'map' ];
+
+class Composite {
+
+	constructor( targetGroup, path, optionalParsedPath ) {
+
+		const parsedPath = optionalParsedPath || PropertyBinding.parseTrackName( path );
+
+		this._targetGroup = targetGroup;
+		this._bindings = targetGroup.subscribe_( path, parsedPath );
+
+	}
+
+	getValue( array, offset ) {
+
+		this.bind(); // bind all binding
+
+		const firstValidIndex = this._targetGroup.nCachedObjects_,
+			binding = this._bindings[ firstValidIndex ];
+
+		// and only call .getValue on the first
+		if ( binding !== undefined ) binding.getValue( array, offset );
+
+	}
+
+	setValue( array, offset ) {
+
+		const bindings = this._bindings;
+
+		for ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {
+
+			bindings[ i ].setValue( array, offset );
+
+		}
+
+	}
+
+	bind() {
+
+		const bindings = this._bindings;
+
+		for ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {
+
+			bindings[ i ].bind();
+
+		}
+
+	}
+
+	unbind() {
+
+		const bindings = this._bindings;
+
+		for ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {
+
+			bindings[ i ].unbind();
+
+		}
+
+	}
+
+}
+
+// Note: This class uses a State pattern on a per-method basis:
+// 'bind' sets 'this.getValue' / 'setValue' and shadows the
+// prototype version of these methods with one that represents
+// the bound state. When the property is not found, the methods
+// become no-ops.
+class PropertyBinding {
+
+	constructor( rootNode, path, parsedPath ) {
+
+		this.path = path;
+		this.parsedPath = parsedPath || PropertyBinding.parseTrackName( path );
+
+		this.node = PropertyBinding.findNode( rootNode, this.parsedPath.nodeName );
+
+		this.rootNode = rootNode;
+
+		// initial state of these methods that calls 'bind'
+		this.getValue = this._getValue_unbound;
+		this.setValue = this._setValue_unbound;
+
+	}
+
+
+	static create( root, path, parsedPath ) {
+
+		if ( ! ( root && root.isAnimationObjectGroup ) ) {
+
+			return new PropertyBinding( root, path, parsedPath );
+
+		} else {
+
+			return new PropertyBinding.Composite( root, path, parsedPath );
+
+		}
+
+	}
+
+	/**
+	 * Replaces spaces with underscores and removes unsupported characters from
+	 * node names, to ensure compatibility with parseTrackName().
+	 *
+	 * @param {string} name Node name to be sanitized.
+	 * @return {string}
+	 */
+	static sanitizeNodeName( name ) {
+
+		return name.replace( /\s/g, '_' ).replace( _reservedRe, '' );
+
+	}
+
+	static parseTrackName( trackName ) {
+
+		const matches = _trackRe.exec( trackName );
+
+		if ( matches === null ) {
+
+			throw new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName );
+
+		}
+
+		const results = {
+			// directoryName: matches[ 1 ], // (tschw) currently unused
+			nodeName: matches[ 2 ],
+			objectName: matches[ 3 ],
+			objectIndex: matches[ 4 ],
+			propertyName: matches[ 5 ], // required
+			propertyIndex: matches[ 6 ]
+		};
+
+		const lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' );
+
+		if ( lastDot !== undefined && lastDot !== - 1 ) {
+
+			const objectName = results.nodeName.substring( lastDot + 1 );
+
+			// Object names must be checked against an allowlist. Otherwise, there
+			// is no way to parse 'foo.bar.baz': 'baz' must be a property, but
+			// 'bar' could be the objectName, or part of a nodeName (which can
+			// include '.' characters).
+			if ( _supportedObjectNames.indexOf( objectName ) !== - 1 ) {
+
+				results.nodeName = results.nodeName.substring( 0, lastDot );
+				results.objectName = objectName;
+
+			}
+
+		}
+
+		if ( results.propertyName === null || results.propertyName.length === 0 ) {
+
+			throw new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName );
+
+		}
+
+		return results;
+
+	}
+
+	static findNode( root, nodeName ) {
+
+		if ( nodeName === undefined || nodeName === '' || nodeName === '.' || nodeName === - 1 || nodeName === root.name || nodeName === root.uuid ) {
+
+			return root;
+
+		}
+
+		// search into skeleton bones.
+		if ( root.skeleton ) {
+
+			const bone = root.skeleton.getBoneByName( nodeName );
+
+			if ( bone !== undefined ) {
+
+				return bone;
+
+			}
+
+		}
+
+		// search into node subtree.
+		if ( root.children ) {
+
+			const searchNodeSubtree = function ( children ) {
+
+				for ( let i = 0; i < children.length; i ++ ) {
+
+					const childNode = children[ i ];
+
+					if ( childNode.name === nodeName || childNode.uuid === nodeName ) {
+
+						return childNode;
+
+					}
+
+					const result = searchNodeSubtree( childNode.children );
+
+					if ( result ) return result;
+
+				}
+
+				return null;
+
+			};
+
+			const subTreeNode = searchNodeSubtree( root.children );
+
+			if ( subTreeNode ) {
+
+				return subTreeNode;
+
+			}
+
+		}
+
+		return null;
+
+	}
+
+	// these are used to "bind" a nonexistent property
+	_getValue_unavailable() {}
+	_setValue_unavailable() {}
+
+	// Getters
+
+	_getValue_direct( buffer, offset ) {
+
+		buffer[ offset ] = this.targetObject[ this.propertyName ];
+
+	}
+
+	_getValue_array( buffer, offset ) {
+
+		const source = this.resolvedProperty;
+
+		for ( let i = 0, n = source.length; i !== n; ++ i ) {
+
+			buffer[ offset ++ ] = source[ i ];
+
+		}
+
+	}
+
+	_getValue_arrayElement( buffer, offset ) {
+
+		buffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];
+
+	}
+
+	_getValue_toArray( buffer, offset ) {
+
+		this.resolvedProperty.toArray( buffer, offset );
+
+	}
+
+	// Direct
+
+	_setValue_direct( buffer, offset ) {
+
+		this.targetObject[ this.propertyName ] = buffer[ offset ];
+
+	}
+
+	_setValue_direct_setNeedsUpdate( buffer, offset ) {
+
+		this.targetObject[ this.propertyName ] = buffer[ offset ];
+		this.targetObject.needsUpdate = true;
+
+	}
+
+	_setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+		this.targetObject[ this.propertyName ] = buffer[ offset ];
+		this.targetObject.matrixWorldNeedsUpdate = true;
+
+	}
+
+	// EntireArray
+
+	_setValue_array( buffer, offset ) {
+
+		const dest = this.resolvedProperty;
+
+		for ( let i = 0, n = dest.length; i !== n; ++ i ) {
+
+			dest[ i ] = buffer[ offset ++ ];
+
+		}
+
+	}
+
+	_setValue_array_setNeedsUpdate( buffer, offset ) {
+
+		const dest = this.resolvedProperty;
+
+		for ( let i = 0, n = dest.length; i !== n; ++ i ) {
+
+			dest[ i ] = buffer[ offset ++ ];
+
+		}
+
+		this.targetObject.needsUpdate = true;
+
+	}
+
+	_setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+		const dest = this.resolvedProperty;
+
+		for ( let i = 0, n = dest.length; i !== n; ++ i ) {
+
+			dest[ i ] = buffer[ offset ++ ];
+
+		}
+
+		this.targetObject.matrixWorldNeedsUpdate = true;
+
+	}
+
+	// ArrayElement
+
+	_setValue_arrayElement( buffer, offset ) {
+
+		this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
+
+	}
+
+	_setValue_arrayElement_setNeedsUpdate( buffer, offset ) {
+
+		this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
+		this.targetObject.needsUpdate = true;
+
+	}
+
+	_setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+		this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
+		this.targetObject.matrixWorldNeedsUpdate = true;
+
+	}
+
+	// HasToFromArray
+
+	_setValue_fromArray( buffer, offset ) {
+
+		this.resolvedProperty.fromArray( buffer, offset );
+
+	}
+
+	_setValue_fromArray_setNeedsUpdate( buffer, offset ) {
+
+		this.resolvedProperty.fromArray( buffer, offset );
+		this.targetObject.needsUpdate = true;
+
+	}
+
+	_setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+		this.resolvedProperty.fromArray( buffer, offset );
+		this.targetObject.matrixWorldNeedsUpdate = true;
+
+	}
+
+	_getValue_unbound( targetArray, offset ) {
+
+		this.bind();
+		this.getValue( targetArray, offset );
+
+	}
+
+	_setValue_unbound( sourceArray, offset ) {
+
+		this.bind();
+		this.setValue( sourceArray, offset );
+
+	}
+
+	// create getter / setter pair for a property in the scene graph
+	bind() {
+
+		let targetObject = this.node;
+		const parsedPath = this.parsedPath;
+
+		const objectName = parsedPath.objectName;
+		const propertyName = parsedPath.propertyName;
+		let propertyIndex = parsedPath.propertyIndex;
+
+		if ( ! targetObject ) {
+
+			targetObject = PropertyBinding.findNode( this.rootNode, parsedPath.nodeName );
+
+			this.node = targetObject;
+
+		}
+
+		// set fail state so we can just 'return' on error
+		this.getValue = this._getValue_unavailable;
+		this.setValue = this._setValue_unavailable;
+
+		// ensure there is a value node
+		if ( ! targetObject ) {
+
+			console.warn( 'THREE.PropertyBinding: No target node found for track: ' + this.path + '.' );
+			return;
+
+		}
+
+		if ( objectName ) {
+
+			let objectIndex = parsedPath.objectIndex;
+
+			// special cases were we need to reach deeper into the hierarchy to get the face materials....
+			switch ( objectName ) {
+
+				case 'materials':
+
+					if ( ! targetObject.material ) {
+
+						console.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );
+						return;
+
+					}
+
+					if ( ! targetObject.material.materials ) {
+
+						console.error( 'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this );
+						return;
+
+					}
+
+					targetObject = targetObject.material.materials;
+
+					break;
+
+				case 'bones':
+
+					if ( ! targetObject.skeleton ) {
+
+						console.error( 'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this );
+						return;
+
+					}
+
+					// potential future optimization: skip this if propertyIndex is already an integer
+					// and convert the integer string to a true integer.
+
+					targetObject = targetObject.skeleton.bones;
+
+					// support resolving morphTarget names into indices.
+					for ( let i = 0; i < targetObject.length; i ++ ) {
+
+						if ( targetObject[ i ].name === objectIndex ) {
+
+							objectIndex = i;
+							break;
+
+						}
+
+					}
+
+					break;
+
+				case 'map':
+
+					if ( 'map' in targetObject ) {
+
+						targetObject = targetObject.map;
+						break;
+
+					}
+
+					if ( ! targetObject.material ) {
+
+						console.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );
+						return;
+
+					}
+
+					if ( ! targetObject.material.map ) {
+
+						console.error( 'THREE.PropertyBinding: Can not bind to material.map as node.material does not have a map.', this );
+						return;
+
+					}
+
+					targetObject = targetObject.material.map;
+					break;
+
+				default:
+
+					if ( targetObject[ objectName ] === undefined ) {
+
+						console.error( 'THREE.PropertyBinding: Can not bind to objectName of node undefined.', this );
+						return;
+
+					}
+
+					targetObject = targetObject[ objectName ];
+
+			}
+
+
+			if ( objectIndex !== undefined ) {
+
+				if ( targetObject[ objectIndex ] === undefined ) {
+
+					console.error( 'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject );
+					return;
+
+				}
+
+				targetObject = targetObject[ objectIndex ];
+
+			}
+
+		}
+
+		// resolve property
+		const nodeProperty = targetObject[ propertyName ];
+
+		if ( nodeProperty === undefined ) {
+
+			const nodeName = parsedPath.nodeName;
+
+			console.error( 'THREE.PropertyBinding: Trying to update property for track: ' + nodeName +
+				'.' + propertyName + ' but it wasn\'t found.', targetObject );
+			return;
+
+		}
+
+		// determine versioning scheme
+		let versioning = this.Versioning.None;
+
+		this.targetObject = targetObject;
+
+		if ( targetObject.needsUpdate !== undefined ) { // material
+
+			versioning = this.Versioning.NeedsUpdate;
+
+		} else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform
+
+			versioning = this.Versioning.MatrixWorldNeedsUpdate;
+
+		}
+
+		// determine how the property gets bound
+		let bindingType = this.BindingType.Direct;
+
+		if ( propertyIndex !== undefined ) {
+
+			// access a sub element of the property array (only primitives are supported right now)
+
+			if ( propertyName === 'morphTargetInfluences' ) {
+
+				// potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.
+
+				// support resolving morphTarget names into indices.
+				if ( ! targetObject.geometry ) {
+
+					console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this );
+					return;
+
+				}
+
+				if ( ! targetObject.geometry.morphAttributes ) {
+
+					console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this );
+					return;
+
+				}
+
+				if ( targetObject.morphTargetDictionary[ propertyIndex ] !== undefined ) {
+
+					propertyIndex = targetObject.morphTargetDictionary[ propertyIndex ];
+
+				}
+
+			}
+
+			bindingType = this.BindingType.ArrayElement;
+
+			this.resolvedProperty = nodeProperty;
+			this.propertyIndex = propertyIndex;
+
+		} else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {
+
+			// must use copy for Object3D.Euler/Quaternion
+
+			bindingType = this.BindingType.HasFromToArray;
+
+			this.resolvedProperty = nodeProperty;
+
+		} else if ( Array.isArray( nodeProperty ) ) {
+
+			bindingType = this.BindingType.EntireArray;
+
+			this.resolvedProperty = nodeProperty;
+
+		} else {
+
+			this.propertyName = propertyName;
+
+		}
+
+		// select getter / setter
+		this.getValue = this.GetterByBindingType[ bindingType ];
+		this.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];
+
+	}
+
+	unbind() {
+
+		this.node = null;
+
+		// back to the prototype version of getValue / setValue
+		// note: avoiding to mutate the shape of 'this' via 'delete'
+		this.getValue = this._getValue_unbound;
+		this.setValue = this._setValue_unbound;
+
+	}
+
+}
+
+PropertyBinding.Composite = Composite;
+
+PropertyBinding.prototype.BindingType = {
+	Direct: 0,
+	EntireArray: 1,
+	ArrayElement: 2,
+	HasFromToArray: 3
+};
+
+PropertyBinding.prototype.Versioning = {
+	None: 0,
+	NeedsUpdate: 1,
+	MatrixWorldNeedsUpdate: 2
+};
+
+PropertyBinding.prototype.GetterByBindingType = [
+
+	PropertyBinding.prototype._getValue_direct,
+	PropertyBinding.prototype._getValue_array,
+	PropertyBinding.prototype._getValue_arrayElement,
+	PropertyBinding.prototype._getValue_toArray,
+
+];
+
+PropertyBinding.prototype.SetterByBindingTypeAndVersioning = [
+
+	[
+		// Direct
+		PropertyBinding.prototype._setValue_direct,
+		PropertyBinding.prototype._setValue_direct_setNeedsUpdate,
+		PropertyBinding.prototype._setValue_direct_setMatrixWorldNeedsUpdate,
+
+	], [
+
+		// EntireArray
+
+		PropertyBinding.prototype._setValue_array,
+		PropertyBinding.prototype._setValue_array_setNeedsUpdate,
+		PropertyBinding.prototype._setValue_array_setMatrixWorldNeedsUpdate,
+
+	], [
+
+		// ArrayElement
+		PropertyBinding.prototype._setValue_arrayElement,
+		PropertyBinding.prototype._setValue_arrayElement_setNeedsUpdate,
+		PropertyBinding.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate,
+
+	], [
+
+		// HasToFromArray
+		PropertyBinding.prototype._setValue_fromArray,
+		PropertyBinding.prototype._setValue_fromArray_setNeedsUpdate,
+		PropertyBinding.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate,
+
+	]
+
+];
+
+/**
+ *
+ * A group of objects that receives a shared animation state.
+ *
+ * Usage:
+ *
+ *  - Add objects you would otherwise pass as 'root' to the
+ *    constructor or the .clipAction method of AnimationMixer.
+ *
+ *  - Instead pass this object as 'root'.
+ *
+ *  - You can also add and remove objects later when the mixer
+ *    is running.
+ *
+ * Note:
+ *
+ *    Objects of this class appear as one object to the mixer,
+ *    so cache control of the individual objects must be done
+ *    on the group.
+ *
+ * Limitation:
+ *
+ *  - The animated properties must be compatible among the
+ *    all objects in the group.
+ *
+ *  - A single property can either be controlled through a
+ *    target group or directly, but not both.
+ */
+
+class AnimationObjectGroup {
+
+	constructor() {
+
+		this.isAnimationObjectGroup = true;
+
+		this.uuid = generateUUID();
+
+		// cached objects followed by the active ones
+		this._objects = Array.prototype.slice.call( arguments );
+
+		this.nCachedObjects_ = 0; // threshold
+		// note: read by PropertyBinding.Composite
+
+		const indices = {};
+		this._indicesByUUID = indices; // for bookkeeping
+
+		for ( let i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			indices[ arguments[ i ].uuid ] = i;
+
+		}
+
+		this._paths = []; // inside: string
+		this._parsedPaths = []; // inside: { we don't care, here }
+		this._bindings = []; // inside: Array< PropertyBinding >
+		this._bindingsIndicesByPath = {}; // inside: indices in these arrays
+
+		const scope = this;
+
+		this.stats = {
+
+			objects: {
+				get total() {
+
+					return scope._objects.length;
+
+				},
+				get inUse() {
+
+					return this.total - scope.nCachedObjects_;
+
+				}
+			},
+			get bindingsPerObject() {
+
+				return scope._bindings.length;
+
+			}
+
+		};
+
+	}
+
+	add() {
+
+		const objects = this._objects,
+			indicesByUUID = this._indicesByUUID,
+			paths = this._paths,
+			parsedPaths = this._parsedPaths,
+			bindings = this._bindings,
+			nBindings = bindings.length;
+
+		let knownObject = undefined,
+			nObjects = objects.length,
+			nCachedObjects = this.nCachedObjects_;
+
+		for ( let i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			const object = arguments[ i ],
+				uuid = object.uuid;
+			let index = indicesByUUID[ uuid ];
+
+			if ( index === undefined ) {
+
+				// unknown object -> add it to the ACTIVE region
+
+				index = nObjects ++;
+				indicesByUUID[ uuid ] = index;
+				objects.push( object );
+
+				// accounting is done, now do the same for all bindings
+
+				for ( let j = 0, m = nBindings; j !== m; ++ j ) {
+
+					bindings[ j ].push( new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ) );
+
+				}
+
+			} else if ( index < nCachedObjects ) {
+
+				knownObject = objects[ index ];
+
+				// move existing object to the ACTIVE region
+
+				const firstActiveIndex = -- nCachedObjects,
+					lastCachedObject = objects[ firstActiveIndex ];
+
+				indicesByUUID[ lastCachedObject.uuid ] = index;
+				objects[ index ] = lastCachedObject;
+
+				indicesByUUID[ uuid ] = firstActiveIndex;
+				objects[ firstActiveIndex ] = object;
+
+				// accounting is done, now do the same for all bindings
+
+				for ( let j = 0, m = nBindings; j !== m; ++ j ) {
+
+					const bindingsForPath = bindings[ j ],
+						lastCached = bindingsForPath[ firstActiveIndex ];
+
+					let binding = bindingsForPath[ index ];
+
+					bindingsForPath[ index ] = lastCached;
+
+					if ( binding === undefined ) {
+
+						// since we do not bother to create new bindings
+						// for objects that are cached, the binding may
+						// or may not exist
+
+						binding = new PropertyBinding( object, paths[ j ], parsedPaths[ j ] );
+
+					}
+
+					bindingsForPath[ firstActiveIndex ] = binding;
+
+				}
+
+			} else if ( objects[ index ] !== knownObject ) {
+
+				console.error( 'THREE.AnimationObjectGroup: Different objects with the same UUID ' +
+					'detected. Clean the caches or recreate your infrastructure when reloading scenes.' );
+
+			} // else the object is already where we want it to be
+
+		} // for arguments
+
+		this.nCachedObjects_ = nCachedObjects;
+
+	}
+
+	remove() {
+
+		const objects = this._objects,
+			indicesByUUID = this._indicesByUUID,
+			bindings = this._bindings,
+			nBindings = bindings.length;
+
+		let nCachedObjects = this.nCachedObjects_;
+
+		for ( let i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			const object = arguments[ i ],
+				uuid = object.uuid,
+				index = indicesByUUID[ uuid ];
+
+			if ( index !== undefined && index >= nCachedObjects ) {
+
+				// move existing object into the CACHED region
+
+				const lastCachedIndex = nCachedObjects ++,
+					firstActiveObject = objects[ lastCachedIndex ];
+
+				indicesByUUID[ firstActiveObject.uuid ] = index;
+				objects[ index ] = firstActiveObject;
+
+				indicesByUUID[ uuid ] = lastCachedIndex;
+				objects[ lastCachedIndex ] = object;
+
+				// accounting is done, now do the same for all bindings
+
+				for ( let j = 0, m = nBindings; j !== m; ++ j ) {
+
+					const bindingsForPath = bindings[ j ],
+						firstActive = bindingsForPath[ lastCachedIndex ],
+						binding = bindingsForPath[ index ];
+
+					bindingsForPath[ index ] = firstActive;
+					bindingsForPath[ lastCachedIndex ] = binding;
+
+				}
+
+			}
+
+		} // for arguments
+
+		this.nCachedObjects_ = nCachedObjects;
+
+	}
+
+	// remove & forget
+	uncache() {
+
+		const objects = this._objects,
+			indicesByUUID = this._indicesByUUID,
+			bindings = this._bindings,
+			nBindings = bindings.length;
+
+		let nCachedObjects = this.nCachedObjects_,
+			nObjects = objects.length;
+
+		for ( let i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			const object = arguments[ i ],
+				uuid = object.uuid,
+				index = indicesByUUID[ uuid ];
+
+			if ( index !== undefined ) {
+
+				delete indicesByUUID[ uuid ];
+
+				if ( index < nCachedObjects ) {
+
+					// object is cached, shrink the CACHED region
+
+					const firstActiveIndex = -- nCachedObjects,
+						lastCachedObject = objects[ firstActiveIndex ],
+						lastIndex = -- nObjects,
+						lastObject = objects[ lastIndex ];
+
+					// last cached object takes this object's place
+					indicesByUUID[ lastCachedObject.uuid ] = index;
+					objects[ index ] = lastCachedObject;
+
+					// last object goes to the activated slot and pop
+					indicesByUUID[ lastObject.uuid ] = firstActiveIndex;
+					objects[ firstActiveIndex ] = lastObject;
+					objects.pop();
+
+					// accounting is done, now do the same for all bindings
+
+					for ( let j = 0, m = nBindings; j !== m; ++ j ) {
+
+						const bindingsForPath = bindings[ j ],
+							lastCached = bindingsForPath[ firstActiveIndex ],
+							last = bindingsForPath[ lastIndex ];
+
+						bindingsForPath[ index ] = lastCached;
+						bindingsForPath[ firstActiveIndex ] = last;
+						bindingsForPath.pop();
+
+					}
+
+				} else {
+
+					// object is active, just swap with the last and pop
+
+					const lastIndex = -- nObjects,
+						lastObject = objects[ lastIndex ];
+
+					if ( lastIndex > 0 ) {
+
+						indicesByUUID[ lastObject.uuid ] = index;
+
+					}
+
+					objects[ index ] = lastObject;
+					objects.pop();
+
+					// accounting is done, now do the same for all bindings
+
+					for ( let j = 0, m = nBindings; j !== m; ++ j ) {
+
+						const bindingsForPath = bindings[ j ];
+
+						bindingsForPath[ index ] = bindingsForPath[ lastIndex ];
+						bindingsForPath.pop();
+
+					}
+
+				} // cached or active
+
+			} // if object is known
+
+		} // for arguments
+
+		this.nCachedObjects_ = nCachedObjects;
+
+	}
+
+	// Internal interface used by befriended PropertyBinding.Composite:
+
+	subscribe_( path, parsedPath ) {
+
+		// returns an array of bindings for the given path that is changed
+		// according to the contained objects in the group
+
+		const indicesByPath = this._bindingsIndicesByPath;
+		let index = indicesByPath[ path ];
+		const bindings = this._bindings;
+
+		if ( index !== undefined ) return bindings[ index ];
+
+		const paths = this._paths,
+			parsedPaths = this._parsedPaths,
+			objects = this._objects,
+			nObjects = objects.length,
+			nCachedObjects = this.nCachedObjects_,
+			bindingsForPath = new Array( nObjects );
+
+		index = bindings.length;
+
+		indicesByPath[ path ] = index;
+
+		paths.push( path );
+		parsedPaths.push( parsedPath );
+		bindings.push( bindingsForPath );
+
+		for ( let i = nCachedObjects, n = objects.length; i !== n; ++ i ) {
+
+			const object = objects[ i ];
+			bindingsForPath[ i ] = new PropertyBinding( object, path, parsedPath );
+
+		}
+
+		return bindingsForPath;
+
+	}
+
+	unsubscribe_( path ) {
+
+		// tells the group to forget about a property path and no longer
+		// update the array previously obtained with 'subscribe_'
+
+		const indicesByPath = this._bindingsIndicesByPath,
+			index = indicesByPath[ path ];
+
+		if ( index !== undefined ) {
+
+			const paths = this._paths,
+				parsedPaths = this._parsedPaths,
+				bindings = this._bindings,
+				lastBindingsIndex = bindings.length - 1,
+				lastBindings = bindings[ lastBindingsIndex ],
+				lastBindingsPath = path[ lastBindingsIndex ];
+
+			indicesByPath[ lastBindingsPath ] = index;
+
+			bindings[ index ] = lastBindings;
+			bindings.pop();
+
+			parsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];
+			parsedPaths.pop();
+
+			paths[ index ] = paths[ lastBindingsIndex ];
+			paths.pop();
+
+		}
+
+	}
+
+}
+
+class AnimationAction {
+
+	constructor( mixer, clip, localRoot = null, blendMode = clip.blendMode ) {
+
+		this._mixer = mixer;
+		this._clip = clip;
+		this._localRoot = localRoot;
+		this.blendMode = blendMode;
+
+		const tracks = clip.tracks,
+			nTracks = tracks.length,
+			interpolants = new Array( nTracks );
+
+		const interpolantSettings = {
+			endingStart: ZeroCurvatureEnding,
+			endingEnd: ZeroCurvatureEnding
+		};
+
+		for ( let i = 0; i !== nTracks; ++ i ) {
+
+			const interpolant = tracks[ i ].createInterpolant( null );
+			interpolants[ i ] = interpolant;
+			interpolant.settings = interpolantSettings;
+
+		}
+
+		this._interpolantSettings = interpolantSettings;
+
+		this._interpolants = interpolants; // bound by the mixer
+
+		// inside: PropertyMixer (managed by the mixer)
+		this._propertyBindings = new Array( nTracks );
+
+		this._cacheIndex = null; // for the memory manager
+		this._byClipCacheIndex = null; // for the memory manager
+
+		this._timeScaleInterpolant = null;
+		this._weightInterpolant = null;
+
+		this.loop = LoopRepeat;
+		this._loopCount = - 1;
+
+		// global mixer time when the action is to be started
+		// it's set back to 'null' upon start of the action
+		this._startTime = null;
+
+		// scaled local time of the action
+		// gets clamped or wrapped to 0..clip.duration according to loop
+		this.time = 0;
+
+		this.timeScale = 1;
+		this._effectiveTimeScale = 1;
+
+		this.weight = 1;
+		this._effectiveWeight = 1;
+
+		this.repetitions = Infinity; // no. of repetitions when looping
+
+		this.paused = false; // true -> zero effective time scale
+		this.enabled = true; // false -> zero effective weight
+
+		this.clampWhenFinished = false;// keep feeding the last frame?
+
+		this.zeroSlopeAtStart = true;// for smooth interpolation w/o separate
+		this.zeroSlopeAtEnd = true;// clips for start, loop and end
+
+	}
+
+	// State & Scheduling
+
+	play() {
+
+		this._mixer._activateAction( this );
+
+		return this;
+
+	}
+
+	stop() {
+
+		this._mixer._deactivateAction( this );
+
+		return this.reset();
+
+	}
+
+	reset() {
+
+		this.paused = false;
+		this.enabled = true;
+
+		this.time = 0; // restart clip
+		this._loopCount = - 1;// forget previous loops
+		this._startTime = null;// forget scheduling
+
+		return this.stopFading().stopWarping();
+
+	}
+
+	isRunning() {
+
+		return this.enabled && ! this.paused && this.timeScale !== 0 &&
+			this._startTime === null && this._mixer._isActiveAction( this );
+
+	}
+
+	// return true when play has been called
+	isScheduled() {
+
+		return this._mixer._isActiveAction( this );
+
+	}
+
+	startAt( time ) {
+
+		this._startTime = time;
+
+		return this;
+
+	}
+
+	setLoop( mode, repetitions ) {
+
+		this.loop = mode;
+		this.repetitions = repetitions;
+
+		return this;
+
+	}
+
+	// Weight
+
+	// set the weight stopping any scheduled fading
+	// although .enabled = false yields an effective weight of zero, this
+	// method does *not* change .enabled, because it would be confusing
+	setEffectiveWeight( weight ) {
+
+		this.weight = weight;
+
+		// note: same logic as when updated at runtime
+		this._effectiveWeight = this.enabled ? weight : 0;
+
+		return this.stopFading();
+
+	}
+
+	// return the weight considering fading and .enabled
+	getEffectiveWeight() {
+
+		return this._effectiveWeight;
+
+	}
+
+	fadeIn( duration ) {
+
+		return this._scheduleFading( duration, 0, 1 );
+
+	}
+
+	fadeOut( duration ) {
+
+		return this._scheduleFading( duration, 1, 0 );
+
+	}
+
+	crossFadeFrom( fadeOutAction, duration, warp ) {
+
+		fadeOutAction.fadeOut( duration );
+		this.fadeIn( duration );
+
+		if ( warp ) {
+
+			const fadeInDuration = this._clip.duration,
+				fadeOutDuration = fadeOutAction._clip.duration,
+
+				startEndRatio = fadeOutDuration / fadeInDuration,
+				endStartRatio = fadeInDuration / fadeOutDuration;
+
+			fadeOutAction.warp( 1.0, startEndRatio, duration );
+			this.warp( endStartRatio, 1.0, duration );
+
+		}
+
+		return this;
+
+	}
+
+	crossFadeTo( fadeInAction, duration, warp ) {
+
+		return fadeInAction.crossFadeFrom( this, duration, warp );
+
+	}
+
+	stopFading() {
+
+		const weightInterpolant = this._weightInterpolant;
+
+		if ( weightInterpolant !== null ) {
+
+			this._weightInterpolant = null;
+			this._mixer._takeBackControlInterpolant( weightInterpolant );
+
+		}
+
+		return this;
+
+	}
+
+	// Time Scale Control
+
+	// set the time scale stopping any scheduled warping
+	// although .paused = true yields an effective time scale of zero, this
+	// method does *not* change .paused, because it would be confusing
+	setEffectiveTimeScale( timeScale ) {
+
+		this.timeScale = timeScale;
+		this._effectiveTimeScale = this.paused ? 0 : timeScale;
+
+		return this.stopWarping();
+
+	}
+
+	// return the time scale considering warping and .paused
+	getEffectiveTimeScale() {
+
+		return this._effectiveTimeScale;
+
+	}
+
+	setDuration( duration ) {
+
+		this.timeScale = this._clip.duration / duration;
+
+		return this.stopWarping();
+
+	}
+
+	syncWith( action ) {
+
+		this.time = action.time;
+		this.timeScale = action.timeScale;
+
+		return this.stopWarping();
+
+	}
+
+	halt( duration ) {
+
+		return this.warp( this._effectiveTimeScale, 0, duration );
+
+	}
+
+	warp( startTimeScale, endTimeScale, duration ) {
+
+		const mixer = this._mixer,
+			now = mixer.time,
+			timeScale = this.timeScale;
+
+		let interpolant = this._timeScaleInterpolant;
+
+		if ( interpolant === null ) {
+
+			interpolant = mixer._lendControlInterpolant();
+			this._timeScaleInterpolant = interpolant;
+
+		}
+
+		const times = interpolant.parameterPositions,
+			values = interpolant.sampleValues;
+
+		times[ 0 ] = now;
+		times[ 1 ] = now + duration;
+
+		values[ 0 ] = startTimeScale / timeScale;
+		values[ 1 ] = endTimeScale / timeScale;
+
+		return this;
+
+	}
+
+	stopWarping() {
+
+		const timeScaleInterpolant = this._timeScaleInterpolant;
+
+		if ( timeScaleInterpolant !== null ) {
+
+			this._timeScaleInterpolant = null;
+			this._mixer._takeBackControlInterpolant( timeScaleInterpolant );
+
+		}
+
+		return this;
+
+	}
+
+	// Object Accessors
+
+	getMixer() {
+
+		return this._mixer;
+
+	}
+
+	getClip() {
+
+		return this._clip;
+
+	}
+
+	getRoot() {
+
+		return this._localRoot || this._mixer._root;
+
+	}
+
+	// Interna
+
+	_update( time, deltaTime, timeDirection, accuIndex ) {
+
+		// called by the mixer
+
+		if ( ! this.enabled ) {
+
+			// call ._updateWeight() to update ._effectiveWeight
+
+			this._updateWeight( time );
+			return;
+
+		}
+
+		const startTime = this._startTime;
+
+		if ( startTime !== null ) {
+
+			// check for scheduled start of action
+
+			const timeRunning = ( time - startTime ) * timeDirection;
+			if ( timeRunning < 0 || timeDirection === 0 ) {
+
+				deltaTime = 0;
+
+			} else {
+
+
+				this._startTime = null; // unschedule
+				deltaTime = timeDirection * timeRunning;
+
+			}
+
+		}
+
+		// apply time scale and advance time
+
+		deltaTime *= this._updateTimeScale( time );
+		const clipTime = this._updateTime( deltaTime );
+
+		// note: _updateTime may disable the action resulting in
+		// an effective weight of 0
+
+		const weight = this._updateWeight( time );
+
+		if ( weight > 0 ) {
+
+			const interpolants = this._interpolants;
+			const propertyMixers = this._propertyBindings;
+
+			switch ( this.blendMode ) {
+
+				case AdditiveAnimationBlendMode:
+
+					for ( let j = 0, m = interpolants.length; j !== m; ++ j ) {
+
+						interpolants[ j ].evaluate( clipTime );
+						propertyMixers[ j ].accumulateAdditive( weight );
+
+					}
+
+					break;
+
+				case NormalAnimationBlendMode:
+				default:
+
+					for ( let j = 0, m = interpolants.length; j !== m; ++ j ) {
+
+						interpolants[ j ].evaluate( clipTime );
+						propertyMixers[ j ].accumulate( accuIndex, weight );
+
+					}
+
+			}
+
+		}
+
+	}
+
+	_updateWeight( time ) {
+
+		let weight = 0;
+
+		if ( this.enabled ) {
+
+			weight = this.weight;
+			const interpolant = this._weightInterpolant;
+
+			if ( interpolant !== null ) {
+
+				const interpolantValue = interpolant.evaluate( time )[ 0 ];
+
+				weight *= interpolantValue;
+
+				if ( time > interpolant.parameterPositions[ 1 ] ) {
+
+					this.stopFading();
+
+					if ( interpolantValue === 0 ) {
+
+						// faded out, disable
+						this.enabled = false;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		this._effectiveWeight = weight;
+		return weight;
+
+	}
+
+	_updateTimeScale( time ) {
+
+		let timeScale = 0;
+
+		if ( ! this.paused ) {
+
+			timeScale = this.timeScale;
+
+			const interpolant = this._timeScaleInterpolant;
+
+			if ( interpolant !== null ) {
+
+				const interpolantValue = interpolant.evaluate( time )[ 0 ];
+
+				timeScale *= interpolantValue;
+
+				if ( time > interpolant.parameterPositions[ 1 ] ) {
+
+					this.stopWarping();
+
+					if ( timeScale === 0 ) {
+
+						// motion has halted, pause
+						this.paused = true;
+
+					} else {
+
+						// warp done - apply final time scale
+						this.timeScale = timeScale;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		this._effectiveTimeScale = timeScale;
+		return timeScale;
+
+	}
+
+	_updateTime( deltaTime ) {
+
+		const duration = this._clip.duration;
+		const loop = this.loop;
+
+		let time = this.time + deltaTime;
+		let loopCount = this._loopCount;
+
+		const pingPong = ( loop === LoopPingPong );
+
+		if ( deltaTime === 0 ) {
+
+			if ( loopCount === - 1 ) return time;
+
+			return ( pingPong && ( loopCount & 1 ) === 1 ) ? duration - time : time;
+
+		}
+
+		if ( loop === LoopOnce ) {
+
+			if ( loopCount === - 1 ) {
+
+				// just started
+
+				this._loopCount = 0;
+				this._setEndings( true, true, false );
+
+			}
+
+			handle_stop: {
+
+				if ( time >= duration ) {
+
+					time = duration;
+
+				} else if ( time < 0 ) {
+
+					time = 0;
+
+				} else {
+
+					this.time = time;
+
+					break handle_stop;
+
+				}
+
+				if ( this.clampWhenFinished ) this.paused = true;
+				else this.enabled = false;
+
+				this.time = time;
+
+				this._mixer.dispatchEvent( {
+					type: 'finished', action: this,
+					direction: deltaTime < 0 ? - 1 : 1
+				} );
+
+			}
+
+		} else { // repetitive Repeat or PingPong
+
+			if ( loopCount === - 1 ) {
+
+				// just started
+
+				if ( deltaTime >= 0 ) {
+
+					loopCount = 0;
+
+					this._setEndings( true, this.repetitions === 0, pingPong );
+
+				} else {
+
+					// when looping in reverse direction, the initial
+					// transition through zero counts as a repetition,
+					// so leave loopCount at -1
+
+					this._setEndings( this.repetitions === 0, true, pingPong );
+
+				}
+
+			}
+
+			if ( time >= duration || time < 0 ) {
+
+				// wrap around
+
+				const loopDelta = Math.floor( time / duration ); // signed
+				time -= duration * loopDelta;
+
+				loopCount += Math.abs( loopDelta );
+
+				const pending = this.repetitions - loopCount;
+
+				if ( pending <= 0 ) {
+
+					// have to stop (switch state, clamp time, fire event)
+
+					if ( this.clampWhenFinished ) this.paused = true;
+					else this.enabled = false;
+
+					time = deltaTime > 0 ? duration : 0;
+
+					this.time = time;
+
+					this._mixer.dispatchEvent( {
+						type: 'finished', action: this,
+						direction: deltaTime > 0 ? 1 : - 1
+					} );
+
+				} else {
+
+					// keep running
+
+					if ( pending === 1 ) {
+
+						// entering the last round
+
+						const atStart = deltaTime < 0;
+						this._setEndings( atStart, ! atStart, pingPong );
+
+					} else {
+
+						this._setEndings( false, false, pingPong );
+
+					}
+
+					this._loopCount = loopCount;
+
+					this.time = time;
+
+					this._mixer.dispatchEvent( {
+						type: 'loop', action: this, loopDelta: loopDelta
+					} );
+
+				}
+
+			} else {
+
+				this.time = time;
+
+			}
+
+			if ( pingPong && ( loopCount & 1 ) === 1 ) {
+
+				// invert time for the "pong round"
+
+				return duration - time;
+
+			}
+
+		}
+
+		return time;
+
+	}
+
+	_setEndings( atStart, atEnd, pingPong ) {
+
+		const settings = this._interpolantSettings;
+
+		if ( pingPong ) {
+
+			settings.endingStart = ZeroSlopeEnding;
+			settings.endingEnd = ZeroSlopeEnding;
+
+		} else {
+
+			// assuming for LoopOnce atStart == atEnd == true
+
+			if ( atStart ) {
+
+				settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;
+
+			} else {
+
+				settings.endingStart = WrapAroundEnding;
+
+			}
+
+			if ( atEnd ) {
+
+				settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;
+
+			} else {
+
+				settings.endingEnd 	 = WrapAroundEnding;
+
+			}
+
+		}
+
+	}
+
+	_scheduleFading( duration, weightNow, weightThen ) {
+
+		const mixer = this._mixer, now = mixer.time;
+		let interpolant = this._weightInterpolant;
+
+		if ( interpolant === null ) {
+
+			interpolant = mixer._lendControlInterpolant();
+			this._weightInterpolant = interpolant;
+
+		}
+
+		const times = interpolant.parameterPositions,
+			values = interpolant.sampleValues;
+
+		times[ 0 ] = now;
+		values[ 0 ] = weightNow;
+		times[ 1 ] = now + duration;
+		values[ 1 ] = weightThen;
+
+		return this;
+
+	}
+
+}
+
+const _controlInterpolantsResultBuffer = new Float32Array( 1 );
+
+
+class AnimationMixer extends EventDispatcher {
+
+	constructor( root ) {
+
+		super();
+
+		this._root = root;
+		this._initMemoryManager();
+		this._accuIndex = 0;
+		this.time = 0;
+		this.timeScale = 1.0;
+
+	}
+
+	_bindAction( action, prototypeAction ) {
+
+		const root = action._localRoot || this._root,
+			tracks = action._clip.tracks,
+			nTracks = tracks.length,
+			bindings = action._propertyBindings,
+			interpolants = action._interpolants,
+			rootUuid = root.uuid,
+			bindingsByRoot = this._bindingsByRootAndName;
+
+		let bindingsByName = bindingsByRoot[ rootUuid ];
+
+		if ( bindingsByName === undefined ) {
+
+			bindingsByName = {};
+			bindingsByRoot[ rootUuid ] = bindingsByName;
+
+		}
+
+		for ( let i = 0; i !== nTracks; ++ i ) {
+
+			const track = tracks[ i ],
+				trackName = track.name;
+
+			let binding = bindingsByName[ trackName ];
+
+			if ( binding !== undefined ) {
+
+				++ binding.referenceCount;
+				bindings[ i ] = binding;
+
+			} else {
+
+				binding = bindings[ i ];
+
+				if ( binding !== undefined ) {
+
+					// existing binding, make sure the cache knows
+
+					if ( binding._cacheIndex === null ) {
+
+						++ binding.referenceCount;
+						this._addInactiveBinding( binding, rootUuid, trackName );
+
+					}
+
+					continue;
+
+				}
+
+				const path = prototypeAction && prototypeAction.
+					_propertyBindings[ i ].binding.parsedPath;
+
+				binding = new PropertyMixer(
+					PropertyBinding.create( root, trackName, path ),
+					track.ValueTypeName, track.getValueSize() );
+
+				++ binding.referenceCount;
+				this._addInactiveBinding( binding, rootUuid, trackName );
+
+				bindings[ i ] = binding;
+
+			}
+
+			interpolants[ i ].resultBuffer = binding.buffer;
+
+		}
+
+	}
+
+	_activateAction( action ) {
+
+		if ( ! this._isActiveAction( action ) ) {
+
+			if ( action._cacheIndex === null ) {
+
+				// this action has been forgotten by the cache, but the user
+				// appears to be still using it -> rebind
+
+				const rootUuid = ( action._localRoot || this._root ).uuid,
+					clipUuid = action._clip.uuid,
+					actionsForClip = this._actionsByClip[ clipUuid ];
+
+				this._bindAction( action,
+					actionsForClip && actionsForClip.knownActions[ 0 ] );
+
+				this._addInactiveAction( action, clipUuid, rootUuid );
+
+			}
+
+			const bindings = action._propertyBindings;
+
+			// increment reference counts / sort out state
+			for ( let i = 0, n = bindings.length; i !== n; ++ i ) {
+
+				const binding = bindings[ i ];
+
+				if ( binding.useCount ++ === 0 ) {
+
+					this._lendBinding( binding );
+					binding.saveOriginalState();
+
+				}
+
+			}
+
+			this._lendAction( action );
+
+		}
+
+	}
+
+	_deactivateAction( action ) {
+
+		if ( this._isActiveAction( action ) ) {
+
+			const bindings = action._propertyBindings;
+
+			// decrement reference counts / sort out state
+			for ( let i = 0, n = bindings.length; i !== n; ++ i ) {
+
+				const binding = bindings[ i ];
+
+				if ( -- binding.useCount === 0 ) {
+
+					binding.restoreOriginalState();
+					this._takeBackBinding( binding );
+
+				}
+
+			}
+
+			this._takeBackAction( action );
+
+		}
+
+	}
+
+	// Memory manager
+
+	_initMemoryManager() {
+
+		this._actions = []; // 'nActiveActions' followed by inactive ones
+		this._nActiveActions = 0;
+
+		this._actionsByClip = {};
+		// inside:
+		// {
+		// 	knownActions: Array< AnimationAction > - used as prototypes
+		// 	actionByRoot: AnimationAction - lookup
+		// }
+
+
+		this._bindings = []; // 'nActiveBindings' followed by inactive ones
+		this._nActiveBindings = 0;
+
+		this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >
+
+
+		this._controlInterpolants = []; // same game as above
+		this._nActiveControlInterpolants = 0;
+
+		const scope = this;
+
+		this.stats = {
+
+			actions: {
+				get total() {
+
+					return scope._actions.length;
+
+				},
+				get inUse() {
+
+					return scope._nActiveActions;
+
+				}
+			},
+			bindings: {
+				get total() {
+
+					return scope._bindings.length;
+
+				},
+				get inUse() {
+
+					return scope._nActiveBindings;
+
+				}
+			},
+			controlInterpolants: {
+				get total() {
+
+					return scope._controlInterpolants.length;
+
+				},
+				get inUse() {
+
+					return scope._nActiveControlInterpolants;
+
+				}
+			}
+
+		};
+
+	}
+
+	// Memory management for AnimationAction objects
+
+	_isActiveAction( action ) {
+
+		const index = action._cacheIndex;
+		return index !== null && index < this._nActiveActions;
+
+	}
+
+	_addInactiveAction( action, clipUuid, rootUuid ) {
+
+		const actions = this._actions,
+			actionsByClip = this._actionsByClip;
+
+		let actionsForClip = actionsByClip[ clipUuid ];
+
+		if ( actionsForClip === undefined ) {
+
+			actionsForClip = {
+
+				knownActions: [ action ],
+				actionByRoot: {}
+
+			};
+
+			action._byClipCacheIndex = 0;
+
+			actionsByClip[ clipUuid ] = actionsForClip;
+
+		} else {
+
+			const knownActions = actionsForClip.knownActions;
+
+			action._byClipCacheIndex = knownActions.length;
+			knownActions.push( action );
+
+		}
+
+		action._cacheIndex = actions.length;
+		actions.push( action );
+
+		actionsForClip.actionByRoot[ rootUuid ] = action;
+
+	}
+
+	_removeInactiveAction( action ) {
+
+		const actions = this._actions,
+			lastInactiveAction = actions[ actions.length - 1 ],
+			cacheIndex = action._cacheIndex;
+
+		lastInactiveAction._cacheIndex = cacheIndex;
+		actions[ cacheIndex ] = lastInactiveAction;
+		actions.pop();
+
+		action._cacheIndex = null;
+
+
+		const clipUuid = action._clip.uuid,
+			actionsByClip = this._actionsByClip,
+			actionsForClip = actionsByClip[ clipUuid ],
+			knownActionsForClip = actionsForClip.knownActions,
+
+			lastKnownAction =
+				knownActionsForClip[ knownActionsForClip.length - 1 ],
+
+			byClipCacheIndex = action._byClipCacheIndex;
+
+		lastKnownAction._byClipCacheIndex = byClipCacheIndex;
+		knownActionsForClip[ byClipCacheIndex ] = lastKnownAction;
+		knownActionsForClip.pop();
+
+		action._byClipCacheIndex = null;
+
+
+		const actionByRoot = actionsForClip.actionByRoot,
+			rootUuid = ( action._localRoot || this._root ).uuid;
+
+		delete actionByRoot[ rootUuid ];
+
+		if ( knownActionsForClip.length === 0 ) {
+
+			delete actionsByClip[ clipUuid ];
+
+		}
+
+		this._removeInactiveBindingsForAction( action );
+
+	}
+
+	_removeInactiveBindingsForAction( action ) {
+
+		const bindings = action._propertyBindings;
+
+		for ( let i = 0, n = bindings.length; i !== n; ++ i ) {
+
+			const binding = bindings[ i ];
+
+			if ( -- binding.referenceCount === 0 ) {
+
+				this._removeInactiveBinding( binding );
+
+			}
+
+		}
+
+	}
+
+	_lendAction( action ) {
+
+		// [ active actions |  inactive actions  ]
+		// [  active actions >| inactive actions ]
+		//                 s        a
+		//                  <-swap->
+		//                 a        s
+
+		const actions = this._actions,
+			prevIndex = action._cacheIndex,
+
+			lastActiveIndex = this._nActiveActions ++,
+
+			firstInactiveAction = actions[ lastActiveIndex ];
+
+		action._cacheIndex = lastActiveIndex;
+		actions[ lastActiveIndex ] = action;
+
+		firstInactiveAction._cacheIndex = prevIndex;
+		actions[ prevIndex ] = firstInactiveAction;
+
+	}
+
+	_takeBackAction( action ) {
+
+		// [  active actions  | inactive actions ]
+		// [ active actions |< inactive actions  ]
+		//        a        s
+		//         <-swap->
+		//        s        a
+
+		const actions = this._actions,
+			prevIndex = action._cacheIndex,
+
+			firstInactiveIndex = -- this._nActiveActions,
+
+			lastActiveAction = actions[ firstInactiveIndex ];
+
+		action._cacheIndex = firstInactiveIndex;
+		actions[ firstInactiveIndex ] = action;
+
+		lastActiveAction._cacheIndex = prevIndex;
+		actions[ prevIndex ] = lastActiveAction;
+
+	}
+
+	// Memory management for PropertyMixer objects
+
+	_addInactiveBinding( binding, rootUuid, trackName ) {
+
+		const bindingsByRoot = this._bindingsByRootAndName,
+			bindings = this._bindings;
+
+		let bindingByName = bindingsByRoot[ rootUuid ];
+
+		if ( bindingByName === undefined ) {
+
+			bindingByName = {};
+			bindingsByRoot[ rootUuid ] = bindingByName;
+
+		}
+
+		bindingByName[ trackName ] = binding;
+
+		binding._cacheIndex = bindings.length;
+		bindings.push( binding );
+
+	}
+
+	_removeInactiveBinding( binding ) {
+
+		const bindings = this._bindings,
+			propBinding = binding.binding,
+			rootUuid = propBinding.rootNode.uuid,
+			trackName = propBinding.path,
+			bindingsByRoot = this._bindingsByRootAndName,
+			bindingByName = bindingsByRoot[ rootUuid ],
+
+			lastInactiveBinding = bindings[ bindings.length - 1 ],
+			cacheIndex = binding._cacheIndex;
+
+		lastInactiveBinding._cacheIndex = cacheIndex;
+		bindings[ cacheIndex ] = lastInactiveBinding;
+		bindings.pop();
+
+		delete bindingByName[ trackName ];
+
+		if ( Object.keys( bindingByName ).length === 0 ) {
+
+			delete bindingsByRoot[ rootUuid ];
+
+		}
+
+	}
+
+	_lendBinding( binding ) {
+
+		const bindings = this._bindings,
+			prevIndex = binding._cacheIndex,
+
+			lastActiveIndex = this._nActiveBindings ++,
+
+			firstInactiveBinding = bindings[ lastActiveIndex ];
+
+		binding._cacheIndex = lastActiveIndex;
+		bindings[ lastActiveIndex ] = binding;
+
+		firstInactiveBinding._cacheIndex = prevIndex;
+		bindings[ prevIndex ] = firstInactiveBinding;
+
+	}
+
+	_takeBackBinding( binding ) {
+
+		const bindings = this._bindings,
+			prevIndex = binding._cacheIndex,
+
+			firstInactiveIndex = -- this._nActiveBindings,
+
+			lastActiveBinding = bindings[ firstInactiveIndex ];
+
+		binding._cacheIndex = firstInactiveIndex;
+		bindings[ firstInactiveIndex ] = binding;
+
+		lastActiveBinding._cacheIndex = prevIndex;
+		bindings[ prevIndex ] = lastActiveBinding;
+
+	}
+
+
+	// Memory management of Interpolants for weight and time scale
+
+	_lendControlInterpolant() {
+
+		const interpolants = this._controlInterpolants,
+			lastActiveIndex = this._nActiveControlInterpolants ++;
+
+		let interpolant = interpolants[ lastActiveIndex ];
+
+		if ( interpolant === undefined ) {
+
+			interpolant = new LinearInterpolant(
+				new Float32Array( 2 ), new Float32Array( 2 ),
+				1, _controlInterpolantsResultBuffer );
+
+			interpolant.__cacheIndex = lastActiveIndex;
+			interpolants[ lastActiveIndex ] = interpolant;
+
+		}
+
+		return interpolant;
+
+	}
+
+	_takeBackControlInterpolant( interpolant ) {
+
+		const interpolants = this._controlInterpolants,
+			prevIndex = interpolant.__cacheIndex,
+
+			firstInactiveIndex = -- this._nActiveControlInterpolants,
+
+			lastActiveInterpolant = interpolants[ firstInactiveIndex ];
+
+		interpolant.__cacheIndex = firstInactiveIndex;
+		interpolants[ firstInactiveIndex ] = interpolant;
+
+		lastActiveInterpolant.__cacheIndex = prevIndex;
+		interpolants[ prevIndex ] = lastActiveInterpolant;
+
+	}
+
+	// return an action for a clip optionally using a custom root target
+	// object (this method allocates a lot of dynamic memory in case a
+	// previously unknown clip/root combination is specified)
+	clipAction( clip, optionalRoot, blendMode ) {
+
+		const root = optionalRoot || this._root,
+			rootUuid = root.uuid;
+
+		let clipObject = typeof clip === 'string' ? AnimationClip.findByName( root, clip ) : clip;
+
+		const clipUuid = clipObject !== null ? clipObject.uuid : clip;
+
+		const actionsForClip = this._actionsByClip[ clipUuid ];
+		let prototypeAction = null;
+
+		if ( blendMode === undefined ) {
+
+			if ( clipObject !== null ) {
+
+				blendMode = clipObject.blendMode;
+
+			} else {
+
+				blendMode = NormalAnimationBlendMode;
+
+			}
+
+		}
+
+		if ( actionsForClip !== undefined ) {
+
+			const existingAction = actionsForClip.actionByRoot[ rootUuid ];
+
+			if ( existingAction !== undefined && existingAction.blendMode === blendMode ) {
+
+				return existingAction;
+
+			}
+
+			// we know the clip, so we don't have to parse all
+			// the bindings again but can just copy
+			prototypeAction = actionsForClip.knownActions[ 0 ];
+
+			// also, take the clip from the prototype action
+			if ( clipObject === null )
+				clipObject = prototypeAction._clip;
+
+		}
+
+		// clip must be known when specified via string
+		if ( clipObject === null ) return null;
+
+		// allocate all resources required to run it
+		const newAction = new AnimationAction( this, clipObject, optionalRoot, blendMode );
+
+		this._bindAction( newAction, prototypeAction );
+
+		// and make the action known to the memory manager
+		this._addInactiveAction( newAction, clipUuid, rootUuid );
+
+		return newAction;
+
+	}
+
+	// get an existing action
+	existingAction( clip, optionalRoot ) {
+
+		const root = optionalRoot || this._root,
+			rootUuid = root.uuid,
+
+			clipObject = typeof clip === 'string' ?
+				AnimationClip.findByName( root, clip ) : clip,
+
+			clipUuid = clipObject ? clipObject.uuid : clip,
+
+			actionsForClip = this._actionsByClip[ clipUuid ];
+
+		if ( actionsForClip !== undefined ) {
+
+			return actionsForClip.actionByRoot[ rootUuid ] || null;
+
+		}
+
+		return null;
+
+	}
+
+	// deactivates all previously scheduled actions
+	stopAllAction() {
+
+		const actions = this._actions,
+			nActions = this._nActiveActions;
+
+		for ( let i = nActions - 1; i >= 0; -- i ) {
+
+			actions[ i ].stop();
+
+		}
+
+		return this;
+
+	}
+
+	// advance the time and update apply the animation
+	update( deltaTime ) {
+
+		deltaTime *= this.timeScale;
+
+		const actions = this._actions,
+			nActions = this._nActiveActions,
+
+			time = this.time += deltaTime,
+			timeDirection = Math.sign( deltaTime ),
+
+			accuIndex = this._accuIndex ^= 1;
+
+		// run active actions
+
+		for ( let i = 0; i !== nActions; ++ i ) {
+
+			const action = actions[ i ];
+
+			action._update( time, deltaTime, timeDirection, accuIndex );
+
+		}
+
+		// update scene graph
+
+		const bindings = this._bindings,
+			nBindings = this._nActiveBindings;
+
+		for ( let i = 0; i !== nBindings; ++ i ) {
+
+			bindings[ i ].apply( accuIndex );
+
+		}
+
+		return this;
+
+	}
+
+	// Allows you to seek to a specific time in an animation.
+	setTime( timeInSeconds ) {
+
+		this.time = 0; // Zero out time attribute for AnimationMixer object;
+		for ( let i = 0; i < this._actions.length; i ++ ) {
+
+			this._actions[ i ].time = 0; // Zero out time attribute for all associated AnimationAction objects.
+
+		}
+
+		return this.update( timeInSeconds ); // Update used to set exact time. Returns "this" AnimationMixer object.
+
+	}
+
+	// return this mixer's root target object
+	getRoot() {
+
+		return this._root;
+
+	}
+
+	// free all resources specific to a particular clip
+	uncacheClip( clip ) {
+
+		const actions = this._actions,
+			clipUuid = clip.uuid,
+			actionsByClip = this._actionsByClip,
+			actionsForClip = actionsByClip[ clipUuid ];
+
+		if ( actionsForClip !== undefined ) {
+
+			// note: just calling _removeInactiveAction would mess up the
+			// iteration state and also require updating the state we can
+			// just throw away
+
+			const actionsToRemove = actionsForClip.knownActions;
+
+			for ( let i = 0, n = actionsToRemove.length; i !== n; ++ i ) {
+
+				const action = actionsToRemove[ i ];
+
+				this._deactivateAction( action );
+
+				const cacheIndex = action._cacheIndex,
+					lastInactiveAction = actions[ actions.length - 1 ];
+
+				action._cacheIndex = null;
+				action._byClipCacheIndex = null;
+
+				lastInactiveAction._cacheIndex = cacheIndex;
+				actions[ cacheIndex ] = lastInactiveAction;
+				actions.pop();
+
+				this._removeInactiveBindingsForAction( action );
+
+			}
+
+			delete actionsByClip[ clipUuid ];
+
+		}
+
+	}
+
+	// free all resources specific to a particular root target object
+	uncacheRoot( root ) {
+
+		const rootUuid = root.uuid,
+			actionsByClip = this._actionsByClip;
+
+		for ( const clipUuid in actionsByClip ) {
+
+			const actionByRoot = actionsByClip[ clipUuid ].actionByRoot,
+				action = actionByRoot[ rootUuid ];
+
+			if ( action !== undefined ) {
+
+				this._deactivateAction( action );
+				this._removeInactiveAction( action );
+
+			}
+
+		}
+
+		const bindingsByRoot = this._bindingsByRootAndName,
+			bindingByName = bindingsByRoot[ rootUuid ];
+
+		if ( bindingByName !== undefined ) {
+
+			for ( const trackName in bindingByName ) {
+
+				const binding = bindingByName[ trackName ];
+				binding.restoreOriginalState();
+				this._removeInactiveBinding( binding );
+
+			}
+
+		}
+
+	}
+
+	// remove a targeted clip from the cache
+	uncacheAction( clip, optionalRoot ) {
+
+		const action = this.existingAction( clip, optionalRoot );
+
+		if ( action !== null ) {
+
+			this._deactivateAction( action );
+			this._removeInactiveAction( action );
+
+		}
+
+	}
+
+}
+
+class Uniform {
+
+	constructor( value ) {
+
+		this.value = value;
+
+	}
+
+	clone() {
+
+		return new Uniform( this.value.clone === undefined ? this.value : this.value.clone() );
+
+	}
+
+}
+
+let _id = 0;
+
+class UniformsGroup extends EventDispatcher {
+
+	constructor() {
+
+		super();
+
+		this.isUniformsGroup = true;
+
+		Object.defineProperty( this, 'id', { value: _id ++ } );
+
+		this.name = '';
+
+		this.usage = StaticDrawUsage;
+		this.uniforms = [];
+
+	}
+
+	add( uniform ) {
+
+		this.uniforms.push( uniform );
+
+		return this;
+
+	}
+
+	remove( uniform ) {
+
+		const index = this.uniforms.indexOf( uniform );
+
+		if ( index !== - 1 ) this.uniforms.splice( index, 1 );
+
+		return this;
+
+	}
+
+	setName( name ) {
+
+		this.name = name;
+
+		return this;
+
+	}
+
+	setUsage( value ) {
+
+		this.usage = value;
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+		return this;
+
+	}
+
+	copy( source ) {
+
+		this.name = source.name;
+		this.usage = source.usage;
+
+		const uniformsSource = source.uniforms;
+
+		this.uniforms.length = 0;
+
+		for ( let i = 0, l = uniformsSource.length; i < l; i ++ ) {
+
+			const uniforms = Array.isArray( uniformsSource[ i ] ) ? uniformsSource[ i ] : [ uniformsSource[ i ] ];
+
+			for ( let j = 0; j < uniforms.length; j ++ ) {
+
+				this.uniforms.push( uniforms[ j ].clone() );
+
+			}
+
+		}
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+class InstancedInterleavedBuffer extends InterleavedBuffer {
+
+	constructor( array, stride, meshPerAttribute = 1 ) {
+
+		super( array, stride );
+
+		this.isInstancedInterleavedBuffer = true;
+
+		this.meshPerAttribute = meshPerAttribute;
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.meshPerAttribute = source.meshPerAttribute;
+
+		return this;
+
+	}
+
+	clone( data ) {
+
+		const ib = super.clone( data );
+
+		ib.meshPerAttribute = this.meshPerAttribute;
+
+		return ib;
+
+	}
+
+	toJSON( data ) {
+
+		const json = super.toJSON( data );
+
+		json.isInstancedInterleavedBuffer = true;
+		json.meshPerAttribute = this.meshPerAttribute;
+
+		return json;
+
+	}
+
+}
+
+class GLBufferAttribute {
+
+	constructor( buffer, type, itemSize, elementSize, count ) {
+
+		this.isGLBufferAttribute = true;
+
+		this.name = '';
+
+		this.buffer = buffer;
+		this.type = type;
+		this.itemSize = itemSize;
+		this.elementSize = elementSize;
+		this.count = count;
+
+		this.version = 0;
+
+	}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+	setBuffer( buffer ) {
+
+		this.buffer = buffer;
+
+		return this;
+
+	}
+
+	setType( type, elementSize ) {
+
+		this.type = type;
+		this.elementSize = elementSize;
+
+		return this;
+
+	}
+
+	setItemSize( itemSize ) {
+
+		this.itemSize = itemSize;
+
+		return this;
+
+	}
+
+	setCount( count ) {
+
+		this.count = count;
+
+		return this;
+
+	}
+
+}
+
+class Raycaster {
+
+	constructor( origin, direction, near = 0, far = Infinity ) {
+
+		this.ray = new Ray( origin, direction );
+		// direction is assumed to be normalized (for accurate distance calculations)
+
+		this.near = near;
+		this.far = far;
+		this.camera = null;
+		this.layers = new Layers();
+
+		this.params = {
+			Mesh: {},
+			Line: { threshold: 1 },
+			LOD: {},
+			Points: { threshold: 1 },
+			Sprite: {}
+		};
+
+	}
+
+	set( origin, direction ) {
+
+		// direction is assumed to be normalized (for accurate distance calculations)
+
+		this.ray.set( origin, direction );
+
+	}
+
+	setFromCamera( coords, camera ) {
+
+		if ( camera.isPerspectiveCamera ) {
+
+			this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
+			this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();
+			this.camera = camera;
+
+		} else if ( camera.isOrthographicCamera ) {
+
+			this.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera
+			this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );
+			this.camera = camera;
+
+		} else {
+
+			console.error( 'THREE.Raycaster: Unsupported camera type: ' + camera.type );
+
+		}
+
+	}
+
+	intersectObject( object, recursive = true, intersects = [] ) {
+
+		intersectObject( object, this, intersects, recursive );
+
+		intersects.sort( ascSort );
+
+		return intersects;
+
+	}
+
+	intersectObjects( objects, recursive = true, intersects = [] ) {
+
+		for ( let i = 0, l = objects.length; i < l; i ++ ) {
+
+			intersectObject( objects[ i ], this, intersects, recursive );
+
+		}
+
+		intersects.sort( ascSort );
+
+		return intersects;
+
+	}
+
+}
+
+function ascSort( a, b ) {
+
+	return a.distance - b.distance;
+
+}
+
+function intersectObject( object, raycaster, intersects, recursive ) {
+
+	if ( object.layers.test( raycaster.layers ) ) {
+
+		object.raycast( raycaster, intersects );
+
+	}
+
+	if ( recursive === true ) {
+
+		const children = object.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			intersectObject( children[ i ], raycaster, intersects, true );
+
+		}
+
+	}
+
+}
+
+/**
+ * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system
+ *
+ * The polar angle (phi) is measured from the positive y-axis. The positive y-axis is up.
+ * The azimuthal angle (theta) is measured from the positive z-axis.
+ */
+
+
+class Spherical {
+
+	constructor( radius = 1, phi = 0, theta = 0 ) {
+
+		this.radius = radius;
+		this.phi = phi; // polar angle
+		this.theta = theta; // azimuthal angle
+
+		return this;
+
+	}
+
+	set( radius, phi, theta ) {
+
+		this.radius = radius;
+		this.phi = phi;
+		this.theta = theta;
+
+		return this;
+
+	}
+
+	copy( other ) {
+
+		this.radius = other.radius;
+		this.phi = other.phi;
+		this.theta = other.theta;
+
+		return this;
+
+	}
+
+	// restrict phi to be between EPS and PI-EPS
+	makeSafe() {
+
+		const EPS = 0.000001;
+		this.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) );
+
+		return this;
+
+	}
+
+	setFromVector3( v ) {
+
+		return this.setFromCartesianCoords( v.x, v.y, v.z );
+
+	}
+
+	setFromCartesianCoords( x, y, z ) {
+
+		this.radius = Math.sqrt( x * x + y * y + z * z );
+
+		if ( this.radius === 0 ) {
+
+			this.theta = 0;
+			this.phi = 0;
+
+		} else {
+
+			this.theta = Math.atan2( x, z );
+			this.phi = Math.acos( clamp( y / this.radius, - 1, 1 ) );
+
+		}
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+/**
+ * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system
+ */
+
+class Cylindrical {
+
+	constructor( radius = 1, theta = 0, y = 0 ) {
+
+		this.radius = radius; // distance from the origin to a point in the x-z plane
+		this.theta = theta; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis
+		this.y = y; // height above the x-z plane
+
+		return this;
+
+	}
+
+	set( radius, theta, y ) {
+
+		this.radius = radius;
+		this.theta = theta;
+		this.y = y;
+
+		return this;
+
+	}
+
+	copy( other ) {
+
+		this.radius = other.radius;
+		this.theta = other.theta;
+		this.y = other.y;
+
+		return this;
+
+	}
+
+	setFromVector3( v ) {
+
+		return this.setFromCartesianCoords( v.x, v.y, v.z );
+
+	}
+
+	setFromCartesianCoords( x, y, z ) {
+
+		this.radius = Math.sqrt( x * x + z * z );
+		this.theta = Math.atan2( x, z );
+		this.y = y;
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+const _vector$4 = /*@__PURE__*/ new Vector2();
+
+class Box2 {
+
+	constructor( min = new Vector2( + Infinity, + Infinity ), max = new Vector2( - Infinity, - Infinity ) ) {
+
+		this.isBox2 = true;
+
+		this.min = min;
+		this.max = max;
+
+	}
+
+	set( min, max ) {
+
+		this.min.copy( min );
+		this.max.copy( max );
+
+		return this;
+
+	}
+
+	setFromPoints( points ) {
+
+		this.makeEmpty();
+
+		for ( let i = 0, il = points.length; i < il; i ++ ) {
+
+			this.expandByPoint( points[ i ] );
+
+		}
+
+		return this;
+
+	}
+
+	setFromCenterAndSize( center, size ) {
+
+		const halfSize = _vector$4.copy( size ).multiplyScalar( 0.5 );
+		this.min.copy( center ).sub( halfSize );
+		this.max.copy( center ).add( halfSize );
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+	copy( box ) {
+
+		this.min.copy( box.min );
+		this.max.copy( box.max );
+
+		return this;
+
+	}
+
+	makeEmpty() {
+
+		this.min.x = this.min.y = + Infinity;
+		this.max.x = this.max.y = - Infinity;
+
+		return this;
+
+	}
+
+	isEmpty() {
+
+		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
+
+		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );
+
+	}
+
+	getCenter( target ) {
+
+		return this.isEmpty() ? target.set( 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
+
+	}
+
+	getSize( target ) {
+
+		return this.isEmpty() ? target.set( 0, 0 ) : target.subVectors( this.max, this.min );
+
+	}
+
+	expandByPoint( point ) {
+
+		this.min.min( point );
+		this.max.max( point );
+
+		return this;
+
+	}
+
+	expandByVector( vector ) {
+
+		this.min.sub( vector );
+		this.max.add( vector );
+
+		return this;
+
+	}
+
+	expandByScalar( scalar ) {
+
+		this.min.addScalar( - scalar );
+		this.max.addScalar( scalar );
+
+		return this;
+
+	}
+
+	containsPoint( point ) {
+
+		return point.x < this.min.x || point.x > this.max.x ||
+			point.y < this.min.y || point.y > this.max.y ? false : true;
+
+	}
+
+	containsBox( box ) {
+
+		return this.min.x <= box.min.x && box.max.x <= this.max.x &&
+			this.min.y <= box.min.y && box.max.y <= this.max.y;
+
+	}
+
+	getParameter( point, target ) {
+
+		// This can potentially have a divide by zero if the box
+		// has a size dimension of 0.
+
+		return target.set(
+			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
+			( point.y - this.min.y ) / ( this.max.y - this.min.y )
+		);
+
+	}
+
+	intersectsBox( box ) {
+
+		// using 4 splitting planes to rule out intersections
+
+		return box.max.x < this.min.x || box.min.x > this.max.x ||
+			box.max.y < this.min.y || box.min.y > this.max.y ? false : true;
+
+	}
+
+	clampPoint( point, target ) {
+
+		return target.copy( point ).clamp( this.min, this.max );
+
+	}
+
+	distanceToPoint( point ) {
+
+		return this.clampPoint( point, _vector$4 ).distanceTo( point );
+
+	}
+
+	intersect( box ) {
+
+		this.min.max( box.min );
+		this.max.min( box.max );
+
+		if ( this.isEmpty() ) this.makeEmpty();
+
+		return this;
+
+	}
+
+	union( box ) {
+
+		this.min.min( box.min );
+		this.max.max( box.max );
+
+		return this;
+
+	}
+
+	translate( offset ) {
+
+		this.min.add( offset );
+		this.max.add( offset );
+
+		return this;
+
+	}
+
+	equals( box ) {
+
+		return box.min.equals( this.min ) && box.max.equals( this.max );
+
+	}
+
+}
+
+const _startP = /*@__PURE__*/ new Vector3();
+const _startEnd = /*@__PURE__*/ new Vector3();
+
+class Line3 {
+
+	constructor( start = new Vector3(), end = new Vector3() ) {
+
+		this.start = start;
+		this.end = end;
+
+	}
+
+	set( start, end ) {
+
+		this.start.copy( start );
+		this.end.copy( end );
+
+		return this;
+
+	}
+
+	copy( line ) {
+
+		this.start.copy( line.start );
+		this.end.copy( line.end );
+
+		return this;
+
+	}
+
+	getCenter( target ) {
+
+		return target.addVectors( this.start, this.end ).multiplyScalar( 0.5 );
+
+	}
+
+	delta( target ) {
+
+		return target.subVectors( this.end, this.start );
+
+	}
+
+	distanceSq() {
+
+		return this.start.distanceToSquared( this.end );
+
+	}
+
+	distance() {
+
+		return this.start.distanceTo( this.end );
+
+	}
+
+	at( t, target ) {
+
+		return this.delta( target ).multiplyScalar( t ).add( this.start );
+
+	}
+
+	closestPointToPointParameter( point, clampToLine ) {
+
+		_startP.subVectors( point, this.start );
+		_startEnd.subVectors( this.end, this.start );
+
+		const startEnd2 = _startEnd.dot( _startEnd );
+		const startEnd_startP = _startEnd.dot( _startP );
+
+		let t = startEnd_startP / startEnd2;
+
+		if ( clampToLine ) {
+
+			t = clamp( t, 0, 1 );
+
+		}
+
+		return t;
+
+	}
+
+	closestPointToPoint( point, clampToLine, target ) {
+
+		const t = this.closestPointToPointParameter( point, clampToLine );
+
+		return this.delta( target ).multiplyScalar( t ).add( this.start );
+
+	}
+
+	applyMatrix4( matrix ) {
+
+		this.start.applyMatrix4( matrix );
+		this.end.applyMatrix4( matrix );
+
+		return this;
+
+	}
+
+	equals( line ) {
+
+		return line.start.equals( this.start ) && line.end.equals( this.end );
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+const _vector$3 = /*@__PURE__*/ new Vector3();
+
+class SpotLightHelper extends Object3D {
+
+	constructor( light, color ) {
+
+		super();
+
+		this.light = light;
+
+		this.matrix = light.matrixWorld;
+		this.matrixAutoUpdate = false;
+
+		this.color = color;
+
+		this.type = 'SpotLightHelper';
+
+		const geometry = new BufferGeometry();
+
+		const positions = [
+			0, 0, 0, 	0, 0, 1,
+			0, 0, 0, 	1, 0, 1,
+			0, 0, 0,	- 1, 0, 1,
+			0, 0, 0, 	0, 1, 1,
+			0, 0, 0, 	0, - 1, 1
+		];
+
+		for ( let i = 0, j = 1, l = 32; i < l; i ++, j ++ ) {
+
+			const p1 = ( i / l ) * Math.PI * 2;
+			const p2 = ( j / l ) * Math.PI * 2;
+
+			positions.push(
+				Math.cos( p1 ), Math.sin( p1 ), 1,
+				Math.cos( p2 ), Math.sin( p2 ), 1
+			);
+
+		}
+
+		geometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+
+		const material = new LineBasicMaterial( { fog: false, toneMapped: false } );
+
+		this.cone = new LineSegments( geometry, material );
+		this.add( this.cone );
+
+		this.update();
+
+	}
+
+	dispose() {
+
+		this.cone.geometry.dispose();
+		this.cone.material.dispose();
+
+	}
+
+	update() {
+
+		this.light.updateWorldMatrix( true, false );
+		this.light.target.updateWorldMatrix( true, false );
+
+		const coneLength = this.light.distance ? this.light.distance : 1000;
+		const coneWidth = coneLength * Math.tan( this.light.angle );
+
+		this.cone.scale.set( coneWidth, coneWidth, coneLength );
+
+		_vector$3.setFromMatrixPosition( this.light.target.matrixWorld );
+
+		this.cone.lookAt( _vector$3 );
+
+		if ( this.color !== undefined ) {
+
+			this.cone.material.color.set( this.color );
+
+		} else {
+
+			this.cone.material.color.copy( this.light.color );
+
+		}
+
+	}
+
+}
+
+const _vector$2 = /*@__PURE__*/ new Vector3();
+const _boneMatrix = /*@__PURE__*/ new Matrix4();
+const _matrixWorldInv = /*@__PURE__*/ new Matrix4();
+
+
+class SkeletonHelper extends LineSegments {
+
+	constructor( object ) {
+
+		const bones = getBoneList( object );
+
+		const geometry = new BufferGeometry();
+
+		const vertices = [];
+		const colors = [];
+
+		const color1 = new Color( 0, 0, 1 );
+		const color2 = new Color( 0, 1, 0 );
+
+		for ( let i = 0; i < bones.length; i ++ ) {
+
+			const bone = bones[ i ];
+
+			if ( bone.parent && bone.parent.isBone ) {
+
+				vertices.push( 0, 0, 0 );
+				vertices.push( 0, 0, 0 );
+				colors.push( color1.r, color1.g, color1.b );
+				colors.push( color2.r, color2.g, color2.b );
+
+			}
+
+		}
+
+		geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		geometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );
+
+		const material = new LineBasicMaterial( { vertexColors: true, depthTest: false, depthWrite: false, toneMapped: false, transparent: true } );
+
+		super( geometry, material );
+
+		this.isSkeletonHelper = true;
+
+		this.type = 'SkeletonHelper';
+
+		this.root = object;
+		this.bones = bones;
+
+		this.matrix = object.matrixWorld;
+		this.matrixAutoUpdate = false;
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		const bones = this.bones;
+
+		const geometry = this.geometry;
+		const position = geometry.getAttribute( 'position' );
+
+		_matrixWorldInv.copy( this.root.matrixWorld ).invert();
+
+		for ( let i = 0, j = 0; i < bones.length; i ++ ) {
+
+			const bone = bones[ i ];
+
+			if ( bone.parent && bone.parent.isBone ) {
+
+				_boneMatrix.multiplyMatrices( _matrixWorldInv, bone.matrixWorld );
+				_vector$2.setFromMatrixPosition( _boneMatrix );
+				position.setXYZ( j, _vector$2.x, _vector$2.y, _vector$2.z );
+
+				_boneMatrix.multiplyMatrices( _matrixWorldInv, bone.parent.matrixWorld );
+				_vector$2.setFromMatrixPosition( _boneMatrix );
+				position.setXYZ( j + 1, _vector$2.x, _vector$2.y, _vector$2.z );
+
+				j += 2;
+
+			}
+
+		}
+
+		geometry.getAttribute( 'position' ).needsUpdate = true;
+
+		super.updateMatrixWorld( force );
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+
+function getBoneList( object ) {
+
+	const boneList = [];
+
+	if ( object.isBone === true ) {
+
+		boneList.push( object );
+
+	}
+
+	for ( let i = 0; i < object.children.length; i ++ ) {
+
+		boneList.push.apply( boneList, getBoneList( object.children[ i ] ) );
+
+	}
+
+	return boneList;
+
+}
+
+class PointLightHelper extends Mesh {
+
+	constructor( light, sphereSize, color ) {
+
+		const geometry = new SphereGeometry( sphereSize, 4, 2 );
+		const material = new MeshBasicMaterial( { wireframe: true, fog: false, toneMapped: false } );
+
+		super( geometry, material );
+
+		this.light = light;
+
+		this.color = color;
+
+		this.type = 'PointLightHelper';
+
+		this.matrix = this.light.matrixWorld;
+		this.matrixAutoUpdate = false;
+
+		this.update();
+
+
+		/*
+	// TODO: delete this comment?
+	const distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );
+	const distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );
+
+	this.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );
+	this.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );
+
+	const d = light.distance;
+
+	if ( d === 0.0 ) {
+
+		this.lightDistance.visible = false;
+
+	} else {
+
+		this.lightDistance.scale.set( d, d, d );
+
+	}
+
+	this.add( this.lightDistance );
+	*/
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+	update() {
+
+		this.light.updateWorldMatrix( true, false );
+
+		if ( this.color !== undefined ) {
+
+			this.material.color.set( this.color );
+
+		} else {
+
+			this.material.color.copy( this.light.color );
+
+		}
+
+		/*
+		const d = this.light.distance;
+
+		if ( d === 0.0 ) {
+
+			this.lightDistance.visible = false;
+
+		} else {
+
+			this.lightDistance.visible = true;
+			this.lightDistance.scale.set( d, d, d );
+
+		}
+		*/
+
+	}
+
+}
+
+const _vector$1 = /*@__PURE__*/ new Vector3();
+const _color1 = /*@__PURE__*/ new Color();
+const _color2 = /*@__PURE__*/ new Color();
+
+class HemisphereLightHelper extends Object3D {
+
+	constructor( light, size, color ) {
+
+		super();
+
+		this.light = light;
+
+		this.matrix = light.matrixWorld;
+		this.matrixAutoUpdate = false;
+
+		this.color = color;
+
+		this.type = 'HemisphereLightHelper';
+
+		const geometry = new OctahedronGeometry( size );
+		geometry.rotateY( Math.PI * 0.5 );
+
+		this.material = new MeshBasicMaterial( { wireframe: true, fog: false, toneMapped: false } );
+		if ( this.color === undefined ) this.material.vertexColors = true;
+
+		const position = geometry.getAttribute( 'position' );
+		const colors = new Float32Array( position.count * 3 );
+
+		geometry.setAttribute( 'color', new BufferAttribute( colors, 3 ) );
+
+		this.add( new Mesh( geometry, this.material ) );
+
+		this.update();
+
+	}
+
+	dispose() {
+
+		this.children[ 0 ].geometry.dispose();
+		this.children[ 0 ].material.dispose();
+
+	}
+
+	update() {
+
+		const mesh = this.children[ 0 ];
+
+		if ( this.color !== undefined ) {
+
+			this.material.color.set( this.color );
+
+		} else {
+
+			const colors = mesh.geometry.getAttribute( 'color' );
+
+			_color1.copy( this.light.color );
+			_color2.copy( this.light.groundColor );
+
+			for ( let i = 0, l = colors.count; i < l; i ++ ) {
+
+				const color = ( i < ( l / 2 ) ) ? _color1 : _color2;
+
+				colors.setXYZ( i, color.r, color.g, color.b );
+
+			}
+
+			colors.needsUpdate = true;
+
+		}
+
+		this.light.updateWorldMatrix( true, false );
+
+		mesh.lookAt( _vector$1.setFromMatrixPosition( this.light.matrixWorld ).negate() );
+
+	}
+
+}
+
+class GridHelper extends LineSegments {
+
+	constructor( size = 10, divisions = 10, color1 = 0x444444, color2 = 0x888888 ) {
+
+		color1 = new Color( color1 );
+		color2 = new Color( color2 );
+
+		const center = divisions / 2;
+		const step = size / divisions;
+		const halfSize = size / 2;
+
+		const vertices = [], colors = [];
+
+		for ( let i = 0, j = 0, k = - halfSize; i <= divisions; i ++, k += step ) {
+
+			vertices.push( - halfSize, 0, k, halfSize, 0, k );
+			vertices.push( k, 0, - halfSize, k, 0, halfSize );
+
+			const color = i === center ? color1 : color2;
+
+			color.toArray( colors, j ); j += 3;
+			color.toArray( colors, j ); j += 3;
+			color.toArray( colors, j ); j += 3;
+			color.toArray( colors, j ); j += 3;
+
+		}
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		geometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );
+
+		const material = new LineBasicMaterial( { vertexColors: true, toneMapped: false } );
+
+		super( geometry, material );
+
+		this.type = 'GridHelper';
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+class PolarGridHelper extends LineSegments {
+
+	constructor( radius = 10, sectors = 16, rings = 8, divisions = 64, color1 = 0x444444, color2 = 0x888888 ) {
+
+		color1 = new Color( color1 );
+		color2 = new Color( color2 );
+
+		const vertices = [];
+		const colors = [];
+
+		// create the sectors
+
+		if ( sectors > 1 ) {
+
+			for ( let i = 0; i < sectors; i ++ ) {
+
+				const v = ( i / sectors ) * ( Math.PI * 2 );
+
+				const x = Math.sin( v ) * radius;
+				const z = Math.cos( v ) * radius;
+
+				vertices.push( 0, 0, 0 );
+				vertices.push( x, 0, z );
+
+				const color = ( i & 1 ) ? color1 : color2;
+
+				colors.push( color.r, color.g, color.b );
+				colors.push( color.r, color.g, color.b );
+
+			}
+
+		}
+
+		// create the rings
+
+		for ( let i = 0; i < rings; i ++ ) {
+
+			const color = ( i & 1 ) ? color1 : color2;
+
+			const r = radius - ( radius / rings * i );
+
+			for ( let j = 0; j < divisions; j ++ ) {
+
+				// first vertex
+
+				let v = ( j / divisions ) * ( Math.PI * 2 );
+
+				let x = Math.sin( v ) * r;
+				let z = Math.cos( v ) * r;
+
+				vertices.push( x, 0, z );
+				colors.push( color.r, color.g, color.b );
+
+				// second vertex
+
+				v = ( ( j + 1 ) / divisions ) * ( Math.PI * 2 );
+
+				x = Math.sin( v ) * r;
+				z = Math.cos( v ) * r;
+
+				vertices.push( x, 0, z );
+				colors.push( color.r, color.g, color.b );
+
+			}
+
+		}
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		geometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );
+
+		const material = new LineBasicMaterial( { vertexColors: true, toneMapped: false } );
+
+		super( geometry, material );
+
+		this.type = 'PolarGridHelper';
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+const _v1 = /*@__PURE__*/ new Vector3();
+const _v2 = /*@__PURE__*/ new Vector3();
+const _v3 = /*@__PURE__*/ new Vector3();
+
+class DirectionalLightHelper extends Object3D {
+
+	constructor( light, size, color ) {
+
+		super();
+
+		this.light = light;
+
+		this.matrix = light.matrixWorld;
+		this.matrixAutoUpdate = false;
+
+		this.color = color;
+
+		this.type = 'DirectionalLightHelper';
+
+		if ( size === undefined ) size = 1;
+
+		let geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( [
+			- size, size, 0,
+			size, size, 0,
+			size, - size, 0,
+			- size, - size, 0,
+			- size, size, 0
+		], 3 ) );
+
+		const material = new LineBasicMaterial( { fog: false, toneMapped: false } );
+
+		this.lightPlane = new Line( geometry, material );
+		this.add( this.lightPlane );
+
+		geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 0, 1 ], 3 ) );
+
+		this.targetLine = new Line( geometry, material );
+		this.add( this.targetLine );
+
+		this.update();
+
+	}
+
+	dispose() {
+
+		this.lightPlane.geometry.dispose();
+		this.lightPlane.material.dispose();
+		this.targetLine.geometry.dispose();
+		this.targetLine.material.dispose();
+
+	}
+
+	update() {
+
+		this.light.updateWorldMatrix( true, false );
+		this.light.target.updateWorldMatrix( true, false );
+
+		_v1.setFromMatrixPosition( this.light.matrixWorld );
+		_v2.setFromMatrixPosition( this.light.target.matrixWorld );
+		_v3.subVectors( _v2, _v1 );
+
+		this.lightPlane.lookAt( _v2 );
+
+		if ( this.color !== undefined ) {
+
+			this.lightPlane.material.color.set( this.color );
+			this.targetLine.material.color.set( this.color );
+
+		} else {
+
+			this.lightPlane.material.color.copy( this.light.color );
+			this.targetLine.material.color.copy( this.light.color );
+
+		}
+
+		this.targetLine.lookAt( _v2 );
+		this.targetLine.scale.z = _v3.length();
+
+	}
+
+}
+
+const _vector = /*@__PURE__*/ new Vector3();
+const _camera = /*@__PURE__*/ new Camera();
+
+/**
+ *	- shows frustum, line of sight and up of the camera
+ *	- suitable for fast updates
+ * 	- based on frustum visualization in lightgl.js shadowmap example
+ *		https://github.com/evanw/lightgl.js/blob/master/tests/shadowmap.html
+ */
+
+class CameraHelper extends LineSegments {
+
+	constructor( camera ) {
+
+		const geometry = new BufferGeometry();
+		const material = new LineBasicMaterial( { color: 0xffffff, vertexColors: true, toneMapped: false } );
+
+		const vertices = [];
+		const colors = [];
+
+		const pointMap = {};
+
+		// near
+
+		addLine( 'n1', 'n2' );
+		addLine( 'n2', 'n4' );
+		addLine( 'n4', 'n3' );
+		addLine( 'n3', 'n1' );
+
+		// far
+
+		addLine( 'f1', 'f2' );
+		addLine( 'f2', 'f4' );
+		addLine( 'f4', 'f3' );
+		addLine( 'f3', 'f1' );
+
+		// sides
+
+		addLine( 'n1', 'f1' );
+		addLine( 'n2', 'f2' );
+		addLine( 'n3', 'f3' );
+		addLine( 'n4', 'f4' );
+
+		// cone
+
+		addLine( 'p', 'n1' );
+		addLine( 'p', 'n2' );
+		addLine( 'p', 'n3' );
+		addLine( 'p', 'n4' );
+
+		// up
+
+		addLine( 'u1', 'u2' );
+		addLine( 'u2', 'u3' );
+		addLine( 'u3', 'u1' );
+
+		// target
+
+		addLine( 'c', 't' );
+		addLine( 'p', 'c' );
+
+		// cross
+
+		addLine( 'cn1', 'cn2' );
+		addLine( 'cn3', 'cn4' );
+
+		addLine( 'cf1', 'cf2' );
+		addLine( 'cf3', 'cf4' );
+
+		function addLine( a, b ) {
+
+			addPoint( a );
+			addPoint( b );
+
+		}
+
+		function addPoint( id ) {
+
+			vertices.push( 0, 0, 0 );
+			colors.push( 0, 0, 0 );
+
+			if ( pointMap[ id ] === undefined ) {
+
+				pointMap[ id ] = [];
+
+			}
+
+			pointMap[ id ].push( ( vertices.length / 3 ) - 1 );
+
+		}
+
+		geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		geometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );
+
+		super( geometry, material );
+
+		this.type = 'CameraHelper';
+
+		this.camera = camera;
+		if ( this.camera.updateProjectionMatrix ) this.camera.updateProjectionMatrix();
+
+		this.matrix = camera.matrixWorld;
+		this.matrixAutoUpdate = false;
+
+		this.pointMap = pointMap;
+
+		this.update();
+
+		// colors
+
+		const colorFrustum = new Color( 0xffaa00 );
+		const colorCone = new Color( 0xff0000 );
+		const colorUp = new Color( 0x00aaff );
+		const colorTarget = new Color( 0xffffff );
+		const colorCross = new Color( 0x333333 );
+
+		this.setColors( colorFrustum, colorCone, colorUp, colorTarget, colorCross );
+
+	}
+
+	setColors( frustum, cone, up, target, cross ) {
+
+		const geometry = this.geometry;
+
+		const colorAttribute = geometry.getAttribute( 'color' );
+
+		// near
+
+		colorAttribute.setXYZ( 0, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 1, frustum.r, frustum.g, frustum.b ); // n1, n2
+		colorAttribute.setXYZ( 2, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 3, frustum.r, frustum.g, frustum.b ); // n2, n4
+		colorAttribute.setXYZ( 4, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 5, frustum.r, frustum.g, frustum.b ); // n4, n3
+		colorAttribute.setXYZ( 6, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 7, frustum.r, frustum.g, frustum.b ); // n3, n1
+
+		// far
+
+		colorAttribute.setXYZ( 8, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 9, frustum.r, frustum.g, frustum.b ); // f1, f2
+		colorAttribute.setXYZ( 10, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 11, frustum.r, frustum.g, frustum.b ); // f2, f4
+		colorAttribute.setXYZ( 12, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 13, frustum.r, frustum.g, frustum.b ); // f4, f3
+		colorAttribute.setXYZ( 14, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 15, frustum.r, frustum.g, frustum.b ); // f3, f1
+
+		// sides
+
+		colorAttribute.setXYZ( 16, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 17, frustum.r, frustum.g, frustum.b ); // n1, f1
+		colorAttribute.setXYZ( 18, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 19, frustum.r, frustum.g, frustum.b ); // n2, f2
+		colorAttribute.setXYZ( 20, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 21, frustum.r, frustum.g, frustum.b ); // n3, f3
+		colorAttribute.setXYZ( 22, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 23, frustum.r, frustum.g, frustum.b ); // n4, f4
+
+		// cone
+
+		colorAttribute.setXYZ( 24, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 25, cone.r, cone.g, cone.b ); // p, n1
+		colorAttribute.setXYZ( 26, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 27, cone.r, cone.g, cone.b ); // p, n2
+		colorAttribute.setXYZ( 28, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 29, cone.r, cone.g, cone.b ); // p, n3
+		colorAttribute.setXYZ( 30, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 31, cone.r, cone.g, cone.b ); // p, n4
+
+		// up
+
+		colorAttribute.setXYZ( 32, up.r, up.g, up.b ); colorAttribute.setXYZ( 33, up.r, up.g, up.b ); // u1, u2
+		colorAttribute.setXYZ( 34, up.r, up.g, up.b ); colorAttribute.setXYZ( 35, up.r, up.g, up.b ); // u2, u3
+		colorAttribute.setXYZ( 36, up.r, up.g, up.b ); colorAttribute.setXYZ( 37, up.r, up.g, up.b ); // u3, u1
+
+		// target
+
+		colorAttribute.setXYZ( 38, target.r, target.g, target.b ); colorAttribute.setXYZ( 39, target.r, target.g, target.b ); // c, t
+		colorAttribute.setXYZ( 40, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 41, cross.r, cross.g, cross.b ); // p, c
+
+		// cross
+
+		colorAttribute.setXYZ( 42, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 43, cross.r, cross.g, cross.b ); // cn1, cn2
+		colorAttribute.setXYZ( 44, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 45, cross.r, cross.g, cross.b ); // cn3, cn4
+
+		colorAttribute.setXYZ( 46, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 47, cross.r, cross.g, cross.b ); // cf1, cf2
+		colorAttribute.setXYZ( 48, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 49, cross.r, cross.g, cross.b ); // cf3, cf4
+
+		colorAttribute.needsUpdate = true;
+
+	}
+
+	update() {
+
+		const geometry = this.geometry;
+		const pointMap = this.pointMap;
+
+		const w = 1, h = 1;
+
+		// we need just camera projection matrix inverse
+		// world matrix must be identity
+
+		_camera.projectionMatrixInverse.copy( this.camera.projectionMatrixInverse );
+
+		// center / target
+
+		setPoint( 'c', pointMap, geometry, _camera, 0, 0, - 1 );
+		setPoint( 't', pointMap, geometry, _camera, 0, 0, 1 );
+
+		// near
+
+		setPoint( 'n1', pointMap, geometry, _camera, - w, - h, - 1 );
+		setPoint( 'n2', pointMap, geometry, _camera, w, - h, - 1 );
+		setPoint( 'n3', pointMap, geometry, _camera, - w, h, - 1 );
+		setPoint( 'n4', pointMap, geometry, _camera, w, h, - 1 );
+
+		// far
+
+		setPoint( 'f1', pointMap, geometry, _camera, - w, - h, 1 );
+		setPoint( 'f2', pointMap, geometry, _camera, w, - h, 1 );
+		setPoint( 'f3', pointMap, geometry, _camera, - w, h, 1 );
+		setPoint( 'f4', pointMap, geometry, _camera, w, h, 1 );
+
+		// up
+
+		setPoint( 'u1', pointMap, geometry, _camera, w * 0.7, h * 1.1, - 1 );
+		setPoint( 'u2', pointMap, geometry, _camera, - w * 0.7, h * 1.1, - 1 );
+		setPoint( 'u3', pointMap, geometry, _camera, 0, h * 2, - 1 );
+
+		// cross
+
+		setPoint( 'cf1', pointMap, geometry, _camera, - w, 0, 1 );
+		setPoint( 'cf2', pointMap, geometry, _camera, w, 0, 1 );
+		setPoint( 'cf3', pointMap, geometry, _camera, 0, - h, 1 );
+		setPoint( 'cf4', pointMap, geometry, _camera, 0, h, 1 );
+
+		setPoint( 'cn1', pointMap, geometry, _camera, - w, 0, - 1 );
+		setPoint( 'cn2', pointMap, geometry, _camera, w, 0, - 1 );
+		setPoint( 'cn3', pointMap, geometry, _camera, 0, - h, - 1 );
+		setPoint( 'cn4', pointMap, geometry, _camera, 0, h, - 1 );
+
+		geometry.getAttribute( 'position' ).needsUpdate = true;
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+
+function setPoint( point, pointMap, geometry, camera, x, y, z ) {
+
+	_vector.set( x, y, z ).unproject( camera );
+
+	const points = pointMap[ point ];
+
+	if ( points !== undefined ) {
+
+		const position = geometry.getAttribute( 'position' );
+
+		for ( let i = 0, l = points.length; i < l; i ++ ) {
+
+			position.setXYZ( points[ i ], _vector.x, _vector.y, _vector.z );
+
+		}
+
+	}
+
+}
+
+const _box = /*@__PURE__*/ new Box3();
+
+class BoxHelper extends LineSegments {
+
+	constructor( object, color = 0xffff00 ) {
+
+		const indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );
+		const positions = new Float32Array( 8 * 3 );
+
+		const geometry = new BufferGeometry();
+		geometry.setIndex( new BufferAttribute( indices, 1 ) );
+		geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+
+		super( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );
+
+		this.object = object;
+		this.type = 'BoxHelper';
+
+		this.matrixAutoUpdate = false;
+
+		this.update();
+
+	}
+
+	update( object ) {
+
+		if ( object !== undefined ) {
+
+			console.warn( 'THREE.BoxHelper: .update() has no longer arguments.' );
+
+		}
+
+		if ( this.object !== undefined ) {
+
+			_box.setFromObject( this.object );
+
+		}
+
+		if ( _box.isEmpty() ) return;
+
+		const min = _box.min;
+		const max = _box.max;
+
+		/*
+			5____4
+		1/___0/|
+		| 6__|_7
+		2/___3/
+
+		0: max.x, max.y, max.z
+		1: min.x, max.y, max.z
+		2: min.x, min.y, max.z
+		3: max.x, min.y, max.z
+		4: max.x, max.y, min.z
+		5: min.x, max.y, min.z
+		6: min.x, min.y, min.z
+		7: max.x, min.y, min.z
+		*/
+
+		const position = this.geometry.attributes.position;
+		const array = position.array;
+
+		array[ 0 ] = max.x; array[ 1 ] = max.y; array[ 2 ] = max.z;
+		array[ 3 ] = min.x; array[ 4 ] = max.y; array[ 5 ] = max.z;
+		array[ 6 ] = min.x; array[ 7 ] = min.y; array[ 8 ] = max.z;
+		array[ 9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;
+		array[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;
+		array[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;
+		array[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;
+		array[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;
+
+		position.needsUpdate = true;
+
+		this.geometry.computeBoundingSphere();
+
+	}
+
+	setFromObject( object ) {
+
+		this.object = object;
+		this.update();
+
+		return this;
+
+	}
+
+	copy( source, recursive ) {
+
+		super.copy( source, recursive );
+
+		this.object = source.object;
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+class Box3Helper extends LineSegments {
+
+	constructor( box, color = 0xffff00 ) {
+
+		const indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );
+
+		const positions = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, - 1, 1, 1, 1, - 1, - 1, 1, - 1, - 1, - 1, - 1, 1, - 1, - 1 ];
+
+		const geometry = new BufferGeometry();
+
+		geometry.setIndex( new BufferAttribute( indices, 1 ) );
+
+		geometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+
+		super( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );
+
+		this.box = box;
+
+		this.type = 'Box3Helper';
+
+		this.geometry.computeBoundingSphere();
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		const box = this.box;
+
+		if ( box.isEmpty() ) return;
+
+		box.getCenter( this.position );
+
+		box.getSize( this.scale );
+
+		this.scale.multiplyScalar( 0.5 );
+
+		super.updateMatrixWorld( force );
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+class PlaneHelper extends Line {
+
+	constructor( plane, size = 1, hex = 0xffff00 ) {
+
+		const color = hex;
+
+		const positions = [ 1, - 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, - 1, 0, 1, 1, 0 ];
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+		geometry.computeBoundingSphere();
+
+		super( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );
+
+		this.type = 'PlaneHelper';
+
+		this.plane = plane;
+
+		this.size = size;
+
+		const positions2 = [ 1, 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, 1, 0, - 1, - 1, 0, 1, - 1, 0 ];
+
+		const geometry2 = new BufferGeometry();
+		geometry2.setAttribute( 'position', new Float32BufferAttribute( positions2, 3 ) );
+		geometry2.computeBoundingSphere();
+
+		this.add( new Mesh( geometry2, new MeshBasicMaterial( { color: color, opacity: 0.2, transparent: true, depthWrite: false, toneMapped: false } ) ) );
+
+	}
+
+	updateMatrixWorld( force ) {
+
+		this.position.set( 0, 0, 0 );
+
+		this.scale.set( 0.5 * this.size, 0.5 * this.size, 1 );
+
+		this.lookAt( this.plane.normal );
+
+		this.translateZ( - this.plane.constant );
+
+		super.updateMatrixWorld( force );
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+		this.children[ 0 ].geometry.dispose();
+		this.children[ 0 ].material.dispose();
+
+	}
+
+}
+
+const _axis = /*@__PURE__*/ new Vector3();
+let _lineGeometry, _coneGeometry;
+
+class ArrowHelper extends Object3D {
+
+	// dir is assumed to be normalized
+
+	constructor( dir = new Vector3( 0, 0, 1 ), origin = new Vector3( 0, 0, 0 ), length = 1, color = 0xffff00, headLength = length * 0.2, headWidth = headLength * 0.2 ) {
+
+		super();
+
+		this.type = 'ArrowHelper';
+
+		if ( _lineGeometry === undefined ) {
+
+			_lineGeometry = new BufferGeometry();
+			_lineGeometry.setAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 1, 0 ], 3 ) );
+
+			_coneGeometry = new CylinderGeometry( 0, 0.5, 1, 5, 1 );
+			_coneGeometry.translate( 0, - 0.5, 0 );
+
+		}
+
+		this.position.copy( origin );
+
+		this.line = new Line( _lineGeometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );
+		this.line.matrixAutoUpdate = false;
+		this.add( this.line );
+
+		this.cone = new Mesh( _coneGeometry, new MeshBasicMaterial( { color: color, toneMapped: false } ) );
+		this.cone.matrixAutoUpdate = false;
+		this.add( this.cone );
+
+		this.setDirection( dir );
+		this.setLength( length, headLength, headWidth );
+
+	}
+
+	setDirection( dir ) {
+
+		// dir is assumed to be normalized
+
+		if ( dir.y > 0.99999 ) {
+
+			this.quaternion.set( 0, 0, 0, 1 );
+
+		} else if ( dir.y < - 0.99999 ) {
+
+			this.quaternion.set( 1, 0, 0, 0 );
+
+		} else {
+
+			_axis.set( dir.z, 0, - dir.x ).normalize();
+
+			const radians = Math.acos( dir.y );
+
+			this.quaternion.setFromAxisAngle( _axis, radians );
+
+		}
+
+	}
+
+	setLength( length, headLength = length * 0.2, headWidth = headLength * 0.2 ) {
+
+		this.line.scale.set( 1, Math.max( 0.0001, length - headLength ), 1 ); // see #17458
+		this.line.updateMatrix();
+
+		this.cone.scale.set( headWidth, headLength, headWidth );
+		this.cone.position.y = length;
+		this.cone.updateMatrix();
+
+	}
+
+	setColor( color ) {
+
+		this.line.material.color.set( color );
+		this.cone.material.color.set( color );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source, false );
+
+		this.line.copy( source.line );
+		this.cone.copy( source.cone );
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.line.geometry.dispose();
+		this.line.material.dispose();
+		this.cone.geometry.dispose();
+		this.cone.material.dispose();
+
+	}
+
+}
+
+class AxesHelper extends LineSegments {
+
+	constructor( size = 1 ) {
+
+		const vertices = [
+			0, 0, 0,	size, 0, 0,
+			0, 0, 0,	0, size, 0,
+			0, 0, 0,	0, 0, size
+		];
+
+		const colors = [
+			1, 0, 0,	1, 0.6, 0,
+			0, 1, 0,	0.6, 1, 0,
+			0, 0, 1,	0, 0.6, 1
+		];
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		geometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );
+
+		const material = new LineBasicMaterial( { vertexColors: true, toneMapped: false } );
+
+		super( geometry, material );
+
+		this.type = 'AxesHelper';
+
+	}
+
+	setColors( xAxisColor, yAxisColor, zAxisColor ) {
+
+		const color = new Color();
+		const array = this.geometry.attributes.color.array;
+
+		color.set( xAxisColor );
+		color.toArray( array, 0 );
+		color.toArray( array, 3 );
+
+		color.set( yAxisColor );
+		color.toArray( array, 6 );
+		color.toArray( array, 9 );
+
+		color.set( zAxisColor );
+		color.toArray( array, 12 );
+		color.toArray( array, 15 );
+
+		this.geometry.attributes.color.needsUpdate = true;
+
+		return this;
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+class ShapePath {
+
+	constructor() {
+
+		this.type = 'ShapePath';
+
+		this.color = new Color();
+
+		this.subPaths = [];
+		this.currentPath = null;
+
+	}
+
+	moveTo( x, y ) {
+
+		this.currentPath = new Path();
+		this.subPaths.push( this.currentPath );
+		this.currentPath.moveTo( x, y );
+
+		return this;
+
+	}
+
+	lineTo( x, y ) {
+
+		this.currentPath.lineTo( x, y );
+
+		return this;
+
+	}
+
+	quadraticCurveTo( aCPx, aCPy, aX, aY ) {
+
+		this.currentPath.quadraticCurveTo( aCPx, aCPy, aX, aY );
+
+		return this;
+
+	}
+
+	bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {
+
+		this.currentPath.bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY );
+
+		return this;
+
+	}
+
+	splineThru( pts ) {
+
+		this.currentPath.splineThru( pts );
+
+		return this;
+
+	}
+
+	toShapes( isCCW ) {
+
+		function toShapesNoHoles( inSubpaths ) {
+
+			const shapes = [];
+
+			for ( let i = 0, l = inSubpaths.length; i < l; i ++ ) {
+
+				const tmpPath = inSubpaths[ i ];
+
+				const tmpShape = new Shape();
+				tmpShape.curves = tmpPath.curves;
+
+				shapes.push( tmpShape );
+
+			}
+
+			return shapes;
+
+		}
+
+		function isPointInsidePolygon( inPt, inPolygon ) {
+
+			const polyLen = inPolygon.length;
+
+			// inPt on polygon contour => immediate success    or
+			// toggling of inside/outside at every single! intersection point of an edge
+			//  with the horizontal line through inPt, left of inPt
+			//  not counting lowerY endpoints of edges and whole edges on that line
+			let inside = false;
+			for ( let p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {
+
+				let edgeLowPt = inPolygon[ p ];
+				let edgeHighPt = inPolygon[ q ];
+
+				let edgeDx = edgeHighPt.x - edgeLowPt.x;
+				let edgeDy = edgeHighPt.y - edgeLowPt.y;
+
+				if ( Math.abs( edgeDy ) > Number.EPSILON ) {
+
+					// not parallel
+					if ( edgeDy < 0 ) {
+
+						edgeLowPt = inPolygon[ q ]; edgeDx = - edgeDx;
+						edgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;
+
+					}
+
+					if ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) 		continue;
+
+					if ( inPt.y === edgeLowPt.y ) {
+
+						if ( inPt.x === edgeLowPt.x )		return	true;		// inPt is on contour ?
+						// continue;				// no intersection or edgeLowPt => doesn't count !!!
+
+					} else {
+
+						const perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );
+						if ( perpEdge === 0 )				return	true;		// inPt is on contour ?
+						if ( perpEdge < 0 ) 				continue;
+						inside = ! inside;		// true intersection left of inPt
+
+					}
+
+				} else {
+
+					// parallel or collinear
+					if ( inPt.y !== edgeLowPt.y ) 		continue;			// parallel
+					// edge lies on the same horizontal line as inPt
+					if ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||
+						 ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )		return	true;	// inPt: Point on contour !
+					// continue;
+
+				}
+
+			}
+
+			return	inside;
+
+		}
+
+		const isClockWise = ShapeUtils.isClockWise;
+
+		const subPaths = this.subPaths;
+		if ( subPaths.length === 0 ) return [];
+
+		let solid, tmpPath, tmpShape;
+		const shapes = [];
+
+		if ( subPaths.length === 1 ) {
+
+			tmpPath = subPaths[ 0 ];
+			tmpShape = new Shape();
+			tmpShape.curves = tmpPath.curves;
+			shapes.push( tmpShape );
+			return shapes;
+
+		}
+
+		let holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );
+		holesFirst = isCCW ? ! holesFirst : holesFirst;
+
+		// console.log("Holes first", holesFirst);
+
+		const betterShapeHoles = [];
+		const newShapes = [];
+		let newShapeHoles = [];
+		let mainIdx = 0;
+		let tmpPoints;
+
+		newShapes[ mainIdx ] = undefined;
+		newShapeHoles[ mainIdx ] = [];
+
+		for ( let i = 0, l = subPaths.length; i < l; i ++ ) {
+
+			tmpPath = subPaths[ i ];
+			tmpPoints = tmpPath.getPoints();
+			solid = isClockWise( tmpPoints );
+			solid = isCCW ? ! solid : solid;
+
+			if ( solid ) {
+
+				if ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )	mainIdx ++;
+
+				newShapes[ mainIdx ] = { s: new Shape(), p: tmpPoints };
+				newShapes[ mainIdx ].s.curves = tmpPath.curves;
+
+				if ( holesFirst )	mainIdx ++;
+				newShapeHoles[ mainIdx ] = [];
+
+				//console.log('cw', i);
+
+			} else {
+
+				newShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );
+
+				//console.log('ccw', i);
+
+			}
+
+		}
+
+		// only Holes? -> probably all Shapes with wrong orientation
+		if ( ! newShapes[ 0 ] )	return	toShapesNoHoles( subPaths );
+
+
+		if ( newShapes.length > 1 ) {
+
+			let ambiguous = false;
+			let toChange = 0;
+
+			for ( let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
+
+				betterShapeHoles[ sIdx ] = [];
+
+			}
+
+			for ( let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
+
+				const sho = newShapeHoles[ sIdx ];
+
+				for ( let hIdx = 0; hIdx < sho.length; hIdx ++ ) {
+
+					const ho = sho[ hIdx ];
+					let hole_unassigned = true;
+
+					for ( let s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {
+
+						if ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {
+
+							if ( sIdx !== s2Idx )	toChange ++;
+
+							if ( hole_unassigned ) {
+
+								hole_unassigned = false;
+								betterShapeHoles[ s2Idx ].push( ho );
+
+							} else {
+
+								ambiguous = true;
+
+							}
+
+						}
+
+					}
+
+					if ( hole_unassigned ) {
+
+						betterShapeHoles[ sIdx ].push( ho );
+
+					}
+
+				}
+
+			}
+
+			if ( toChange > 0 && ambiguous === false ) {
+
+				newShapeHoles = betterShapeHoles;
+
+			}
+
+		}
+
+		let tmpHoles;
+
+		for ( let i = 0, il = newShapes.length; i < il; i ++ ) {
+
+			tmpShape = newShapes[ i ].s;
+			shapes.push( tmpShape );
+			tmpHoles = newShapeHoles[ i ];
+
+			for ( let j = 0, jl = tmpHoles.length; j < jl; j ++ ) {
+
+				tmpShape.holes.push( tmpHoles[ j ].h );
+
+			}
+
+		}
+
+		//console.log("shape", shapes);
+
+		return shapes;
+
+	}
+
+}
+
+if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
+
+	__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'register', { detail: {
+		revision: REVISION,
+	} } ) );
+
+}
+
+if ( typeof window !== 'undefined' ) {
+
+	if ( window.__THREE__ ) {
+
+		console.warn( 'WARNING: Multiple instances of Three.js being imported.' );
+
+	} else {
+
+		window.__THREE__ = REVISION;
+
+	}
+
+}
+
+export { ACESFilmicToneMapping, AddEquation, AddOperation, AdditiveAnimationBlendMode, AdditiveBlending, AgXToneMapping, AlphaFormat, AlwaysCompare, AlwaysDepth, AlwaysStencilFunc, AmbientLight, AnimationAction, AnimationClip, AnimationLoader, AnimationMixer, AnimationObjectGroup, AnimationUtils, ArcCurve, ArrayCamera, ArrowHelper, AttachedBindMode, Audio, AudioAnalyser, AudioContext, AudioListener, AudioLoader, AxesHelper, BackSide, BasicDepthPacking, BasicShadowMap, BatchedMesh, Bone, BooleanKeyframeTrack, Box2, Box3, Box3Helper, BoxGeometry, BoxHelper, BufferAttribute, BufferGeometry, BufferGeometryLoader, ByteType, Cache, Camera, CameraHelper, CanvasTexture, CapsuleGeometry, CatmullRomCurve3, CineonToneMapping, CircleGeometry, ClampToEdgeWrapping, Clock, Color, ColorKeyframeTrack, ColorManagement, CompressedArrayTexture, CompressedCubeTexture, CompressedTexture, CompressedTextureLoader, ConeGeometry, ConstantAlphaFactor, ConstantColorFactor, CubeCamera, CubeReflectionMapping, CubeRefractionMapping, CubeTexture, CubeTextureLoader, CubeUVReflectionMapping, CubicBezierCurve, CubicBezierCurve3, CubicInterpolant, CullFaceBack, CullFaceFront, CullFaceFrontBack, CullFaceNone, Curve, CurvePath, CustomBlending, CustomToneMapping, CylinderGeometry, Cylindrical, Data3DTexture, DataArrayTexture, DataTexture, DataTextureLoader, DataUtils, DecrementStencilOp, DecrementWrapStencilOp, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DepthTexture, DetachedBindMode, DirectionalLight, DirectionalLightHelper, DiscreteInterpolant, DisplayP3ColorSpace, DodecahedronGeometry, DoubleSide, DstAlphaFactor, DstColorFactor, DynamicCopyUsage, DynamicDrawUsage, DynamicReadUsage, EdgesGeometry, EllipseCurve, EqualCompare, EqualDepth, EqualStencilFunc, EquirectangularReflectionMapping, EquirectangularRefractionMapping, Euler, EventDispatcher, ExtrudeGeometry, FileLoader, Float16BufferAttribute, Float32BufferAttribute, Float64BufferAttribute, FloatType, Fog, FogExp2, FramebufferTexture, FrontSide, Frustum, GLBufferAttribute, GLSL1, GLSL3, GreaterCompare, GreaterDepth, GreaterEqualCompare, GreaterEqualDepth, GreaterEqualStencilFunc, GreaterStencilFunc, GridHelper, Group, HalfFloatType, HemisphereLight, HemisphereLightHelper, IcosahedronGeometry, ImageBitmapLoader, ImageLoader, ImageUtils, IncrementStencilOp, IncrementWrapStencilOp, InstancedBufferAttribute, InstancedBufferGeometry, InstancedInterleavedBuffer, InstancedMesh, Int16BufferAttribute, Int32BufferAttribute, Int8BufferAttribute, IntType, InterleavedBuffer, InterleavedBufferAttribute, Interpolant, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InvertStencilOp, KeepStencilOp, KeyframeTrack, LOD, LatheGeometry, Layers, LessCompare, LessDepth, LessEqualCompare, LessEqualDepth, LessEqualStencilFunc, LessStencilFunc, Light, LightProbe, Line, Line3, LineBasicMaterial, LineCurve, LineCurve3, LineDashedMaterial, LineLoop, LineSegments, LinearDisplayP3ColorSpace, LinearEncoding, LinearFilter, LinearInterpolant, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, LinearSRGBColorSpace, LinearToneMapping, LinearTransfer, Loader, LoaderUtils, LoadingManager, LoopOnce, LoopPingPong, LoopRepeat, LuminanceAlphaFormat, LuminanceFormat, MOUSE, Material, MaterialLoader, MathUtils, Matrix3, Matrix4, MaxEquation, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshDistanceMaterial, MeshLambertMaterial, MeshMatcapMaterial, MeshNormalMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MeshToonMaterial, MinEquation, MirroredRepeatWrapping, MixOperation, MultiplyBlending, MultiplyOperation, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, NeverCompare, NeverDepth, NeverStencilFunc, NoBlending, NoColorSpace, NoToneMapping, NormalAnimationBlendMode, NormalBlending, NotEqualCompare, NotEqualDepth, NotEqualStencilFunc, NumberKeyframeTrack, Object3D, ObjectLoader, ObjectSpaceNormalMap, OctahedronGeometry, OneFactor, OneMinusConstantAlphaFactor, OneMinusConstantColorFactor, OneMinusDstAlphaFactor, OneMinusDstColorFactor, OneMinusSrcAlphaFactor, OneMinusSrcColorFactor, OrthographicCamera, P3Primaries, PCFShadowMap, PCFSoftShadowMap, PMREMGenerator, Path, PerspectiveCamera, Plane, PlaneGeometry, PlaneHelper, PointLight, PointLightHelper, Points, PointsMaterial, PolarGridHelper, PolyhedronGeometry, PositionalAudio, PropertyBinding, PropertyMixer, QuadraticBezierCurve, QuadraticBezierCurve3, Quaternion, QuaternionKeyframeTrack, QuaternionLinearInterpolant, RED_GREEN_RGTC2_Format, RED_RGTC1_Format, REVISION, RGBADepthPacking, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RGIntegerFormat, RawShaderMaterial, Ray, Raycaster, Rec709Primaries, RectAreaLight, RedFormat, RedIntegerFormat, ReinhardToneMapping, RenderTarget, RepeatWrapping, ReplaceStencilOp, ReverseSubtractEquation, RingGeometry, SIGNED_RED_GREEN_RGTC2_Format, SIGNED_RED_RGTC1_Format, SRGBColorSpace, SRGBTransfer, Scene, ShaderChunk, ShaderLib, ShaderMaterial, ShadowMaterial, Shape, ShapeGeometry, ShapePath, ShapeUtils, ShortType, Skeleton, SkeletonHelper, SkinnedMesh, Source, Sphere, SphereGeometry, Spherical, SphericalHarmonics3, SplineCurve, SpotLight, SpotLightHelper, Sprite, SpriteMaterial, SrcAlphaFactor, SrcAlphaSaturateFactor, SrcColorFactor, StaticCopyUsage, StaticDrawUsage, StaticReadUsage, StereoCamera, StreamCopyUsage, StreamDrawUsage, StreamReadUsage, StringKeyframeTrack, SubtractEquation, SubtractiveBlending, TOUCH, TangentSpaceNormalMap, TetrahedronGeometry, Texture, TextureLoader, TorusGeometry, TorusKnotGeometry, Triangle, TriangleFanDrawMode, TriangleStripDrawMode, TrianglesDrawMode, TubeGeometry, TwoPassDoubleSide, UVMapping, Uint16BufferAttribute, Uint32BufferAttribute, Uint8BufferAttribute, Uint8ClampedBufferAttribute, Uniform, UniformsGroup, UniformsLib, UniformsUtils, UnsignedByteType, UnsignedInt248Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VSMShadowMap, Vector2, Vector3, Vector4, VectorKeyframeTrack, VideoTexture, WebGL1Renderer, WebGL3DRenderTarget, WebGLArrayRenderTarget, WebGLCoordinateSystem, WebGLCubeRenderTarget, WebGLMultipleRenderTargets, WebGLRenderTarget, WebGLRenderer, WebGLUtils, WebGPUCoordinateSystem, WireframeGeometry, WrapAroundEnding, ZeroCurvatureEnding, ZeroFactor, ZeroSlopeEnding, ZeroStencilOp, _SRGBAFormat, createCanvasElement, sRGBEncoding };

From e6824a30c84fa4caae54b3e14def2d8352239edb Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:06:20 +0200
Subject: [PATCH 019/160] Add Three.js structure renderer

---
 .../plans/crysview-structure-visualization.md |   2 +-
 .../display/structure/renderers/__init__.py   |   1 +
 .../display/structure/renderers/threejs.py    | 153 ++++++++++
 .../structure/templates/structure.html.j2     | 271 ++++++++++++++++++
 .../display/structure/viewing.py              |   5 +
 5 files changed, 431 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/display/structure/renderers/threejs.py
 create mode 100644 src/easydiffraction/display/structure/templates/structure.html.j2

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 3271591aa..805aa7f56 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -868,7 +868,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     wheel check is a Phase 2 step.
   - Commit: `Vendor pinned Three.js assets`.
 
-- [ ] **P1.14 — Add the Three.js structure renderer**
+- [x] **P1.14 — Add the Three.js structure renderer**
   - Files: new
     `src/easydiffraction/display/structure/renderers/threejs.py`; new
     `src/easydiffraction/display/structure/templates/structure.html.j2`;
diff --git a/src/easydiffraction/display/structure/renderers/__init__.py b/src/easydiffraction/display/structure/renderers/__init__.py
index 7faed819a..a9541d15e 100644
--- a/src/easydiffraction/display/structure/renderers/__init__.py
+++ b/src/easydiffraction/display/structure/renderers/__init__.py
@@ -6,3 +6,4 @@
 
 from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
 from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
new file mode 100644
index 000000000..3cf032a91
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -0,0 +1,153 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Three.js renderer: an interactive, self-contained HTML structure view."""
+
+from __future__ import annotations
+
+import base64
+import json
+import pathlib
+import uuid
+
+from jinja2 import Environment
+from jinja2 import PackageLoader
+
+from easydiffraction.display.structure.assets.colors import theme_colors
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.scene import StructureScene
+from easydiffraction.utils._vendored.theme_detect import is_dark
+
+_VENDOR = pathlib.Path(__file__).parent / 'vendor' / 'threejs'
+_CDN = 'https://cdn.jsdelivr.net/npm/three@0.160.0'
+_ADDON_CONTROLS = 'three/addons/controls/OrbitControls.js'
+_ADDON_CSS2D = 'three/addons/renderers/CSS2DRenderer.js'
+
+
+def _environment() -> Environment:
+    """Return the Jinja environment for structure-view templates."""
+    return Environment(
+        loader=PackageLoader('easydiffraction.display.structure', 'templates'),
+        autoescape=False,
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+
+def _data_url(path: pathlib.Path) -> str:
+    encoded = base64.b64encode(path.read_bytes()).decode('ascii')
+    return f'data:text/javascript;base64,{encoded}'
+
+
+def _import_map(*, offline: bool) -> dict[str, str]:
+    if offline:
+        return {
+            'three': _data_url(_VENDOR / 'three.module.js'),
+            _ADDON_CONTROLS: _data_url(_VENDOR / 'OrbitControls.js'),
+            _ADDON_CSS2D: _data_url(_VENDOR / 'CSS2DRenderer.js'),
+        }
+    return {
+        'three': f'{_CDN}/build/three.module.js',
+        _ADDON_CONTROLS: f'{_CDN}/examples/jsm/controls/OrbitControls.js',
+        _ADDON_CSS2D: f'{_CDN}/examples/jsm/renderers/CSS2DRenderer.js',
+    }
+
+
+def _scene_payload(scene: StructureScene) -> dict:
+    axes = None
+    if scene.axes is not None:
+        axes = {
+            'origin': scene.axes.origin,
+            'arrows': [
+                {'vector': arrow.vector, 'colour': arrow.colour, 'letter': arrow.letter}
+                for arrow in scene.axes.axes
+            ],
+        }
+    edges = []
+    if scene.cell_edges is not None:
+        edges = [{'start': edge.start, 'end': edge.end} for edge in scene.cell_edges.edges]
+    return {
+        'atoms': [
+            {'centre': a.centre, 'radius': a.radius, 'colour': a.colour, 'label': a.label}
+            for a in scene.atoms
+        ],
+        'wedgeSpheres': [
+            {
+                'centre': s.centre,
+                'radius': s.radius,
+                'label': s.label,
+                'wedges': [{'fraction': w.fraction, 'colour': w.colour} for w in s.wedges],
+            }
+            for s in scene.occupancy_spheres
+        ],
+        'ellipsoids': [
+            {
+                'centre': e.centre,
+                'semiAxes': e.semi_axes,
+                'orientation': [list(row) for row in e.orientation],
+                'colour': e.colour,
+                'label': e.label,
+            }
+            for e in scene.ellipsoids
+        ],
+        'bonds': [
+            {
+                'start': b.start,
+                'end': b.end,
+                'startColour': b.start_colour,
+                'endColour': b.end_colour,
+            }
+            for b in scene.bonds
+        ],
+        'cellEdges': edges,
+        'axes': axes,
+        'labels': [{'anchor': label.anchor, 'text': label.text} for label in scene.labels],
+    }
+
+
+def _rgb_css(rgb: tuple[int, int, int]) -> str:
+    return f'rgb({rgb[0]}, {rgb[1]}, {rgb[2]})'
+
+
+class ThreeJsStructureRenderer(StructureRendererBase):
+    """Interactive Three.js renderer for notebook and standalone HTML."""
+
+    SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'})
+
+    def supported_features(self) -> frozenset[str]:
+        """Return the features the Three.js engine can draw."""
+        return self.SUPPORTED
+
+    def render(self, scene: StructureScene, *, features: frozenset[str], offline: bool = True) -> str:
+        """
+        Render the scene as a self-contained interactive HTML document.
+
+        Parameters
+        ----------
+        scene : StructureScene
+            The renderer-neutral primitives to draw.
+        features : frozenset[str]
+            The content-resolved feature set; drives the modebar's initial
+            visibility toggles.
+        offline : bool
+            When ``True`` (default), inline the pinned Three.js assets so
+            the view renders with no network; when ``False`` link the CDN.
+
+        Returns
+        -------
+        str
+            A complete HTML document.
+        """
+        dark = is_dark()
+        colours = theme_colors(dark)
+        payload = json.dumps(_scene_payload(scene)).replace('</', '<\\/')
+        import_map = json.dumps(_import_map(offline=offline)).replace('</', '<\\/')
+        template = _environment().get_template('structure.html.j2')
+        return template.render(
+            container_id=f'crysview-{uuid.uuid4().hex}',
+            scene_json=payload,
+            import_map=import_map,
+            features_json=json.dumps(sorted(features)),
+            background=_rgb_css(colours['background']),
+            foreground=_rgb_css(colours['foreground']),
+            theme='dark' if dark else 'light',
+        )
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
new file mode 100644
index 000000000..1726ab3a7
--- /dev/null
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -0,0 +1,271 @@
+<div id="{{ container_id }}" class="crysview" style="position:relative;width:100%;height:480px;
+     background:{{ background }};color:{{ foreground }};border:1px solid rgba(128,128,128,0.3);
+     border-radius:6px;overflow:hidden;font-family:system-ui,sans-serif;">
+  <div class="crysview-canvas" style="position:absolute;inset:0;"></div>
+  <div class="crysview-modebar" style="position:absolute;top:6px;right:6px;display:flex;gap:3px;
+       flex-wrap:wrap;justify-content:flex-end;max-width:70%;"></div>
+  <div class="crysview-legend" style="position:absolute;left:8px;bottom:6px;font-size:12px;
+       display:flex;gap:10px;flex-wrap:wrap;text-shadow:0 0 2px {{ background }};"></div>
+  <div class="crysview-tooltip" style="position:absolute;padding:2px 6px;font-size:12px;
+       background:rgba(0,0,0,0.75);color:#fff;border-radius:3px;pointer-events:none;
+       display:none;"></div>
+</div>
+
+<script type="importmap">{{ import_map }}</script>
+<script type="module">
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { CSS2DRenderer, CSS2DObject } from 'three/addons/renderers/CSS2DRenderer.js';
+
+const SCENE = {{ scene_json }};
+const FEATURES = {{ features_json }};
+const FG = '{{ foreground }}';
+
+const root = document.getElementById('{{ container_id }}');
+const host = root.querySelector('.crysview-canvas');
+const modebar = root.querySelector('.crysview-modebar');
+const legend = root.querySelector('.crysview-legend');
+const tooltip = root.querySelector('.crysview-tooltip');
+
+const col = (rgb) => new THREE.Color(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255);
+const vec = (xyz) => new THREE.Vector3(xyz[0], xyz[1], xyz[2]);
+const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
+
+let width = host.clientWidth || 640;
+let height = host.clientHeight || 480;
+
+const scene = new THREE.Scene();
+const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+renderer.setPixelRatio(window.devicePixelRatio);
+renderer.setSize(width, height);
+host.appendChild(renderer.domElement);
+
+const labelRenderer = new CSS2DRenderer();
+labelRenderer.setSize(width, height);
+labelRenderer.domElement.style.position = 'absolute';
+labelRenderer.domElement.style.top = '0';
+labelRenderer.domElement.style.pointerEvents = 'none';
+host.appendChild(labelRenderer.domElement);
+
+scene.add(new THREE.AmbientLight(0xffffff, 0.65));
+const key = new THREE.DirectionalLight(0xffffff, 0.8);
+key.position.set(1, 1, 1);
+scene.add(key);
+
+const groups = {};
+for (const name of ['atoms', 'bonds', 'cell', 'axes', 'labels']) {
+  groups[name] = new THREE.Group();
+  groups[name].visible = FEATURES.includes(name);
+  scene.add(groups[name]);
+}
+
+const unitSphere = new THREE.SphereGeometry(1, 24, 16);
+
+for (const a of SCENE.atoms) {
+  const mesh = new THREE.Mesh(unitSphere, new THREE.MeshStandardMaterial({ color: col(a.colour) }));
+  mesh.position.copy(vec(a.centre));
+  mesh.scale.setScalar(a.radius);
+  mesh.userData.label = a.label;
+  groups.atoms.add(mesh);
+}
+
+for (const s of SCENE.wedgeSpheres) {
+  let phi = 0;
+  for (const w of s.wedges) {
+    const span = w.fraction * Math.PI * 2;
+    const geo = new THREE.SphereGeometry(s.radius, Math.max(6, Math.round(48 * w.fraction)), 16, phi, span);
+    const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(w.colour), side: THREE.DoubleSide }));
+    mesh.position.copy(vec(s.centre));
+    mesh.userData.label = s.label;
+    groups.atoms.add(mesh);
+    phi += span;
+  }
+}
+
+for (const e of SCENE.ellipsoids) {
+  const mesh = new THREE.Mesh(unitSphere, new THREE.MeshStandardMaterial({ color: col(e.colour) }));
+  mesh.position.copy(vec(e.centre));
+  mesh.scale.set(e.semiAxes[0], e.semiAxes[1], e.semiAxes[2]);
+  const basis = new THREE.Matrix4().makeBasis(vec(e.orientation[0]), vec(e.orientation[1]), vec(e.orientation[2]));
+  mesh.quaternion.setFromRotationMatrix(basis);
+  mesh.userData.label = e.label;
+  groups.atoms.add(mesh);
+}
+
+const addHalfBond = (p0, p1, colour) => {
+  const direction = p1.clone().sub(p0);
+  const length = direction.length();
+  if (length < 1e-6) return;
+  const geo = new THREE.CylinderGeometry(0.12, 0.12, length, 12);
+  const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(colour) }));
+  mesh.position.copy(p0.clone().add(p1).multiplyScalar(0.5));
+  mesh.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.normalize());
+  groups.bonds.add(mesh);
+};
+for (const b of SCENE.bonds) {
+  const start = vec(b.start);
+  const end = vec(b.end);
+  const mid = start.clone().add(end).multiplyScalar(0.5);
+  addHalfBond(start, mid, b.startColour);
+  addHalfBond(mid, end, b.endColour);
+}
+
+const cellMaterial = new THREE.LineBasicMaterial({ color: new THREE.Color(FG) });
+for (const edge of SCENE.cellEdges) {
+  const geo = new THREE.BufferGeometry().setFromPoints([vec(edge.start), vec(edge.end)]);
+  groups.cell.add(new THREE.Line(geo, cellMaterial));
+}
+
+if (SCENE.axes) {
+  const origin = vec(SCENE.axes.origin);
+  for (const arrow of SCENE.axes.arrows) {
+    const v = vec(arrow.vector);
+    const len = v.length();
+    groups.axes.add(new THREE.ArrowHelper(v.clone().normalize(), origin, len, col(arrow.colour).getHex(), len * 0.12, len * 0.07));
+    const div = document.createElement('div');
+    div.textContent = arrow.letter;
+    div.style.color = `rgb(${arrow.colour[0]},${arrow.colour[1]},${arrow.colour[2]})`;
+    div.style.fontWeight = 'bold';
+    const tag = new CSS2DObject(div);
+    tag.position.copy(origin.clone().add(v.clone().multiplyScalar(1.12)));
+    groups.axes.add(tag);
+  }
+}
+
+for (const label of SCENE.labels) {
+  const div = document.createElement('div');
+  div.textContent = label.text;
+  div.style.fontSize = '11px';
+  div.style.color = FG;
+  const obj = new CSS2DObject(div);
+  obj.position.copy(vec(label.anchor));
+  groups.labels.add(obj);
+}
+
+const box = new THREE.Box3();
+scene.traverse((obj) => {
+  if (obj.isMesh || obj.isLine) box.expandByObject(obj);
+});
+if (box.isEmpty()) box.set(new THREE.Vector3(-1, -1, -1), new THREE.Vector3(1, 1, 1));
+const target = box.getBoundingSphere(new THREE.Sphere()).center;
+const radius = Math.max(box.getBoundingSphere(new THREE.Sphere()).radius, 1);
+const aspect = width / height;
+const far = radius * 100;
+const distance = radius * 2.6;
+const home = target.clone().add(new THREE.Vector3(distance, distance * 0.6, distance));
+
+const perspective = new THREE.PerspectiveCamera(45, aspect, radius * 0.01, far);
+const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.3, radius * aspect * 1.3, radius * 1.3, -radius * 1.3, -far, far);
+perspective.position.copy(home);
+ortho.position.copy(home);
+let camera = ortho;
+
+const controls = new OrbitControls(camera, renderer.domElement);
+controls.target.copy(target);
+controls.update();
+
+const setCamera = (next) => {
+  next.position.copy(camera.position);
+  controls.object = next;
+  camera = next;
+  controls.update();
+};
+const viewAlong = (axisVector) => {
+  camera.position.copy(target.clone().add(axisVector.clone().normalize().multiplyScalar(distance)));
+  controls.update();
+};
+
+const button = (label, title, onClick) => {
+  const el = document.createElement('button');
+  el.textContent = label;
+  el.title = title;
+  el.style.cssText = 'font-size:11px;padding:2px 6px;cursor:pointer;border-radius:3px;' +
+    'border:1px solid rgba(128,128,128,0.5);background:rgba(128,128,128,0.15);color:inherit;';
+  el.addEventListener('click', onClick);
+  modebar.appendChild(el);
+  return el;
+};
+
+button('persp/ortho', 'Toggle perspective / parallel projection', () => {
+  setCamera(camera === ortho ? perspective : ortho);
+});
+const cellBasis = SCENE.axes ? SCENE.axes.arrows.map((a) => vec(a.vector)) : [];
+['a', 'b', 'c'].forEach((letter, i) => {
+  if (cellBasis[i]) button(letter, `View along ${letter}`, () => viewAlong(cellBasis[i]));
+});
+button('reset', 'Reset the view', () => {
+  camera.position.copy(home);
+  controls.target.copy(target);
+  controls.update();
+});
+for (const name of ['atoms', 'bonds', 'cell', 'axes', 'labels']) {
+  if (groups[name].children.length === 0) continue;
+  const btn = button(name, `Toggle ${name}`, () => {
+    groups[name].visible = !groups[name].visible;
+    btn.style.opacity = groups[name].visible ? '1' : '0.45';
+  });
+  btn.style.opacity = groups[name].visible ? '1' : '0.45';
+}
+
+const seen = new Map();
+const collectLegend = (label, colour) => {
+  const element = elementOf(label);
+  if (!seen.has(element)) seen.set(element, colour);
+};
+SCENE.atoms.forEach((a) => collectLegend(a.label, a.colour));
+SCENE.ellipsoids.forEach((e) => collectLegend(e.label, e.colour));
+SCENE.wedgeSpheres.forEach((s) => s.wedges[0] && collectLegend(s.label, s.wedges[0].colour));
+for (const [element, colour] of seen) {
+  const item = document.createElement('span');
+  item.style.cssText = 'display:inline-flex;align-items:center;gap:4px;';
+  const swatch = document.createElement('span');
+  swatch.style.cssText = `display:inline-block;width:10px;height:10px;border-radius:50%;` +
+    `background:rgb(${colour[0]},${colour[1]},${colour[2]});`;
+  item.appendChild(swatch);
+  const text = document.createElement('span');
+  text.textContent = element;
+  item.appendChild(text);
+  legend.appendChild(item);
+}
+
+const raycaster = new THREE.Raycaster();
+const pointer = new THREE.Vector2();
+renderer.domElement.addEventListener('pointermove', (event) => {
+  const rect = renderer.domElement.getBoundingClientRect();
+  pointer.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+  pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+  raycaster.setFromCamera(pointer, camera);
+  const hits = raycaster.intersectObjects(groups.atoms.children, false);
+  const labelled = hits.find((hit) => hit.object.userData.label);
+  if (labelled) {
+    tooltip.textContent = labelled.object.userData.label;
+    tooltip.style.left = `${event.clientX - rect.left + 8}px`;
+    tooltip.style.top = `${event.clientY - rect.top + 8}px`;
+    tooltip.style.display = 'block';
+  } else {
+    tooltip.style.display = 'none';
+  }
+});
+
+const resize = () => {
+  width = host.clientWidth || width;
+  height = host.clientHeight || height;
+  const ratio = width / height;
+  perspective.aspect = ratio;
+  perspective.updateProjectionMatrix();
+  ortho.left = -radius * ratio * 1.3;
+  ortho.right = radius * ratio * 1.3;
+  ortho.updateProjectionMatrix();
+  renderer.setSize(width, height);
+  labelRenderer.setSize(width, height);
+};
+if (window.ResizeObserver) new ResizeObserver(resize).observe(host);
+
+const animate = () => {
+  requestAnimationFrame(animate);
+  controls.update();
+  renderer.render(scene, camera);
+  labelRenderer.render(scene, camera);
+};
+animate();
+</script>
diff --git a/src/easydiffraction/display/structure/viewing.py b/src/easydiffraction/display/structure/viewing.py
index bdaee0f5e..94c1db611 100644
--- a/src/easydiffraction/display/structure/viewing.py
+++ b/src/easydiffraction/display/structure/viewing.py
@@ -8,6 +8,7 @@
 from easydiffraction.display.base import RendererFactoryBase
 from easydiffraction.display.structure.enums import ViewerEngineEnum
 from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
 from easydiffraction.display.structure.scene import StructureScene
 
 
@@ -21,6 +22,10 @@ def _registry(cls) -> dict:
                 'description': ViewerEngineEnum.ASCII.description(),
                 'class': AsciiStructureRenderer,
             },
+            ViewerEngineEnum.THREEJS.value: {
+                'description': ViewerEngineEnum.THREEJS.description(),
+                'class': ThreeJsStructureRenderer,
+            },
         }
 
 

From acd43cb5a5d153691ea3d8eabcbad23ce8971a0d Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:13:51 +0200
Subject: [PATCH 020/160] Embed structure figure in HTML report under
 html_offline

---
 .../plans/crysview-structure-visualization.md |  2 +-
 .../project/categories/report/default.py      |  2 +-
 src/easydiffraction/report/html_renderer.py   | 43 ++++++++++++++++++-
 .../report/templates/html/report.html.j2      |  5 +++
 4 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 805aa7f56..946e10521 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -901,7 +901,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
       standalone-HTML write path.
   - Commit: `Add Three.js structure renderer`.
 
-- [ ] **P1.15 — Embed the structure figure in the HTML report**
+- [x] **P1.15 — Embed the structure figure in the HTML report**
   - Files: existing `src/easydiffraction/report/html_renderer.py`,
     `src/easydiffraction/report/templates/html/report.html.j2`.
   - Render a structure figure into the HTML report honoring the report's
diff --git a/src/easydiffraction/project/categories/report/default.py b/src/easydiffraction/project/categories/report/default.py
index 054b0b398..156cd2f98 100644
--- a/src/easydiffraction/project/categories/report/default.py
+++ b/src/easydiffraction/project/categories/report/default.py
@@ -195,7 +195,7 @@ def as_html(self, *, offline: bool = False) -> str:
         """
         from easydiffraction.report.html_renderer import render_html_report  # noqa: PLC0415
 
-        return render_html_report(self.data_context(), offline=offline)
+        return render_html_report(self.data_context(), offline=offline, project=self.project)
 
     def save_tex(self) -> pathlib.Path:
         """
diff --git a/src/easydiffraction/report/html_renderer.py b/src/easydiffraction/report/html_renderer.py
index dc557a60e..f9790c956 100644
--- a/src/easydiffraction/report/html_renderer.py
+++ b/src/easydiffraction/report/html_renderer.py
@@ -63,6 +63,7 @@ def render_html_report(
     context: dict[str, object],
     *,
     offline: bool = False,
+    project: object | None = None,
 ) -> str:
     """
     Render a report data context as HTML.
@@ -73,6 +74,9 @@ def render_html_report(
         Data returned by ``Report.data_context()``.
     offline : bool, default=False
         Whether Plotly figures should embed JavaScript assets.
+    project : object | None, default=None
+        Live project used to build interactive 3D structure figures.
+        When ``None``, the report omits structure views.
 
     Returns
     -------
@@ -87,6 +91,9 @@ def render_html_report(
         context,
         offline=offline,
     )
+    template_context['structure_figures'] = (
+        _structure_figure_html_context(project, offline=offline) if project is not None else {}
+    )
     return _environment().get_template(_TEMPLATE_NAME).render(**template_context)
 
 
@@ -119,7 +126,7 @@ def save_html_report(
     output_path = html_report_path(project, path)
     output_path.parent.mkdir(parents=True, exist_ok=True)
     output_path.write_text(
-        render_html_report(context, offline=offline),
+        render_html_report(context, offline=offline, project=project),
         encoding='utf-8',
     )
     if offline:
@@ -185,6 +192,40 @@ def _fit_figure_html_context(
     return rendered
 
 
+def _structure_figure_html_context(
+    project: object,
+    *,
+    offline: bool,
+) -> dict[str, str]:
+    """Return interactive structure-view HTML snippets by structure name."""
+    from easydiffraction.display.structure.builder import build_scene  # noqa: PLC0415
+    from easydiffraction.display.structure.builder import (  # noqa: PLC0415
+        structure_feature_availability,
+    )
+    from easydiffraction.display.structure.renderers.threejs import (  # noqa: PLC0415
+        ThreeJsStructureRenderer,
+    )
+
+    renderer = ThreeJsStructureRenderer()
+    window = project.view.view_range()
+    rendered: dict[str, str] = {}
+    for structure in project.structures.values():
+        availability = structure_feature_availability(structure, style=project.style)
+        features = project.display._resolve_structure_features('auto', availability)
+        scene = build_scene(
+            structure,
+            style=project.style,
+            view_range=window,
+            features=features,
+        )
+        rendered[str(structure.name)] = renderer.render(
+            scene,
+            features=features,
+            offline=offline,
+        )
+    return rendered
+
+
 def _fit_data_figure(
     experiment_id: str,
     fit_data: dict[str, object],
diff --git a/src/easydiffraction/report/templates/html/report.html.j2 b/src/easydiffraction/report/templates/html/report.html.j2
index f380782d2..eabd0fc3e 100644
--- a/src/easydiffraction/report/templates/html/report.html.j2
+++ b/src/easydiffraction/report/templates/html/report.html.j2
@@ -140,6 +140,11 @@
       <article class="record">
         <h3>{{ structure.id }}</h3>
 
+        {% if structure_figures[structure.id] %}
+        <h4>Structure view</h4>
+        <div class="figure">{{ structure_figures[structure.id] | safe }}</div>
+        {% endif %}
+
         {% for category in structure.categories %}
         <h4>{{ category.title }}</h4>
         {% if category.kind == "item" %}

From dbcf55f115c3f6fec5ec27edef0a397e149bcc39 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:20:45 +0200
Subject: [PATCH 021/160] Document structure view in tutorials and reference

---
 docs/dev/adrs/index.md                        |   1 +
 .../plans/crysview-structure-visualization.md |   2 +-
 docs/docs/tutorials/ed-3.ipynb                | 380 ++++++++++++------
 docs/docs/tutorials/ed-3.py                   |  56 +++
 .../user-guide/analysis-workflow/model.md     |  58 +++
 5 files changed, 377 insertions(+), 120 deletions(-)

diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index 2f86cd54b..be1eb4485 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -43,6 +43,7 @@ folders.
 | Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
 | Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                       | [`test-strategy.md`](accepted/test-strategy.md)                                              |
 | Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                      | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                  |
+| User-facing API      | Suggestion | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures. | [`crysview-structure-visualization.md`](suggestions/crysview-structure-visualization.md)     |
 | User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                       | [`display-ux.md`](accepted/display-ux.md)                                                    |
 | User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.    | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                    |
 | User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and publication metadata surfaces.             | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 946e10521..8350daa45 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -912,7 +912,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     switch at `html_renderer.py:170`.
   - Commit: `Embed structure figure in HTML report under html_offline`.
 
-- [ ] **P1.16 — Promote ADR index row, tutorials, and docs**
+- [x] **P1.16 — Promote ADR index row, tutorials, and docs**
   - Files: existing [`docs/dev/adrs/index.md`](../adrs/index.md);
     `docs/docs/tutorials/*.py` (+ regenerated `*.ipynb`);
     `docs/docs/user-guide/`, `docs/docs/api-reference/`.
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index 2a61c928a..cf39258af 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -385,6 +385,148 @@
    "cell_type": "markdown",
    "id": "33",
    "metadata": {},
+   "source": [
+    "#### View Structure in 3D\n",
+    "\n",
+    "EasyDiffraction can draw the structure that has just been defined. The\n",
+    "renderer engine is selected through `project.view`. The default\n",
+    "`threejs` engine shows an interactive 3D view inside Jupyter, while the\n",
+    "`ascii` engine prints a compact schematic that works in any terminal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.view.show_supported()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35",
+   "metadata": {},
+   "source": [
+    "Visual styling — the atom shape, per-element radius model, and colour\n",
+    "scheme — is configured on `project.style`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.style.show_supported()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.style.atom_shape = 'ball'\n",
+    "project.style.radius_model = 'covalent'\n",
+    "project.style.color_scheme = 'jmol'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38",
+   "metadata": {},
+   "source": [
+    "Bonds are generated automatically between atoms whose separation lies\n",
+    "within the per-structure cutoffs stored on `structure.geom`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.structures['lbco'].geom.min_bond_distance_cutoff = 0.5\n",
+    "project.structures['lbco'].geom.bond_distance_incr = 0.45"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40",
+   "metadata": {},
+   "source": [
+    "List which features the structure data and the active engine can draw."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.show_structure_options(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42",
+   "metadata": {},
+   "source": [
+    "Draw the structure. With `include='auto'` (the default) every available\n",
+    "feature is shown; a specific tuple such as `('atoms', 'bonds', 'cell')`\n",
+    "can be requested instead."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44",
+   "metadata": {},
+   "source": [
+    "For a quick text schematic in any terminal, switch to the `ascii`\n",
+    "engine, then restore the interactive default."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.view.type = 'ascii'\n",
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.view.type = 'threejs'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47",
+   "metadata": {},
    "source": [
     "#### Save Project State\n",
     "\n",
@@ -396,7 +538,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -405,7 +547,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "49",
    "metadata": {},
    "source": [
     "## Step 3: Define Experiment\n",
@@ -416,7 +558,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "36",
+   "id": "50",
    "metadata": {},
    "source": [
     "#### Download Measured Data\n",
@@ -427,7 +569,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -436,7 +578,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Add Diffraction Experiment"
@@ -445,7 +587,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -460,7 +602,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "54",
    "metadata": {},
    "source": [
     "#### Show Defined Experiments"
@@ -469,7 +611,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -478,7 +620,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "56",
    "metadata": {},
    "source": [
     "#### Show Measured Data"
@@ -487,7 +629,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -496,7 +638,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "44",
+   "id": "58",
    "metadata": {},
    "source": [
     "#### Set Instrument\n",
@@ -507,7 +649,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "45",
+   "id": "59",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -517,7 +659,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "46",
+   "id": "60",
    "metadata": {},
    "source": [
     "#### Set Peak Profile\n",
@@ -528,7 +670,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "47",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -537,7 +679,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "48",
+   "id": "62",
    "metadata": {},
    "source": [
     "Select the desired peak profile type."
@@ -546,7 +688,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "63",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -555,7 +697,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "64",
    "metadata": {},
    "source": [
     "Modify default peak profile parameters."
@@ -564,7 +706,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "65",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -577,7 +719,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "66",
    "metadata": {},
    "source": [
     "#### Set Background"
@@ -585,7 +727,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "53",
+   "id": "67",
    "metadata": {},
    "source": [
     "Show supported background types."
@@ -594,7 +736,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "54",
+   "id": "68",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -603,7 +745,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "55",
+   "id": "69",
    "metadata": {},
    "source": [
     "Select the desired background type."
@@ -612,7 +754,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "56",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -621,7 +763,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "57",
+   "id": "71",
    "metadata": {},
    "source": [
     "Add background points."
@@ -630,7 +772,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -643,7 +785,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "73",
    "metadata": {},
    "source": [
     "Show current background points."
@@ -652,7 +794,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "74",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -661,7 +803,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "61",
+   "id": "75",
    "metadata": {},
    "source": [
     "#### Set Linked Phases\n",
@@ -672,7 +814,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "62",
+   "id": "76",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -681,7 +823,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "77",
    "metadata": {},
    "source": [
     "#### Show Experiment as CIF"
@@ -690,7 +832,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "78",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -699,7 +841,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "79",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -708,7 +850,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "80",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -717,7 +859,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "81",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis\n",
@@ -733,7 +875,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "82",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -742,7 +884,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "69",
+   "id": "83",
    "metadata": {},
    "source": [
     "Select the desired calculation engine."
@@ -751,7 +893,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "84",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -760,7 +902,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71",
+   "id": "85",
    "metadata": {},
    "source": [
     "#### Show Calculated Data"
@@ -769,7 +911,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "72",
+   "id": "86",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -778,7 +920,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "73",
+   "id": "87",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -787,7 +929,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "74",
+   "id": "88",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -797,7 +939,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "75",
+   "id": "89",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -806,7 +948,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "76",
+   "id": "90",
    "metadata": {},
    "source": [
     "#### Show Parameters\n",
@@ -817,7 +959,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "77",
+   "id": "91",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -826,7 +968,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "78",
+   "id": "92",
    "metadata": {},
    "source": [
     "Show all fittable parameters."
@@ -835,7 +977,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "79",
+   "id": "93",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -844,7 +986,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "80",
+   "id": "94",
    "metadata": {},
    "source": [
     "Show only free parameters."
@@ -853,7 +995,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "81",
+   "id": "95",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -862,7 +1004,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "82",
+   "id": "96",
    "metadata": {},
    "source": [
     "Show how to access parameters in the code."
@@ -871,7 +1013,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "83",
+   "id": "97",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -880,7 +1022,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "84",
+   "id": "98",
    "metadata": {},
    "source": [
     "#### Set Fit Mode\n",
@@ -891,7 +1033,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "85",
+   "id": "99",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -900,7 +1042,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "86",
+   "id": "100",
    "metadata": {},
    "source": [
     "Select desired fit mode."
@@ -909,7 +1051,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "87",
+   "id": "101",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -918,7 +1060,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "88",
+   "id": "102",
    "metadata": {},
    "source": [
     "#### Set Minimizer\n",
@@ -929,7 +1071,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "89",
+   "id": "103",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -938,7 +1080,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "90",
+   "id": "104",
    "metadata": {},
    "source": [
     "Select desired fitting engine."
@@ -947,7 +1089,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "91",
+   "id": "105",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -956,7 +1098,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "92",
+   "id": "106",
    "metadata": {},
    "source": [
     "### Perform Fit 1/5\n",
@@ -967,7 +1109,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "93",
+   "id": "107",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -976,7 +1118,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "94",
+   "id": "108",
    "metadata": {},
    "source": [
     "Set experiment parameters to be refined."
@@ -985,7 +1127,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "95",
+   "id": "109",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1000,7 +1142,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "96",
+   "id": "110",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1009,7 +1151,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "97",
+   "id": "111",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1018,7 +1160,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "98",
+   "id": "112",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1027,7 +1169,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "99",
+   "id": "113",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1037,7 +1179,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "100",
+   "id": "114",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1046,7 +1188,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "101",
+   "id": "115",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1056,7 +1198,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "102",
+   "id": "116",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1065,7 +1207,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "103",
+   "id": "117",
    "metadata": {},
    "source": [
     "### Perform Fit 2/5\n",
@@ -1076,7 +1218,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "104",
+   "id": "118",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1088,7 +1230,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "105",
+   "id": "119",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1097,7 +1239,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "106",
+   "id": "120",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1106,7 +1248,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "107",
+   "id": "121",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1115,7 +1257,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "108",
+   "id": "122",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1125,7 +1267,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "109",
+   "id": "123",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1134,7 +1276,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "110",
+   "id": "124",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1144,7 +1286,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "111",
+   "id": "125",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1153,7 +1295,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "112",
+   "id": "126",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -1162,7 +1304,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "113",
+   "id": "127",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1171,7 +1313,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "114",
+   "id": "128",
    "metadata": {},
    "source": [
     "### Perform Fit 3/5\n",
@@ -1182,7 +1324,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "115",
+   "id": "129",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1194,7 +1336,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "116",
+   "id": "130",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1203,7 +1345,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "117",
+   "id": "131",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1212,7 +1354,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "118",
+   "id": "132",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1221,7 +1363,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "119",
+   "id": "133",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1231,7 +1373,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "120",
+   "id": "134",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1240,7 +1382,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "121",
+   "id": "135",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1250,7 +1392,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "122",
+   "id": "136",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1259,7 +1401,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "123",
+   "id": "137",
    "metadata": {},
    "source": [
     "### Perform Fit 4/5\n",
@@ -1272,7 +1414,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "124",
+   "id": "138",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1288,7 +1430,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "125",
+   "id": "139",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -1297,7 +1439,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "126",
+   "id": "140",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1306,7 +1448,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "127",
+   "id": "141",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1315,7 +1457,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "128",
+   "id": "142",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1324,7 +1466,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "129",
+   "id": "143",
    "metadata": {},
    "source": [
     "Show free parameters."
@@ -1333,7 +1475,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "130",
+   "id": "144",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1342,7 +1484,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "131",
+   "id": "145",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1351,7 +1493,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "132",
+   "id": "146",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1361,7 +1503,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "133",
+   "id": "147",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1370,7 +1512,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "134",
+   "id": "148",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1380,7 +1522,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "135",
+   "id": "149",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1389,7 +1531,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "136",
+   "id": "150",
    "metadata": {},
    "source": [
     "### Perform Fit 5/5\n",
@@ -1402,7 +1544,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "137",
+   "id": "151",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1418,7 +1560,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "138",
+   "id": "152",
    "metadata": {},
    "source": [
     "Set more constraints."
@@ -1427,7 +1569,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "139",
+   "id": "153",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1438,7 +1580,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "140",
+   "id": "154",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1447,7 +1589,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "141",
+   "id": "155",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -1458,7 +1600,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "142",
+   "id": "156",
    "metadata": {},
    "source": [
     "Set structure parameters to be refined."
@@ -1467,7 +1609,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "143",
+   "id": "157",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1476,7 +1618,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "144",
+   "id": "158",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1485,7 +1627,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "145",
+   "id": "159",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1494,7 +1636,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "146",
+   "id": "160",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1503,7 +1645,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "147",
+   "id": "161",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1514,7 +1656,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "148",
+   "id": "162",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1523,7 +1665,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "149",
+   "id": "163",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1533,7 +1675,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "150",
+   "id": "164",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1542,7 +1684,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "151",
+   "id": "165",
    "metadata": {},
    "source": [
     "## Step 5: Generate Report\n",
@@ -1562,7 +1704,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "152",
+   "id": "166",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index 49ac1d7e6..ff6bfce9e 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -172,6 +172,62 @@
 # %%
 project.structures['lbco'].show()
 
+# %% [markdown]
+# #### View Structure in 3D
+#
+# EasyDiffraction can draw the structure that has just been defined. The
+# renderer engine is selected through `project.view`. The default
+# `threejs` engine shows an interactive 3D view inside Jupyter, while the
+# `ascii` engine prints a compact schematic that works in any terminal.
+
+# %%
+project.view.show_supported()
+
+# %% [markdown]
+# Visual styling — the atom shape, per-element radius model, and colour
+# scheme — is configured on `project.style`.
+
+# %%
+project.style.show_supported()
+
+# %%
+project.style.atom_shape = 'ball'
+project.style.radius_model = 'covalent'
+project.style.color_scheme = 'jmol'
+
+# %% [markdown]
+# Bonds are generated automatically between atoms whose separation lies
+# within the per-structure cutoffs stored on `structure.geom`.
+
+# %%
+project.structures['lbco'].geom.min_bond_distance_cutoff = 0.5
+project.structures['lbco'].geom.bond_distance_incr = 0.45
+
+# %% [markdown]
+# List which features the structure data and the active engine can draw.
+
+# %%
+project.display.show_structure_options(struct_name='lbco')
+
+# %% [markdown]
+# Draw the structure. With `include='auto'` (the default) every available
+# feature is shown; a specific tuple such as `('atoms', 'bonds', 'cell')`
+# can be requested instead.
+
+# %%
+project.display.structure(struct_name='lbco')
+
+# %% [markdown]
+# For a quick text schematic in any terminal, switch to the `ascii`
+# engine, then restore the interactive default.
+
+# %%
+project.view.type = 'ascii'
+project.display.structure(struct_name='lbco')
+
+# %%
+project.view.type = 'threejs'
+
 # %% [markdown]
 # #### Save Project State
 #
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 3227199d6..14da2a758 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -180,6 +180,64 @@ Structure 🧩 'lbco' as cif
 ╘═══════════════════════════════════════════╛
 ```
 
+## Viewing a Model in 3D
+
+EasyDiffraction can render a defined structure as an interactive 3D view.
+The renderer engine is chosen through `project.view`. The interactive
+Three.js engine is the default; the ASCII engine prints a
+terminal-friendly schematic.
+
+```python
+# List the available renderer engines
+project.view.show_supported()
+
+# Switch the active engine if desired
+project.view.type = 'threejs'
+```
+
+Visual styling — independent of the per-element data — is configured on
+`project.style`:
+
+```python
+# List the accepted style settings
+project.style.show_supported()
+
+# Choose how atoms are depicted, sized, and coloured
+project.style.atom_shape = 'ball'  # 'ball' or 'ortep'
+project.style.radius_model = 'covalent'  # 'vdw', 'covalent', 'ionic', 'atomic'
+project.style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
+```
+
+Bonds are generated automatically between atoms whose separation falls
+within the per-structure cutoffs stored on `structure.geom` (the standard
+cif_core `_geom` parameters):
+
+```python
+# Tune the per-structure bond-generation cutoffs (angstrom)
+project.structures['lbco'].geom.min_bond_distance_cutoff = 0.5
+project.structures['lbco'].geom.bond_distance_incr = 0.45
+```
+
+Draw the structure through `project.display`, mirroring
+`project.display.pattern()`:
+
+```python
+# List which features the data and active engine can draw
+project.display.show_structure_options(struct_name='lbco')
+
+# Draw the structure (include='auto' shows every available feature)
+project.display.structure(struct_name='lbco')
+
+# Or request a specific set of features
+project.display.structure(
+    struct_name='lbco',
+    include=('atoms', 'bonds', 'cell'),
+)
+```
+
+The same interactive view is embedded automatically in the HTML report
+(see the [Report](report.md) section).
+
 ## Saving a Model
 
 Saving the project, as described in the [Project](project.md) section,

From 9135f3125681b3175a16f809ec77858b6bc1b65d Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:20:59 +0200
Subject: [PATCH 022/160] Reach Phase 1 review gate

---
 docs/dev/plans/crysview-structure-visualization.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 8350daa45..9ba7993c6 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -930,7 +930,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     reference and a short user-guide section.
   - Commit: `Document structure view in tutorials and reference`.
 
-- [ ] **P1.17 — Reach Phase 1 review gate**
+- [x] **P1.17 — Reach Phase 1 review gate**
   - No-code step. Mark every `[ ]` above as `[x]`; commit the plan-file
     update alone.
   - Commit: `Reach Phase 1 review gate`.

From 506ce7906b7ebddf84ea8fcbc82a051d0f3332a0 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:25:39 +0200
Subject: [PATCH 023/160] Resync tutorial notebooks with sources

---
 docs/docs/tutorials/ed-13.ipynb |  2 +-
 docs/docs/tutorials/ed-14.ipynb | 17 ++++++++---------
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/docs/docs/tutorials/ed-13.ipynb b/docs/docs/tutorials/ed-13.ipynb
index 5734acb88..3dce6bc36 100644
--- a/docs/docs/tutorials/ed-13.ipynb
+++ b/docs/docs/tutorials/ed-13.ipynb
@@ -2648,7 +2648,7 @@
  ],
  "metadata": {
   "jupytext": {
-   "cell_metadata_filter": "title,tags,-all",
+   "cell_metadata_filter": "tags,title,-all",
    "main_language": "python",
    "notebook_metadata_filter": "-all"
   }
diff --git a/docs/docs/tutorials/ed-14.ipynb b/docs/docs/tutorials/ed-14.ipynb
index 76b1ca781..b6c62e3bb 100644
--- a/docs/docs/tutorials/ed-14.ipynb
+++ b/docs/docs/tutorials/ed-14.ipynb
@@ -64,7 +64,12 @@
    "outputs": [],
    "source": [
     "# Create minimal project without name and description\n",
-    "project = ed.Project()\n",
+    "project = ed.Project(name='tbti_heidi')\n",
+    "project.info.title = 'Tb2Ti2O7 at HEiDi@FRMII'\n",
+    "project.info.description = \"\"\"This project demonstrates a standard\n",
+    "refinement of the crystal structure of Tb2Ti2O7 using single crystal \n",
+    "neutron diffraction data from HEiDi at FRM II.\"\"\"\n",
+    "\n",
     "project.save_as('projects/tbti_heidi')"
    ]
   },
@@ -444,13 +449,7 @@
    "id": "40",
    "metadata": {},
    "source": [
-    "## Step 6: Generate Report\n",
-    "\n",
-    "By default, no report files are generated. Here we enable HTML and\n",
-    "TeX reports, so that both the HTML and PDF report files are generated\n",
-    "when saving the project.\n",
-    "\n",
-    "We also support saving the report in CIF and TEX formats."
+    "## Step 6: Generate Report"
    ]
   },
   {
@@ -460,7 +459,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.report.html = True\n",
+    "# Enable PDF report generation before the last save (time consuming)\n",
     "project.report.pdf = True\n",
     "project.save()"
    ]

From 87e11f8fa9230c1d3a5916d424267f94492bf3c3 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:31:13 +0200
Subject: [PATCH 024/160] Default structure view engine to environment-aware
 auto

---
 .../display/structure/enums.py                |  8 ++++++--
 .../project/categories/view/default.py        | 19 ++++++++++++++-----
 src/easydiffraction/project/display.py        |  2 +-
 3 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
index 2813beb1a..4976b72ce 100644
--- a/src/easydiffraction/display/structure/enums.py
+++ b/src/easydiffraction/display/structure/enums.py
@@ -6,6 +6,8 @@
 
 from enum import StrEnum
 
+from easydiffraction.utils.environment import in_jupyter
+
 
 class ViewerEngineEnum(StrEnum):
     """Available structure-view renderer engines."""
@@ -15,8 +17,10 @@ class ViewerEngineEnum(StrEnum):
 
     @classmethod
     def default(cls) -> ViewerEngineEnum:
-        """Select the default engine (rich Three.js, headless-friendly)."""
-        return cls.THREEJS
+        """Select the default engine based on environment."""
+        if in_jupyter():
+            return cls.THREEJS
+        return cls.ASCII
 
     def description(self) -> str:
         """Human-readable description for UI listings."""
diff --git a/src/easydiffraction/project/categories/view/default.py b/src/easydiffraction/project/categories/view/default.py
index 9ff8ef44f..929d0b0e6 100644
--- a/src/easydiffraction/project/categories/view/default.py
+++ b/src/easydiffraction/project/categories/view/default.py
@@ -20,7 +20,9 @@
 from easydiffraction.project.categories.view.factory import ViewFactory
 from easydiffraction.utils.logging import log
 
-VIEW_ENGINE_OPTIONS = [member.value for member in ViewerEngineEnum]
+AUTO_ENGINE = 'auto'
+AUTO_DESCRIPTION = 'Environment default structure-view engine'
+VIEW_ENGINE_OPTIONS = [AUTO_ENGINE, *[member.value for member in ViewerEngineEnum]]
 
 
 def _range_descriptor(name: str, default: float) -> NumericDescriptor:
@@ -53,7 +55,7 @@ def __init__(self) -> None:
             name='type',
             description='Structure-view renderer backend type',
             value_spec=AttributeSpec(
-                default=ViewerEngineEnum.default().value,
+                default=AUTO_ENGINE,
                 validator=MembershipValidator(allowed=VIEW_ENGINE_OPTIONS),
             ),
             cif_handler=CifHandler(names=['_view.type']),
@@ -77,6 +79,12 @@ def __init__(self) -> None:
         self._range_c_min = _range_descriptor('range_c_min', 0.0)
         self._range_c_max = _range_descriptor('range_c_max', 1.0)
 
+    @staticmethod
+    def _resolved_engine(value: str) -> str:
+        if value == AUTO_ENGINE:
+            return ViewerEngineEnum.default().value
+        return value
+
     def _set_type(self, value: str, *, strict: bool = True) -> None:
         if value not in VIEW_ENGINE_OPTIONS:
             msg = (
@@ -87,15 +95,16 @@ def _set_type(self, value: str, *, strict: bool = True) -> None:
                 raise ValueError(msg)
             log.warning(msg)
             return
-        if self._viewer.engine != value:
-            self._viewer.engine = value
+        resolved_engine = self._resolved_engine(value)
+        if self._viewer.engine != resolved_engine:
+            self._viewer.engine = resolved_engine
         self._type.value = value
 
     @staticmethod
     def _supported_types(filters: dict[str, object]) -> list[tuple[str, str]]:
         """Return supported structure-view renderer backends."""
         del filters
-        return ViewerFactory.descriptions()
+        return [(AUTO_ENGINE, AUTO_DESCRIPTION), *ViewerFactory.descriptions()]
 
     @property
     def viewer(self) -> Viewer:
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 461797a0c..784777ee9 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -606,7 +606,7 @@ def _emit_structure_output(self, output: str) -> None:
         from easydiffraction.display.structure.enums import ViewerEngineEnum  # noqa: PLC0415
         from easydiffraction.utils.environment import in_jupyter  # noqa: PLC0415
 
-        if self._project.view.type == ViewerEngineEnum.ASCII.value:
+        if self._project.view.viewer.engine == ViewerEngineEnum.ASCII.value:
             console.print(output)
             return
         if in_jupyter():

From 6b7ec70bf135a914d2dc47a1c5e6cfe44dfc9036 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:35:18 +0200
Subject: [PATCH 025/160] Document auto default for structure view engine

---
 .../crysview-structure-visualization.md       | 14 +++--
 .../plans/crysview-structure-visualization.md | 55 +++++++++++--------
 docs/docs/tutorials/ed-3.ipynb                | 12 ++--
 docs/docs/tutorials/ed-3.py                   | 12 ++--
 .../user-guide/analysis-workflow/model.md     | 11 ++--
 5 files changed, 58 insertions(+), 46 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 2ac563dcc..61e2d0e2c 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -112,7 +112,7 @@ A switchable engine selector is added on the project owner, parallel to
 `project.chart` / `project.table`. It is named `view`:
 
 ```python
-project.view.type = 'threejs'   # or 'ascii' for the terminal
+project.view.type = 'auto'   # default: 'threejs' in Jupyter, 'ascii' in a terminal
 project.view.show_supported()
 ```
 
@@ -123,7 +123,10 @@ with CIF tag `_view.type`. The name is kept short and parallel to
 `project.view.show_supported()` lists engines. Switching `type` calls
 the owner's private `_swap_view` hook, which rebinds the active renderer
 — the same Family B rebinding the chart engine selector uses — so no
-public `view_type` setter or `show_supported_view_types()` is added.
+public `view_type` setter or `show_supported_view_types()` is added. The
+default is `auto`, which resolves at draw time to `threejs` in a Jupyter
+notebook and `ascii` in a terminal — exactly as `_chart.type` /
+`_table.type` resolve their environment defaults.
 
 ### 3. Add a `structure()` entry point on the display facade
 
@@ -464,7 +467,7 @@ persisted to CIF.
 
 ```python
 # How: renderer engine
-project.view.type = 'threejs'        # or 'ascii' for the terminal
+project.view.type = 'auto'           # default: 'threejs' in Jupyter, 'ascii' in a terminal
 project.view.show_supported()
 
 # How: standard styling models, not per-element values (visual only)
@@ -506,7 +509,7 @@ The persisted equivalent in the project CIF:
 
 ```
 # In the project CIF (project-level view + style):
-_view.type           threejs
+_view.type           auto
 _view.show_labels    false
 _view.show_moments   true
 _view.range_a_min    0
@@ -527,7 +530,8 @@ _geom.bond_distance_incr         0.4
 ```
 
 The `_view.type` tag follows `_chart.type` / `_table.type` from the
-Display UX Facade ADR; `_geom.min_bond_distance_cutoff` and
+Display UX Facade ADR, including their `auto` environment-default
+convention (resolved to `threejs` in Jupyter, `ascii` in a terminal); `_geom.min_bond_distance_cutoff` and
 `_geom.bond_distance_incr` are the **standard cif_core** bond-cutoff
 tags (`_atom_type.radius_bond` is the standard per-type bonding radius,
 used when present). The `_style.*` and `_view.*` tags are
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 9ba7993c6..a25083a19 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -86,10 +86,11 @@ plan-level structural choices confirmed with the author at plan start.
   `threejs` (notebook + standalone HTML), shipping together exactly as
   the `asciichartpy` and `plotly` chart engines do. Qt Quick 3D is
   deferred.
-- **Switchable `view` selector** (§2): `project.view.type` (`'threejs'`
-  default-capable / `'ascii'`), CIF `_view.type`, following the
-  category-owned selector contract with a private `_swap_view` Family B
-  rebind. No `view_type` setter, no `show_supported_view_types()`.
+- **Switchable `view` selector** (§2): `project.view.type` (`'auto'`
+  default, resolving to `'threejs'` in Jupyter / `'ascii'` in a
+  terminal), CIF `_view.type`, following the category-owned selector
+  contract with a private `_swap_view` Family B rebind. No `view_type`
+  setter, no `show_supported_view_types()`.
 - **`structure()` entry point** (§3):
   `project.display.structure(struct_name=...)` parallel to
   `pattern(expt_name=...)`, with `include=` reusing the pattern
@@ -430,11 +431,13 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Define four `(str, Enum)` classes per the Enum-Backed Closed Values
     ADR, each with a `default()` classmethod (model on
     `PlotterEngineEnum` at `display/plotting.py:50`):
-    - `ViewerEngineEnum`: `ASCII = 'ascii'`, `THREEJS = 'threejs'`
-      (default `THREEJS` — the rich engine, matching `chart`'s
-      default-to-rich-engine precedent and the ADR §8 persisted example
-      `_view.type threejs`). `project.view.type` therefore defaults to
-      `threejs`; see P1.9 and the headless note there.
+    - `ViewerEngineEnum`: `ASCII = 'ascii'`, `THREEJS = 'threejs'`, with
+      an **environment-aware `default()`** (`threejs` in Jupyter, `ascii`
+      in a terminal), matching `PlotterEngineEnum` / `TableEngineEnum`.
+      The `view` category adds an `'auto'` selector sentinel resolved
+      through `default()`, so `project.view.type` defaults to `auto` and
+      the ADR §8 persisted example is `_view.type auto`; see P1.9 and the
+      headless note there.
     - `AtomShapeEnum`: `BALL = 'ball'`, `ORTEP = 'ortep'` (default
       `ORTEP`).
     - `RadiusModelEnum`: `VDW = 'vdw'`, `COVALENT = 'covalent'`,
@@ -721,9 +724,10 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     (`project/categories/chart/default.py`): `_category_code='view'`,
     `_owner_attr_name='view'`, `_swap_method_name='_swap_view'`; a
     `type` `StringDescriptor` with CIF `_view.type` validated against
-    `ViewerEngineEnum` + `ViewerFactory.descriptions()` and **defaulting
-    to `ViewerEngineEnum.default()` (`threejs`)**, matching P1.1;
-    `from_cif` calling `self._parent._swap_view`. Plus persisted
+    `['auto', *ViewerEngineEnum]` + `ViewerFactory.descriptions()` and
+    **defaulting to `'auto'`** (resolved to a concrete engine through
+    `ViewerEngineEnum.default()`, exactly as `Chart` resolves its
+    `'auto'`), matching P1.1; `from_cif` calling `self._parent._swap_view`. Plus persisted
     view-state descriptors: `show_labels` (`BoolDescriptor`, default off),
     `show_moments` (`BoolDescriptor`, default on-where-data), and the
     per-axis range as **six scalar `NumericDescriptor`s**
@@ -732,16 +736,17 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     and 1, each axis validated `min < max` in the setter), mirroring the
     six scalar cell parameters; `structure()`'s `range=` tuple arg
     overrides them per call. `show_supported()` lists engines.
-  - **Headless implication of the `threejs` default.** With `threejs`
-    default, `project.display.structure(...)` returns/writes an HTML
-    string and needs **no browser**, so it runs unattended in CI,
-    `script-tests`, and notebooks out of the box. The
-    terminal/CLI/headless `ascii` engine the ADR §2 names is opt-in via
-    `project.view.type = 'ascii'`. The P1.16 tutorial and the Phase 2
+  - **Headless implication of the `auto` default.** In Jupyter (and
+    under nbmake `script-tests`, which run a Jupyter kernel) `auto`
+    resolves to `threejs`, so `project.display.structure(...)`
+    returns/writes an HTML string and needs **no browser** — it runs
+    unattended out of the box. In a bare terminal `auto` resolves to the
+    `ascii` engine the ADR §2 names; `threejs` can still be forced via
+    `project.view.type = 'threejs'`. The P1.16 tutorial and the Phase 2
     script-test coverage item therefore exercise **both** paths: the
-    default `threejs` HTML emission and an explicit
-    `view.type = 'ascii'` terminal render (see the Phase 2 "Integration
-    / script-test coverage" item).
+    `threejs` HTML emission and an explicit `view.type = 'ascii'`
+    terminal render (see the Phase 2 "Integration / script-test
+    coverage" item).
   - Register `View` in `project/categories/view/__init__.py`.
   - Commit: `Add switchable view category for renderer selection`.
 
@@ -1019,7 +1024,8 @@ coverage (configured in P1.13).
       extended `RangeValidator`); `show_supported()` lists every
       setting's accepted values; `_style.*` CIF round-trips. P1.8.
 - [ ] **`tests/unit/easydiffraction/project/categories/view/test_view.py`**
-      (new) — `type` validates against `ViewerEngineEnum`; setting
+      (new) — `type` validates against `['auto', *ViewerEngineEnum]` and
+      defaults to `'auto'`; setting
       `type` calls `_swap_view`; a `range_a_max` below `range_a_min` is
       rejected (per-axis `min < max`); `_view.type` / `_view.show_*` /
       `_view.range_a_min` … `_view.range_c_max` CIF round-trip;
@@ -1065,8 +1071,9 @@ coverage (configured in P1.13).
 - [ ] **Integration / script-test coverage** — confirm
       `pixi run script-tests` exercises the tutorial that calls
       `project.display.structure(...)` along **both** engine paths: the
-      **default `threejs`** HTML emission (no browser, runs headless in
-      CI) and an explicit `project.view.type = 'ascii'` terminal render.
+      **`auto` default** (which resolves to `threejs` under nbmake's
+      Jupyter kernel) HTML emission (no browser, runs headless in CI) and
+      an explicit `project.view.type = 'ascii'` terminal render.
       Extend a tutorial if not. P1.16.
 
 Use `pixi run test-structure-check` to confirm the unit-test layout
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index cf39258af..5da7977b5 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -389,9 +389,9 @@
     "#### View Structure in 3D\n",
     "\n",
     "EasyDiffraction can draw the structure that has just been defined. The\n",
-    "renderer engine is selected through `project.view`. The default\n",
-    "`threejs` engine shows an interactive 3D view inside Jupyter, while the\n",
-    "`ascii` engine prints a compact schematic that works in any terminal."
+    "renderer engine is selected through `project.view`. The default `auto`\n",
+    "engine resolves to an interactive `threejs` view inside Jupyter and a\n",
+    "compact `ascii` schematic in a terminal."
    ]
   },
   {
@@ -498,8 +498,8 @@
    "id": "44",
    "metadata": {},
    "source": [
-    "For a quick text schematic in any terminal, switch to the `ascii`\n",
-    "engine, then restore the interactive default."
+    "For a quick text schematic, switch to the `ascii` engine explicitly,\n",
+    "then restore the automatic default."
    ]
   },
   {
@@ -520,7 +520,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.view.type = 'threejs'"
+    "project.view.type = 'auto'"
    ]
   },
   {
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index ff6bfce9e..ba50f7037 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -176,9 +176,9 @@
 # #### View Structure in 3D
 #
 # EasyDiffraction can draw the structure that has just been defined. The
-# renderer engine is selected through `project.view`. The default
-# `threejs` engine shows an interactive 3D view inside Jupyter, while the
-# `ascii` engine prints a compact schematic that works in any terminal.
+# renderer engine is selected through `project.view`. The default `auto`
+# engine resolves to an interactive `threejs` view inside Jupyter and a
+# compact `ascii` schematic in a terminal.
 
 # %%
 project.view.show_supported()
@@ -218,15 +218,15 @@
 project.display.structure(struct_name='lbco')
 
 # %% [markdown]
-# For a quick text schematic in any terminal, switch to the `ascii`
-# engine, then restore the interactive default.
+# For a quick text schematic, switch to the `ascii` engine explicitly,
+# then restore the automatic default.
 
 # %%
 project.view.type = 'ascii'
 project.display.structure(struct_name='lbco')
 
 # %%
-project.view.type = 'threejs'
+project.view.type = 'auto'
 
 # %% [markdown]
 # #### Save Project State
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 14da2a758..26aacd398 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -183,16 +183,17 @@ Structure 🧩 'lbco' as cif
 ## Viewing a Model in 3D
 
 EasyDiffraction can render a defined structure as an interactive 3D view.
-The renderer engine is chosen through `project.view`. The interactive
-Three.js engine is the default; the ASCII engine prints a
-terminal-friendly schematic.
+The renderer engine is chosen through `project.view`. The default `auto`
+engine resolves to the interactive Three.js view in Jupyter and the
+terminal-friendly ASCII schematic in a console — mirroring how
+`project.chart` and `project.table` pick their environment defaults.
 
 ```python
 # List the available renderer engines
 project.view.show_supported()
 
-# Switch the active engine if desired
-project.view.type = 'threejs'
+# Override the automatic choice if desired ('auto', 'threejs', 'ascii')
+project.view.type = 'auto'
 ```
 
 Visual styling — independent of the per-element data — is configured on

From c797089c394373e4dfd7d33091d7902a2576e8c8 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:36:05 +0200
Subject: [PATCH 026/160] Fix single-crystal tick rounding and lighten markers
 and bars

Round the shared tick step to the nearest 1/2/5 power of ten and anchor
ticks at 0, so both axes read 0, 500, ..., 2500 (was 750-spaced from the
padded minimum). Colour the marker stroke like the fill to drop the ring,
and thin the error-bar line and caps.
---
 .../display/plotters/plotly.py                | 36 +++++++++++++------
 1 file changed, 25 insertions(+), 11 deletions(-)

diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index f10edd231..34dbbc06d 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -49,8 +49,8 @@
 MEASURED_MARKER_SIZE = 6
 MEASURED_MARKER_LINE_WIDTH = 0
 SINGLE_CRYSTAL_MARKER_LINE_WIDTH = 0.5
-MEASURED_ERROR_BAR_THICKNESS = 1.0
-MEASURED_ERROR_BAR_WIDTH = 3
+MEASURED_ERROR_BAR_THICKNESS = 0.5
+MEASURED_ERROR_BAR_WIDTH = 2
 LIGHT_AXIS_FRAME_COLOR = 'rgba(120, 140, 160, 0.28)'
 DARK_AXIS_FRAME_COLOR = 'rgba(110, 145, 190, 0.35)'
 LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
@@ -147,9 +147,11 @@ def single_crystal_tick_step(
 ) -> float:
     """Return a 'nice' tick step covering ``[minimum, maximum]``.
 
-    The raw step ``span / target_ticks`` is rounded up to the nearest
-    ``DISPLAY_TICK_FRACTIONS`` value, so two axes sharing this step and the
-    same range show identical ticks.
+    The raw step ``span / target_ticks`` is rounded to the nearest 1/2/5
+    multiple of a power of ten (the classic axis-label rounding), so the
+    ticks read as round numbers and the same step gives identical x and y
+    ticks over a shared range. Combined with a tick origin of 0 this
+    reproduces Plotly's own choice (e.g. a 500 step, not 750).
 
     Parameters
     ----------
@@ -172,10 +174,15 @@ def single_crystal_tick_step(
     exponent = float(np.floor(np.log10(raw_step)))
     base = 10.0**exponent
     fraction = raw_step / base
-    for nice_fraction in DISPLAY_TICK_FRACTIONS:
-        if fraction <= nice_fraction:
-            return nice_fraction * base
-    return DISPLAY_TICK_FRACTIONS[-1] * base
+    if fraction < 1.5:
+        nice_fraction = 1.0
+    elif fraction < 3.0:
+        nice_fraction = 2.0
+    elif fraction < 7.0:
+        nice_fraction = 5.0
+    else:
+        nice_fraction = 10.0
+    return nice_fraction * base
 
 
 @dataclass(frozen=True)
@@ -652,7 +659,12 @@ def _get_single_crystal_trace(
             marker={
                 'symbol': 'circle',
                 'size': MEASURED_MARKER_SIZE,
-                'line': {'width': SINGLE_CRYSTAL_MARKER_LINE_WIDTH},
+                # Stroke colour matches the fill (like the pgfplots PDF) so
+                # there is no contrasting ring around the markers.
+                'line': {
+                    'width': SINGLE_CRYSTAL_MARKER_LINE_WIDTH,
+                    'color': DEFAULT_COLORS['meas'],
+                },
                 'color': DEFAULT_COLORS['meas'],
             },
             error_y={
@@ -1207,9 +1219,11 @@ def _get_layout(
         if axis_range is not None:
             for axis in (xaxis, yaxis):
                 axis['range'] = list(axis_range)
-                axis['tick0'] = axis_range[0]
         if axis_dtick is not None:
             for axis in (xaxis, yaxis):
+                # Anchor ticks at 0 so they read as round numbers (0, 500,
+                # 1000, ...) instead of starting at the padded minimum.
+                axis['tick0'] = 0
                 axis['dtick'] = axis_dtick
         return go.Layout(
             margin={

From e21ff4b8ffac305c09225d736325fcfcda9900bc Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:36:05 +0200
Subject: [PATCH 027/160] Test single-crystal tick step rounding and marker
 stroke

Add a regression that the padded heidi range rounds to a 500 step (not
750) and assert the marker stroke colour matches the fill.
---
 tests/unit/easydiffraction/display/plotters/test_plotly.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 6384bd821..26d3446f3 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -351,6 +351,7 @@ def __init__(self, html):
     assert trace.kwargs['mode'] == 'markers'
     assert 'error_y' in trace.kwargs
     assert trace.kwargs['marker']['size'] == pp.MEASURED_MARKER_SIZE
+    assert trace.kwargs['marker']['line']['color'] == pp.DEFAULT_COLORS['meas']
     assert trace.kwargs['error_y']['thickness'] == pp.MEASURED_ERROR_BAR_THICKNESS
     assert trace.kwargs['error_y']['width'] == pp.MEASURED_ERROR_BAR_WIDTH
 
@@ -408,6 +409,9 @@ def test_single_crystal_tick_step_rounds_to_nice_value():
 
     # Span 3000 over ~6 intervals -> raw 500 -> nice 500.
     assert pp.single_crystal_tick_step(0.0, 3000.0) == pytest.approx(500.0)
+    # Padded heidi-like range (span just above the 500 threshold) rounds to
+    # 500, not 750 (regression for the old round-up logic).
+    assert pp.single_crystal_tick_step(-158.275, 2841.73) == pytest.approx(500.0)
     # Degenerate span falls back to 1.0.
     assert pp.single_crystal_tick_step(5.0, 5.0) == pytest.approx(1.0)
 

From a2a90cc8f77603f8eaad776c5d10d13b84944685 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:45:14 +0200
Subject: [PATCH 028/160] Remove unimplemented Structure.show() superseded by
 display.structure()

---
 docs/docs/tutorials/ed-3.ipynb                | 284 ++++++++----------
 docs/docs/tutorials/ed-3.py                   |   6 -
 .../datablocks/structure/item/base.py         |   5 -
 .../structure/item/test_base_coverage.py      |   5 -
 4 files changed, 133 insertions(+), 167 deletions(-)

diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index 5da7977b5..aebf570a3 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -367,24 +367,6 @@
    "cell_type": "markdown",
    "id": "31",
    "metadata": {},
-   "source": [
-    "#### Show Structure Structure"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "32",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "project.structures['lbco'].show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "33",
-   "metadata": {},
    "source": [
     "#### View Structure in 3D\n",
     "\n",
@@ -397,7 +379,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -406,7 +388,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "33",
    "metadata": {},
    "source": [
     "Visual styling — the atom shape, per-element radius model, and colour\n",
@@ -416,7 +398,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -426,7 +408,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -437,7 +419,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "36",
    "metadata": {},
    "source": [
     "Bonds are generated automatically between atoms whose separation lies\n",
@@ -447,7 +429,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -457,7 +439,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "38",
    "metadata": {},
    "source": [
     "List which features the structure data and the active engine can draw."
@@ -466,7 +448,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -475,7 +457,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "40",
    "metadata": {},
    "source": [
     "Draw the structure. With `include='auto'` (the default) every available\n",
@@ -486,7 +468,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -495,7 +477,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "44",
+   "id": "42",
    "metadata": {},
    "source": [
     "For a quick text schematic, switch to the `ascii` engine explicitly,\n",
@@ -505,7 +487,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "45",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -516,7 +498,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -525,7 +507,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "45",
    "metadata": {},
    "source": [
     "#### Save Project State\n",
@@ -538,7 +520,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -547,7 +529,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "47",
    "metadata": {},
    "source": [
     "## Step 3: Define Experiment\n",
@@ -558,7 +540,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "48",
    "metadata": {},
    "source": [
     "#### Download Measured Data\n",
@@ -569,7 +551,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -578,7 +560,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "50",
    "metadata": {},
    "source": [
     "#### Add Diffraction Experiment"
@@ -587,7 +569,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -602,7 +584,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Show Defined Experiments"
@@ -611,7 +593,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -620,7 +602,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "56",
+   "id": "54",
    "metadata": {},
    "source": [
     "#### Show Measured Data"
@@ -629,7 +611,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -638,7 +620,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "58",
+   "id": "56",
    "metadata": {},
    "source": [
     "#### Set Instrument\n",
@@ -649,7 +631,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "59",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -659,7 +641,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "60",
+   "id": "58",
    "metadata": {},
    "source": [
     "#### Set Peak Profile\n",
@@ -670,7 +652,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "61",
+   "id": "59",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -679,7 +661,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "62",
+   "id": "60",
    "metadata": {},
    "source": [
     "Select the desired peak profile type."
@@ -688,7 +670,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "63",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -697,7 +679,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "64",
+   "id": "62",
    "metadata": {},
    "source": [
     "Modify default peak profile parameters."
@@ -706,7 +688,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "65",
+   "id": "63",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -719,7 +701,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "66",
+   "id": "64",
    "metadata": {},
    "source": [
     "#### Set Background"
@@ -727,7 +709,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "65",
    "metadata": {},
    "source": [
     "Show supported background types."
@@ -736,7 +718,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -745,7 +727,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "69",
+   "id": "67",
    "metadata": {},
    "source": [
     "Select the desired background type."
@@ -754,7 +736,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "68",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -763,7 +745,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71",
+   "id": "69",
    "metadata": {},
    "source": [
     "Add background points."
@@ -772,7 +754,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "72",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -785,7 +767,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "73",
+   "id": "71",
    "metadata": {},
    "source": [
     "Show current background points."
@@ -794,7 +776,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "74",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -803,7 +785,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "75",
+   "id": "73",
    "metadata": {},
    "source": [
     "#### Set Linked Phases\n",
@@ -814,7 +796,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "76",
+   "id": "74",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -823,7 +805,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "77",
+   "id": "75",
    "metadata": {},
    "source": [
     "#### Show Experiment as CIF"
@@ -832,7 +814,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "78",
+   "id": "76",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -841,7 +823,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "79",
+   "id": "77",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -850,7 +832,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "80",
+   "id": "78",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -859,7 +841,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "81",
+   "id": "79",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis\n",
@@ -875,7 +857,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "82",
+   "id": "80",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -884,7 +866,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "83",
+   "id": "81",
    "metadata": {},
    "source": [
     "Select the desired calculation engine."
@@ -893,7 +875,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "84",
+   "id": "82",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -902,7 +884,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "85",
+   "id": "83",
    "metadata": {},
    "source": [
     "#### Show Calculated Data"
@@ -911,7 +893,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "86",
+   "id": "84",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -920,7 +902,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "87",
+   "id": "85",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -929,7 +911,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "88",
+   "id": "86",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -939,7 +921,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "89",
+   "id": "87",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -948,7 +930,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "90",
+   "id": "88",
    "metadata": {},
    "source": [
     "#### Show Parameters\n",
@@ -959,7 +941,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "91",
+   "id": "89",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -968,7 +950,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "92",
+   "id": "90",
    "metadata": {},
    "source": [
     "Show all fittable parameters."
@@ -977,7 +959,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "93",
+   "id": "91",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -986,7 +968,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "94",
+   "id": "92",
    "metadata": {},
    "source": [
     "Show only free parameters."
@@ -995,7 +977,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "95",
+   "id": "93",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1004,7 +986,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "96",
+   "id": "94",
    "metadata": {},
    "source": [
     "Show how to access parameters in the code."
@@ -1013,7 +995,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "97",
+   "id": "95",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1022,7 +1004,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "98",
+   "id": "96",
    "metadata": {},
    "source": [
     "#### Set Fit Mode\n",
@@ -1033,7 +1015,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "99",
+   "id": "97",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1042,7 +1024,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "100",
+   "id": "98",
    "metadata": {},
    "source": [
     "Select desired fit mode."
@@ -1051,7 +1033,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "101",
+   "id": "99",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1060,7 +1042,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "102",
+   "id": "100",
    "metadata": {},
    "source": [
     "#### Set Minimizer\n",
@@ -1071,7 +1053,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "103",
+   "id": "101",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1080,7 +1062,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "104",
+   "id": "102",
    "metadata": {},
    "source": [
     "Select desired fitting engine."
@@ -1089,7 +1071,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "105",
+   "id": "103",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1098,7 +1080,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "106",
+   "id": "104",
    "metadata": {},
    "source": [
     "### Perform Fit 1/5\n",
@@ -1109,7 +1091,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "107",
+   "id": "105",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1118,7 +1100,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "108",
+   "id": "106",
    "metadata": {},
    "source": [
     "Set experiment parameters to be refined."
@@ -1127,7 +1109,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "109",
+   "id": "107",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1142,7 +1124,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "110",
+   "id": "108",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1151,7 +1133,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "111",
+   "id": "109",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1160,7 +1142,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "112",
+   "id": "110",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1169,7 +1151,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "113",
+   "id": "111",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1179,7 +1161,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "114",
+   "id": "112",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1188,7 +1170,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "115",
+   "id": "113",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1198,7 +1180,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "116",
+   "id": "114",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1207,7 +1189,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "117",
+   "id": "115",
    "metadata": {},
    "source": [
     "### Perform Fit 2/5\n",
@@ -1218,7 +1200,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "118",
+   "id": "116",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1230,7 +1212,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "119",
+   "id": "117",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1239,7 +1221,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "120",
+   "id": "118",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1248,7 +1230,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "121",
+   "id": "119",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1257,7 +1239,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "122",
+   "id": "120",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1267,7 +1249,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "123",
+   "id": "121",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1276,7 +1258,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "124",
+   "id": "122",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1286,7 +1268,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "125",
+   "id": "123",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1295,7 +1277,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "126",
+   "id": "124",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -1304,7 +1286,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "127",
+   "id": "125",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1313,7 +1295,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "128",
+   "id": "126",
    "metadata": {},
    "source": [
     "### Perform Fit 3/5\n",
@@ -1324,7 +1306,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "129",
+   "id": "127",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1336,7 +1318,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "130",
+   "id": "128",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1345,7 +1327,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "131",
+   "id": "129",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1354,7 +1336,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "132",
+   "id": "130",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1363,7 +1345,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "133",
+   "id": "131",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1373,7 +1355,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "134",
+   "id": "132",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1382,7 +1364,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "135",
+   "id": "133",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1392,7 +1374,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "136",
+   "id": "134",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1401,7 +1383,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "137",
+   "id": "135",
    "metadata": {},
    "source": [
     "### Perform Fit 4/5\n",
@@ -1414,7 +1396,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "138",
+   "id": "136",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1430,7 +1412,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "139",
+   "id": "137",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -1439,7 +1421,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "140",
+   "id": "138",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1448,7 +1430,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "141",
+   "id": "139",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1457,7 +1439,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "142",
+   "id": "140",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1466,7 +1448,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "143",
+   "id": "141",
    "metadata": {},
    "source": [
     "Show free parameters."
@@ -1475,7 +1457,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "144",
+   "id": "142",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1484,7 +1466,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "145",
+   "id": "143",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1493,7 +1475,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "146",
+   "id": "144",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1503,7 +1485,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "147",
+   "id": "145",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1512,7 +1494,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "148",
+   "id": "146",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1522,7 +1504,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "149",
+   "id": "147",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1531,7 +1513,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "150",
+   "id": "148",
    "metadata": {},
    "source": [
     "### Perform Fit 5/5\n",
@@ -1544,7 +1526,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "151",
+   "id": "149",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1560,7 +1542,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "152",
+   "id": "150",
    "metadata": {},
    "source": [
     "Set more constraints."
@@ -1569,7 +1551,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "153",
+   "id": "151",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1580,7 +1562,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "154",
+   "id": "152",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1589,7 +1571,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "155",
+   "id": "153",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -1600,7 +1582,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "156",
+   "id": "154",
    "metadata": {},
    "source": [
     "Set structure parameters to be refined."
@@ -1609,7 +1591,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "157",
+   "id": "155",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1618,7 +1600,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "158",
+   "id": "156",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1627,7 +1609,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "159",
+   "id": "157",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1636,7 +1618,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "160",
+   "id": "158",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1645,7 +1627,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "161",
+   "id": "159",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1656,7 +1638,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "162",
+   "id": "160",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1665,7 +1647,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "163",
+   "id": "161",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1675,7 +1657,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "164",
+   "id": "162",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1684,7 +1666,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "165",
+   "id": "163",
    "metadata": {},
    "source": [
     "## Step 5: Generate Report\n",
@@ -1704,7 +1686,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "166",
+   "id": "164",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index ba50f7037..72b1d496f 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -166,12 +166,6 @@
 # %%
 project.structures['lbco'].show_as_cif()
 
-# %% [markdown]
-# #### Show Structure Structure
-
-# %%
-project.structures['lbco'].show()
-
 # %% [markdown]
 # #### View Structure in 3D
 #
diff --git a/src/easydiffraction/datablocks/structure/item/base.py b/src/easydiffraction/datablocks/structure/item/base.py
index 108c10142..8d8d27928 100644
--- a/src/easydiffraction/datablocks/structure/item/base.py
+++ b/src/easydiffraction/datablocks/structure/item/base.py
@@ -241,11 +241,6 @@ def _update_categories(
     # Public methods
     # ------------------------------------------------------------------
 
-    def show(self) -> None:
-        """Display an ASCII projection of the structure in 2D."""
-        console.paragraph(f"Structure 🧩 '{self.name}'")
-        console.print('Not implemented yet.')
-
     def show_as_cif(self) -> None:
         """Render the CIF text for this structure in the terminal."""
         console.paragraph(f"Structure 🧩 '{self.name}' as cif")
diff --git a/tests/unit/easydiffraction/datablocks/structure/item/test_base_coverage.py b/tests/unit/easydiffraction/datablocks/structure/item/test_base_coverage.py
index 6d8967703..f7f968f01 100644
--- a/tests/unit/easydiffraction/datablocks/structure/item/test_base_coverage.py
+++ b/tests/unit/easydiffraction/datablocks/structure/item/test_base_coverage.py
@@ -93,11 +93,6 @@ def test_atom_sites_setter_replaces_instance(self, structure):
 
 
 class TestStructureDisplay:
-    def test_show(self, structure, capsys):
-        structure.show()
-        out = capsys.readouterr().out
-        assert 'test_struct' in out
-
     def test_show_as_cif(self, structure, capsys):
         structure.show_as_cif()
         out = capsys.readouterr().out

From 3eb4ce9105cd216d8c4eb41179320481bf65248c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:49:56 +0200
Subject: [PATCH 029/160] Wrap Three.js import map in required imports key

---
 src/easydiffraction/display/structure/renderers/threejs.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 3cf032a91..f45763605 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -140,7 +140,7 @@ def render(self, scene: StructureScene, *, features: frozenset[str], offline: bo
         dark = is_dark()
         colours = theme_colors(dark)
         payload = json.dumps(_scene_payload(scene)).replace('</', '<\\/')
-        import_map = json.dumps(_import_map(offline=offline)).replace('</', '<\\/')
+        import_map = json.dumps({'imports': _import_map(offline=offline)}).replace('</', '<\\/')
         template = _environment().get_template('structure.html.j2')
         return template.render(
             container_id=f'crysview-{uuid.uuid4().hex}',

From 00f7c3ded480a6f0537d50483b8d5788db10daee Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 10:50:15 +0200
Subject: [PATCH 030/160] Add import-map regression guard to Phase 2 test plan

---
 docs/dev/plans/crysview-structure-visualization.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index a25083a19..d98862f66 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -1053,7 +1053,11 @@ coverage (configured in P1.13).
       3D-only, moments gated, ionic→covalent substitution). P1.12.
 - [ ] **`tests/unit/easydiffraction/display/structure/renderers/test_threejs.py`**
       (new) — the renderer emits an HTML string containing the scene
-      JSON and the modebar controls; **offline** mode embeds the
+      JSON and the modebar controls; the emitted `<script
+      type="importmap">` parses to JSON with a top-level **`imports`**
+      key mapping `three` (regression guard: a bare specifier map with no
+      `imports` wrapper silently fails to resolve and renders blank);
+      **offline** mode embeds the
       Three.js asset text inline (no CDN URL), online mode links it; the
       standalone write path produces a self-contained file; the resolved
       dark/light theme drives the canvas/annotation colours (assert the

From f00287a4162adbbfc0a1818b8364ff8e1f6cd718 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 11:03:35 +0200
Subject: [PATCH 031/160] Force light theme for structure view in HTML reports

---
 .../display/structure/renderers/threejs.py       | 16 ++++++++++++++--
 src/easydiffraction/report/html_renderer.py      |  1 +
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index f45763605..aca2dc7db 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -117,7 +117,14 @@ def supported_features(self) -> frozenset[str]:
         """Return the features the Three.js engine can draw."""
         return self.SUPPORTED
 
-    def render(self, scene: StructureScene, *, features: frozenset[str], offline: bool = True) -> str:
+    def render(
+        self,
+        scene: StructureScene,
+        *,
+        features: frozenset[str],
+        offline: bool = True,
+        dark: bool | None = None,
+    ) -> str:
         """
         Render the scene as a self-contained interactive HTML document.
 
@@ -131,13 +138,18 @@ def render(self, scene: StructureScene, *, features: frozenset[str], offline: bo
         offline : bool
             When ``True`` (default), inline the pinned Three.js assets so
             the view renders with no network; when ``False`` link the CDN.
+        dark : bool | None
+            Force the dark (``True``) or light (``False``) theme. When
+            ``None`` (default), auto-detect from the environment. Reports
+            pass ``False`` so the view matches their light page.
 
         Returns
         -------
         str
             A complete HTML document.
         """
-        dark = is_dark()
+        if dark is None:
+            dark = is_dark()
         colours = theme_colors(dark)
         payload = json.dumps(_scene_payload(scene)).replace('</', '<\\/')
         import_map = json.dumps({'imports': _import_map(offline=offline)}).replace('</', '<\\/')
diff --git a/src/easydiffraction/report/html_renderer.py b/src/easydiffraction/report/html_renderer.py
index f9790c956..a3e4efce6 100644
--- a/src/easydiffraction/report/html_renderer.py
+++ b/src/easydiffraction/report/html_renderer.py
@@ -222,6 +222,7 @@ def _structure_figure_html_context(
             scene,
             features=features,
             offline=offline,
+            dark=False,
         )
     return rendered
 

From d52c094c3f35fa4329ca9b048271b54bcac66dad Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 11:10:36 +0200
Subject: [PATCH 032/160] Match structure-view modebar and layout to reference
 demo

---
 .../structure/templates/structure.html.j2     | 172 +++++++++++++-----
 1 file changed, 128 insertions(+), 44 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 1726ab3a7..dec1ffbb6 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -1,16 +1,57 @@
 <div id="{{ container_id }}" class="crysview" style="position:relative;width:100%;height:480px;
      background:{{ background }};color:{{ foreground }};border:1px solid rgba(128,128,128,0.3);
-     border-radius:6px;overflow:hidden;font-family:system-ui,sans-serif;">
-  <div class="crysview-canvas" style="position:absolute;inset:0;"></div>
-  <div class="crysview-modebar" style="position:absolute;top:6px;right:6px;display:flex;gap:3px;
-       flex-wrap:wrap;justify-content:flex-end;max-width:70%;"></div>
-  <div class="crysview-legend" style="position:absolute;left:8px;bottom:6px;font-size:12px;
-       display:flex;gap:10px;flex-wrap:wrap;text-shadow:0 0 2px {{ background }};"></div>
-  <div class="crysview-tooltip" style="position:absolute;padding:2px 6px;font-size:12px;
-       background:rgba(0,0,0,0.75);color:#fff;border-radius:3px;pointer-events:none;
-       display:none;"></div>
+     border-radius:6px;overflow:hidden;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
+  <div class="cv-canvas" style="position:absolute;inset:0;"></div>
+  <div class="cv-modebar cv-card"></div>
+  <div class="cv-legend cv-card"></div>
+  <div class="cv-hint">drag = rotate&nbsp;&middot;&nbsp;wheel = zoom&nbsp;&middot;&nbsp;right-drag = pan</div>
+  <div class="cv-tooltip"></div>
 </div>
 
+<style>
+  #{{ container_id }} .cv-card {
+    position: absolute; z-index: 10; background: rgba(255, 255, 255, 0.94);
+    border: 1px solid #e2e2e2; border-radius: 8px;
+    box-shadow: 0 1px 6px rgba(0, 0, 0, 0.12); font-size: 12px; color: #222;
+  }
+  #{{ container_id }} .cv-modebar {
+    top: 10px; right: 10px; display: flex; align-items: center; gap: 6px;
+    padding: 5px 7px; flex-wrap: wrap; justify-content: flex-end; max-width: 80%;
+  }
+  #{{ container_id }} .mb-grp { display: flex; gap: 4px; }
+  #{{ container_id }} .mb-sep { align-self: stretch; width: 1px; background: #e4e4e4; margin: 3px 2px; }
+  #{{ container_id }} .mb {
+    width: 32px; height: 30px; display: inline-flex; align-items: center;
+    justify-content: center; padding: 0; border: 1px solid #dcdcdc; border-radius: 6px;
+    background: #f5f5f6; color: #2a3f5f; cursor: pointer;
+    transition: background 0.12s, color 0.12s, border-color 0.12s;
+  }
+  #{{ container_id }} .mb:hover { background: #e9eaef; }
+  #{{ container_id }} .mb svg { width: 17px; height: 17px; display: block; }
+  #{{ container_id }} .mb.lt { font: 700 15px/1 Georgia, 'Times New Roman', serif; }
+  #{{ container_id }} .mb.tog { color: #b9bdc6; }
+  #{{ container_id }} .mb.tog.on { color: #2a3f5f; background: #e7ecf5; border-color: #c6d0e2; }
+  #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; }
+  #{{ container_id }} .cv-legend .sw {
+    display: inline-block; width: 11px; height: 11px; border-radius: 50%;
+    margin-right: 7px; vertical-align: middle; border: 1px solid rgba(0, 0, 0, 0.18);
+  }
+  #{{ container_id }} .cv-hint {
+    position: absolute; z-index: 10; bottom: 8px; left: 10px; font-size: 11px;
+    color: #555; background: rgba(255, 255, 255, 0.82); padding: 5px 9px; border-radius: 6px;
+  }
+  #{{ container_id }} .cv-tooltip {
+    position: absolute; z-index: 30; pointer-events: none; display: none;
+    background: rgba(33, 42, 62, 0.92); color: #fff; padding: 3px 8px;
+    border-radius: 5px; font-size: 12px; white-space: nowrap;
+  }
+  #{{ container_id }} .cv-atom-label {
+    font-size: 11px; font-weight: 600; color: {{ foreground }};
+    text-shadow: 0 0 3px {{ background }}, 0 0 3px {{ background }}, 0 0 3px {{ background }};
+    pointer-events: none; white-space: nowrap;
+  }
+</style>
+
 <script type="importmap">{{ import_map }}</script>
 <script type="module">
 import * as THREE from 'three';
@@ -21,14 +62,27 @@ const SCENE = {{ scene_json }};
 const FEATURES = {{ features_json }};
 const FG = '{{ foreground }}';
 
+const ICONS = {
+  perspective: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="4.5" width="17" height="15" rx="1.5"/><path d="M9 4.5 11 19.5M15 4.5 13 19.5"/></svg>',
+  orthographic: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="4.5" width="17" height="15" rx="1.5"/><path d="M9.5 4.5V19.5M14.5 4.5V19.5"/></svg>',
+  home: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 11 12 3l9 8"/><path d="M5 9.5V20h5v-6h4v6h5V9.5"/></svg>',
+  cell: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round" stroke-linecap="round"><path d="M12 2.5 20 7v9l-8 4.5L4 16V7Z"/><path d="M4 7l8 4.5L20 7M12 11.5v9"/></svg>',
+  axes: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M5 19V6M5 19h13M5 19l7-7"/><path d="M5 6 3.3 8.2M5 6l1.7 2.2M18 19l-2.2-1.4M18 19l-2.2 1.4"/></svg>',
+  atoms: '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="9.5" cy="13.5" r="5"/><circle cx="16.5" cy="8" r="3.2"/></svg>',
+  bonds: '<svg viewBox="0 0 24 24"><line x1="8" y1="16" x2="16" y2="8" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"/><circle cx="6.7" cy="17.3" r="3.1" fill="currentColor"/><circle cx="17.3" cy="6.7" r="3.1" fill="currentColor"/></svg>',
+  moments: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20V5"/><path d="M7 10l5-6 5 6"/></svg>',
+  labels: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round" stroke-linecap="round"><rect x="3.5" y="5" width="17" height="14" rx="2"/><path d="M9 15.5 12 8.5l3 7M10.1 13.2h3.8"/></svg>',
+};
+
 const root = document.getElementById('{{ container_id }}');
-const host = root.querySelector('.crysview-canvas');
-const modebar = root.querySelector('.crysview-modebar');
-const legend = root.querySelector('.crysview-legend');
-const tooltip = root.querySelector('.crysview-tooltip');
+const host = root.querySelector('.cv-canvas');
+const modebar = root.querySelector('.cv-modebar');
+const legend = root.querySelector('.cv-legend');
+const tooltip = root.querySelector('.cv-tooltip');
 
 const col = (rgb) => new THREE.Color(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255);
 const vec = (xyz) => new THREE.Vector3(xyz[0], xyz[1], xyz[2]);
+const rgbCss = (rgb) => `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
 const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
 
 let width = host.clientWidth || 640;
@@ -47,13 +101,16 @@ labelRenderer.domElement.style.top = '0';
 labelRenderer.domElement.style.pointerEvents = 'none';
 host.appendChild(labelRenderer.domElement);
 
-scene.add(new THREE.AmbientLight(0xffffff, 0.65));
-const key = new THREE.DirectionalLight(0xffffff, 0.8);
+scene.add(new THREE.AmbientLight(0xffffff, 0.55));
+const key = new THREE.DirectionalLight(0xffffff, 0.9);
 key.position.set(1, 1, 1);
 scene.add(key);
+const fill = new THREE.DirectionalLight(0xffffff, 0.35);
+fill.position.set(-1, -0.5, -1);
+scene.add(fill);
 
 const groups = {};
-for (const name of ['atoms', 'bonds', 'cell', 'axes', 'labels']) {
+for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
   groups[name] = new THREE.Group();
   groups[name].visible = FEATURES.includes(name);
   scene.add(groups[name]);
@@ -124,7 +181,7 @@ if (SCENE.axes) {
     groups.axes.add(new THREE.ArrowHelper(v.clone().normalize(), origin, len, col(arrow.colour).getHex(), len * 0.12, len * 0.07));
     const div = document.createElement('div');
     div.textContent = arrow.letter;
-    div.style.color = `rgb(${arrow.colour[0]},${arrow.colour[1]},${arrow.colour[2]})`;
+    div.style.color = rgbCss(arrow.colour);
     div.style.fontWeight = 'bold';
     const tag = new CSS2DObject(div);
     tag.position.copy(origin.clone().add(v.clone().multiplyScalar(1.12)));
@@ -134,9 +191,8 @@ if (SCENE.axes) {
 
 for (const label of SCENE.labels) {
   const div = document.createElement('div');
+  div.className = 'cv-atom-label';
   div.textContent = label.text;
-  div.style.fontSize = '11px';
-  div.style.color = FG;
   const obj = new CSS2DObject(div);
   obj.position.copy(vec(label.anchor));
   groups.labels.add(obj);
@@ -159,13 +215,17 @@ const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.3, radius * aspe
 perspective.position.copy(home);
 ortho.position.copy(home);
 let camera = ortho;
+let projection = 'orthographic';
 
 const controls = new OrbitControls(camera, renderer.domElement);
+controls.enableDamping = true;
+controls.dampingFactor = 0.08;
 controls.target.copy(target);
 controls.update();
 
 const setCamera = (next) => {
   next.position.copy(camera.position);
+  next.up.copy(camera.up);
   controls.object = next;
   camera = next;
   controls.update();
@@ -175,36 +235,62 @@ const viewAlong = (axisVector) => {
   controls.update();
 };
 
-const button = (label, title, onClick) => {
+const iconButton = (parent, html, title, cls) => {
   const el = document.createElement('button');
-  el.textContent = label;
+  el.className = 'mb' + (cls ? ' ' + cls : '');
+  el.innerHTML = html;
   el.title = title;
-  el.style.cssText = 'font-size:11px;padding:2px 6px;cursor:pointer;border-radius:3px;' +
-    'border:1px solid rgba(128,128,128,0.5);background:rgba(128,128,128,0.15);color:inherit;';
-  el.addEventListener('click', onClick);
-  modebar.appendChild(el);
+  parent.appendChild(el);
   return el;
 };
 
-button('persp/ortho', 'Toggle perspective / parallel projection', () => {
-  setCamera(camera === ortho ? perspective : ortho);
+const cameraGroup = document.createElement('div');
+cameraGroup.className = 'mb-grp';
+modebar.appendChild(cameraGroup);
+
+const projButton = iconButton(cameraGroup, ICONS.orthographic, 'Parallel (orthographic) view');
+projButton.addEventListener('click', () => {
+  projection = projection === 'orthographic' ? 'perspective' : 'orthographic';
+  setCamera(projection === 'orthographic' ? ortho : perspective);
+  projButton.innerHTML = ICONS[projection];
+  projButton.title = projection === 'orthographic' ? 'Parallel (orthographic) view' : 'Perspective view';
 });
+
 const cellBasis = SCENE.axes ? SCENE.axes.arrows.map((a) => vec(a.vector)) : [];
-['a', 'b', 'c'].forEach((letter, i) => {
-  if (cellBasis[i]) button(letter, `View along ${letter}`, () => viewAlong(cellBasis[i]));
-});
-button('reset', 'Reset the view', () => {
+if (SCENE.axes) {
+  SCENE.axes.arrows.forEach((arrow, i) => {
+    const button = iconButton(cameraGroup, arrow.letter, `View along ${arrow.letter}`, 'lt');
+    button.style.color = rgbCss(arrow.colour);
+    button.addEventListener('click', () => viewAlong(cellBasis[i]));
+  });
+}
+
+const homeButton = iconButton(cameraGroup, ICONS.home, 'Reset view');
+homeButton.addEventListener('click', () => {
   camera.position.copy(home);
   controls.target.copy(target);
   controls.update();
 });
-for (const name of ['atoms', 'bonds', 'cell', 'axes', 'labels']) {
-  if (groups[name].children.length === 0) continue;
-  const btn = button(name, `Toggle ${name}`, () => {
-    groups[name].visible = !groups[name].visible;
-    btn.style.opacity = groups[name].visible ? '1' : '0.45';
+
+const featureGroup = document.createElement('div');
+featureGroup.className = 'mb-grp';
+let hasFeatureToggle = false;
+for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
+  if (!groups[name] || groups[name].children.length === 0) continue;
+  hasFeatureToggle = true;
+  const visible = groups[name].visible;
+  const button = iconButton(featureGroup, ICONS[name], name.charAt(0).toUpperCase() + name.slice(1), 'tog' + (visible ? ' on' : ''));
+  button.addEventListener('click', () => {
+    const next = !groups[name].visible;
+    groups[name].visible = next;
+    button.classList.toggle('on', next);
   });
-  btn.style.opacity = groups[name].visible ? '1' : '0.45';
+}
+if (hasFeatureToggle) {
+  const separator = document.createElement('div');
+  separator.className = 'mb-sep';
+  modebar.appendChild(separator);
+  modebar.appendChild(featureGroup);
 }
 
 const seen = new Map();
@@ -216,17 +302,15 @@ SCENE.atoms.forEach((a) => collectLegend(a.label, a.colour));
 SCENE.ellipsoids.forEach((e) => collectLegend(e.label, e.colour));
 SCENE.wedgeSpheres.forEach((s) => s.wedges[0] && collectLegend(s.label, s.wedges[0].colour));
 for (const [element, colour] of seen) {
-  const item = document.createElement('span');
-  item.style.cssText = 'display:inline-flex;align-items:center;gap:4px;';
+  const item = document.createElement('div');
   const swatch = document.createElement('span');
-  swatch.style.cssText = `display:inline-block;width:10px;height:10px;border-radius:50%;` +
-    `background:rgb(${colour[0]},${colour[1]},${colour[2]});`;
+  swatch.className = 'sw';
+  swatch.style.background = rgbCss(colour);
   item.appendChild(swatch);
-  const text = document.createElement('span');
-  text.textContent = element;
-  item.appendChild(text);
+  item.appendChild(document.createTextNode(element));
   legend.appendChild(item);
 }
+if (seen.size === 0) legend.style.display = 'none';
 
 const raycaster = new THREE.Raycaster();
 const pointer = new THREE.Vector2();

From fb922eaad7d3b09b37029854b9d605d2615bf790 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 11:23:37 +0200
Subject: [PATCH 033/160] Add atom_scale and per-axis axis lengths to structure
 scene

---
 .../display/structure/builder.py              | 16 ++++++++++------
 .../project/categories/style/default.py       | 19 +++++++++++++++++++
 2 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 1b5499ba2..f5a564eec 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -144,6 +144,7 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
     element = _element_symbol(atom.type_symbol.value)
     colour = color_for(element, style.color_scheme.value)
     radius, substituted = radius_for(element, style.radius_model.value)
+    ball_radius = radius * style.atom_scale.value
     label = atom.label.value
     adp_type = AdpTypeEnum(atom.adp_type.value)
     scale = float(chi.ppf(style.adp_probability.value, 3))
@@ -160,9 +161,9 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
         if adp_type is AdpTypeEnum.BISO:
             u_iso = u_iso / EIGHT_PI_SQ
         iso_radius = float(np.sqrt(max(u_iso, 0.0))) * scale
-        primitive = AtomSphere(_vec3(centre), iso_radius or radius, colour, label)
+        primitive = AtomSphere(_vec3(centre), iso_radius or ball_radius, colour, label)
     else:
-        primitive = AtomSphere(_vec3(centre), radius, colour, label)
+        primitive = AtomSphere(_vec3(centre), ball_radius, colour, label)
     return _SceneAtom(primitive, centre, element, colour, label), substituted
 
 
@@ -175,7 +176,7 @@ def _wedge_sphere(rows, centre, *, style):
     else:
         wedges = [OccupancyWedge(occ, colour) for _, occ, _, colour, _ in rows]
         wedges.append(OccupancyWedge(1.0 - total, VACANCY_COLOR))
-    radius = max(radius for _, _, _, _, radius in rows)
+    radius = max(radius for _, _, _, _, radius in rows) * style.atom_scale.value
     major = max(rows, key=lambda r: r[1])
     label = '/'.join(r[0].label.value for r in rows)
     primitive = OccupancyWedgeSphere(_vec3(centre), radius, tuple(wedges), label)
@@ -240,11 +241,14 @@ def _cell_edges(matrix: np.ndarray) -> CellEdges:
 
 
 def _axis_triad(matrix: np.ndarray) -> AxisTriad:
-    length = 1.3 * max(float(np.linalg.norm(matrix[:, i])) for i in range(3))
+    lengths = [float(np.linalg.norm(matrix[:, i])) for i in range(3)]
+    extra = 0.3 * max(lengths)
     arrows = []
     for i, letter in enumerate('abc'):
-        direction = matrix[:, i] / float(np.linalg.norm(matrix[:, i]))
-        arrows.append(AxisArrow(_vec3(direction * length), AXIS_COLORS[letter], letter))
+        direction = matrix[:, i] / lengths[i]
+        arrows.append(
+            AxisArrow(_vec3(direction * (lengths[i] + extra)), AXIS_COLORS[letter], letter)
+        )
     return AxisTriad((0.0, 0.0, 0.0), (arrows[0], arrows[1], arrows[2]))
 
 
diff --git a/src/easydiffraction/project/categories/style/default.py b/src/easydiffraction/project/categories/style/default.py
index 3530bed4c..9b1d7a612 100644
--- a/src/easydiffraction/project/categories/style/default.py
+++ b/src/easydiffraction/project/categories/style/default.py
@@ -75,6 +75,15 @@ def __init__(self) -> None:
             ),
             cif_handler=CifHandler(names=['_style.adp_probability']),
         )
+        self._atom_scale = NumericDescriptor(
+            name='atom_scale',
+            description='Ball-atom radius as a fraction of the model radius.',
+            value_spec=AttributeSpec(
+                default=0.5,
+                validator=RangeValidator(gt=0.0, le=1.0),
+            ),
+            cif_handler=CifHandler(names=['_style.atom_scale']),
+        )
 
     @property
     def atom_shape(self) -> StringDescriptor:
@@ -112,6 +121,15 @@ def adp_probability(self) -> NumericDescriptor:
     def adp_probability(self, value: float) -> None:
         self._adp_probability.value = value
 
+    @property
+    def atom_scale(self) -> NumericDescriptor:
+        """Ball-atom radius as a fraction of the model radius (0, 1]."""
+        return self._atom_scale
+
+    @atom_scale.setter
+    def atom_scale(self, value: float) -> None:
+        self._atom_scale.value = value
+
     def show_supported(self) -> None:
         """List the accepted values for every styling setting."""
         console.paragraph('Supported style settings')
@@ -122,6 +140,7 @@ def show_supported(self) -> None:
         ):
             console.print(f"{setting}: {', '.join(member.value for member in enum)}")
         console.print('adp_probability: float in the open interval (0, 1)')
+        console.print('atom_scale: float in (0, 1] (1 = space-filling model radius)')
 
     @property
     def as_cif(self) -> str:

From 5a4cd3babbd6bf036c74de6ea1c251f4af863eab Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 11:23:37 +0200
Subject: [PATCH 034/160] Thicken axes, tighten zoom, add PNG download and
 mixed-site legend

---
 .../structure/templates/structure.html.j2     | 86 ++++++++++++++-----
 1 file changed, 66 insertions(+), 20 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index dec1ffbb6..c4447ec9e 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -72,6 +72,7 @@ const ICONS = {
   bonds: '<svg viewBox="0 0 24 24"><line x1="8" y1="16" x2="16" y2="8" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"/><circle cx="6.7" cy="17.3" r="3.1" fill="currentColor"/><circle cx="17.3" cy="6.7" r="3.1" fill="currentColor"/></svg>',
   moments: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20V5"/><path d="M7 10l5-6 5 6"/></svg>',
   labels: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round" stroke-linecap="round"><rect x="3.5" y="5" width="17" height="14" rx="2"/><path d="M9 15.5 12 8.5l3 7M10.1 13.2h3.8"/></svg>',
+  camera: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"><path d="M4 8h3l1.5-2h7L17 8h3a1 1 0 0 1 1 1v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V9a1 1 0 0 1 1-1Z"/><circle cx="12" cy="13" r="3.4"/></svg>',
 };
 
 const root = document.getElementById('{{ container_id }}');
@@ -89,7 +90,7 @@ let width = host.clientWidth || 640;
 let height = host.clientHeight || 480;
 
 const scene = new THREE.Scene();
-const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true, preserveDrawingBuffer: true });
 renderer.setPixelRatio(window.devicePixelRatio);
 renderer.setSize(width, height);
 host.appendChild(renderer.domElement);
@@ -173,18 +174,36 @@ for (const edge of SCENE.cellEdges) {
   groups.cell.add(new THREE.Line(geo, cellMaterial));
 }
 
+const Y_AXIS = new THREE.Vector3(0, 1, 0);
+const buildArrow = (origin, v, colour) => {
+  const group = new THREE.Group();
+  const length = v.length();
+  const shaftR = length * 0.012;
+  const headLen = length * 0.12;
+  const headR = shaftR * 4;
+  const shaftLen = Math.max(length - headLen, 1e-3);
+  const material = new THREE.MeshStandardMaterial({ color: col(colour) });
+  const shaft = new THREE.Mesh(new THREE.CylinderGeometry(shaftR, shaftR, shaftLen, 16), material);
+  shaft.position.y = shaftLen / 2;
+  const head = new THREE.Mesh(new THREE.ConeGeometry(headR, headLen, 20), material);
+  head.position.y = shaftLen + headLen / 2;
+  group.add(shaft, head);
+  group.quaternion.setFromUnitVectors(Y_AXIS, v.clone().normalize());
+  group.position.copy(origin);
+  return group;
+};
+
 if (SCENE.axes) {
   const origin = vec(SCENE.axes.origin);
   for (const arrow of SCENE.axes.arrows) {
     const v = vec(arrow.vector);
-    const len = v.length();
-    groups.axes.add(new THREE.ArrowHelper(v.clone().normalize(), origin, len, col(arrow.colour).getHex(), len * 0.12, len * 0.07));
+    groups.axes.add(buildArrow(origin, v, arrow.colour));
     const div = document.createElement('div');
     div.textContent = arrow.letter;
     div.style.color = rgbCss(arrow.colour);
     div.style.fontWeight = 'bold';
     const tag = new CSS2DObject(div);
-    tag.position.copy(origin.clone().add(v.clone().multiplyScalar(1.12)));
+    tag.position.copy(origin.clone().add(v.clone().multiplyScalar(1.08)));
     groups.axes.add(tag);
   }
 }
@@ -207,11 +226,11 @@ const target = box.getBoundingSphere(new THREE.Sphere()).center;
 const radius = Math.max(box.getBoundingSphere(new THREE.Sphere()).radius, 1);
 const aspect = width / height;
 const far = radius * 100;
-const distance = radius * 2.6;
+const distance = radius * 2.0;
 const home = target.clone().add(new THREE.Vector3(distance, distance * 0.6, distance));
 
 const perspective = new THREE.PerspectiveCamera(45, aspect, radius * 0.01, far);
-const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.3, radius * aspect * 1.3, radius * 1.3, -radius * 1.3, -far, far);
+const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.05, radius * aspect * 1.05, radius * 1.05, -radius * 1.05, -far, far);
 perspective.position.copy(home);
 ortho.position.copy(home);
 let camera = ortho;
@@ -272,6 +291,15 @@ homeButton.addEventListener('click', () => {
   controls.update();
 });
 
+const downloadButton = iconButton(cameraGroup, ICONS.camera, 'Download PNG');
+downloadButton.addEventListener('click', () => {
+  renderer.render(scene, camera);
+  const link = document.createElement('a');
+  link.download = 'structure.png';
+  link.href = renderer.domElement.toDataURL('image/png');
+  link.click();
+});
+
 const featureGroup = document.createElement('div');
 featureGroup.className = 'mb-grp';
 let hasFeatureToggle = false;
@@ -293,24 +321,42 @@ if (hasFeatureToggle) {
   modebar.appendChild(featureGroup);
 }
 
-const seen = new Map();
-const collectLegend = (label, colour) => {
-  const element = elementOf(label);
-  if (!seen.has(element)) seen.set(element, colour);
-};
-SCENE.atoms.forEach((a) => collectLegend(a.label, a.colour));
-SCENE.ellipsoids.forEach((e) => collectLegend(e.label, e.colour));
-SCENE.wedgeSpheres.forEach((s) => s.wedges[0] && collectLegend(s.label, s.wedges[0].colour));
-for (const [element, colour] of seen) {
+const addLegendItem = (background, text) => {
   const item = document.createElement('div');
   const swatch = document.createElement('span');
   swatch.className = 'sw';
-  swatch.style.background = rgbCss(colour);
+  swatch.style.background = background;
   item.appendChild(swatch);
-  item.appendChild(document.createTextNode(element));
+  item.appendChild(document.createTextNode(text));
   legend.appendChild(item);
+};
+
+const seenElements = new Map();
+const collectElement = (label, colour) => {
+  const element = elementOf(label);
+  if (!seenElements.has(element)) seenElements.set(element, colour);
+};
+SCENE.atoms.forEach((a) => collectElement(a.label, a.colour));
+SCENE.ellipsoids.forEach((e) => collectElement(e.label, e.colour));
+for (const [element, colour] of seenElements) addLegendItem(rgbCss(colour), element);
+
+const seenWedges = new Set();
+for (const s of SCENE.wedgeSpheres) {
+  if (seenWedges.has(s.label)) continue;
+  seenWedges.add(s.label);
+  let acc = 0;
+  const stops = s.wedges.map((w) => {
+    const start = acc * 100;
+    acc += w.fraction;
+    return `${rgbCss(w.colour)} ${start.toFixed(1)}% ${(acc * 100).toFixed(1)}%`;
+  });
+  const parts = s.label.split('/');
+  const ratio = s.wedges.slice(0, parts.length).map((w) => Math.round(w.fraction * 100));
+  const text = ratio.length > 1 ? `${s.label} (${ratio.join('/')})` : s.label;
+  addLegendItem(`linear-gradient(90deg, ${stops.join(', ')})`, text);
 }
-if (seen.size === 0) legend.style.display = 'none';
+
+if (!legend.children.length) legend.style.display = 'none';
 
 const raycaster = new THREE.Raycaster();
 const pointer = new THREE.Vector2();
@@ -337,8 +383,8 @@ const resize = () => {
   const ratio = width / height;
   perspective.aspect = ratio;
   perspective.updateProjectionMatrix();
-  ortho.left = -radius * ratio * 1.3;
-  ortho.right = radius * ratio * 1.3;
+  ortho.left = -radius * ratio * 1.05;
+  ortho.right = radius * ratio * 1.05;
   ortho.updateProjectionMatrix();
   renderer.setSize(width, height);
   labelRenderer.setSize(width, height);

From 11b3df01fa7e407a9cc46282af5a7f37c22ab582 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 11:24:12 +0200
Subject: [PATCH 035/160] Document atom_scale style option

---
 docs/dev/adrs/suggestions/crysview-structure-visualization.md | 2 ++
 docs/docs/user-guide/analysis-workflow/model.md               | 1 +
 2 files changed, 3 insertions(+)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 61e2d0e2c..fbfad883f 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -475,6 +475,7 @@ project.style.atom_shape = 'ortep'        # ball | ortep
 project.style.radius_model = 'covalent'   # vdw | covalent | ionic | atomic (default covalent)
 project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
 project.style.adp_probability = 0.5       # ortep only; fraction in (0, 1)
+project.style.atom_scale = 0.5            # ball only; radius as fraction of model radius (0, 1]
 project.style.show_supported()            # accepted values per setting
 
 # Which bonds exist: a per-structure geometric property, not styling.
@@ -523,6 +524,7 @@ _style.atom_shape       ortep
 _style.radius_model     covalent
 _style.color_scheme     jmol
 _style.adp_probability  0.5
+_style.atom_scale       0.5
 
 # In the structure (sample) CIF, beside _cell / _atom_site (per-structure):
 _geom.min_bond_distance_cutoff   0.0
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 26aacd398..7f24971da 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -207,6 +207,7 @@ project.style.show_supported()
 project.style.atom_shape = 'ball'  # 'ball' or 'ortep'
 project.style.radius_model = 'covalent'  # 'vdw', 'covalent', 'ionic', 'atomic'
 project.style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
+project.style.atom_scale = 0.5  # ball radius as a fraction of the model radius
 ```
 
 Bonds are generated automatically between atoms whose separation falls

From 74066b3a9f29e4c9f5164beccf1151fd8f76188a Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 12:27:53 +0200
Subject: [PATCH 036/160] Rename rendering selectors to
 rendering_plot/structure/table

---
 .../crysview-structure-visualization.md       |  88 +++++++--------
 .../plans/crysview-structure-visualization.md | 106 +++++++++---------
 docs/docs/tutorials/ed-11.ipynb               |   4 +-
 docs/docs/tutorials/ed-11.py                  |   4 +-
 docs/docs/tutorials/ed-12.ipynb               |   6 +-
 docs/docs/tutorials/ed-12.py                  |   6 +-
 docs/docs/tutorials/ed-3.ipynb                |  14 +--
 docs/docs/tutorials/ed-3.py                   |  14 +--
 .../user-guide/analysis-workflow/model.md     |   8 +-
 src/easydiffraction/__main__.py               |   2 +-
 src/easydiffraction/analysis/analysis.py      |   2 +-
 src/easydiffraction/io/cif/serialize.py       |  22 ++--
 .../project/categories/chart/__init__.py      |   8 --
 .../categories/rendering_plot/__init__.py     |   8 ++
 .../{chart => rendering_plot}/default.py      |  38 +++----
 .../{chart => rendering_plot}/factory.py      |   6 +-
 .../rendering_structure/__init__.py           |   8 ++
 .../{view => rendering_structure}/default.py  |  36 +++---
 .../{view => rendering_structure}/factory.py  |   4 +-
 .../categories/rendering_table/__init__.py    |   8 ++
 .../{table => rendering_table}/default.py     |  28 ++---
 .../{table => rendering_table}/factory.py     |   4 +-
 .../project/categories/table/__init__.py      |   8 --
 .../project/categories/view/__init__.py       |   8 --
 src/easydiffraction/project/display.py        |  52 ++++-----
 src/easydiffraction/project/project.py        |  42 +++----
 src/easydiffraction/project/project_config.py |  30 ++---
 src/easydiffraction/report/html_renderer.py   |   2 +-
 .../project/categories/chart/test_default.py  | 104 -----------------
 .../project/categories/chart/test_factory.py  |  23 ----
 .../categories/rendering_plot/test_default.py | 104 +++++++++++++++++
 .../categories/rendering_plot/test_factory.py |  23 ++++
 .../test_default.py                           |  24 ++--
 .../rendering_table/test_factory.py           |  23 ++++
 .../project/categories/table/test_factory.py  |  23 ----
 .../easydiffraction/project/test_display.py   |  14 +--
 .../easydiffraction/project/test_project.py   |   8 +-
 .../project/test_project_config.py            |  52 +++++----
 .../project/test_project_load.py              |   8 +-
 39 files changed, 488 insertions(+), 484 deletions(-)
 delete mode 100644 src/easydiffraction/project/categories/chart/__init__.py
 create mode 100644 src/easydiffraction/project/categories/rendering_plot/__init__.py
 rename src/easydiffraction/project/categories/{chart => rendering_plot}/default.py (70%)
 rename src/easydiffraction/project/categories/{chart => rendering_plot}/factory.py (68%)
 create mode 100644 src/easydiffraction/project/categories/rendering_structure/__init__.py
 rename src/easydiffraction/project/categories/{view => rendering_structure}/default.py (84%)
 rename src/easydiffraction/project/categories/{view => rendering_structure}/factory.py (76%)
 create mode 100644 src/easydiffraction/project/categories/rendering_table/__init__.py
 rename src/easydiffraction/project/categories/{table => rendering_table}/default.py (76%)
 rename src/easydiffraction/project/categories/{table => rendering_table}/factory.py (78%)
 delete mode 100644 src/easydiffraction/project/categories/table/__init__.py
 delete mode 100644 src/easydiffraction/project/categories/view/__init__.py
 delete mode 100644 tests/unit/easydiffraction/project/categories/chart/test_default.py
 delete mode 100644 tests/unit/easydiffraction/project/categories/chart/test_factory.py
 create mode 100644 tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py
 create mode 100644 tests/unit/easydiffraction/project/categories/rendering_plot/test_factory.py
 rename tests/unit/easydiffraction/project/categories/{table => rendering_table}/test_default.py (64%)
 create mode 100644 tests/unit/easydiffraction/project/categories/rendering_table/test_factory.py
 delete mode 100644 tests/unit/easydiffraction/project/categories/table/test_factory.py

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index fbfad883f..6c0416b5e 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -48,11 +48,11 @@ Relevant facts about the current codebase:
   `atom_sites` (fractional coordinates, occupancy, isotropic ADP),
   `atom_site_aniso` (anisotropic ADP), and `space_group`.
 - The 1D charting subsystem already uses a switchable-engine pattern.
-  `project.chart.type` selects a plotter engine implemented under
+  `project.rendering_plot.type` selects a plotter engine implemented under
   `src/easydiffraction/display/plotters/` (`ascii.py`, `plotly.py`), and
-  `project.table.type` selects a tabler. These follow the
-  switchable-category ADRs, with CIF tags `_chart.type` and
-  `_table.type`.
+  `project.rendering_table.type` selects a tabler. These follow the
+  switchable-category ADRs, with CIF tags `_rendering_plot.type` and
+  `_rendering_table.type`.
 - `easycrystallography` is **not** a dependency today and is not
   imported anywhere in `src/`. Any layering that places a separate
   visualization package between `easycrystallography` and
@@ -97,7 +97,7 @@ prototype already assumes.
 ### 2. Draw the scene with thin, pluggable renderers
 
 Renderers consume the scene and draw it; they hold no crystallographic
-logic. Renderer choice mirrors `project.chart.type`:
+logic. Renderer choice mirrors `project.rendering_plot.type`:
 
 - an ASCII renderer for terminal, CLI, and headless contexts;
 - a Three.js renderer for notebooks (embedded HTML/JS) and standalone
@@ -109,24 +109,24 @@ the `ascii` and `plotly` chart engines do; Qt Quick 3D follows for the
 GUI.
 
 A switchable engine selector is added on the project owner, parallel to
-`project.chart` / `project.table`. It is named `view`:
+`project.rendering_plot` / `project.rendering_table`. It is named `view`:
 
 ```python
-project.view.type = 'auto'   # default: 'threejs' in Jupyter, 'ascii' in a terminal
-project.view.show_supported()
+project.rendering_structure.type = 'auto'   # default: 'threejs' in Jupyter, 'ascii' in a terminal
+project.rendering_structure.show_supported()
 ```
 
-with CIF tag `_view.type`. The name is kept short and parallel to
+with CIF tag `_rendering_structure.type`. The name is kept short and parallel to
 `chart` / `table`, and follows the category-owned selector contract:
-`project.view` is a read-only attribute on the owner;
-`project.view.type` is the writable selector;
-`project.view.show_supported()` lists engines. Switching `type` calls
-the owner's private `_swap_view` hook, which rebinds the active renderer
+`project.rendering_structure` is a read-only attribute on the owner;
+`project.rendering_structure.type` is the writable selector;
+`project.rendering_structure.show_supported()` lists engines. Switching `type` calls
+the owner's private `_swap_rendering_structure` hook, which rebinds the active renderer
 — the same Family B rebinding the chart engine selector uses — so no
 public `view_type` setter or `show_supported_view_types()` is added. The
 default is `auto`, which resolves at draw time to `threejs` in a Jupyter
-notebook and `ascii` in a terminal — exactly as `_chart.type` /
-`_table.type` resolve their environment defaults.
+notebook and `ascii` in a terminal — exactly as `_rendering_plot.type` /
+`_rendering_table.type` resolve their environment defaults.
 
 ### 3. Add a `structure()` entry point on the display facade
 
@@ -189,8 +189,8 @@ persisted and overridable per call:
 # Persisted per-axis bounds — six scalar settings, like the cell
 # parameters (defaults 0 and 1 on each axis = the full cell, borders
 # included):
-project.view.range_a_max = 2                       # two cells along a
-project.view.range_c_min, project.view.range_c_max = -0.2, 1.2   # margin on c
+project.rendering_structure.range_a_max = 2                       # two cells along a
+project.rendering_structure.range_c_min, project.rendering_structure.range_c_max = -0.2, 1.2   # margin on c
 
 # A convenience tuple overrides the persisted range for one call only:
 project.display.structure(
@@ -467,8 +467,8 @@ persisted to CIF.
 
 ```python
 # How: renderer engine
-project.view.type = 'auto'           # default: 'threejs' in Jupyter, 'ascii' in a terminal
-project.view.show_supported()
+project.rendering_structure.type = 'auto'           # default: 'threejs' in Jupyter, 'ascii' in a terminal
+project.rendering_structure.show_supported()
 
 # How: standard styling models, not per-element values (visual only)
 project.style.atom_shape = 'ortep'        # ball | ortep
@@ -496,29 +496,29 @@ project.display.structure(
 # Three.js modebar stays active, so the user can still toggle each
 # feature live afterwards. show_moments stays inert until the structure
 # model carries moment fields (see Deferred Work).
-project.view.show_labels = False
-project.view.show_moments = True
+project.rendering_structure.show_labels = False
+project.rendering_structure.show_moments = True
 
 # What region (persisted): six per-axis fractional bounds (defaults 0 and
 # 1 = full cell, borders included), mirroring the six scalar cell
 # parameters.
-project.view.range_a_min = 0
-project.view.range_a_max = 1   # range_b_min/max and range_c_min/max likewise
+project.rendering_structure.range_a_min = 0
+project.rendering_structure.range_a_max = 1   # range_b_min/max and range_c_min/max likewise
 ```
 
 The persisted equivalent in the project CIF:
 
 ```
 # In the project CIF (project-level view + style):
-_view.type           auto
-_view.show_labels    false
-_view.show_moments   true
-_view.range_a_min    0
-_view.range_a_max    1
-_view.range_b_min    0
-_view.range_b_max    1
-_view.range_c_min    0
-_view.range_c_max    1
+_rendering_structure.type           auto
+_rendering_structure.show_labels    false
+_rendering_structure.show_moments   true
+_rendering_structure.range_a_min    0
+_rendering_structure.range_a_max    1
+_rendering_structure.range_b_min    0
+_rendering_structure.range_b_max    1
+_rendering_structure.range_c_min    0
+_rendering_structure.range_c_max    1
 
 _style.atom_shape       ortep
 _style.radius_model     covalent
@@ -531,12 +531,12 @@ _geom.min_bond_distance_cutoff   0.0
 _geom.bond_distance_incr         0.4
 ```
 
-The `_view.type` tag follows `_chart.type` / `_table.type` from the
+The `_rendering_structure.type` tag follows `_rendering_plot.type` / `_rendering_table.type` from the
 Display UX Facade ADR, including their `auto` environment-default
 convention (resolved to `threejs` in Jupyter, `ascii` in a terminal); `_geom.min_bond_distance_cutoff` and
 `_geom.bond_distance_incr` are the **standard cif_core** bond-cutoff
 tags (`_atom_type.radius_bond` is the standard per-type bonding radius,
-used when present). The `_style.*` and `_view.*` tags are
+used when present). The `_style.*` and `_rendering_structure.*` tags are
 project-internal app settings whose exact spelling is finalized in the
 implementation plan (see sections 6, 8 and Open Questions).
 
@@ -544,13 +544,13 @@ Initial visibility resolves in a fixed order, so a reopened project and
 a per-call request behave predictably:
 
 1. **An explicit `include=(...)` tuple wins outright.** The view opens
-   showing exactly those features; persisted `_view.show_*` flags are
+   showing exactly those features; persisted `_rendering_structure.show_*` flags are
    ignored for that call. So `include=('atoms',)` shows only atoms even
    when `show_labels=True` is persisted.
 2. **`include='auto'`** — the default, and what a bare `structure()`
    call uses — resolves each feature in turn from: data availability
    first (a feature with no data is off, such as moments without moment
-   fields), then the persisted `_view.show_*` flag where one exists,
+   fields), then the persisted `_rendering_structure.show_*` flag where one exists,
    then the built-in default otherwise. Version 1 persists flags only
    for the two features whose default a scientist most often flips —
    `show_labels` (off) and `show_moments` (on where data exists); atoms,
@@ -564,7 +564,7 @@ a per-call request behave predictably:
    `show_structure_options()` and at draw time.
 4. **Live modebar changes apply on top of that initial state and are
    runtime-only.** Toggling a feature in the Three.js modebar never
-   rewrites the persisted `_view.show_*` flags or the `include=` set, so
+   rewrites the persisted `_rendering_structure.show_*` flags or the `include=` set, so
    reopening the project restores the resolved initial state rather than
    the last live toggle.
 
@@ -578,8 +578,8 @@ a per-call request behave predictably:
   structure and engine is discoverable with reasons.
 - Keeping crystallography in the scene builder and out of renderers lets
   several front-ends (Three.js now, Qt Quick 3D later) share one model.
-- A new switchable `view` category (`project.view.type`, CIF
-  `_view.type`) must be added per the switchable-category and
+- A new switchable `view` category (`project.rendering_structure.type`, CIF
+  `_rendering_structure.type`) must be added per the switchable-category and
   category-owner ADRs, alongside a plain (non-switchable) `style`
   category: `style` has no factory-swapped `type`, only enum-backed
   value settings discoverable through `show_supported()`.
@@ -651,10 +651,10 @@ the final names.
 
 - **CIF tag spelling — resolved.** Project CIF: `_style.atom_shape`,
   `_style.radius_model`, `_style.color_scheme`,
-  `_style.adp_probability`, and `_view.type` / `_view.show_labels` /
-  `_view.show_moments` / `_view.range_{a,b,c}_{min,max}`. These are project-internal
-  app/settings tags (`_view.type` follows the Display-UX `_chart.type` /
-  `_table.type` precedent); the radii and colours are a bundled
+  `_style.adp_probability`, and `_rendering_structure.type` / `_rendering_structure.show_labels` /
+  `_rendering_structure.show_moments` / `_rendering_structure.range_{a,b,c}_{min,max}`. These are project-internal
+  app/settings tags (`_rendering_structure.type` follows the Display-UX `_rendering_plot.type` /
+  `_rendering_table.type` precedent); the radii and colours are a bundled
   element-database asset, not CIF-serialized.
 - **Per-structure bond-cutoff category — resolved (standard
   `_geom.*`).** A single-record `structure.geom` category holding the
@@ -676,7 +676,7 @@ the final names.
   only atoms inside the range (borders included) and bonds only between
   in-scene atoms — no out-of-range partner atoms or edge-coordination
   completion. The range is persisted as six scalar tags
-  `_view.range_{a,b,c}_{min,max}` (one number each, defaults 0 and 1),
+  `_rendering_structure.range_{a,b,c}_{min,max}` (one number each, defaults 0 and 1),
   mirroring the six scalar cell parameters; a per-call `range=` tuple on
   `structure()` overrides them for one call.
 
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index d98862f66..fc158ec50 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -40,8 +40,8 @@ exceptions to those instructions.
     and
     [`switchable-category-api.md`](../adrs/accepted/switchable-category-api.md)
     — the contract the new switchable `view` category follows
-    (`project.view` read-only attribute; `project.view.type` writable
-    selector; `project.view.show_supported()`; private `_swap_view`
+    (`project.rendering_structure` read-only attribute; `project.rendering_structure.type` writable
+    selector; `project.rendering_structure.show_supported()`; private `_swap_rendering_structure`
     hook, Family B engine rebind).
   - [`selector-families.md`](../adrs/accepted/selector-families.md) —
     `view` is a switchable-category selector (Family B), like `chart` /
@@ -86,10 +86,10 @@ plan-level structural choices confirmed with the author at plan start.
   `threejs` (notebook + standalone HTML), shipping together exactly as
   the `asciichartpy` and `plotly` chart engines do. Qt Quick 3D is
   deferred.
-- **Switchable `view` selector** (§2): `project.view.type` (`'auto'`
+- **Switchable `view` selector** (§2): `project.rendering_structure.type` (`'auto'`
   default, resolving to `'threejs'` in Jupyter / `'ascii'` in a
-  terminal), CIF `_view.type`, following the category-owned selector
-  contract with a private `_swap_view` Family B rebind. No `view_type`
+  terminal), CIF `_rendering_structure.type`, following the category-owned selector
+  contract with a private `_swap_rendering_structure` Family B rebind. No `view_type`
   setter, no `show_supported_view_types()`.
 - **`structure()` entry point** (§3):
   `project.display.structure(struct_name=...)` parallel to
@@ -99,7 +99,7 @@ plan-level structural choices confirmed with the author at plan start.
   mirrors `show_pattern_options()`. Notebook embeds an interactive view
   (IPython HTML repr); a standalone HTML file can be written to a path.
 - **Per-axis fractional range** (§3): six scalar bounds
-  `project.view.range_{a,b,c}_{min,max}` (defaults 0 and 1 = full cell,
+  `project.rendering_structure.range_{a,b,c}_{min,max}` (defaults 0 and 1 = full cell,
   **borders included**), mirroring the six scalar cell parameters;
   non-integer allowed, validated min < max per axis, persisted; a
   per-call `range=` tuple on `structure()` overrides for one call.
@@ -153,7 +153,7 @@ plan-level structural choices confirmed with the author at plan start.
   `html_offline` flag — the same switch that already governs
   Plotly/MathJax.
 - **Visibility precedence** (§8): explicit `include=(...)` tuple wins
-  outright (ignores persisted `_view.show_*`); `include='auto'` resolves
+  outright (ignores persisted `_rendering_structure.show_*`); `include='auto'` resolves
   each feature from data-availability → persisted flag (only
   `show_labels` off, `show_moments` on-where-data) → built-in default;
   unsupported options are skipped and announced, never errored; live
@@ -199,17 +199,17 @@ below were verified reachable (HTTP 200).
 - **Exact CIF tag spelling for `style`, `view`, and `geom`** (ADR Open
   Question 1) — **Resolved (final).** Project CIF: `_style.atom_shape`,
   `_style.radius_model`, `_style.color_scheme`,
-  `_style.adp_probability`, and `_view.type`, `_view.show_labels`,
-  `_view.show_moments`, plus the per-axis range as six scalar tags
-  `_view.range_a_min` / `_view.range_a_max` / `_view.range_b_min` /
-  `_view.range_b_max` / `_view.range_c_min` / `_view.range_c_max` (one
+  `_style.adp_probability`, and `_rendering_structure.type`, `_rendering_structure.show_labels`,
+  `_rendering_structure.show_moments`, plus the per-axis range as six scalar tags
+  `_rendering_structure.range_a_min` / `_rendering_structure.range_a_max` / `_rendering_structure.range_b_min` /
+  `_rendering_structure.range_b_max` / `_rendering_structure.range_c_min` / `_rendering_structure.range_c_max` (one
   number each, defaults 0 and 1), mirroring the cell parameters. Structure
   CIF (per-structure): the **standard
   cif_core** bond cutoffs `_geom.min_bond_distance_cutoff` (default
   `0.0`) and `_geom.bond_distance_incr` (default `0.4`), plus the
   per-type bonding radius `_atom_type.radius_bond` when present (P1.11).
-  `_view.type` follows the Display-UX ADR (`_chart.type` /
-  `_table.type`); `_style.*` and `_view.*` are project-internal
+  `_rendering_structure.type` follows the Display-UX ADR (`_rendering_plot.type` /
+  `_rendering_table.type`); `_style.*` and `_rendering_structure.*` are project-internal
   app/settings tags; the bond cutoffs use the standard `_geom.*`
   category `cif_core.dic` defines (`_geom.min_bond_distance_cutoff` dic
   13084, `_geom.bond_distance_incr` dic 13044), while the computed
@@ -314,11 +314,11 @@ below were verified reachable (HTTP 200).
 
 **New project categories:**
 
-- `src/easydiffraction/project/categories/view/__init__.py`,
+- `src/easydiffraction/project/categories/rendering_structure/__init__.py`,
   `default.py`, `factory.py` (new —
   `View(CategoryItem, SwitchableCategoryBase)`,
-  `ViewFactory(FactoryBase)`, modelled on
-  `src/easydiffraction/project/categories/chart/`).
+  `RenderingStructureFactory(FactoryBase)`, modelled on
+  `src/easydiffraction/project/categories/rendering_plot/`).
 - `src/easydiffraction/project/categories/style/__init__.py`,
   `default.py`, `factory.py` (new — `Style` plain category +
   `StyleFactory`, modelled on the existing plain category under
@@ -348,15 +348,15 @@ below were verified reachable (HTTP 200).
 **Project wiring + persistence:**
 
 - `src/easydiffraction/project/project.py` (existing — add `view` /
-  `style` read-only properties and the private `_swap_view` hook,
-  mirroring `_swap_chart` at `project.py:238`).
+  `style` read-only properties and the private `_swap_rendering_structure` hook,
+  mirroring `_swap_rendering_plot` at `project.py:238`).
 - `src/easydiffraction/project/project_config.py` (existing — import +
-  instantiate `ViewFactory` / `StyleFactory` defaults, mirroring the
+  instantiate `RenderingStructureFactory` / `StyleFactory` defaults, mirroring the
   chart/table wiring at `project_config.py:36`).
 - The CIF read-side hook that restores chart/table (in
   `project_config.py` / the project-config CIF deserializer) — extend to
-  restore `_view.*` / `_style.*` (mirrors the chart `from_cif` at
-  `project/categories/chart/default.py:94`).
+  restore `_rendering_structure.*` / `_style.*` (mirrors the chart `from_cif` at
+  `project/categories/rendering_plot/default.py:94`).
 
 **Display facade:**
 
@@ -404,7 +404,7 @@ P1.16):**
   `pixi run notebook-prepare`).
 - `docs/docs/tutorials/*.ipynb` (regenerated artefacts).
 - `docs/docs/user-guide/` and `docs/docs/api-reference/` (existing — add
-  `project.display.structure()`, `project.view`, `project.style`
+  `project.display.structure()`, `project.rendering_structure`, `project.style`
   reference + a short user-guide section).
 
 ## Commit discipline
@@ -435,8 +435,8 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
       an **environment-aware `default()`** (`threejs` in Jupyter, `ascii`
       in a terminal), matching `PlotterEngineEnum` / `TableEngineEnum`.
       The `view` category adds an `'auto'` selector sentinel resolved
-      through `default()`, so `project.view.type` defaults to `auto` and
-      the ADR §8 persisted example is `_view.type auto`; see P1.9 and the
+      through `default()`, so `project.rendering_structure.type` defaults to `auto` and
+      the ADR §8 persisted example is `_rendering_structure.type auto`; see P1.9 and the
       headless note there.
     - `AtomShapeEnum`: `BALL = 'ball'`, `ORTEP = 'ortep'` (default
       `ORTEP`).
@@ -671,7 +671,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     (`display/plotting.py:5980`) and `TableRendererFactory` /
     `TableRenderer` (`display/tables.py:142`): a `_registry()` of
     `{engine: {'description', 'class'}}`, `descriptions()`, and the
-    active-engine binding the `_swap_view` hook rebinds. Add the
+    active-engine binding the `_swap_rendering_structure` hook rebinds. Add the
     `@ViewerFactory.register` decorator to `AsciiStructureRenderer` in
     this step (the factory now exists).
   - **Registration wiring (AGENTS.md §Architecture).**
@@ -718,21 +718,21 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
 
 - [x] **P1.9 — Add the switchable `view` category**
   - Files: new
-    `src/easydiffraction/project/categories/view/__init__.py`,
+    `src/easydiffraction/project/categories/rendering_structure/__init__.py`,
     `default.py`, `factory.py`.
   - `View(CategoryItem, SwitchableCategoryBase)` modelled on `Chart`
-    (`project/categories/chart/default.py`): `_category_code='view'`,
-    `_owner_attr_name='view'`, `_swap_method_name='_swap_view'`; a
-    `type` `StringDescriptor` with CIF `_view.type` validated against
+    (`project/categories/rendering_plot/default.py`): `_category_code='view'`,
+    `_owner_attr_name='view'`, `_swap_method_name='_swap_rendering_structure'`; a
+    `type` `StringDescriptor` with CIF `_rendering_structure.type` validated against
     `['auto', *ViewerEngineEnum]` + `ViewerFactory.descriptions()` and
     **defaulting to `'auto'`** (resolved to a concrete engine through
     `ViewerEngineEnum.default()`, exactly as `Chart` resolves its
-    `'auto'`), matching P1.1; `from_cif` calling `self._parent._swap_view`. Plus persisted
+    `'auto'`), matching P1.1; `from_cif` calling `self._parent._swap_rendering_structure`. Plus persisted
     view-state descriptors: `show_labels` (`BoolDescriptor`, default off),
     `show_moments` (`BoolDescriptor`, default on-where-data), and the
     per-axis range as **six scalar `NumericDescriptor`s**
     `range_a_min` / `range_a_max` / `range_b_min` / `range_b_max` /
-    `range_c_min` / `range_c_max` (CIF `_view.range_a_min` … , defaults 0
+    `range_c_min` / `range_c_max` (CIF `_rendering_structure.range_a_min` … , defaults 0
     and 1, each axis validated `min < max` in the setter), mirroring the
     six scalar cell parameters; `structure()`'s `range=` tuple arg
     overrides them per call. `show_supported()` lists engines.
@@ -742,30 +742,30 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     returns/writes an HTML string and needs **no browser** — it runs
     unattended out of the box. In a bare terminal `auto` resolves to the
     `ascii` engine the ADR §2 names; `threejs` can still be forced via
-    `project.view.type = 'threejs'`. The P1.16 tutorial and the Phase 2
+    `project.rendering_structure.type = 'threejs'`. The P1.16 tutorial and the Phase 2
     script-test coverage item therefore exercise **both** paths: the
     `threejs` HTML emission and an explicit `view.type = 'ascii'`
     terminal render (see the Phase 2 "Integration / script-test
     coverage" item).
-  - Register `View` in `project/categories/view/__init__.py`.
+  - Register `View` in `project/categories/rendering_structure/__init__.py`.
   - Commit: `Add switchable view category for renderer selection`.
 
-- [x] **P1.10 — Wire `project.view` / `project.style` + CIF
+- [x] **P1.10 — Wire `project.rendering_structure` / `project.style` + CIF
       persistence**
   - Files: existing `src/easydiffraction/project/project.py`,
     `src/easydiffraction/project/project_config.py` (+ the
     project-config CIF deserializer hook).
   - Add read-only `view` / `style` properties on `Project` (mirror
-    `chart` / `table` at `project.py:315`) and the private `_swap_view`
-    hook (mirror `_swap_chart` at `project.py:238`) that rebinds the
+    `chart` / `table` at `project.py:315`) and the private `_swap_rendering_structure`
+    hook (mirror `_swap_rendering_plot` at `project.py:238`) that rebinds the
     active `Viewer` engine.
-  - Instantiate `ViewFactory` / `StyleFactory` defaults in
+  - Instantiate `RenderingStructureFactory` / `StyleFactory` defaults in
     `project_config.py` (mirror `project_config.py:36`) and extend the
-    CIF read side to restore `_view.*` / `_style.*` (mirror the chart
+    CIF read side to restore `_rendering_structure.*` / `_style.*` (mirror the chart
     `from_cif`).
   - Round-trip check is deferred to the Phase 2 tests; this step only
     wires the surfaces.
-  - Commit: `Wire project.view and project.style with CIF persistence`.
+  - Commit: `Wire project.rendering_structure and project.style with CIF persistence`.
 
 - [x] **P1.11 — Add the per-structure `geom` bond-cutoff category**
   - Files: new
@@ -808,7 +808,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
       build the scene via
       `build_scene(structure, style=project.style, view_range=<resolved range>, features=<resolved set>)`
       (per-call `range` overrides the persisted view range for
-      that call); render with the active `project.view` engine.
+      that call); render with the active `project.rendering_structure` engine.
       **Signature mirrors `pattern()`**: `structure(...) -> None`,
       displaying directly as a side effect (notebook: `IPython.display`
       of the engine's HTML; terminal: print the ASCII view); when `path`
@@ -850,7 +850,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     - Add structure `include`-option descriptions next to
       `_PATTERN_OPTION_DESCRIPTIONS`.
   - End-to-end ASCII path works after this step
-    (`project.view.type='ascii'`).
+    (`project.rendering_structure.type='ascii'`).
   - Commit:
     `Add structure() and show_structure_options() display surface`.
 
@@ -924,13 +924,13 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Add the **User-facing API** index row for the crysview ADR (the ADR
     file itself is committed/promoted by `/draft-impl-1` Phase A).
   - Add a structure-view example to a representative tutorial
-    (`project.view.type`, `project.style.*`,
+    (`project.rendering_structure.type`, `project.style.*`,
     `structure.geom.min_bond_distance_cutoff` /
     `structure.geom.bond_distance_incr`,
     `project.display.structure(...)`, `show_structure_options(...)`);
     regenerate notebooks via `pixi run notebook-prepare` and stage the
     `.py` + regenerated `.ipynb` together.
-  - Add `project.display.structure()` / `project.view` / `project.style`
+  - Add `project.display.structure()` / `project.rendering_structure` / `project.style`
     and the per-structure `structure.geom` bond cutoffs to the API
     reference and a short user-guide section.
   - Commit: `Document structure view in tutorials and reference`.
@@ -1023,17 +1023,17 @@ coverage (configured in P1.13).
       **rejects both endpoints `0.0` and `1.0`** (open interval, via the
       extended `RangeValidator`); `show_supported()` lists every
       setting's accepted values; `_style.*` CIF round-trips. P1.8.
-- [ ] **`tests/unit/easydiffraction/project/categories/view/test_view.py`**
+- [ ] **`tests/unit/easydiffraction/project/categories/rendering_structure/test_rendering_structure.py`**
       (new) — `type` validates against `['auto', *ViewerEngineEnum]` and
       defaults to `'auto'`; setting
-      `type` calls `_swap_view`; a `range_a_max` below `range_a_min` is
-      rejected (per-axis `min < max`); `_view.type` / `_view.show_*` /
-      `_view.range_a_min` … `_view.range_c_max` CIF round-trip;
+      `type` calls `_swap_rendering_structure`; a `range_a_max` below `range_a_min` is
+      rejected (per-axis `min < max`); `_rendering_structure.type` / `_rendering_structure.show_*` /
+      `_rendering_structure.range_a_min` … `_rendering_structure.range_c_max` CIF round-trip;
       `show_supported()` lists engines. P1.9.
 - [ ] **`tests/unit/easydiffraction/project/test_project.py`** (extend)
-      — `project.view` / `project.style` are read-only attributes;
-      switching `project.view.type` rebinds the active engine; a saved +
-      reloaded project restores `_view.*` / `_style.*` identically.
+      — `project.rendering_structure` / `project.style` are read-only attributes;
+      switching `project.rendering_structure.type` rebinds the active engine; a saved +
+      reloaded project restores `_rendering_structure.*` / `_style.*` identically.
       P1.10.
 - [ ] **`tests/unit/easydiffraction/datablocks/structure/categories/geom/test_geom.py`**
       (new — single parent-level test if the package is only
@@ -1077,7 +1077,7 @@ coverage (configured in P1.13).
       `project.display.structure(...)` along **both** engine paths: the
       **`auto` default** (which resolves to `threejs` under nbmake's
       Jupyter kernel) HTML emission (no browser, runs headless in CI) and
-      an explicit `project.view.type = 'ascii'` terminal render.
+      an explicit `project.rendering_structure.type = 'ascii'` terminal render.
       Extend a tutorial if not. P1.16.
 
 Use `pixi run test-structure-check` to confirm the unit-test layout
@@ -1129,7 +1129,7 @@ ellipsoids — alongside the existing 1D pattern view.
   `project.display.show_structure_options('lbco')` lists what each
   engine and the current structure can show, with reasons when something
   is unavailable.
-- **Choose the engine and the styling, once.** `project.view.type`
+- **Choose the engine and the styling, once.** `project.rendering_structure.type`
   selects `threejs` or `ascii`; `project.style` picks the depiction
   (`ortep` thermal ellipsoids — the default — or `ball`-and-stick), a
   standard radius model (covalent by default, or vdw/ionic/atomic), and
@@ -1142,7 +1142,7 @@ ellipsoids — alongside the existing 1D pattern view.
   the standard bond cut-offs (a minimum distance and a tolerance added
   to the atoms' bonding radii) for each structure, saved in that
   structure's own file, so different phases can use different cut-offs.
-- **See a single cell, a margin, or several cells.** `project.view` sets
+- **See a single cell, a margin, or several cells.** `project.rendering_structure` sets
   a per-axis fractional range (default: the
   full cell with border atoms drawn); widen it for a margin or multiple
   cells.
diff --git a/docs/docs/tutorials/ed-11.ipynb b/docs/docs/tutorials/ed-11.ipynb
index 4cd82dd22..d8753eeac 100644
--- a/docs/docs/tutorials/ed-11.ipynb
+++ b/docs/docs/tutorials/ed-11.ipynb
@@ -82,7 +82,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.chart.show_supported()"
+    "project.rendering_plot.show_supported()"
    ]
   },
   {
@@ -93,7 +93,7 @@
    "outputs": [],
    "source": [
     "# Set global plot range for plots\n",
-    "project.chart.plotter.x_max = 40"
+    "project.rendering_plot.plotter.x_max = 40"
    ]
   },
   {
diff --git a/docs/docs/tutorials/ed-11.py b/docs/docs/tutorials/ed-11.py
index de6e54bb6..b85ede086 100644
--- a/docs/docs/tutorials/ed-11.py
+++ b/docs/docs/tutorials/ed-11.py
@@ -21,11 +21,11 @@
 # ## Set Plotting Engine
 
 # %%
-project.chart.show_supported()
+project.rendering_plot.show_supported()
 
 # %%
 # Set global plot range for plots
-project.chart.plotter.x_max = 40
+project.rendering_plot.plotter.x_max = 40
 
 # %% [markdown]
 # ## Add Structure
diff --git a/docs/docs/tutorials/ed-12.ipynb b/docs/docs/tutorials/ed-12.ipynb
index 62245c730..8941526a3 100644
--- a/docs/docs/tutorials/ed-12.ipynb
+++ b/docs/docs/tutorials/ed-12.ipynb
@@ -87,7 +87,7 @@
    "source": [
     "# Keep the auto-selected engine. Alternatively, you can uncomment the\n",
     "# line below to explicitly set the engine to the required one.\n",
-    "# project.chart.type = 'plotly'"
+    "# project.rendering_plot.type = 'plotly'"
    ]
   },
   {
@@ -98,8 +98,8 @@
    "outputs": [],
    "source": [
     "# Set global plot range for plots\n",
-    "project.chart.plotter.x_min = 2.0\n",
-    "project.chart.plotter.x_max = 30.0"
+    "project.rendering_plot.plotter.x_min = 2.0\n",
+    "project.rendering_plot.plotter.x_max = 30.0"
    ]
   },
   {
diff --git a/docs/docs/tutorials/ed-12.py b/docs/docs/tutorials/ed-12.py
index d1b5dd30e..88251255c 100644
--- a/docs/docs/tutorials/ed-12.py
+++ b/docs/docs/tutorials/ed-12.py
@@ -26,12 +26,12 @@
 # %%
 # Keep the auto-selected engine. Alternatively, you can uncomment the
 # line below to explicitly set the engine to the required one.
-# project.chart.type = 'plotly'
+# project.rendering_plot.type = 'plotly'
 
 # %%
 # Set global plot range for plots
-project.chart.plotter.x_min = 2.0
-project.chart.plotter.x_max = 30.0
+project.rendering_plot.plotter.x_min = 2.0
+project.rendering_plot.plotter.x_max = 30.0
 
 # %% [markdown]
 # ## Add Structure
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index aebf570a3..26e4d3836 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -174,7 +174,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.chart.show_supported()"
+    "project.rendering_plot.show_supported()"
    ]
   },
   {
@@ -192,7 +192,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.chart.show_supported()"
+    "project.rendering_plot.show_supported()"
    ]
   },
   {
@@ -371,7 +371,7 @@
     "#### View Structure in 3D\n",
     "\n",
     "EasyDiffraction can draw the structure that has just been defined. The\n",
-    "renderer engine is selected through `project.view`. The default `auto`\n",
+    "renderer engine is selected through `project.rendering_structure`. The default `auto`\n",
     "engine resolves to an interactive `threejs` view inside Jupyter and a\n",
     "compact `ascii` schematic in a terminal."
    ]
@@ -383,7 +383,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.view.show_supported()"
+    "project.rendering_structure.show_supported()"
    ]
   },
   {
@@ -413,7 +413,7 @@
    "outputs": [],
    "source": [
     "project.style.atom_shape = 'ball'\n",
-    "project.style.radius_model = 'covalent'\n",
+    "project.style.radius_model = 'atomic'\n",
     "project.style.color_scheme = 'jmol'"
    ]
   },
@@ -491,7 +491,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.view.type = 'ascii'\n",
+    "project.rendering_structure.type = 'ascii'\n",
     "project.display.structure(struct_name='lbco')"
    ]
   },
@@ -502,7 +502,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.view.type = 'auto'"
+    "project.rendering_structure.type = 'auto'"
    ]
   },
   {
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index 72b1d496f..1d9e12aa6 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -67,13 +67,13 @@
 # Show supported plotting engines.
 
 # %%
-project.chart.show_supported()
+project.rendering_plot.show_supported()
 
 # %% [markdown]
 # Show current plotting configuration.
 
 # %%
-project.chart.show_supported()
+project.rendering_plot.show_supported()
 
 # %% [markdown]
 # ## Step 2: Define Structure
@@ -170,12 +170,12 @@
 # #### View Structure in 3D
 #
 # EasyDiffraction can draw the structure that has just been defined. The
-# renderer engine is selected through `project.view`. The default `auto`
+# renderer engine is selected through `project.rendering_structure`. The default `auto`
 # engine resolves to an interactive `threejs` view inside Jupyter and a
 # compact `ascii` schematic in a terminal.
 
 # %%
-project.view.show_supported()
+project.rendering_structure.show_supported()
 
 # %% [markdown]
 # Visual styling — the atom shape, per-element radius model, and colour
@@ -186,7 +186,7 @@
 
 # %%
 project.style.atom_shape = 'ball'
-project.style.radius_model = 'covalent'
+project.style.radius_model = 'atomic'
 project.style.color_scheme = 'jmol'
 
 # %% [markdown]
@@ -216,11 +216,11 @@
 # then restore the automatic default.
 
 # %%
-project.view.type = 'ascii'
+project.rendering_structure.type = 'ascii'
 project.display.structure(struct_name='lbco')
 
 # %%
-project.view.type = 'auto'
+project.rendering_structure.type = 'auto'
 
 # %% [markdown]
 # #### Save Project State
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 7f24971da..b637627c6 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -183,17 +183,17 @@ Structure 🧩 'lbco' as cif
 ## Viewing a Model in 3D
 
 EasyDiffraction can render a defined structure as an interactive 3D view.
-The renderer engine is chosen through `project.view`. The default `auto`
+The renderer engine is chosen through `project.rendering_structure`. The default `auto`
 engine resolves to the interactive Three.js view in Jupyter and the
 terminal-friendly ASCII schematic in a console — mirroring how
-`project.chart` and `project.table` pick their environment defaults.
+`project.rendering_plot` and `project.rendering_table` pick their environment defaults.
 
 ```python
 # List the available renderer engines
-project.view.show_supported()
+project.rendering_structure.show_supported()
 
 # Override the automatic choice if desired ('auto', 'threejs', 'ascii')
-project.view.type = 'auto'
+project.rendering_structure.type = 'auto'
 ```
 
 Visual styling — independent of the per-element data — is configured on
diff --git a/src/easydiffraction/__main__.py b/src/easydiffraction/__main__.py
index 201183c01..bbd8ffc3e 100644
--- a/src/easydiffraction/__main__.py
+++ b/src/easydiffraction/__main__.py
@@ -85,7 +85,7 @@ def _display_project_outputs(project: object) -> None:
     project.display.fit.correlations()
 
     if _project_result_kind(project) == 'bayesian':
-        if project.chart.plotter.engine == 'plotly':
+        if project.rendering_plot.plotter.engine == 'plotly':
             project.display.posterior.pairs()
         project.display.posterior.distribution()
         for experiment in project.experiments:
diff --git a/src/easydiffraction/analysis/analysis.py b/src/easydiffraction/analysis/analysis.py
index f53593b21..3e1aaae09 100644
--- a/src/easydiffraction/analysis/analysis.py
+++ b/src/easydiffraction/analysis/analysis.py
@@ -2417,7 +2417,7 @@ def _store_posterior_plot_cache_projection(self, results: BayesianFitResults) ->
             self._persisted_fit_state_sidecar['predictive_datasets'] = {}
             return
 
-        plotter = self.project.chart.plotter
+        plotter = self.project.rendering_plot.plotter
         distribution_payload = self._store_posterior_distribution_cache_projection(
             plotter=plotter,
             results=results,
diff --git a/src/easydiffraction/io/cif/serialize.py b/src/easydiffraction/io/cif/serialize.py
index d09236ba4..ec9f3c792 100644
--- a/src/easydiffraction/io/cif/serialize.py
+++ b/src/easydiffraction/io/cif/serialize.py
@@ -566,7 +566,7 @@ def _as_cif_text(section: object) -> str:
 def project_config_to_cif(project: object) -> str:
     """Render project-level configuration to ``project.cif`` text."""
     sections: list[str] = []
-    for attr_name in ('info', 'chart', 'report'):
+    for attr_name in ('info', 'rendering_plot', 'report'):
         section = getattr(project, attr_name, None)
         if section is not None:
             sections.append(_as_cif_text(section))
@@ -575,7 +575,7 @@ def project_config_to_cif(project: object) -> str:
     if publication is not None:
         sections.append(category_owner_to_cif(publication))
 
-    for attr_name in ('table', 'verbosity'):
+    for attr_name in ('rendering_table', 'verbosity'):
         section = getattr(project, attr_name, None)
         if section is not None:
             sections.append(_as_cif_text(section))
@@ -684,9 +684,9 @@ def project_config_from_cif(project: object, cif_text: str) -> None:
 
     _populate_project_info_from_block(project.info, block)
 
-    chart = getattr(project, 'chart', None)
-    if chart is not None:
-        chart.from_cif(block)
+    rendering_plot = getattr(project, 'rendering_plot', None)
+    if rendering_plot is not None:
+        rendering_plot.from_cif(block)
 
     report = getattr(project, 'report', None)
     if report is not None:
@@ -697,17 +697,17 @@ def project_config_from_cif(project: object, cif_text: str) -> None:
     if publication is not None:
         publication.from_cif(block)
 
-    table = getattr(project, 'table', None)
-    if table is not None:
-        table.from_cif(block)
+    rendering_table = getattr(project, 'rendering_table', None)
+    if rendering_table is not None:
+        rendering_table.from_cif(block)
 
     verbosity = getattr(project, 'verbosity', None)
     if verbosity is not None:
         verbosity.from_cif(block)
 
-    view = getattr(project, 'view', None)
-    if view is not None:
-        view.from_cif(block)
+    rendering_structure = getattr(project, 'rendering_structure', None)
+    if rendering_structure is not None:
+        rendering_structure.from_cif(block)
 
     style = getattr(project, 'style', None)
     if style is not None:
diff --git a/src/easydiffraction/project/categories/chart/__init__.py b/src/easydiffraction/project/categories/chart/__init__.py
deleted file mode 100644
index 1ae8bf874..000000000
--- a/src/easydiffraction/project/categories/chart/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project chart category exports."""
-
-from __future__ import annotations
-
-from easydiffraction.project.categories.chart.default import Chart
-from easydiffraction.project.categories.chart.factory import ChartFactory
diff --git a/src/easydiffraction/project/categories/rendering_plot/__init__.py b/src/easydiffraction/project/categories/rendering_plot/__init__.py
new file mode 100644
index 000000000..140a114ec
--- /dev/null
+++ b/src/easydiffraction/project/categories/rendering_plot/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project rendering_plot category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+from easydiffraction.project.categories.rendering_plot.factory import RenderingPlotFactory
diff --git a/src/easydiffraction/project/categories/chart/default.py b/src/easydiffraction/project/categories/rendering_plot/default.py
similarity index 70%
rename from src/easydiffraction/project/categories/chart/default.py
rename to src/easydiffraction/project/categories/rendering_plot/default.py
index 5d45cdcea..bf058a661 100644
--- a/src/easydiffraction/project/categories/chart/default.py
+++ b/src/easydiffraction/project/categories/rendering_plot/default.py
@@ -1,6 +1,6 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project chart category."""
+"""Project rendering_plot category."""
 
 from __future__ import annotations
 
@@ -15,25 +15,25 @@
 from easydiffraction.display.plotting import PlotterFactory
 from easydiffraction.io.cif.handler import CifHandler
 from easydiffraction.io.cif.parse import read_cif_str
-from easydiffraction.project.categories.chart.factory import ChartFactory
+from easydiffraction.project.categories.rendering_plot.factory import RenderingPlotFactory
 from easydiffraction.utils.logging import log
 
 AUTO_ENGINE = 'auto'
-AUTO_DESCRIPTION = 'Environment default chart engine'
+AUTO_DESCRIPTION = 'Environment default rendering_plot engine'
 CHART_ENGINE_OPTIONS = [AUTO_ENGINE, *[member.value for member in PlotterEngineEnum]]
 
 
-@ChartFactory.register
-class Chart(CategoryItem, SwitchableCategoryBase):
-    """Chart engine selection for a project."""
+@RenderingPlotFactory.register
+class RenderingPlot(CategoryItem, SwitchableCategoryBase):
+    """RenderingPlot engine selection for a project."""
 
-    _category_code = 'chart'
-    _owner_attr_name = 'chart'
-    _swap_method_name = '_swap_chart'
+    _category_code = 'rendering_plot'
+    _owner_attr_name = 'rendering_plot'
+    _swap_method_name = '_swap_rendering_plot'
 
     type_info = TypeInfo(
         tag='default',
-        description='Project chart category',
+        description='Project rendering_plot category',
     )
 
     def __init__(self) -> None:
@@ -42,14 +42,14 @@ def __init__(self) -> None:
         self._plotter = Plotter()
         self._type = StringDescriptor(
             name='type',
-            description='Chart renderer backend type',
+            description='RenderingPlot renderer backend type',
             value_spec=AttributeSpec(
                 default=AUTO_ENGINE,
                 validator=MembershipValidator(
                     allowed=CHART_ENGINE_OPTIONS,
                 ),
             ),
-            cif_handler=CifHandler(names=['_chart.type']),
+            cif_handler=CifHandler(names=['_rendering_plot.type']),
         )
 
     @staticmethod
@@ -61,9 +61,9 @@ def _resolved_engine(value: str) -> str:
     def _set_type(self, value: str, *, strict: bool = True) -> None:
         if value not in CHART_ENGINE_OPTIONS:
             msg = (
-                f"Unsupported chart type '{value}'. "
+                f"Unsupported rendering_plot type '{value}'. "
                 f'Supported: {CHART_ENGINE_OPTIONS}. '
-                f"For more information, use 'chart.show_supported()'"
+                f"For more information, use 'rendering_plot.show_supported()'"
             )
             if strict:
                 raise ValueError(msg)
@@ -87,14 +87,14 @@ def plotter(self) -> Plotter:
     def _supported_types(
         filters: dict[str, object],
     ) -> list[tuple[str, str]]:
-        """Return supported chart renderer backends."""
+        """Return supported rendering_plot renderer backends."""
         del filters
         return [(AUTO_ENGINE, AUTO_DESCRIPTION), *PlotterFactory.descriptions()]
 
     def from_cif(self, block: object, idx: int = 0) -> None:
-        """Populate this chart category from a CIF block."""
+        """Populate this rendering_plot category from a CIF block."""
         del idx
-        chart_type = read_cif_str(block, '_chart.type')
-        if chart_type is None:
+        rendering_plot_type = read_cif_str(block, '_rendering_plot.type')
+        if rendering_plot_type is None:
             return
-        self._parent._swap_chart(chart_type, strict=False)
+        self._parent._swap_rendering_plot(rendering_plot_type, strict=False)
diff --git a/src/easydiffraction/project/categories/chart/factory.py b/src/easydiffraction/project/categories/rendering_plot/factory.py
similarity index 68%
rename from src/easydiffraction/project/categories/chart/factory.py
rename to src/easydiffraction/project/categories/rendering_plot/factory.py
index 4c3237bb4..2d7c2ab65 100644
--- a/src/easydiffraction/project/categories/chart/factory.py
+++ b/src/easydiffraction/project/categories/rendering_plot/factory.py
@@ -1,6 +1,6 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Factory for project chart categories."""
+"""Factory for project rendering_plot categories."""
 
 from __future__ import annotations
 
@@ -9,8 +9,8 @@
 from easydiffraction.core.factory import FactoryBase
 
 
-class ChartFactory(FactoryBase):
-    """Create project chart category instances."""
+class RenderingPlotFactory(FactoryBase):
+    """Create project rendering_plot category instances."""
 
     _default_rules: ClassVar[dict] = {
         frozenset(): 'default',
diff --git a/src/easydiffraction/project/categories/rendering_structure/__init__.py b/src/easydiffraction/project/categories/rendering_structure/__init__.py
new file mode 100644
index 000000000..6ecfff1ee
--- /dev/null
+++ b/src/easydiffraction/project/categories/rendering_structure/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project rendering_structure category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
+from easydiffraction.project.categories.rendering_structure.factory import RenderingStructureFactory
diff --git a/src/easydiffraction/project/categories/view/default.py b/src/easydiffraction/project/categories/rendering_structure/default.py
similarity index 84%
rename from src/easydiffraction/project/categories/view/default.py
rename to src/easydiffraction/project/categories/rendering_structure/default.py
index 929d0b0e6..6e462498d 100644
--- a/src/easydiffraction/project/categories/view/default.py
+++ b/src/easydiffraction/project/categories/rendering_structure/default.py
@@ -1,6 +1,6 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project structure-view category (switchable renderer + view state)."""
+"""Project structure-rendering_structure category (switchable renderer + view state)."""
 
 from __future__ import annotations
 
@@ -17,7 +17,7 @@
 from easydiffraction.display.structure.viewing import ViewerFactory
 from easydiffraction.io.cif.handler import CifHandler
 from easydiffraction.io.cif.parse import read_cif_str
-from easydiffraction.project.categories.view.factory import ViewFactory
+from easydiffraction.project.categories.rendering_structure.factory import RenderingStructureFactory
 from easydiffraction.utils.logging import log
 
 AUTO_ENGINE = 'auto'
@@ -30,21 +30,21 @@ def _range_descriptor(name: str, default: float) -> NumericDescriptor:
         name=name,
         description='Per-axis fractional view-range bound.',
         value_spec=AttributeSpec(default=default),
-        cif_handler=CifHandler(names=[f'_view.{name}']),
+        cif_handler=CifHandler(names=[f'_rendering_structure.{name}']),
     )
 
 
-@ViewFactory.register
-class View(CategoryItem, SwitchableCategoryBase):
+@RenderingStructureFactory.register
+class RenderingStructure(CategoryItem, SwitchableCategoryBase):
     """Renderer engine selection and view state for a project."""
 
-    _category_code = 'view'
-    _owner_attr_name = 'view'
-    _swap_method_name = '_swap_view'
+    _category_code = 'rendering_structure'
+    _owner_attr_name = 'rendering_structure'
+    _swap_method_name = '_swap_rendering_structure'
 
     type_info = TypeInfo(
         tag='default',
-        description='Project view category',
+        description='Project rendering_structure category',
     )
 
     def __init__(self) -> None:
@@ -58,19 +58,19 @@ def __init__(self) -> None:
                 default=AUTO_ENGINE,
                 validator=MembershipValidator(allowed=VIEW_ENGINE_OPTIONS),
             ),
-            cif_handler=CifHandler(names=['_view.type']),
+            cif_handler=CifHandler(names=['_rendering_structure.type']),
         )
         self._show_labels = BoolDescriptor(
             name='show_labels',
             description='Show atom labels when the view opens.',
             value_spec=AttributeSpec(default=False),
-            cif_handler=CifHandler(names=['_view.show_labels']),
+            cif_handler=CifHandler(names=['_rendering_structure.show_labels']),
         )
         self._show_moments = BoolDescriptor(
             name='show_moments',
             description='Show magnetic-moment arrows where the data exists.',
             value_spec=AttributeSpec(default=True),
-            cif_handler=CifHandler(names=['_view.show_moments']),
+            cif_handler=CifHandler(names=['_rendering_structure.show_moments']),
         )
         self._range_a_min = _range_descriptor('range_a_min', 0.0)
         self._range_a_max = _range_descriptor('range_a_max', 1.0)
@@ -88,8 +88,8 @@ def _resolved_engine(value: str) -> str:
     def _set_type(self, value: str, *, strict: bool = True) -> None:
         if value not in VIEW_ENGINE_OPTIONS:
             msg = (
-                f"Unsupported view type '{value}'. Supported: {VIEW_ENGINE_OPTIONS}. "
-                f"For more information, use 'view.show_supported()'"
+                f"Unsupported rendering_structure type '{value}'. Supported: {VIEW_ENGINE_OPTIONS}. "
+                f"For more information, use 'rendering_structure.show_supported()'"
             )
             if strict:
                 raise ValueError(msg)
@@ -200,13 +200,13 @@ def view_range(self) -> tuple[tuple[float, float], tuple[float, float], tuple[fl
         )
 
     def from_cif(self, block: object, idx: int = 0) -> None:
-        """Populate this view category from a CIF block, rebinding engine."""
+        """Populate this rendering_structure category from a CIF block, rebinding engine."""
         super().from_cif(block, idx)
-        view_type = read_cif_str(block, '_view.type')
+        view_type = read_cif_str(block, '_rendering_structure.type')
         if view_type is not None:
-            self._parent._swap_view(view_type, strict=False)
+            self._parent._swap_rendering_structure(view_type, strict=False)
 
     @property
     def as_cif(self) -> str:
-        """Return CIF representation of this view category."""
+        """Return CIF representation of this rendering_structure category."""
         return super().as_cif
diff --git a/src/easydiffraction/project/categories/view/factory.py b/src/easydiffraction/project/categories/rendering_structure/factory.py
similarity index 76%
rename from src/easydiffraction/project/categories/view/factory.py
rename to src/easydiffraction/project/categories/rendering_structure/factory.py
index c9af4aa9b..cdcc6d251 100644
--- a/src/easydiffraction/project/categories/view/factory.py
+++ b/src/easydiffraction/project/categories/rendering_structure/factory.py
@@ -9,8 +9,8 @@
 from easydiffraction.core.factory import FactoryBase
 
 
-class ViewFactory(FactoryBase):
-    """Create project view category instances."""
+class RenderingStructureFactory(FactoryBase):
+    """Create project rendering_structure category instances."""
 
     _default_rules: ClassVar[dict] = {
         frozenset(): 'default',
diff --git a/src/easydiffraction/project/categories/rendering_table/__init__.py b/src/easydiffraction/project/categories/rendering_table/__init__.py
new file mode 100644
index 000000000..59a65396a
--- /dev/null
+++ b/src/easydiffraction/project/categories/rendering_table/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project rendering_table category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.rendering_table.default import RenderingTable
+from easydiffraction.project.categories.rendering_table.factory import RenderingTableFactory
diff --git a/src/easydiffraction/project/categories/table/default.py b/src/easydiffraction/project/categories/rendering_table/default.py
similarity index 76%
rename from src/easydiffraction/project/categories/table/default.py
rename to src/easydiffraction/project/categories/rendering_table/default.py
index 00aa5f47a..98ef5ca47 100644
--- a/src/easydiffraction/project/categories/table/default.py
+++ b/src/easydiffraction/project/categories/rendering_table/default.py
@@ -1,6 +1,6 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project table category."""
+"""Project rendering_table category."""
 
 from __future__ import annotations
 
@@ -15,7 +15,7 @@
 from easydiffraction.display.tables import TableRendererFactory
 from easydiffraction.io.cif.handler import CifHandler
 from easydiffraction.io.cif.parse import read_cif_str
-from easydiffraction.project.categories.table.factory import TableFactory
+from easydiffraction.project.categories.rendering_table.factory import RenderingTableFactory
 from easydiffraction.utils.logging import log
 
 AUTO_ENGINE = 'auto'
@@ -23,17 +23,17 @@
 TABLE_ENGINE_OPTIONS = [AUTO_ENGINE, *[member.value for member in TableEngineEnum]]
 
 
-@TableFactory.register
-class Table(CategoryItem, SwitchableCategoryBase):
+@RenderingTableFactory.register
+class RenderingTable(CategoryItem, SwitchableCategoryBase):
     """Table engine selection for a project."""
 
-    _category_code = 'table'
-    _owner_attr_name = 'table'
-    _swap_method_name = '_swap_table'
+    _category_code = 'rendering_table'
+    _owner_attr_name = 'rendering_table'
+    _swap_method_name = '_swap_rendering_table'
 
     type_info = TypeInfo(
         tag='default',
-        description='Project table category',
+        description='Project rendering_table category',
     )
 
     def __init__(self) -> None:
@@ -49,7 +49,7 @@ def __init__(self) -> None:
                     allowed=TABLE_ENGINE_OPTIONS,
                 ),
             ),
-            cif_handler=CifHandler(names=['_table.type']),
+            cif_handler=CifHandler(names=['_rendering_table.type']),
         )
 
     @staticmethod
@@ -61,9 +61,9 @@ def _resolved_engine(value: str) -> str:
     def _set_type(self, value: str, *, strict: bool = True) -> None:
         if value not in TABLE_ENGINE_OPTIONS:
             msg = (
-                f"Unsupported table type '{value}'. "
+                f"Unsupported rendering_table type '{value}'. "
                 f'Supported: {TABLE_ENGINE_OPTIONS}. '
-                f"For more information, use 'table.show_supported()'"
+                f"For more information, use 'rendering_table.show_supported()'"
             )
             if strict:
                 raise ValueError(msg)
@@ -89,9 +89,9 @@ def _supported_types(
         return [(AUTO_ENGINE, AUTO_DESCRIPTION), *TableRendererFactory.descriptions()]
 
     def from_cif(self, block: object, idx: int = 0) -> None:
-        """Populate this table category from a CIF block."""
+        """Populate this rendering_table category from a CIF block."""
         del idx
-        table_type = read_cif_str(block, '_table.type')
+        table_type = read_cif_str(block, '_rendering_table.type')
         if table_type is None:
             return
-        self._parent._swap_table(table_type, strict=False)
+        self._parent._swap_rendering_table(table_type, strict=False)
diff --git a/src/easydiffraction/project/categories/table/factory.py b/src/easydiffraction/project/categories/rendering_table/factory.py
similarity index 78%
rename from src/easydiffraction/project/categories/table/factory.py
rename to src/easydiffraction/project/categories/rendering_table/factory.py
index eac859310..c7b7f0d82 100644
--- a/src/easydiffraction/project/categories/table/factory.py
+++ b/src/easydiffraction/project/categories/rendering_table/factory.py
@@ -9,8 +9,8 @@
 from easydiffraction.core.factory import FactoryBase
 
 
-class TableFactory(FactoryBase):
-    """Create project table category instances."""
+class RenderingTableFactory(FactoryBase):
+    """Create project rendering_table category instances."""
 
     _default_rules: ClassVar[dict] = {
         frozenset(): 'default',
diff --git a/src/easydiffraction/project/categories/table/__init__.py b/src/easydiffraction/project/categories/table/__init__.py
deleted file mode 100644
index 810cb5c97..000000000
--- a/src/easydiffraction/project/categories/table/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project table category exports."""
-
-from __future__ import annotations
-
-from easydiffraction.project.categories.table.default import Table
-from easydiffraction.project.categories.table.factory import TableFactory
diff --git a/src/easydiffraction/project/categories/view/__init__.py b/src/easydiffraction/project/categories/view/__init__.py
deleted file mode 100644
index 8bed937f7..000000000
--- a/src/easydiffraction/project/categories/view/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project view category exports."""
-
-from __future__ import annotations
-
-from easydiffraction.project.categories.view.default import View
-from easydiffraction.project.categories.view.factory import ViewFactory
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 784777ee9..9c3d2443e 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -143,7 +143,7 @@ def correlations(
         show_diagonal: bool = True,
     ) -> None:
         """Show parameter correlations from the latest fit."""
-        self._project.chart.plotter.plot_param_correlations(
+        self._project.rendering_plot.plotter.plot_param_correlations(
             threshold=threshold,
             precision=precision,
             max_parameters=max_parameters,
@@ -165,9 +165,9 @@ def series(
             another.
         """
         if param is None:
-            self._project.chart.plotter.plot_all_param_series(versus=versus)
+            self._project.rendering_plot.plotter.plot_all_param_series(versus=versus)
         else:
-            self._project.chart.plotter.plot_param_series(param=param, versus=versus)
+            self._project.rendering_plot.plotter.plot_param_series(param=param, versus=versus)
 
     def help(self) -> None:
         """Print available fit-display methods."""
@@ -210,7 +210,7 @@ def _predictive_needs_processing_indicator(
         """Return whether predictive plotting still needs processing."""
         analysis = self._project.analysis
         experiment = self._project.experiments[expt_name]
-        plotter = self._project.chart.plotter
+        plotter = self._project.rendering_plot.plotter
         _, x_axis_name, _, _, _ = plotter._resolve_x_axis(experiment.type, x)
         x_axis_name = str(x_axis_name)
         require_draws = plotter.engine == PlotterEngineEnum.PLOTLY.value and style in {
@@ -261,7 +261,7 @@ def pairs(
             else nullcontext()
         )
         with indicator_context:
-            self._project.chart.plotter.plot_posterior_pairs(
+            self._project.rendering_plot.plotter.plot_posterior_pairs(
                 parameters=parameters,
                 style=style,
                 threshold=threshold,
@@ -272,7 +272,7 @@ def distribution(self, param: object | None = None) -> None:
         """
         Plot posterior distributions for one or all free parameters.
         """
-        plotter = self._project.chart.plotter
+        plotter = self._project.rendering_plot.plotter
         if param is not None:
             plotter.plot_param_distribution(param)
             return
@@ -309,7 +309,7 @@ def predictive(
             else nullcontext()
         )
         with indicator_context:
-            self._project.chart.plotter.plot_posterior_predictive(
+            self._project.rendering_plot.plotter.plot_posterior_predictive(
                 expt_name=expt_name,
                 style=style,
                 x_min=x_min,
@@ -385,7 +385,7 @@ def pattern(
                     else nullcontext()
                 )
                 with indicator_context:
-                    self._project.chart.plotter._plot_posterior_predictive_request(
+                    self._project.rendering_plot.plotter._plot_posterior_predictive_request(
                         expt_name=expt_name,
                         style='band',
                         plot_options=_MeasVsCalcPlotOptions(
@@ -428,7 +428,7 @@ def pattern(
                 else nullcontext()
             )
             with indicator_context:
-                self._project.chart.plotter._plot_posterior_predictive_request(
+                self._project.rendering_plot.plotter._plot_posterior_predictive_request(
                     expt_name=expt_name,
                     style='band',
                     plot_options=_MeasVsCalcPlotOptions(
@@ -481,7 +481,7 @@ def structure(
         Show a 3D structure view for one structure.
 
         Parallels :meth:`pattern`: it draws with the active
-        ``project.view`` engine and displays directly (no return value).
+        ``project.rendering_structure`` engine and displays directly (no return value).
         Feature visibility is resolved per ADR section 8; the renderer
         announces and skips any feature it cannot draw.
 
@@ -491,12 +491,12 @@ def structure(
             Name of the structure to draw.
         include : str | tuple[str, ...]
             ``'auto'`` (default) resolves features from data availability,
-            persisted ``project.view`` flags, then built-in defaults; an
+            persisted ``project.rendering_structure`` flags, then built-in defaults; an
             explicit tuple of ``atoms``/``bonds``/``cell``/``axes``/
             ``moments``/``labels`` wins outright.
         range : tuple | None
             Optional per-axis ``((min, max), ...)`` window overriding the
-            persisted ``project.view`` range for this call only.
+            persisted ``project.rendering_structure`` range for this call only.
         path : str | None
             When given, write the rendered view to this path instead of
             displaying it (a standalone HTML file for the Three.js engine).
@@ -509,14 +509,14 @@ def structure(
         structure = self._project.structures[struct_name]
         availability = structure_feature_availability(structure, style=self._project.style)
         features = self._resolve_structure_features(include, availability)
-        window = range if range is not None else self._project.view.view_range()
+        window = range if range is not None else self._project.rendering_structure.view_range()
         scene = build_scene(
             structure,
             style=self._project.style,
             view_range=window,
             features=features,
         )
-        output = self._project.view.viewer.render(scene, features=features)
+        output = self._project.rendering_structure.viewer.render(scene, features=features)
         if path is not None:
             import pathlib  # noqa: PLC0415
 
@@ -532,7 +532,7 @@ def show_structure_options(self, struct_name: str) -> None:
 
         structure = self._project.structures[struct_name]
         availability = structure_feature_availability(structure, style=self._project.style)
-        supported = self._project.view.viewer.supported_features()
+        supported = self._project.rendering_structure.viewer.supported_features()
         auto = self._resolve_structure_features('auto', availability)
 
         rows = []
@@ -565,7 +565,7 @@ def _resolve_structure_features(
         normalized = self._normalize_structure_include(include)
         if normalized != ('auto',):
             return frozenset(normalized)
-        view = self._project.view
+        view = self._project.rendering_structure
         resolved = {f for f in ('atoms', 'bonds', 'cell', 'axes') if f in availability.available}
         if 'labels' in availability.available and view.show_labels.value:
             resolved.add('labels')
@@ -606,7 +606,7 @@ def _emit_structure_output(self, output: str) -> None:
         from easydiffraction.display.structure.enums import ViewerEngineEnum  # noqa: PLC0415
         from easydiffraction.utils.environment import in_jupyter  # noqa: PLC0415
 
-        if self._project.view.viewer.engine == ViewerEngineEnum.ASCII.value:
+        if self._project.rendering_structure.viewer.engine == ViewerEngineEnum.ASCII.value:
             console.print(output)
             return
         if in_jupyter():
@@ -617,7 +617,7 @@ def _emit_structure_output(self, output: str) -> None:
             return
         console.print(
             'Three.js structure view generated as HTML. Pass path=... to save it, '
-            "or set project.view.type = 'ascii' for a terminal view.",
+            "or set project.rendering_structure.type = 'ascii' for a terminal view.",
         )
 
     @staticmethod
@@ -752,7 +752,7 @@ def _show_point_estimate_pattern(
         self._validate_requested_include(statuses, include)
         include_set = set(include)
         if include_set == {'measured'}:
-            self._project.chart.plotter.plot_meas(
+            self._project.rendering_plot.plotter.plot_meas(
                 expt_name=expt_name,
                 x_min=x_min,
                 x_max=x_max,
@@ -761,7 +761,7 @@ def _show_point_estimate_pattern(
             )
             return
         if include_set == {'measured', 'excluded'}:
-            self._project.chart.plotter.plot_meas(
+            self._project.rendering_plot.plotter.plot_meas(
                 expt_name=expt_name,
                 x_min=x_min,
                 x_max=x_max,
@@ -770,7 +770,7 @@ def _show_point_estimate_pattern(
             )
             return
         if include_set == {'calculated'}:
-            self._project.chart.plotter.plot_calc(
+            self._project.rendering_plot.plotter.plot_calc(
                 expt_name=expt_name,
                 x_min=x_min,
                 x_max=x_max,
@@ -779,7 +779,7 @@ def _show_point_estimate_pattern(
             )
             return
         if include_set == {'calculated', 'excluded'}:
-            self._project.chart.plotter.plot_calc(
+            self._project.rendering_plot.plotter.plot_calc(
                 expt_name=expt_name,
                 x_min=x_min,
                 x_max=x_max,
@@ -788,7 +788,7 @@ def _show_point_estimate_pattern(
             )
             return
         if {'measured', 'calculated'}.issubset(include_set):
-            self._project.chart.plotter._plot_meas_vs_calc_request(
+            self._project.rendering_plot.plotter._plot_meas_vs_calc_request(
                 expt_name=expt_name,
                 plot_options=_MeasVsCalcPlotOptions(
                     x_min=x_min,
@@ -810,7 +810,7 @@ def _show_point_estimate_pattern(
 
     def _pattern_option_statuses(self, expt_name: str) -> list[PatternOptionStatus]:
         """Return availability details for the requested experiment."""
-        self._project.chart.plotter._update_project_categories(expt_name)
+        self._project.rendering_plot.plotter._update_project_categories(expt_name)
         experiment = self._project.experiments[expt_name]
         pattern = intensity_category_for(experiment)
         sample_form = experiment.type.sample_form.value
@@ -1034,9 +1034,9 @@ def _uncertainty_status(
         if not posterior_predictive:
             return False, 'Posterior predictive data is unavailable.'
 
-        active_chart_engine = getattr(self._project.chart.plotter, 'engine', None)
+        active_chart_engine = getattr(self._project.rendering_plot.plotter, 'engine', None)
         if active_chart_engine is None:
-            active_chart_engine = self._project.chart.type
+            active_chart_engine = self._project.rendering_plot.type
 
         if active_chart_engine != PlotterEngineEnum.PLOTLY.value:
             return False, 'Uncertainty bands currently require the Plotly chart engine.'
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index f7e70a397..e49b0083a 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -36,11 +36,11 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from easydiffraction.project.categories.chart import Chart
+    from easydiffraction.project.categories.rendering_plot import RenderingPlot
     from easydiffraction.project.categories.style import Style
-    from easydiffraction.project.categories.table import Table
+    from easydiffraction.project.categories.rendering_table import RenderingTable
     from easydiffraction.project.categories.verbosity import Verbosity
-    from easydiffraction.project.categories.view import View
+    from easydiffraction.project.categories.rendering_structure import RenderingStructure
     from easydiffraction.project.project_info import ProjectInfo
     from easydiffraction.report import Report
 
@@ -209,10 +209,10 @@ def __init__(
         object.__setattr__(self, '_info', self._config.info)
         self._structures = Structures()
         self._experiments = Experiments()
-        object.__setattr__(self, '_chart', self._config.chart)
-        object.__setattr__(self, '_table', self._config.table)
+        object.__setattr__(self, '_rendering_plot', self._config.rendering_plot)
+        object.__setattr__(self, '_rendering_table', self._config.rendering_table)
         object.__setattr__(self, '_verbosity', self._config.verbosity)
-        object.__setattr__(self, '_view', self._config.view)
+        object.__setattr__(self, '_rendering_structure', self._config.rendering_structure)
         object.__setattr__(self, '_style', self._config.style)
         object.__setattr__(self, '_report', self._config.report)
         self._publication = PublicationFactory.create(PublicationFactory.default_tag())
@@ -228,9 +228,9 @@ def _attach_category_parents(self) -> None:
         self._structures._parent = self
         self._experiments._parent = self
         self._analysis._parent = self
-        self._chart._parent = self
-        self._table._parent = self
-        self._view._parent = self
+        self._rendering_plot._parent = self
+        self._rendering_table._parent = self
+        self._rendering_structure._parent = self
         self._style._parent = self
         self._report._parent = self
         self._publication._parent = self
@@ -241,17 +241,17 @@ def _supported_filters_for(category: object) -> dict[str, object]:
         del category
         return {}
 
-    def _swap_chart(self, new_type: str, *, strict: bool = True) -> None:
+    def _swap_rendering_plot(self, new_type: str, *, strict: bool = True) -> None:
         """Switch the active chart renderer."""
-        self._chart._set_type(new_type, strict=strict)
+        self._rendering_plot._set_type(new_type, strict=strict)
 
-    def _swap_table(self, new_type: str, *, strict: bool = True) -> None:
+    def _swap_rendering_table(self, new_type: str, *, strict: bool = True) -> None:
         """Switch the active table renderer."""
-        self._table._set_type(new_type, strict=strict)
+        self._rendering_table._set_type(new_type, strict=strict)
 
-    def _swap_view(self, new_type: str, *, strict: bool = True) -> None:
+    def _swap_rendering_structure(self, new_type: str, *, strict: bool = True) -> None:
         """Switch the active structure-view renderer."""
-        self._view._set_type(new_type, strict=strict)
+        self._rendering_structure._set_type(new_type, strict=strict)
 
     @classmethod
     def current_project_path(cls) -> pathlib.Path | None:
@@ -323,19 +323,19 @@ def experiments(self, experiments: Experiments) -> None:
         self._experiments = experiments
 
     @property
-    def chart(self) -> Chart:
+    def rendering_plot(self) -> RenderingPlot:
         """Chart configuration bound to the project."""
-        return self._chart
+        return self._rendering_plot
 
     @property
-    def table(self) -> Table:
+    def rendering_table(self) -> RenderingTable:
         """Table configuration bound to the project."""
-        return self._table
+        return self._rendering_table
 
     @property
-    def view(self) -> View:
+    def rendering_structure(self) -> RenderingStructure:
         """Structure-view configuration bound to the project."""
-        return self._view
+        return self._rendering_structure
 
     @property
     def style(self) -> Style:
diff --git a/src/easydiffraction/project/project_config.py b/src/easydiffraction/project/project_config.py
index feff171bc..369466888 100644
--- a/src/easydiffraction/project/project_config.py
+++ b/src/easydiffraction/project/project_config.py
@@ -5,20 +5,20 @@
 from __future__ import annotations
 
 from easydiffraction.core.category_owner import CategoryOwner
-from easydiffraction.project.categories.chart import Chart
-from easydiffraction.project.categories.chart import ChartFactory
+from easydiffraction.project.categories.rendering_plot import RenderingPlot
+from easydiffraction.project.categories.rendering_plot import RenderingPlotFactory
 from easydiffraction.project.categories.info import ProjectInfo
 from easydiffraction.project.categories.info import ProjectInfoFactory
 from easydiffraction.project.categories.report import Report
 from easydiffraction.project.categories.report import ReportFactory
-from easydiffraction.project.categories.table import Table
-from easydiffraction.project.categories.table import TableFactory
+from easydiffraction.project.categories.rendering_table import RenderingTable
+from easydiffraction.project.categories.rendering_table import RenderingTableFactory
 from easydiffraction.project.categories.style import Style
 from easydiffraction.project.categories.style import StyleFactory
 from easydiffraction.project.categories.verbosity import Verbosity
 from easydiffraction.project.categories.verbosity import VerbosityFactory
-from easydiffraction.project.categories.view import View
-from easydiffraction.project.categories.view import ViewFactory
+from easydiffraction.project.categories.rendering_structure import RenderingStructure
+from easydiffraction.project.categories.rendering_structure import RenderingStructureFactory
 
 
 class ProjectConfig(CategoryOwner):
@@ -37,11 +37,11 @@ def __init__(
             title=title,
             description=description,
         )
-        self._chart = ChartFactory.create(ChartFactory.default_tag())
+        self._rendering_plot = RenderingPlotFactory.create(RenderingPlotFactory.default_tag())
         self._report = ReportFactory.create(ReportFactory.default_tag())
-        self._table = TableFactory.create(TableFactory.default_tag())
+        self._rendering_table = RenderingTableFactory.create(RenderingTableFactory.default_tag())
         self._verbosity = VerbosityFactory.create(VerbosityFactory.default_tag())
-        self._view = ViewFactory.create(ViewFactory.default_tag())
+        self._rendering_structure = RenderingStructureFactory.create(RenderingStructureFactory.default_tag())
         self._style = StyleFactory.create(StyleFactory.default_tag())
 
     @property
@@ -50,9 +50,9 @@ def info(self) -> ProjectInfo:
         return self._info
 
     @property
-    def chart(self) -> Chart:
+    def rendering_plot(self) -> RenderingPlot:
         """Chart configuration category."""
-        return self._chart
+        return self._rendering_plot
 
     @property
     def report(self) -> Report:
@@ -60,9 +60,9 @@ def report(self) -> Report:
         return self._report
 
     @property
-    def table(self) -> Table:
+    def rendering_table(self) -> RenderingTable:
         """Table configuration category."""
-        return self._table
+        return self._rendering_table
 
     @property
     def verbosity(self) -> Verbosity:
@@ -70,9 +70,9 @@ def verbosity(self) -> Verbosity:
         return self._verbosity
 
     @property
-    def view(self) -> View:
+    def rendering_structure(self) -> RenderingStructure:
         """Structure-view configuration category."""
-        return self._view
+        return self._rendering_structure
 
     @property
     def style(self) -> Style:
diff --git a/src/easydiffraction/report/html_renderer.py b/src/easydiffraction/report/html_renderer.py
index a3e4efce6..e888271e8 100644
--- a/src/easydiffraction/report/html_renderer.py
+++ b/src/easydiffraction/report/html_renderer.py
@@ -207,7 +207,7 @@ def _structure_figure_html_context(
     )
 
     renderer = ThreeJsStructureRenderer()
-    window = project.view.view_range()
+    window = project.rendering_structure.view_range()
     rendered: dict[str, str] = {}
     for structure in project.structures.values():
         availability = structure_feature_availability(structure, style=project.style)
diff --git a/tests/unit/easydiffraction/project/categories/chart/test_default.py b/tests/unit/easydiffraction/project/categories/chart/test_default.py
deleted file mode 100644
index 6cf297dec..000000000
--- a/tests/unit/easydiffraction/project/categories/chart/test_default.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-
-import gemmi
-
-
-def test_chart_defaults():
-    from easydiffraction.display.plotting import PlotterEngineEnum
-    from easydiffraction.project.categories.chart.default import Chart
-
-    chart = Chart()
-
-    assert chart.type_info.tag == 'default'
-    assert chart._identity.category_code == 'chart'
-    assert chart.type == 'auto'
-    assert chart.plotter.engine in [member.value for member in PlotterEngineEnum]
-
-
-def test_chart_plotter_binds_parent():
-    from easydiffraction.project.categories.chart.default import Chart
-
-    chart = Chart()
-    parent = object()
-    chart._parent = parent
-
-    plotter = chart.plotter
-
-    assert plotter._project is parent
-
-
-def test_chart_selector_updates_engine():
-    from easydiffraction.display.plotting import PlotterEngineEnum
-    from easydiffraction.project.categories.chart.default import Chart
-
-    chart = Chart()
-
-    chart._set_type('plotly')
-
-    assert chart.type == 'plotly'
-    assert chart.plotter.engine == 'plotly'
-
-    chart._set_type('auto')
-
-    assert chart.type == 'auto'
-    assert chart.plotter.engine == PlotterEngineEnum.default().value
-
-
-def test_chart_from_cif_restores_type():
-    from easydiffraction.project.categories.chart.default import Chart
-
-    chart = Chart()
-
-    swapped: list[tuple[str, dict]] = []
-
-    class _Parent:
-        def _swap_chart(self, new_type, *, strict):
-            swapped.append((new_type, {'strict': strict}))
-            chart._set_type(new_type, strict=strict)
-
-    chart._parent = _Parent()
-    block = gemmi.cif.read_string(
-        'data_test\n_chart.type plotly\n',
-    ).sole_block()
-
-    chart.from_cif(block)
-
-    assert swapped == [('plotly', {'strict': False})]
-    assert chart.type == 'plotly'
-
-
-def test_chart_invalid_type_assignment_raises():
-    import pytest
-
-    from easydiffraction.project.categories.chart.default import Chart
-
-    chart = Chart()
-    initial_type = chart.type
-
-    with pytest.raises(ValueError, match='Unsupported chart type'):
-        chart._set_type('bogus-engine')
-
-    assert chart.type == initial_type
-
-
-def test_chart_from_cif_tolerates_invalid_type(monkeypatch):
-    from easydiffraction.project.categories.chart import default as chart_mod
-    from easydiffraction.project.categories.chart.default import Chart
-
-    chart = Chart()
-    chart._parent = type(
-        'P',
-        (),
-        {'_swap_chart': lambda self, t, *, strict: chart._set_type(t, strict=strict)},
-    )()
-    block = gemmi.cif.read_string(
-        'data_test\n_chart.type bogus-engine\n',
-    ).sole_block()
-
-    warnings: list[str] = []
-    monkeypatch.setattr(chart_mod.log, 'warning', warnings.append)
-    chart.from_cif(block)
-
-    assert chart.type == 'auto'
-    assert any('Unsupported chart type' in w for w in warnings)
diff --git a/tests/unit/easydiffraction/project/categories/chart/test_factory.py b/tests/unit/easydiffraction/project/categories/chart/test_factory.py
deleted file mode 100644
index e659835fa..000000000
--- a/tests/unit/easydiffraction/project/categories/chart/test_factory.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-
-import pytest
-
-
-def test_chart_factory_default_and_create():
-    from easydiffraction.project.categories.chart.default import Chart
-    from easydiffraction.project.categories.chart.factory import ChartFactory
-
-    assert ChartFactory.default_tag() == 'default'
-    assert 'default' in ChartFactory.supported_tags()
-
-    chart = ChartFactory.create('default')
-
-    assert isinstance(chart, Chart)
-
-
-def test_chart_factory_rejects_unknown_tag():
-    from easydiffraction.project.categories.chart.factory import ChartFactory
-
-    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
-        ChartFactory.create('missing')
diff --git a/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py b/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py
new file mode 100644
index 000000000..0b2b236e2
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py
@@ -0,0 +1,104 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+
+import gemmi
+
+
+def test_rendering_plot_defaults():
+    from easydiffraction.display.plotting import PlotterEngineEnum
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+
+    rendering_plot = RenderingPlot()
+
+    assert rendering_plot.type_info.tag == 'default'
+    assert rendering_plot._identity.category_code == 'rendering_plot'
+    assert rendering_plot.type == 'auto'
+    assert rendering_plot.plotter.engine in [member.value for member in PlotterEngineEnum]
+
+
+def test_rendering_plot_plotter_binds_parent():
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+
+    rendering_plot = RenderingPlot()
+    parent = object()
+    rendering_plot._parent = parent
+
+    plotter = rendering_plot.plotter
+
+    assert plotter._project is parent
+
+
+def test_rendering_plot_selector_updates_engine():
+    from easydiffraction.display.plotting import PlotterEngineEnum
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+
+    rendering_plot = RenderingPlot()
+
+    rendering_plot._set_type('plotly')
+
+    assert rendering_plot.type == 'plotly'
+    assert rendering_plot.plotter.engine == 'plotly'
+
+    rendering_plot._set_type('auto')
+
+    assert rendering_plot.type == 'auto'
+    assert rendering_plot.plotter.engine == PlotterEngineEnum.default().value
+
+
+def test_rendering_plot_from_cif_restores_type():
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+
+    rendering_plot = RenderingPlot()
+
+    swapped: list[tuple[str, dict]] = []
+
+    class _Parent:
+        def _swap_rendering_plot(self, new_type, *, strict):
+            swapped.append((new_type, {'strict': strict}))
+            rendering_plot._set_type(new_type, strict=strict)
+
+    rendering_plot._parent = _Parent()
+    block = gemmi.cif.read_string(
+        'data_test\n_rendering_plot.type plotly\n',
+    ).sole_block()
+
+    rendering_plot.from_cif(block)
+
+    assert swapped == [('plotly', {'strict': False})]
+    assert rendering_plot.type == 'plotly'
+
+
+def test_rendering_plot_invalid_type_assignment_raises():
+    import pytest
+
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+
+    rendering_plot = RenderingPlot()
+    initial_type = rendering_plot.type
+
+    with pytest.raises(ValueError, match='Unsupported rendering_plot type'):
+        rendering_plot._set_type('bogus-engine')
+
+    assert rendering_plot.type == initial_type
+
+
+def test_rendering_plot_from_cif_tolerates_invalid_type(monkeypatch):
+    from easydiffraction.project.categories.rendering_plot import default as rendering_plot_mod
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+
+    rendering_plot = RenderingPlot()
+    rendering_plot._parent = type(
+        'P',
+        (),
+        {'_swap_rendering_plot': lambda self, t, *, strict: rendering_plot._set_type(t, strict=strict)},
+    )()
+    block = gemmi.cif.read_string(
+        'data_test\n_rendering_plot.type bogus-engine\n',
+    ).sole_block()
+
+    warnings: list[str] = []
+    monkeypatch.setattr(rendering_plot_mod.log, 'warning', warnings.append)
+    rendering_plot.from_cif(block)
+
+    assert rendering_plot.type == 'auto'
+    assert any('Unsupported rendering_plot type' in w for w in warnings)
diff --git a/tests/unit/easydiffraction/project/categories/rendering_plot/test_factory.py b/tests/unit/easydiffraction/project/categories/rendering_plot/test_factory.py
new file mode 100644
index 000000000..46f8c8944
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/rendering_plot/test_factory.py
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+
+import pytest
+
+
+def test_rendering_plot_factory_default_and_create():
+    from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+    from easydiffraction.project.categories.rendering_plot.factory import RenderingPlotFactory
+
+    assert RenderingPlotFactory.default_tag() == 'default'
+    assert 'default' in RenderingPlotFactory.supported_tags()
+
+    rendering_plot = RenderingPlotFactory.create('default')
+
+    assert isinstance(rendering_plot, RenderingPlot)
+
+
+def test_rendering_plot_factory_rejects_unknown_tag():
+    from easydiffraction.project.categories.rendering_plot.factory import RenderingPlotFactory
+
+    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
+        RenderingPlotFactory.create('missing')
diff --git a/tests/unit/easydiffraction/project/categories/table/test_default.py b/tests/unit/easydiffraction/project/categories/rendering_table/test_default.py
similarity index 64%
rename from tests/unit/easydiffraction/project/categories/table/test_default.py
rename to tests/unit/easydiffraction/project/categories/rendering_table/test_default.py
index 50dbccf8e..943b21d12 100644
--- a/tests/unit/easydiffraction/project/categories/table/test_default.py
+++ b/tests/unit/easydiffraction/project/categories/rendering_table/test_default.py
@@ -6,21 +6,21 @@
 
 def test_table_defaults():
     from easydiffraction.display.tables import TableEngineEnum
-    from easydiffraction.project.categories.table.default import Table
+    from easydiffraction.project.categories.rendering_table.default import RenderingTable
 
-    table = Table()
+    table = RenderingTable()
 
     assert table.type_info.tag == 'default'
-    assert table._identity.category_code == 'table'
+    assert table._identity.category_code == 'rendering_table'
     assert table.type == 'auto'
     assert table.tabler.engine in [member.value for member in TableEngineEnum]
 
 
 def test_table_selector_updates_engine():
     from easydiffraction.display.tables import TableEngineEnum
-    from easydiffraction.project.categories.table.default import Table
+    from easydiffraction.project.categories.rendering_table.default import RenderingTable
 
-    table = Table()
+    table = RenderingTable()
 
     table._set_type('rich')
 
@@ -34,20 +34,20 @@ def test_table_selector_updates_engine():
 
 
 def test_table_from_cif_restores_type():
-    from easydiffraction.project.categories.table.default import Table
+    from easydiffraction.project.categories.rendering_table.default import RenderingTable
 
-    table = Table()
+    table = RenderingTable()
 
     swapped: list[tuple[str, dict]] = []
 
     class _Parent:
-        def _swap_table(self, new_type, *, strict):
+        def _swap_rendering_table(self, new_type, *, strict):
             swapped.append((new_type, {'strict': strict}))
             table._set_type(new_type, strict=strict)
 
     table._parent = _Parent()
     block = gemmi.cif.read_string(
-        'data_test\n_table.type rich\n',
+        'data_test\n_rendering_table.type rich\n',
     ).sole_block()
 
     table.from_cif(block)
@@ -59,12 +59,12 @@ def _swap_table(self, new_type, *, strict):
 def test_table_invalid_type_assignment_raises():
     import pytest
 
-    from easydiffraction.project.categories.table.default import Table
+    from easydiffraction.project.categories.rendering_table.default import RenderingTable
 
-    table = Table()
+    table = RenderingTable()
     initial_type = table.type
 
-    with pytest.raises(ValueError, match='Unsupported table type'):
+    with pytest.raises(ValueError, match='Unsupported rendering_table type'):
         table._set_type('bogus-engine')
 
     assert table.type == initial_type
diff --git a/tests/unit/easydiffraction/project/categories/rendering_table/test_factory.py b/tests/unit/easydiffraction/project/categories/rendering_table/test_factory.py
new file mode 100644
index 000000000..6624e40b7
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/rendering_table/test_factory.py
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+
+import pytest
+
+
+def test_table_factory_default_and_create():
+    from easydiffraction.project.categories.rendering_table.default import RenderingTable
+    from easydiffraction.project.categories.rendering_table.factory import RenderingTableFactory
+
+    assert RenderingTableFactory.default_tag() == 'default'
+    assert 'default' in RenderingTableFactory.supported_tags()
+
+    table = RenderingTableFactory.create('default')
+
+    assert isinstance(table, RenderingTable)
+
+
+def test_table_factory_rejects_unknown_tag():
+    from easydiffraction.project.categories.rendering_table.factory import RenderingTableFactory
+
+    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
+        RenderingTableFactory.create('missing')
diff --git a/tests/unit/easydiffraction/project/categories/table/test_factory.py b/tests/unit/easydiffraction/project/categories/table/test_factory.py
deleted file mode 100644
index 72c9baa95..000000000
--- a/tests/unit/easydiffraction/project/categories/table/test_factory.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-
-import pytest
-
-
-def test_table_factory_default_and_create():
-    from easydiffraction.project.categories.table.default import Table
-    from easydiffraction.project.categories.table.factory import TableFactory
-
-    assert TableFactory.default_tag() == 'default'
-    assert 'default' in TableFactory.supported_tags()
-
-    table = TableFactory.create('default')
-
-    assert isinstance(table, Table)
-
-
-def test_table_factory_rejects_unknown_tag():
-    from easydiffraction.project.categories.table.factory import TableFactory
-
-    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
-        TableFactory.create('missing')
diff --git a/tests/unit/easydiffraction/project/test_display.py b/tests/unit/easydiffraction/project/test_display.py
index f80d243e4..1c635823e 100644
--- a/tests/unit/easydiffraction/project/test_display.py
+++ b/tests/unit/easydiffraction/project/test_display.py
@@ -63,7 +63,7 @@ def _recorder(*args, **kwargs):
             bayesian_predictive_datasets=[],
             _persisted_fit_state_sidecar={},
         ),
-        chart=SimpleNamespace(plotter=plotter),
+        rendering_plot=SimpleNamespace(plotter=plotter),
         experiments={'hrpt': SimpleNamespace(type=SimpleNamespace())},
         free_parameters=[],
         verbosity=SimpleNamespace(fit=SimpleNamespace(value='full')),
@@ -301,8 +301,8 @@ def test_posterior_predictive_skips_processing_indicator_for_restored_cache(monk
         },
     )
     project.experiments = {'hrpt': SimpleNamespace(type=SimpleNamespace())}
-    project.chart.plotter.engine = 'plotly'
-    project.chart.plotter._resolve_x_axis = lambda expt_type, x: (
+    project.rendering_plot.plotter.engine = 'plotly'
+    project.rendering_plot.plotter._resolve_x_axis = lambda expt_type, x: (
         'two_theta',
         'two_theta',
         None,
@@ -341,7 +341,7 @@ def fake_activity_indicator(label, *, verbosity):
 def test_posterior_distribution_without_param_plots_all_free_parameters():
     project, calls = _make_project_stub()
     project.free_parameters = ['a', 'b']
-    project.chart.plotter.engine = 'plotly'
+    project.rendering_plot.plotter.engine = 'plotly'
     display = ProjectDisplay(project)
 
     display.posterior.distribution()
@@ -355,7 +355,7 @@ def test_posterior_distribution_without_param_plots_all_free_parameters():
 def test_posterior_distribution_without_param_plots_all_free_parameters_for_ascii():
     project, calls = _make_project_stub()
     project.free_parameters = ['a', 'b']
-    project.chart.plotter.engine = 'asciichartpy'
+    project.rendering_plot.plotter.engine = 'asciichartpy'
     display = ProjectDisplay(project)
 
     display.posterior.distribution()
@@ -546,7 +546,7 @@ def test_pattern_option_statuses_ignore_placeholder_arrays_without_usable_state(
         experiments={'hrpt': experiment},
         structures=SimpleNamespace(names=['phase-a']),
         analysis=SimpleNamespace(fit_results=None),
-        chart=SimpleNamespace(
+        rendering_plot=SimpleNamespace(
             plotter=SimpleNamespace(_update_project_categories=lambda expt_name: None),
             type='plotly',
         ),
@@ -592,7 +592,7 @@ def _recorder(*args, **kwargs):
         experiments={'heidi': experiment},
         structures=SimpleNamespace(names=['si']),
         analysis=SimpleNamespace(fit_results=None),
-        chart=SimpleNamespace(
+        rendering_plot=SimpleNamespace(
             plotter=SimpleNamespace(
                 _update_project_categories=lambda expt_name: None,
                 _plot_meas_vs_calc_request=record('_plot_meas_vs_calc_request'),
diff --git a/tests/unit/easydiffraction/project/test_project.py b/tests/unit/easydiffraction/project/test_project.py
index 153fd5687..a57d0e46c 100644
--- a/tests/unit/easydiffraction/project/test_project.py
+++ b/tests/unit/easydiffraction/project/test_project.py
@@ -67,16 +67,16 @@ def test_project_free_params_aggregate_structures_and_experiments():
 
 
 def test_project_exposes_chart_table_and_display_facades():
-    from easydiffraction.project.categories.chart import Chart
-    from easydiffraction.project.categories.table import Table
+    from easydiffraction.project.categories.rendering_plot import RenderingPlot
+    from easydiffraction.project.categories.rendering_table import RenderingTable
     from easydiffraction.project.display import ProjectDisplay
     from easydiffraction.project.project import Project
     from easydiffraction.report import Report
 
     project = Project()
 
-    assert isinstance(project.chart, Chart)
-    assert isinstance(project.table, Table)
+    assert isinstance(project.rendering_plot, RenderingPlot)
+    assert isinstance(project.rendering_table, RenderingTable)
     assert isinstance(project.display, ProjectDisplay)
     assert isinstance(project.report, Report)
     assert hasattr(project.report, 'save')
diff --git a/tests/unit/easydiffraction/project/test_project_config.py b/tests/unit/easydiffraction/project/test_project_config.py
index c921b3199..617f3d871 100644
--- a/tests/unit/easydiffraction/project/test_project_config.py
+++ b/tests/unit/easydiffraction/project/test_project_config.py
@@ -8,9 +8,9 @@
 
 def test_project_config_exposes_project_info_chart_and_table_categories():
     from easydiffraction.core.category_owner import CategoryOwner
-    from easydiffraction.project.categories.chart import Chart
+    from easydiffraction.project.categories.rendering_plot import RenderingPlot
     from easydiffraction.project.categories.report import Report
-    from easydiffraction.project.categories.table import Table
+    from easydiffraction.project.categories.rendering_table import RenderingTable
     from easydiffraction.project.project_config import ProjectConfig
     from easydiffraction.project.project_info import ProjectInfo
 
@@ -18,13 +18,13 @@ def test_project_config_exposes_project_info_chart_and_table_categories():
 
     assert isinstance(config, CategoryOwner)
     assert isinstance(config.info, ProjectInfo)
-    assert isinstance(config.chart, Chart)
+    assert isinstance(config.rendering_plot, RenderingPlot)
     assert isinstance(config.report, Report)
-    assert isinstance(config.table, Table)
+    assert isinstance(config.rendering_table, RenderingTable)
     assert config.info._parent is config
-    assert config.chart._parent is config
+    assert config.rendering_plot._parent is config
     assert config.report._parent is config
-    assert config.table._parent is config
+    assert config.rendering_table._parent is config
     assert config.info.name == 'beer'
     assert config.info.title == 'Beer title'
     assert config.info.description == 'Some description'
@@ -35,17 +35,21 @@ def test_project_config_exposes_project_info_chart_and_table_categories():
     assert config.verbosity.fit.value == 'full'
     assert config.categories == [
         config.info,
-        config.chart,
+        config.rendering_plot,
         config.report,
-        config.table,
+        config.rendering_table,
         config.verbosity,
+        config.rendering_structure,
+        config.style,
     ]
     assert config.parameters == (
         config.info.parameters
-        + config.chart.parameters
+        + config.rendering_plot.parameters
         + config.report.parameters
-        + config.table.parameters
+        + config.rendering_table.parameters
         + config.verbosity.parameters
+        + config.rendering_structure.parameters
+        + config.style.parameters
     )
 
 
@@ -62,15 +66,15 @@ def test_project_config_as_cif_has_project_chart_and_table_sections_without_data
     assert '_project.description' in cif_text
     assert '_project.created' in cif_text
     assert '_project.last_modified' in cif_text
-    assert '_chart.type' in cif_text
+    assert '_rendering_plot.type' in cif_text
     assert '_report.cif' in cif_text
     assert '_report.html' in cif_text
     assert '_report.tex' in cif_text
     assert '_report.pdf' in cif_text
     assert '_report.html_offline' in cif_text
-    assert '_table.type' in cif_text
-    assert '_chart.type auto' in cif_text
-    assert '_table.type auto' in cif_text
+    assert '_rendering_table.type' in cif_text
+    assert '_rendering_plot.type auto' in cif_text
+    assert '_rendering_table.type auto' in cif_text
     assert '_verbosity.fit full' in cif_text
 
 
@@ -83,15 +87,15 @@ def test_project_save_and_load_use_auto_display_defaults_when_unset(tmp_path):
     project_cif = (tmp_path / 'proj' / 'project.cif').read_text()
 
     assert not project_cif.startswith('data_')
-    assert '_chart.type auto' in project_cif
+    assert '_rendering_plot.type auto' in project_cif
     assert '_report.cif false' in project_cif
-    assert '_table.type auto' in project_cif
+    assert '_rendering_table.type auto' in project_cif
     assert '_verbosity.fit full' in project_cif
 
     loaded = Project.load(str(tmp_path / 'proj'))
 
-    assert loaded.chart.type == 'auto'
-    assert loaded.table.type == 'auto'
+    assert loaded.rendering_plot.type == 'auto'
+    assert loaded.rendering_table.type == 'auto'
     assert loaded.verbosity.fit.value == 'full'
 
 
@@ -99,16 +103,16 @@ def test_project_save_and_load_keep_project_config_section_format(tmp_path):
     from easydiffraction.project.project import Project
 
     project = Project(name='beer', title='Beer title', description='Some description')
-    project.chart.type = 'asciichartpy'
-    project.table.type = 'rich'
+    project.rendering_plot.type = 'asciichartpy'
+    project.rendering_table.type = 'rich'
     project.save_as(str(tmp_path / 'proj'))
 
     project_cif = (tmp_path / 'proj' / 'project.cif').read_text()
     assert not project_cif.startswith('data_')
     assert '_project.id               beer' in project_cif
-    assert '_chart.type asciichartpy' in project_cif
+    assert '_rendering_plot.type asciichartpy' in project_cif
     assert '_report.cif false' in project_cif
-    assert '_table.type rich' in project_cif
+    assert '_rendering_table.type rich' in project_cif
     assert '_verbosity.fit full' in project_cif
 
     loaded = Project.load(str(tmp_path / 'proj'))
@@ -117,8 +121,8 @@ def test_project_save_and_load_keep_project_config_section_format(tmp_path):
     assert loaded.info.description == 'Some description'
     assert isinstance(loaded.info.created, datetime.datetime)
     assert isinstance(loaded.info.last_modified, datetime.datetime)
-    assert loaded.chart.type == 'asciichartpy'
-    assert loaded.table.type == 'rich'
+    assert loaded.rendering_plot.type == 'asciichartpy'
+    assert loaded.rendering_table.type == 'rich'
     assert loaded.verbosity.fit.value == 'full'
 
 
diff --git a/tests/unit/easydiffraction/project/test_project_load.py b/tests/unit/easydiffraction/project/test_project_load.py
index cfbd7652d..6747d55c8 100644
--- a/tests/unit/easydiffraction/project/test_project_load.py
+++ b/tests/unit/easydiffraction/project/test_project_load.py
@@ -83,14 +83,14 @@ def test_round_trips_fit_mode(self, tmp_path):
 
     def test_round_trips_display_engine_configuration(self, tmp_path):
         original = Project(name='d1')
-        original.chart.type = 'asciichartpy'
-        original.table.type = 'rich'
+        original.rendering_plot.type = 'asciichartpy'
+        original.rendering_table.type = 'rich'
         original.save_as(str(tmp_path / 'proj'))
 
         loaded = Project.load(str(tmp_path / 'proj'))
 
-        assert loaded.chart.type == 'asciichartpy'
-        assert loaded.table.type == 'rich'
+        assert loaded.rendering_plot.type == 'asciichartpy'
+        assert loaded.rendering_table.type == 'rich'
 
     def test_round_trips_constraints(self, tmp_path):
         original = Project(name='c1')

From 3c9f7f78a8a7516bac01801ce872a555b869c5d6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 12:35:23 +0200
Subject: [PATCH 037/160] Fall back to identity symmetry for unlisted space
 groups

---
 .../crystallography/crystallography.py            |  4 +++-
 .../crystallography/test_crystallography.py       | 15 +++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/easydiffraction/crystallography/crystallography.py b/src/easydiffraction/crystallography/crystallography.py
index 0e694900c..555b20352 100644
--- a/src/easydiffraction/crystallography/crystallography.py
+++ b/src/easydiffraction/crystallography/crystallography.py
@@ -417,7 +417,9 @@ def _get_general_position_ops(
     """
     key = (it_number, coord_code)
     if key not in SPACE_GROUPS:
-        log.error(f'Space group ({it_number}, {coord_code!r}) not found')
+        # Not in the local SPACE_GROUPS table (e.g. P 1, where cryspy
+        # reports no coordinate-system codes). The caller falls back to
+        # the identity operator, so report no general-position ops.
         return None
 
     entry = SPACE_GROUPS[key]
diff --git a/tests/unit/easydiffraction/crystallography/test_crystallography.py b/tests/unit/easydiffraction/crystallography/test_crystallography.py
index 73e1a1342..e8608f18d 100644
--- a/tests/unit/easydiffraction/crystallography/test_crystallography.py
+++ b/tests/unit/easydiffraction/crystallography/test_crystallography.py
@@ -8,3 +8,18 @@ def test_module_import():
     expected_module_name = 'easydiffraction.crystallography.crystallography'
     actual_module_name = MUT.__name__
     assert expected_module_name == actual_module_name
+
+
+def test_symmetry_operators_falls_back_to_identity_for_unlisted_group():
+    import numpy as np
+
+    from easydiffraction.crystallography.crystallography import symmetry_operators
+
+    # P 1 is absent from the local SPACE_GROUPS table (the default-structure
+    # case that previously raised while building a structure scene).
+    ops = symmetry_operators('P 1', '')
+
+    assert len(ops) == 1
+    rotation, translation = ops[0]
+    assert np.array_equal(rotation, np.eye(3, dtype=int))
+    assert np.array_equal(translation, np.zeros(3))

From 6ef90ee47691660f8ed7dc7e256b4e6df64790e7 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 12:37:36 +0200
Subject: [PATCH 038/160] Update ADRs to renamed rendering_plot/table selectors

---
 .../adrs/accepted/category-owner-sections.md  |  8 ++--
 docs/dev/adrs/accepted/display-ux.md          | 14 +++----
 .../adrs/accepted/iucr-cif-tag-alignment.md   |  2 +-
 .../project-facade-and-persistence.md         |  2 +-
 .../accepted/project-summary-rendering.md     | 28 ++++++-------
 docs/dev/adrs/accepted/selector-families.md   |  2 +-
 .../switchable-category-owned-selectors.md    | 40 +++++++++----------
 .../python-cif-category-correspondence.md     | 22 +++++-----
 8 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/docs/dev/adrs/accepted/category-owner-sections.md b/docs/dev/adrs/accepted/category-owner-sections.md
index a5cf27b39..29ebcd199 100644
--- a/docs/dev/adrs/accepted/category-owner-sections.md
+++ b/docs/dev/adrs/accepted/category-owner-sections.md
@@ -85,12 +85,12 @@ Its current children are:
 The public API stays flat and user-facing:
 
 - `project.info`
-- `project.chart`
-- `project.table`
+- `project.rendering_plot`
+- `project.rendering_table`
 
 Saved `project.cif` remains a section file without a `data_` header. It
-serializes the `_project.*` metadata category plus the `_chart.*` and
-`_table.*` configuration categories without pretending that the project
+serializes the `_project.*` metadata category plus the `_rendering_plot.*` and
+`_rendering_table.*` configuration categories without pretending that the project
 config is a real datablock.
 
 ### 4. CIF serialization is split by responsibility
diff --git a/docs/dev/adrs/accepted/display-ux.md b/docs/dev/adrs/accepted/display-ux.md
index 379bdb8c8..1b7379fb4 100644
--- a/docs/dev/adrs/accepted/display-ux.md
+++ b/docs/dev/adrs/accepted/display-ux.md
@@ -43,21 +43,21 @@ defaults.
 
 Use `project.display` as the user-facing facade for display actions.
 Move serialized renderer settings out of that facade and into separate
-project categories named `project.chart` and `project.table`.
+project categories named `project.rendering_plot` and `project.rendering_table`.
 
 Renderer settings:
 
 ```python
-project.chart.type = 'plotly'
-project.table.type = 'pandas'
-project.chart.show_supported()
-project.table.show_supported()
+project.rendering_plot.type = 'plotly'
+project.rendering_table.type = 'pandas'
+project.rendering_plot.show_supported()
+project.rendering_table.show_supported()
 ```
 
 CIF names:
 
-- `_chart.type`
-- `_table.type`
+- `_rendering_plot.type`
+- `_rendering_table.type`
 
 No legacy loader is required for `_display.plotter_type` or
 `_display.tabler_type`. The project is in beta, so this cleanup may
diff --git a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
index 3072bc81c..1d7faddee 100644
--- a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
+++ b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
@@ -109,7 +109,7 @@ Out of scope:
   IUCr export emits the publication-metadata categories per §2.3a with
   `?` placeholders where the project has no source data.
 - imgCIF (`cif_img.dic`); no raw image persistence path exists.
-- Project-level singleton categories `_info.*`, `_chart.*`, `_table.*`,
+- Project-level singleton categories `_info.*`, `_rendering_plot.*`, `_rendering_table.*`,
   `_verbosity.*` — out of scope here; see
   `python-cif-category-correspondence`.
 
diff --git a/docs/dev/adrs/accepted/project-facade-and-persistence.md b/docs/dev/adrs/accepted/project-facade-and-persistence.md
index 6d16f7118..a70108091 100644
--- a/docs/dev/adrs/accepted/project-facade-and-persistence.md
+++ b/docs/dev/adrs/accepted/project-facade-and-persistence.md
@@ -90,7 +90,7 @@ serialized project-information field. If the path is exposed in Python,
 it must not emit a `_project.path` CIF item.
 
 The project-level singleton categories currently persisted in
-`project.cif` are `_project.*`, `_chart.*`, `_report.*`, `_table.*`,
+`project.cif` are `_project.*`, `_rendering_plot.*`, `_report.*`, `_rendering_table.*`,
 `_verbosity.*`, `_journal.*`, `_journal_date.*`, `_journal_coeditor.*`,
 `_publ_contact_author.*`, `_publ_body.*`, and the `_publ_author.*` loop.
 
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index 8098b6d12..1b0ecd116 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -172,7 +172,7 @@ Out of scope:
   Covered by the alignment ADR; the output file lives at
   `reports/<project>.cif` and is opt-in via `project.report.cif = True`.
 - Pre-existing project-level singleton categories (`_info.*`,
-  `_chart.*`, `_table.*`, `_verbosity.*`). Covered by the in-flight
+  `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*`). Covered by the in-flight
   [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md).
   This ADR **does** add one new project-level singleton category,
   `_report.*`, alongside them (see §1.3 and the ADRs-amended list); that
@@ -213,7 +213,7 @@ The alignment ADR has already created the `project.report` facade
 extends it along two axes:
 
 - A new **configuration category** on `project.report` — persisted in
-  `project.cif`, matching the existing `project.chart`, `project.table`,
+  `project.cif`, matching the existing `project.rendering_plot`, `project.rendering_table`,
   `project.verbosity` config pattern — that records _which_ report
   formats `project.save()` emits and _how_.
 - A new set of **ad-hoc per-format methods** for explicit one-off writes
@@ -242,7 +242,7 @@ read by `project.save()` thereafter:
 
 Four per-format scalar booleans (`cif`, `html`, `tex`, `pdf`) plus
 `html_offline` — **five fields total**, all single-row in CIF. Matches
-the existing `project.chart`, `project.table`, `project.verbosity`
+the existing `project.rendering_plot`, `project.rendering_table`, `project.verbosity`
 scalar-config shape verbatim. All booleans default to `False`, so an
 unconfigured project produces no `reports/` directory at all.
 
@@ -388,7 +388,7 @@ unconditionally. They are explicit one-offs.
 #### 1.3 CIF persistence of the configuration
 
 The configuration category serialises to `project.cif` next to the other
-project-level singleton categories (`_info.*`, `_chart.*`, `_table.*`,
+project-level singleton categories (`_info.*`, `_rendering_plot.*`, `_rendering_table.*`,
 `_verbosity.*`). The CIF tag prefix is `_report.*` — a Set category with
 five scalar items, no loops:
 
@@ -402,8 +402,8 @@ _info.created        2026-05-26T12:00:00
 _info.last_modified  2026-05-26T15:42:00
 
 # ---- Chart / table / verbosity selectors (existing config) ----
-_chart.type          plotly
-_table.type          plotly
+_rendering_plot.type          plotly
+_rendering_table.type          plotly
 _verbosity.fit       short
 
 # ---- Report configuration (this ADR §1.3) ----
@@ -416,7 +416,7 @@ _report.html_offline  no
 
 All five items are scalar DDLm dotted entries — the category is declared
 `_definition.class Set` so a single value per item, no loops permitted.
-Matches the existing `_chart.*`, `_table.*`, `_verbosity.*` category
+Matches the existing `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*` category
 shape exactly. The `yes`/`no` boolean encoding follows the project's
 existing CIF boolean convention.
 
@@ -463,8 +463,8 @@ The split is summarised below.
 | Slot                                 | Pattern | CIF location                             | Python shape                                         |
 | ------------------------------------ | ------- | ---------------------------------------- | ---------------------------------------------------- |
 | `project.info`                       | A       | `project.cif` (`_info.*`)                | small `CategoryItem`                                 |
-| `project.chart`                      | A       | `project.cif` (`_chart.*`)               | `CategoryItem` (one field)                           |
-| `project.table`                      | A       | `project.cif` (`_table.*`)               | `CategoryItem` (one field)                           |
+| `project.rendering_plot`                      | A       | `project.cif` (`_rendering_plot.*`)               | `CategoryItem` (one field)                           |
+| `project.rendering_table`                      | A       | `project.cif` (`_rendering_table.*`)               | `CategoryItem` (one field)                           |
 | `project.verbosity`                  | A       | `project.cif` (`_verbosity.*`)           | `CategoryItem` (one field)                           |
 | **`project.report`** (this ADR)      | **A**   | **`project.cif` (`_report.*`)**          | **`CategoryItem` (five fields) plus action methods** |
 | `project.publication` (this ADR, §5) | A       | `project.cif` (`_publ_*` / `_journal_*`) | `CategoryOwner` of six sibling categories            |
@@ -483,8 +483,8 @@ Reasons `project.report` is Pattern A, not Pattern B:
   configuration, which already share `project.cif` for the same reason —
   they are all project-level preferences, not domain data.
 
-What makes `project.report` look heavier than `project.chart` /
-`project.table` / `project.verbosity` is the action methods on the
+What makes `project.report` look heavier than `project.rendering_plot` /
+`project.rendering_table` / `project.verbosity` is the action methods on the
 facade (`save_cif()`, `save_html()`, `show_report()`, `data_context()`,
 etc.). Those live on the Python class alongside the configuration
 fields, which is the facade-hybrid amendment to
@@ -893,7 +893,7 @@ Rationale for the config category (replacing the earlier flag-based and
 "auto on every save" positions):
 
 - Reports are a _project preference_, not a per-call argument.
-  `project.chart.type`, `project.table.type`, `project.verbosity.fit`
+  `project.rendering_plot.type`, `project.rendering_table.type`, `project.verbosity.fit`
   follow the same pattern — set once, persisted in `project.cif`,
   applied on every save.
 - `project.save()` has one job: save the project. With all report
@@ -1955,7 +1955,7 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      `_report.html_offline`). Set the configuration once through those
      booleans; `project.save()` applies it on every save thereafter.
      Replaces the flag with persisted configuration, matching the
-     existing `project.chart`, `project.table`, `project.verbosity`
+     existing `project.rendering_plot`, `project.rendering_table`, `project.verbosity`
      pattern.
   2. **`project.report.save()` surface redesigned.** The accepted
      `project.report.save()` is now a no-argument convenience that reads
@@ -2035,7 +2035,7 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      `project.analysis`, `project.report`. Persisted to `project.cif`
      next to the other project-level singleton categories.
   3. **Project-level singleton category enumeration extended.** The
-     accepted ADR enumerates `_info.*`, `_chart.*`, `_table.*`,
+     accepted ADR enumerates `_info.*`, `_rendering_plot.*`, `_rendering_table.*`,
      `_verbosity.*` as the project-level singleton categories owned by
      `project.cif`. This ADR adds two more to that enumeration:
      `_report.*` (this ADR §1.3) and `_publication.*` family (this ADR
diff --git a/docs/dev/adrs/accepted/selector-families.md b/docs/dev/adrs/accepted/selector-families.md
index 66fb655ff..fefeb1d04 100644
--- a/docs/dev/adrs/accepted/selector-families.md
+++ b/docs/dev/adrs/accepted/selector-families.md
@@ -40,7 +40,7 @@ Recognize three selector families:
 
 | Family                       | User intent                     | Examples                                                                        |
 | ---------------------------- | ------------------------------- | ------------------------------------------------------------------------------- |
-| Backend selector             | Pick an execution backend       | `experiment.calculator.type`, `project.chart.type`, `project.table.type`        |
+| Backend selector             | Pick an execution backend       | `experiment.calculator.type`, `project.rendering_plot.type`, `project.rendering_table.type`        |
 | Switchable-category selector | Swap a category implementation  | `analysis.minimizer.type`, `experiment.background.type`, `experiment.peak.type` |
 | Active-sibling selector      | Pick the active sibling surface | `analysis.fitting_mode.type`                                                    |
 
diff --git a/docs/dev/adrs/accepted/switchable-category-owned-selectors.md b/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
index 9207992e5..ab276cffb 100644
--- a/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
+++ b/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
@@ -147,8 +147,8 @@ own category (also §8).
 | (none — only `_pd_background.*` loop) | `_background.type`   | A                  |
 | (none — only active-class fields)     | `_extinction.type`   | A                  |
 | `_calculation.calculator_type`        | `_calculator.type`   | B (and §8 rename)  |
-| `_rendering.chart_engine`             | `_chart.type`        | B (and §8 split)   |
-| `_rendering.table_engine`             | `_table.type`        | B (and §8 split)   |
+| `_rendering.chart_engine`             | `_rendering_plot.type`        | B (and §8 split)   |
+| `_rendering.table_engine`             | `_rendering_table.type`        | B (and §8 split)   |
 | `_fitting.mode_type`                  | `_fitting_mode.type` | C (and §8 promote) |
 
 ¹ Mechanism family per [`selector-families.md`](selector-families.md): A
@@ -461,7 +461,7 @@ Owners contribute only the filter dict via
 `_supported_filters_for(category)`.
 
 The Family-B swap hooks (e.g. `Experiment._swap_calculator`,
-`Project._swap_chart`, `Project._swap_table`) follow the same shape but
+`Project._swap_rendering_plot`, `Project._swap_rendering_table`) follow the same shape but
 rebind the live engine rather than the category instance. The Family-C
 swap hook (`Analysis._swap_fitting_mode`) performs the existing
 sibling-activation logic. The mixin does not care which mechanism the
@@ -599,12 +599,12 @@ levels).
 The `Rendering` category is **removed**. Two new sibling categories
 appear on `Project`:
 
-- `project.chart` — `CategoryItem` with one writable selector `type`
+- `project.rendering_plot` — `CategoryItem` with one writable selector `type`
   (`PlotterEngineEnum` plus the `'auto'` sentinel) and the live
-  `Plotter` facade as a private internal. CIF block: `_chart.*`.
-- `project.table` — `CategoryItem` with one writable selector `type`
+  `Plotter` facade as a private internal. CIF block: `_rendering_plot.*`.
+- `project.rendering_table` — `CategoryItem` with one writable selector `type`
   (`TableEngineEnum` plus `'auto'`) and the live `TableRenderer` facade
-  as a private internal. CIF block: `_table.*`.
+  as a private internal. CIF block: `_rendering_table.*`.
 
 Both follow the §4 mechanism — Family B (engine swap), `category.type`
 surface — and become natural homes for future chart-only and table-only
@@ -614,8 +614,8 @@ descriptors (e.g. `chart.height`, `chart.theme`, `table.max_rows`,
 The owner-level `project.rendering.show_chart_engines()`,
 `project.rendering.show_table_engines()`, and
 `project.rendering.show_config()` methods are deleted. Their
-replacements are `project.chart.show_supported()`,
-`project.table.show_supported()`, and (if needed) a thin
+replacements are `project.rendering_plot.show_supported()`,
+`project.rendering_table.show_supported()`, and (if needed) a thin
 `project.show_config()` that prints both categories' current state.
 
 #### 8b. `analysis.fitting_mode_type` → `analysis.fitting_mode.type`
@@ -692,8 +692,8 @@ separate, smaller table.
 | 3   | experiment | `experiment.background_type = 'X'`             | `experiment.background.type = 'X'` | (none — only `_pd_background.*` loop)   | `_background.type`   | A              | `experiment/item/bragg_pd.py:184`                 |
 | 4   | experiment | `experiment.extinction_type = 'X'`             | `experiment.extinction.type = 'X'` | (none — only active class's own fields) | `_extinction.type`   | A              | `experiment/item/base.py:312`                     |
 | 5   | experiment | `experiment.calculation.calculator_type = 'X'` | `experiment.calculator.type = 'X'` | `_calculation.calculator_type`          | `_calculator.type`   | B + §8 rename  | `experiment/categories/calculation/default.py:50` |
-| 6   | project    | `project.rendering.chart_engine = 'X'`         | `project.chart.type = 'X'`         | `_rendering.chart_engine`               | `_chart.type`        | B + §8 split   | `project/categories/rendering/default.py:100`     |
-| 7   | project    | `project.rendering.table_engine = 'X'`         | `project.table.type = 'X'`         | `_rendering.table_engine`               | `_table.type`        | B + §8 split   | `project/categories/rendering/default.py:109`     |
+| 6   | project    | `project.rendering.chart_engine = 'X'`         | `project.rendering_plot.type = 'X'`         | `_rendering.chart_engine`               | `_rendering_plot.type`        | B + §8 split   | `project/categories/rendering/default.py:100`     |
+| 7   | project    | `project.rendering.table_engine = 'X'`         | `project.rendering_table.type = 'X'`         | `_rendering.table_engine`               | `_rendering_table.type`        | B + §8 split   | `project/categories/rendering/default.py:109`     |
 | 8   | analysis   | `analysis.fitting_mode_type = 'X'`             | `analysis.fitting_mode.type = 'X'` | `_fitting.mode_type`                    | `_fitting_mode.type` | C + §8 promote | `analysis/analysis.py:960`                        |
 
 Mechanism legend (recap):
@@ -837,15 +837,15 @@ member and exposes `category.type` plus `category.show_supported()`.
 - [`display-ux.md`](display-ux.md) — replace every reference to
   `project.rendering`, `_rendering.chart_engine`, and
   `_rendering.table_engine` with the post-§8a shape:
-  `project.chart.type`, `project.table.type`, CIF blocks `_chart.*` and
-  `_table.*`. Drop the writable-selector contract that puts chart/table
+  `project.rendering_plot.type`, `project.rendering_table.type`, CIF blocks `_rendering_plot.*` and
+  `_rendering_table.*`. Drop the writable-selector contract that puts chart/table
   engines on the `rendering` category; document instead that each
   renderer lives on its own category with the canonical `category.type`
   surface.
 - [`category-owner-sections.md`](category-owner-sections.md) — update
   the `ProjectConfig` children list: drop `Rendering`; add `Chart` and
   `Table` as siblings. Update the `_rendering.*` CIF block reference to
-  `_chart.*` and `_table.*`.
+  `_rendering_plot.*` and `_rendering_table.*`.
 
 (A grep against `docs/dev/adrs/accepted/` for the renamed Python names
 and CIF tags surfaced four additional hits that turned out to be generic
@@ -918,8 +918,8 @@ visible at a glance.
 ```
 data_project
 
-_chart.type   plotly
-_table.type   rich
+_rendering_plot.type   plotly
+_rendering_table.type   rich
 ```
 
 The `_rendering.*` block is gone; two single-purpose blocks replace it
@@ -1040,11 +1040,11 @@ project.experiments['hrpt'].background.create(id='1', order=0, coef=0.42)
 project.experiments['hrpt'].calculator.show_supported()
 project.experiments['hrpt'].calculator.type = 'cryspy'
 
-project.chart.show_supported()
-project.chart.type = 'plotly'
+project.rendering_plot.show_supported()
+project.rendering_plot.type = 'plotly'
 
-project.table.show_supported()
-project.table.type = 'rich'
+project.rendering_table.show_supported()
+project.rendering_table.type = 'rich'
 
 # Family C — active-sibling selector (same surface)
 project.analysis.fitting_mode.show_supported()
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
index f7fbe77c5..65561e670 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
@@ -16,15 +16,15 @@ saved in:
 project.cif
 ```
 
-Inside that file, generic category names such as `_info.*`, `_chart.*`,
-`_table.*`, and `_verbosity.*` are less ambiguous than they would be in
+Inside that file, generic category names such as `_info.*`, `_rendering_plot.*`,
+`_rendering_table.*`, and `_verbosity.*` are less ambiguous than they would be in
 a single monolithic CIF file. This opens the option of a strict
 one-to-one correspondence for project-owned singleton categories:
 
 ```text
 project.info.title        -> project.cif: _info.title
-project.chart.type        -> project.cif: _chart.type
-project.table.type        -> project.cif: _table.type
+project.rendering_plot.type        -> project.cif: _rendering_plot.type
+project.rendering_table.type        -> project.cif: _rendering_table.type
 project.verbosity.fit     -> project.cif: _verbosity.fit
 ```
 
@@ -55,7 +55,7 @@ to objects reached from the current `Project` root, for example
 
 | Current Python surface                           | Current saved location   | Current CIF block form | Notes                                                                                 |
 | ------------------------------------------------ | ------------------------ | ---------------------- | ------------------------------------------------------------------------------------- |
-| `project.info`, `project.chart`, `project.table` | `project.cif`            | bare categories        | Project-level singleton config.                                                       |
+| `project.info`, `project.rendering_plot`, `project.rendering_table` | `project.cif`            | bare categories        | Project-level singleton config.                                                       |
 | `project.report`                                 | `project.cif`            | bare category          | Project-owned report-output config; report methods render artifacts under `reports/`. |
 | `project.publication`                            | `project.cif`            | bare categories + loop | Journal-submission metadata under `_journal_*` / `_publ_*` categories.                |
 | `project.verbosity`                              | `project.cif`            | bare category          | Project-owned fit-output verbosity category backed by `VerbosityEnum`.                |
@@ -76,10 +76,10 @@ to objects reached from the current `Project` root, for example
 | `project.info.created`       | `_project.created`       | Partly | Field name matches, category name does not.                                                        |
 | `project.info.last_modified` | `_project.last_modified` | Partly | Field name matches, category name does not.                                                        |
 | `project.info.path`          | none                     | No     | Runtime storage path, not a CIF field.                                                             |
-| `project.chart.type`         | `_chart.type`            | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.rendering_plot.type`         | `_rendering_plot.type`            | Yes    | Direct category-owned selector mapping.                                                            |
 | `project.report.*`           | `_report.*`              | Yes    | Direct project-owned report-output configuration mapping.                                          |
 | `project.publication.*`      | `_journal.*` / `_publ_*` | Partly | Python keeps one owner with sibling categories; CIF uses journal and publication dictionary names. |
-| `project.table.type`         | `_table.type`            | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.rendering_table.type`         | `_rendering_table.type`            | Yes    | Direct category-owned selector mapping.                                                            |
 | `project.verbosity.fit`      | `_verbosity.fit`         | Yes    | Direct category and field mapping for fitting process output verbosity.                            |
 
 ### Analysis Configuration
@@ -249,8 +249,8 @@ the accepted `_project.*` baseline:
 | `project.info.description`   | `_info.description`   | Currently `_project.description`.                |
 | `project.info.created`       | `_info.created`       | Currently `_project.created`.                    |
 | `project.info.last_modified` | `_info.last_modified` | Currently `_project.last_modified`.              |
-| `project.chart.type`         | `_chart.type`         | Already matches.                                 |
-| `project.table.type`         | `_table.type`         | Already matches.                                 |
+| `project.rendering_plot.type`         | `_rendering_plot.type`         | Already matches.                                 |
+| `project.rendering_table.type`         | `_rendering_table.type`         | Already matches.                                 |
 | `project.verbosity.fit`      | `_verbosity.fit`      | Implemented direct fit-output verbosity mapping. |
 
 Alternative target if the project identity field should be called `id`
@@ -330,14 +330,14 @@ underlying API pattern.
   `project.verbosity.fit`, leaving room for future coverage-specific
   verbosity fields.
 - Chart and table renderers are separate selector categories
-  (`project.chart.type`, `project.table.type`), so a future collapsed
+  (`project.rendering_plot.type`, `project.rendering_table.type`), so a future collapsed
   renderer setting would need a separate ADR.
 
 ## Open Questions
 
 - Should the project identity remain `project.info.name`, or should it
   become `project.info.id` to mirror the saved identifier field?
-- Should `project.chart.type` and `project.table.type` remain separate,
+- Should `project.rendering_plot.type` and `project.rendering_table.type` remain separate,
   or should the public API and CIF collapse to one renderer field?
 - Should `project.verbosity = 'short'` remain as a convenience alias for
   `project.verbosity.fit = 'short'`, or should strict correspondence

From 0383c0155fde1107b84c924137e567c40400e96a Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 12:38:59 +0200
Subject: [PATCH 039/160] Reconcile crysview ADR/plan prose with renamed
 selectors

---
 .../suggestions/crysview-structure-visualization.md   | 11 ++++++-----
 docs/dev/plans/crysview-structure-visualization.md    | 10 +++++-----
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 6c0416b5e..07b707af3 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -109,21 +109,22 @@ the `ascii` and `plotly` chart engines do; Qt Quick 3D follows for the
 GUI.
 
 A switchable engine selector is added on the project owner, parallel to
-`project.rendering_plot` / `project.rendering_table`. It is named `view`:
+`project.rendering_plot` / `project.rendering_table`. It is named
+`rendering_structure`:
 
 ```python
 project.rendering_structure.type = 'auto'   # default: 'threejs' in Jupyter, 'ascii' in a terminal
 project.rendering_structure.show_supported()
 ```
 
-with CIF tag `_rendering_structure.type`. The name is kept short and parallel to
-`chart` / `table`, and follows the category-owned selector contract:
+with CIF tag `_rendering_structure.type`. The name parallels
+`rendering_plot` / `rendering_table`, and follows the category-owned selector contract:
 `project.rendering_structure` is a read-only attribute on the owner;
 `project.rendering_structure.type` is the writable selector;
 `project.rendering_structure.show_supported()` lists engines. Switching `type` calls
 the owner's private `_swap_rendering_structure` hook, which rebinds the active renderer
-— the same Family B rebinding the chart engine selector uses — so no
-public `view_type` setter or `show_supported_view_types()` is added. The
+— the same Family B rebinding the plot engine selector uses — so no
+public `rendering_structure_type` setter or `show_supported_rendering_structure_types()` is added. The
 default is `auto`, which resolves at draw time to `threejs` in a Jupyter
 notebook and `ascii` in a terminal — exactly as `_rendering_plot.type` /
 `_rendering_table.type` resolve their environment defaults.
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index fc158ec50..ba0b8ad77 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -86,11 +86,11 @@ plan-level structural choices confirmed with the author at plan start.
   `threejs` (notebook + standalone HTML), shipping together exactly as
   the `asciichartpy` and `plotly` chart engines do. Qt Quick 3D is
   deferred.
-- **Switchable `view` selector** (§2): `project.rendering_structure.type` (`'auto'`
+- **Switchable `rendering_structure` selector** (§2): `project.rendering_structure.type` (`'auto'`
   default, resolving to `'threejs'` in Jupyter / `'ascii'` in a
   terminal), CIF `_rendering_structure.type`, following the category-owned selector
-  contract with a private `_swap_rendering_structure` Family B rebind. No `view_type`
-  setter, no `show_supported_view_types()`.
+  contract with a private `_swap_rendering_structure` Family B rebind. No `rendering_structure_type`
+  setter, no `show_supported_rendering_structure_types()`.
 - **`structure()` entry point** (§3):
   `project.display.structure(struct_name=...)` parallel to
   `pattern(expt_name=...)`, with `include=` reusing the pattern
@@ -755,8 +755,8 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
   - Files: existing `src/easydiffraction/project/project.py`,
     `src/easydiffraction/project/project_config.py` (+ the
     project-config CIF deserializer hook).
-  - Add read-only `view` / `style` properties on `Project` (mirror
-    `chart` / `table` at `project.py:315`) and the private `_swap_rendering_structure`
+  - Add read-only `rendering_structure` / `style` properties on `Project` (mirror
+    `rendering_plot` / `rendering_table` at `project.py:315`) and the private `_swap_rendering_structure`
     hook (mirror `_swap_rendering_plot` at `project.py:238`) that rebinds the
     active `Viewer` engine.
   - Instantiate `RenderingStructureFactory` / `StyleFactory` defaults in

From d23b95fd69e54a2956f455b0608e9f5a61d2d73e Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 12:47:25 +0200
Subject: [PATCH 040/160] Square-root compress atom ball sizes and lower
 default scale

---
 .../adrs/suggestions/crysview-structure-visualization.md | 4 ++--
 docs/docs/user-guide/analysis-workflow/model.md          | 2 +-
 src/easydiffraction/display/structure/builder.py         | 9 +++++++--
 src/easydiffraction/project/categories/style/default.py  | 8 ++++----
 4 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 07b707af3..f0e53913b 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -476,7 +476,7 @@ project.style.atom_shape = 'ortep'        # ball | ortep
 project.style.radius_model = 'covalent'   # vdw | covalent | ionic | atomic (default covalent)
 project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
 project.style.adp_probability = 0.5       # ortep only; fraction in (0, 1)
-project.style.atom_scale = 0.5            # ball only; radius as fraction of model radius (0, 1]
+project.style.atom_scale = 0.3            # ball only; overall size, sqrt-compressed (0, 1]
 project.style.show_supported()            # accepted values per setting
 
 # Which bonds exist: a per-structure geometric property, not styling.
@@ -525,7 +525,7 @@ _style.atom_shape       ortep
 _style.radius_model     covalent
 _style.color_scheme     jmol
 _style.adp_probability  0.5
-_style.atom_scale       0.5
+_style.atom_scale       0.3
 
 # In the structure (sample) CIF, beside _cell / _atom_site (per-structure):
 _geom.min_bond_distance_cutoff   0.0
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index b637627c6..b81869b1f 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -207,7 +207,7 @@ project.style.show_supported()
 project.style.atom_shape = 'ball'  # 'ball' or 'ortep'
 project.style.radius_model = 'covalent'  # 'vdw', 'covalent', 'ionic', 'atomic'
 project.style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
-project.style.atom_scale = 0.5  # ball radius as a fraction of the model radius
+project.style.atom_scale = 0.3  # overall ball size (square-root compressed)
 ```
 
 Bonds are generated automatically between atoms whose separation falls
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index f5a564eec..df1e3c0b3 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -139,12 +139,17 @@ def _cartesian_u(atom, aniso, matrix: np.ndarray, cell) -> np.ndarray:
     return mn @ comps @ mn.T
 
 
+def _display_radius(model_radius: float, style) -> float:
+    """Square-root-compressed ball radius (narrows the heavy/light spread)."""
+    return style.atom_scale.value * float(np.sqrt(model_radius))
+
+
 def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
     """Build the sphere/ellipsoid primitive for a single full-occupancy atom."""
     element = _element_symbol(atom.type_symbol.value)
     colour = color_for(element, style.color_scheme.value)
     radius, substituted = radius_for(element, style.radius_model.value)
-    ball_radius = radius * style.atom_scale.value
+    ball_radius = _display_radius(radius, style)
     label = atom.label.value
     adp_type = AdpTypeEnum(atom.adp_type.value)
     scale = float(chi.ppf(style.adp_probability.value, 3))
@@ -176,7 +181,7 @@ def _wedge_sphere(rows, centre, *, style):
     else:
         wedges = [OccupancyWedge(occ, colour) for _, occ, _, colour, _ in rows]
         wedges.append(OccupancyWedge(1.0 - total, VACANCY_COLOR))
-    radius = max(radius for _, _, _, _, radius in rows) * style.atom_scale.value
+    radius = _display_radius(max(radius for _, _, _, _, radius in rows), style)
     major = max(rows, key=lambda r: r[1])
     label = '/'.join(r[0].label.value for r in rows)
     primitive = OccupancyWedgeSphere(_vec3(centre), radius, tuple(wedges), label)
diff --git a/src/easydiffraction/project/categories/style/default.py b/src/easydiffraction/project/categories/style/default.py
index 9b1d7a612..d967425e0 100644
--- a/src/easydiffraction/project/categories/style/default.py
+++ b/src/easydiffraction/project/categories/style/default.py
@@ -77,9 +77,9 @@ def __init__(self) -> None:
         )
         self._atom_scale = NumericDescriptor(
             name='atom_scale',
-            description='Ball-atom radius as a fraction of the model radius.',
+            description='Overall ball-atom size factor (square-root compressed).',
             value_spec=AttributeSpec(
-                default=0.5,
+                default=0.3,
                 validator=RangeValidator(gt=0.0, le=1.0),
             ),
             cif_handler=CifHandler(names=['_style.atom_scale']),
@@ -123,7 +123,7 @@ def adp_probability(self, value: float) -> None:
 
     @property
     def atom_scale(self) -> NumericDescriptor:
-        """Ball-atom radius as a fraction of the model radius (0, 1]."""
+        """Overall ball-atom size factor in (0, 1] (square-root compressed)."""
         return self._atom_scale
 
     @atom_scale.setter
@@ -140,7 +140,7 @@ def show_supported(self) -> None:
         ):
             console.print(f"{setting}: {', '.join(member.value for member in enum)}")
         console.print('adp_probability: float in the open interval (0, 1)')
-        console.print('atom_scale: float in (0, 1] (1 = space-filling model radius)')
+        console.print('atom_scale: float in (0, 1] (overall ball size; sqrt-compressed)')
 
     @property
     def as_cif(self) -> str:

From 77b66515f3ff16d02aa6144a682f920a6bc40d85 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 12:50:53 +0200
Subject: [PATCH 041/160] Halve bond cylinder radius for ball-and-stick balance

---
 .../display/structure/templates/structure.html.j2               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index c4447ec9e..58f5aabc0 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -154,7 +154,7 @@ const addHalfBond = (p0, p1, colour) => {
   const direction = p1.clone().sub(p0);
   const length = direction.length();
   if (length < 1e-6) return;
-  const geo = new THREE.CylinderGeometry(0.12, 0.12, length, 12);
+  const geo = new THREE.CylinderGeometry(0.06, 0.06, length, 12);
   const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(colour) }));
   mesh.position.copy(p0.clone().add(p1).multiplyScalar(0.5));
   mesh.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.normalize());

From ad0be68cfdd198a0627a14374eb5bcf75b4575cc Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 13:52:38 +0200
Subject: [PATCH 042/160] Lower default bond increment to 0.25 A for cleaner
 bonding

---
 .../adrs/suggestions/crysview-structure-visualization.md    | 6 +++---
 docs/dev/plans/crysview-structure-visualization.md          | 6 +++---
 docs/docs/tutorials/ed-3.ipynb                              | 2 +-
 docs/docs/tutorials/ed-3.py                                 | 2 +-
 docs/docs/user-guide/analysis-workflow/model.md             | 2 +-
 .../datablocks/structure/categories/geom/default.py         | 2 +-
 src/easydiffraction/display/structure/builder.py            | 2 +-
 7 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index f0e53913b..a7c574f89 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -484,7 +484,7 @@ project.style.show_supported()            # accepted values per setting
 # bond iff  min_cutoff <= d <= r_bond(i) + r_bond(j) + incr.
 structure = project.structures['lbco']
 structure.geom.min_bond_distance_cutoff = 0.0   # default 0.0 Å
-structure.geom.bond_distance_incr       = 0.4   # default 0.4 Å (documented, tunable)
+structure.geom.bond_distance_incr       = 0.25   # default 0.25 Å (documented, tunable)
 
 # What (per call): content for one view, overriding the initial defaults
 project.display.structure(struct_name='lbco')                    # 'auto'
@@ -529,7 +529,7 @@ _style.atom_scale       0.3
 
 # In the structure (sample) CIF, beside _cell / _atom_site (per-structure):
 _geom.min_bond_distance_cutoff   0.0
-_geom.bond_distance_incr         0.4
+_geom.bond_distance_incr         0.25
 ```
 
 The `_rendering_structure.type` tag follows `_rendering_plot.type` / `_rendering_table.type` from the
@@ -660,7 +660,7 @@ the final names.
 - **Per-structure bond-cutoff category — resolved (standard
   `_geom.*`).** A single-record `structure.geom` category holding the
   cif_core cutoffs `_geom.min_bond_distance_cutoff` (default `0.0` Å)
-  and `_geom.bond_distance_incr` (default `0.4` Å, documented and
+  and `_geom.bond_distance_incr` (default `0.25` Å, documented and
   tunable), in the structure datablock. A bond is drawn when
   `min_bond_distance_cutoff ≤ d ≤ r_bond(i) + r_bond(j) + bond_distance_incr`,
   with `r_bond` = `_atom_type.radius_bond` when present, else the
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index ba0b8ad77..247abeca6 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -206,7 +206,7 @@ below were verified reachable (HTTP 200).
   number each, defaults 0 and 1), mirroring the cell parameters. Structure
   CIF (per-structure): the **standard
   cif_core** bond cutoffs `_geom.min_bond_distance_cutoff` (default
-  `0.0`) and `_geom.bond_distance_incr` (default `0.4`), plus the
+  `0.0`) and `_geom.bond_distance_incr` (default `0.25`), plus the
   per-type bonding radius `_atom_type.radius_bond` when present (P1.11).
   `_rendering_structure.type` follows the Display-UX ADR (`_rendering_plot.type` /
   `_rendering_table.type`); `_style.*` and `_rendering_structure.*` are project-internal
@@ -778,7 +778,7 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     the standard cif_core bond-generation cutoffs:
     - `min_bond_distance_cutoff` (float Å, default `0.0`) — CIF
       `_geom.min_bond_distance_cutoff`.
-    - `bond_distance_incr` (float Å, default `0.4`, documented and
+    - `bond_distance_incr` (float Å, default `0.25`, documented and
       tunable) — CIF `_geom.bond_distance_incr`. A bond forms between
       two in-scene atoms when
       `min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + bond_distance_incr`,
@@ -1038,7 +1038,7 @@ coverage (configured in P1.13).
 - [ ] **`tests/unit/easydiffraction/datablocks/structure/categories/geom/test_geom.py`**
       (new — single parent-level test if the package is only
       `default.py`/`factory.py`) — defaults are
-      `min_bond_distance_cutoff = 0.0` and `bond_distance_incr = 0.4`;
+      `min_bond_distance_cutoff = 0.0` and `bond_distance_incr = 0.25`;
       both `_geom.min_bond_distance_cutoff` and
       `_geom.bond_distance_incr` round-trip in the **structure**
       datablock; a multi-phase project keeps independent cutoffs per
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index 26e4d3836..eaa063437 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -434,7 +434,7 @@
    "outputs": [],
    "source": [
     "project.structures['lbco'].geom.min_bond_distance_cutoff = 0.5\n",
-    "project.structures['lbco'].geom.bond_distance_incr = 0.45"
+    "project.structures['lbco'].geom.bond_distance_incr = 0.25"
    ]
   },
   {
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index 1d9e12aa6..c72573876 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -195,7 +195,7 @@
 
 # %%
 project.structures['lbco'].geom.min_bond_distance_cutoff = 0.5
-project.structures['lbco'].geom.bond_distance_incr = 0.45
+project.structures['lbco'].geom.bond_distance_incr = 0.25
 
 # %% [markdown]
 # List which features the structure data and the active engine can draw.
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index b81869b1f..b3139565f 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -217,7 +217,7 @@ cif_core `_geom` parameters):
 ```python
 # Tune the per-structure bond-generation cutoffs (angstrom)
 project.structures['lbco'].geom.min_bond_distance_cutoff = 0.5
-project.structures['lbco'].geom.bond_distance_incr = 0.45
+project.structures['lbco'].geom.bond_distance_incr = 0.25
 ```
 
 Draw the structure through `project.display`, mirroring
diff --git a/src/easydiffraction/datablocks/structure/categories/geom/default.py b/src/easydiffraction/datablocks/structure/categories/geom/default.py
index 21a491a03..4a06bc0b6 100644
--- a/src/easydiffraction/datablocks/structure/categories/geom/default.py
+++ b/src/easydiffraction/datablocks/structure/categories/geom/default.py
@@ -40,7 +40,7 @@ def __init__(self) -> None:
             name='bond_distance_incr',
             description='Increment added to the summed bonding radii (angstrom).',
             value_spec=AttributeSpec(
-                default=0.4,
+                default=0.25,
                 validator=RangeValidator(ge=0.0),
             ),
             cif_handler=CifHandler(names=['_geom.bond_distance_incr']),
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index df1e3c0b3..8081bc4bd 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -40,7 +40,7 @@
 # Tolerance (fractional units) for scene-atom identity and occupancy grouping.
 IDENTITY_TOL = 1e-4
 EIGHT_PI_SQ = 8.0 * np.pi**2
-DEFAULT_BOND_INCR = 0.4
+DEFAULT_BOND_INCR = 0.25
 ALL_FEATURES = ('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels')
 
 

From 87b93e92f21364b84faf3c6fdde711da6ac11c07 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 13:52:38 +0200
Subject: [PATCH 043/160] Default to a trimetric c-axis-up structure view

---
 .../structure/templates/structure.html.j2     | 29 ++++++++++++++++---
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 58f5aabc0..76919a044 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -227,10 +227,29 @@ const radius = Math.max(box.getBoundingSphere(new THREE.Sphere()).radius, 1);
 const aspect = width / height;
 const far = radius * 100;
 const distance = radius * 2.0;
-const home = target.clone().add(new THREE.Vector3(distance, distance * 0.6, distance));
+
+// Trimetric default view: c-axis up, tilted above the ab-plane and rotated
+// in azimuth so all three axes read distinctly. Falls back to a fixed angle
+// when the cell axes are not in the scene.
+const cellBasis = SCENE.axes ? SCENE.axes.arrows.map((a) => vec(a.vector)) : [];
+let viewUp;
+let viewDir;
+if (cellBasis.length === 3) {
+  const aHat = cellBasis[0].clone().normalize();
+  const bHat = cellBasis[1].clone().normalize();
+  const cHat = cellBasis[2].clone().normalize();
+  viewUp = cHat.clone();
+  viewDir = aHat.multiplyScalar(1.0).add(bHat.multiplyScalar(0.45)).add(cHat.multiplyScalar(0.55)).normalize();
+} else {
+  viewUp = new THREE.Vector3(0, 1, 0);
+  viewDir = new THREE.Vector3(1.0, 0.8, 1.5).normalize();
+}
+const home = target.clone().add(viewDir.multiplyScalar(distance));
 
 const perspective = new THREE.PerspectiveCamera(45, aspect, radius * 0.01, far);
 const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.05, radius * aspect * 1.05, radius * 1.05, -radius * 1.05, -far, far);
+perspective.up.copy(viewUp);
+ortho.up.copy(viewUp);
 perspective.position.copy(home);
 ortho.position.copy(home);
 let camera = ortho;
@@ -249,7 +268,8 @@ const setCamera = (next) => {
   camera = next;
   controls.update();
 };
-const viewAlong = (axisVector) => {
+const viewAlong = (axisVector, upVector) => {
+  camera.up.copy(upVector);
   camera.position.copy(target.clone().add(axisVector.clone().normalize().multiplyScalar(distance)));
   controls.update();
 };
@@ -275,17 +295,18 @@ projButton.addEventListener('click', () => {
   projButton.title = projection === 'orthographic' ? 'Parallel (orthographic) view' : 'Perspective view';
 });
 
-const cellBasis = SCENE.axes ? SCENE.axes.arrows.map((a) => vec(a.vector)) : [];
 if (SCENE.axes) {
   SCENE.axes.arrows.forEach((arrow, i) => {
     const button = iconButton(cameraGroup, arrow.letter, `View along ${arrow.letter}`, 'lt');
     button.style.color = rgbCss(arrow.colour);
-    button.addEventListener('click', () => viewAlong(cellBasis[i]));
+    const upAxis = i === 2 ? cellBasis[1] : cellBasis[2];
+    button.addEventListener('click', () => viewAlong(cellBasis[i], upAxis));
   });
 }
 
 const homeButton = iconButton(cameraGroup, ICONS.home, 'Reset view');
 homeButton.addEventListener('click', () => {
+  camera.up.copy(viewUp);
   camera.position.copy(home);
   controls.target.copy(target);
   controls.update();

From c691e721c9083e32cefeed0e2b258e5a84a2a591 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 13:52:38 +0200
Subject: [PATCH 044/160] Note near-neighbour auto-bonding as a future
 improvement

---
 docs/dev/issues/open.md | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/docs/dev/issues/open.md b/docs/dev/issues/open.md
index 81bbd9cb3..d355f1dc8 100644
--- a/docs/dev/issues/open.md
+++ b/docs/dev/issues/open.md
@@ -1790,6 +1790,33 @@ Requirements:
 
 ---
 
+## 108. 🟢 Smarter Automatic Bond Detection (Near-Neighbour Analysis)
+
+**Type:** UX / Visualization
+
+crysview generates bonds with the cif_core distance rule
+(`min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + bond_distance_incr`).
+It is deterministic and dependency-free, but a single global increment
+cannot separate coordination shells: dense structures (e.g. the LBCO
+perovskite, where the Co–O octahedron and the longer La/Ba–O cation
+contacts both fall in range) render a busy bond mesh. The default
+`bond_distance_incr` was lowered to `0.25 Å` to favour the primary
+coordination shell, but this remains a blunt instrument.
+
+**Fix:** consider an optional near-neighbour algorithm for automatic
+"reasonable" bonding — e.g. a Voronoi / solid-angle method such as
+pymatgen's `CrystalNN` or `VoronoiNN`, or an ASE/Jmol-style
+multiplicative covalent tolerance `d ≤ (r_A + r_B)·f`. The Voronoi route
+is the most robust across arbitrary structures but introduces a
+heavyweight dependency (pymatgen), so it needs a dependency decision; the
+multiplicative tolerance is lighter but deviates from the cif_core
+additive `_geom` model crysview currently follows.
+
+**Depends on:** dependency decision for pymatgen (if the Voronoi route is
+chosen).
+
+---
+
 ## Summary
 
 | #   | Issue                                             | Severity | Type                         |
@@ -1880,3 +1907,4 @@ Requirements:
 | 105 | Remove orphaned fit-result reset helper           | 🟢 Low   | Cleanup                      |
 | 106 | Document `FitResultBase.result_kind` default      | 🟢 Low   | Code readability             |
 | 107 | Validate CIF report vs IUCr dictionaries          | 🟡 Med   | Test coverage                |
+| 108 | Smarter automatic bond detection (near-neighbour) | 🟢 Low   | UX / Visualization           |

From 632b4162d09c9b292222e6bc83d6b1935d6b1661 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:02:04 +0200
Subject: [PATCH 045/160] Prune bonds to first coordination shell

---
 .../display/structure/builder.py              | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 8081bc4bd..110d02df6 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -41,6 +41,11 @@
 IDENTITY_TOL = 1e-4
 EIGHT_PI_SQ = 8.0 * np.pi**2
 DEFAULT_BOND_INCR = 0.25
+# Prune bonds to the first coordination shell: keep a contact only if it is
+# within this multiple of the nearer atom's nearest-neighbour distance. Stops
+# large ionic-cation covalent radii (e.g. La/Ba) from bonding to every anion
+# (see open issue #108 for the full near-neighbour approach).
+COORDINATION_SHELL_FACTOR = 1.3
 ALL_FEATURES = ('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels')
 
 
@@ -220,14 +225,23 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
 
 
 def _build_bonds(scene_atoms, geom_min: float, geom_incr: float):
-    """Detect bonds between in-scene atoms via the cif_core _geom rule."""
+    """Detect bonds via the cif_core _geom rule, pruned to the first shell."""
     bonds = []
+    count = len(scene_atoms)
+    if count < 2:
+        return bonds
     radii = [radius_for(a.element, 'covalent')[0] for a in scene_atoms]
+    centres = np.array([a.centre for a in scene_atoms], dtype=float)
+    distances = np.linalg.norm(centres[:, None, :] - centres[None, :, :], axis=2)
+    np.fill_diagonal(distances, np.inf)
+    nearest = distances.min(axis=1)
     for i, atom_i in enumerate(scene_atoms):
-        for j in range(i + 1, len(scene_atoms)):
+        for j in range(i + 1, count):
             atom_j = scene_atoms[j]
-            distance = float(np.linalg.norm(atom_i.centre - atom_j.centre))
-            if geom_min <= distance <= radii[i] + radii[j] + geom_incr:
+            distance = float(distances[i, j])
+            shell = min(nearest[i], nearest[j]) * COORDINATION_SHELL_FACTOR
+            covalent_cutoff = radii[i] + radii[j] + geom_incr
+            if geom_min <= distance <= min(covalent_cutoff, shell):
                 bonds.append(Bond(_vec3(atom_i.centre), _vec3(atom_j.centre),
                                   atom_i.colour, atom_j.colour))
     return bonds

From 1567d05881f936289ae730625f726ea316d2ba72 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:02:04 +0200
Subject: [PATCH 046/160] Reduce default zoom ~20% and left-align legend text

---
 .../display/structure/templates/structure.html.j2      | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 76919a044..8ca9438ac 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -31,7 +31,7 @@
   #{{ container_id }} .mb.lt { font: 700 15px/1 Georgia, 'Times New Roman', serif; }
   #{{ container_id }} .mb.tog { color: #b9bdc6; }
   #{{ container_id }} .mb.tog.on { color: #2a3f5f; background: #e7ecf5; border-color: #c6d0e2; }
-  #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; }
+  #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; text-align: left; }
   #{{ container_id }} .cv-legend .sw {
     display: inline-block; width: 11px; height: 11px; border-radius: 50%;
     margin-right: 7px; vertical-align: middle; border: 1px solid rgba(0, 0, 0, 0.18);
@@ -226,7 +226,7 @@ const target = box.getBoundingSphere(new THREE.Sphere()).center;
 const radius = Math.max(box.getBoundingSphere(new THREE.Sphere()).radius, 1);
 const aspect = width / height;
 const far = radius * 100;
-const distance = radius * 2.0;
+const distance = radius * 2.4;
 
 // Trimetric default view: c-axis up, tilted above the ab-plane and rotated
 // in azimuth so all three axes read distinctly. Falls back to a fixed angle
@@ -247,7 +247,7 @@ if (cellBasis.length === 3) {
 const home = target.clone().add(viewDir.multiplyScalar(distance));
 
 const perspective = new THREE.PerspectiveCamera(45, aspect, radius * 0.01, far);
-const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.05, radius * aspect * 1.05, radius * 1.05, -radius * 1.05, -far, far);
+const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.26, radius * aspect * 1.26, radius * 1.26, -radius * 1.26, -far, far);
 perspective.up.copy(viewUp);
 ortho.up.copy(viewUp);
 perspective.position.copy(home);
@@ -404,8 +404,8 @@ const resize = () => {
   const ratio = width / height;
   perspective.aspect = ratio;
   perspective.updateProjectionMatrix();
-  ortho.left = -radius * ratio * 1.05;
-  ortho.right = radius * ratio * 1.05;
+  ortho.left = -radius * ratio * 1.26;
+  ortho.right = radius * ratio * 1.26;
   ortho.updateProjectionMatrix();
   renderer.setSize(width, height);
   labelRenderer.setSize(width, height);

From f1250c282425e242bbf37cdf2e1ccd829b937cd5 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:03:46 +0200
Subject: [PATCH 047/160] Document first-shell bond prune in ADR, plan, and
 issues

---
 .../crysview-structure-visualization.md       |  7 +++-
 docs/dev/issues/open.md                       | 34 ++++++++++---------
 .../plans/crysview-structure-visualization.md |  6 +++-
 3 files changed, 29 insertions(+), 18 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index a7c574f89..113610f94 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -319,7 +319,12 @@ bond is drawn between two sites when their distance `d` satisfies
 `_geom.min_bond_distance_cutoff ≤ d ≤ r_bond(i) + r_bond(j) + _geom.bond_distance_incr`,
 where the per-type bonding radius `r_bond` is `_atom_type.radius_bond`
 when the structure carries it, otherwise the element's covalent radius
-from the bundled database. These two cutoffs live on the **structure**
+from the bundled database. Matches are then pruned to the first
+coordination shell — a contact is kept only when it is within `1.3×` the
+nearer atom's nearest-neighbour distance — so the large covalent radii of
+ionic A-site cations do not bond to every surrounding anion (a heuristic
+stop-gap; see open issue #108 for the full near-neighbour approach). These
+two cutoffs live on the **structure**
 and persist in the structure's own CIF (see section 8), not in
 `project.style`. The display `radius_model` (vdw / covalent / ionic /
 atomic) changes only the rendered sphere _size_ — it never decides which
diff --git a/docs/dev/issues/open.md b/docs/dev/issues/open.md
index d355f1dc8..afead8846 100644
--- a/docs/dev/issues/open.md
+++ b/docs/dev/issues/open.md
@@ -1795,22 +1795,24 @@ Requirements:
 **Type:** UX / Visualization
 
 crysview generates bonds with the cif_core distance rule
-(`min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + bond_distance_incr`).
-It is deterministic and dependency-free, but a single global increment
-cannot separate coordination shells: dense structures (e.g. the LBCO
-perovskite, where the Co–O octahedron and the longer La/Ba–O cation
-contacts both fall in range) render a busy bond mesh. The default
-`bond_distance_incr` was lowered to `0.25 Å` to favour the primary
-coordination shell, but this remains a blunt instrument.
-
-**Fix:** consider an optional near-neighbour algorithm for automatic
-"reasonable" bonding — e.g. a Voronoi / solid-angle method such as
-pymatgen's `CrystalNN` or `VoronoiNN`, or an ASE/Jmol-style
-multiplicative covalent tolerance `d ≤ (r_A + r_B)·f`. The Voronoi route
-is the most robust across arbitrary structures but introduces a
-heavyweight dependency (pymatgen), so it needs a dependency decision; the
-multiplicative tolerance is lighter but deviates from the cif_core
-additive `_geom` model crysview currently follows.
+(`min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + bond_distance_incr`),
+then prunes to the first coordination shell — a contact survives only if
+it is within `1.3×` the nearer atom's nearest-neighbour distance
+(`COORDINATION_SHELL_FACTOR` in `display/structure/builder.py`). This
+stop-gap handles the common cases (e.g. LBCO renders just the Co–O
+octahedron) without a new dependency, but the fixed factor is still a
+heuristic: it can over-prune strongly distorted shells (e.g. elongated
+Jahn–Teller octahedra) or under-prune others, and it is not yet
+user-configurable.
+
+**Fix:** consider a robust, configurable near-neighbour algorithm for
+automatic "reasonable" bonding — e.g. a Voronoi / solid-angle method such
+as pymatgen's `CrystalNN` or `VoronoiNN`, which weights neighbours by
+solid angle instead of a single relative cutoff. The Voronoi route is the
+most robust across arbitrary structures but introduces a heavyweight
+dependency (pymatgen), so it needs a dependency decision; an ASE/Jmol-style
+multiplicative covalent tolerance is lighter but, like the current factor,
+cannot separate shells when ionic-cation covalent radii are large.
 
 **Depends on:** dependency decision for pymatgen (if the Voronoi route is
 chosen).
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 247abeca6..1eaafa55a 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -596,7 +596,11 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
       `geom.min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + geom.bond_distance_incr`,
       where `r_bond` is `_atom_type.radius_bond` when the structure
       carries it, else the element's covalent radius from the bundled DB
-      (P1.4). Split-coloured at midpoint; only atoms already in the
+      (P1.4). Matches are then pruned to the first coordination shell
+      (kept only within `1.3×` the nearer atom's nearest-neighbour
+      distance, `COORDINATION_SHELL_FACTOR`) so large ionic-cation
+      covalent radii do not over-bond — a heuristic stop-gap, see open
+      issue #108. Split-coloured at midpoint; only atoms already in the
       scene (no out-of-range partners, see Open Questions). The builder
       reads the cutoffs from `structure.geom`, like cell/atom data —
       they are not styling and are independent of the display

From 1bf985bbc2a2c9d93455cec21d4d4a6ebc2d07f6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:08:03 +0200
Subject: [PATCH 048/160] Write rendering_structure and style sections to
 project.cif

---
 src/easydiffraction/io/cif/serialize.py                 | 2 +-
 tests/unit/easydiffraction/project/test_project_load.py | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/easydiffraction/io/cif/serialize.py b/src/easydiffraction/io/cif/serialize.py
index ec9f3c792..189875109 100644
--- a/src/easydiffraction/io/cif/serialize.py
+++ b/src/easydiffraction/io/cif/serialize.py
@@ -575,7 +575,7 @@ def project_config_to_cif(project: object) -> str:
     if publication is not None:
         sections.append(category_owner_to_cif(publication))
 
-    for attr_name in ('rendering_table', 'verbosity'):
+    for attr_name in ('rendering_table', 'rendering_structure', 'style', 'verbosity'):
         section = getattr(project, attr_name, None)
         if section is not None:
             sections.append(_as_cif_text(section))
diff --git a/tests/unit/easydiffraction/project/test_project_load.py b/tests/unit/easydiffraction/project/test_project_load.py
index 6747d55c8..4cc7c68d3 100644
--- a/tests/unit/easydiffraction/project/test_project_load.py
+++ b/tests/unit/easydiffraction/project/test_project_load.py
@@ -85,12 +85,16 @@ def test_round_trips_display_engine_configuration(self, tmp_path):
         original = Project(name='d1')
         original.rendering_plot.type = 'asciichartpy'
         original.rendering_table.type = 'rich'
+        original.rendering_structure.type = 'ascii'
+        original.style.atom_shape = 'ball'
         original.save_as(str(tmp_path / 'proj'))
 
         loaded = Project.load(str(tmp_path / 'proj'))
 
         assert loaded.rendering_plot.type == 'asciichartpy'
         assert loaded.rendering_table.type == 'rich'
+        assert loaded.rendering_structure.type == 'ascii'
+        assert loaded.style.atom_shape.value == 'ball'
 
     def test_round_trips_constraints(self, tmp_path):
         original = Project(name='c1')

From 266c0133108ef171fd354e6c13caa4f57c6d0974 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:20:36 +0200
Subject: [PATCH 049/160] Add TikZ structure figure to TeX/PDF reports

---
 .../display/structure/renderers/__init__.py   |   1 +
 .../display/structure/renderers/tikz.py       | 211 ++++++++++++++++++
 .../report/templates/tex/report.tex.j2        |   9 +
 src/easydiffraction/report/tex_renderer.py    |  59 +++++
 .../report/test_tex_renderer.py               |  29 +++
 5 files changed, 309 insertions(+)
 create mode 100644 src/easydiffraction/display/structure/renderers/tikz.py

diff --git a/src/easydiffraction/display/structure/renderers/__init__.py b/src/easydiffraction/display/structure/renderers/__init__.py
index a9541d15e..5854e349a 100644
--- a/src/easydiffraction/display/structure/renderers/__init__.py
+++ b/src/easydiffraction/display/structure/renderers/__init__.py
@@ -7,3 +7,4 @@
 from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
 from easydiffraction.display.structure.renderers.base import StructureRendererBase
 from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
+from easydiffraction.display.structure.renderers.tikz import TikzStructureRenderer
diff --git a/src/easydiffraction/display/structure/renderers/tikz.py b/src/easydiffraction/display/structure/renderers/tikz.py
new file mode 100644
index 000000000..148dcfee9
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/tikz.py
@@ -0,0 +1,211 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""TikZ renderer: a static, vector 2D structure figure for LaTeX/PDF reports."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.scene import StructureScene
+
+_FIGURE_SIZE_CM = 6.0
+_BOND_RADIUS = 0.06  # matches the Three.js bond cylinder radius (angstrom)
+_PREAMBLE = (
+    '\\documentclass[border=2pt]{standalone}\n'
+    '\\usepackage{tikz}\n'
+    '\\usetikzlibrary{shadings,arrows.meta}\n'
+    '\\begin{document}\n'
+)
+
+
+def _rgb(colour: tuple[int, int, int]) -> str:
+    """Return an inline xcolor expression for an RGB triple."""
+    return f'{{rgb,255:red,{colour[0]};green,{colour[1]};blue,{colour[2]}}}'
+
+
+def _unit(vector: np.ndarray) -> np.ndarray:
+    """Return the unit vector, or the input when it has no length."""
+    length = float(np.linalg.norm(vector))
+    return vector / length if length > 1e-9 else vector
+
+
+def _view_basis(scene: StructureScene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return (view_dir, right, up) for a trimetric, c-axis-up projection."""
+    if scene.axes is not None:
+        a_hat = _unit(np.asarray(scene.axes.axes[0].vector, dtype=float))
+        b_hat = _unit(np.asarray(scene.axes.axes[1].vector, dtype=float))
+        c_hat = _unit(np.asarray(scene.axes.axes[2].vector, dtype=float))
+        view_up = c_hat
+        view_dir = _unit(1.0 * a_hat + 0.45 * b_hat + 0.55 * c_hat)
+    else:
+        view_up = np.array([0.0, 1.0, 0.0])
+        view_dir = _unit(np.array([1.0, 0.8, 1.5]))
+    right = _unit(np.cross(view_up, view_dir))
+    up = _unit(np.cross(view_dir, right))
+    return view_dir, right, up
+
+
+def _scene_points(scene: StructureScene) -> np.ndarray:
+    """Return all 3D anchor points used to centre and scale the figure."""
+    points: list[tuple[float, float, float]] = []
+    points.extend(a.centre for a in scene.atoms)
+    points.extend(s.centre for s in scene.occupancy_spheres)
+    points.extend(e.centre for e in scene.ellipsoids)
+    if scene.cell_edges is not None:
+        for edge in scene.cell_edges.edges:
+            points.append(edge.start)
+            points.append(edge.end)
+    if scene.axes is not None:
+        origin = np.asarray(scene.axes.origin, dtype=float)
+        points.append(scene.axes.origin)
+        for arrow in scene.axes.axes:
+            points.append(tuple(origin + np.asarray(arrow.vector, dtype=float)))
+    return np.array(points, dtype=float) if points else np.zeros((1, 3))
+
+
+class TikzStructureRenderer(StructureRendererBase):
+    """Render a structure scene as a standalone TikZ/LaTeX document."""
+
+    SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes'})
+
+    def supported_features(self) -> frozenset[str]:
+        """Return the features the TikZ engine can draw."""
+        return self.SUPPORTED
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        """
+        Render the scene as a standalone TikZ document.
+
+        Parameters
+        ----------
+        scene : StructureScene
+            The renderer-neutral primitives to draw.
+        features : frozenset[str]
+            The content-resolved feature set; ``atoms``/``bonds``/``cell``/
+            ``axes`` are drawn, others (moments, labels) are skipped.
+
+        Returns
+        -------
+        str
+            A complete ``standalone`` LaTeX document with one tikzpicture.
+        """
+        view_dir, right, up = _view_basis(scene)
+        points = _scene_points(scene)
+        target = points.mean(axis=0)
+
+        def project(point: object) -> tuple[float, float, float]:
+            rel = np.asarray(point, dtype=float) - target
+            return float(rel @ right), float(rel @ up), float(rel @ view_dir)
+
+        scale = self._scale(points, right, up, target)
+        bond_width = 2.0 * _BOND_RADIUS * scale
+        drawables: list[tuple[float, str]] = []
+        if 'cell' in features:
+            drawables.extend(self._cell_commands(scene, project))
+        if 'axes' in features:
+            drawables.extend(self._axis_commands(scene, project))
+        if 'bonds' in features:
+            drawables.extend(self._bond_commands(scene, project, bond_width))
+        if 'atoms' in features:
+            drawables.extend(self._atom_commands(scene, project))
+
+        drawables.sort(key=lambda item: item[0])
+        body = '\n'.join(command for _depth, command in drawables)
+        return (
+            f'{_PREAMBLE}'
+            f'\\begin{{tikzpicture}}[scale={scale:.4f}]\n'
+            f'{body}\n'
+            f'\\end{{tikzpicture}}\n'
+            f'\\end{{document}}\n'
+        )
+
+    @staticmethod
+    def _scale(points: np.ndarray, right: np.ndarray, up: np.ndarray, target: np.ndarray) -> float:
+        """Return a tikzpicture scale that fits the figure to a fixed size."""
+        rel = points - target
+        projected = np.column_stack((rel @ right, rel @ up))
+        extent = float((projected.max(axis=0) - projected.min(axis=0)).max())
+        return _FIGURE_SIZE_CM / extent if extent > 1e-6 else 1.0
+
+    @staticmethod
+    def _cell_commands(scene, project) -> list[tuple[float, str]]:
+        commands = []
+        if scene.cell_edges is None:
+            return commands
+        for edge in scene.cell_edges.edges:
+            x1, y1, d1 = project(edge.start)
+            x2, y2, d2 = project(edge.end)
+            commands.append((
+                (d1 + d2) / 2,
+                f'\\draw[line width=0.4pt,black!55] ({x1:.4f},{y1:.4f}) -- ({x2:.4f},{y2:.4f});',
+            ))
+        return commands
+
+    @staticmethod
+    def _axis_commands(scene, project) -> list[tuple[float, str]]:
+        commands = []
+        if scene.axes is None:
+            return commands
+        origin = np.asarray(scene.axes.origin, dtype=float)
+        ox, oy, _od = project(scene.axes.origin)
+        for arrow in scene.axes.axes:
+            colour = _rgb(arrow.colour)
+            tip = tuple(origin + np.asarray(arrow.vector, dtype=float))
+            tx, ty, td = project(tip)
+            commands.append((
+                td,
+                f'\\draw[-{{Stealth[length=2.4mm]}},line width=1pt,color={colour}] '
+                f'({ox:.4f},{oy:.4f}) -- ({tx:.4f},{ty:.4f});',
+            ))
+            lx = ox + (tx - ox) * 1.1
+            ly = oy + (ty - oy) * 1.1
+            commands.append((
+                td,
+                f'\\node[color={colour},font=\\bfseries] at ({lx:.4f},{ly:.4f}) {{{arrow.letter}}};',
+            ))
+        return commands
+
+    @staticmethod
+    def _bond_commands(scene, project, bond_width: float) -> list[tuple[float, str]]:
+        commands = []
+        for bond in scene.bonds:
+            sx, sy, sd = project(bond.start)
+            ex, ey, ed = project(bond.end)
+            mx, my = (sx + ex) / 2, (sy + ey) / 2
+            depth = (sd + ed) / 2
+            for x0, y0, x1, y1, colour in (
+                (sx, sy, mx, my, bond.start_colour),
+                (mx, my, ex, ey, bond.end_colour),
+            ):
+                commands.append((
+                    depth,
+                    f'\\draw[line width={bond_width:.4f}cm,line cap=round,color={_rgb(colour)}] '
+                    f'({x0:.4f},{y0:.4f}) -- ({x1:.4f},{y1:.4f});',
+                ))
+        return commands
+
+    @staticmethod
+    def _atom_commands(scene, project) -> list[tuple[float, str]]:
+        commands = []
+        for atom in scene.atoms:
+            x, y, depth = project(atom.centre)
+            commands.append((
+                depth,
+                f'\\shade[ball color={_rgb(atom.colour)}] ({x:.4f},{y:.4f}) circle ({atom.radius:.4f});',
+            ))
+        for sphere in scene.occupancy_spheres:
+            x, y, depth = project(sphere.centre)
+            colour = sphere.wedges[0].colour if sphere.wedges else (128, 128, 128)
+            commands.append((
+                depth,
+                f'\\shade[ball color={_rgb(colour)}] ({x:.4f},{y:.4f}) circle ({sphere.radius:.4f});',
+            ))
+        for ellipsoid in scene.ellipsoids:
+            x, y, depth = project(ellipsoid.centre)
+            radius = max(ellipsoid.semi_axes)
+            commands.append((
+                depth,
+                f'\\shade[ball color={_rgb(ellipsoid.colour)}] ({x:.4f},{y:.4f}) circle ({radius:.4f});',
+            ))
+        return commands
diff --git a/src/easydiffraction/report/templates/tex/report.tex.j2 b/src/easydiffraction/report/templates/tex/report.tex.j2
index 7e0c997d6..52cfc78d0 100644
--- a/src/easydiffraction/report/templates/tex/report.tex.j2
+++ b/src/easydiffraction/report/templates/tex/report.tex.j2
@@ -194,6 +194,15 @@ Minimizer & {{ tex_software_name(analysis.software.minimizer) }} & {{ analysis.s
 % --------------------------------------------------------------------
 \subsection{ {{- structure.id | tex -}} }
 
+{% if tex.structure_figure_paths[structure.id] %}
+\subsubsection*{Structure view}
+
+\begin{figure}[H]
+\centering
+\includegraphics[width=0.6\linewidth]{ {{- tex.structure_figure_paths[structure.id] -}} }
+\end{figure}
+{% endif %}
+
 {% for category in structure.categories %}
 \subsubsection*{ {{- category.title | tex -}} }
 
diff --git a/src/easydiffraction/report/tex_renderer.py b/src/easydiffraction/report/tex_renderer.py
index 9346b5b5b..6e1c50286 100644
--- a/src/easydiffraction/report/tex_renderer.py
+++ b/src/easydiffraction/report/tex_renderer.py
@@ -124,6 +124,7 @@ def render_tex_report(context: dict[str, object]) -> str:
         context,
         fit_csv_paths=_fit_csv_paths(context),
         fit_figure_paths=_fit_figure_paths(context),
+        structure_figure_paths=_structure_figure_paths(context),
     )
     return _environment().get_template(_TEMPLATE_NAME).render(**template_context)
 
@@ -159,10 +160,12 @@ def save_tex_report(
     template_context = dict(context)
     template_context['report_style'] = report_style_context()
     fit_asset_paths = _write_fit_assets(project, context, tex_dir)
+    structure_figure_paths = _write_structure_assets(project, context, tex_dir)
     template_context['tex'] = _tex_context(
         context,
         fit_csv_paths=fit_asset_paths['csv'],
         fit_figure_paths=fit_asset_paths['figure'],
+        structure_figure_paths=structure_figure_paths,
     )
     output_path.write_text(
         _render_prepared_context(template_context),
@@ -264,11 +267,13 @@ def _tex_context(
     *,
     fit_csv_paths: dict[str, str],
     fit_figure_paths: dict[str, str],
+    structure_figure_paths: dict[str, str],
 ) -> dict[str, object]:
     """Return TeX-specific render context."""
     return {
         'fit_csv_paths': fit_csv_paths,
         'fit_figure_paths': fit_figure_paths,
+        'structure_figure_paths': structure_figure_paths,
         'fit_bragg_tick_styles': fit_bragg_tick_styles(),
         'fit_plot_ranges': _fit_plot_ranges(context),
         'fit_plot_styles': fit_plot_styles(),
@@ -414,6 +419,60 @@ def _fit_figure_paths(context: dict[str, object]) -> dict[str, str]:
     return paths
 
 
+def _structure_asset_stem(struct_id: str) -> str:
+    """Return a filesystem-safe stem for a structure figure asset."""
+    return f'struct_{_safe_asset_stem(struct_id)}'
+
+
+def _structure_figure_paths(context: dict[str, object]) -> dict[str, str]:
+    """Return expected structure-figure PDF paths for TeX rendering."""
+    paths: dict[str, str] = {}
+    for structure in context.get('structures') or []:
+        if not isinstance(structure, dict):
+            continue
+        struct_id = str(structure.get('id') or 'structure')
+        paths[struct_id] = f'data/{_structure_asset_stem(struct_id)}.pdf'
+    return paths
+
+
+def _write_structure_assets(
+    project: object,
+    context: dict[str, object],
+    out_dir: pathlib.Path,
+) -> dict[str, str]:
+    """Write one standalone TikZ structure figure per structure."""
+    from easydiffraction.display.structure.builder import build_scene  # noqa: PLC0415
+    from easydiffraction.display.structure.builder import (  # noqa: PLC0415
+        structure_feature_availability,
+    )
+    from easydiffraction.display.structure.renderers.tikz import (  # noqa: PLC0415
+        TikzStructureRenderer,
+    )
+
+    del context
+    structures = getattr(project, 'structures', None)
+    values = getattr(structures, 'values', None)
+    if not callable(values):
+        return {}
+
+    renderer = TikzStructureRenderer()
+    window = project.rendering_structure.view_range()
+    style = project.style
+    data_dir = out_dir / 'data'
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    figure_paths: dict[str, str] = {}
+    for structure in values():
+        struct_id = str(getattr(structure, 'name', '') or 'structure')
+        availability = structure_feature_availability(structure, style=style)
+        features = project.display._resolve_structure_features('auto', availability)
+        scene = build_scene(structure, style=style, view_range=window, features=features)
+        figure_path = data_dir / f'{_structure_asset_stem(struct_id)}.tex'
+        figure_path.write_text(renderer.render(scene, features=features), encoding='utf-8')
+        figure_paths[struct_id] = f'data/{figure_path.stem}.pdf'
+    return figure_paths
+
+
 def _project_experiments_by_id(project: object) -> dict[str, object]:
     """Return project experiment objects keyed by datablock id."""
     experiments = getattr(project, 'experiments', None)
diff --git a/tests/unit/easydiffraction/report/test_tex_renderer.py b/tests/unit/easydiffraction/report/test_tex_renderer.py
index 41eedca56..68d251b71 100644
--- a/tests/unit/easydiffraction/report/test_tex_renderer.py
+++ b/tests/unit/easydiffraction/report/test_tex_renderer.py
@@ -459,3 +459,32 @@ def test_save_tex_report_removes_stale_managed_bundle_dirs(tmp_path):
     assert not (tex_dir / 'data').exists()
     assert not (tex_dir / 'figures').exists()
     assert not (tex_dir / 'styles').exists()
+
+
+def test_save_tex_report_writes_tikz_structure_figure(tmp_path):
+    import easydiffraction as ed
+
+    from easydiffraction.report.tex_renderer import save_tex_report
+
+    project = ed.Project(name='struct_fig')
+    project.structures.create(name='nacl')
+    structure = project.structures['nacl']
+    structure.cell.length_a = 5.64
+    structure.cell.length_b = 5.64
+    structure.cell.length_c = 5.64
+    structure.atom_sites.create(
+        label='Na', type_symbol='Na', fract_x=0, fract_y=0, fract_z=0, adp_iso=0.5, occupancy=1
+    )
+    structure.atom_sites.create(
+        label='Cl', type_symbol='Cl', fract_x=0.5, fract_y=0.5, fract_z=0.5, adp_iso=0.5, occupancy=1
+    )
+
+    tex_path = tmp_path / 'report.tex'
+    save_tex_report(project, project.report.data_context(), path=tex_path)
+
+    figure_path = tex_path.parent / 'data' / 'struct_nacl.tex'
+    assert figure_path.exists()
+    figure_text = figure_path.read_text(encoding='utf-8')
+    assert '\\begin{tikzpicture}' in figure_text
+    assert '\\shade[ball color' in figure_text
+    assert 'data/struct_nacl.pdf' in tex_path.read_text(encoding='utf-8')

From d0273b70ccfe8f8ad760d310ccbb3394d6b4e4ad Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:20:36 +0200
Subject: [PATCH 050/160] Document TikZ structure figure in ADR and user guide

---
 .../suggestions/crysview-structure-visualization.md    | 10 +++++++---
 docs/docs/user-guide/analysis-workflow/model.md        |  5 +++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 113610f94..518ebc632 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -102,11 +102,15 @@ logic. Renderer choice mirrors `project.rendering_plot.type`:
 - an ASCII renderer for terminal, CLI, and headless contexts;
 - a Three.js renderer for notebooks (embedded HTML/JS) and standalone
   HTML;
+- a TikZ renderer that emits a static, vector structure figure for the
+  TeX/PDF report — a 2D trimetric projection of the same scene, depth
+  sorted with ball-shaded atoms. It is **not** a user-selectable engine
+  (it is invoked by the report, like `pgfplots` is for the fit plot);
 - a Qt Quick 3D renderer for the GUI is planned.
 
-ASCII and Three.js are the initial engines, shipping together exactly as
-the `ascii` and `plotly` chart engines do; Qt Quick 3D follows for the
-GUI.
+ASCII and Three.js are the initial interactive engines, shipping together
+exactly as the `ascii` and `plotly` chart engines do; the TikZ renderer
+serves the TeX/PDF report, and Qt Quick 3D follows for the GUI.
 
 A switchable engine selector is added on the project owner, parallel to
 `project.rendering_plot` / `project.rendering_table`. It is named
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index b3139565f..8976891c3 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -237,8 +237,9 @@ project.display.structure(
 )
 ```
 
-The same interactive view is embedded automatically in the HTML report
-(see the [Report](report.md) section).
+The same view is embedded automatically in the generated reports — an
+interactive Three.js view in the HTML report and a static vector figure
+in the TeX/PDF report (see the [Report](report.md) section).
 
 ## Saving a Model
 

From b4be38c3a7f01e3455bddd9cdad7a1e40c9c6d09 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:36:59 +0200
Subject: [PATCH 051/160] Clip TikZ bonds to atom surfaces for correct
 occlusion

---
 .../display/structure/renderers/tikz.py       | 51 +++++++++++++++----
 1 file changed, 42 insertions(+), 9 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/tikz.py b/src/easydiffraction/display/structure/renderers/tikz.py
index 148dcfee9..b11e54526 100644
--- a/src/easydiffraction/display/structure/renderers/tikz.py
+++ b/src/easydiffraction/display/structure/renderers/tikz.py
@@ -64,6 +64,24 @@ def _scene_points(scene: StructureScene) -> np.ndarray:
     return np.array(points, dtype=float) if points else np.zeros((1, 3))
 
 
+def _key(point: object) -> tuple[float, float, float]:
+    """Return a rounded coordinate key for atom-radius lookup."""
+    p = np.asarray(point, dtype=float)
+    return (round(float(p[0]), 5), round(float(p[1]), 5), round(float(p[2]), 5))
+
+
+def _radius_lookup(scene: StructureScene) -> dict[tuple[float, float, float], float]:
+    """Map each atom centre to its drawn radius (for clipping bonds)."""
+    lookup: dict[tuple[float, float, float], float] = {}
+    for atom in scene.atoms:
+        lookup[_key(atom.centre)] = atom.radius
+    for sphere in scene.occupancy_spheres:
+        lookup[_key(sphere.centre)] = sphere.radius
+    for ellipsoid in scene.ellipsoids:
+        lookup[_key(ellipsoid.centre)] = max(ellipsoid.semi_axes)
+    return lookup
+
+
 class TikzStructureRenderer(StructureRendererBase):
     """Render a structure scene as a standalone TikZ/LaTeX document."""
 
@@ -106,7 +124,7 @@ def project(point: object) -> tuple[float, float, float]:
         if 'axes' in features:
             drawables.extend(self._axis_commands(scene, project))
         if 'bonds' in features:
-            drawables.extend(self._bond_commands(scene, project, bond_width))
+            drawables.extend(self._bond_commands(scene, project, bond_width, _radius_lookup(scene)))
         if 'atoms' in features:
             drawables.extend(self._atom_commands(scene, project))
 
@@ -167,16 +185,31 @@ def _axis_commands(scene, project) -> list[tuple[float, str]]:
         return commands
 
     @staticmethod
-    def _bond_commands(scene, project, bond_width: float) -> list[tuple[float, str]]:
+    def _bond_commands(scene, project, bond_width, radius_lookup) -> list[tuple[float, str]]:
         commands = []
         for bond in scene.bonds:
-            sx, sy, sd = project(bond.start)
-            ex, ey, ed = project(bond.end)
-            mx, my = (sx + ex) / 2, (sy + ey) / 2
-            depth = (sd + ed) / 2
-            for x0, y0, x1, y1, colour in (
-                (sx, sy, mx, my, bond.start_colour),
-                (mx, my, ex, ey, bond.end_colour),
+            start = np.asarray(bond.start, dtype=float)
+            end = np.asarray(bond.end, dtype=float)
+            segment = end - start
+            length = float(np.linalg.norm(segment))
+            if length < 1e-6:
+                continue
+            direction = segment / length
+            r_start = radius_lookup.get(_key(bond.start), 0.0)
+            r_end = radius_lookup.get(_key(bond.end), 0.0)
+            if r_start + r_end >= length:
+                continue
+            # Clip the stick to the two atom surfaces so it neither crosses
+            # an atom centre nor protrudes from a sphere it is hidden behind.
+            clipped_start = start + direction * r_start
+            clipped_end = end - direction * r_end
+            mid = (clipped_start + clipped_end) / 2.0
+            sx, sy, sd = project(clipped_start)
+            ex, ey, ed = project(clipped_end)
+            mx, my, md = project(mid)
+            for x0, y0, x1, y1, depth, colour in (
+                (sx, sy, mx, my, (sd + md) / 2, bond.start_colour),
+                (mx, my, ex, ey, (md + ed) / 2, bond.end_colour),
             ):
                 commands.append((
                     depth,

From 89839160be3695d60534c069b80ef28e331593fa Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 14:51:30 +0200
Subject: [PATCH 052/160] Depth-segment cell edges and overlay axis triad in
 TikZ figure

---
 .../display/structure/renderers/tikz.py       | 71 ++++++++++++++-----
 src/easydiffraction/report/tex_renderer.py    |  5 +-
 2 files changed, 59 insertions(+), 17 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/tikz.py b/src/easydiffraction/display/structure/renderers/tikz.py
index b11e54526..64e8b88fc 100644
--- a/src/easydiffraction/display/structure/renderers/tikz.py
+++ b/src/easydiffraction/display/structure/renderers/tikz.py
@@ -82,6 +82,31 @@ def _radius_lookup(scene: StructureScene) -> dict[tuple[float, float, float], fl
     return lookup
 
 
+def _segment_commands(
+    p0: object,
+    p1: object,
+    project,
+    style: str,
+    *,
+    segments: int = 12,
+    arrow_tip: str = '',
+) -> list[tuple[float, str]]:
+    """Split a line into depth-sorted sub-segments so atoms can occlude it."""
+    start = np.asarray(p0, dtype=float)
+    end = np.asarray(p1, dtype=float)
+    projected = [project(start + (end - start) * (i / segments)) for i in range(segments + 1)]
+    commands = []
+    for index in range(segments):
+        x0, y0, d0 = projected[index]
+        x1, y1, d1 = projected[index + 1]
+        tip = arrow_tip if index == segments - 1 else ''
+        commands.append((
+            (d0 + d1) / 2,
+            f'\\draw[{tip}{style}] ({x0:.4f},{y0:.4f}) -- ({x1:.4f},{y1:.4f});',
+        ))
+    return commands
+
+
 class TikzStructureRenderer(StructureRendererBase):
     """Render a structure scene as a standalone TikZ/LaTeX document."""
 
@@ -91,7 +116,13 @@ def supported_features(self) -> frozenset[str]:
         """Return the features the TikZ engine can draw."""
         return self.SUPPORTED
 
-    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+    def render(
+        self,
+        scene: StructureScene,
+        *,
+        features: frozenset[str],
+        axes_on_top: bool = False,
+    ) -> str:
         """
         Render the scene as a standalone TikZ document.
 
@@ -102,6 +133,10 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         features : frozenset[str]
             The content-resolved feature set; ``atoms``/``bonds``/``cell``/
             ``axes`` are drawn, others (moments, labels) are skipped.
+        axes_on_top : bool
+            When ``False`` (default), the axis shafts are depth-segmented so
+            atoms occlude them. When ``True``, the axis triad is drawn as an
+            always-visible reference overlay.
 
         Returns
         -------
@@ -122,7 +157,7 @@ def project(point: object) -> tuple[float, float, float]:
         if 'cell' in features:
             drawables.extend(self._cell_commands(scene, project))
         if 'axes' in features:
-            drawables.extend(self._axis_commands(scene, project))
+            drawables.extend(self._axis_commands(scene, project, on_top=axes_on_top))
         if 'bonds' in features:
             drawables.extend(self._bond_commands(scene, project, bond_width, _radius_lookup(scene)))
         if 'atoms' in features:
@@ -152,34 +187,38 @@ def _cell_commands(scene, project) -> list[tuple[float, str]]:
         if scene.cell_edges is None:
             return commands
         for edge in scene.cell_edges.edges:
-            x1, y1, d1 = project(edge.start)
-            x2, y2, d2 = project(edge.end)
-            commands.append((
-                (d1 + d2) / 2,
-                f'\\draw[line width=0.4pt,black!55] ({x1:.4f},{y1:.4f}) -- ({x2:.4f},{y2:.4f});',
-            ))
+            commands.extend(
+                _segment_commands(edge.start, edge.end, project, 'line width=0.4pt,black!55')
+            )
         return commands
 
     @staticmethod
-    def _axis_commands(scene, project) -> list[tuple[float, str]]:
+    def _axis_commands(scene, project, *, on_top: bool) -> list[tuple[float, str]]:
         commands = []
         if scene.axes is None:
             return commands
         origin = np.asarray(scene.axes.origin, dtype=float)
         ox, oy, _od = project(scene.axes.origin)
+        arrow_tip = '-{Stealth[length=2.4mm]},'
         for arrow in scene.axes.axes:
             colour = _rgb(arrow.colour)
+            style = f'line width=1pt,color={colour}'
             tip = tuple(origin + np.asarray(arrow.vector, dtype=float))
-            tx, ty, td = project(tip)
-            commands.append((
-                td,
-                f'\\draw[-{{Stealth[length=2.4mm]}},line width=1pt,color={colour}] '
-                f'({ox:.4f},{oy:.4f}) -- ({tx:.4f},{ty:.4f});',
-            ))
+            tx, ty, _td = project(tip)
+            if on_top:
+                commands.append((
+                    float('inf'),
+                    f'\\draw[{arrow_tip}{style}] ({ox:.4f},{oy:.4f}) -- ({tx:.4f},{ty:.4f});',
+                ))
+            else:
+                commands.extend(
+                    _segment_commands(scene.axes.origin, tip, project, style, arrow_tip=arrow_tip)
+                )
+            # The letter always stays on top so the reference label is legible.
             lx = ox + (tx - ox) * 1.1
             ly = oy + (ty - oy) * 1.1
             commands.append((
-                td,
+                float('inf'),
                 f'\\node[color={colour},font=\\bfseries] at ({lx:.4f},{ly:.4f}) {{{arrow.letter}}};',
             ))
         return commands
diff --git a/src/easydiffraction/report/tex_renderer.py b/src/easydiffraction/report/tex_renderer.py
index 6e1c50286..13896a029 100644
--- a/src/easydiffraction/report/tex_renderer.py
+++ b/src/easydiffraction/report/tex_renderer.py
@@ -468,7 +468,10 @@ def _write_structure_assets(
         features = project.display._resolve_structure_features('auto', availability)
         scene = build_scene(structure, style=style, view_range=window, features=features)
         figure_path = data_dir / f'{_structure_asset_stem(struct_id)}.tex'
-        figure_path.write_text(renderer.render(scene, features=features), encoding='utf-8')
+        figure_path.write_text(
+            renderer.render(scene, features=features, axes_on_top=True),
+            encoding='utf-8',
+        )
         figure_paths[struct_id] = f'data/{figure_path.stem}.pdf'
     return figure_paths
 

From 2aa24aaf38ff0d76f6dd1e8a16ed040ced8bde12 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 15:00:19 +0200
Subject: [PATCH 053/160] Use depth-occluded axes in TeX structure figure

---
 src/easydiffraction/report/tex_renderer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/easydiffraction/report/tex_renderer.py b/src/easydiffraction/report/tex_renderer.py
index 13896a029..445d87d2f 100644
--- a/src/easydiffraction/report/tex_renderer.py
+++ b/src/easydiffraction/report/tex_renderer.py
@@ -469,7 +469,7 @@ def _write_structure_assets(
         scene = build_scene(structure, style=style, view_range=window, features=features)
         figure_path = data_dir / f'{_structure_asset_stem(struct_id)}.tex'
         figure_path.write_text(
-            renderer.render(scene, features=features, axes_on_top=True),
+            renderer.render(scene, features=features, axes_on_top=False),
             encoding='utf-8',
         )
         figure_paths[struct_id] = f'data/{figure_path.stem}.pdf'

From 42113e7bffc31c28838420cbd63a9d07aaaf7202 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 17:23:01 +0200
Subject: [PATCH 054/160] Replace TikZ structure figures with raster PNG

---
 .../crysview-structure-visualization.md       |  14 +-
 .../user-guide/analysis-workflow/model.md     |   4 +-
 pixi.lock                                     |   1 +
 pyproject.toml                                |   1 +
 .../display/structure/builder.py              |  12 +
 .../display/structure/renderers/__init__.py   |   2 +-
 .../display/structure/renderers/raster.py     | 379 ++++++++++++++++++
 .../display/structure/renderers/threejs.py    |   1 +
 .../display/structure/renderers/tikz.py       | 283 -------------
 .../display/structure/scene.py                |   9 +
 .../structure/templates/structure.html.j2     |  29 +-
 src/easydiffraction/report/tex_renderer.py    |  21 +-
 .../report/test_tex_renderer.py               |  10 +-
 13 files changed, 431 insertions(+), 335 deletions(-)
 create mode 100644 src/easydiffraction/display/structure/renderers/raster.py
 delete mode 100644 src/easydiffraction/display/structure/renderers/tikz.py

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 518ebc632..89766acc1 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -102,14 +102,18 @@ logic. Renderer choice mirrors `project.rendering_plot.type`:
 - an ASCII renderer for terminal, CLI, and headless contexts;
 - a Three.js renderer for notebooks (embedded HTML/JS) and standalone
   HTML;
-- a TikZ renderer that emits a static, vector structure figure for the
-  TeX/PDF report — a 2D trimetric projection of the same scene, depth
-  sorted with ball-shaded atoms. It is **not** a user-selectable engine
-  (it is invoked by the report, like `pgfplots` is for the fit plot);
+- a raster renderer that emits a static, z-buffered PNG image for the
+  TeX/PDF report — a trimetric projection of the same scene with a
+  per-pixel depth buffer, so hidden-surface removal is exact (atoms,
+  bonds, cell edges, and axes all occlude correctly). It is **not** a
+  user-selectable engine (it is invoked by the report, like `pgfplots`
+  is for the fit plot). The z-buffer rasterisation is plain numpy; it
+  uses `Pillow` to draw the a/b/c axis labels and the element legend
+  and to encode the PNG;
 - a Qt Quick 3D renderer for the GUI is planned.
 
 ASCII and Three.js are the initial interactive engines, shipping together
-exactly as the `ascii` and `plotly` chart engines do; the TikZ renderer
+exactly as the `ascii` and `plotly` chart engines do; the raster renderer
 serves the TeX/PDF report, and Qt Quick 3D follows for the GUI.
 
 A switchable engine selector is added on the project owner, parallel to
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 8976891c3..6649dcfb8 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -238,8 +238,8 @@ project.display.structure(
 ```
 
 The same view is embedded automatically in the generated reports — an
-interactive Three.js view in the HTML report and a static vector figure
-in the TeX/PDF report (see the [Report](report.md) section).
+interactive Three.js view in the HTML report and a static, depth-rendered
+image in the TeX/PDF report (see the [Report](report.md) section).
 
 ## Saving a Model
 
diff --git a/pixi.lock b/pixi.lock
index 64a94ef1b..96e17870c 100644
--- a/pixi.lock
+++ b/pixi.lock
@@ -8763,6 +8763,7 @@ packages:
   - lmfit
   - numpy
   - pandas
+  - pillow>=10.1
   - plotly
   - pooch
   - py3dmol
diff --git a/pyproject.toml b/pyproject.toml
index f069fac3c..c8d57b976 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -48,6 +48,7 @@ dependencies = [
   'pandas',         # Displaying tables in Jupyter notebooks
   'plotly',         # Interactive plots
   'py3Dmol',        # Visualisation of crystal structures
+  'pillow>=10.1',   # Rendering structure figures (labels, legend) for reports
 ]
 
 [project.optional-dependencies]
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 110d02df6..e82fd6661 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -32,6 +32,7 @@
 from easydiffraction.display.structure.scene import Bond
 from easydiffraction.display.structure.scene import CellEdge
 from easydiffraction.display.structure.scene import CellEdges
+from easydiffraction.display.structure.scene import LegendEntry
 from easydiffraction.display.structure.scene import OccupancyWedge
 from easydiffraction.display.structure.scene import OccupancyWedgeSphere
 from easydiffraction.display.structure.scene import StructureScene
@@ -271,6 +272,16 @@ def _axis_triad(matrix: np.ndarray) -> AxisTriad:
     return AxisTriad((0.0, 0.0, 0.0), (arrows[0], arrows[1], arrows[2]))
 
 
+def _legend(sites, style) -> tuple[LegendEntry, ...]:
+    """Return one colour swatch per distinct element, in first-seen order."""
+    entries: dict[str, tuple[int, int, int]] = {}
+    for atom in sites:
+        element = _element_symbol(atom.type_symbol.value)
+        if element not in entries:
+            entries[element] = color_for(element, style.color_scheme.value)
+    return tuple(LegendEntry(symbol, colour) for symbol, colour in entries.items())
+
+
 def build_scene(structure, *, style, view_range, features) -> StructureScene:
     """
     Build a renderer-neutral scene from a structure and resolved features.
@@ -328,6 +339,7 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
         axes=_axis_triad(matrix) if 'axes' in features else None,
         labels=tuple(TextLabel(_vec3(a.centre), a.label) for a in scene_atoms)
         if 'labels' in features else (),
+        legend=_legend(sites, style) if 'atoms' in features else (),
     )
 
 
diff --git a/src/easydiffraction/display/structure/renderers/__init__.py b/src/easydiffraction/display/structure/renderers/__init__.py
index 5854e349a..520e41d22 100644
--- a/src/easydiffraction/display/structure/renderers/__init__.py
+++ b/src/easydiffraction/display/structure/renderers/__init__.py
@@ -6,5 +6,5 @@
 
 from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
 from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.renderers.raster import RasterStructureRenderer
 from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
-from easydiffraction.display.structure.renderers.tikz import TikzStructureRenderer
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
new file mode 100644
index 000000000..103157b7b
--- /dev/null
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -0,0 +1,379 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Raster renderer: a z-buffered PNG structure image for reports.
+
+A tiny software rasteriser with a per-pixel depth buffer, so hidden-surface
+removal is exact for any structure. Spheres, bonds, cell edges, and axis
+arrows are all depth-tested against the same numpy buffer; Pillow then draws
+the a/b/c axis labels and the element legend on top and encodes the PNG.
+"""
+
+from __future__ import annotations
+
+import io
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from PIL import ImageFont
+
+_CANVAS = 1800
+_SUPERSAMPLE = 2
+_MARGIN_FRAC = 0.06
+_BOND_RADIUS = 0.06
+_AMBIENT = 0.55  # matches the Three.js AmbientLight intensity
+_LIGHT = np.array([0.42, 0.5, 0.75])  # (right, up, toward-camera)
+_LIGHT = _LIGHT / np.linalg.norm(_LIGHT)
+_FILL = np.array([-0.42, -0.25, -0.5])  # back-fill, mirrors the Three.js fill light
+_FILL = _FILL / np.linalg.norm(_FILL)
+_LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
+_LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
+# Axis-arrow proportions, as fractions of the arrow length (match the Three.js
+# buildArrow so the PDF and HTML axis triads look identical).
+_AXIS_SHAFT_RADIUS_FRAC = 0.012
+_AXIS_HEAD_RADIUS_FRAC = 0.048
+_AXIS_HEAD_LENGTH_FRAC = 0.12
+
+
+def _unit(vector: np.ndarray) -> np.ndarray:
+    """Return the unit vector, or the input when it has no length."""
+    length = float(np.linalg.norm(vector))
+    return vector / length if length > 1e-9 else vector
+
+
+def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return (view_dir, right, up) for a trimetric, c-axis-up projection."""
+    if scene.axes is not None:
+        a_hat = _unit(np.asarray(scene.axes.axes[0].vector, dtype=float))
+        b_hat = _unit(np.asarray(scene.axes.axes[1].vector, dtype=float))
+        c_hat = _unit(np.asarray(scene.axes.axes[2].vector, dtype=float))
+        view_up = c_hat
+        view_dir = _unit(1.0 * a_hat + 0.22 * b_hat + 0.33 * c_hat)
+    else:
+        view_up = np.array([0.0, 1.0, 0.0])
+        view_dir = _unit(np.array([1.0, 0.8, 1.5]))
+    right = _unit(np.cross(view_up, view_dir))
+    up = _unit(np.cross(view_dir, right))
+    return view_dir, right, up
+
+
+def _diffuse_intensity(normal: np.ndarray) -> np.ndarray:
+    """Lambertian key-plus-fill intensity for a unit surface-normal field."""
+    key = np.clip(normal @ _LIGHT, 0.0, 1.0)
+    fill = 0.4 * np.clip(normal @ _FILL, 0.0, 1.0)
+    return np.clip(_AMBIENT + (1.0 - _AMBIENT) * (key + fill), 0.0, 1.0)
+
+
+def _font(pixels: int) -> ImageFont.FreeTypeFont:
+    """Return the scalable default font at the requested pixel size."""
+    from PIL import ImageFont  # noqa: PLC0415
+
+    return ImageFont.load_default(size=pixels)
+
+
+def _scene_points(scene) -> np.ndarray:
+    """Return all 3D anchor points used to centre and scale the view."""
+    points: list[tuple[float, float, float]] = []
+    points.extend(a.centre for a in scene.atoms)
+    points.extend(s.centre for s in scene.occupancy_spheres)
+    points.extend(e.centre for e in scene.ellipsoids)
+    if scene.cell_edges is not None:
+        for edge in scene.cell_edges.edges:
+            points.append(edge.start)
+            points.append(edge.end)
+    if scene.axes is not None:
+        origin = np.asarray(scene.axes.origin, dtype=float)
+        points.append(scene.axes.origin)
+        for arrow in scene.axes.axes:
+            points.append(tuple(origin + np.asarray(arrow.vector, dtype=float)))
+    return np.array(points, dtype=float) if points else np.zeros((1, 3))
+
+
+def _max_radius(scene) -> float:
+    """Return the largest drawn atom radius (for view padding)."""
+    radii = [a.radius for a in scene.atoms]
+    radii += [s.radius for s in scene.occupancy_spheres]
+    radii += [max(e.semi_axes) for e in scene.ellipsoids]
+    return max(radii) if radii else 0.0
+
+
+class RasterStructureRenderer:
+    """Render a structure scene as a z-buffered PNG image."""
+
+    SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes'})
+
+    def render_png(self, scene, *, features: frozenset[str]) -> bytes:
+        """Return PNG bytes of the scene rendered with a per-pixel z-buffer."""
+        view_dir, right, up = _view_basis(scene)
+        points = _scene_points(scene)
+        target = points.mean(axis=0)
+
+        size = _CANVAS * _SUPERSAMPLE
+        relative = points - target
+        screen = np.column_stack((relative @ right, relative @ up))
+        pad = _max_radius(scene)
+        lo = screen.min(axis=0) - pad
+        hi = screen.max(axis=0) + pad
+        extent = float((hi - lo).max()) or 1.0
+        scale = (size * (1.0 - 2.0 * _MARGIN_FRAC)) / extent
+        centre2d = (lo + hi) / 2.0
+
+        def project(point: object) -> tuple[float, float, float]:
+            rel = np.asarray(point, dtype=float) - target
+            sx = (float(rel @ right) - centre2d[0]) * scale + size / 2.0
+            sy = size / 2.0 - (float(rel @ up) - centre2d[1]) * scale
+            return sx, sy, float(rel @ view_dir)
+
+        colour = np.ones((size, size, 3), dtype=np.float32)
+        depth = np.full((size, size), -np.inf, dtype=np.float32)
+
+        if 'cell' in features and scene.cell_edges is not None:
+            for edge in scene.cell_edges.edges:
+                self._capsule(colour, depth, project, scale, edge.start, edge.end,
+                              0.012, (90, 90, 90), (90, 90, 90))
+        if 'axes' in features and scene.axes is not None:
+            self._axes(colour, depth, project, (right, up, view_dir), scene.axes)
+        if 'bonds' in features:
+            for bond in scene.bonds:
+                self._capsule(colour, depth, project, scale, bond.start, bond.end,
+                              _BOND_RADIUS, bond.start_colour, bond.end_colour)
+        if 'atoms' in features:
+            for atom in scene.atoms:
+                self._sphere(colour, depth, project, scale, atom.centre, atom.radius, atom.colour)
+            for sphere in scene.occupancy_spheres:
+                self._sphere(colour, depth, project, scale, sphere.centre, sphere.radius,
+                             (128, 128, 128), wedges=sphere.wedges)
+            for ellipsoid in scene.ellipsoids:
+                self._sphere(colour, depth, project, scale, ellipsoid.centre,
+                             max(ellipsoid.semi_axes), ellipsoid.colour)
+
+        downsampled = (
+            colour.reshape(_CANVAS, _SUPERSAMPLE, _CANVAS, _SUPERSAMPLE, 3).mean(axis=(1, 3))
+        )
+        rgb = np.clip(downsampled * 255.0, 0, 255).astype(np.uint8)
+        return self._compose_png(rgb, scene, project, features)
+
+    @staticmethod
+    def _compose_png(rgb, scene, project, features) -> bytes:
+        """Draw axis labels and the legend with Pillow, then encode the PNG."""
+        from PIL import Image  # noqa: PLC0415
+        from PIL import ImageDraw  # noqa: PLC0415
+
+        image = Image.fromarray(rgb, mode='RGB')
+        draw = ImageDraw.Draw(image)
+        if 'axes' in features and scene.axes is not None:
+            RasterStructureRenderer._draw_axis_labels(draw, scene.axes, project)
+        if scene.legend:
+            RasterStructureRenderer._draw_legend(draw, scene.legend)
+        buffer = io.BytesIO()
+        image.save(buffer, format='PNG')
+        return buffer.getvalue()
+
+    @staticmethod
+    def _draw_axis_labels(draw, axes, project) -> None:
+        """Place each axis letter just beyond its arrow tip, always on top."""
+        font = _font(int(_CANVAS * _LABEL_FRAC))
+        inset = int(_CANVAS * 0.02)
+        origin = np.asarray(axes.origin, dtype=float)
+        ox, oy, _od = project(axes.origin)
+        for arrow in axes.axes:
+            tip = origin + np.asarray(arrow.vector, dtype=float)
+            tx, ty, _td = project(tuple(tip))
+            lx = float(np.clip((ox + (tx - ox) * 1.08) / _SUPERSAMPLE, inset, _CANVAS - inset))
+            ly = float(np.clip((oy + (ty - oy) * 1.08) / _SUPERSAMPLE, inset, _CANVAS - inset))
+            draw.text((lx, ly), arrow.letter, font=font, fill=tuple(arrow.colour), anchor='mm')
+
+    @staticmethod
+    def _draw_legend(draw, legend) -> None:
+        """Draw element colour swatches and symbols in a top-left panel."""
+        font = _font(int(_CANVAS * _LEGEND_FRAC))
+        margin = int(_CANVAS * 0.025)
+        pad = int(_CANVAS * 0.014)
+        radius = int(_CANVAS * 0.015)
+        pitch = int(_CANVAS * 0.048)
+        gap = int(_CANVAS * 0.012)
+        text_width = max((draw.textlength(e.symbol, font=font) for e in legend), default=0.0)
+        panel_width = 2 * pad + 2 * radius + gap + int(text_width)
+        panel_height = pad + len(legend) * pitch
+        draw.rounded_rectangle(
+            (margin, margin, margin + panel_width, margin + panel_height),
+            radius=int(_CANVAS * 0.01), fill=(255, 255, 255), outline=(170, 170, 170),
+            width=max(1, int(_CANVAS * 0.0015)),
+        )
+        for index, entry in enumerate(legend):
+            cx = margin + pad
+            cy = margin + pad + radius + index * pitch
+            draw.ellipse(
+                (cx, cy - radius, cx + 2 * radius, cy + radius),
+                fill=tuple(entry.colour), outline=(60, 60, 60), width=max(1, int(_CANVAS * 0.0012)),
+            )
+            draw.text((cx + 2 * radius + gap, cy), entry.symbol,
+                      font=font, fill=(40, 40, 40), anchor='lm')
+
+    @staticmethod
+    def _sphere(colour, depth, project, scale, centre, radius, base, *, wedges=None) -> None:
+        size = colour.shape[0]
+        cx, cy, cd = project(centre)
+        r_px = radius * scale
+        if r_px < 0.5:
+            return
+        x0, x1 = max(0, int(cx - r_px)), min(size, int(cx + r_px) + 1)
+        y0, y1 = max(0, int(cy - r_px)), min(size, int(cy + r_px) + 1)
+        if x0 >= x1 or y0 >= y1:
+            return
+        ys, xs = np.mgrid[y0:y1, x0:x1]
+        dx = (xs - cx) / r_px
+        dy = (ys - cy) / r_px
+        rho2 = dx * dx + dy * dy
+        inside = rho2 <= 1.0
+        if not inside.any():
+            return
+        nz = np.sqrt(np.clip(1.0 - rho2, 0.0, 1.0))
+        surf_depth = cd + nz * radius
+        sub = depth[y0:y1, x0:x1]
+        update = inside & (surf_depth > sub)
+        if not update.any():
+            return
+        # Matte (Lambertian) shading to match the Three.js MeshStandardMaterial:
+        # normal in (right, up, toward-camera) space; image y is down.
+        normal = np.stack((dx, -dy, nz), axis=-1)
+        intensity = _diffuse_intensity(normal)[..., None]
+        base_rgb = RasterStructureRenderer._base_colours(dx, dy, base, wedges)
+        shade = np.clip(base_rgb * intensity, 0, 1)
+        sub[update] = surf_depth[update]
+        colour[y0:y1, x0:x1][update] = shade[update]
+
+    @staticmethod
+    def _base_colours(dx, dy, base, wedges) -> np.ndarray:
+        """Per-pixel base colour: a flat tint, or azimuthal occupancy wedges."""
+        if not wedges:
+            flat = np.asarray(base, dtype=np.float32) / 255.0
+            return np.broadcast_to(flat, dx.shape + (3,))
+        # Pie slices by screen-space azimuth (image y is down, so negate dy).
+        angle = (np.arctan2(-dy, dx) / (2.0 * np.pi)) % 1.0
+        base_rgb = np.empty(dx.shape + (3,), dtype=np.float32)
+        lo = 0.0
+        for wedge in wedges:
+            mask = (angle >= lo) & (angle < lo + wedge.fraction)
+            base_rgb[mask] = np.asarray(wedge.colour, dtype=np.float32) / 255.0
+            lo += wedge.fraction
+        base_rgb[angle >= lo] = np.asarray(wedges[-1].colour, dtype=np.float32) / 255.0
+        return base_rgb
+
+    @staticmethod
+    def _capsule(colour, depth, project, scale, p0, p1, radius, colour0, colour1) -> None:
+        size = colour.shape[0]
+        ax, ay, ad = project(p0)
+        bx, by, bd = project(p1)
+        r_px = max(radius * scale, 0.6)
+        x0 = max(0, int(min(ax, bx) - r_px))
+        x1 = min(size, int(max(ax, bx) + r_px) + 1)
+        y0 = max(0, int(min(ay, by) - r_px))
+        y1 = min(size, int(max(ay, by) + r_px) + 1)
+        if x0 >= x1 or y0 >= y1:
+            return
+        ys, xs = np.mgrid[y0:y1, x0:x1]
+        seg = np.array([bx - ax, by - ay], dtype=float)
+        length2 = float(seg @ seg) or 1.0
+        t = np.clip(((xs - ax) * seg[0] + (ys - ay) * seg[1]) / length2, 0.0, 1.0)
+        proj_x = ax + t * seg[0]
+        proj_y = ay + t * seg[1]
+        dist = np.hypot(xs - proj_x, ys - proj_y)
+        inside = dist <= r_px
+        if not inside.any():
+            return
+        nz = np.sqrt(np.clip(1.0 - (dist / r_px) ** 2, 0.0, 1.0))
+        surf_depth = ad + t * (bd - ad) + nz * radius
+        sub = depth[y0:y1, x0:x1]
+        update = inside & (surf_depth > sub)
+        if not update.any():
+            return
+        # Directional cylinder shading: normal perpendicular to the projected
+        # axis (image y is down), with the bulge as the toward-camera component.
+        normal = np.stack(((xs - proj_x) / r_px, -(ys - proj_y) / r_px, nz), axis=-1)
+        intensity = _diffuse_intensity(normal)[..., None]
+        c0 = np.asarray(colour0, dtype=np.float32) / 255.0
+        c1 = np.asarray(colour1, dtype=np.float32) / 255.0
+        base = np.where((t < 0.5)[..., None], c0, c1)
+        shade = np.clip(base * intensity, 0, 1)
+        sub[update] = surf_depth[update]
+        colour[y0:y1, x0:x1][update] = shade[update]
+
+    @staticmethod
+    def _triangle(colour, depth, v0, v1, v2, shade) -> None:
+        """Z-test and fill one flat-shaded triangle from projected vertices."""
+        size = colour.shape[0]
+        (x0, y0, d0), (x1, y1, d1), (x2, y2, d2) = v0, v1, v2
+        min_x = max(0, int(min(x0, x1, x2)))
+        max_x = min(size, int(max(x0, x1, x2)) + 1)
+        min_y = max(0, int(min(y0, y1, y2)))
+        max_y = min(size, int(max(y0, y1, y2)) + 1)
+        if min_x >= max_x or min_y >= max_y:
+            return
+        denom = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2)
+        if abs(denom) < 1e-9:
+            return
+        ys, xs = np.mgrid[min_y:max_y, min_x:max_x]
+        w0 = ((y1 - y2) * (xs - x2) + (x2 - x1) * (ys - y2)) / denom
+        w1 = ((y2 - y0) * (xs - x2) + (x0 - x2) * (ys - y2)) / denom
+        w2 = 1.0 - w0 - w1
+        inside = (w0 >= 0.0) & (w1 >= 0.0) & (w2 >= 0.0)
+        if not inside.any():
+            return
+        tri_depth = w0 * d0 + w1 * d1 + w2 * d2
+        sub = depth[min_y:max_y, min_x:max_x]
+        update = inside & (tri_depth > sub)
+        if not update.any():
+            return
+        sub[update] = tri_depth[update]
+        colour[min_y:max_y, min_x:max_x][update] = shade
+
+    def _arrow(self, colour, depth, project, basis, origin, vector, rgb) -> None:
+        """Draw a shaft cylinder and head cone as 3D triangles (orientation-safe)."""
+        right, up, view_dir = basis
+        length = float(np.linalg.norm(vector))
+        if length < 1e-9:
+            return
+        axis = vector / length
+        ref = np.array([0.0, 0.0, 1.0]) if abs(axis[2]) < 0.9 else np.array([0.0, 1.0, 0.0])
+        u = _unit(np.cross(ref, axis))
+        v = np.cross(axis, u)
+        shaft_r = _AXIS_SHAFT_RADIUS_FRAC * length
+        head_r = _AXIS_HEAD_RADIUS_FRAC * length
+        base = origin + axis * (length - _AXIS_HEAD_LENGTH_FRAC * length)
+        tip = origin + vector
+        flat = np.asarray(rgb, dtype=np.float32) / 255.0
+
+        def shade_for(world_normal: np.ndarray) -> np.ndarray:
+            cam = np.array([world_normal @ right, world_normal @ up, world_normal @ view_dir])
+            return np.clip(flat * float(_diffuse_intensity(cam)), 0.0, 1.0)
+
+        segments = 32
+        ring = [np.cos(angle) * u + np.sin(angle) * v
+                for angle in (2.0 * np.pi * i / segments for i in range(segments))]
+        for i in range(segments):
+            d0 = ring[i]
+            d1 = ring[(i + 1) % segments]
+            shaft_shade = shade_for(_unit(d0 + d1))
+            o0 = project(tuple(origin + shaft_r * d0))
+            o1 = project(tuple(origin + shaft_r * d1))
+            s0 = project(tuple(base + shaft_r * d0))
+            s1 = project(tuple(base + shaft_r * d1))
+            self._triangle(colour, depth, o0, o1, s1, shaft_shade)
+            self._triangle(colour, depth, o0, s1, s0, shaft_shade)
+            b0 = base + head_r * d0
+            b1 = base + head_r * d1
+            normal = _unit(np.cross(b1 - b0, tip - b0))
+            if normal @ (d0 + d1) < 0.0:
+                normal = -normal
+            self._triangle(colour, depth, project(tuple(b0)), project(tuple(b1)),
+                           project(tuple(tip)), shade_for(normal))
+            self._triangle(colour, depth, project(tuple(base)), project(tuple(b1)),
+                           project(tuple(b0)), shade_for(-axis))
+
+    def _axes(self, colour, depth, project, basis, axes) -> None:
+        origin = np.asarray(axes.origin, dtype=float)
+        for arrow in axes.axes:
+            self._arrow(colour, depth, project, basis, origin,
+                        np.asarray(arrow.vector, dtype=float), arrow.colour)
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index aca2dc7db..4c6a86815 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -101,6 +101,7 @@ def _scene_payload(scene: StructureScene) -> dict:
         'cellEdges': edges,
         'axes': axes,
         'labels': [{'anchor': label.anchor, 'text': label.text} for label in scene.labels],
+        'legend': [{'symbol': entry.symbol, 'colour': entry.colour} for entry in scene.legend],
     }
 
 
diff --git a/src/easydiffraction/display/structure/renderers/tikz.py b/src/easydiffraction/display/structure/renderers/tikz.py
deleted file mode 100644
index 64e8b88fc..000000000
--- a/src/easydiffraction/display/structure/renderers/tikz.py
+++ /dev/null
@@ -1,283 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""TikZ renderer: a static, vector 2D structure figure for LaTeX/PDF reports."""
-
-from __future__ import annotations
-
-import numpy as np
-
-from easydiffraction.display.structure.renderers.base import StructureRendererBase
-from easydiffraction.display.structure.scene import StructureScene
-
-_FIGURE_SIZE_CM = 6.0
-_BOND_RADIUS = 0.06  # matches the Three.js bond cylinder radius (angstrom)
-_PREAMBLE = (
-    '\\documentclass[border=2pt]{standalone}\n'
-    '\\usepackage{tikz}\n'
-    '\\usetikzlibrary{shadings,arrows.meta}\n'
-    '\\begin{document}\n'
-)
-
-
-def _rgb(colour: tuple[int, int, int]) -> str:
-    """Return an inline xcolor expression for an RGB triple."""
-    return f'{{rgb,255:red,{colour[0]};green,{colour[1]};blue,{colour[2]}}}'
-
-
-def _unit(vector: np.ndarray) -> np.ndarray:
-    """Return the unit vector, or the input when it has no length."""
-    length = float(np.linalg.norm(vector))
-    return vector / length if length > 1e-9 else vector
-
-
-def _view_basis(scene: StructureScene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Return (view_dir, right, up) for a trimetric, c-axis-up projection."""
-    if scene.axes is not None:
-        a_hat = _unit(np.asarray(scene.axes.axes[0].vector, dtype=float))
-        b_hat = _unit(np.asarray(scene.axes.axes[1].vector, dtype=float))
-        c_hat = _unit(np.asarray(scene.axes.axes[2].vector, dtype=float))
-        view_up = c_hat
-        view_dir = _unit(1.0 * a_hat + 0.45 * b_hat + 0.55 * c_hat)
-    else:
-        view_up = np.array([0.0, 1.0, 0.0])
-        view_dir = _unit(np.array([1.0, 0.8, 1.5]))
-    right = _unit(np.cross(view_up, view_dir))
-    up = _unit(np.cross(view_dir, right))
-    return view_dir, right, up
-
-
-def _scene_points(scene: StructureScene) -> np.ndarray:
-    """Return all 3D anchor points used to centre and scale the figure."""
-    points: list[tuple[float, float, float]] = []
-    points.extend(a.centre for a in scene.atoms)
-    points.extend(s.centre for s in scene.occupancy_spheres)
-    points.extend(e.centre for e in scene.ellipsoids)
-    if scene.cell_edges is not None:
-        for edge in scene.cell_edges.edges:
-            points.append(edge.start)
-            points.append(edge.end)
-    if scene.axes is not None:
-        origin = np.asarray(scene.axes.origin, dtype=float)
-        points.append(scene.axes.origin)
-        for arrow in scene.axes.axes:
-            points.append(tuple(origin + np.asarray(arrow.vector, dtype=float)))
-    return np.array(points, dtype=float) if points else np.zeros((1, 3))
-
-
-def _key(point: object) -> tuple[float, float, float]:
-    """Return a rounded coordinate key for atom-radius lookup."""
-    p = np.asarray(point, dtype=float)
-    return (round(float(p[0]), 5), round(float(p[1]), 5), round(float(p[2]), 5))
-
-
-def _radius_lookup(scene: StructureScene) -> dict[tuple[float, float, float], float]:
-    """Map each atom centre to its drawn radius (for clipping bonds)."""
-    lookup: dict[tuple[float, float, float], float] = {}
-    for atom in scene.atoms:
-        lookup[_key(atom.centre)] = atom.radius
-    for sphere in scene.occupancy_spheres:
-        lookup[_key(sphere.centre)] = sphere.radius
-    for ellipsoid in scene.ellipsoids:
-        lookup[_key(ellipsoid.centre)] = max(ellipsoid.semi_axes)
-    return lookup
-
-
-def _segment_commands(
-    p0: object,
-    p1: object,
-    project,
-    style: str,
-    *,
-    segments: int = 12,
-    arrow_tip: str = '',
-) -> list[tuple[float, str]]:
-    """Split a line into depth-sorted sub-segments so atoms can occlude it."""
-    start = np.asarray(p0, dtype=float)
-    end = np.asarray(p1, dtype=float)
-    projected = [project(start + (end - start) * (i / segments)) for i in range(segments + 1)]
-    commands = []
-    for index in range(segments):
-        x0, y0, d0 = projected[index]
-        x1, y1, d1 = projected[index + 1]
-        tip = arrow_tip if index == segments - 1 else ''
-        commands.append((
-            (d0 + d1) / 2,
-            f'\\draw[{tip}{style}] ({x0:.4f},{y0:.4f}) -- ({x1:.4f},{y1:.4f});',
-        ))
-    return commands
-
-
-class TikzStructureRenderer(StructureRendererBase):
-    """Render a structure scene as a standalone TikZ/LaTeX document."""
-
-    SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes'})
-
-    def supported_features(self) -> frozenset[str]:
-        """Return the features the TikZ engine can draw."""
-        return self.SUPPORTED
-
-    def render(
-        self,
-        scene: StructureScene,
-        *,
-        features: frozenset[str],
-        axes_on_top: bool = False,
-    ) -> str:
-        """
-        Render the scene as a standalone TikZ document.
-
-        Parameters
-        ----------
-        scene : StructureScene
-            The renderer-neutral primitives to draw.
-        features : frozenset[str]
-            The content-resolved feature set; ``atoms``/``bonds``/``cell``/
-            ``axes`` are drawn, others (moments, labels) are skipped.
-        axes_on_top : bool
-            When ``False`` (default), the axis shafts are depth-segmented so
-            atoms occlude them. When ``True``, the axis triad is drawn as an
-            always-visible reference overlay.
-
-        Returns
-        -------
-        str
-            A complete ``standalone`` LaTeX document with one tikzpicture.
-        """
-        view_dir, right, up = _view_basis(scene)
-        points = _scene_points(scene)
-        target = points.mean(axis=0)
-
-        def project(point: object) -> tuple[float, float, float]:
-            rel = np.asarray(point, dtype=float) - target
-            return float(rel @ right), float(rel @ up), float(rel @ view_dir)
-
-        scale = self._scale(points, right, up, target)
-        bond_width = 2.0 * _BOND_RADIUS * scale
-        drawables: list[tuple[float, str]] = []
-        if 'cell' in features:
-            drawables.extend(self._cell_commands(scene, project))
-        if 'axes' in features:
-            drawables.extend(self._axis_commands(scene, project, on_top=axes_on_top))
-        if 'bonds' in features:
-            drawables.extend(self._bond_commands(scene, project, bond_width, _radius_lookup(scene)))
-        if 'atoms' in features:
-            drawables.extend(self._atom_commands(scene, project))
-
-        drawables.sort(key=lambda item: item[0])
-        body = '\n'.join(command for _depth, command in drawables)
-        return (
-            f'{_PREAMBLE}'
-            f'\\begin{{tikzpicture}}[scale={scale:.4f}]\n'
-            f'{body}\n'
-            f'\\end{{tikzpicture}}\n'
-            f'\\end{{document}}\n'
-        )
-
-    @staticmethod
-    def _scale(points: np.ndarray, right: np.ndarray, up: np.ndarray, target: np.ndarray) -> float:
-        """Return a tikzpicture scale that fits the figure to a fixed size."""
-        rel = points - target
-        projected = np.column_stack((rel @ right, rel @ up))
-        extent = float((projected.max(axis=0) - projected.min(axis=0)).max())
-        return _FIGURE_SIZE_CM / extent if extent > 1e-6 else 1.0
-
-    @staticmethod
-    def _cell_commands(scene, project) -> list[tuple[float, str]]:
-        commands = []
-        if scene.cell_edges is None:
-            return commands
-        for edge in scene.cell_edges.edges:
-            commands.extend(
-                _segment_commands(edge.start, edge.end, project, 'line width=0.4pt,black!55')
-            )
-        return commands
-
-    @staticmethod
-    def _axis_commands(scene, project, *, on_top: bool) -> list[tuple[float, str]]:
-        commands = []
-        if scene.axes is None:
-            return commands
-        origin = np.asarray(scene.axes.origin, dtype=float)
-        ox, oy, _od = project(scene.axes.origin)
-        arrow_tip = '-{Stealth[length=2.4mm]},'
-        for arrow in scene.axes.axes:
-            colour = _rgb(arrow.colour)
-            style = f'line width=1pt,color={colour}'
-            tip = tuple(origin + np.asarray(arrow.vector, dtype=float))
-            tx, ty, _td = project(tip)
-            if on_top:
-                commands.append((
-                    float('inf'),
-                    f'\\draw[{arrow_tip}{style}] ({ox:.4f},{oy:.4f}) -- ({tx:.4f},{ty:.4f});',
-                ))
-            else:
-                commands.extend(
-                    _segment_commands(scene.axes.origin, tip, project, style, arrow_tip=arrow_tip)
-                )
-            # The letter always stays on top so the reference label is legible.
-            lx = ox + (tx - ox) * 1.1
-            ly = oy + (ty - oy) * 1.1
-            commands.append((
-                float('inf'),
-                f'\\node[color={colour},font=\\bfseries] at ({lx:.4f},{ly:.4f}) {{{arrow.letter}}};',
-            ))
-        return commands
-
-    @staticmethod
-    def _bond_commands(scene, project, bond_width, radius_lookup) -> list[tuple[float, str]]:
-        commands = []
-        for bond in scene.bonds:
-            start = np.asarray(bond.start, dtype=float)
-            end = np.asarray(bond.end, dtype=float)
-            segment = end - start
-            length = float(np.linalg.norm(segment))
-            if length < 1e-6:
-                continue
-            direction = segment / length
-            r_start = radius_lookup.get(_key(bond.start), 0.0)
-            r_end = radius_lookup.get(_key(bond.end), 0.0)
-            if r_start + r_end >= length:
-                continue
-            # Clip the stick to the two atom surfaces so it neither crosses
-            # an atom centre nor protrudes from a sphere it is hidden behind.
-            clipped_start = start + direction * r_start
-            clipped_end = end - direction * r_end
-            mid = (clipped_start + clipped_end) / 2.0
-            sx, sy, sd = project(clipped_start)
-            ex, ey, ed = project(clipped_end)
-            mx, my, md = project(mid)
-            for x0, y0, x1, y1, depth, colour in (
-                (sx, sy, mx, my, (sd + md) / 2, bond.start_colour),
-                (mx, my, ex, ey, (md + ed) / 2, bond.end_colour),
-            ):
-                commands.append((
-                    depth,
-                    f'\\draw[line width={bond_width:.4f}cm,line cap=round,color={_rgb(colour)}] '
-                    f'({x0:.4f},{y0:.4f}) -- ({x1:.4f},{y1:.4f});',
-                ))
-        return commands
-
-    @staticmethod
-    def _atom_commands(scene, project) -> list[tuple[float, str]]:
-        commands = []
-        for atom in scene.atoms:
-            x, y, depth = project(atom.centre)
-            commands.append((
-                depth,
-                f'\\shade[ball color={_rgb(atom.colour)}] ({x:.4f},{y:.4f}) circle ({atom.radius:.4f});',
-            ))
-        for sphere in scene.occupancy_spheres:
-            x, y, depth = project(sphere.centre)
-            colour = sphere.wedges[0].colour if sphere.wedges else (128, 128, 128)
-            commands.append((
-                depth,
-                f'\\shade[ball color={_rgb(colour)}] ({x:.4f},{y:.4f}) circle ({sphere.radius:.4f});',
-            ))
-        for ellipsoid in scene.ellipsoids:
-            x, y, depth = project(ellipsoid.centre)
-            radius = max(ellipsoid.semi_axes)
-            commands.append((
-                depth,
-                f'\\shade[ball color={_rgb(ellipsoid.colour)}] ({x:.4f},{y:.4f}) circle ({radius:.4f});',
-            ))
-        return commands
diff --git a/src/easydiffraction/display/structure/scene.py b/src/easydiffraction/display/structure/scene.py
index 79bbdbe58..9c686e393 100644
--- a/src/easydiffraction/display/structure/scene.py
+++ b/src/easydiffraction/display/structure/scene.py
@@ -118,6 +118,14 @@ class TextLabel:
     text: str
 
 
+@dataclass(frozen=True, slots=True)
+class LegendEntry:
+    """One element's colour swatch and symbol for the structure legend."""
+
+    symbol: str
+    colour: Rgb
+
+
 @dataclass(frozen=True, slots=True)
 class StructureScene:
     """Renderer-neutral Cartesian primitives for one structure."""
@@ -131,3 +139,4 @@ class StructureScene:
     cell_edges: CellEdges | None = None
     axes: AxisTriad | None = None
     labels: tuple[TextLabel, ...] = ()
+    legend: tuple[LegendEntry, ...] = ()
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 8ca9438ac..1b03e3657 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -84,7 +84,6 @@ const tooltip = root.querySelector('.cv-tooltip');
 const col = (rgb) => new THREE.Color(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255);
 const vec = (xyz) => new THREE.Vector3(xyz[0], xyz[1], xyz[2]);
 const rgbCss = (rgb) => `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
-const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
 
 let width = host.clientWidth || 640;
 let height = host.clientHeight || 480;
@@ -239,7 +238,7 @@ if (cellBasis.length === 3) {
   const bHat = cellBasis[1].clone().normalize();
   const cHat = cellBasis[2].clone().normalize();
   viewUp = cHat.clone();
-  viewDir = aHat.multiplyScalar(1.0).add(bHat.multiplyScalar(0.45)).add(cHat.multiplyScalar(0.55)).normalize();
+  viewDir = aHat.multiplyScalar(1.0).add(bHat.multiplyScalar(0.22)).add(cHat.multiplyScalar(0.33)).normalize();
 } else {
   viewUp = new THREE.Vector3(0, 1, 0);
   viewDir = new THREE.Vector3(1.0, 0.8, 1.5).normalize();
@@ -352,30 +351,8 @@ const addLegendItem = (background, text) => {
   legend.appendChild(item);
 };
 
-const seenElements = new Map();
-const collectElement = (label, colour) => {
-  const element = elementOf(label);
-  if (!seenElements.has(element)) seenElements.set(element, colour);
-};
-SCENE.atoms.forEach((a) => collectElement(a.label, a.colour));
-SCENE.ellipsoids.forEach((e) => collectElement(e.label, e.colour));
-for (const [element, colour] of seenElements) addLegendItem(rgbCss(colour), element);
-
-const seenWedges = new Set();
-for (const s of SCENE.wedgeSpheres) {
-  if (seenWedges.has(s.label)) continue;
-  seenWedges.add(s.label);
-  let acc = 0;
-  const stops = s.wedges.map((w) => {
-    const start = acc * 100;
-    acc += w.fraction;
-    return `${rgbCss(w.colour)} ${start.toFixed(1)}% ${(acc * 100).toFixed(1)}%`;
-  });
-  const parts = s.label.split('/');
-  const ratio = s.wedges.slice(0, parts.length).map((w) => Math.round(w.fraction * 100));
-  const text = ratio.length > 1 ? `${s.label} (${ratio.join('/')})` : s.label;
-  addLegendItem(`linear-gradient(90deg, ${stops.join(', ')})`, text);
-}
+// One solid swatch per distinct element, mirroring the PDF report legend.
+for (const entry of SCENE.legend) addLegendItem(rgbCss(entry.colour), entry.symbol);
 
 if (!legend.children.length) legend.style.display = 'none';
 
diff --git a/src/easydiffraction/report/tex_renderer.py b/src/easydiffraction/report/tex_renderer.py
index 445d87d2f..dd2d29e5b 100644
--- a/src/easydiffraction/report/tex_renderer.py
+++ b/src/easydiffraction/report/tex_renderer.py
@@ -425,13 +425,13 @@ def _structure_asset_stem(struct_id: str) -> str:
 
 
 def _structure_figure_paths(context: dict[str, object]) -> dict[str, str]:
-    """Return expected structure-figure PDF paths for TeX rendering."""
+    """Return expected structure-figure PNG paths for TeX rendering."""
     paths: dict[str, str] = {}
     for structure in context.get('structures') or []:
         if not isinstance(structure, dict):
             continue
         struct_id = str(structure.get('id') or 'structure')
-        paths[struct_id] = f'data/{_structure_asset_stem(struct_id)}.pdf'
+        paths[struct_id] = f'data/{_structure_asset_stem(struct_id)}.png'
     return paths
 
 
@@ -440,13 +440,13 @@ def _write_structure_assets(
     context: dict[str, object],
     out_dir: pathlib.Path,
 ) -> dict[str, str]:
-    """Write one standalone TikZ structure figure per structure."""
+    """Write one z-buffered PNG structure figure per structure."""
     from easydiffraction.display.structure.builder import build_scene  # noqa: PLC0415
     from easydiffraction.display.structure.builder import (  # noqa: PLC0415
         structure_feature_availability,
     )
-    from easydiffraction.display.structure.renderers.tikz import (  # noqa: PLC0415
-        TikzStructureRenderer,
+    from easydiffraction.display.structure.renderers.raster import (  # noqa: PLC0415
+        RasterStructureRenderer,
     )
 
     del context
@@ -455,7 +455,7 @@ def _write_structure_assets(
     if not callable(values):
         return {}
 
-    renderer = TikzStructureRenderer()
+    renderer = RasterStructureRenderer()
     window = project.rendering_structure.view_range()
     style = project.style
     data_dir = out_dir / 'data'
@@ -467,12 +467,9 @@ def _write_structure_assets(
         availability = structure_feature_availability(structure, style=style)
         features = project.display._resolve_structure_features('auto', availability)
         scene = build_scene(structure, style=style, view_range=window, features=features)
-        figure_path = data_dir / f'{_structure_asset_stem(struct_id)}.tex'
-        figure_path.write_text(
-            renderer.render(scene, features=features, axes_on_top=False),
-            encoding='utf-8',
-        )
-        figure_paths[struct_id] = f'data/{figure_path.stem}.pdf'
+        figure_path = data_dir / f'{_structure_asset_stem(struct_id)}.png'
+        figure_path.write_bytes(renderer.render_png(scene, features=features))
+        figure_paths[struct_id] = f'data/{figure_path.name}'
     return figure_paths
 
 
diff --git a/tests/unit/easydiffraction/report/test_tex_renderer.py b/tests/unit/easydiffraction/report/test_tex_renderer.py
index 68d251b71..c26fe46b6 100644
--- a/tests/unit/easydiffraction/report/test_tex_renderer.py
+++ b/tests/unit/easydiffraction/report/test_tex_renderer.py
@@ -461,7 +461,7 @@ def test_save_tex_report_removes_stale_managed_bundle_dirs(tmp_path):
     assert not (tex_dir / 'styles').exists()
 
 
-def test_save_tex_report_writes_tikz_structure_figure(tmp_path):
+def test_save_tex_report_writes_structure_figure_png(tmp_path):
     import easydiffraction as ed
 
     from easydiffraction.report.tex_renderer import save_tex_report
@@ -482,9 +482,7 @@ def test_save_tex_report_writes_tikz_structure_figure(tmp_path):
     tex_path = tmp_path / 'report.tex'
     save_tex_report(project, project.report.data_context(), path=tex_path)
 
-    figure_path = tex_path.parent / 'data' / 'struct_nacl.tex'
+    figure_path = tex_path.parent / 'data' / 'struct_nacl.png'
     assert figure_path.exists()
-    figure_text = figure_path.read_text(encoding='utf-8')
-    assert '\\begin{tikzpicture}' in figure_text
-    assert '\\shade[ball color' in figure_text
-    assert 'data/struct_nacl.pdf' in tex_path.read_text(encoding='utf-8')
+    assert figure_path.read_bytes().startswith(b'\x89PNG\r\n\x1a\n')
+    assert 'data/struct_nacl.png' in tex_path.read_text(encoding='utf-8')

From f31996da7cbbd63c2cd2c6e335fed4bc00c6228a Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 19:19:08 +0200
Subject: [PATCH 055/160] Merge atom_shape and radius_model into atom_view
 setting

---
 .../crysview-structure-visualization.md       | 82 +++++++++++--------
 docs/docs/tutorials/ed-3.ipynb                |  3 +-
 docs/docs/tutorials/ed-3.py                   |  3 +-
 .../user-guide/analysis-workflow/model.md     |  9 +-
 .../display/structure/__init__.py             |  3 +-
 .../display/structure/builder.py              | 14 ++--
 .../display/structure/enums.py                | 66 +++++++--------
 .../project/categories/style/default.py       | 50 ++++-------
 .../project/test_project_load.py              |  4 +-
 9 files changed, 113 insertions(+), 121 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 89766acc1..af46322a8 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -289,40 +289,51 @@ A scientist picks one model and one scheme instead of editing dozens of
 per-element rows, which keeps the view consistent and reproducible:
 
 ```python
-project.style.atom_shape = 'ortep'        # ball | ortep
-project.style.radius_model = 'covalent'   # vdw | covalent | ionic | atomic (default covalent)
+project.style.atom_view = 'adp'           # vdw | covalent | ionic | atomic | adp (default adp)
 project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
 project.style.show_supported()            # accepted values per setting
 ```
 
-How an atom is shaped is a single **display-style switch**,
-`atom_shape`, because a ball-and-stick radius and an ADP probability
-surface are different depictions and a view shows one of them at a time:
-
-- `'ball'` draws every atom as a **radius-model sphere** (the radius
-  model above); displacement parameters do not affect size. This is the
-  familiar ball-and-stick depiction and works for any structure, with or
-  without ADP.
-- `'ortep'` draws each atom as its **ADP probability surface** — a
-  sphere for an atom with only isotropic ADP, an ellipsoid (semi-axes
-  and orientation from the ADP tensor) for an anisotropic one. Atoms
-  that carry no ADP fall back to a radius-model sphere. This is the
+How an atom is sized and shaped is a single **display-style switch**,
+`atom_view`, because the standard radius models and the ADP probability
+surface are alternative depictions and a view shows one of them at a
+time:
+
+- `'vdw'`, `'covalent'`, `'ionic'`, `'atomic'` draw every atom as a
+  **radius-model sphere** for the named standard radius table;
+  displacement parameters do not affect size. This is the familiar
+  ball-and-stick depiction and works for any structure, with or without
+  ADP.
+- `'adp'` draws each atom as its **ADP probability surface** — a sphere
+  for an atom with only isotropic ADP, an ellipsoid (semi-axes and
+  orientation from the ADP tensor) for an anisotropic one. Atoms that
+  carry no ADP fall back to a covalent-radius sphere. This is the
   thermal-ellipsoid (ORTEP) depiction crystallographers use to inspect
   the displacement parameters a refinement adjusts.
 
-The default is `'ortep'`, because this is a refinement tool and the
-thermal ellipsoids are usually the point; a structure with no ADP simply
-renders as radius-model spheres, identical to `'ball'`.
-
-In `'ortep'` the surfaces are drawn at one **probability level**,
+The default is `'adp'`, because this is a refinement tool and the thermal
+ellipsoids are usually the point; a structure with no ADP simply renders
+as covalent-radius spheres.
+
+> **Amendment — `atom_view` merge.** An earlier design split this into
+> two settings: `atom_shape` (`ball`/`ortep`) and `radius_model`
+> (`vdw`/`covalent`/`ionic`/`atomic`). They were merged into the single
+> `atom_view` selector `{vdw, covalent, ionic, atomic, adp}` because
+> `radius_model` was meaningful only in ball mode, so the two-field form
+> carried four degenerate `ortep`×radius-model combinations. The flat
+> list removes the dead states and matches how VESTA/Mercury present the
+> choice. The `adp` view still uses covalent radii for the ball fallback
+> and for mixed-occupancy sites. CIF field: `_style.atom_view`.
+
+In `'adp'` the surfaces are drawn at one **probability level**,
 `adp_probability`, a fraction in the open interval (0, 1) — not a
 percentage — validated on assignment. It defaults to `0.5` (the ORTEP
 and journal 50% convention) and is freely changeable (for example
-`0.95`). It has no effect in `'ball'`.
+`0.95`). It has no effect in the radius-model views.
 
 Which bonds the view draws is **not** a styling choice — it is a
 geometric property of the structure, and it follows the **standard
-cif_core `_geom` auto-bonding model**, not the display `radius_model`. A
+cif_core `_geom` auto-bonding model**, not the display `atom_view`. A
 bond is drawn between two sites when their distance `d` satisfies
 `_geom.min_bond_distance_cutoff ≤ d ≤ r_bond(i) + r_bond(j) + _geom.bond_distance_incr`,
 where the per-type bonding radius `r_bond` is `_atom_type.radius_bond`
@@ -334,8 +345,8 @@ ionic A-site cations do not bond to every surrounding anion (a heuristic
 stop-gap; see open issue #108 for the full near-neighbour approach). These
 two cutoffs live on the **structure**
 and persist in the structure's own CIF (see section 8), not in
-`project.style`. The display `radius_model` (vdw / covalent / ionic /
-atomic) changes only the rendered sphere _size_ — it never decides which
+`project.style`. The `atom_view` radius models (vdw / covalent / ionic /
+atomic) change only the rendered sphere _size_ — they never decide which
 bonds appear; bond detection is governed solely by the `_geom` cutoffs
 and the per-type bonding radius. Version 1 draws bonds computed on the
 fly from this rule while the scene is built and persists no bond table.
@@ -344,7 +355,7 @@ and `_geom_angle` loops, with distances, angles, symmetry codes, and
 standard uncertainties — is a separate, related feature that reuses the
 same symmetry-expansion and distance math (see Deferred Work).
 
-`atom_shape`, `radius_model`, and `color_scheme` are finite, closed
+`atom_view` and `color_scheme` are finite, closed
 value sets, so each is a `(str, Enum)` validated on assignment per the
 [Enum-Backed Closed Value Sets](../../../docs/dev/adrs/accepted/enum-backed-closed-values.md)
 ADR, and `project.style.show_supported()` lists the accepted values for
@@ -353,9 +364,10 @@ give through `show_supported()`. `style` is a plain category, not a
 switchable one: it has no factory-swapped `type`, only these validated
 value settings.
 
-The defaults are the **covalent** radius model and the **Jmol/CPK**
+The defaults are the **`adp`** atom view and the **Jmol/CPK**
 colour scheme, so the view looks right with no configuration. Covalent
-is the default because it is backed by complete, well-documented
+radii — the `adp` ball fallback and the `atom_view = 'covalent'` option —
+are preferred because they are backed by complete, well-documented
 per-element data and needs no oxidation state: today's atom-site model
 carries only an element symbol — no charge, oxidation-state, or
 coordination field — so a model that depends on charge cannot be
@@ -368,7 +380,7 @@ scheme are selected. The database carries, per element, the van der
 Waals, covalent, ionic (a representative Shannon radius at a documented
 default oxidation state and coordination), and atomic/empirical radii,
 plus the Jmol/CPK and VESTA colour palettes, each value carrying a
-documented provenance. The ionic entries let `radius_model = 'ionic'`
+documented provenance. The ionic entries let `atom_view = 'ionic'`
 work today against the documented default oxidation state; when a future
 atom-site charge field exists the ionic model will prefer the site's
 charge. An element with no entry for the selected radius model falls
@@ -485,11 +497,10 @@ project.rendering_structure.type = 'auto'           # default: 'threejs' in Jupy
 project.rendering_structure.show_supported()
 
 # How: standard styling models, not per-element values (visual only)
-project.style.atom_shape = 'ortep'        # ball | ortep
-project.style.radius_model = 'covalent'   # vdw | covalent | ionic | atomic (default covalent)
+project.style.atom_view = 'adp'           # vdw | covalent | ionic | atomic | adp (default adp)
 project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
-project.style.adp_probability = 0.5       # ortep only; fraction in (0, 1)
-project.style.atom_scale = 0.3            # ball only; overall size, sqrt-compressed (0, 1]
+project.style.adp_probability = 0.5       # adp only; fraction in (0, 1)
+project.style.atom_scale = 0.3            # radius-model views only; size, sqrt-compressed (0, 1]
 project.style.show_supported()            # accepted values per setting
 
 # Which bonds exist: a per-structure geometric property, not styling.
@@ -534,8 +545,7 @@ _rendering_structure.range_b_max    1
 _rendering_structure.range_c_min    0
 _rendering_structure.range_c_max    1
 
-_style.atom_shape       ortep
-_style.radius_model     covalent
+_style.atom_view        adp
 _style.color_scheme     jmol
 _style.adp_probability  0.5
 _style.atom_scale       0.3
@@ -625,7 +635,7 @@ a per-call request behave predictably:
   per-type bonding radius (`_atom_type.radius_bond`, defaulting to the
   covalent radius), all on the structure and persisted in the structure
   CIF — not in `project.style`, and independent of the display
-  `radius_model`. Version 1 draws bonds on the fly and persists no bond
+  `atom_view`. Version 1 draws bonds on the fly and persists no bond
   table; the full computed `_geom_bond` / `_geom_angle` tables are
   deferred to a separate feature.
 - The structure view auto-detects the host's dark/light theme (reusing
@@ -663,8 +673,8 @@ All items below are now **resolved** so the implementation plan can be
 executed autonomously; the plan records the verified data sources and
 the final names.
 
-- **CIF tag spelling — resolved.** Project CIF: `_style.atom_shape`,
-  `_style.radius_model`, `_style.color_scheme`,
+- **CIF tag spelling — resolved.** Project CIF: `_style.atom_view`,
+  `_style.color_scheme`,
   `_style.adp_probability`, and `_rendering_structure.type` / `_rendering_structure.show_labels` /
   `_rendering_structure.show_moments` / `_rendering_structure.range_{a,b,c}_{min,max}`. These are project-internal
   app/settings tags (`_rendering_structure.type` follows the Display-UX `_rendering_plot.type` /
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index eaa063437..94a4e0d06 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -412,8 +412,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.style.atom_shape = 'ball'\n",
-    "project.style.radius_model = 'atomic'\n",
+    "project.style.atom_view = 'atomic'\n",
     "project.style.color_scheme = 'jmol'"
    ]
   },
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index c72573876..a33815103 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -185,8 +185,7 @@
 project.style.show_supported()
 
 # %%
-project.style.atom_shape = 'ball'
-project.style.radius_model = 'atomic'
+project.style.atom_view = 'atomic'
 project.style.color_scheme = 'jmol'
 
 # %% [markdown]
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 6649dcfb8..ef783ec5d 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -203,11 +203,14 @@ Visual styling — independent of the per-element data — is configured on
 # List the accepted style settings
 project.style.show_supported()
 
-# Choose how atoms are depicted, sized, and coloured
-project.style.atom_shape = 'ball'  # 'ball' or 'ortep'
-project.style.radius_model = 'covalent'  # 'vdw', 'covalent', 'ionic', 'atomic'
+# Choose how atoms are depicted, sized, and coloured.
+# atom_view picks a radius-model ball ('vdw'/'covalent'/'ionic'/'atomic')
+# or 'adp' for displacement surfaces (spheres for isotropic sites,
+# ellipsoids for anisotropic ones — driven by each atom's adp_type).
+project.style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', 'atomic', or 'adp'
 project.style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
 project.style.atom_scale = 0.3  # overall ball size (square-root compressed)
+project.style.adp_probability = 0.5  # ADP ellipsoid probability level (0–1)
 ```
 
 Bonds are generated automatically between atoms whose separation falls
diff --git a/src/easydiffraction/display/structure/__init__.py b/src/easydiffraction/display/structure/__init__.py
index d22b6ca41..6c723dcf9 100644
--- a/src/easydiffraction/display/structure/__init__.py
+++ b/src/easydiffraction/display/structure/__init__.py
@@ -4,9 +4,8 @@
 
 from __future__ import annotations
 
-from easydiffraction.display.structure.enums import AtomShapeEnum
+from easydiffraction.display.structure.enums import AtomViewEnum
 from easydiffraction.display.structure.enums import ColorSchemeEnum
-from easydiffraction.display.structure.enums import RadiusModelEnum
 from easydiffraction.display.structure.enums import ViewerEngineEnum
 from easydiffraction.display.structure.viewing import Viewer
 from easydiffraction.display.structure.viewing import ViewerFactory
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index e82fd6661..830037d0d 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -25,6 +25,7 @@
 from easydiffraction.display.structure.assets.colors import VACANCY_COLOR
 from easydiffraction.display.structure.assets.colors import color_for
 from easydiffraction.display.structure.assets.radii import radius_for
+from easydiffraction.display.structure.enums import AtomViewEnum
 from easydiffraction.display.structure.scene import AdpEllipsoid
 from easydiffraction.display.structure.scene import AtomSphere
 from easydiffraction.display.structure.scene import AxisArrow
@@ -154,12 +155,13 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
     """Build the sphere/ellipsoid primitive for a single full-occupancy atom."""
     element = _element_symbol(atom.type_symbol.value)
     colour = color_for(element, style.color_scheme.value)
-    radius, substituted = radius_for(element, style.radius_model.value)
+    view = AtomViewEnum(style.atom_view.value)
+    radius, substituted = radius_for(element, view.radius_model())
     ball_radius = _display_radius(radius, style)
     label = atom.label.value
     adp_type = AdpTypeEnum(atom.adp_type.value)
     scale = float(chi.ppf(style.adp_probability.value, 3))
-    if style.atom_shape.value == 'ortep' and adp_type in {AdpTypeEnum.UANI, AdpTypeEnum.BANI} \
+    if view.is_adp and adp_type in {AdpTypeEnum.UANI, AdpTypeEnum.BANI} \
             and label in aniso_collection:
         u_cart = _cartesian_u(atom, aniso_collection[label], matrix, cell)
         semi, orient = ecr.adp_principal_axes(u_cart)
@@ -167,7 +169,7 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
             _vec3(centre), _vec3(semi * scale),
             tuple(_vec3(orient[:, i]) for i in range(3)), colour, label,
         )
-    elif style.atom_shape.value == 'ortep' and adp_type in {AdpTypeEnum.UISO, AdpTypeEnum.BISO}:
+    elif view.is_adp and adp_type in {AdpTypeEnum.UISO, AdpTypeEnum.BISO}:
         u_iso = atom.adp_iso.value
         if adp_type is AdpTypeEnum.BISO:
             u_iso = u_iso / EIGHT_PI_SQ
@@ -213,11 +215,12 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
                     substitutions.add(_element_symbol(atom.type_symbol.value))
                 continue
         rows = []
+        radius_model = AtomViewEnum(style.atom_view.value).radius_model()
         for idx, _ in members:
             atom = sites[idx]
             element = _element_symbol(atom.type_symbol.value)
             colour = color_for(element, style.color_scheme.value)
-            radius, substituted = radius_for(element, style.radius_model.value)
+            radius, substituted = radius_for(element, radius_model)
             rows.append((atom, atom.occupancy.value, element, colour, radius))
             if substituted:
                 substitutions.add(element)
@@ -370,9 +373,10 @@ def structure_feature_availability(structure, *, style) -> FeatureAvailability:
     if sites:
         available |= {'atoms', 'bonds', 'labels'}
     substitutions = set()
+    radius_model = AtomViewEnum(style.atom_view.value).radius_model()
     for atom in sites:
         element = _element_symbol(atom.type_symbol.value)
-        _, substituted = radius_for(element, style.radius_model.value)
+        _, substituted = radius_for(element, radius_model)
         if substituted:
             substitutions.add(element)
     return FeatureAvailability(frozenset(available), tuple(sorted(substitutions)))
diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
index 4976b72ce..264730d77 100644
--- a/src/easydiffraction/display/structure/enums.py
+++ b/src/easydiffraction/display/structure/enums.py
@@ -31,50 +31,50 @@ def description(self) -> str:
         return ''
 
 
-class AtomShapeEnum(StrEnum):
-    """How each atom is depicted in the structure view."""
+class AtomViewEnum(StrEnum):
+    """How atoms are sized and shaped in the structure view.
 
-    BALL = 'ball'
-    ORTEP = 'ortep'
-
-    @classmethod
-    def default(cls) -> AtomShapeEnum:
-        """Select the default atom shape (ORTEP thermal surfaces)."""
-        return cls.ORTEP
-
-    def description(self) -> str:
-        """Human-readable description for UI listings."""
-        if self is AtomShapeEnum.BALL:
-            return 'Ball-and-stick radius-model spheres'
-        if self is AtomShapeEnum.ORTEP:
-            return 'ORTEP ADP probability surfaces (ellipsoids)'
-        return ''
-
-
-class RadiusModelEnum(StrEnum):
-    """Standard per-element radius model for atom sphere size."""
+    The four radius models draw fixed balls; ``adp`` draws displacement
+    surfaces (spheres for isotropic sites, ellipsoids for anisotropic).
+    """
 
     VDW = 'vdw'
     COVALENT = 'covalent'
     IONIC = 'ionic'
     ATOMIC = 'atomic'
+    ADP = 'adp'
 
     @classmethod
-    def default(cls) -> RadiusModelEnum:
-        """Select the default radius model (covalent; charge-free)."""
-        return cls.COVALENT
+    def default(cls) -> AtomViewEnum:
+        """Select the default atom view (ADP displacement surfaces)."""
+        return cls.ADP
+
+    @property
+    def is_adp(self) -> bool:
+        """Return whether atoms are drawn as displacement surfaces, not balls."""
+        return self is AtomViewEnum.ADP
+
+    def radius_model(self) -> str:
+        """Return the radius-table name for ball sizing.
+
+        The ``adp`` view still needs ball radii for mixed-occupancy sites
+        and as a fallback for zero-displacement atoms, where it uses
+        covalent radii.
+        """
+        if self is AtomViewEnum.ADP:
+            return AtomViewEnum.COVALENT.value
+        return self.value
 
     def description(self) -> str:
         """Human-readable description for UI listings."""
-        if self is RadiusModelEnum.VDW:
-            return 'Van der Waals radii'
-        if self is RadiusModelEnum.COVALENT:
-            return 'Covalent radii'
-        if self is RadiusModelEnum.IONIC:
-            return 'Ionic (Shannon) radii'
-        if self is RadiusModelEnum.ATOMIC:
-            return 'Atomic (empirical) radii'
-        return ''
+        descriptions = {
+            AtomViewEnum.VDW: 'Van der Waals radius balls',
+            AtomViewEnum.COVALENT: 'Covalent radius balls',
+            AtomViewEnum.IONIC: 'Ionic (Shannon) radius balls',
+            AtomViewEnum.ATOMIC: 'Atomic (empirical) radius balls',
+            AtomViewEnum.ADP: 'ADP probability surfaces (spheres / ellipsoids)',
+        }
+        return descriptions.get(self, '')
 
 
 class ColorSchemeEnum(StrEnum):
diff --git a/src/easydiffraction/project/categories/style/default.py b/src/easydiffraction/project/categories/style/default.py
index d967425e0..61b94cc74 100644
--- a/src/easydiffraction/project/categories/style/default.py
+++ b/src/easydiffraction/project/categories/style/default.py
@@ -11,9 +11,8 @@
 from easydiffraction.core.validation import RangeValidator
 from easydiffraction.core.variable import NumericDescriptor
 from easydiffraction.core.variable import StringDescriptor
-from easydiffraction.display.structure.enums import AtomShapeEnum
+from easydiffraction.display.structure.enums import AtomViewEnum
 from easydiffraction.display.structure.enums import ColorSchemeEnum
-from easydiffraction.display.structure.enums import RadiusModelEnum
 from easydiffraction.io.cif.handler import CifHandler
 from easydiffraction.project.categories.style.factory import StyleFactory
 from easydiffraction.utils.logging import console
@@ -33,27 +32,16 @@ class Style(CategoryItem):
     def __init__(self) -> None:
         super().__init__()
 
-        self._atom_shape = StringDescriptor(
-            name='atom_shape',
-            description='Atom depiction mode for the structure view.',
+        self._atom_view = StringDescriptor(
+            name='atom_view',
+            description='How atoms are sized and shaped in the structure view.',
             value_spec=AttributeSpec(
-                default=AtomShapeEnum.default().value,
+                default=AtomViewEnum.default().value,
                 validator=MembershipValidator(
-                    allowed=[member.value for member in AtomShapeEnum],
+                    allowed=[member.value for member in AtomViewEnum],
                 ),
             ),
-            cif_handler=CifHandler(names=['_style.atom_shape']),
-        )
-        self._radius_model = StringDescriptor(
-            name='radius_model',
-            description='Standard per-element radius model.',
-            value_spec=AttributeSpec(
-                default=RadiusModelEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in RadiusModelEnum],
-                ),
-            ),
-            cif_handler=CifHandler(names=['_style.radius_model']),
+            cif_handler=CifHandler(names=['_style.atom_view']),
         )
         self._color_scheme = StringDescriptor(
             name='color_scheme',
@@ -86,22 +74,13 @@ def __init__(self) -> None:
         )
 
     @property
-    def atom_shape(self) -> StringDescriptor:
-        """Atom depiction mode (``ball`` or ``ortep``)."""
-        return self._atom_shape
-
-    @atom_shape.setter
-    def atom_shape(self, value: str) -> None:
-        self._atom_shape.value = AtomShapeEnum(value).value
-
-    @property
-    def radius_model(self) -> StringDescriptor:
-        """Standard per-element radius model."""
-        return self._radius_model
+    def atom_view(self) -> StringDescriptor:
+        """How atoms are sized/shaped (``vdw``/``covalent``/``ionic``/``atomic``/``adp``)."""
+        return self._atom_view
 
-    @radius_model.setter
-    def radius_model(self, value: str) -> None:
-        self._radius_model.value = RadiusModelEnum(value).value
+    @atom_view.setter
+    def atom_view(self, value: str) -> None:
+        self._atom_view.value = AtomViewEnum(value).value
 
     @property
     def color_scheme(self) -> StringDescriptor:
@@ -134,8 +113,7 @@ def show_supported(self) -> None:
         """List the accepted values for every styling setting."""
         console.paragraph('Supported style settings')
         for setting, enum in (
-            ('atom_shape', AtomShapeEnum),
-            ('radius_model', RadiusModelEnum),
+            ('atom_view', AtomViewEnum),
             ('color_scheme', ColorSchemeEnum),
         ):
             console.print(f"{setting}: {', '.join(member.value for member in enum)}")
diff --git a/tests/unit/easydiffraction/project/test_project_load.py b/tests/unit/easydiffraction/project/test_project_load.py
index 4cc7c68d3..4d07b07f3 100644
--- a/tests/unit/easydiffraction/project/test_project_load.py
+++ b/tests/unit/easydiffraction/project/test_project_load.py
@@ -86,7 +86,7 @@ def test_round_trips_display_engine_configuration(self, tmp_path):
         original.rendering_plot.type = 'asciichartpy'
         original.rendering_table.type = 'rich'
         original.rendering_structure.type = 'ascii'
-        original.style.atom_shape = 'ball'
+        original.style.atom_view = 'vdw'
         original.save_as(str(tmp_path / 'proj'))
 
         loaded = Project.load(str(tmp_path / 'proj'))
@@ -94,7 +94,7 @@ def test_round_trips_display_engine_configuration(self, tmp_path):
         assert loaded.rendering_plot.type == 'asciichartpy'
         assert loaded.rendering_table.type == 'rich'
         assert loaded.rendering_structure.type == 'ascii'
-        assert loaded.style.atom_shape.value == 'ball'
+        assert loaded.style.atom_view.value == 'vdw'
 
     def test_round_trips_constraints(self, tmp_path):
         original = Project(name='c1')

From 313e6a1ffa35ae1f4961fc7a93314ca896104c2b Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 19:19:14 +0200
Subject: [PATCH 056/160] Render true ADP ellipsoids in the raster figure

---
 .../display/structure/renderers/raster.py     | 58 ++++++++++++++++++-
 1 file changed, 56 insertions(+), 2 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 103157b7b..3143029f3 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -145,8 +145,7 @@ def project(point: object) -> tuple[float, float, float]:
                 self._sphere(colour, depth, project, scale, sphere.centre, sphere.radius,
                              (128, 128, 128), wedges=sphere.wedges)
             for ellipsoid in scene.ellipsoids:
-                self._sphere(colour, depth, project, scale, ellipsoid.centre,
-                             max(ellipsoid.semi_axes), ellipsoid.colour)
+                self._ellipsoid(colour, depth, project, scale, (right, up, view_dir), ellipsoid)
 
         downsampled = (
             colour.reshape(_CANVAS, _SUPERSAMPLE, _CANVAS, _SUPERSAMPLE, 3).mean(axis=(1, 3))
@@ -261,6 +260,61 @@ def _base_colours(dx, dy, base, wedges) -> np.ndarray:
         base_rgb[angle >= lo] = np.asarray(wedges[-1].colour, dtype=np.float32) / 255.0
         return base_rgb
 
+    @staticmethod
+    def _ellipsoid(colour, depth, project, scale, basis, ell) -> None:
+        """Z-tested, shaded oriented ADP ellipsoid (exact ray cast per pixel)."""
+        right, up, view_dir = basis
+        centre = np.asarray(ell.centre, dtype=float)
+        semi = np.maximum(np.asarray(ell.semi_axes, dtype=float), 1e-9)
+        axes = [np.asarray(vec, dtype=float) for vec in ell.orientation]
+        cx, cy, cd = project(centre)
+        half_x = scale * float(np.sqrt(sum((semi[k] * (axes[k] @ right)) ** 2 for k in range(3))))
+        half_y = scale * float(np.sqrt(sum((semi[k] * (axes[k] @ up)) ** 2 for k in range(3))))
+        size = colour.shape[0]
+        x0, x1 = max(0, int(cx - half_x)), min(size, int(cx + half_x) + 1)
+        y0, y1 = max(0, int(cy - half_y)), min(size, int(cy + half_y) + 1)
+        if x0 >= x1 or y0 >= y1:
+            return
+        # Camera-frame components of each principal axis.
+        r = [float(axes[k] @ right) for k in range(3)]
+        u = [float(axes[k] @ up) for k in range(3)]
+        v = [float(axes[k] @ view_dir) for k in range(3)]
+        a_coeff = sum((v[k] / semi[k]) ** 2 for k in range(3))
+        if a_coeff <= 0.0:
+            return
+        # Solve |S^-1 R^T (q)|^2 = 1 along the view ray q = image-plane + t*view_dir.
+        ys, xs = np.mgrid[y0:y1, x0:x1]
+        offset_right = (xs - cx) / scale
+        offset_up = -(ys - cy) / scale
+        base = [offset_right * r[k] + offset_up * u[k] for k in range(3)]
+        b_coeff = sum(2.0 * base[k] * v[k] / semi[k] ** 2 for k in range(3))
+        c_coeff = sum((base[k] / semi[k]) ** 2 for k in range(3)) - 1.0
+        disc = b_coeff * b_coeff - 4.0 * a_coeff * c_coeff
+        inside = disc >= 0.0
+        if not inside.any():
+            return
+        t = (-b_coeff + np.sqrt(np.clip(disc, 0.0, None))) / (2.0 * a_coeff)
+        surf_depth = cd + t
+        sub = depth[y0:y1, x0:x1]
+        update = inside & (surf_depth > sub)
+        if not update.any():
+            return
+        local = [(base[k] + t * v[k]) / semi[k] for k in range(3)]
+        nx = sum(local[k] / semi[k] * axes[k][0] for k in range(3))
+        ny = sum(local[k] / semi[k] * axes[k][1] for k in range(3))
+        nz = sum(local[k] / semi[k] * axes[k][2] for k in range(3))
+        norm = np.sqrt(nx * nx + ny * ny + nz * nz)
+        norm = np.where(norm > 1e-12, norm, 1.0)
+        normal = np.stack((
+            (nx * right[0] + ny * right[1] + nz * right[2]) / norm,
+            (nx * up[0] + ny * up[1] + nz * up[2]) / norm,
+            (nx * view_dir[0] + ny * view_dir[1] + nz * view_dir[2]) / norm,
+        ), axis=-1)
+        intensity = _diffuse_intensity(normal)[..., None]
+        shade = np.clip(np.asarray(ell.colour, dtype=np.float32) / 255.0 * intensity, 0, 1)
+        sub[update] = surf_depth[update]
+        colour[y0:y1, x0:x1][update] = shade[update]
+
     @staticmethod
     def _capsule(colour, depth, project, scale, p0, p1, radius, colour0, colour1) -> None:
         size = colour.shape[0]

From 6414deb6772fc29d82f71322cf92da913d4738f6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 19:19:25 +0200
Subject: [PATCH 057/160] Demonstrate ADP atom view in ed-14 tutorial

---
 docs/docs/tutorials/ed-14.ipynb | 107 ++++++++++++++++++++++++--------
 docs/docs/tutorials/ed-14.py    |  24 +++++++
 2 files changed, 105 insertions(+), 26 deletions(-)

diff --git a/docs/docs/tutorials/ed-14.ipynb b/docs/docs/tutorials/ed-14.ipynb
index b6c62e3bb..3ad2eaf52 100644
--- a/docs/docs/tutorials/ed-14.ipynb
+++ b/docs/docs/tutorials/ed-14.ipynb
@@ -173,7 +173,11 @@
    "id": "15",
    "metadata": {},
    "source": [
-    "## Step 3: Define Experiment"
+    "### Structure View (ADP mode)\n",
+    "\n",
+    "Select the ADP atom view. With the starting isotropic displacements every\n",
+    "atom is drawn as a sphere; after the anisotropic refinement below, the same\n",
+    "view will draw probability ellipsoids for the anisotropic sites."
    ]
   },
   {
@@ -182,6 +186,34 @@
    "id": "16",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.style.atom_view = 'adp'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='tbti')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18",
+   "metadata": {},
+   "source": [
+    "## Step 3: Define Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Download data file from repository\n",
     "data_path = ed.download_data(id=19, destination='data')"
@@ -190,7 +222,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -206,7 +238,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -216,7 +248,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -227,7 +259,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -237,7 +269,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "24",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -247,7 +279,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "22",
+   "id": "25",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis I (ADP iso)"
@@ -256,7 +288,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -266,7 +298,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -285,7 +317,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -296,7 +328,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,7 +340,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "30",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -319,7 +351,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "28",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -329,7 +361,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -339,7 +371,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "33",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -348,7 +380,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "31",
+   "id": "34",
    "metadata": {},
    "source": [
     "## Step 5: Perform Analysis (ADP aniso)"
@@ -357,7 +389,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -370,7 +402,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -380,7 +412,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -397,7 +429,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -407,7 +439,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -417,7 +449,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -427,7 +459,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -437,7 +469,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -446,7 +478,30 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "43",
+   "metadata": {},
+   "source": [
+    "### Structure View after refinement\n",
+    "\n",
+    "Tb, Ti and O1 were refined with anisotropic displacements (`Uani`), so the\n",
+    "ADP view now draws them as probability ellipsoids, while O2 stayed isotropic\n",
+    "(`Uiso`) and remains a sphere — highlighting how the view changed from the\n",
+    "initial spheres to ellipsoids."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='tbti')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45",
    "metadata": {},
    "source": [
     "## Step 6: Generate Report"
@@ -455,7 +510,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-14.py b/docs/docs/tutorials/ed-14.py
index 7f7507412..dda677782 100644
--- a/docs/docs/tutorials/ed-14.py
+++ b/docs/docs/tutorials/ed-14.py
@@ -57,6 +57,19 @@
 structure.atom_sites['O1'].adp_iso = 0.0
 structure.atom_sites['O2'].adp_iso = 0.0
 
+# %% [markdown]
+# ### Structure View (ADP mode)
+#
+# Select the ADP atom view. With the starting isotropic displacements every
+# atom is drawn as a sphere; after the anisotropic refinement below, the same
+# view will draw probability ellipsoids for the anisotropic sites.
+
+# %%
+project.style.atom_view = 'adp'
+
+# %%
+project.display.structure(struct_name='tbti')
+
 # %% [markdown]
 # ## Step 3: Define Experiment
 
@@ -164,6 +177,17 @@
 # %%
 structure.show_as_cif()
 
+# %% [markdown]
+# ### Structure View after refinement
+#
+# Tb, Ti and O1 were refined with anisotropic displacements (`Uani`), so the
+# ADP view now draws them as probability ellipsoids, while O2 stayed isotropic
+# (`Uiso`) and remains a sphere — highlighting how the view changed from the
+# initial spheres to ellipsoids.
+
+# %%
+project.display.structure(struct_name='tbti')
+
 # %% [markdown]
 # ## Step 6: Generate Report
 

From 37223a40390db0ae1150e6569d517c1757883bf0 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 19:27:28 +0200
Subject: [PATCH 058/160] Add colour-scheme selector to the structure view

---
 .../display/structure/renderers/threejs.py    |  7 +++
 .../structure/templates/structure.html.j2     | 56 +++++++++++++++++--
 2 files changed, 59 insertions(+), 4 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 4c6a86815..03f4ce134 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -12,7 +12,9 @@
 from jinja2 import Environment
 from jinja2 import PackageLoader
 
+from easydiffraction.display.structure.assets.colors import color_for
 from easydiffraction.display.structure.assets.colors import theme_colors
+from easydiffraction.display.structure.enums import ColorSchemeEnum
 from easydiffraction.display.structure.renderers.base import StructureRendererBase
 from easydiffraction.display.structure.scene import StructureScene
 from easydiffraction.utils._vendored.theme_detect import is_dark
@@ -102,6 +104,11 @@ def _scene_payload(scene: StructureScene) -> dict:
         'axes': axes,
         'labels': [{'anchor': label.anchor, 'text': label.text} for label in scene.labels],
         'legend': [{'symbol': entry.symbol, 'colour': entry.colour} for entry in scene.legend],
+        'palettes': {
+            scheme.value: {entry.symbol: color_for(entry.symbol, scheme.value)
+                           for entry in scene.legend}
+            for scheme in ColorSchemeEnum
+        },
     }
 
 
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 1b03e3657..e324275c6 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -31,6 +31,10 @@
   #{{ container_id }} .mb.lt { font: 700 15px/1 Georgia, 'Times New Roman', serif; }
   #{{ container_id }} .mb.tog { color: #b9bdc6; }
   #{{ container_id }} .mb.tog.on { color: #2a3f5f; background: #e7ecf5; border-color: #c6d0e2; }
+  #{{ container_id }} .mb-select {
+    height: 30px; border: 1px solid #dcdcdc; border-radius: 6px; background: #f5f5f6;
+    color: #2a3f5f; font-size: 12px; padding: 0 4px; cursor: pointer;
+  }
   #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; text-align: left; }
   #{{ container_id }} .cv-legend .sw {
     display: inline-block; width: 11px; height: 11px; border-radius: 50%;
@@ -84,6 +88,8 @@ const tooltip = root.querySelector('.cv-tooltip');
 const col = (rgb) => new THREE.Color(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255);
 const vec = (xyz) => new THREE.Vector3(xyz[0], xyz[1], xyz[2]);
 const rgbCss = (rgb) => `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
+const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
+const PALETTES = SCENE.palettes || {};
 
 let width = host.clientWidth || 640;
 let height = host.clientHeight || 480;
@@ -123,20 +129,23 @@ for (const a of SCENE.atoms) {
   mesh.position.copy(vec(a.centre));
   mesh.scale.setScalar(a.radius);
   mesh.userData.label = a.label;
+  mesh.userData.element = elementOf(a.label);
   groups.atoms.add(mesh);
 }
 
 for (const s of SCENE.wedgeSpheres) {
   let phi = 0;
-  for (const w of s.wedges) {
+  const parts = s.label.split('/');
+  s.wedges.forEach((w, i) => {
     const span = w.fraction * Math.PI * 2;
     const geo = new THREE.SphereGeometry(s.radius, Math.max(6, Math.round(48 * w.fraction)), 16, phi, span);
     const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(w.colour), side: THREE.DoubleSide }));
     mesh.position.copy(vec(s.centre));
     mesh.userData.label = s.label;
+    mesh.userData.element = parts[i] || null;   // null for the vacancy wedge
     groups.atoms.add(mesh);
     phi += span;
-  }
+  });
 }
 
 for (const e of SCENE.ellipsoids) {
@@ -146,6 +155,7 @@ for (const e of SCENE.ellipsoids) {
   const basis = new THREE.Matrix4().makeBasis(vec(e.orientation[0]), vec(e.orientation[1]), vec(e.orientation[2]));
   mesh.quaternion.setFromRotationMatrix(basis);
   mesh.userData.label = e.label;
+  mesh.userData.element = elementOf(e.label);
   groups.atoms.add(mesh);
 }
 
@@ -341,7 +351,8 @@ if (hasFeatureToggle) {
   modebar.appendChild(featureGroup);
 }
 
-const addLegendItem = (background, text) => {
+const legendSwatches = [];
+const addLegendItem = (background, text, symbol) => {
   const item = document.createElement('div');
   const swatch = document.createElement('span');
   swatch.className = 'sw';
@@ -349,13 +360,50 @@ const addLegendItem = (background, text) => {
   item.appendChild(swatch);
   item.appendChild(document.createTextNode(text));
   legend.appendChild(item);
+  if (symbol) legendSwatches.push({ symbol, el: swatch });
 };
 
 // One solid swatch per distinct element, mirroring the PDF report legend.
-for (const entry of SCENE.legend) addLegendItem(rgbCss(entry.colour), entry.symbol);
+for (const entry of SCENE.legend) addLegendItem(rgbCss(entry.colour), entry.symbol, entry.symbol);
 
 if (!legend.children.length) legend.style.display = 'none';
 
+// Colour-scheme selector: recolours atoms and legend swatches live. The
+// crystallography stays in Python; the JS only picks a pre-computed palette.
+const schemeNames = Object.keys(PALETTES);
+if (schemeNames.length > 1 && SCENE.legend.length) {
+  const matches = (a, b) => a && b && a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+  const first = SCENE.legend[0];
+  let current = schemeNames.find((name) => matches(PALETTES[name][first.symbol], first.colour))
+    || schemeNames[0];
+  const applyScheme = (name) => {
+    const palette = PALETTES[name] || {};
+    groups.atoms.traverse((obj) => {
+      if (obj.isMesh && palette[obj.userData.element]) {
+        obj.material.color.copy(col(palette[obj.userData.element]));
+      }
+    });
+    for (const { symbol, el } of legendSwatches) {
+      if (palette[symbol]) el.style.background = rgbCss(palette[symbol]);
+    }
+  };
+  const select = document.createElement('select');
+  select.className = 'mb-select';
+  select.title = 'Colour scheme';
+  for (const name of schemeNames) {
+    const opt = document.createElement('option');
+    opt.value = name;
+    opt.textContent = name;
+    opt.selected = name === current;
+    select.appendChild(opt);
+  }
+  select.addEventListener('change', () => applyScheme(select.value));
+  const schemeGroup = document.createElement('div');
+  schemeGroup.className = 'mb-grp';
+  schemeGroup.appendChild(select);
+  modebar.appendChild(schemeGroup);
+}
+
 const raycaster = new THREE.Raycaster();
 const pointer = new THREE.Vector2();
 renderer.domElement.addEventListener('pointermove', (event) => {

From 0bac3cbd46fae3af70c259dd356b72e0eb5b6802 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 20:49:05 +0200
Subject: [PATCH 059/160] Render atoms by ADP shape with relative-proportion
 wedges

---
 .../display/structure/builder.py              | 86 +++++++++++--------
 .../display/structure/renderers/raster.py     |  3 +-
 .../display/structure/renderers/threejs.py    |  1 +
 .../display/structure/scene.py                |  7 +-
 .../structure/templates/structure.html.j2     | 24 ++++--
 5 files changed, 77 insertions(+), 44 deletions(-)

diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 830037d0d..13199cfe8 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -22,7 +22,6 @@
 from easydiffraction.crystallography import crystallography as ecr
 from easydiffraction.datablocks.structure.categories.atom_sites.enums import AdpTypeEnum
 from easydiffraction.display.structure.assets.colors import AXIS_COLORS
-from easydiffraction.display.structure.assets.colors import VACANCY_COLOR
 from easydiffraction.display.structure.assets.colors import color_for
 from easydiffraction.display.structure.assets.radii import radius_for
 from easydiffraction.display.structure.enums import AtomViewEnum
@@ -151,10 +150,13 @@ def _display_radius(model_radius: float, style) -> float:
     return style.atom_scale.value * float(np.sqrt(model_radius))
 
 
-def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
-    """Build the sphere/ellipsoid primitive for a single full-occupancy atom."""
+def _atom_shape(atom, *, style, matrix, cell, aniso_collection):
+    """Return an atom's ADP-driven shape and the radius-substitution flag.
+
+    The shape is ``('ellipsoid', semi_axes, orientation)`` for an anisotropic
+    atom in the ADP view, otherwise ``('sphere', radius)``.
+    """
     element = _element_symbol(atom.type_symbol.value)
-    colour = color_for(element, style.color_scheme.value)
     view = AtomViewEnum(style.atom_view.value)
     radius, substituted = radius_for(element, view.radius_model())
     ball_radius = _display_radius(radius, style)
@@ -165,57 +167,68 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
             and label in aniso_collection:
         u_cart = _cartesian_u(atom, aniso_collection[label], matrix, cell)
         semi, orient = ecr.adp_principal_axes(u_cart)
-        primitive = AdpEllipsoid(
-            _vec3(centre), _vec3(semi * scale),
-            tuple(_vec3(orient[:, i]) for i in range(3)), colour, label,
-        )
+        shape = ('ellipsoid', _vec3(semi * scale),
+                 tuple(_vec3(orient[:, i]) for i in range(3)))
     elif view.is_adp and adp_type in {AdpTypeEnum.UISO, AdpTypeEnum.BISO}:
         u_iso = atom.adp_iso.value
         if adp_type is AdpTypeEnum.BISO:
             u_iso = u_iso / EIGHT_PI_SQ
         iso_radius = float(np.sqrt(max(u_iso, 0.0))) * scale
-        primitive = AtomSphere(_vec3(centre), iso_radius or ball_radius, colour, label)
+        shape = ('sphere', iso_radius or ball_radius)
     else:
-        primitive = AtomSphere(_vec3(centre), ball_radius, colour, label)
-    return _SceneAtom(primitive, centre, element, colour, label), substituted
+        shape = ('sphere', ball_radius)
+    return shape, substituted
 
 
-def _wedge_sphere(rows, centre, *, style):
-    """Build an occupancy-wedge sphere for coincident atom-site rows."""
-    total = sum(occ for _, occ, _, _, _ in rows)
-    wedges = []
-    if total >= 1.0:
-        wedges = [OccupancyWedge(occ / total, colour) for _, occ, _, colour, _ in rows]
+def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
+    """Build a solid sphere/ellipsoid primitive for a single atom."""
+    element = _element_symbol(atom.type_symbol.value)
+    colour = color_for(element, style.color_scheme.value)
+    shape, substituted = _atom_shape(
+        atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection,
+    )
+    if shape[0] == 'ellipsoid':
+        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], colour, atom.label.value)
     else:
-        wedges = [OccupancyWedge(occ, colour) for _, occ, _, colour, _ in rows]
-        wedges.append(OccupancyWedge(1.0 - total, VACANCY_COLOR))
-    radius = _display_radius(max(radius for _, _, _, _, radius in rows), style)
-    major = max(rows, key=lambda r: r[1])
+        primitive = AtomSphere(_vec3(centre), shape[1], colour, atom.label.value)
+    return _SceneAtom(primitive, centre, element, colour, atom.label.value), substituted
+
+
+def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection):
+    """Build a shared-site primitive: the major atom's ADP shape split into
+    relative-proportion colour wedges (absolute occupancy ignored)."""
+    total = sum(occ for _, occ, _, _, _ in rows) or 1.0
+    wedges = tuple(OccupancyWedge(occ / total, colour) for _, occ, _, colour, _ in rows)
+    major_atom, _occ, major_element, major_colour, _radius = max(rows, key=lambda r: r[1])
     label = '/'.join(r[0].label.value for r in rows)
-    primitive = OccupancyWedgeSphere(_vec3(centre), radius, tuple(wedges), label)
-    return _SceneAtom(primitive, centre, major[2], major[3], label)
+    shape, _ = _atom_shape(
+        major_atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection,
+    )
+    if shape[0] == 'ellipsoid':
+        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], major_colour, label, wedges)
+    else:
+        primitive = OccupancyWedgeSphere(_vec3(centre), shape[1], wedges, label)
+    return _SceneAtom(primitive, centre, major_element, major_colour, label)
 
 
 def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
     """Return the scene atoms (one per position cluster) and substitutions."""
     scene_atoms = []
     substitutions: set = set()
+    radius_model = AtomViewEnum(style.atom_view.value).radius_model()
     for members in clusters.values():
         centre = ecr.fractional_to_cartesian(members[0][1], matrix)
         if len(members) == 1:
             atom = sites[members[0][0]]
-            occ = atom.occupancy.value
-            if occ >= 1.0 - IDENTITY_TOL:
-                scene_atom, substituted = _atom_primitive(
-                    atom, centre, style=style, matrix=matrix, cell=cell,
-                    aniso_collection=aniso_collection,
-                )
-                scene_atoms.append(scene_atom)
-                if substituted:
-                    substitutions.add(_element_symbol(atom.type_symbol.value))
-                continue
+            scene_atom, substituted = _atom_primitive(
+                atom, centre, style=style, matrix=matrix, cell=cell,
+                aniso_collection=aniso_collection,
+            )
+            scene_atoms.append(scene_atom)
+            if substituted:
+                substitutions.add(_element_symbol(atom.type_symbol.value))
+            continue
         rows = []
-        radius_model = AtomViewEnum(style.atom_view.value).radius_model()
         for idx, _ in members:
             atom = sites[idx]
             element = _element_symbol(atom.type_symbol.value)
@@ -224,7 +237,10 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
             rows.append((atom, atom.occupancy.value, element, colour, radius))
             if substituted:
                 substitutions.add(element)
-        scene_atoms.append(_wedge_sphere(rows, centre, style=style))
+        scene_atoms.append(_wedge_atom(
+            rows, centre, style=style, matrix=matrix, cell=cell,
+            aniso_collection=aniso_collection,
+        ))
     return scene_atoms, substitutions
 
 
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 3143029f3..47bb7b351 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -311,7 +311,8 @@ def _ellipsoid(colour, depth, project, scale, basis, ell) -> None:
             (nx * view_dir[0] + ny * view_dir[1] + nz * view_dir[2]) / norm,
         ), axis=-1)
         intensity = _diffuse_intensity(normal)[..., None]
-        shade = np.clip(np.asarray(ell.colour, dtype=np.float32) / 255.0 * intensity, 0, 1)
+        base_rgb = RasterStructureRenderer._base_colours(xs - cx, ys - cy, ell.colour, ell.wedges)
+        shade = np.clip(base_rgb * intensity, 0, 1)
         sub[update] = surf_depth[update]
         colour[y0:y1, x0:x1][update] = shade[update]
 
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 03f4ce134..d88e2d81c 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -88,6 +88,7 @@ def _scene_payload(scene: StructureScene) -> dict:
                 'orientation': [list(row) for row in e.orientation],
                 'colour': e.colour,
                 'label': e.label,
+                'wedges': [{'fraction': w.fraction, 'colour': w.colour} for w in e.wedges],
             }
             for e in scene.ellipsoids
         ],
diff --git a/src/easydiffraction/display/structure/scene.py b/src/easydiffraction/display/structure/scene.py
index 9c686e393..836135e7f 100644
--- a/src/easydiffraction/display/structure/scene.py
+++ b/src/easydiffraction/display/structure/scene.py
@@ -50,13 +50,18 @@ class OccupancyWedgeSphere:
 
 @dataclass(frozen=True, slots=True)
 class AdpEllipsoid:
-    """An anisotropic ADP probability ellipsoid for one atom."""
+    """An anisotropic ADP probability ellipsoid for one atom.
+
+    ``wedges`` splits a shared site into relative-proportion colour wedges
+    (empty for a single atom, which uses ``colour``).
+    """
 
     centre: Vec3
     semi_axes: Vec3
     orientation: Mat3
     colour: Rgb
     label: str
+    wedges: tuple[OccupancyWedge, ...] = ()
 
 
 @dataclass(frozen=True, slots=True)
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index e324275c6..582f120d7 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -149,14 +149,24 @@ for (const s of SCENE.wedgeSpheres) {
 }
 
 for (const e of SCENE.ellipsoids) {
-  const mesh = new THREE.Mesh(unitSphere, new THREE.MeshStandardMaterial({ color: col(e.colour) }));
-  mesh.position.copy(vec(e.centre));
-  mesh.scale.set(e.semiAxes[0], e.semiAxes[1], e.semiAxes[2]);
   const basis = new THREE.Matrix4().makeBasis(vec(e.orientation[0]), vec(e.orientation[1]), vec(e.orientation[2]));
-  mesh.quaternion.setFromRotationMatrix(basis);
-  mesh.userData.label = e.label;
-  mesh.userData.element = elementOf(e.label);
-  groups.atoms.add(mesh);
+  const quat = new THREE.Quaternion().setFromRotationMatrix(basis);
+  const split = e.wedges && e.wedges.length;
+  const wedges = split ? e.wedges : [{ fraction: 1, colour: e.colour }];
+  const parts = e.label.split('/');
+  let phi = 0;
+  wedges.forEach((w, i) => {
+    const span = w.fraction * Math.PI * 2;
+    const geo = new THREE.SphereGeometry(1, Math.max(6, Math.round(48 * w.fraction)), 16, phi, span);
+    const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(w.colour), side: THREE.DoubleSide }));
+    mesh.position.copy(vec(e.centre));
+    mesh.scale.set(e.semiAxes[0], e.semiAxes[1], e.semiAxes[2]);
+    mesh.quaternion.copy(quat);
+    mesh.userData.label = e.label;
+    mesh.userData.element = split ? (parts[i] || null) : elementOf(e.label);
+    groups.atoms.add(mesh);
+    phi += span;
+  });
 }
 
 const addHalfBond = (p0, p1, colour) => {

From 61f52702d9c35126718a61ee814dd0be6338e774 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 21:26:07 +0200
Subject: [PATCH 060/160] Fix anisotropic ADP orientation and reciprocal c-axis

---
 .../display/structure/builder.py              | 60 ++++++++++++-------
 1 file changed, 37 insertions(+), 23 deletions(-)

diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 13199cfe8..1b4f87d34 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -91,7 +91,7 @@ def _reciprocal_lengths(cell) -> np.ndarray:
     al, be, ga = np.radians([alpha, beta, gamma])
     ca, cb, cg = np.cos([al, be, ga])
     omega = np.sqrt(1.0 - ca * ca - cb * cb - cg * cg + 2.0 * ca * cb * cg)
-    return np.array([np.sin(al) / (a * omega), np.sin(be) / (b * omega), np.sin(cg) / (c * omega)])
+    return np.array([np.sin(al) / (a * omega), np.sin(be) / (b * omega), np.sin(ga) / (c * omega)])
 
 
 def _lattice_shifts(pos: np.ndarray, view_range):
@@ -110,30 +110,39 @@ def _pos_key(pos: np.ndarray) -> tuple[int, int, int]:
 
 
 def _expand_positions(sites, ops, view_range):
-    """Generate (row_index, fractional position) for every in-range copy."""
+    """Generate (row_index, fractional position, rotation) for each in-range copy.
+
+    The symmetry rotation is kept so an anisotropic ADP tensor can be rotated
+    onto each equivalent site (otherwise every copy reuses one orientation).
+    """
     generated = []
     for idx, atom in enumerate(sites):
         base = np.array([atom.fract_x.value, atom.fract_y.value, atom.fract_z.value], dtype=float)
         for rot, trans in ops:
             image = rot @ base + trans
             for shift in _lattice_shifts(image, view_range):
-                generated.append((idx, image + shift))
+                generated.append((idx, image + shift, rot))
     return generated
 
 
 def _group_by_position(generated):
     """Dedup scene atoms (row + position) and cluster coincident positions."""
     seen: dict = {}
-    for idx, pos in generated:
-        seen.setdefault((idx, _pos_key(pos)), (idx, pos))
+    for idx, pos, rot in generated:
+        seen.setdefault((idx, _pos_key(pos)), (idx, pos, rot))
     clusters: dict = {}
-    for idx, pos in seen.values():
-        clusters.setdefault(_pos_key(pos), []).append((idx, pos))
+    for idx, pos, rot in seen.values():
+        clusters.setdefault(_pos_key(pos), []).append((idx, pos, rot))
     return clusters
 
 
-def _cartesian_u(atom, aniso, matrix: np.ndarray, cell) -> np.ndarray:
-    """Cartesian U tensor for an anisotropic atom (CIF U^ij convention)."""
+def _cartesian_u(atom, aniso, matrix: np.ndarray, cell, rot: np.ndarray) -> np.ndarray:
+    """Cartesian U tensor for an anisotropic atom (CIF U^ij convention).
+
+    ``rot`` is the fractional symmetry rotation that placed this copy; the
+    tensor is rotated onto the copy in Cartesian space so each equivalent
+    site shows the correctly oriented ellipsoid.
+    """
     comps = np.array([
         [aniso.adp_11.value, aniso.adp_12.value, aniso.adp_13.value],
         [aniso.adp_12.value, aniso.adp_22.value, aniso.adp_23.value],
@@ -142,7 +151,9 @@ def _cartesian_u(atom, aniso, matrix: np.ndarray, cell) -> np.ndarray:
     if AdpTypeEnum(atom.adp_type.value) is AdpTypeEnum.BANI:
         comps = comps / EIGHT_PI_SQ
     mn = matrix @ np.diag(_reciprocal_lengths(cell))
-    return mn @ comps @ mn.T
+    u_cart = mn @ comps @ mn.T
+    r_cart = matrix @ rot @ np.linalg.inv(matrix)
+    return r_cart @ u_cart @ r_cart.T
 
 
 def _display_radius(model_radius: float, style) -> float:
@@ -150,11 +161,12 @@ def _display_radius(model_radius: float, style) -> float:
     return style.atom_scale.value * float(np.sqrt(model_radius))
 
 
-def _atom_shape(atom, *, style, matrix, cell, aniso_collection):
+def _atom_shape(atom, *, style, matrix, cell, aniso_collection, rot):
     """Return an atom's ADP-driven shape and the radius-substitution flag.
 
     The shape is ``('ellipsoid', semi_axes, orientation)`` for an anisotropic
-    atom in the ADP view, otherwise ``('sphere', radius)``.
+    atom in the ADP view, otherwise ``('sphere', radius)``. ``rot`` is the
+    symmetry rotation placing this copy (identity for the reference atom).
     """
     element = _element_symbol(atom.type_symbol.value)
     view = AtomViewEnum(style.atom_view.value)
@@ -165,7 +177,7 @@ def _atom_shape(atom, *, style, matrix, cell, aniso_collection):
     scale = float(chi.ppf(style.adp_probability.value, 3))
     if view.is_adp and adp_type in {AdpTypeEnum.UANI, AdpTypeEnum.BANI} \
             and label in aniso_collection:
-        u_cart = _cartesian_u(atom, aniso_collection[label], matrix, cell)
+        u_cart = _cartesian_u(atom, aniso_collection[label], matrix, cell, rot)
         semi, orient = ecr.adp_principal_axes(u_cart)
         shape = ('ellipsoid', _vec3(semi * scale),
                  tuple(_vec3(orient[:, i]) for i in range(3)))
@@ -180,12 +192,12 @@ def _atom_shape(atom, *, style, matrix, cell, aniso_collection):
     return shape, substituted
 
 
-def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
+def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection, rot):
     """Build a solid sphere/ellipsoid primitive for a single atom."""
     element = _element_symbol(atom.type_symbol.value)
     colour = color_for(element, style.color_scheme.value)
     shape, substituted = _atom_shape(
-        atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection,
+        atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection, rot=rot,
     )
     if shape[0] == 'ellipsoid':
         primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], colour, atom.label.value)
@@ -197,12 +209,13 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection):
 def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection):
     """Build a shared-site primitive: the major atom's ADP shape split into
     relative-proportion colour wedges (absolute occupancy ignored)."""
-    total = sum(occ for _, occ, _, _, _ in rows) or 1.0
-    wedges = tuple(OccupancyWedge(occ / total, colour) for _, occ, _, colour, _ in rows)
-    major_atom, _occ, major_element, major_colour, _radius = max(rows, key=lambda r: r[1])
+    total = sum(occ for _, occ, _, _, _, _ in rows) or 1.0
+    wedges = tuple(OccupancyWedge(occ / total, colour) for _, occ, _, colour, _, _ in rows)
+    major_atom, _occ, major_element, major_colour, _radius, major_rot = max(rows, key=lambda r: r[1])
     label = '/'.join(r[0].label.value for r in rows)
     shape, _ = _atom_shape(
-        major_atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection,
+        major_atom, style=style, matrix=matrix, cell=cell,
+        aniso_collection=aniso_collection, rot=major_rot,
     )
     if shape[0] == 'ellipsoid':
         primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], major_colour, label, wedges)
@@ -219,22 +232,23 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
     for members in clusters.values():
         centre = ecr.fractional_to_cartesian(members[0][1], matrix)
         if len(members) == 1:
-            atom = sites[members[0][0]]
+            idx, _pos, rot = members[0]
+            atom = sites[idx]
             scene_atom, substituted = _atom_primitive(
                 atom, centre, style=style, matrix=matrix, cell=cell,
-                aniso_collection=aniso_collection,
+                aniso_collection=aniso_collection, rot=rot,
             )
             scene_atoms.append(scene_atom)
             if substituted:
                 substitutions.add(_element_symbol(atom.type_symbol.value))
             continue
         rows = []
-        for idx, _ in members:
+        for idx, _pos, rot in members:
             atom = sites[idx]
             element = _element_symbol(atom.type_symbol.value)
             colour = color_for(element, style.color_scheme.value)
             radius, substituted = radius_for(element, radius_model)
-            rows.append((atom, atom.occupancy.value, element, colour, radius))
+            rows.append((atom, atom.occupancy.value, element, colour, radius, rot))
             if substituted:
                 substitutions.add(element)
         scene_atoms.append(_wedge_atom(

From e4c42bb52626cd8b047c8dbda0da546273c114fd Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 21:26:07 +0200
Subject: [PATCH 061/160] Speed up structure-view zoom; stack the hint in three
 rows

---
 .../display/structure/templates/structure.html.j2             | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 582f120d7..f72d3e0bc 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -4,7 +4,7 @@
   <div class="cv-canvas" style="position:absolute;inset:0;"></div>
   <div class="cv-modebar cv-card"></div>
   <div class="cv-legend cv-card"></div>
-  <div class="cv-hint">drag = rotate&nbsp;&middot;&nbsp;wheel = zoom&nbsp;&middot;&nbsp;right-drag = pan</div>
+  <div class="cv-hint">drag = rotate<br>wheel = zoom<br>right-drag = pan</div>
   <div class="cv-tooltip"></div>
 </div>
 
@@ -43,6 +43,7 @@
   #{{ container_id }} .cv-hint {
     position: absolute; z-index: 10; bottom: 8px; left: 10px; font-size: 11px;
     color: #555; background: rgba(255, 255, 255, 0.82); padding: 5px 9px; border-radius: 6px;
+    line-height: 1.5; text-align: left;
   }
   #{{ container_id }} .cv-tooltip {
     position: absolute; z-index: 30; pointer-events: none; display: none;
@@ -277,6 +278,7 @@ let projection = 'orthographic';
 const controls = new OrbitControls(camera, renderer.domElement);
 controls.enableDamping = true;
 controls.dampingFactor = 0.08;
+controls.zoomSpeed = 3.0;   // larger wheel/touchpad zoom steps (tune to taste)
 controls.target.copy(target);
 controls.update();
 

From 217d13392250824aad361ccba40286f484939e4c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 21:44:44 +0200
Subject: [PATCH 062/160] Add specular highlights to the raster structure
 figure

---
 .../display/structure/renderers/raster.py           | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 47bb7b351..e81a76f43 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -27,6 +27,10 @@
 _LIGHT = _LIGHT / np.linalg.norm(_LIGHT)
 _FILL = np.array([-0.42, -0.25, -0.5])  # back-fill, mirrors the Three.js fill light
 _FILL = _FILL / np.linalg.norm(_FILL)
+_HALF = _LIGHT + np.array([0.0, 0.0, 1.0])  # Blinn-Phong half-vector (view = toward camera)
+_HALF = _HALF / np.linalg.norm(_HALF)
+_SHININESS = 30.0  # specular exponent (tight bright highlight, VESTA-like)
+_SPEC_STRENGTH = 0.55
 _LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
 _LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
 # Axis-arrow proportions, as fractions of the arrow length (match the Three.js
@@ -65,6 +69,11 @@ def _diffuse_intensity(normal: np.ndarray) -> np.ndarray:
     return np.clip(_AMBIENT + (1.0 - _AMBIENT) * (key + fill), 0.0, 1.0)
 
 
+def _specular(normal: np.ndarray) -> np.ndarray:
+    """Blinn-Phong specular highlight for a unit surface-normal field."""
+    return _SPEC_STRENGTH * np.clip(normal @ _HALF, 0.0, 1.0) ** _SHININESS
+
+
 def _font(pixels: int) -> ImageFont.FreeTypeFont:
     """Return the scalable default font at the requested pixel size."""
     from PIL import ImageFont  # noqa: PLC0415
@@ -239,7 +248,7 @@ def _sphere(colour, depth, project, scale, centre, radius, base, *, wedges=None)
         normal = np.stack((dx, -dy, nz), axis=-1)
         intensity = _diffuse_intensity(normal)[..., None]
         base_rgb = RasterStructureRenderer._base_colours(dx, dy, base, wedges)
-        shade = np.clip(base_rgb * intensity, 0, 1)
+        shade = np.clip(base_rgb * intensity + _specular(normal)[..., None], 0, 1)
         sub[update] = surf_depth[update]
         colour[y0:y1, x0:x1][update] = shade[update]
 
@@ -312,7 +321,7 @@ def _ellipsoid(colour, depth, project, scale, basis, ell) -> None:
         ), axis=-1)
         intensity = _diffuse_intensity(normal)[..., None]
         base_rgb = RasterStructureRenderer._base_colours(xs - cx, ys - cy, ell.colour, ell.wedges)
-        shade = np.clip(base_rgb * intensity, 0, 1)
+        shade = np.clip(base_rgb * intensity + _specular(normal)[..., None], 0, 1)
         sub[update] = surf_depth[update]
         colour[y0:y1, x0:x1][update] = shade[update]
 

From 71986d384cda92736e7ae23e58f017dae8bf1137 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sat, 30 May 2026 21:44:44 +0200
Subject: [PATCH 063/160] Add HTML specular, bond recolour and asymmetric-unit
 toggle

---
 .../display/structure/builder.py              | 40 +++++++++------
 .../display/structure/renderers/threejs.py    |  7 ++-
 .../display/structure/scene.py                |  5 ++
 .../structure/templates/structure.html.j2     | 49 ++++++++++++++-----
 4 files changed, 73 insertions(+), 28 deletions(-)

diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 1b4f87d34..14bac9f0b 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -116,23 +116,26 @@ def _expand_positions(sites, ops, view_range):
     onto each equivalent site (otherwise every copy reuses one orientation).
     """
     generated = []
+    identity = np.eye(3)
     for idx, atom in enumerate(sites):
         base = np.array([atom.fract_x.value, atom.fract_y.value, atom.fract_z.value], dtype=float)
         for rot, trans in ops:
             image = rot @ base + trans
+            reference_op = bool(np.allclose(rot, identity) and np.allclose(trans, 0.0))
             for shift in _lattice_shifts(image, view_range):
-                generated.append((idx, image + shift, rot))
+                is_au = reference_op and bool(np.allclose(shift, 0.0))
+                generated.append((idx, image + shift, rot, is_au))
     return generated
 
 
 def _group_by_position(generated):
     """Dedup scene atoms (row + position) and cluster coincident positions."""
     seen: dict = {}
-    for idx, pos, rot in generated:
-        seen.setdefault((idx, _pos_key(pos)), (idx, pos, rot))
+    for idx, pos, rot, is_au in generated:
+        seen.setdefault((idx, _pos_key(pos)), (idx, pos, rot, is_au))
     clusters: dict = {}
-    for idx, pos, rot in seen.values():
-        clusters.setdefault(_pos_key(pos), []).append((idx, pos, rot))
+    for idx, pos, rot, is_au in seen.values():
+        clusters.setdefault(_pos_key(pos), []).append((idx, pos, rot, is_au))
     return clusters
 
 
@@ -192,7 +195,7 @@ def _atom_shape(atom, *, style, matrix, cell, aniso_collection, rot):
     return shape, substituted
 
 
-def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection, rot):
+def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection, rot, asymmetric):
     """Build a solid sphere/ellipsoid primitive for a single atom."""
     element = _element_symbol(atom.type_symbol.value)
     colour = color_for(element, style.color_scheme.value)
@@ -200,13 +203,15 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection, rot)
         atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection, rot=rot,
     )
     if shape[0] == 'ellipsoid':
-        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], colour, atom.label.value)
+        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], colour,
+                                 atom.label.value, asymmetric=asymmetric)
     else:
-        primitive = AtomSphere(_vec3(centre), shape[1], colour, atom.label.value)
+        primitive = AtomSphere(_vec3(centre), shape[1], colour, atom.label.value,
+                               asymmetric=asymmetric)
     return _SceneAtom(primitive, centre, element, colour, atom.label.value), substituted
 
 
-def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection):
+def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection, asymmetric):
     """Build a shared-site primitive: the major atom's ADP shape split into
     relative-proportion colour wedges (absolute occupancy ignored)."""
     total = sum(occ for _, occ, _, _, _, _ in rows) or 1.0
@@ -218,9 +223,10 @@ def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection):
         aniso_collection=aniso_collection, rot=major_rot,
     )
     if shape[0] == 'ellipsoid':
-        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], major_colour, label, wedges)
+        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], major_colour,
+                                 label, wedges, asymmetric)
     else:
-        primitive = OccupancyWedgeSphere(_vec3(centre), shape[1], wedges, label)
+        primitive = OccupancyWedgeSphere(_vec3(centre), shape[1], wedges, label, asymmetric)
     return _SceneAtom(primitive, centre, major_element, major_colour, label)
 
 
@@ -231,19 +237,20 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
     radius_model = AtomViewEnum(style.atom_view.value).radius_model()
     for members in clusters.values():
         centre = ecr.fractional_to_cartesian(members[0][1], matrix)
+        cluster_au = any(member[3] for member in members)
         if len(members) == 1:
-            idx, _pos, rot = members[0]
+            idx, _pos, rot, _au = members[0]
             atom = sites[idx]
             scene_atom, substituted = _atom_primitive(
                 atom, centre, style=style, matrix=matrix, cell=cell,
-                aniso_collection=aniso_collection, rot=rot,
+                aniso_collection=aniso_collection, rot=rot, asymmetric=cluster_au,
             )
             scene_atoms.append(scene_atom)
             if substituted:
                 substitutions.add(_element_symbol(atom.type_symbol.value))
             continue
         rows = []
-        for idx, _pos, rot in members:
+        for idx, _pos, rot, _au in members:
             atom = sites[idx]
             element = _element_symbol(atom.type_symbol.value)
             colour = color_for(element, style.color_scheme.value)
@@ -253,7 +260,7 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
                 substitutions.add(element)
         scene_atoms.append(_wedge_atom(
             rows, centre, style=style, matrix=matrix, cell=cell,
-            aniso_collection=aniso_collection,
+            aniso_collection=aniso_collection, asymmetric=cluster_au,
         ))
     return scene_atoms, substitutions
 
@@ -277,7 +284,8 @@ def _build_bonds(scene_atoms, geom_min: float, geom_incr: float):
             covalent_cutoff = radii[i] + radii[j] + geom_incr
             if geom_min <= distance <= min(covalent_cutoff, shell):
                 bonds.append(Bond(_vec3(atom_i.centre), _vec3(atom_j.centre),
-                                  atom_i.colour, atom_j.colour))
+                                  atom_i.colour, atom_j.colour,
+                                  atom_i.element, atom_j.element))
     return bonds
 
 
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index d88e2d81c..45f5d6a31 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -69,7 +69,8 @@ def _scene_payload(scene: StructureScene) -> dict:
         edges = [{'start': edge.start, 'end': edge.end} for edge in scene.cell_edges.edges]
     return {
         'atoms': [
-            {'centre': a.centre, 'radius': a.radius, 'colour': a.colour, 'label': a.label}
+            {'centre': a.centre, 'radius': a.radius, 'colour': a.colour, 'label': a.label,
+             'asymmetric': a.asymmetric}
             for a in scene.atoms
         ],
         'wedgeSpheres': [
@@ -78,6 +79,7 @@ def _scene_payload(scene: StructureScene) -> dict:
                 'radius': s.radius,
                 'label': s.label,
                 'wedges': [{'fraction': w.fraction, 'colour': w.colour} for w in s.wedges],
+                'asymmetric': s.asymmetric,
             }
             for s in scene.occupancy_spheres
         ],
@@ -89,6 +91,7 @@ def _scene_payload(scene: StructureScene) -> dict:
                 'colour': e.colour,
                 'label': e.label,
                 'wedges': [{'fraction': w.fraction, 'colour': w.colour} for w in e.wedges],
+                'asymmetric': e.asymmetric,
             }
             for e in scene.ellipsoids
         ],
@@ -98,6 +101,8 @@ def _scene_payload(scene: StructureScene) -> dict:
                 'end': b.end,
                 'startColour': b.start_colour,
                 'endColour': b.end_colour,
+                'startElement': b.start_element,
+                'endElement': b.end_element,
             }
             for b in scene.bonds
         ],
diff --git a/src/easydiffraction/display/structure/scene.py b/src/easydiffraction/display/structure/scene.py
index 836135e7f..4df5196bb 100644
--- a/src/easydiffraction/display/structure/scene.py
+++ b/src/easydiffraction/display/structure/scene.py
@@ -28,6 +28,7 @@ class AtomSphere:
     radius: float
     colour: Rgb
     label: str
+    asymmetric: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -46,6 +47,7 @@ class OccupancyWedgeSphere:
     radius: float
     wedges: tuple[OccupancyWedge, ...]
     label: str
+    asymmetric: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -62,6 +64,7 @@ class AdpEllipsoid:
     colour: Rgb
     label: str
     wedges: tuple[OccupancyWedge, ...] = ()
+    asymmetric: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -72,6 +75,8 @@ class Bond:
     end: Vec3
     start_colour: Rgb
     end_colour: Rgb
+    start_element: str = ''
+    end_element: str = ''
 
 
 @dataclass(frozen=True, slots=True)
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index f72d3e0bc..2a9c50c6e 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -92,6 +92,13 @@ const rgbCss = (rgb) => `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
 const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
 const PALETTES = SCENE.palettes || {};
 
+// Glossy Phong material so atoms show a bright specular highlight (VESTA-like).
+const SPECULAR = new THREE.Color(0.32, 0.32, 0.32);
+const solidMat = (c, doubleSide) => new THREE.MeshPhongMaterial({
+  color: c, shininess: 60, specular: SPECULAR,
+  side: doubleSide ? THREE.DoubleSide : THREE.FrontSide,
+});
+
 let width = host.clientWidth || 640;
 let height = host.clientHeight || 480;
 
@@ -126,11 +133,12 @@ for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
 const unitSphere = new THREE.SphereGeometry(1, 24, 16);
 
 for (const a of SCENE.atoms) {
-  const mesh = new THREE.Mesh(unitSphere, new THREE.MeshStandardMaterial({ color: col(a.colour) }));
+  const mesh = new THREE.Mesh(unitSphere, solidMat(col(a.colour)));
   mesh.position.copy(vec(a.centre));
   mesh.scale.setScalar(a.radius);
   mesh.userData.label = a.label;
   mesh.userData.element = elementOf(a.label);
+  mesh.userData.asymmetric = a.asymmetric;
   groups.atoms.add(mesh);
 }
 
@@ -140,10 +148,11 @@ for (const s of SCENE.wedgeSpheres) {
   s.wedges.forEach((w, i) => {
     const span = w.fraction * Math.PI * 2;
     const geo = new THREE.SphereGeometry(s.radius, Math.max(6, Math.round(48 * w.fraction)), 16, phi, span);
-    const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(w.colour), side: THREE.DoubleSide }));
+    const mesh = new THREE.Mesh(geo, solidMat(col(w.colour), true));
     mesh.position.copy(vec(s.centre));
     mesh.userData.label = s.label;
     mesh.userData.element = parts[i] || null;   // null for the vacancy wedge
+    mesh.userData.asymmetric = s.asymmetric;
     groups.atoms.add(mesh);
     phi += span;
   });
@@ -159,33 +168,35 @@ for (const e of SCENE.ellipsoids) {
   wedges.forEach((w, i) => {
     const span = w.fraction * Math.PI * 2;
     const geo = new THREE.SphereGeometry(1, Math.max(6, Math.round(48 * w.fraction)), 16, phi, span);
-    const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(w.colour), side: THREE.DoubleSide }));
+    const mesh = new THREE.Mesh(geo, solidMat(col(w.colour), true));
     mesh.position.copy(vec(e.centre));
     mesh.scale.set(e.semiAxes[0], e.semiAxes[1], e.semiAxes[2]);
     mesh.quaternion.copy(quat);
     mesh.userData.label = e.label;
     mesh.userData.element = split ? (parts[i] || null) : elementOf(e.label);
+    mesh.userData.asymmetric = e.asymmetric;
     groups.atoms.add(mesh);
     phi += span;
   });
 }
 
-const addHalfBond = (p0, p1, colour) => {
+const addHalfBond = (p0, p1, colour, element) => {
   const direction = p1.clone().sub(p0);
   const length = direction.length();
   if (length < 1e-6) return;
   const geo = new THREE.CylinderGeometry(0.06, 0.06, length, 12);
-  const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col(colour) }));
+  const mesh = new THREE.Mesh(geo, solidMat(col(colour)));
   mesh.position.copy(p0.clone().add(p1).multiplyScalar(0.5));
   mesh.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.normalize());
+  mesh.userData.element = element || null;
   groups.bonds.add(mesh);
 };
 for (const b of SCENE.bonds) {
   const start = vec(b.start);
   const end = vec(b.end);
   const mid = start.clone().add(end).multiplyScalar(0.5);
-  addHalfBond(start, mid, b.startColour);
-  addHalfBond(mid, end, b.endColour);
+  addHalfBond(start, mid, b.startColour, b.startElement);
+  addHalfBond(mid, end, b.endColour, b.endElement);
 }
 
 const cellMaterial = new THREE.LineBasicMaterial({ color: new THREE.Color(FG) });
@@ -202,7 +213,7 @@ const buildArrow = (origin, v, colour) => {
   const headLen = length * 0.12;
   const headR = shaftR * 4;
   const shaftLen = Math.max(length - headLen, 1e-3);
-  const material = new THREE.MeshStandardMaterial({ color: col(colour) });
+  const material = solidMat(col(colour));
   const shaft = new THREE.Mesh(new THREE.CylinderGeometry(shaftR, shaftR, shaftLen, 16), material);
   shaft.position.y = shaftLen / 2;
   const head = new THREE.Mesh(new THREE.ConeGeometry(headR, headLen, 20), material);
@@ -278,7 +289,7 @@ let projection = 'orthographic';
 const controls = new OrbitControls(camera, renderer.domElement);
 controls.enableDamping = true;
 controls.dampingFactor = 0.08;
-controls.zoomSpeed = 3.0;   // larger wheel/touchpad zoom steps (tune to taste)
+controls.zoomSpeed = 20.0;   // larger wheel/touchpad zoom steps (tune to taste)
 controls.target.copy(target);
 controls.update();
 
@@ -356,6 +367,20 @@ for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
     button.classList.toggle('on', next);
   });
 }
+// Asymmetric-unit toggle: hide symmetry-equivalent copies, keep the reference atoms.
+const hasNonAU = SCENE.atoms.some((a) => !a.asymmetric)
+  || SCENE.wedgeSpheres.some((s) => !s.asymmetric)
+  || SCENE.ellipsoids.some((e) => !e.asymmetric);
+if (hasNonAU && groups.atoms.children.length) {
+  hasFeatureToggle = true;
+  let auOnly = false;
+  const auButton = iconButton(featureGroup, 'AU', 'Asymmetric unit only', 'lt tog');
+  auButton.addEventListener('click', () => {
+    auOnly = !auOnly;
+    groups.atoms.children.forEach((m) => { m.visible = !auOnly || m.userData.asymmetric; });
+    auButton.classList.toggle('on', auOnly);
+  });
+}
 if (hasFeatureToggle) {
   const separator = document.createElement('div');
   separator.className = 'mb-sep';
@@ -390,11 +415,13 @@ if (schemeNames.length > 1 && SCENE.legend.length) {
     || schemeNames[0];
   const applyScheme = (name) => {
     const palette = PALETTES[name] || {};
-    groups.atoms.traverse((obj) => {
+    const recolor = (obj) => {
       if (obj.isMesh && palette[obj.userData.element]) {
         obj.material.color.copy(col(palette[obj.userData.element]));
       }
-    });
+    };
+    groups.atoms.traverse(recolor);
+    groups.bonds.traverse(recolor);
     for (const { symbol, el } of legendSwatches) {
       if (palette[symbol]) el.style.background = rgbCss(palette[symbol]);
     }

From 956c9c2df2b4f129eda4756016719876532919b5 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 00:11:05 +0200
Subject: [PATCH 064/160] Drop atomic radius, improve rendering consistency

---
 .../crysview-structure-visualization.md       |  30 +--
 .../user-guide/analysis-workflow/model.md     |   4 +-
 .../display/structure/assets/radii.py         |   2 +-
 .../display/structure/enums.py                |   4 +-
 .../display/structure/renderers/ascii.py      |  99 ++++++----
 .../display/structure/renderers/raster.py     |  53 ++++--
 .../structure/templates/structure.html.j2     | 174 +++++++++++++-----
 .../project/categories/style/default.py       |   2 +-
 src/easydiffraction/project/display.py        |   6 +-
 9 files changed, 251 insertions(+), 123 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index af46322a8..9d17d6542 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -280,8 +280,7 @@ charge where the model needs it):
 
 - a **radius model** turns an element into a sphere radius — van der
   Waals, ionic (Shannon; the site charge where a model carries one,
-  otherwise a documented per-element default, see below), covalent, or
-  atomic/empirical;
+  otherwise a documented per-element default, see below), or covalent;
 - a **colour scheme** is a named element-colour palette — the Jmol/CPK
   scheme, the VESTA scheme, and similar well-known sets.
 
@@ -289,7 +288,7 @@ A scientist picks one model and one scheme instead of editing dozens of
 per-element rows, which keeps the view consistent and reproducible:
 
 ```python
-project.style.atom_view = 'adp'           # vdw | covalent | ionic | atomic | adp (default adp)
+project.style.atom_view = 'adp'           # vdw | covalent | ionic | adp (default adp)
 project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
 project.style.show_supported()            # accepted values per setting
 ```
@@ -299,7 +298,7 @@ How an atom is sized and shaped is a single **display-style switch**,
 surface are alternative depictions and a view shows one of them at a
 time:
 
-- `'vdw'`, `'covalent'`, `'ionic'`, `'atomic'` draw every atom as a
+- `'vdw'`, `'covalent'`, `'ionic'` draw every atom as a
   **radius-model sphere** for the named standard radius table;
   displacement parameters do not affect size. This is the familiar
   ball-and-stick depiction and works for any structure, with or without
@@ -318,12 +317,17 @@ as covalent-radius spheres.
 > **Amendment — `atom_view` merge.** An earlier design split this into
 > two settings: `atom_shape` (`ball`/`ortep`) and `radius_model`
 > (`vdw`/`covalent`/`ionic`/`atomic`). They were merged into the single
-> `atom_view` selector `{vdw, covalent, ionic, atomic, adp}` because
-> `radius_model` was meaningful only in ball mode, so the two-field form
-> carried four degenerate `ortep`×radius-model combinations. The flat
-> list removes the dead states and matches how VESTA/Mercury present the
-> choice. The `adp` view still uses covalent radii for the ball fallback
-> and for mixed-occupancy sites. CIF field: `_style.atom_view`.
+> `atom_view` selector because `radius_model` was meaningful only in ball
+> mode, so the two-field form carried four degenerate `ortep`×radius-model
+> combinations. The flat list removes the dead states and matches how
+> VESTA/Mercury present the choice. The `atomic`/empirical option was then
+> dropped, leaving `{vdw, covalent, ionic, adp}`: its radii are within a
+> few percent of `covalent` for most elements (and identical for some), so
+> after ball-size compression it was visually indistinguishable and added
+> a redundant choice. The atomic radii remain in the element database,
+> unused by the public selector. The `adp` view still uses covalent radii
+> for the ball fallback and for mixed-occupancy sites. CIF field:
+> `_style.atom_view`.
 
 In `'adp'` the surfaces are drawn at one **probability level**,
 `adp_probability`, a fraction in the open interval (0, 1) — not a
@@ -345,8 +349,8 @@ ionic A-site cations do not bond to every surrounding anion (a heuristic
 stop-gap; see open issue #108 for the full near-neighbour approach). These
 two cutoffs live on the **structure**
 and persist in the structure's own CIF (see section 8), not in
-`project.style`. The `atom_view` radius models (vdw / covalent / ionic /
-atomic) change only the rendered sphere _size_ — they never decide which
+`project.style`. The `atom_view` radius models (vdw / covalent / ionic)
+change only the rendered sphere _size_ — they never decide which
 bonds appear; bond detection is governed solely by the `_geom` cutoffs
 and the per-type bonding radius. Version 1 draws bonds computed on the
 fly from this rule while the scene is built and persists no bond table.
@@ -497,7 +501,7 @@ project.rendering_structure.type = 'auto'           # default: 'threejs' in Jupy
 project.rendering_structure.show_supported()
 
 # How: standard styling models, not per-element values (visual only)
-project.style.atom_view = 'adp'           # vdw | covalent | ionic | atomic | adp (default adp)
+project.style.atom_view = 'adp'           # vdw | covalent | ionic | adp (default adp)
 project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
 project.style.adp_probability = 0.5       # adp only; fraction in (0, 1)
 project.style.atom_scale = 0.3            # radius-model views only; size, sqrt-compressed (0, 1]
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index ef783ec5d..56e42c620 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -204,10 +204,10 @@ Visual styling — independent of the per-element data — is configured on
 project.style.show_supported()
 
 # Choose how atoms are depicted, sized, and coloured.
-# atom_view picks a radius-model ball ('vdw'/'covalent'/'ionic'/'atomic')
+# atom_view picks a radius-model ball ('vdw'/'covalent'/'ionic')
 # or 'adp' for displacement surfaces (spheres for isotropic sites,
 # ellipsoids for anisotropic ones — driven by each atom's adp_type).
-project.style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', 'atomic', or 'adp'
+project.style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', or 'adp'
 project.style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
 project.style.atom_scale = 0.3  # overall ball size (square-root compressed)
 project.style.adp_probability = 0.5  # ADP ellipsoid probability level (0–1)
diff --git a/src/easydiffraction/display/structure/assets/radii.py b/src/easydiffraction/display/structure/assets/radii.py
index 458f46f28..5ae7b11e8 100644
--- a/src/easydiffraction/display/structure/assets/radii.py
+++ b/src/easydiffraction/display/structure/assets/radii.py
@@ -23,7 +23,7 @@ def radius_for(element: str, model: str) -> tuple[float, bool]:
     element : str
         Bare element symbol, e.g. ``'Fe'``.
     model : str
-        One of ``'vdw'``, ``'covalent'``, ``'ionic'``, ``'atomic'``.
+        One of ``'vdw'``, ``'covalent'``, ``'ionic'``.
 
     Returns
     -------
diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
index 264730d77..71480ae32 100644
--- a/src/easydiffraction/display/structure/enums.py
+++ b/src/easydiffraction/display/structure/enums.py
@@ -34,14 +34,13 @@ def description(self) -> str:
 class AtomViewEnum(StrEnum):
     """How atoms are sized and shaped in the structure view.
 
-    The four radius models draw fixed balls; ``adp`` draws displacement
+    The radius models draw fixed balls; ``adp`` draws displacement
     surfaces (spheres for isotropic sites, ellipsoids for anisotropic).
     """
 
     VDW = 'vdw'
     COVALENT = 'covalent'
     IONIC = 'ionic'
-    ATOMIC = 'atomic'
     ADP = 'adp'
 
     @classmethod
@@ -71,7 +70,6 @@ def description(self) -> str:
             AtomViewEnum.VDW: 'Van der Waals radius balls',
             AtomViewEnum.COVALENT: 'Covalent radius balls',
             AtomViewEnum.IONIC: 'Ionic (Shannon) radius balls',
-            AtomViewEnum.ATOMIC: 'Atomic (empirical) radius balls',
             AtomViewEnum.ADP: 'ADP probability surfaces (spheres / ellipsoids)',
         }
         return descriptions.get(self, '')
diff --git a/src/easydiffraction/display/structure/renderers/ascii.py b/src/easydiffraction/display/structure/renderers/ascii.py
index b2f8d1b07..aa8936977 100644
--- a/src/easydiffraction/display/structure/renderers/ascii.py
+++ b/src/easydiffraction/display/structure/renderers/ascii.py
@@ -11,7 +11,10 @@
 
 Rgb = tuple[int, int, int]
 
-GLYPH_RAMP = ('·', '•', '●', '⬤')
+# Single-width glyphs only: '⬤' (U+2B24) is absent from common monospace fonts
+# and falls back to a proportional glyph, which renders wider than one cell and
+# pushes the cell's right border out of alignment.
+GLYPH_RAMP = ('·', '•', '●')
 GRID_WIDTH = 56
 PAD = 2
 CHAR_ASPECT = 0.5  # terminal cells are roughly twice as tall as wide
@@ -49,8 +52,14 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         atoms = _collect_atoms(scene)
         basis = np.array(scene.cell_basis, dtype=float)
         lengths = [float(np.linalg.norm(v)) for v in basis]
-        h_vec = basis[int(np.argmax(lengths))]
-        v_vec = basis[int(np.argmin(lengths))]
+        # Project onto the longest axis (horizontal) and shortest (vertical).
+        # Use the same descending, stable sort as the 3D renderers so all
+        # engines agree on which axis is up when two lengths tie (np.argmin
+        # breaks ties to the first index, the sort to the last).
+        order = sorted(range(3), key=lambda i: lengths[i], reverse=True)
+        h_idx, v_idx = order[0], order[2]
+        h_vec = basis[h_idx]
+        v_vec = basis[v_idx]
         h_hat = h_vec / (np.linalg.norm(h_vec) or 1.0)
         v_hat = v_vec / (np.linalg.norm(v_vec) or 1.0)
 
@@ -69,13 +78,18 @@ def project(point) -> tuple[float, float]:
 
         lines = _grid_to_lines(grid)
         if 'axes' in features:
-            lines = _annotate_axes(lines)
+            cells = [place(c) for c in corners]
+            left_col = min(c for _, c in cells)
+            bottom_row = max(r for r, _ in cells)
+            # Collapse the grid's blank top-padding rows to a single spacer
+            # between the vertical-axis label and the cell's top border.
+            while len(lines) > 1 and lines[0] == '' and lines[1] == '':
+                lines.pop(0)
+                bottom_row -= 1
+            lines = _annotate_axes(lines, left_col, bottom_row, 'abc'[v_idx], 'abc'[h_idx])
         text = '\n'.join(lines)
         if 'atoms' in features and atoms:
             text += '\n\n' + _legend(atoms)
-        notes = _announcements(scene, features, self.SUPPORTED)
-        if notes:
-            text += '\n\n' + '\n'.join(notes)
         return text
 
 
@@ -98,29 +112,41 @@ def place(point) -> tuple[int, int]:
     return grid, place
 
 
-def _draw_line(grid, p0, p1, glyph, colour):
-    (r0, c0), (r1, c1) = p0, p1
-    steps = max(abs(r1 - r0), abs(c1 - c0)) or 1
-    for i in range(steps + 1):
-        row = round(r0 + (r1 - r0) * i / steps)
-        col = round(c0 + (c1 - c0) * i / steps)
-        grid.setdefault((row, col), (glyph, colour))
-
-
 def _draw_cell(grid, place, corners):
+    # Draw the projected cell as a clean, closed rectangle (the bounding box of
+    # the four projected corners). Integer-rounding the corners independently
+    # otherwise leaves the borders one row/column out of step. This snaps the
+    # slant of oblique cells to an upright box, which the schematic accepts.
     grey = (150, 150, 150)
-    c00, c10, c01, c11 = (place(c) for c in corners)
-    for a, b in ((c00, c10), (c01, c11)):
-        _draw_line(grid, a, b, '─', grey)
-    for a, b in ((c00, c01), (c10, c11)):
-        _draw_line(grid, a, b, '│', grey)
+    cells = [place(c) for c in corners]
+    rows = [r for r, _ in cells]
+    cols = [c for _, c in cells]
+    top, bottom = min(rows), max(rows)
+    left, right = min(cols), max(cols)
+    for col in range(left, right + 1):
+        grid.setdefault((top, col), ('─', grey))
+        grid.setdefault((bottom, col), ('─', grey))
+    for row in range(top, bottom + 1):
+        grid.setdefault((row, left), ('│', grey))
+        grid.setdefault((row, right), ('│', grey))
+    for cell, glyph in (((top, left), '╭'), ((top, right), '╮'),
+                        ((bottom, left), '╰'), ((bottom, right), '╯')):
+        grid[cell] = (glyph, grey)
 
 
 def _draw_atoms(grid, place, atoms):
     max_radius = max(a[1] for a in atoms) or 1.0
+    placed: dict = {}
     for centre, radius, colour, _label in atoms:
+        row, col = place(centre)
+        # Skip near-duplicates: a same-colour atom already in this or an
+        # adjacent cell (periodic images projecting to nearly one spot).
+        if any(placed.get((row + dr, col + dc)) == colour
+               for dr in (-1, 0, 1) for dc in (-1, 0, 1)):
+            continue
         bucket = min(len(GLYPH_RAMP) - 1, int(radius / max_radius * len(GLYPH_RAMP)))
-        grid[place(centre)] = (GLYPH_RAMP[bucket], colour)
+        grid[(row, col)] = (GLYPH_RAMP[bucket], colour)
+        placed[(row, col)] = colour
 
 
 def _grid_to_lines(grid):
@@ -135,17 +161,23 @@ def _grid_to_lines(grid):
     return lines
 
 
-def _annotate_axes(lines):
-    if lines:
-        lines[0] = '  c ↑' + lines[0][5:] if len(lines[0]) > 5 else '  c ↑'
-        lines[-1] = lines[-1] + '  → a'
-    return lines
+def _annotate_axes(lines, left_col, bottom_row, v_letter, h_letter):
+    """Stack the vertical-axis label above the cell and place the horizontal
+    label at the right end of the bottom border (ANSI-safe: no slicing).
+    """
+    indent = ' ' * left_col
+    header = ['', f'{indent}{v_letter}', f'{indent}↑']  # blank line, letter, arrow
+    body = list(lines)
+    if 0 <= bottom_row < len(body):
+        body[bottom_row] = body[bottom_row] + f'  → {h_letter}'
+    return header + body
 
 
 def _legend(atoms) -> str:
     seen: dict = {}
     for _centre, radius, colour, label in atoms:
-        element = ''.join(ch for ch in label if ch.isalpha()) or label
+        # Keep '/' so a shared site reads 'La/Ba', not 'LaBa'; drop digits.
+        element = ''.join(ch for ch in label if ch.isalpha() or ch == '/') or label
         seen.setdefault(element, (radius, colour))
     max_radius = max(r for r, _ in seen.values()) or 1.0
     items = []
@@ -153,14 +185,3 @@ def _legend(atoms) -> str:
         bucket = min(len(GLYPH_RAMP) - 1, int(radius / max_radius * len(GLYPH_RAMP)))
         items.append(_tint(colour, f'{GLYPH_RAMP[bucket]} {element}'))
     return 'Legend:  ' + '   '.join(items)
-
-
-def _announcements(scene, features, supported) -> list[str]:
-    notes = []
-    skipped = [f for f in ('bonds', 'labels', 'moments') if f in features and f not in supported]
-    if skipped:
-        notes.append('Shown only by the 3D engines: ' + ', '.join(skipped) + '.')
-    if scene.ellipsoids:
-        notes.append('ADP ellipsoids are flattened to dots; use a 3D engine for ellipsoids.')
-    notes.append('Schematic single-cell view; wider ranges are shown only by the 3D engines.')
-    return notes
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index e81a76f43..9842f2b06 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -22,15 +22,15 @@
 _SUPERSAMPLE = 2
 _MARGIN_FRAC = 0.06
 _BOND_RADIUS = 0.06
-_AMBIENT = 0.55  # matches the Three.js AmbientLight intensity
-_LIGHT = np.array([0.42, 0.5, 0.75])  # (right, up, toward-camera)
+_AMBIENT = 0.5  # broad fill so most of each atom stays bright and saturated
+_LIGHT = np.array([0.3, 0.45, 0.85])  # (right, up, toward-camera); frontal key
 _LIGHT = _LIGHT / np.linalg.norm(_LIGHT)
-_FILL = np.array([-0.42, -0.25, -0.5])  # back-fill, mirrors the Three.js fill light
+_FILL = np.array([-0.4, -0.2, -0.45])  # back-fill, mirrors the Three.js fill light
 _FILL = _FILL / np.linalg.norm(_FILL)
 _HALF = _LIGHT + np.array([0.0, 0.0, 1.0])  # Blinn-Phong half-vector (view = toward camera)
 _HALF = _HALF / np.linalg.norm(_HALF)
-_SHININESS = 30.0  # specular exponent (tight bright highlight, VESTA-like)
-_SPEC_STRENGTH = 0.55
+_SHININESS = 36.0  # specular exponent
+_SPEC_STRENGTH = 0.28  # small, subtle highlight (not a hard white spot)
 _LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
 _LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
 # Axis-arrow proportions, as fractions of the arrow length (match the Three.js
@@ -47,13 +47,22 @@ def _unit(vector: np.ndarray) -> np.ndarray:
 
 
 def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Return (view_dir, right, up) for a trimetric, c-axis-up projection."""
+    """Return (view_dir, right, up): longest axis horizontal, shortest vertical.
+
+    Mirrors the Three.js default camera: the camera sits in the
+    +longest +middle +shortest octant so the origin corner is at the far back
+    and the longest/middle axes splay toward the viewer with the shortest axis
+    up, giving the standard trimetric view in both the PDF and interactive
+    figures.
+    """
     if scene.axes is not None:
-        a_hat = _unit(np.asarray(scene.axes.axes[0].vector, dtype=float))
-        b_hat = _unit(np.asarray(scene.axes.axes[1].vector, dtype=float))
-        c_hat = _unit(np.asarray(scene.axes.axes[2].vector, dtype=float))
-        view_up = c_hat
-        view_dir = _unit(1.0 * a_hat + 0.22 * b_hat + 0.33 * c_hat)
+        vectors = [np.asarray(ax.vector, dtype=float) for ax in scene.axes.axes]
+        order = sorted(range(3), key=lambda i: np.linalg.norm(vectors[i]), reverse=True)
+        longest = _unit(vectors[order[0]])
+        middle = _unit(vectors[order[1]])
+        shortest = _unit(vectors[order[2]])
+        view_up = shortest
+        view_dir = _unit(0.82 * longest + 0.82 * middle + 0.55 * shortest)
     else:
         view_up = np.array([0.0, 1.0, 0.0])
         view_dir = _unit(np.array([1.0, 0.8, 1.5]))
@@ -393,19 +402,24 @@ def _triangle(colour, depth, v0, v1, v2, shade) -> None:
         sub[update] = tri_depth[update]
         colour[min_y:max_y, min_x:max_x][update] = shade
 
-    def _arrow(self, colour, depth, project, basis, origin, vector, rgb) -> None:
-        """Draw a shaft cylinder and head cone as 3D triangles (orientation-safe)."""
+    def _arrow(self, colour, depth, project, basis, origin, vector, rgb, ref_length) -> None:
+        """Draw a shaft cylinder and head cone as 3D triangles (orientation-safe).
+
+        Thickness and head size scale from ``ref_length`` (the longest axis),
+        not each arrow's own length, so all three axes share one uniform
+        thickness regardless of cell anisotropy.
+        """
         right, up, view_dir = basis
         length = float(np.linalg.norm(vector))
         if length < 1e-9:
             return
         axis = vector / length
-        ref = np.array([0.0, 0.0, 1.0]) if abs(axis[2]) < 0.9 else np.array([0.0, 1.0, 0.0])
-        u = _unit(np.cross(ref, axis))
+        perp = np.array([0.0, 0.0, 1.0]) if abs(axis[2]) < 0.9 else np.array([0.0, 1.0, 0.0])
+        u = _unit(np.cross(perp, axis))
         v = np.cross(axis, u)
-        shaft_r = _AXIS_SHAFT_RADIUS_FRAC * length
-        head_r = _AXIS_HEAD_RADIUS_FRAC * length
-        base = origin + axis * (length - _AXIS_HEAD_LENGTH_FRAC * length)
+        shaft_r = _AXIS_SHAFT_RADIUS_FRAC * ref_length
+        head_r = _AXIS_HEAD_RADIUS_FRAC * ref_length
+        base = origin + axis * max(length - _AXIS_HEAD_LENGTH_FRAC * ref_length, 1e-3)
         tip = origin + vector
         flat = np.asarray(rgb, dtype=np.float32) / 255.0
 
@@ -438,6 +452,7 @@ def shade_for(world_normal: np.ndarray) -> np.ndarray:
 
     def _axes(self, colour, depth, project, basis, axes) -> None:
         origin = np.asarray(axes.origin, dtype=float)
+        ref_length = max((float(np.linalg.norm(a.vector)) for a in axes.axes), default=1.0)
         for arrow in axes.axes:
             self._arrow(colour, depth, project, basis, origin,
-                        np.asarray(arrow.vector, dtype=float), arrow.colour)
+                        np.asarray(arrow.vector, dtype=float), arrow.colour, ref_length)
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 2a9c50c6e..852221380 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -1,6 +1,6 @@
 <div id="{{ container_id }}" class="crysview" style="position:relative;width:100%;height:480px;
      background:{{ background }};color:{{ foreground }};border:1px solid rgba(128,128,128,0.3);
-     border-radius:6px;overflow:hidden;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
+     border-radius:0;box-sizing:border-box;overflow:hidden;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
   <div class="cv-canvas" style="position:absolute;inset:0;"></div>
   <div class="cv-modebar cv-card"></div>
   <div class="cv-legend cv-card"></div>
@@ -11,18 +11,18 @@
 <style>
   #{{ container_id }} .cv-card {
     position: absolute; z-index: 10; background: rgba(255, 255, 255, 0.94);
-    border: 1px solid #e2e2e2; border-radius: 8px;
+    border: 1px solid #e2e2e2; border-radius: 0;
     box-shadow: 0 1px 6px rgba(0, 0, 0, 0.12); font-size: 12px; color: #222;
   }
   #{{ container_id }} .cv-modebar {
-    top: 10px; right: 10px; display: flex; align-items: center; gap: 6px;
-    padding: 5px 7px; flex-wrap: wrap; justify-content: flex-end; max-width: 80%;
+    top: 10px; right: 10px; display: flex; align-items: center; gap: 16px;
+    padding: 0; flex-wrap: wrap; justify-content: flex-end; max-width: 80%;
+    background: none; border: none; box-shadow: none;
   }
   #{{ container_id }} .mb-grp { display: flex; gap: 4px; }
-  #{{ container_id }} .mb-sep { align-self: stretch; width: 1px; background: #e4e4e4; margin: 3px 2px; }
   #{{ container_id }} .mb {
     width: 32px; height: 30px; display: inline-flex; align-items: center;
-    justify-content: center; padding: 0; border: 1px solid #dcdcdc; border-radius: 6px;
+    justify-content: center; padding: 0; border: 1px solid #dcdcdc; border-radius: 0;
     background: #f5f5f6; color: #2a3f5f; cursor: pointer;
     transition: background 0.12s, color 0.12s, border-color 0.12s;
   }
@@ -32,8 +32,12 @@
   #{{ container_id }} .mb.tog { color: #b9bdc6; }
   #{{ container_id }} .mb.tog.on { color: #2a3f5f; background: #e7ecf5; border-color: #c6d0e2; }
   #{{ container_id }} .mb-select {
-    height: 30px; border: 1px solid #dcdcdc; border-radius: 6px; background: #f5f5f6;
-    color: #2a3f5f; font-size: 12px; padding: 0 4px; cursor: pointer;
+    height: 30px; box-sizing: border-box; border: 1px solid #dcdcdc; border-radius: 0;
+    color: #2a3f5f; font-size: 12px; padding: 0 22px 0 8px; cursor: pointer;
+    -webkit-appearance: none; -moz-appearance: none; appearance: none;
+    background-color: #f5f5f6;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%232a3f5f' stroke-width='1.3'/%3E%3C/svg%3E");
+    background-repeat: no-repeat; background-position: right 7px center; background-size: 9px 9px;
   }
   #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; text-align: left; }
   #{{ container_id }} .cv-legend .sw {
@@ -42,13 +46,13 @@
   }
   #{{ container_id }} .cv-hint {
     position: absolute; z-index: 10; bottom: 8px; left: 10px; font-size: 11px;
-    color: #555; background: rgba(255, 255, 255, 0.82); padding: 5px 9px; border-radius: 6px;
+    color: #555; background: rgba(255, 255, 255, 0.82); padding: 5px 9px; border-radius: 0;
     line-height: 1.5; text-align: left;
   }
   #{{ container_id }} .cv-tooltip {
     position: absolute; z-index: 30; pointer-events: none; display: none;
     background: rgba(33, 42, 62, 0.92); color: #fff; padding: 3px 8px;
-    border-radius: 5px; font-size: 12px; white-space: nowrap;
+    border-radius: 0; font-size: 12px; white-space: nowrap;
   }
   #{{ container_id }} .cv-atom-label {
     font-size: 11px; font-weight: 600; color: {{ foreground }};
@@ -86,16 +90,20 @@ const modebar = root.querySelector('.cv-modebar');
 const legend = root.querySelector('.cv-legend');
 const tooltip = root.querySelector('.cv-tooltip');
 
-const col = (rgb) => new THREE.Color(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255);
+// Element palettes are authored in sRGB; tag the colour space so Three.js
+// converts to linear for lighting instead of treating it as already-linear
+// (which washes out and desaturates the atoms).
+const col = (rgb) => new THREE.Color().setRGB(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255, THREE.SRGBColorSpace);
 const vec = (xyz) => new THREE.Vector3(xyz[0], xyz[1], xyz[2]);
 const rgbCss = (rgb) => `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
 const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
 const PALETTES = SCENE.palettes || {};
 
-// Glossy Phong material so atoms show a bright specular highlight (VESTA-like).
-const SPECULAR = new THREE.Color(0.32, 0.32, 0.32);
+// Phong material with a small, subtle highlight (mirrors the raster figure:
+// bright saturated atoms, tight specular spot, small dark region).
+const SPECULAR = new THREE.Color(0.2, 0.2, 0.2);
 const solidMat = (c, doubleSide) => new THREE.MeshPhongMaterial({
-  color: c, shininess: 60, specular: SPECULAR,
+  color: c, shininess: 90, specular: SPECULAR,
   side: doubleSide ? THREE.DoubleSide : THREE.FrontSide,
 });
 
@@ -115,13 +123,12 @@ labelRenderer.domElement.style.top = '0';
 labelRenderer.domElement.style.pointerEvents = 'none';
 host.appendChild(labelRenderer.domElement);
 
-scene.add(new THREE.AmbientLight(0xffffff, 0.55));
-const key = new THREE.DirectionalLight(0xffffff, 0.9);
-key.position.set(1, 1, 1);
-scene.add(key);
-const fill = new THREE.DirectionalLight(0xffffff, 0.35);
-fill.position.set(-1, -0.5, -1);
-scene.add(fill);
+// Camera-relative key + fill (headlights) so atoms stay bright and saturated
+// from any angle, with a small dark region — matching the raster figure.
+scene.add(new THREE.AmbientLight(0xffffff, 0.68));
+const key = new THREE.DirectionalLight(0xffffff, 1.25);
+const fill = new THREE.DirectionalLight(0xffffff, 0.34);
+scene.add(key, key.target, fill, fill.target);
 
 const groups = {};
 for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
@@ -206,11 +213,13 @@ for (const edge of SCENE.cellEdges) {
 }
 
 const Y_AXIS = new THREE.Vector3(0, 1, 0);
-const buildArrow = (origin, v, colour) => {
+// `ref` is the longest axis length; thickness and head size derive from it
+// (not each arrow's own length) so all three axes share one uniform thickness.
+const buildArrow = (origin, v, colour, ref) => {
   const group = new THREE.Group();
   const length = v.length();
-  const shaftR = length * 0.012;
-  const headLen = length * 0.12;
+  const shaftR = ref * 0.012;
+  const headLen = ref * 0.12;
   const headR = shaftR * 4;
   const shaftLen = Math.max(length - headLen, 1e-3);
   const material = solidMat(col(colour));
@@ -226,9 +235,10 @@ const buildArrow = (origin, v, colour) => {
 
 if (SCENE.axes) {
   const origin = vec(SCENE.axes.origin);
+  const ref = Math.max(...SCENE.axes.arrows.map((a) => vec(a.vector).length()), 1e-3);
   for (const arrow of SCENE.axes.arrows) {
     const v = vec(arrow.vector);
-    groups.axes.add(buildArrow(origin, v, arrow.colour));
+    groups.axes.add(buildArrow(origin, v, arrow.colour, ref));
     const div = document.createElement('div');
     div.textContent = arrow.letter;
     div.style.color = rgbCss(arrow.colour);
@@ -254,31 +264,80 @@ scene.traverse((obj) => {
 });
 if (box.isEmpty()) box.set(new THREE.Vector3(-1, -1, -1), new THREE.Vector3(1, 1, 1));
 const target = box.getBoundingSphere(new THREE.Sphere()).center;
-const radius = Math.max(box.getBoundingSphere(new THREE.Sphere()).radius, 1);
 const aspect = width / height;
-const far = radius * 100;
-const distance = radius * 2.4;
-
-// Trimetric default view: c-axis up, tilted above the ab-plane and rotated
-// in azimuth so all three axes read distinctly. Falls back to a fixed angle
-// when the cell axes are not in the scene.
 const cellBasis = SCENE.axes ? SCENE.axes.arrows.map((a) => vec(a.vector)) : [];
+
+// Real content points the framing must enclose — atom centres, cell vertices,
+// axis-arrow tips and their label glyphs. (AABB corners are wrong here: they
+// stick out into empty space and over-zoom-out the view.) fitPad grows the
+// extent by the largest atom radius so boundary spheres are not clipped.
+const fitPoints = [];
+let fitPad = 0;
+for (const a of SCENE.atoms) { fitPoints.push(vec(a.centre)); fitPad = Math.max(fitPad, a.radius); }
+for (const s of SCENE.wedgeSpheres || []) { fitPoints.push(vec(s.centre)); fitPad = Math.max(fitPad, s.radius); }
+for (const e of SCENE.ellipsoids || []) { fitPoints.push(vec(e.centre)); fitPad = Math.max(fitPad, Math.max(...e.semiAxes)); }
+for (const edge of SCENE.cellEdges || []) { fitPoints.push(vec(edge.start), vec(edge.end)); }
+if (SCENE.axes) {
+  const axesOrigin = vec(SCENE.axes.origin);
+  fitPoints.push(axesOrigin);
+  for (const arrow of SCENE.axes.arrows)
+    fitPoints.push(axesOrigin.clone().add(vec(arrow.vector).multiplyScalar(1.16)));
+}
+if (!fitPoints.length) fitPoints.push(box.min.clone(), box.max.clone());
+
+// Default orientation: longest cell axis horizontal, shortest vertical, the
+// remaining axis into depth, then a small azimuth + elevation for a trimetric
+// 3D read. Falls back to a fixed angle when the cell axes are absent.
 let viewUp;
 let viewDir;
-if (cellBasis.length === 3) {
-  const aHat = cellBasis[0].clone().normalize();
-  const bHat = cellBasis[1].clone().normalize();
-  const cHat = cellBasis[2].clone().normalize();
-  viewUp = cHat.clone();
-  viewDir = aHat.multiplyScalar(1.0).add(bHat.multiplyScalar(0.22)).add(cHat.multiplyScalar(0.33)).normalize();
+if (SCENE.axes && SCENE.axes.arrows.length === 3) {
+  const sorted = SCENE.axes.arrows.map((a) => vec(a.vector)).sort((p, q) => q.length() - p.length());
+  const longest = sorted[0].clone().normalize();
+  const middle = sorted[1].clone().normalize();
+  const shortest = sorted[2].clone().normalize();
+  viewUp = shortest.clone();
+  // Camera in the +longest +middle +shortest octant: the origin corner sits at
+  // the far back, the longest and middle axes splay toward the viewer, and the
+  // shortest axis points up — the standard trimetric crystallographic view.
+  viewDir = longest.clone().multiplyScalar(0.82)
+    .add(middle.clone().multiplyScalar(0.82))
+    .add(shortest.clone().multiplyScalar(0.55))
+    .normalize();
 } else {
   viewUp = new THREE.Vector3(0, 1, 0);
   viewDir = new THREE.Vector3(1.0, 0.8, 1.5).normalize();
 }
-const home = target.clone().add(viewDir.multiplyScalar(distance));
 
-const perspective = new THREE.PerspectiveCamera(45, aspect, radius * 0.01, far);
-const ortho = new THREE.OrthographicCamera(-radius * aspect * 1.26, radius * aspect * 1.26, radius * 1.26, -radius * 1.26, -far, far);
+// Screen-space fit: project the fit points onto the camera right/up axes and
+// frame their 2D bounding box. Recentering the target on that box keeps the
+// content centred even though arrows/labels extend it asymmetrically, and the
+// extent-based zoom is independent of cell size, axis ratios, and aspect.
+const look = viewDir.clone().negate();
+const camRight = new THREE.Vector3().crossVectors(look, viewUp).normalize();
+const camUp = new THREE.Vector3().crossVectors(camRight, look).normalize();
+let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
+for (const p of fitPoints) {
+  const d = p.clone().sub(target);
+  const u = d.dot(camRight), v = d.dot(camUp);
+  minU = Math.min(minU, u); maxU = Math.max(maxU, u);
+  minV = Math.min(minV, v); maxV = Math.max(maxV, v);
+}
+target.addScaledVector(camRight, (minU + maxU) / 2).addScaledVector(camUp, (minV + maxV) / 2);
+const halfW = Math.max((maxU - minU) / 2 + fitPad, 0.5) * 1.06;
+const halfH = Math.max((maxV - minV) / 2 + fitPad, 0.5) * 1.06;
+const radius = Math.max(halfW, halfH);
+const far = radius * 100;
+const tanV = Math.tan((45 * Math.PI) / 360);
+const distance = Math.max(halfH / tanV, halfW / (tanV * aspect)) * 1.05;
+const home = target.clone().add(viewDir.clone().multiplyScalar(distance));
+
+const perspective = new THREE.PerspectiveCamera(45, aspect, Math.max(distance * 0.01, 0.01), far);
+// Ortho frustum sized to the projected extent; reserve a top band for the
+// modebar/legend so the cell sits a little lower and clears them.
+const orthoHalfH = Math.max(halfH, halfW / aspect);
+const topBandPx = 50;
+const topPad = (2 * orthoHalfH / height) * topBandPx;
+const ortho = new THREE.OrthographicCamera(-orthoHalfH * aspect, orthoHalfH * aspect, orthoHalfH + topPad, -orthoHalfH, -far, far);
 perspective.up.copy(viewUp);
 ortho.up.copy(viewUp);
 perspective.position.copy(home);
@@ -286,6 +345,17 @@ ortho.position.copy(home);
 let camera = ortho;
 let projection = 'orthographic';
 
+// Normalise axis-arrow thickness to the on-screen zoom so arrows look equally
+// thin in every cell. They are built proportional to the longest axis, but the
+// ortho zoom is not (it depends on aspect and the trimetric tilt), so wide or
+// elongated cells would otherwise show fatter arrows than cubic ones. Scale
+// radially only, leaving each arrow's length and overhang untouched.
+if (SCENE.axes && SCENE.axes.arrows.length) {
+  const builtRef = Math.max(...SCENE.axes.arrows.map((a) => vec(a.vector).length()), 1e-3);
+  const arrowScale = (orthoHalfH * 0.010) / (builtRef * 0.012);
+  groups.axes.children.forEach((g) => { if (g.isGroup) g.scale.set(arrowScale, 1, arrowScale); });
+}
+
 const controls = new OrbitControls(camera, renderer.domElement);
 controls.enableDamping = true;
 controls.dampingFactor = 0.08;
@@ -382,9 +452,6 @@ if (hasNonAU && groups.atoms.children.length) {
   });
 }
 if (hasFeatureToggle) {
-  const separator = document.createElement('div');
-  separator.className = 'mb-sep';
-  modebar.appendChild(separator);
   modebar.appendChild(featureGroup);
 }
 
@@ -476,9 +543,28 @@ const resize = () => {
 };
 if (window.ResizeObserver) new ResizeObserver(resize).observe(host);
 
+// Camera-relative light directions (right, up, toward-camera), matching the
+// raster figure's _LIGHT / _FILL so both engines shade atoms identically.
+const KEY_LOCAL = [0.3, 0.45, 0.85];
+const FILL_LOCAL = [-0.4, -0.2, -0.45];
+const keyDir = new THREE.Vector3();
+const fillDir = new THREE.Vector3();
+const placeLight = (light, local, dir) => {
+  const m = camera.matrixWorld.elements;
+  dir.set(
+    local[0] * m[0] + local[1] * m[4] + local[2] * m[8],
+    local[0] * m[1] + local[1] * m[5] + local[2] * m[9],
+    local[0] * m[2] + local[1] * m[6] + local[2] * m[10],
+  ).normalize();
+  light.position.copy(target).addScaledVector(dir, radius * 5);
+  light.target.position.copy(target);
+};
+
 const animate = () => {
   requestAnimationFrame(animate);
   controls.update();
+  placeLight(key, KEY_LOCAL, keyDir);
+  placeLight(fill, FILL_LOCAL, fillDir);
   renderer.render(scene, camera);
   labelRenderer.render(scene, camera);
 };
diff --git a/src/easydiffraction/project/categories/style/default.py b/src/easydiffraction/project/categories/style/default.py
index 61b94cc74..716cbc008 100644
--- a/src/easydiffraction/project/categories/style/default.py
+++ b/src/easydiffraction/project/categories/style/default.py
@@ -58,7 +58,7 @@ def __init__(self) -> None:
             name='adp_probability',
             description='ORTEP probability level, a fraction in (0, 1).',
             value_spec=AttributeSpec(
-                default=0.5,
+                default=0.99,
                 validator=RangeValidator(gt=0.0, lt=1.0),
             ),
             cif_handler=CifHandler(names=['_style.adp_probability']),
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 9c3d2443e..fe56822dc 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -522,6 +522,7 @@ def structure(
 
             pathlib.Path(path).write_text(output)
             return
+        console.paragraph(f"Structure 🧩 '{struct_name}'")
         self._emit_structure_output(output)
 
     def show_structure_options(self, struct_name: str) -> None:
@@ -607,7 +608,10 @@ def _emit_structure_output(self, output: str) -> None:
         from easydiffraction.utils.environment import in_jupyter  # noqa: PLC0415
 
         if self._project.rendering_structure.viewer.engine == ViewerEngineEnum.ASCII.value:
-            console.print(output)
+            # Built-in print preserves the renderer's raw ANSI colour codes
+            # (Jupyter and terminals interpret them); Rich's console.print
+            # would escape and garble them. Mirrors the ASCII pattern plotter.
+            print(output)
             return
         if in_jupyter():
             from IPython.display import HTML  # noqa: PLC0415

From 8c0f01a081690f0b9894131f1fa1191cd781680c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 09:05:40 +0200
Subject: [PATCH 065/160] Fix structure-view distortion at off-axis camera
 angles

---
 .../structure/templates/structure.html.j2     | 20 +++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 852221380..b920ef751 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -336,8 +336,13 @@ const perspective = new THREE.PerspectiveCamera(45, aspect, Math.max(distance *
 // modebar/legend so the cell sits a little lower and clears them.
 const orthoHalfH = Math.max(halfH, halfW / aspect);
 const topBandPx = 50;
-const topPad = (2 * orthoHalfH / height) * topBandPx;
-const ortho = new THREE.OrthographicCamera(-orthoHalfH * aspect, orthoHalfH * aspect, orthoHalfH + topPad, -orthoHalfH, -far, far);
+// Reserve a band at the top for the modebar by growing the vertical extent and
+// shifting the centre up, keeping width/height === aspect so spheres stay round.
+// (Adding the band only to `top` skews the frustum and distorts the scene.)
+const band = (2 * orthoHalfH / height) * topBandPx;
+const halfV = orthoHalfH + band * 0.5;
+const ortho = new THREE.OrthographicCamera(
+  -halfV * aspect, halfV * aspect, halfV + band * 0.5, -halfV + band * 0.5, -far, far);
 perspective.up.copy(viewUp);
 ortho.up.copy(viewUp);
 perspective.position.copy(home);
@@ -535,8 +540,15 @@ const resize = () => {
   const ratio = width / height;
   perspective.aspect = ratio;
   perspective.updateProjectionMatrix();
-  ortho.left = -radius * ratio * 1.26;
-  ortho.right = radius * ratio * 1.26;
+  // Recompute the ortho frustum for the new aspect exactly as on setup, so
+  // width/height === ratio (spheres stay round) and the modebar band is kept.
+  const oh = Math.max(halfH, halfW / ratio);
+  const reserve = (2 * oh / height) * topBandPx;
+  const hv = oh + reserve * 0.5;
+  ortho.left = -hv * ratio;
+  ortho.right = hv * ratio;
+  ortho.top = hv + reserve * 0.5;
+  ortho.bottom = -hv + reserve * 0.5;
   ortho.updateProjectionMatrix();
   renderer.setSize(width, height);
   labelRenderer.setSize(width, height);

From 66e187a7aea4d592ca4e7b1f88fc3f2813c7da8e Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 09:05:40 +0200
Subject: [PATCH 066/160] Default view: longest axis horizontal, second-longest
 up

---
 .../display/structure/renderers/ascii.py      |  9 ++++----
 .../display/structure/renderers/raster.py     | 22 +++++++++----------
 .../structure/templates/structure.html.j2     | 17 +++++++-------
 3 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/ascii.py b/src/easydiffraction/display/structure/renderers/ascii.py
index aa8936977..d12935e40 100644
--- a/src/easydiffraction/display/structure/renderers/ascii.py
+++ b/src/easydiffraction/display/structure/renderers/ascii.py
@@ -51,13 +51,12 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         """Render a schematic ASCII view and announce 3D-only features."""
         atoms = _collect_atoms(scene)
         basis = np.array(scene.cell_basis, dtype=float)
+        # Match the 3D default orientation (by axis length): longest axis
+        # horizontal, 2nd-longest vertical, shortest the dropped depth axis — so
+        # the ASCII and 3D engines share the up axis and width:height ratio.
         lengths = [float(np.linalg.norm(v)) for v in basis]
-        # Project onto the longest axis (horizontal) and shortest (vertical).
-        # Use the same descending, stable sort as the 3D renderers so all
-        # engines agree on which axis is up when two lengths tie (np.argmin
-        # breaks ties to the first index, the sort to the last).
         order = sorted(range(3), key=lambda i: lengths[i], reverse=True)
-        h_idx, v_idx = order[0], order[2]
+        h_idx, v_idx = order[0], order[1]
         h_vec = basis[h_idx]
         v_vec = basis[v_idx]
         h_hat = h_vec / (np.linalg.norm(h_vec) or 1.0)
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 9842f2b06..cfe287683 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -47,22 +47,20 @@ def _unit(vector: np.ndarray) -> np.ndarray:
 
 
 def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Return (view_dir, right, up): longest axis horizontal, shortest vertical.
+    """Return (view_dir, right, up) for the default view.
 
-    Mirrors the Three.js default camera: the camera sits in the
-    +longest +middle +shortest octant so the origin corner is at the far back
-    and the longest/middle axes splay toward the viewer with the shortest axis
-    up, giving the standard trimetric view in both the PDF and interactive
-    figures.
+    Mirrors the Three.js default camera (by axis length): the longest axis is
+    horizontal, the 2nd-longest points up, the shortest goes into depth, and the
+    scene is viewed along ``0.37 longest + 0.24 middle + 0.90 shortest`` — so the
+    PDF figure and the interactive view orient identically.
     """
     if scene.axes is not None:
         vectors = [np.asarray(ax.vector, dtype=float) for ax in scene.axes.axes]
-        order = sorted(range(3), key=lambda i: np.linalg.norm(vectors[i]), reverse=True)
-        longest = _unit(vectors[order[0]])
-        middle = _unit(vectors[order[1]])
-        shortest = _unit(vectors[order[2]])
-        view_up = shortest
-        view_dir = _unit(0.82 * longest + 0.82 * middle + 0.55 * shortest)
+        longest, middle, shortest = (
+            _unit(vectors[i]) for i in sorted(range(3), key=lambda i: np.linalg.norm(vectors[i]), reverse=True)
+        )
+        view_up = middle
+        view_dir = _unit(0.37 * longest + 0.24 * middle + 0.90 * shortest)
     else:
         view_up = np.array([0.0, 1.0, 0.0])
         view_dir = _unit(np.array([1.0, 0.8, 1.5]))
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index b920ef751..14950168e 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -285,23 +285,22 @@ if (SCENE.axes) {
 }
 if (!fitPoints.length) fitPoints.push(box.min.clone(), box.max.clone());
 
-// Default orientation: longest cell axis horizontal, shortest vertical, the
-// remaining axis into depth, then a small azimuth + elevation for a trimetric
+// Default orientation: longest cell axis horizontal, 2nd-longest vertical, the
+// shortest axis into depth, then a small azimuth + elevation for a trimetric
 // 3D read. Falls back to a fixed angle when the cell axes are absent.
 let viewUp;
 let viewDir;
 if (SCENE.axes && SCENE.axes.arrows.length === 3) {
+  // Default view (by axis length): longest axis horizontal, 2nd-longest up,
+  // shortest into depth, viewed along 0.37·longest + 0.24·middle + 0.90·shortest.
   const sorted = SCENE.axes.arrows.map((a) => vec(a.vector)).sort((p, q) => q.length() - p.length());
   const longest = sorted[0].clone().normalize();
   const middle = sorted[1].clone().normalize();
   const shortest = sorted[2].clone().normalize();
-  viewUp = shortest.clone();
-  // Camera in the +longest +middle +shortest octant: the origin corner sits at
-  // the far back, the longest and middle axes splay toward the viewer, and the
-  // shortest axis points up — the standard trimetric crystallographic view.
-  viewDir = longest.clone().multiplyScalar(0.82)
-    .add(middle.clone().multiplyScalar(0.82))
-    .add(shortest.clone().multiplyScalar(0.55))
+  viewUp = middle.clone();
+  viewDir = longest.clone().multiplyScalar(0.37)
+    .add(middle.clone().multiplyScalar(0.24))
+    .add(shortest.clone().multiplyScalar(0.90))
     .normalize();
 } else {
   viewUp = new THREE.Vector3(0, 1, 0);

From 19f53f7784f618987c77e71c87d38dc94067c294 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 09:05:46 +0200
Subject: [PATCH 067/160] Rebuild axis arrows at a constant on-screen size

---
 .../display/structure/renderers/raster.py     |  58 ++++++----
 .../structure/templates/structure.html.j2     | 108 +++++++++---------
 2 files changed, 90 insertions(+), 76 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index cfe287683..6d38adc00 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -33,11 +33,14 @@
 _SPEC_STRENGTH = 0.28  # small, subtle highlight (not a hard white spot)
 _LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
 _LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
-# Axis-arrow proportions, as fractions of the arrow length (match the Three.js
-# buildArrow so the PDF and HTML axis triads look identical).
-_AXIS_SHAFT_RADIUS_FRAC = 0.012
-_AXIS_HEAD_RADIUS_FRAC = 0.048
-_AXIS_HEAD_LENGTH_FRAC = 0.12
+# Axis-arrow proportions, as fractions of the fit extent, so the arrows are a
+# constant on-screen size in every cell (mirrors the Three.js defaults). The fit
+# extent is ~2x the Three.js half-height reference, hence ~half its fractions.
+_AXIS_SHAFT_RADIUS_FRAC = 0.0045
+_AXIS_HEAD_RADIUS_FRAC = 0.014
+_AXIS_HEAD_LENGTH_FRAC = 0.043
+_AXIS_OVERHANG_FRAC = 0.045  # minimum overhang past the cell corner
+_AXIS_GAP_FRAC = 0.02  # clear gap between a corner atom and the head base
 
 
 def _unit(vector: np.ndarray) -> np.ndarray:
@@ -99,10 +102,9 @@ def _scene_points(scene) -> np.ndarray:
             points.append(edge.start)
             points.append(edge.end)
     if scene.axes is not None:
-        origin = np.asarray(scene.axes.origin, dtype=float)
+        # Only the cell origin; the axis arrows are sized from the fit extent and
+        # reserved with a margin, not enclosed point-by-point.
         points.append(scene.axes.origin)
-        for arrow in scene.axes.axes:
-            points.append(tuple(origin + np.asarray(arrow.vector, dtype=float)))
     return np.array(points, dtype=float) if points else np.zeros((1, 3))
 
 
@@ -131,7 +133,10 @@ def render_png(self, scene, *, features: frozenset[str]) -> bytes:
         pad = _max_radius(scene)
         lo = screen.min(axis=0) - pad
         hi = screen.max(axis=0) + pad
-        extent = float((hi - lo).max()) or 1.0
+        content_extent = float((hi - lo).max()) or 1.0
+        # Reserve room for the axis arrows (drawn beyond the cell, sized from the
+        # extent below) so their heads and letters stay inside the frame.
+        extent = content_extent * (1.24 if scene.axes is not None else 1.0)
         scale = (size * (1.0 - 2.0 * _MARGIN_FRAC)) / extent
         centre2d = (lo + hi) / 2.0
 
@@ -149,7 +154,7 @@ def project(point: object) -> tuple[float, float, float]:
                 self._capsule(colour, depth, project, scale, edge.start, edge.end,
                               0.012, (90, 90, 90), (90, 90, 90))
         if 'axes' in features and scene.axes is not None:
-            self._axes(colour, depth, project, (right, up, view_dir), scene.axes)
+            self._axes(colour, depth, project, (right, up, view_dir), scene.axes, extent, pad)
         if 'bonds' in features:
             for bond in scene.bonds:
                 self._capsule(colour, depth, project, scale, bond.start, bond.end,
@@ -400,12 +405,12 @@ def _triangle(colour, depth, v0, v1, v2, shade) -> None:
         sub[update] = tri_depth[update]
         colour[min_y:max_y, min_x:max_x][update] = shade
 
-    def _arrow(self, colour, depth, project, basis, origin, vector, rgb, ref_length) -> None:
+    def _arrow(self, colour, depth, project, basis, origin, vector, extent, rgb) -> None:
         """Draw a shaft cylinder and head cone as 3D triangles (orientation-safe).
 
-        Thickness and head size scale from ``ref_length`` (the longest axis),
-        not each arrow's own length, so all three axes share one uniform
-        thickness regardless of cell anisotropy.
+        Thickness and head size are fractions of ``extent`` (the fit extent), so
+        the arrow is a constant on-screen size in every cell. ``vector`` already
+        runs to the arrow tip (cell edge plus overhang).
         """
         right, up, view_dir = basis
         length = float(np.linalg.norm(vector))
@@ -415,9 +420,9 @@ def _arrow(self, colour, depth, project, basis, origin, vector, rgb, ref_length)
         perp = np.array([0.0, 0.0, 1.0]) if abs(axis[2]) < 0.9 else np.array([0.0, 1.0, 0.0])
         u = _unit(np.cross(perp, axis))
         v = np.cross(axis, u)
-        shaft_r = _AXIS_SHAFT_RADIUS_FRAC * ref_length
-        head_r = _AXIS_HEAD_RADIUS_FRAC * ref_length
-        base = origin + axis * max(length - _AXIS_HEAD_LENGTH_FRAC * ref_length, 1e-3)
+        shaft_r = _AXIS_SHAFT_RADIUS_FRAC * extent
+        head_r = _AXIS_HEAD_RADIUS_FRAC * extent
+        base = origin + axis * max(length - _AXIS_HEAD_LENGTH_FRAC * extent, 1e-3)
         tip = origin + vector
         flat = np.asarray(rgb, dtype=np.float32) / 255.0
 
@@ -448,9 +453,20 @@ def shade_for(world_normal: np.ndarray) -> np.ndarray:
             self._triangle(colour, depth, project(tuple(base)), project(tuple(b1)),
                            project(tuple(b0)), shade_for(-axis))
 
-    def _axes(self, colour, depth, project, basis, axes) -> None:
+    def _axes(self, colour, depth, project, basis, axes, extent, max_atom_r) -> None:
         origin = np.asarray(axes.origin, dtype=float)
-        ref_length = max((float(np.linalg.norm(a.vector)) for a in axes.axes), default=1.0)
-        for arrow in axes.axes:
+        vectors = [np.asarray(a.vector, dtype=float) for a in axes.axes]
+        # Recover the longest cell edge (the builder adds a 0.3*max overhang).
+        max_axis = max((float(np.linalg.norm(v)) for v in vectors), default=1.0) / 1.3
+        head_len = _AXIS_HEAD_LENGTH_FRAC * extent
+        # Overhang clears the largest atom (so corner atoms never hide the head),
+        # plus the head length and a small gap.
+        overhang = max(_AXIS_OVERHANG_FRAC * extent, max_atom_r + head_len + _AXIS_GAP_FRAC * extent)
+        for arrow, vector in zip(axes.axes, vectors):
+            length = float(np.linalg.norm(vector))
+            if length < 1e-9:
+                continue
+            axis = vector / length
+            axis_len = max(length - 0.3 * max_axis, 1e-3)
             self._arrow(colour, depth, project, basis, origin,
-                        np.asarray(arrow.vector, dtype=float), arrow.colour, ref_length)
+                        axis * (axis_len + overhang), extent, arrow.colour)
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 14950168e..f4daac9d3 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -212,42 +212,9 @@ for (const edge of SCENE.cellEdges) {
   groups.cell.add(new THREE.Line(geo, cellMaterial));
 }
 
-const Y_AXIS = new THREE.Vector3(0, 1, 0);
-// `ref` is the longest axis length; thickness and head size derive from it
-// (not each arrow's own length) so all three axes share one uniform thickness.
-const buildArrow = (origin, v, colour, ref) => {
-  const group = new THREE.Group();
-  const length = v.length();
-  const shaftR = ref * 0.012;
-  const headLen = ref * 0.12;
-  const headR = shaftR * 4;
-  const shaftLen = Math.max(length - headLen, 1e-3);
-  const material = solidMat(col(colour));
-  const shaft = new THREE.Mesh(new THREE.CylinderGeometry(shaftR, shaftR, shaftLen, 16), material);
-  shaft.position.y = shaftLen / 2;
-  const head = new THREE.Mesh(new THREE.ConeGeometry(headR, headLen, 20), material);
-  head.position.y = shaftLen + headLen / 2;
-  group.add(shaft, head);
-  group.quaternion.setFromUnitVectors(Y_AXIS, v.clone().normalize());
-  group.position.copy(origin);
-  return group;
-};
-
-if (SCENE.axes) {
-  const origin = vec(SCENE.axes.origin);
-  const ref = Math.max(...SCENE.axes.arrows.map((a) => vec(a.vector).length()), 1e-3);
-  for (const arrow of SCENE.axes.arrows) {
-    const v = vec(arrow.vector);
-    groups.axes.add(buildArrow(origin, v, arrow.colour, ref));
-    const div = document.createElement('div');
-    div.textContent = arrow.letter;
-    div.style.color = rgbCss(arrow.colour);
-    div.style.fontWeight = 'bold';
-    const tag = new CSS2DObject(div);
-    tag.position.copy(origin.clone().add(v.clone().multiplyScalar(1.08)));
-    groups.axes.add(tag);
-  }
-}
+// Axis arrows are built after the camera fit (below), so their thickness, head,
+// and overhang can be sized from the on-screen zoom and look identical in
+// every cell regardless of size or proportions.
 
 for (const label of SCENE.labels) {
   const div = document.createElement('div');
@@ -268,8 +235,9 @@ const aspect = width / height;
 const cellBasis = SCENE.axes ? SCENE.axes.arrows.map((a) => vec(a.vector)) : [];
 
 // Real content points the framing must enclose — atom centres, cell vertices,
-// axis-arrow tips and their label glyphs. (AABB corners are wrong here: they
-// stick out into empty space and over-zoom-out the view.) fitPad grows the
+// and the cell origin. (AABB corners are wrong here: they stick out into empty
+// space and over-zoom-out the view.) Axis arrows are sized from the zoom and
+// reserved via `margin` below, not enclosed point-by-point. fitPad grows the
 // extent by the largest atom radius so boundary spheres are not clipped.
 const fitPoints = [];
 let fitPad = 0;
@@ -277,12 +245,7 @@ for (const a of SCENE.atoms) { fitPoints.push(vec(a.centre)); fitPad = Math.max(
 for (const s of SCENE.wedgeSpheres || []) { fitPoints.push(vec(s.centre)); fitPad = Math.max(fitPad, s.radius); }
 for (const e of SCENE.ellipsoids || []) { fitPoints.push(vec(e.centre)); fitPad = Math.max(fitPad, Math.max(...e.semiAxes)); }
 for (const edge of SCENE.cellEdges || []) { fitPoints.push(vec(edge.start), vec(edge.end)); }
-if (SCENE.axes) {
-  const axesOrigin = vec(SCENE.axes.origin);
-  fitPoints.push(axesOrigin);
-  for (const arrow of SCENE.axes.arrows)
-    fitPoints.push(axesOrigin.clone().add(vec(arrow.vector).multiplyScalar(1.16)));
-}
+if (SCENE.axes) fitPoints.push(vec(SCENE.axes.origin));
 if (!fitPoints.length) fitPoints.push(box.min.clone(), box.max.clone());
 
 // Default orientation: longest cell axis horizontal, 2nd-longest vertical, the
@@ -322,8 +285,11 @@ for (const p of fitPoints) {
   minV = Math.min(minV, v); maxV = Math.max(maxV, v);
 }
 target.addScaledVector(camRight, (minU + maxU) / 2).addScaledVector(camUp, (minV + maxV) / 2);
-const halfW = Math.max((maxU - minU) / 2 + fitPad, 0.5) * 1.06;
-const halfH = Math.max((maxV - minV) / 2 + fitPad, 0.5) * 1.06;
+// Reserve extra extent for the axis arrows (drawn beyond the cell, sized from
+// the zoom below) and their letters, so they stay inside the frame.
+const margin = SCENE.axes ? 1.24 : 1.06;
+const halfW = Math.max((maxU - minU) / 2 + fitPad, 0.5) * margin;
+const halfH = Math.max((maxV - minV) / 2 + fitPad, 0.5) * margin;
 const radius = Math.max(halfW, halfH);
 const far = radius * 100;
 const tanV = Math.tan((45 * Math.PI) / 360);
@@ -349,15 +315,47 @@ ortho.position.copy(home);
 let camera = ortho;
 let projection = 'orthographic';
 
-// Normalise axis-arrow thickness to the on-screen zoom so arrows look equally
-// thin in every cell. They are built proportional to the longest axis, but the
-// ortho zoom is not (it depends on aspect and the trimetric tilt), so wide or
-// elongated cells would otherwise show fatter arrows than cubic ones. Scale
-// radially only, leaving each arrow's length and overhang untouched.
-if (SCENE.axes && SCENE.axes.arrows.length) {
-  const builtRef = Math.max(...SCENE.axes.arrows.map((a) => vec(a.vector).length()), 1e-3);
-  const arrowScale = (orthoHalfH * 0.010) / (builtRef * 0.012);
-  groups.axes.children.forEach((g) => { if (g.isGroup) g.scale.set(arrowScale, 1, arrowScale); });
+// Build the axis arrows now (after the fit) so every dimension is a fixed
+// fraction of the on-screen zoom (orthoHalfH): identical thickness, head
+// length, and overhang past the cell corner in every cell, regardless of size
+// or proportions. The cell-edge length is recovered per axis so the shaft still
+// reaches the cell corner before overhanging.
+if (SCENE.axes && SCENE.axes.arrows.length === 3) {
+  const Y_AXIS = new THREE.Vector3(0, 1, 0);
+  const origin = vec(SCENE.axes.origin);
+  const arrowVecs = SCENE.axes.arrows.map((a) => vec(a.vector));
+  const maxAxis = Math.max(...arrowVecs.map((v) => v.length()), 1e-3) / 1.3;
+  const shaftR = orthoHalfH * 0.009;
+  const headR = orthoHalfH * 0.028;
+  const headLen = orthoHalfH * 0.085;
+  // Overhang past the cell corner: at least clear the largest atom (corner
+  // atoms otherwise hide the head) plus the head length and a small gap, so the
+  // cap is always fully visible beyond any corner atom.
+  const overhang = Math.max(orthoHalfH * 0.09, fitPad + headLen + orthoHalfH * 0.04);
+  SCENE.axes.arrows.forEach((arrow, i) => {
+    const v = arrowVecs[i];
+    const dir = v.clone().normalize();
+    const axisLen = Math.max(v.length() - 0.3 * maxAxis, 1e-3);
+    const total = axisLen + overhang;
+    const shaftLen = Math.max(total - headLen, 1e-3);
+    const material = solidMat(col(arrow.colour));
+    const group = new THREE.Group();
+    const shaft = new THREE.Mesh(new THREE.CylinderGeometry(shaftR, shaftR, shaftLen, 16), material);
+    shaft.position.y = shaftLen / 2;
+    const head = new THREE.Mesh(new THREE.ConeGeometry(headR, headLen, 20), material);
+    head.position.y = shaftLen + headLen / 2;
+    group.add(shaft, head);
+    group.quaternion.setFromUnitVectors(Y_AXIS, dir);
+    group.position.copy(origin);
+    groups.axes.add(group);
+    const div = document.createElement('div');
+    div.textContent = arrow.letter;
+    div.style.color = rgbCss(arrow.colour);
+    div.style.fontWeight = 'bold';
+    const tag = new CSS2DObject(div);
+    tag.position.copy(origin).addScaledVector(dir, total + orthoHalfH * 0.05);
+    groups.axes.add(tag);
+  });
 }
 
 const controls = new OrbitControls(camera, renderer.domElement);

From f37c392906d2db3d5a29e8bf0c147f59bef5cfc7 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 09:05:46 +0200
Subject: [PATCH 068/160] Hide a/b/c axis labels with the axes toggle

---
 .../display/structure/templates/structure.html.j2              | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index f4daac9d3..941981567 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -436,6 +436,9 @@ for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
   button.addEventListener('click', () => {
     const next = !groups[name].visible;
     groups[name].visible = next;
+    // CSS2D labels (a/b/c, atom labels) ignore ancestor visibility in the
+    // CSS2DRenderer, so toggle them explicitly to match the meshes.
+    groups[name].traverse((o) => { if (o.isCSS2DObject) o.visible = next; });
     button.classList.toggle('on', next);
   });
 }

From 9898d3ad1da47c683aea426adc6de536a39b7e3c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:29:08 +0200
Subject: [PATCH 069/160] Note crysview Phase 2 coverage and superseded prose

---
 docs/dev/plans/crysview-structure-visualization.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 1eaafa55a..5cb7c7aea 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -5,6 +5,18 @@ Implementation plan for the
 ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
 exceptions to those instructions.
 
+> **Status (updated).** Phase 1 (code) shipped on this branch — the
+> feature is implemented. **Phase 2 (tests) was never executed**; its
+> unit-test files are discharged by the
+> [`structure-view-settings`](structure-view-settings.md) plan's Phase 2,
+> written once against the final API. Some prose below is kept only as a
+> historical design record and predates two later changes: the
+> `atom_shape`/`radius_model` → `atom_view` merge (commit `f31996da7`)
+> and the `structure-view-settings` split of `style` / `rendering_structure`
+> into `rendering_structure` (engine) + `structure_view` + `structure_style`.
+> See the crysview ADR and the `structure-view-settings` plan for the
+> current design.
+
 > **Context for this plan.** This is a **greenfield feature**: there is
 > no prior crysview implementation on the branch. The ADR review cycle
 > closed at the review-5 sentinel ("No findings. Ready to commit."), so

From 1692ac011170b116c1183ecd3e3ad4a0368aa974 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:30:18 +0200
Subject: [PATCH 070/160] Add value-selector-discovery ADR suggestion

---
 docs/dev/adrs/index.md                        |   1 +
 .../suggestions/value-selector-discovery.md   | 216 ++++++++++++++++++
 2 files changed, 217 insertions(+)
 create mode 100644 docs/dev/adrs/suggestions/value-selector-discovery.md

diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index be1eb4485..622dc9980 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -51,3 +51,4 @@ folders.
 | User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                      | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)      |
 | User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.  | [`switchable-category-api.md`](accepted/switchable-category-api.md)                          |
 | User-facing API      | Accepted   | Switchable Category Owned Selectors       | Moves the writable `type` selector and `show_supported()` onto the category itself; collapses the CIF duplication. | [`switchable-category-owned-selectors.md`](accepted/switchable-category-owned-selectors.md)  |
+| User-facing API      | Suggestion | Value-Selector Discovery                  | Gives enumerated value fields a per-descriptor `show_supported()`, beside the three category-level selector families. | [`value-selector-discovery.md`](suggestions/value-selector-discovery.md)                     |
diff --git a/docs/dev/adrs/suggestions/value-selector-discovery.md b/docs/dev/adrs/suggestions/value-selector-discovery.md
new file mode 100644
index 000000000..8bf4b2169
--- /dev/null
+++ b/docs/dev/adrs/suggestions/value-selector-discovery.md
@@ -0,0 +1,216 @@
+# ADR: Value-Selector Discovery
+
+## Status
+
+Proposed.
+
+## Date
+
+2026-05-31
+
+## Group
+
+User-facing API.
+
+## Context
+
+EasyDiffraction is used by scientists who explore the API in notebooks,
+so every "pick one of a fixed set" choice should be discoverable in
+place.
+
+Two accepted ADRs set up that expectation but only half-deliver it:
+
+- [`enum-backed-closed-values.md`](enum-backed-closed-values.md) requires
+  every finite closed set to be a `(str, Enum)` and names "finite choices
+  are discoverable" as a consequence. It also makes enum members the
+  source of truth for **descriptions**.
+- [`switchable-category-owned-selectors.md`](switchable-category-owned-selectors.md)
+  gives the three category-level selector families from
+  [`selector-families.md`](selector-families.md) — backend,
+  switchable-category, and active-sibling — a uniform public shape:
+
+  ```python
+  category.type = 'new-type'
+  category.show_supported()
+  ```
+
+  All three are *category-level* selectors: each has an owner
+  `_swap_<name>` hook, the category **is** the single selector, and
+  `show_supported()` lives on the category.
+
+But many enumerated choices are **not** category-level selectors. They
+are plain enumerated *fields* inside a category — there is no backend or
+category to swap, only a value the consumer reads. Examples today:
+
+- `structure_style.atom_view`, `structure_style.color_scheme`
+- the `experiment.experiment_type` axes (`sample_form`, `beam_mode`,
+  `radiation_probe`, `scattering_type`)
+- `verbosity` levels, and similar project-owned closed sets
+
+These value fields have **no discovery surface**. A scientist must read
+source or trigger a validation error to learn the options — exactly the
+gap the enum-backed ADR promised to close. They are declared ad hoc as
+`StringDescriptor(... MembershipValidator(allowed=[m.value for m in E]))`,
+duplicating the enum-to-allowed wiring at every site.
+
+Not every `MembershipValidator`-backed field qualifies. Some validate
+against **dynamic or external** sets rather than a project-owned closed
+enum: `atom_sites.type_symbol` (CrySPY isotope symbols from
+`DATABASE['Isotopes']`), `atom_sites.wyckoff_letter` (space-group
+dependent), `space_group.name_h_m` (CrySPY H-M symbols), and
+`space_group.it_coordinate_system_code` (derived from the current H-M
+symbol). These are boundary-facing CIF/science values, not `(str, Enum)`
+closed sets with a static `.default()`/`.description()`; they are out of
+scope here (see Decision and Deferred Work).
+
+## Decision
+
+Recognize a fourth selector shape — the **value selector** — and give it
+a discovery surface symmetric with the three category-level families.
+
+1. **Definition.** A value selector is an enumerated descriptor field
+   over a **project-owned, static `(str, Enum)`** closed set (per
+   [`enum-backed-closed-values.md`](enum-backed-closed-values.md)) whose
+   assignment sets a value (no class swap, no `_swap_<name>` hook). It is
+   distinct from the three category-level families in
+   [`selector-families.md`](selector-families.md), which swap a category
+   instance, rebind a backend, or activate siblings. A field whose allowed
+   set is **dynamic, external, or context-dependent** (validated against a
+   database or another field rather than a closed enum) is **not** a value
+   selector and is out of scope — see Decision 4.
+
+2. **Discovery lives on the descriptor.** A value selector exposes
+   `show_supported()` on the descriptor itself, reusing the **same**
+   `render_table` presentation and `*`-marks-current convention that
+   category-level `show_supported()` uses, with the value column and
+   descriptions sourced from the enum (per
+   [`enum-backed-closed-values.md`](enum-backed-closed-values.md)):
+
+   ```python
+   project.structure_style.color_scheme = 'vesta'      # set (string or member)
+   project.structure_style.color_scheme.show_supported()
+   # Color Scheme types
+   #    Value  Description
+   #    jmol   Jmol / CPK colour scheme
+   #  * vesta  VESTA colour scheme
+   ```
+
+   This sits beside the category-level shape, not replacing it:
+
+   ```python
+   project.rendering_structure.type = 'threejs'        # category-level selector
+   project.rendering_structure.show_supported()
+   ```
+
+3. **One descriptor, one source of truth.** Introduce a core
+   `EnumDescriptor` bound to a `(str, Enum)` class. It derives the
+   `MembershipValidator` and the default (`Enum.default()`) from the
+   enum, stores the enum, and renders `show_supported()` from
+   `Enum.description`. It replaces the manual
+   `StringDescriptor + MembershipValidator(allowed=[...])` pattern at
+   every value-selector site, so the enum is wired once.
+
+4. **Scope.** A non-switchable field adopts `EnumDescriptor` **only when
+   its allowed set is a project-owned, static `(str, Enum)`** — e.g.
+   `atom_view`, `color_scheme`, the `experiment_type` axes, `verbosity`.
+   Each such enum must expose `.default()` and `.description`; add them
+   where missing. Explicitly **out of scope**:
+   - Category-level `.type` selectors (the three families) — unchanged;
+     they keep their category-level `show_supported()`.
+   - **Dynamic / external / context-dependent** membership validators —
+     `atom_sites.type_symbol`, `atom_sites.wyckoff_letter`,
+     `space_group.name_h_m`, `space_group.it_coordinate_system_code`, and
+     any field whose allowed values come from a database, another field,
+     or runtime context. These keep their existing `MembershipValidator`
+     and current validation behavior; they do **not** become
+     `EnumDescriptor`s and do **not** gain `show_supported()` under this
+     ADR. A separate dynamic-choice discovery surface is deferred.
+
+   An implementation audit classifies each `MembershipValidator` field as
+   value selector, category-level selector, or dynamic/external before
+   any migration.
+
+5. **No category-level `show_supported()` on bundle categories.** A
+   category that holds several value selectors (e.g. `structure_style`,
+   `experiment.experiment_type`) does **not** gain a category-level
+   `show_supported()`. "Supported values of what?" has no single answer
+   on a multi-field bundle; discovery is per value selector. (A
+   clearly-named grouped overview may be added later for tightly-related
+   axis bundles — see Deferred Work.)
+
+6. **Numbers are not selectors.** Bounded numeric fields
+   (`adp_probability`, `atom_scale`, `range_*`, …) keep plain numeric
+   descriptors. Their limits live in the docstring and the validation
+   error; they have nothing to enumerate, so no `show_supported()`.
+
+7. **`help()` integration.** Because descriptors already expose `help()`
+   (per [`help-discoverability.md`](help-discoverability.md)),
+   `show_supported()` is surfaced automatically when a user calls
+   `help()` on the descriptor — `help()` says what the field is,
+   `show_supported()` lists its values.
+
+## Consequences
+
+- Every finite choice is discoverable at its own selector, finally
+  delivering the enum-backed ADR's "discoverable" promise for value
+  fields, with one table format shared across all selector shapes.
+- The public surface is uniform: *every* selector answers
+  `show_supported()`. Category-level selectors answer at
+  `category.show_supported()`; value selectors at
+  `category.field.show_supported()`. The asymmetry is intentional — a
+  category-level selector *is* the category, whereas a value field is one
+  of several on its category.
+- No deeper category tree: `show_supported()` is a method on the
+  descriptor the getter already returns, not a nested sub-category.
+- Immutable categories (per
+  [`immutable-experiment-type.md`](immutable-experiment-type.md)) still
+  expose `show_supported()` as read-only discovery, even where the value
+  is creation-time only.
+- This is a project-wide migration of the **enum-backed** value selectors
+  only (the audit pins the exact set; the dynamic/external validators
+  above are excluded and keep their current behavior). Affected enums gain
+  `.default()`/`.description` where missing. The phased rollout — and the
+  matching narrowing of which `atom_sites`/`space_group` fields are touched
+  — is tracked by the
+  [`structure-view-settings`](../../plans/structure-view-settings.md)
+  implementation plan, which also reorganizes the structure-view
+  categories that motivated this ADR.
+
+## Alternatives Considered
+
+- **Promote each value selector to a switchable category.** Rejected:
+  the three families in [`selector-families.md`](selector-families.md)
+  swap a category instance, a backend, or siblings via a `_swap_<name>`
+  hook; a colour scheme or atom-view mode swaps nothing. Forcing that
+  machinery would either nest a category under a category
+  (`structure_style.color_scheme.type` — a deeper tree, which violates
+  the flat-sibling rule) or pollute the top level (`project.color_scheme`).
+- **Category-level `show_supported()` listing every enumerated field on
+  the bundle.** Rejected as the primary surface: ambiguous on a
+  multi-field category and redundant with the per-descriptor method. Kept
+  open only as an optional, clearly-named grouped overview for related
+  axis bundles (Deferred Work).
+- **Rely on `help()`, docstrings, and validation errors.** Rejected:
+  `help()` describes the field but does not enumerate accepted values
+  with the active one marked, and users should not have to trigger an
+  error to learn the options.
+- **Keep `StringDescriptor + MembershipValidator(allowed=[...])` and bolt
+  on `show_supported()` per site.** Rejected: duplicates the
+  enum-to-allowed wiring, is easy to forget, and has no single source of
+  truth. `EnumDescriptor` binds the enum once and derives validation,
+  default, and discovery together.
+
+## Deferred Work
+
+- A separate **dynamic-choice descriptor** giving a discovery surface
+  (a `show_supported()`-style listing) to fields whose allowed set is
+  dynamic, external, or context-dependent — `atom_sites.type_symbol`,
+  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
+  `space_group.it_coordinate_system_code`, and similar. Out of scope here;
+  these keep their current `MembershipValidator` until such a descriptor
+  exists.
+- An optional, clearly-named grouped overview for tightly-related axis
+  bundles (notably `experiment.experiment_type`'s four axes shown
+  together). Not part of the initial rollout.
+- Adopting `EnumDescriptor` at value-selector sites beyond those the
+  motivating plan touches, if any remain after the audit.

From b360e59cd6439e07a8bc1ceefc928fc3a698cfb5 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:30:18 +0200
Subject: [PATCH 071/160] Add structure-view-settings implementation plan

---
 docs/dev/plans/structure-view-settings.md | 299 ++++++++++++++++++++++
 1 file changed, 299 insertions(+)
 create mode 100644 docs/dev/plans/structure-view-settings.md

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
new file mode 100644
index 000000000..c9b941507
--- /dev/null
+++ b/docs/dev/plans/structure-view-settings.md
@@ -0,0 +1,299 @@
+# Plan: Uniform value-selector discovery + structure-view settings split
+
+Follows [`AGENTS.md`](../../../AGENTS.md). It applies the standard two-phase
+workflow, with one deliberate exception — the implementation branch (see
+**Branch & PR** below). The slug `structure-view-settings` is
+retained for continuity (it began as the `project.style` consolidation), but the
+scope has broadened: Part A introduces a project-wide selector-discovery
+convention, and Part B reorganises the structure-view settings on top of it.
+
+**Branch & PR (deliberate exception).** §Planning asks for a flat-slug
+`structure-view-settings` branch off `develop`. This plan deliberately deviates:
+the work continues on the in-flight `crysview-structure-visualization` branch
+because it builds directly on the structure-view rendering commits already there
+(not yet on `develop`) and ships as part of the same crysview feature delivery.
+The PR still targets `develop`, not `master`. If the convention work is later
+split from the visualization PR, a dedicated `structure-view-settings` branch off
+`develop` is the fallback.
+
+## ADR
+
+This plan now needs ADR work (it was previously "no ADR required"):
+
+- **New ADR — `value-selector-discovery`** (draft via `/draft-adr` before
+  Phase 1, or accept alongside this plan). Recognises a **fourth** selector
+  shape beyond the three category-level families in
+  [`selector-families.md`](../adrs/accepted/selector-families.md):
+  - **Category-level selectors** — the backend, switchable-category, and
+    active-sibling families. Each *is* a category and owns `<category>.type` +
+    category-level `<category>.show_supported()` per
+    [`switchable-category-owned-selectors.md`](../adrs/accepted/switchable-category-owned-selectors.md).
+    **Unchanged by this plan.**
+  - **Value selectors** — enumerated descriptor *fields* over a project-owned
+    static `(str, Enum)` (no class swap, no `_swap_<name>` hook). They gain a
+    descriptor-level `show_supported()` reusing the **same** `render_table` and
+    `*`-marks-current convention. This is the new half.
+- **Update — crysview ADR**
+  ([`crysview-structure-visualization.md`](../adrs/suggestions/crysview-structure-visualization.md)):
+  the structure-view surface becomes three categories; `_style.*` →
+  `_structure_style.*`; `show_labels`/`show_moments`/`range_*` move to
+  `_structure_view.*`; `_rendering_structure.*` reduces to `type`;
+  `atom_view`/`color_scheme` become value selectors with `show_supported()`.
+
+## Motivation
+
+Two long-standing inconsistencies, fixed together because Part B depends on
+Part A:
+
+1. **Selector discovery is half-built.** Switchable categories expose
+   `show_supported()` (e.g. `rendering_plot.show_supported()`), but the
+   project-owned enum-backed *value* selectors (`experiment.experiment_type`
+   axes, `verbosity`, the structure `atom_view`/`color_scheme`, …) have **no**
+   uniform way to list their accepted values. Scientists must read source or
+   trigger a validation error to learn the options. (Fields with dynamic or
+   external membership — `atom_sites.type_symbol`, `space_group.name_h_m`, … —
+   are *not* value selectors and are out of scope; see the ADR.)
+2. **Structure-view settings are split awkwardly.** `project.rendering_structure`
+   carries engine + content + region; `project.style` (generic `_style.*`)
+   carries appearance — but `rendering_plot`/`rendering_table` are pure engine
+   selectors. The structure view should match that layering and isolate the
+   appearance settings that will keep growing (bonds, polyhedra, lighting,
+   moment scale).
+
+## Decisions
+
+- **`EnumDescriptor` (Part A).** A new `core/variable.py` descriptor bound to a
+  `(str, Enum)`. It derives `allowed` (the `MembershipValidator`) and the
+  default (`Enum.default()`) from the enum, stores the enum class, and exposes
+  `show_supported()` rendering `render_table(['', 'Value', 'Description'])` with
+  `*` on the current value and descriptions from `Enum.description`. Replaces the
+  manual `StringDescriptor(... MembershipValidator(allowed=[m.value for m in E]))`
+  pattern for value selectors.
+- **Enums gain `.default()` and `.description` (Part A).** Every enum behind a
+  value selector must expose both; add them where missing. Wording is concise,
+  scientist-facing.
+- **Scope is project-owned static enum sets only.** A field migrates to
+  `EnumDescriptor` only when its allowed set is a project-owned, static
+  `(str, Enum)` closed set (`atom_view`, `color_scheme`, the `experiment_type`
+  axes, `verbosity`). Two buckets are out of scope and unchanged: (a) category-level
+  `.type` selectors — the backend, switchable-category, and active-sibling
+  families — keep their category-level `show_supported()` per the
+  selector-families and switchable ADRs; (b) **dynamic / external /
+  context-dependent** membership validators —
+  `atom_sites.type_symbol`, `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
+  `space_group.it_coordinate_system_code` — keep their current
+  `MembershipValidator` (a dynamic-choice discovery surface is deferred per the
+  ADR). The P1.3 audit sorts every field into one of these three buckets.
+- **Numerics stay plain.** `adp_probability`, `atom_scale`, the `range_*`
+  scalars, and similar bounded numbers remain `NumericDescriptor`s; their limits
+  live in the docstring + validation error, not in a `show_supported()` table
+  (nothing to enumerate). This resolves the earlier "list all vs enumerated
+  only" question: selectors list, scalars document.
+- **Three flat sibling categories (Part B).**
+  - `rendering_structure` — engine only: `type` (+ the live `viewer` facade),
+    `show_supported()` already lists engines. CIF: `_rendering_structure.type`.
+  - `structure_view` — durable content/region: `show_labels`, `show_moments`,
+    and six flat `range_{a,b,c}_{min,max}` scalars. CIF: `_structure_view.*`.
+  - `structure_style` — durable appearance: `atom_view`, `color_scheme`
+    (`EnumDescriptor`s), `adp_probability`, `atom_scale`. CIF:
+    `_structure_style.*`.
+- **Range stays six flat scalars.** API is `range_a_min … range_c_max` (six
+  setters), 1:1 with the six CIF tags, mirroring the six `_cell.*` parameters.
+  Keep the internal `view_range()` helper that assembles the
+  `((a_min,a_max),(b_min,b_max),(c_min,c_max))` tuple, and the per-call `range=`
+  override on `display.structure()` (per the crysview ADR). No tuple-valued
+  public setter.
+- **Per-descriptor discovery only.** `show_supported()` lives on the value
+  selector itself (`structure_style.color_scheme.show_supported()`), never on the
+  bundle category. Switchable categories keep their category-level
+  `show_supported()` because the category *is* a single selector; a multi-setting
+  bundle has no single "supported values", so a method there would be ambiguous
+  and redundant. An `experiment_type` overview (its four axes shown together) may
+  be added later as a clearly-named convenience — deferred, not part of this
+  change.
+- **No nesting, no deeper tree.** `color_scheme.show_supported()` is a method on
+  the descriptor the getter already returns — not a sub-category. The category
+  tree depth is unchanged.
+- **CIF renames (beta → no shim).** `_style.*` is dropped; `_structure_view.*`
+  and `_structure_style.*` are added; `_rendering_structure.*` reduces to
+  `type`. No backward-compatible reader.
+- **Defaults preserved.** Keep current defaults during the move
+  (`adp_probability`, `atom_scale`, the show flags, range bounds, every migrated
+  selector's default).
+
+## Open questions
+
+None outstanding:
+
+- **Naming — resolved.** `structure_view` / `structure_style` (CIF
+  `_structure_view.*` / `_structure_style.*`), confirmed.
+- **Discovery surface — resolved.** Per-descriptor `show_supported()` only; no
+  category-level method on the non-switchable bundle categories (see Decisions).
+- **Selector classification** is handled by the P1.3 audit (three buckets:
+  value selector / category-level selector / dynamic-external) and recorded in
+  this plan during implementation.
+
+## Concrete files likely to change
+
+**Part A — convention + project-wide migration**
+
+- `src/easydiffraction/core/variable.py` — add `EnumDescriptor`; reuse
+  `render_table` from `utils/utils.py`.
+- `src/easydiffraction/core/validation.py` — only if a small helper eases
+  deriving `allowed` from an enum.
+- Value-selector enums (add `.default()`/`.description` where missing):
+  `display/structure/enums.py` (`AtomViewEnum`, `ColorSchemeEnum`),
+  `datablocks/experiment/categories/experiment_type/*` (sample_form, beam_mode,
+  radiation_probe, scattering_type), `project/categories/verbosity/*`, and any
+  others the audit confirms as project-owned closed sets. **Excluded** (dynamic
+  or external membership, unchanged): `atom_sites.type_symbol`,
+  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
+  `space_group.it_coordinate_system_code`.
+- The category files that declare those value selectors → switch the field
+  declarations to `EnumDescriptor` (one commit per area; see Phase 1).
+
+**Part B — structure-view three-way split**
+
+- `src/easydiffraction/project/categories/rendering_structure/default.py` —
+  remove `show_labels`/`show_moments`/`range_*`; keep `type` + `viewer`.
+- `src/easydiffraction/project/categories/structure_view/` — **new** package
+  (`__init__.py`, `default.py`, `factory.py`): the moved content/region settings
+  + `view_range()`.
+- `src/easydiffraction/project/categories/structure_style/` — **renamed** from
+  `style/`: `atom_view`/`color_scheme` as `EnumDescriptor`, `adp_probability`/
+  `atom_scale` as `NumericDescriptor`; CIF `_structure_style.*`.
+- `src/easydiffraction/project/categories/style/` — **removed**.
+- `src/easydiffraction/project/project.py`,
+  `src/easydiffraction/project/project_config.py` — add
+  `project.structure_view` / `project.structure_style`; drop `project.style`.
+- `src/easydiffraction/io/cif/serialize.py` — swap the `style` block for the
+  `structure_view` + `structure_style` blocks; trim `rendering_structure`.
+- `src/easydiffraction/display/structure/builder.py`,
+  `src/easydiffraction/project/display.py`,
+  `src/easydiffraction/report/html_renderer.py`,
+  `src/easydiffraction/report/tex_renderer.py` — repoint `style=` to
+  `project.structure_style` and read the view window/flags from
+  `project.structure_view`.
+
+**Docs / tutorials / tests**
+
+- `docs/docs/user-guide/analysis-workflow/model.md` (the `project.style.*`
+  examples); the crysview ADR; the new `value-selector-discovery` ADR.
+- `docs/docs/tutorials/ed-3.py`, `ed-14.py`, `ed-17.py` (any `project.style.*`),
+  then `pixi run notebook-prepare`.
+- Tests mirroring every changed module: `EnumDescriptor` + `show_supported`,
+  each migrated category, new `structure_view`/`structure_style`, removed
+  `style`; repoint `tests/.../project/test_project_config.py`,
+  `test_project_load.py`, `display/plotters/test_plotly.py`. Verify the mirror
+  with `pixi run test-structure-check`.
+
+## Implementation steps (Phase 1)
+
+Each step is one atomic commit (stage explicit paths; commit before the next)
+per §Commits. When an AI agent follows this plan, every completed Phase 1 step
+is staged and committed locally before moving on.
+
+**Part A — value-selector discovery convention**
+
+- [ ] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py` with the
+  `show_supported()` table (reuse `render_table`). Commit:
+  `Add EnumDescriptor with show_supported listing`.
+- [ ] **P1.2 — Enum metadata.** Add `.default()`/`.description` to value-selector
+  enums that lack them (no field migration yet). Commit:
+  `Add default and description to value-selector enums`.
+- [ ] **P1.3 — Classify selectors.** Audit every `MembershipValidator` usage;
+  record a three-bucket table in this plan (value selector / category-level
+  selector / dynamic-external), doc-only. Commit:
+  `Classify enumerated selectors for discovery`.
+- [ ] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
+  `radiation_probe`, `scattering_type` → `EnumDescriptor`. Commit:
+  `Use EnumDescriptor for experiment_type axes`.
+- [ ] **P1.5 — Migrate in-scope structure-data selectors.** Migrate only the
+  enum-backed value fields the P1.3 audit confirms (e.g. an ADP-type enum, if
+  present). The dynamic/external validators (`atom_sites.type_symbol`,
+  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
+  `space_group.it_coordinate_system_code`) are **out of scope** and keep their
+  current `MembershipValidator`. If the audit finds none in scope, mark this
+  step complete with no code change. Commit (if any):
+  `Use EnumDescriptor for structure-data selectors`.
+- [ ] **P1.6 — Migrate remaining value selectors.** `verbosity` and any others
+  from the audit → `EnumDescriptor`. Commit:
+  `Use EnumDescriptor for remaining value selectors`.
+
+**Part B — structure-view three-way split.** Ordered additive-first: the new
+categories and their consumers land before the old surfaces are removed, so
+**every commit imports and renders** — no intermediate revision loses a live
+API. A short bridge period where old and new surfaces coexist is intentional.
+
+- [ ] **P1.7 — Add `structure_view` (additive).** New category +
+  `project.structure_view` + a new `_structure_view.*` CIF block carrying
+  `show_labels`, `show_moments`, six `range_*` scalars, and `view_range()`.
+  `rendering_structure` keeps its copies for now. Commit:
+  `Add structure_view content/region category`.
+- [ ] **P1.8 — Add `structure_style` (additive).** New category +
+  `project.structure_style` + a new `_structure_style.*` CIF block;
+  `atom_view`/`color_scheme` as `EnumDescriptor`, `adp_probability`/`atom_scale`
+  as `NumericDescriptor`. The old `style` category / `project.style` stay for
+  now. Commit: `Add structure_style appearance category`.
+- [ ] **P1.9 — Repoint consumers to the new categories.** Builder, display
+  facade, and report renderers read appearance from `project.structure_style`
+  and the window/flags from `project.structure_view` (`builder.py`,
+  `display.py`, `html_renderer.py`, `tex_renderer.py`). After this commit
+  nothing reads `project.style` or `rendering_structure.view_range()`, but both
+  still exist — so the revision builds and renders. Commit:
+  `Read structure view and style from new categories`.
+- [ ] **P1.10 — Remove the old surfaces.** Now that no consumer uses them:
+  remove `show_labels`/`show_moments`/`range_*`/`view_range()` from
+  `rendering_structure` (leaving engine `type` + `viewer`); remove the `style`
+  package, `project.style`, and the bespoke `Style.show_supported()`; drop the
+  `_style.*` block and the moved `_rendering_structure.*` tags from CIF
+  serialise. Commit: `Remove the old style and rendering_structure surfaces`.
+- [ ] **P1.11 — Docs, ADRs, tutorials.** Update `model.md`, the crysview ADR,
+  the `value-selector-discovery` ADR, and `ed-3/14/17.py`; run
+  `pixi run notebook-prepare`; commit source + regenerated notebooks. Commit:
+  `Move structure-view docs and tutorials to new categories`.
+- [ ] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit the
+  checklist update alone. Commit: `Reach Phase 1 review gate`.
+
+## Phase 2 — Verification
+
+This Phase 2 also discharges the crysview feature's never-written unit tests
+(the [`crysview-structure-visualization`](crysview-structure-visualization.md)
+plan's Phase 2 was never executed — `display/structure/` has no unit tests),
+written **once** against the final post-split API:
+
+- **This plan's surfaces:** `EnumDescriptor` + per-selector `show_supported()`;
+  each migrated value selector; the new `structure_view` / `structure_style`
+  categories; removal of `style`; the slimmed `rendering_structure`.
+- **Crysview surfaces still untested:** `display/structure/` — `test_enums.py`,
+  `test_scene.py`, `test_builder.py`, `renderers/test_ascii.py`,
+  `renderers/test_raster.py`, `renderers/test_threejs.py`, `test_viewing.py`;
+  the crystallography geometry helpers; the element-radii asset;
+  `report/test_html_renderer.py` (structure figure); and the structure
+  surfaces of `project/test_display.py`.
+
+Mirror the source tree per §Testing (verify with `pixi run test-structure-check`),
+then run, capturing logs with the zsh-safe pattern:
+
+```sh
+pixi run fix
+pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
+pixi run test-structure-check
+pixi run unit-tests > /tmp/easydiffraction-unit.log 2>&1; unit_tests_exit_code=$?; tail -n 100 /tmp/easydiffraction-unit.log; exit $unit_tests_exit_code
+pixi run integration-tests > /tmp/easydiffraction-integration.log 2>&1; integration_tests_exit_code=$?; tail -n 100 /tmp/easydiffraction-integration.log; exit $integration_tests_exit_code
+pixi run script-tests > /tmp/easydiffraction-script.log 2>&1; script_tests_exit_code=$?; tail -n 100 /tmp/easydiffraction-script.log; exit $script_tests_exit_code
+```
+
+## Suggested Pull Request
+
+**Title:** Make every option list discoverable, and tidy structure-view settings
+
+**Description:** Any setting that takes one of a fixed list of values — the
+experiment type, atom depiction, colour scheme, verbosity, and more — can now
+show its options the same way, with the active one marked,
+via `show_supported()`. Separately, the structure-view settings are reorganised
+to match the rest of the project: `project.rendering_structure` now just selects
+the engine, `project.structure_view` holds what and where to draw, and
+`project.structure_style` holds how it looks. Structure-view settings saved by
+older versions (the `_style.*` block) need re-applying (beta: no automatic
+migration).

From a24643f91d756761a04e68fe0d5519f052f68280 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:35:18 +0200
Subject: [PATCH 072/160] Add EnumDescriptor with show_supported listing

---
 docs/dev/plans/structure-view-settings.md |  2 +-
 src/easydiffraction/core/variable.py      | 82 +++++++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index c9b941507..dcf022d87 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -195,7 +195,7 @@ is staged and committed locally before moving on.
 
 **Part A — value-selector discovery convention**
 
-- [ ] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py` with the
+- [x] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py` with the
   `show_supported()` table (reuse `render_table`). Commit:
   `Add EnumDescriptor with show_supported listing`.
 - [ ] **P1.2 — Enum metadata.** Add `.default()`/`.description` to value-selector
diff --git a/src/easydiffraction/core/variable.py b/src/easydiffraction/core/variable.py
index e9f6dd2c4..283660995 100644
--- a/src/easydiffraction/core/variable.py
+++ b/src/easydiffraction/core/variable.py
@@ -12,6 +12,7 @@
 from easydiffraction.core.units_vocabulary import normalize_units_code
 from easydiffraction.core.validation import AttributeSpec
 from easydiffraction.core.validation import DataTypes
+from easydiffraction.core.validation import MembershipValidator
 from easydiffraction.core.validation import RangeValidator
 from easydiffraction.core.validation import TypeValidator
 from easydiffraction.io.cif.serialize import param_from_cif
@@ -19,6 +20,8 @@
 from easydiffraction.utils.logging import log
 
 if TYPE_CHECKING:
+    from enum import StrEnum
+
     from easydiffraction.core.display_handler import DisplayHandler
     from easydiffraction.core.posterior import PosteriorParameterSummary
     from easydiffraction.io.cif.handler import CifHandler
@@ -644,6 +647,85 @@ def __init__(
 # ======================================================================
 
 
+class EnumDescriptor(StringDescriptor):
+    """String descriptor bound to a closed ``(str, Enum)`` value set.
+
+    Derives validation and the default from ``enum`` and exposes
+    ``show_supported()`` listing the members with the active one marked,
+    matching the switchable-category table (value-selector-discovery ADR).
+    """
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        enum: type[StrEnum],
+        cif_handler: CifHandler,
+        description: str | None = None,
+        default: str | None = None,
+        display_handler: DisplayHandler | None = None,
+    ) -> None:
+        """
+        Initialize an enum-backed string descriptor.
+
+        Parameters
+        ----------
+        name : str
+            Local name of the descriptor within its category.
+        enum : type[StrEnum]
+            The ``(str, Enum)`` class whose members are the allowed values.
+        cif_handler : CifHandler
+            Object that tracks CIF identifiers.
+        description : str | None, default=None
+            Optional human-readable description.
+        default : str | None, default=None
+            Default value; falls back to ``enum.default()`` when omitted.
+        display_handler : DisplayHandler | None, default=None
+            Optional labels and units for display contexts.
+        """
+        self._enum = enum
+        resolved_default = enum.default().value if default is None else default
+        value_spec = AttributeSpec(
+            default=resolved_default,
+            validator=MembershipValidator(allowed=[member.value for member in enum]),
+        )
+        super().__init__(
+            name=name,
+            description=description,
+            value_spec=value_spec,
+            cif_handler=cif_handler,
+            display_handler=display_handler,
+        )
+
+    @property
+    def enum(self) -> type[StrEnum]:
+        """Return the ``(str, Enum)`` class backing this selector."""
+        return self._enum
+
+    def show_supported(self) -> None:
+        """List the accepted values, marking the active one."""
+        # Lazy display imports keep core/ free of heavy imports on this
+        # rarely-called path (mirrors help()).
+        from easydiffraction.utils.logging import console  # noqa: PLC0415
+        from easydiffraction.utils.utils import render_table  # noqa: PLC0415
+
+        current = self.value
+        columns_data = [
+            ['*' if member.value == current else '', member.value, member.description()]
+            for member in self._enum
+        ]
+        title = self._name.replace('_', ' ').title()
+        console.paragraph(f'{title} types')
+        render_table(
+            columns_headers=['', 'Value', 'Description'],
+            columns_alignment=['left', 'left', 'left'],
+            columns_data=columns_data,
+        )
+
+
+# ======================================================================
+
+
 class BoolDescriptor(GenericBoolDescriptor):
     """Boolean descriptor bound to a CIF handler."""
 

From 65c7e17921a5907981a9e7e9c35337b626e14071 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:47:47 +0200
Subject: [PATCH 073/160] Classify enumerated selectors for discovery

---
 docs/dev/plans/structure-view-settings.md | 74 +++++++++++++++++------
 1 file changed, 57 insertions(+), 17 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index dcf022d87..f093c812f 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -83,7 +83,7 @@ Part A:
   `atom_sites.type_symbol`, `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
   `space_group.it_coordinate_system_code` — keep their current
   `MembershipValidator` (a dynamic-choice discovery surface is deferred per the
-  ADR). The P1.3 audit sorts every field into one of these three buckets.
+  ADR). The P1.2 audit sorts every field into one of these three buckets.
 - **Numerics stay plain.** `adp_probability`, `atom_scale`, the `range_*`
   scalars, and similar bounded numbers remain `NumericDescriptor`s; their limits
   live in the docstring + validation error, not in a `show_supported()` table
@@ -129,7 +129,7 @@ None outstanding:
   `_structure_view.*` / `_structure_style.*`), confirmed.
 - **Discovery surface — resolved.** Per-descriptor `show_supported()` only; no
   category-level method on the non-switchable bundle categories (see Decisions).
-- **Selector classification** is handled by the P1.3 audit (three buckets:
+- **Selector classification** is handled by the P1.2 audit (three buckets:
   value selector / category-level selector / dynamic-external) and recorded in
   this plan during implementation.
 
@@ -198,27 +198,31 @@ is staged and committed locally before moving on.
 - [x] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py` with the
   `show_supported()` table (reuse `render_table`). Commit:
   `Add EnumDescriptor with show_supported listing`.
-- [ ] **P1.2 — Enum metadata.** Add `.default()`/`.description` to value-selector
-  enums that lack them (no field migration yet). Commit:
-  `Add default and description to value-selector enums`.
-- [ ] **P1.3 — Classify selectors.** Audit every `MembershipValidator` usage;
+- [x] **P1.2 — Classify selectors.** Audit every `MembershipValidator` usage;
   record a three-bucket table in this plan (value selector / category-level
-  selector / dynamic-external), doc-only. Commit:
-  `Classify enumerated selectors for discovery`.
+  selector / dynamic-external), doc-only. See *Selector classification* below.
+  Commit: `Classify enumerated selectors for discovery`.
+- [ ] **P1.3 — Enum metadata.** Add `.default()`/`.description()` to the in-scope
+  value-selector enums that lack them (no field migration yet). Commit:
+  `Add default and description to value-selector enums`.
 - [ ] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
   `radiation_probe`, `scattering_type` → `EnumDescriptor`. Commit:
   `Use EnumDescriptor for experiment_type axes`.
-- [ ] **P1.5 — Migrate in-scope structure-data selectors.** Migrate only the
-  enum-backed value fields the P1.3 audit confirms (e.g. an ADP-type enum, if
-  present). The dynamic/external validators (`atom_sites.type_symbol`,
+- [ ] **P1.5 — Migrate `atom_sites.adp_type`.** The P1.2 audit confirms
+  `adp_type` (`AdpTypeEnum`) is the one in-scope structure-data value selector →
+  `EnumDescriptor` (preserve its dual CIF names `_atom_site.ADP_type` /
+  `_atom_site.adp_type` and the category's `adp_type` setter). The
+  dynamic/external validators (`atom_sites.type_symbol`,
   `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
   `space_group.it_coordinate_system_code`) are **out of scope** and keep their
-  current `MembershipValidator`. If the audit finds none in scope, mark this
-  step complete with no code change. Commit (if any):
-  `Use EnumDescriptor for structure-data selectors`.
-- [ ] **P1.6 — Migrate remaining value selectors.** `verbosity` and any others
-  from the audit → `EnumDescriptor`. Commit:
-  `Use EnumDescriptor for remaining value selectors`.
+  current `MembershipValidator`. Commit:
+  `Use EnumDescriptor for atom_sites adp_type`.
+- [ ] **P1.6 — Migrate remaining value selectors.** Per the P1.2 audit:
+  `verbosity.fit` (`VerbosityEnum`), `fit_result.result_kind`
+  (`FitResultKindEnum`), `fit_parameter_correlations.source_kind`
+  (`FitCorrelationSourceEnum`), and `extinction.model` (`ExtinctionModelEnum`)
+  → `EnumDescriptor`, one commit per area. Commit (per area):
+  `Use EnumDescriptor for <area> selector`.
 
 **Part B — structure-view three-way split.** Ordered additive-first: the new
 categories and their consumers land before the old surfaces are removed, so
@@ -255,6 +259,42 @@ API. A short bridge period where old and new surfaces coexist is intentional.
 - [ ] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit the
   checklist update alone. Commit: `Reach Phase 1 review gate`.
 
+### Selector classification (P1.2 audit)
+
+Every `MembershipValidator` site, sorted into the three buckets from the
+`value-selector-discovery` ADR, plus a fourth not-yet-enum-backed group.
+
+**Migrate to `EnumDescriptor` (project-owned static `(str, Enum)`):**
+
+| Field | Enum | Step | Note |
+| --- | --- | --- | --- |
+| `experiment_type.sample_form` | `SampleFormEnum` | P1.4 | has `display_handler` |
+| `experiment_type.beam_mode` | `BeamModeEnum` | P1.4 | has `display_handler` |
+| `experiment_type.radiation_probe` | `RadiationProbeEnum` | P1.4 | has `display_handler` |
+| `experiment_type.scattering_type` | `ScatteringTypeEnum` | P1.4 | has `display_handler` |
+| `atom_sites.adp_type` | `AdpTypeEnum` | P1.5 | dual CIF names; category setter |
+| `verbosity.fit` | `VerbosityEnum` | P1.6 | |
+| `fit_result.result_kind` | `FitResultKindEnum` | P1.6 | |
+| `fit_parameter_correlations.source_kind` | `FitCorrelationSourceEnum` | P1.6 | |
+| `extinction.model` | `ExtinctionModelEnum` | P1.6 | |
+| `style.atom_view` | `AtomViewEnum` | P1.8 | already has metadata |
+| `style.color_scheme` | `ColorSchemeEnum` | P1.8 | already has metadata |
+
+**Category-level `.type` selectors — unchanged** (backend / switchable-category
+/ active-sibling families): `rendering_plot`, `rendering_table`,
+`rendering_structure`, `minimizer`, `background`, `peak`, `calculator`,
+`extinction`, `fitting_mode`.
+
+**Dynamic / external / context-dependent — unchanged:**
+`atom_sites.type_symbol` (isotope database), `atom_sites.wyckoff_letter`
+(space-group dependent), `space_group.name_h_m` /
+`space_group.it_coordinate_system_code` (callable, H-M-derived), minimizer
+`initialization_method` (per-class enum **subset**, not the full set).
+
+**Bucket 4 — closed but not `(str, Enum)`, out of scope** (candidates for a
+future enum-ification per `enum-backed-closed-values`, tracked separately):
+`data.calc_status` (`['incl', 'excl']`), `emcee.proposal_moves` (raw tuple).
+
 ## Phase 2 — Verification
 
 This Phase 2 also discharges the crysview feature's never-written unit tests

From c84f7dde85d0d95d79681f994d0d75430b21bfcf Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:49:48 +0200
Subject: [PATCH 074/160] Add default and description to value-selector enums

---
 docs/dev/plans/structure-view-settings.md |  6 ++++--
 src/easydiffraction/analysis/enums.py     | 16 ++++++++++++++++
 src/easydiffraction/utils/enums.py        | 10 ++++++++++
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index f093c812f..0d6dda503 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -202,9 +202,11 @@ is staged and committed locally before moving on.
   record a three-bucket table in this plan (value selector / category-level
   selector / dynamic-external), doc-only. See *Selector classification* below.
   Commit: `Classify enumerated selectors for discovery`.
-- [ ] **P1.3 — Enum metadata.** Add `.default()`/`.description()` to the in-scope
+- [x] **P1.3 — Enum metadata.** Add `.default()`/`.description()` to the in-scope
   value-selector enums that lack them (no field migration yet). Commit:
-  `Add default and description to value-selector enums`.
+  `Add default and description to value-selector enums`. *(Only `VerbosityEnum`,
+  `FitResultKindEnum`, `FitCorrelationSourceEnum` lacked `description()`; the
+  rest already had both.)*
 - [ ] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
   `radiation_probe`, `scattering_type` → `EnumDescriptor`. Commit:
   `Use EnumDescriptor for experiment_type axes`.
diff --git a/src/easydiffraction/analysis/enums.py b/src/easydiffraction/analysis/enums.py
index 94d78cc64..3fd1803dc 100644
--- a/src/easydiffraction/analysis/enums.py
+++ b/src/easydiffraction/analysis/enums.py
@@ -41,6 +41,14 @@ def default(cls) -> FitResultKindEnum:
         """Return the default persisted fit-result kind."""
         return cls.DETERMINISTIC
 
+    def description(self) -> str:
+        """Return a human-readable description of this fit-result kind."""
+        if self is FitResultKindEnum.DETERMINISTIC:
+            return 'Least-squares (point-estimate) fit result.'
+        if self is FitResultKindEnum.BAYESIAN:
+            return 'Bayesian (posterior-sampling) fit result.'
+        return ''
+
 
 class FitCorrelationSourceEnum(StrEnum):
     """Source of a persisted fit-parameter correlation summary."""
@@ -52,3 +60,11 @@ class FitCorrelationSourceEnum(StrEnum):
     def default(cls) -> FitCorrelationSourceEnum:
         """Return the default persisted correlation source."""
         return cls.DETERMINISTIC
+
+    def description(self) -> str:
+        """Return a human-readable description of this correlation source."""
+        if self is FitCorrelationSourceEnum.DETERMINISTIC:
+            return 'Correlations from the least-squares covariance matrix.'
+        if self is FitCorrelationSourceEnum.POSTERIOR:
+            return 'Correlations from posterior samples.'
+        return ''
diff --git a/src/easydiffraction/utils/enums.py b/src/easydiffraction/utils/enums.py
index 64d980177..8de9ac148 100644
--- a/src/easydiffraction/utils/enums.py
+++ b/src/easydiffraction/utils/enums.py
@@ -28,3 +28,13 @@ class VerbosityEnum(StrEnum):
     def default(cls) -> VerbosityEnum:
         """Return the default verbosity (FULL)."""
         return cls.FULL
+
+    def description(self) -> str:
+        """Return a human-readable description of this verbosity level."""
+        if self is VerbosityEnum.FULL:
+            return 'Multi-line output with headers, tables, and details.'
+        if self is VerbosityEnum.SHORT:
+            return 'Single-line status messages per action.'
+        if self is VerbosityEnum.SILENT:
+            return 'No console output.'
+        return ''

From d779c9e2ce75cf7cc71812980fb9787b8dbe4fbf Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 11:58:51 +0200
Subject: [PATCH 075/160] Use EnumDescriptor for experiment_type axes

---
 docs/dev/plans/structure-view-settings.md     |  2 +-
 .../categories/experiment_type/default.py     | 52 ++++++-------------
 2 files changed, 18 insertions(+), 36 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 0d6dda503..d8a065a19 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -207,7 +207,7 @@ is staged and committed locally before moving on.
   `Add default and description to value-selector enums`. *(Only `VerbosityEnum`,
   `FitResultKindEnum`, `FitCorrelationSourceEnum` lacked `description()`; the
   rest already had both.)*
-- [ ] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
+- [x] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
   `radiation_probe`, `scattering_type` → `EnumDescriptor`. Commit:
   `Use EnumDescriptor for experiment_type axes`.
 - [ ] **P1.5 — Migrate `atom_sites.adp_type`.** The P1.2 audit confirms
diff --git a/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py b/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py
index 8616ed08c..24b3eba5b 100644
--- a/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py
+++ b/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py
@@ -13,9 +13,7 @@
 from easydiffraction.core.category import CategoryItem
 from easydiffraction.core.display_handler import DisplayHandler
 from easydiffraction.core.metadata import TypeInfo
-from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.validation import MembershipValidator
-from easydiffraction.core.variable import StringDescriptor
+from easydiffraction.core.variable import EnumDescriptor
 from easydiffraction.datablocks.experiment.categories.experiment_type.factory import (
     ExperimentTypeFactory,
 )
@@ -40,13 +38,10 @@ class ExperimentType(CategoryItem):
     def __init__(self) -> None:
         super().__init__()
 
-        self._sample_form = StringDescriptor(
+        self._sample_form = EnumDescriptor(
             name='sample_form',
+            enum=SampleFormEnum,
             description='Powder diffraction or single crystal diffraction',
-            value_spec=AttributeSpec(
-                default=SampleFormEnum.default().value,
-                validator=MembershipValidator(allowed=[member.value for member in SampleFormEnum]),
-            ),
             cif_handler=CifHandler(
                 names=['_expt_type.sample_form'],
                 iucr_name='_easydiffraction_experiment_type.sample_form',
@@ -57,13 +52,10 @@ def __init__(self) -> None:
             ),
         )
 
-        self._beam_mode = StringDescriptor(
+        self._beam_mode = EnumDescriptor(
             name='beam_mode',
+            enum=BeamModeEnum,
             description='Constant wavelength (CW) or time-of-flight (TOF) measurement',
-            value_spec=AttributeSpec(
-                default=BeamModeEnum.default().value,
-                validator=MembershipValidator(allowed=[member.value for member in BeamModeEnum]),
-            ),
             cif_handler=CifHandler(
                 names=['_expt_type.beam_mode'],
                 iucr_name='_easydiffraction_experiment_type.beam_mode',
@@ -73,15 +65,10 @@ def __init__(self) -> None:
                 latex_name='Beam mode',
             ),
         )
-        self._radiation_probe = StringDescriptor(
+        self._radiation_probe = EnumDescriptor(
             name='radiation_probe',
+            enum=RadiationProbeEnum,
             description='Neutron or X-ray diffraction measurement',
-            value_spec=AttributeSpec(
-                default=RadiationProbeEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in RadiationProbeEnum]
-                ),
-            ),
             cif_handler=CifHandler(
                 names=['_expt_type.radiation_probe'],
                 iucr_name='_easydiffraction_experiment_type.radiation_probe',
@@ -91,15 +78,10 @@ def __init__(self) -> None:
                 latex_name='Probe',
             ),
         )
-        self._scattering_type = StringDescriptor(
+        self._scattering_type = EnumDescriptor(
             name='scattering_type',
+            enum=ScatteringTypeEnum,
             description='Conventional Bragg diffraction or total scattering (PDF)',
-            value_spec=AttributeSpec(
-                default=ScatteringTypeEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in ScatteringTypeEnum]
-                ),
-            ),
             cif_handler=CifHandler(
                 names=['_expt_type.scattering_type'],
                 iucr_name='_easydiffraction_experiment_type.scattering_type',
@@ -131,41 +113,41 @@ def _set_scattering_type(self, value: str) -> None:
     # ------------------------------------------------------------------
 
     @property
-    def sample_form(self) -> StringDescriptor:
+    def sample_form(self) -> EnumDescriptor:
         """
         Powder diffraction or single crystal diffraction.
 
         Reading this property returns the underlying
-        ``StringDescriptor`` object.
+        ``EnumDescriptor`` object.
         """
         return self._sample_form
 
     @property
-    def beam_mode(self) -> StringDescriptor:
+    def beam_mode(self) -> EnumDescriptor:
         """
         Constant wavelength (CW) or time-of-flight (TOF) measurement.
 
         Reading this property returns the underlying
-        ``StringDescriptor`` object.
+        ``EnumDescriptor`` object.
         """
         return self._beam_mode
 
     @property
-    def radiation_probe(self) -> StringDescriptor:
+    def radiation_probe(self) -> EnumDescriptor:
         """
         Neutron or X-ray diffraction measurement.
 
         Reading this property returns the underlying
-        ``StringDescriptor`` object.
+        ``EnumDescriptor`` object.
         """
         return self._radiation_probe
 
     @property
-    def scattering_type(self) -> StringDescriptor:
+    def scattering_type(self) -> EnumDescriptor:
         """
         Conventional Bragg diffraction or total scattering (PDF).
 
         Reading this property returns the underlying
-        ``StringDescriptor`` object.
+        ``EnumDescriptor`` object.
         """
         return self._scattering_type

From 4a483a0fd0b8359ac5f775ddc4f85a8738b4b23c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:00:27 +0200
Subject: [PATCH 076/160] Use EnumDescriptor for atom_sites adp_type

---
 docs/dev/plans/structure-view-settings.md            |  2 +-
 .../structure/categories/atom_sites/default.py       | 12 +++++-------
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index d8a065a19..22782ef4c 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -210,7 +210,7 @@ is staged and committed locally before moving on.
 - [x] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
   `radiation_probe`, `scattering_type` → `EnumDescriptor`. Commit:
   `Use EnumDescriptor for experiment_type axes`.
-- [ ] **P1.5 — Migrate `atom_sites.adp_type`.** The P1.2 audit confirms
+- [x] **P1.5 — Migrate `atom_sites.adp_type`.** The P1.2 audit confirms
   `adp_type` (`AdpTypeEnum`) is the one in-scope structure-data value selector →
   `EnumDescriptor` (preserve its dual CIF names `_atom_site.ADP_type` /
   `_atom_site.adp_type` and the category's `adp_type` setter). The
diff --git a/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py b/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py
index ec47a19f2..0cae289e4 100644
--- a/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py
+++ b/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py
@@ -21,6 +21,7 @@
 from easydiffraction.core.validation import MembershipValidator
 from easydiffraction.core.validation import RangeValidator
 from easydiffraction.core.validation import RegexValidator
+from easydiffraction.core.variable import EnumDescriptor
 from easydiffraction.core.variable import Parameter
 from easydiffraction.core.variable import StringDescriptor
 from easydiffraction.crystallography import crystallography as ecr
@@ -167,18 +168,15 @@ def __init__(self) -> None:
                 ]
             ),
         )
-        self._adp_type = StringDescriptor(
+        self._adp_type = EnumDescriptor(
             name='adp_type',
+            enum=AdpTypeEnum,
             description='Type of atomic displacement parameter (ADP) '
             'used (e.g., Biso, Uiso, Uani, Bani).',
             display_handler=DisplayHandler(
                 display_name='ADP type',
                 latex_name='ADP type',
             ),
-            value_spec=AttributeSpec(
-                default=AdpTypeEnum.default(),
-                validator=MembershipValidator(allowed=[m.value for m in AdpTypeEnum]),
-            ),
             cif_handler=CifHandler(names=['_atom_site.ADP_type', '_atom_site.adp_type']),
         )
 
@@ -415,12 +413,12 @@ def type_symbol(self, value: str) -> None:
         self._type_symbol.value = value
 
     @property
-    def adp_type(self) -> StringDescriptor:
+    def adp_type(self) -> EnumDescriptor:
         """
         ADP type used (e.g., Biso, Uiso, Uani, Bani).
 
         Reading this property returns the underlying
-        ``StringDescriptor`` object. Assigning to it updates the
+        ``EnumDescriptor`` object. Assigning to it updates the
         parameter value.
         """
         return self._adp_type

From 983a12f93fb052176f8f0f51d015378d472af016 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:01:43 +0200
Subject: [PATCH 077/160] Use EnumDescriptor for verbosity selector

---
 .../project/categories/verbosity/default.py       | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/src/easydiffraction/project/categories/verbosity/default.py b/src/easydiffraction/project/categories/verbosity/default.py
index 09b3821c6..ad7d6b78b 100644
--- a/src/easydiffraction/project/categories/verbosity/default.py
+++ b/src/easydiffraction/project/categories/verbosity/default.py
@@ -6,9 +6,7 @@
 
 from easydiffraction.core.category import CategoryItem
 from easydiffraction.core.metadata import TypeInfo
-from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.validation import MembershipValidator
-from easydiffraction.core.variable import StringDescriptor
+from easydiffraction.core.variable import EnumDescriptor
 from easydiffraction.io.cif.handler import CifHandler
 from easydiffraction.project.categories.verbosity.factory import VerbosityFactory
 from easydiffraction.utils.enums import VerbosityEnum
@@ -28,20 +26,15 @@ class Verbosity(CategoryItem):
     def __init__(self) -> None:
         super().__init__()
 
-        self._fit = StringDescriptor(
+        self._fit = EnumDescriptor(
             name='fit',
+            enum=VerbosityEnum,
             description='Fitting process output verbosity',
-            value_spec=AttributeSpec(
-                default=VerbosityEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in VerbosityEnum],
-                ),
-            ),
             cif_handler=CifHandler(names=['_verbosity.fit']),
         )
 
     @property
-    def fit(self) -> StringDescriptor:
+    def fit(self) -> EnumDescriptor:
         """Fitting process output verbosity."""
         return self._fit
 

From 65e1798aa5b14afe11d399194e61f9eef27065e6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:02:51 +0200
Subject: [PATCH 078/160] Use EnumDescriptor for fit_result result_kind

---
 .../analysis/categories/fit_result/base.py          | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/easydiffraction/analysis/categories/fit_result/base.py b/src/easydiffraction/analysis/categories/fit_result/base.py
index 604b1020e..90668aa50 100644
--- a/src/easydiffraction/analysis/categories/fit_result/base.py
+++ b/src/easydiffraction/analysis/categories/fit_result/base.py
@@ -12,8 +12,8 @@
 from easydiffraction.core.display_handler import DisplayHandler
 from easydiffraction.core.metadata import TypeInfo
 from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.validation import MembershipValidator
 from easydiffraction.core.variable import BoolDescriptor
+from easydiffraction.core.variable import EnumDescriptor
 from easydiffraction.core.variable import GenericDescriptorBase
 from easydiffraction.core.variable import IntegerDescriptor
 from easydiffraction.core.variable import NumericDescriptor
@@ -49,15 +49,10 @@ class FitResultBase(CategoryItem):
 
     def __init__(self) -> None:
         super().__init__()
-        self._result_kind = StringDescriptor(
+        self._result_kind = EnumDescriptor(
             name='result_kind',
+            enum=FitResultKindEnum,
             description='Kind of the latest persisted fit-result projection.',
-            value_spec=AttributeSpec(
-                default=FitResultKindEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in FitResultKindEnum]
-                ),
-            ),
             cif_handler=CifHandler(names=['_fit_result.result_kind']),
             display_handler=_result_display_handler('Result kind'),
         )
@@ -98,7 +93,7 @@ def __init__(self) -> None:
         )
 
     @property
-    def result_kind(self) -> StringDescriptor:
+    def result_kind(self) -> EnumDescriptor:
         """Kind of the latest persisted fit-result projection."""
         return self._result_kind
 

From 9d95c7aa46ab985a3bd4775677e70aebc36ed882 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:03:46 +0200
Subject: [PATCH 079/160] Use EnumDescriptor for fit_parameter_correlations
 source_kind

---
 .../fit_parameter_correlations/default.py           | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/easydiffraction/analysis/categories/fit_parameter_correlations/default.py b/src/easydiffraction/analysis/categories/fit_parameter_correlations/default.py
index 4b08057e3..eb0b1260a 100644
--- a/src/easydiffraction/analysis/categories/fit_parameter_correlations/default.py
+++ b/src/easydiffraction/analysis/categories/fit_parameter_correlations/default.py
@@ -12,9 +12,9 @@
 from easydiffraction.core.category import CategoryItem
 from easydiffraction.core.metadata import TypeInfo
 from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.validation import MembershipValidator
 from easydiffraction.core.validation import RangeValidator
 from easydiffraction.core.validation import RegexValidator
+from easydiffraction.core.variable import EnumDescriptor
 from easydiffraction.core.variable import NumericDescriptor
 from easydiffraction.core.variable import StringDescriptor
 from easydiffraction.io.cif.handler import CifHandler
@@ -47,15 +47,10 @@ def __init__(self) -> None:
             ),
             cif_handler=CifHandler(names=['_fit_parameter_correlation.id']),
         )
-        self._source_kind = StringDescriptor(
+        self._source_kind = EnumDescriptor(
             name='source_kind',
+            enum=FitCorrelationSourceEnum,
             description='Origin of the persisted correlation summary.',
-            value_spec=AttributeSpec(
-                default=FitCorrelationSourceEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in FitCorrelationSourceEnum]
-                ),
-            ),
             cif_handler=CifHandler(names=['_fit_parameter_correlation.source_kind']),
         )
         self._param_unique_name_i = StringDescriptor(
@@ -96,7 +91,7 @@ def _set_id(self, value: str) -> None:
         self._id.value = value
 
     @property
-    def source_kind(self) -> StringDescriptor:
+    def source_kind(self) -> EnumDescriptor:
         """Origin of the persisted correlation summary."""
         return self._source_kind
 

From 195f648a40970113bbdf96be3ffe9ad61613109c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:04:56 +0200
Subject: [PATCH 080/160] Use EnumDescriptor for extinction model selector

---
 docs/dev/plans/structure-view-settings.md        |  2 +-
 .../categories/extinction/becker_coppens.py      | 16 +++++-----------
 2 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 22782ef4c..71300a725 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -219,7 +219,7 @@ is staged and committed locally before moving on.
   `space_group.it_coordinate_system_code`) are **out of scope** and keep their
   current `MembershipValidator`. Commit:
   `Use EnumDescriptor for atom_sites adp_type`.
-- [ ] **P1.6 — Migrate remaining value selectors.** Per the P1.2 audit:
+- [x] **P1.6 — Migrate remaining value selectors.** Per the P1.2 audit:
   `verbosity.fit` (`VerbosityEnum`), `fit_result.result_kind`
   (`FitResultKindEnum`), `fit_parameter_correlations.source_kind`
   (`FitCorrelationSourceEnum`), and `extinction.model` (`ExtinctionModelEnum`)
diff --git a/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py b/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py
index 4ddd12c8b..6bf58ac63 100644
--- a/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py
+++ b/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py
@@ -11,10 +11,9 @@
 from easydiffraction.core.metadata import Compatibility
 from easydiffraction.core.metadata import TypeInfo
 from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.validation import MembershipValidator
 from easydiffraction.core.validation import RangeValidator
+from easydiffraction.core.variable import EnumDescriptor
 from easydiffraction.core.variable import Parameter
-from easydiffraction.core.variable import StringDescriptor
 from easydiffraction.datablocks.experiment.categories.extinction.base import ExtinctionBase
 from easydiffraction.datablocks.experiment.categories.extinction.factory import ExtinctionFactory
 from easydiffraction.datablocks.experiment.item.enums import CalculatorEnum
@@ -51,15 +50,10 @@ class BeckerCoppensExtinction(ExtinctionBase):
     def __init__(self) -> None:
         super().__init__()
 
-        self._model = StringDescriptor(
+        self._model = EnumDescriptor(
             name='model',
+            enum=ExtinctionModelEnum,
             description='Mosaicity distribution model (gauss or lorentz)',
-            value_spec=AttributeSpec(
-                default=ExtinctionModelEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in ExtinctionModelEnum],
-                ),
-            ),
             cif_handler=CifHandler(
                 names=['_extinction.model'],
                 iucr_name='_easydiffraction_extinction.model',
@@ -106,12 +100,12 @@ def __init__(self) -> None:
     # ------------------------------------------------------------------
 
     @property
-    def model(self) -> StringDescriptor:
+    def model(self) -> EnumDescriptor:
         """
         Mosaicity distribution model (``'gauss'`` or ``'lorentz'``).
 
         Reading this property returns the underlying
-        ``StringDescriptor`` object. Assigning to it updates the
+        ``EnumDescriptor`` object. Assigning to it updates the
         descriptor value.
         """
         return self._model

From cf11738f98015d0b894951d23c46b03aafb49cf4 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:15:08 +0200
Subject: [PATCH 081/160] Add structure_view content/region category

---
 docs/dev/plans/structure-view-settings.md     |   2 +-
 .../categories/structure_view/__init__.py     |   8 +
 .../categories/structure_view/default.py      | 150 ++++++++++++++++++
 .../categories/structure_view/factory.py      |  17 ++
 src/easydiffraction/project/project.py        |   8 +
 src/easydiffraction/project/project_config.py |   8 +
 6 files changed, 192 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/project/categories/structure_view/__init__.py
 create mode 100644 src/easydiffraction/project/categories/structure_view/default.py
 create mode 100644 src/easydiffraction/project/categories/structure_view/factory.py

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 71300a725..fae1fedcc 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -231,7 +231,7 @@ categories and their consumers land before the old surfaces are removed, so
 **every commit imports and renders** — no intermediate revision loses a live
 API. A short bridge period where old and new surfaces coexist is intentional.
 
-- [ ] **P1.7 — Add `structure_view` (additive).** New category +
+- [x] **P1.7 — Add `structure_view` (additive).** New category +
   `project.structure_view` + a new `_structure_view.*` CIF block carrying
   `show_labels`, `show_moments`, six `range_*` scalars, and `view_range()`.
   `rendering_structure` keeps its copies for now. Commit:
diff --git a/src/easydiffraction/project/categories/structure_view/__init__.py b/src/easydiffraction/project/categories/structure_view/__init__.py
new file mode 100644
index 000000000..aafd3e971
--- /dev/null
+++ b/src/easydiffraction/project/categories/structure_view/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project structure_view category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.structure_view.default import StructureView
+from easydiffraction.project.categories.structure_view.factory import StructureViewFactory
diff --git a/src/easydiffraction/project/categories/structure_view/default.py b/src/easydiffraction/project/categories/structure_view/default.py
new file mode 100644
index 000000000..0abb81a2e
--- /dev/null
+++ b/src/easydiffraction/project/categories/structure_view/default.py
@@ -0,0 +1,150 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project structure_view category (durable content + region view state)."""
+
+from __future__ import annotations
+
+from easydiffraction.core.category import CategoryItem
+from easydiffraction.core.metadata import TypeInfo
+from easydiffraction.core.validation import AttributeSpec
+from easydiffraction.core.variable import BoolDescriptor
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.io.cif.handler import CifHandler
+from easydiffraction.project.categories.structure_view.factory import StructureViewFactory
+from easydiffraction.utils.logging import log
+
+
+def _range_descriptor(name: str, default: float) -> NumericDescriptor:
+    return NumericDescriptor(
+        name=name,
+        description='Per-axis fractional view-range bound.',
+        value_spec=AttributeSpec(default=default),
+        cif_handler=CifHandler(names=[f'_structure_view.{name}']),
+    )
+
+
+@StructureViewFactory.register
+class StructureView(CategoryItem):
+    """What and where to draw in the structure view (engine-neutral)."""
+
+    _category_code = 'structure_view'
+
+    type_info = TypeInfo(
+        tag='default',
+        description='Project structure_view category',
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._show_labels = BoolDescriptor(
+            name='show_labels',
+            description='Show atom labels when the view opens.',
+            value_spec=AttributeSpec(default=False),
+            cif_handler=CifHandler(names=['_structure_view.show_labels']),
+        )
+        self._show_moments = BoolDescriptor(
+            name='show_moments',
+            description='Show magnetic-moment arrows where the data exists.',
+            value_spec=AttributeSpec(default=True),
+            cif_handler=CifHandler(names=['_structure_view.show_moments']),
+        )
+        self._range_a_min = _range_descriptor('range_a_min', 0.0)
+        self._range_a_max = _range_descriptor('range_a_max', 1.0)
+        self._range_b_min = _range_descriptor('range_b_min', 0.0)
+        self._range_b_max = _range_descriptor('range_b_max', 1.0)
+        self._range_c_min = _range_descriptor('range_c_min', 0.0)
+        self._range_c_max = _range_descriptor('range_c_max', 1.0)
+
+    @property
+    def show_labels(self) -> BoolDescriptor:
+        """Whether atom labels are shown when the view opens."""
+        return self._show_labels
+
+    @show_labels.setter
+    def show_labels(self, value: bool) -> None:
+        self._show_labels.value = value
+
+    @property
+    def show_moments(self) -> BoolDescriptor:
+        """Whether moment arrows are shown where the data exists."""
+        return self._show_moments
+
+    @show_moments.setter
+    def show_moments(self, value: bool) -> None:
+        self._show_moments.value = value
+
+    def _set_bound(self, descriptor: NumericDescriptor, value: float, *, lower: float, upper: float) -> None:
+        if not lower < value < upper:
+            log.warning(
+                f"'{descriptor.name}' = {value} violates min < max on its axis; ignored.",
+            )
+            return
+        descriptor.value = value
+
+    @property
+    def range_a_min(self) -> NumericDescriptor:
+        """Lower fractional bound along a."""
+        return self._range_a_min
+
+    @range_a_min.setter
+    def range_a_min(self, value: float) -> None:
+        self._set_bound(self._range_a_min, value, lower=float('-inf'), upper=self._range_a_max.value)
+
+    @property
+    def range_a_max(self) -> NumericDescriptor:
+        """Upper fractional bound along a."""
+        return self._range_a_max
+
+    @range_a_max.setter
+    def range_a_max(self, value: float) -> None:
+        self._set_bound(self._range_a_max, value, lower=self._range_a_min.value, upper=float('inf'))
+
+    @property
+    def range_b_min(self) -> NumericDescriptor:
+        """Lower fractional bound along b."""
+        return self._range_b_min
+
+    @range_b_min.setter
+    def range_b_min(self, value: float) -> None:
+        self._set_bound(self._range_b_min, value, lower=float('-inf'), upper=self._range_b_max.value)
+
+    @property
+    def range_b_max(self) -> NumericDescriptor:
+        """Upper fractional bound along b."""
+        return self._range_b_max
+
+    @range_b_max.setter
+    def range_b_max(self, value: float) -> None:
+        self._set_bound(self._range_b_max, value, lower=self._range_b_min.value, upper=float('inf'))
+
+    @property
+    def range_c_min(self) -> NumericDescriptor:
+        """Lower fractional bound along c."""
+        return self._range_c_min
+
+    @range_c_min.setter
+    def range_c_min(self, value: float) -> None:
+        self._set_bound(self._range_c_min, value, lower=float('-inf'), upper=self._range_c_max.value)
+
+    @property
+    def range_c_max(self) -> NumericDescriptor:
+        """Upper fractional bound along c."""
+        return self._range_c_max
+
+    @range_c_max.setter
+    def range_c_max(self, value: float) -> None:
+        self._set_bound(self._range_c_max, value, lower=self._range_c_min.value, upper=float('inf'))
+
+    def view_range(self) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
+        """Assemble the per-axis ``((min, max), ...)`` fractional window."""
+        return (
+            (self._range_a_min.value, self._range_a_max.value),
+            (self._range_b_min.value, self._range_b_max.value),
+            (self._range_c_min.value, self._range_c_max.value),
+        )
+
+    @property
+    def as_cif(self) -> str:
+        """Return CIF representation of this structure_view category."""
+        return super().as_cif
diff --git a/src/easydiffraction/project/categories/structure_view/factory.py b/src/easydiffraction/project/categories/structure_view/factory.py
new file mode 100644
index 000000000..8e9ca467b
--- /dev/null
+++ b/src/easydiffraction/project/categories/structure_view/factory.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Factory for project structure_view categories."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from easydiffraction.core.factory import FactoryBase
+
+
+class StructureViewFactory(FactoryBase):
+    """Create project structure_view category instances."""
+
+    _default_rules: ClassVar[dict] = {
+        frozenset(): 'default',
+    }
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index e49b0083a..22b66e6dc 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -41,6 +41,7 @@
     from easydiffraction.project.categories.rendering_table import RenderingTable
     from easydiffraction.project.categories.verbosity import Verbosity
     from easydiffraction.project.categories.rendering_structure import RenderingStructure
+    from easydiffraction.project.categories.structure_view import StructureView
     from easydiffraction.project.project_info import ProjectInfo
     from easydiffraction.report import Report
 
@@ -213,6 +214,7 @@ def __init__(
         object.__setattr__(self, '_rendering_table', self._config.rendering_table)
         object.__setattr__(self, '_verbosity', self._config.verbosity)
         object.__setattr__(self, '_rendering_structure', self._config.rendering_structure)
+        object.__setattr__(self, '_structure_view', self._config.structure_view)
         object.__setattr__(self, '_style', self._config.style)
         object.__setattr__(self, '_report', self._config.report)
         self._publication = PublicationFactory.create(PublicationFactory.default_tag())
@@ -231,6 +233,7 @@ def _attach_category_parents(self) -> None:
         self._rendering_plot._parent = self
         self._rendering_table._parent = self
         self._rendering_structure._parent = self
+        self._structure_view._parent = self
         self._style._parent = self
         self._report._parent = self
         self._publication._parent = self
@@ -337,6 +340,11 @@ def rendering_structure(self) -> RenderingStructure:
         """Structure-view configuration bound to the project."""
         return self._rendering_structure
 
+    @property
+    def structure_view(self) -> StructureView:
+        """Structure-view content and region bound to the project."""
+        return self._structure_view
+
     @property
     def style(self) -> Style:
         """Structure-view styling bound to the project."""
diff --git a/src/easydiffraction/project/project_config.py b/src/easydiffraction/project/project_config.py
index 369466888..d5bbb8610 100644
--- a/src/easydiffraction/project/project_config.py
+++ b/src/easydiffraction/project/project_config.py
@@ -19,6 +19,8 @@
 from easydiffraction.project.categories.verbosity import VerbosityFactory
 from easydiffraction.project.categories.rendering_structure import RenderingStructure
 from easydiffraction.project.categories.rendering_structure import RenderingStructureFactory
+from easydiffraction.project.categories.structure_view import StructureView
+from easydiffraction.project.categories.structure_view import StructureViewFactory
 
 
 class ProjectConfig(CategoryOwner):
@@ -42,6 +44,7 @@ def __init__(
         self._rendering_table = RenderingTableFactory.create(RenderingTableFactory.default_tag())
         self._verbosity = VerbosityFactory.create(VerbosityFactory.default_tag())
         self._rendering_structure = RenderingStructureFactory.create(RenderingStructureFactory.default_tag())
+        self._structure_view = StructureViewFactory.create(StructureViewFactory.default_tag())
         self._style = StyleFactory.create(StyleFactory.default_tag())
 
     @property
@@ -74,6 +77,11 @@ def rendering_structure(self) -> RenderingStructure:
         """Structure-view configuration category."""
         return self._rendering_structure
 
+    @property
+    def structure_view(self) -> StructureView:
+        """Structure-view content and region category."""
+        return self._structure_view
+
     @property
     def style(self) -> Style:
         """Structure-view styling category."""

From 1b228043d029bab07af53f704eb87c355973dda9 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:18:40 +0200
Subject: [PATCH 082/160] Add structure_style appearance category

---
 docs/dev/plans/structure-view-settings.md     |   2 +-
 .../categories/structure_style/__init__.py    |   8 ++
 .../categories/structure_style/default.py     | 103 ++++++++++++++++++
 .../categories/structure_style/factory.py     |  17 +++
 src/easydiffraction/project/project.py        |   8 ++
 src/easydiffraction/project/project_config.py |   8 ++
 6 files changed, 145 insertions(+), 1 deletion(-)
 create mode 100644 src/easydiffraction/project/categories/structure_style/__init__.py
 create mode 100644 src/easydiffraction/project/categories/structure_style/default.py
 create mode 100644 src/easydiffraction/project/categories/structure_style/factory.py

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index fae1fedcc..28156f790 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -236,7 +236,7 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   `show_labels`, `show_moments`, six `range_*` scalars, and `view_range()`.
   `rendering_structure` keeps its copies for now. Commit:
   `Add structure_view content/region category`.
-- [ ] **P1.8 — Add `structure_style` (additive).** New category +
+- [x] **P1.8 — Add `structure_style` (additive).** New category +
   `project.structure_style` + a new `_structure_style.*` CIF block;
   `atom_view`/`color_scheme` as `EnumDescriptor`, `adp_probability`/`atom_scale`
   as `NumericDescriptor`. The old `style` category / `project.style` stay for
diff --git a/src/easydiffraction/project/categories/structure_style/__init__.py b/src/easydiffraction/project/categories/structure_style/__init__.py
new file mode 100644
index 000000000..bc92b70c7
--- /dev/null
+++ b/src/easydiffraction/project/categories/structure_style/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project structure_style category exports."""
+
+from __future__ import annotations
+
+from easydiffraction.project.categories.structure_style.default import StructureStyle
+from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
diff --git a/src/easydiffraction/project/categories/structure_style/default.py b/src/easydiffraction/project/categories/structure_style/default.py
new file mode 100644
index 000000000..2cc0d9941
--- /dev/null
+++ b/src/easydiffraction/project/categories/structure_style/default.py
@@ -0,0 +1,103 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Project structure_style category (durable structure-view appearance)."""
+
+from __future__ import annotations
+
+from easydiffraction.core.category import CategoryItem
+from easydiffraction.core.metadata import TypeInfo
+from easydiffraction.core.validation import AttributeSpec
+from easydiffraction.core.validation import RangeValidator
+from easydiffraction.core.variable import EnumDescriptor
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.display.structure.enums import AtomViewEnum
+from easydiffraction.display.structure.enums import ColorSchemeEnum
+from easydiffraction.io.cif.handler import CifHandler
+from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+
+@StructureStyleFactory.register
+class StructureStyle(CategoryItem):
+    """How the structure view looks (appearance, not per-element)."""
+
+    _category_code = 'structure_style'
+
+    type_info = TypeInfo(
+        tag='default',
+        description='Project structure_style category',
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._atom_view = EnumDescriptor(
+            name='atom_view',
+            enum=AtomViewEnum,
+            description='How atoms are sized and shaped in the structure view.',
+            cif_handler=CifHandler(names=['_structure_style.atom_view']),
+        )
+        self._color_scheme = EnumDescriptor(
+            name='color_scheme',
+            enum=ColorSchemeEnum,
+            description='Standard element colour scheme.',
+            cif_handler=CifHandler(names=['_structure_style.color_scheme']),
+        )
+        self._adp_probability = NumericDescriptor(
+            name='adp_probability',
+            description='ORTEP probability level, a fraction in (0, 1).',
+            value_spec=AttributeSpec(
+                default=0.99,
+                validator=RangeValidator(gt=0.0, lt=1.0),
+            ),
+            cif_handler=CifHandler(names=['_structure_style.adp_probability']),
+        )
+        self._atom_scale = NumericDescriptor(
+            name='atom_scale',
+            description='Overall ball-atom size factor (square-root compressed).',
+            value_spec=AttributeSpec(
+                default=0.3,
+                validator=RangeValidator(gt=0.0, le=1.0),
+            ),
+            cif_handler=CifHandler(names=['_structure_style.atom_scale']),
+        )
+
+    @property
+    def atom_view(self) -> EnumDescriptor:
+        """How atoms are sized/shaped (``vdw``/``covalent``/``ionic``/``adp``)."""
+        return self._atom_view
+
+    @atom_view.setter
+    def atom_view(self, value: str) -> None:
+        self._atom_view.value = AtomViewEnum(value).value
+
+    @property
+    def color_scheme(self) -> EnumDescriptor:
+        """Standard element colour scheme."""
+        return self._color_scheme
+
+    @color_scheme.setter
+    def color_scheme(self, value: str) -> None:
+        self._color_scheme.value = ColorSchemeEnum(value).value
+
+    @property
+    def adp_probability(self) -> NumericDescriptor:
+        """ORTEP probability level (fraction in the open interval (0, 1))."""
+        return self._adp_probability
+
+    @adp_probability.setter
+    def adp_probability(self, value: float) -> None:
+        self._adp_probability.value = value
+
+    @property
+    def atom_scale(self) -> NumericDescriptor:
+        """Overall ball-atom size factor in (0, 1] (square-root compressed)."""
+        return self._atom_scale
+
+    @atom_scale.setter
+    def atom_scale(self, value: float) -> None:
+        self._atom_scale.value = value
+
+    @property
+    def as_cif(self) -> str:
+        """Return CIF representation of this structure_style category."""
+        return super().as_cif
diff --git a/src/easydiffraction/project/categories/structure_style/factory.py b/src/easydiffraction/project/categories/structure_style/factory.py
new file mode 100644
index 000000000..61df09a43
--- /dev/null
+++ b/src/easydiffraction/project/categories/structure_style/factory.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Factory for project structure_style categories."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from easydiffraction.core.factory import FactoryBase
+
+
+class StructureStyleFactory(FactoryBase):
+    """Create project structure_style category instances."""
+
+    _default_rules: ClassVar[dict] = {
+        frozenset(): 'default',
+    }
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index 22b66e6dc..e0d2c9142 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -42,6 +42,7 @@
     from easydiffraction.project.categories.verbosity import Verbosity
     from easydiffraction.project.categories.rendering_structure import RenderingStructure
     from easydiffraction.project.categories.structure_view import StructureView
+    from easydiffraction.project.categories.structure_style import StructureStyle
     from easydiffraction.project.project_info import ProjectInfo
     from easydiffraction.report import Report
 
@@ -215,6 +216,7 @@ def __init__(
         object.__setattr__(self, '_verbosity', self._config.verbosity)
         object.__setattr__(self, '_rendering_structure', self._config.rendering_structure)
         object.__setattr__(self, '_structure_view', self._config.structure_view)
+        object.__setattr__(self, '_structure_style', self._config.structure_style)
         object.__setattr__(self, '_style', self._config.style)
         object.__setattr__(self, '_report', self._config.report)
         self._publication = PublicationFactory.create(PublicationFactory.default_tag())
@@ -234,6 +236,7 @@ def _attach_category_parents(self) -> None:
         self._rendering_table._parent = self
         self._rendering_structure._parent = self
         self._structure_view._parent = self
+        self._structure_style._parent = self
         self._style._parent = self
         self._report._parent = self
         self._publication._parent = self
@@ -345,6 +348,11 @@ def structure_view(self) -> StructureView:
         """Structure-view content and region bound to the project."""
         return self._structure_view
 
+    @property
+    def structure_style(self) -> StructureStyle:
+        """Structure-view appearance bound to the project."""
+        return self._structure_style
+
     @property
     def style(self) -> Style:
         """Structure-view styling bound to the project."""
diff --git a/src/easydiffraction/project/project_config.py b/src/easydiffraction/project/project_config.py
index d5bbb8610..6c0b8acf8 100644
--- a/src/easydiffraction/project/project_config.py
+++ b/src/easydiffraction/project/project_config.py
@@ -21,6 +21,8 @@
 from easydiffraction.project.categories.rendering_structure import RenderingStructureFactory
 from easydiffraction.project.categories.structure_view import StructureView
 from easydiffraction.project.categories.structure_view import StructureViewFactory
+from easydiffraction.project.categories.structure_style import StructureStyle
+from easydiffraction.project.categories.structure_style import StructureStyleFactory
 
 
 class ProjectConfig(CategoryOwner):
@@ -45,6 +47,7 @@ def __init__(
         self._verbosity = VerbosityFactory.create(VerbosityFactory.default_tag())
         self._rendering_structure = RenderingStructureFactory.create(RenderingStructureFactory.default_tag())
         self._structure_view = StructureViewFactory.create(StructureViewFactory.default_tag())
+        self._structure_style = StructureStyleFactory.create(StructureStyleFactory.default_tag())
         self._style = StyleFactory.create(StyleFactory.default_tag())
 
     @property
@@ -82,6 +85,11 @@ def structure_view(self) -> StructureView:
         """Structure-view content and region category."""
         return self._structure_view
 
+    @property
+    def structure_style(self) -> StructureStyle:
+        """Structure-view appearance category."""
+        return self._structure_style
+
     @property
     def style(self) -> Style:
         """Structure-view styling category."""

From 7344a28ee06d4a775dd63015582f3aa69faaae03 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:30:04 +0200
Subject: [PATCH 083/160] Read structure view and style from new categories

---
 docs/dev/plans/structure-view-settings.md        |  2 +-
 src/easydiffraction/display/structure/builder.py |  6 +++---
 src/easydiffraction/project/display.py           | 10 +++++-----
 src/easydiffraction/report/html_renderer.py      |  6 +++---
 src/easydiffraction/report/tex_renderer.py       |  4 ++--
 5 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 28156f790..4bd87a3c8 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -241,7 +241,7 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   `atom_view`/`color_scheme` as `EnumDescriptor`, `adp_probability`/`atom_scale`
   as `NumericDescriptor`. The old `style` category / `project.style` stay for
   now. Commit: `Add structure_style appearance category`.
-- [ ] **P1.9 — Repoint consumers to the new categories.** Builder, display
+- [x] **P1.9 — Repoint consumers to the new categories.** Builder, display
   facade, and report renderers read appearance from `project.structure_style`
   and the window/flags from `project.structure_view` (`builder.py`,
   `display.py`, `html_renderer.py`, `tex_renderer.py`). After this commit
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index 14bac9f0b..da9b9623f 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -333,8 +333,8 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
         A structure datablock with ``cell``, ``atom_sites``,
         ``atom_site_aniso``, ``space_group`` and ``geom`` categories.
     style : object
-        The ``project.style`` category (atom shape, radius model, colour
-        scheme, ADP probability).
+        The ``project.structure_style`` category (atom view, colour
+        scheme, ADP probability, atom scale).
     view_range : tuple
         Per-axis ``((min, max), (min, max), (min, max))`` fractional range.
     features : frozenset[str]
@@ -397,7 +397,7 @@ def structure_feature_availability(structure, *, style) -> FeatureAvailability:
     structure : object
         A structure datablock.
     style : object
-        The ``project.style`` category (its radius model drives the
+        The ``project.structure_style`` category (its atom view drives the
         covalent-substitution report).
 
     Returns
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index fe56822dc..4b77a2dfc 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -507,12 +507,12 @@ def structure(
         )
 
         structure = self._project.structures[struct_name]
-        availability = structure_feature_availability(structure, style=self._project.style)
+        availability = structure_feature_availability(structure, style=self._project.structure_style)
         features = self._resolve_structure_features(include, availability)
-        window = range if range is not None else self._project.rendering_structure.view_range()
+        window = range if range is not None else self._project.structure_view.view_range()
         scene = build_scene(
             structure,
-            style=self._project.style,
+            style=self._project.structure_style,
             view_range=window,
             features=features,
         )
@@ -532,7 +532,7 @@ def show_structure_options(self, struct_name: str) -> None:
         )
 
         structure = self._project.structures[struct_name]
-        availability = structure_feature_availability(structure, style=self._project.style)
+        availability = structure_feature_availability(structure, style=self._project.structure_style)
         supported = self._project.rendering_structure.viewer.supported_features()
         auto = self._resolve_structure_features('auto', availability)
 
@@ -566,7 +566,7 @@ def _resolve_structure_features(
         normalized = self._normalize_structure_include(include)
         if normalized != ('auto',):
             return frozenset(normalized)
-        view = self._project.rendering_structure
+        view = self._project.structure_view
         resolved = {f for f in ('atoms', 'bonds', 'cell', 'axes') if f in availability.available}
         if 'labels' in availability.available and view.show_labels.value:
             resolved.add('labels')
diff --git a/src/easydiffraction/report/html_renderer.py b/src/easydiffraction/report/html_renderer.py
index e888271e8..4025ad63e 100644
--- a/src/easydiffraction/report/html_renderer.py
+++ b/src/easydiffraction/report/html_renderer.py
@@ -207,14 +207,14 @@ def _structure_figure_html_context(
     )
 
     renderer = ThreeJsStructureRenderer()
-    window = project.rendering_structure.view_range()
+    window = project.structure_view.view_range()
     rendered: dict[str, str] = {}
     for structure in project.structures.values():
-        availability = structure_feature_availability(structure, style=project.style)
+        availability = structure_feature_availability(structure, style=project.structure_style)
         features = project.display._resolve_structure_features('auto', availability)
         scene = build_scene(
             structure,
-            style=project.style,
+            style=project.structure_style,
             view_range=window,
             features=features,
         )
diff --git a/src/easydiffraction/report/tex_renderer.py b/src/easydiffraction/report/tex_renderer.py
index dd2d29e5b..c30d6243c 100644
--- a/src/easydiffraction/report/tex_renderer.py
+++ b/src/easydiffraction/report/tex_renderer.py
@@ -456,8 +456,8 @@ def _write_structure_assets(
         return {}
 
     renderer = RasterStructureRenderer()
-    window = project.rendering_structure.view_range()
-    style = project.style
+    window = project.structure_view.view_range()
+    style = project.structure_style
     data_dir = out_dir / 'data'
     data_dir.mkdir(parents=True, exist_ok=True)
 

From 9006b8d8455ac120b71c65b024c366d0ac24d02c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:34:14 +0200
Subject: [PATCH 084/160] Remove the old style and rendering_structure surfaces

---
 docs/dev/plans/structure-view-settings.md     |   2 +-
 src/easydiffraction/io/cif/serialize.py       |  18 ++-
 .../categories/rendering_structure/default.py | 121 +----------------
 .../project/categories/style/__init__.py      |   8 --
 .../project/categories/style/default.py       | 126 ------------------
 .../project/categories/style/factory.py       |  17 ---
 src/easydiffraction/project/project.py        |   8 --
 src/easydiffraction/project/project_config.py |   8 --
 8 files changed, 17 insertions(+), 291 deletions(-)
 delete mode 100644 src/easydiffraction/project/categories/style/__init__.py
 delete mode 100644 src/easydiffraction/project/categories/style/default.py
 delete mode 100644 src/easydiffraction/project/categories/style/factory.py

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 4bd87a3c8..40b35e179 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -248,7 +248,7 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   nothing reads `project.style` or `rendering_structure.view_range()`, but both
   still exist — so the revision builds and renders. Commit:
   `Read structure view and style from new categories`.
-- [ ] **P1.10 — Remove the old surfaces.** Now that no consumer uses them:
+- [x] **P1.10 — Remove the old surfaces.** Now that no consumer uses them:
   remove `show_labels`/`show_moments`/`range_*`/`view_range()` from
   `rendering_structure` (leaving engine `type` + `viewer`); remove the `style`
   package, `project.style`, and the bespoke `Style.show_supported()`; drop the
diff --git a/src/easydiffraction/io/cif/serialize.py b/src/easydiffraction/io/cif/serialize.py
index 189875109..4adea6aa4 100644
--- a/src/easydiffraction/io/cif/serialize.py
+++ b/src/easydiffraction/io/cif/serialize.py
@@ -575,7 +575,13 @@ def project_config_to_cif(project: object) -> str:
     if publication is not None:
         sections.append(category_owner_to_cif(publication))
 
-    for attr_name in ('rendering_table', 'rendering_structure', 'style', 'verbosity'):
+    for attr_name in (
+        'rendering_table',
+        'rendering_structure',
+        'structure_view',
+        'structure_style',
+        'verbosity',
+    ):
         section = getattr(project, attr_name, None)
         if section is not None:
             sections.append(_as_cif_text(section))
@@ -709,9 +715,13 @@ def project_config_from_cif(project: object, cif_text: str) -> None:
     if rendering_structure is not None:
         rendering_structure.from_cif(block)
 
-    style = getattr(project, 'style', None)
-    if style is not None:
-        style.from_cif(block)
+    structure_view = getattr(project, 'structure_view', None)
+    if structure_view is not None:
+        structure_view.from_cif(block)
+
+    structure_style = getattr(project, 'structure_style', None)
+    if structure_style is not None:
+        structure_style.from_cif(block)
 
 
 def analysis_from_cif(analysis: object, cif_text: str) -> None:
diff --git a/src/easydiffraction/project/categories/rendering_structure/default.py b/src/easydiffraction/project/categories/rendering_structure/default.py
index 6e462498d..8eee95a38 100644
--- a/src/easydiffraction/project/categories/rendering_structure/default.py
+++ b/src/easydiffraction/project/categories/rendering_structure/default.py
@@ -1,6 +1,6 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project structure-rendering_structure category (switchable renderer + view state)."""
+"""Project structure-rendering_structure category (switchable renderer engine)."""
 
 from __future__ import annotations
 
@@ -9,8 +9,6 @@
 from easydiffraction.core.switchable import SwitchableCategoryBase
 from easydiffraction.core.validation import AttributeSpec
 from easydiffraction.core.validation import MembershipValidator
-from easydiffraction.core.variable import BoolDescriptor
-from easydiffraction.core.variable import NumericDescriptor
 from easydiffraction.core.variable import StringDescriptor
 from easydiffraction.display.structure.enums import ViewerEngineEnum
 from easydiffraction.display.structure.viewing import Viewer
@@ -25,18 +23,9 @@
 VIEW_ENGINE_OPTIONS = [AUTO_ENGINE, *[member.value for member in ViewerEngineEnum]]
 
 
-def _range_descriptor(name: str, default: float) -> NumericDescriptor:
-    return NumericDescriptor(
-        name=name,
-        description='Per-axis fractional view-range bound.',
-        value_spec=AttributeSpec(default=default),
-        cif_handler=CifHandler(names=[f'_rendering_structure.{name}']),
-    )
-
-
 @RenderingStructureFactory.register
 class RenderingStructure(CategoryItem, SwitchableCategoryBase):
-    """Renderer engine selection and view state for a project."""
+    """Renderer engine selection for the project structure view."""
 
     _category_code = 'rendering_structure'
     _owner_attr_name = 'rendering_structure'
@@ -60,24 +49,6 @@ def __init__(self) -> None:
             ),
             cif_handler=CifHandler(names=['_rendering_structure.type']),
         )
-        self._show_labels = BoolDescriptor(
-            name='show_labels',
-            description='Show atom labels when the view opens.',
-            value_spec=AttributeSpec(default=False),
-            cif_handler=CifHandler(names=['_rendering_structure.show_labels']),
-        )
-        self._show_moments = BoolDescriptor(
-            name='show_moments',
-            description='Show magnetic-moment arrows where the data exists.',
-            value_spec=AttributeSpec(default=True),
-            cif_handler=CifHandler(names=['_rendering_structure.show_moments']),
-        )
-        self._range_a_min = _range_descriptor('range_a_min', 0.0)
-        self._range_a_max = _range_descriptor('range_a_max', 1.0)
-        self._range_b_min = _range_descriptor('range_b_min', 0.0)
-        self._range_b_max = _range_descriptor('range_b_max', 1.0)
-        self._range_c_min = _range_descriptor('range_c_min', 0.0)
-        self._range_c_max = _range_descriptor('range_c_max', 1.0)
 
     @staticmethod
     def _resolved_engine(value: str) -> str:
@@ -111,94 +82,6 @@ def viewer(self) -> Viewer:
         """Live structure-view facade bound to the active engine."""
         return self._viewer
 
-    @property
-    def show_labels(self) -> BoolDescriptor:
-        """Whether atom labels are shown when the view opens."""
-        return self._show_labels
-
-    @show_labels.setter
-    def show_labels(self, value: bool) -> None:
-        self._show_labels.value = value
-
-    @property
-    def show_moments(self) -> BoolDescriptor:
-        """Whether moment arrows are shown where the data exists."""
-        return self._show_moments
-
-    @show_moments.setter
-    def show_moments(self, value: bool) -> None:
-        self._show_moments.value = value
-
-    def _set_bound(self, descriptor: NumericDescriptor, value: float, *, lower: float, upper: float) -> None:
-        if not lower < value < upper:
-            log.warning(
-                f"'{descriptor.name}' = {value} violates min < max on its axis; ignored.",
-            )
-            return
-        descriptor.value = value
-
-    @property
-    def range_a_min(self) -> NumericDescriptor:
-        """Lower fractional bound along a."""
-        return self._range_a_min
-
-    @range_a_min.setter
-    def range_a_min(self, value: float) -> None:
-        self._set_bound(self._range_a_min, value, lower=float('-inf'), upper=self._range_a_max.value)
-
-    @property
-    def range_a_max(self) -> NumericDescriptor:
-        """Upper fractional bound along a."""
-        return self._range_a_max
-
-    @range_a_max.setter
-    def range_a_max(self, value: float) -> None:
-        self._set_bound(self._range_a_max, value, lower=self._range_a_min.value, upper=float('inf'))
-
-    @property
-    def range_b_min(self) -> NumericDescriptor:
-        """Lower fractional bound along b."""
-        return self._range_b_min
-
-    @range_b_min.setter
-    def range_b_min(self, value: float) -> None:
-        self._set_bound(self._range_b_min, value, lower=float('-inf'), upper=self._range_b_max.value)
-
-    @property
-    def range_b_max(self) -> NumericDescriptor:
-        """Upper fractional bound along b."""
-        return self._range_b_max
-
-    @range_b_max.setter
-    def range_b_max(self, value: float) -> None:
-        self._set_bound(self._range_b_max, value, lower=self._range_b_min.value, upper=float('inf'))
-
-    @property
-    def range_c_min(self) -> NumericDescriptor:
-        """Lower fractional bound along c."""
-        return self._range_c_min
-
-    @range_c_min.setter
-    def range_c_min(self, value: float) -> None:
-        self._set_bound(self._range_c_min, value, lower=float('-inf'), upper=self._range_c_max.value)
-
-    @property
-    def range_c_max(self) -> NumericDescriptor:
-        """Upper fractional bound along c."""
-        return self._range_c_max
-
-    @range_c_max.setter
-    def range_c_max(self, value: float) -> None:
-        self._set_bound(self._range_c_max, value, lower=self._range_c_min.value, upper=float('inf'))
-
-    def view_range(self) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        """Assemble the per-axis ``((min, max), ...)`` fractional window."""
-        return (
-            (self._range_a_min.value, self._range_a_max.value),
-            (self._range_b_min.value, self._range_b_max.value),
-            (self._range_c_min.value, self._range_c_max.value),
-        )
-
     def from_cif(self, block: object, idx: int = 0) -> None:
         """Populate this rendering_structure category from a CIF block, rebinding engine."""
         super().from_cif(block, idx)
diff --git a/src/easydiffraction/project/categories/style/__init__.py b/src/easydiffraction/project/categories/style/__init__.py
deleted file mode 100644
index 736c97652..000000000
--- a/src/easydiffraction/project/categories/style/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project style category exports."""
-
-from __future__ import annotations
-
-from easydiffraction.project.categories.style.default import Style
-from easydiffraction.project.categories.style.factory import StyleFactory
diff --git a/src/easydiffraction/project/categories/style/default.py b/src/easydiffraction/project/categories/style/default.py
deleted file mode 100644
index 716cbc008..000000000
--- a/src/easydiffraction/project/categories/style/default.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project structure-view styling category."""
-
-from __future__ import annotations
-
-from easydiffraction.core.category import CategoryItem
-from easydiffraction.core.metadata import TypeInfo
-from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.validation import MembershipValidator
-from easydiffraction.core.validation import RangeValidator
-from easydiffraction.core.variable import NumericDescriptor
-from easydiffraction.core.variable import StringDescriptor
-from easydiffraction.display.structure.enums import AtomViewEnum
-from easydiffraction.display.structure.enums import ColorSchemeEnum
-from easydiffraction.io.cif.handler import CifHandler
-from easydiffraction.project.categories.style.factory import StyleFactory
-from easydiffraction.utils.logging import console
-
-
-@StyleFactory.register
-class Style(CategoryItem):
-    """Visual styling for the structure view (not per-element)."""
-
-    _category_code = 'style'
-
-    type_info = TypeInfo(
-        tag='default',
-        description='Project structure-view style category',
-    )
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._atom_view = StringDescriptor(
-            name='atom_view',
-            description='How atoms are sized and shaped in the structure view.',
-            value_spec=AttributeSpec(
-                default=AtomViewEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in AtomViewEnum],
-                ),
-            ),
-            cif_handler=CifHandler(names=['_style.atom_view']),
-        )
-        self._color_scheme = StringDescriptor(
-            name='color_scheme',
-            description='Standard element colour scheme.',
-            value_spec=AttributeSpec(
-                default=ColorSchemeEnum.default().value,
-                validator=MembershipValidator(
-                    allowed=[member.value for member in ColorSchemeEnum],
-                ),
-            ),
-            cif_handler=CifHandler(names=['_style.color_scheme']),
-        )
-        self._adp_probability = NumericDescriptor(
-            name='adp_probability',
-            description='ORTEP probability level, a fraction in (0, 1).',
-            value_spec=AttributeSpec(
-                default=0.99,
-                validator=RangeValidator(gt=0.0, lt=1.0),
-            ),
-            cif_handler=CifHandler(names=['_style.adp_probability']),
-        )
-        self._atom_scale = NumericDescriptor(
-            name='atom_scale',
-            description='Overall ball-atom size factor (square-root compressed).',
-            value_spec=AttributeSpec(
-                default=0.3,
-                validator=RangeValidator(gt=0.0, le=1.0),
-            ),
-            cif_handler=CifHandler(names=['_style.atom_scale']),
-        )
-
-    @property
-    def atom_view(self) -> StringDescriptor:
-        """How atoms are sized/shaped (``vdw``/``covalent``/``ionic``/``atomic``/``adp``)."""
-        return self._atom_view
-
-    @atom_view.setter
-    def atom_view(self, value: str) -> None:
-        self._atom_view.value = AtomViewEnum(value).value
-
-    @property
-    def color_scheme(self) -> StringDescriptor:
-        """Standard element colour scheme."""
-        return self._color_scheme
-
-    @color_scheme.setter
-    def color_scheme(self, value: str) -> None:
-        self._color_scheme.value = ColorSchemeEnum(value).value
-
-    @property
-    def adp_probability(self) -> NumericDescriptor:
-        """ORTEP probability level (fraction in the open interval (0, 1))."""
-        return self._adp_probability
-
-    @adp_probability.setter
-    def adp_probability(self, value: float) -> None:
-        self._adp_probability.value = value
-
-    @property
-    def atom_scale(self) -> NumericDescriptor:
-        """Overall ball-atom size factor in (0, 1] (square-root compressed)."""
-        return self._atom_scale
-
-    @atom_scale.setter
-    def atom_scale(self, value: float) -> None:
-        self._atom_scale.value = value
-
-    def show_supported(self) -> None:
-        """List the accepted values for every styling setting."""
-        console.paragraph('Supported style settings')
-        for setting, enum in (
-            ('atom_view', AtomViewEnum),
-            ('color_scheme', ColorSchemeEnum),
-        ):
-            console.print(f"{setting}: {', '.join(member.value for member in enum)}")
-        console.print('adp_probability: float in the open interval (0, 1)')
-        console.print('atom_scale: float in (0, 1] (overall ball size; sqrt-compressed)')
-
-    @property
-    def as_cif(self) -> str:
-        """Return CIF representation of this style category."""
-        return super().as_cif
diff --git a/src/easydiffraction/project/categories/style/factory.py b/src/easydiffraction/project/categories/style/factory.py
deleted file mode 100644
index e1613a462..000000000
--- a/src/easydiffraction/project/categories/style/factory.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Factory for project style categories."""
-
-from __future__ import annotations
-
-from typing import ClassVar
-
-from easydiffraction.core.factory import FactoryBase
-
-
-class StyleFactory(FactoryBase):
-    """Create project style category instances."""
-
-    _default_rules: ClassVar[dict] = {
-        frozenset(): 'default',
-    }
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index e0d2c9142..a2b71160e 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -37,7 +37,6 @@
     from collections.abc import Callable
 
     from easydiffraction.project.categories.rendering_plot import RenderingPlot
-    from easydiffraction.project.categories.style import Style
     from easydiffraction.project.categories.rendering_table import RenderingTable
     from easydiffraction.project.categories.verbosity import Verbosity
     from easydiffraction.project.categories.rendering_structure import RenderingStructure
@@ -217,7 +216,6 @@ def __init__(
         object.__setattr__(self, '_rendering_structure', self._config.rendering_structure)
         object.__setattr__(self, '_structure_view', self._config.structure_view)
         object.__setattr__(self, '_structure_style', self._config.structure_style)
-        object.__setattr__(self, '_style', self._config.style)
         object.__setattr__(self, '_report', self._config.report)
         self._publication = PublicationFactory.create(PublicationFactory.default_tag())
         self._display = ProjectDisplay(self)
@@ -237,7 +235,6 @@ def _attach_category_parents(self) -> None:
         self._rendering_structure._parent = self
         self._structure_view._parent = self
         self._structure_style._parent = self
-        self._style._parent = self
         self._report._parent = self
         self._publication._parent = self
 
@@ -353,11 +350,6 @@ def structure_style(self) -> StructureStyle:
         """Structure-view appearance bound to the project."""
         return self._structure_style
 
-    @property
-    def style(self) -> Style:
-        """Structure-view styling bound to the project."""
-        return self._style
-
     @property
     def display(self) -> ProjectDisplay:
         """Current display entry-point bound to the project."""
diff --git a/src/easydiffraction/project/project_config.py b/src/easydiffraction/project/project_config.py
index 6c0b8acf8..36384887e 100644
--- a/src/easydiffraction/project/project_config.py
+++ b/src/easydiffraction/project/project_config.py
@@ -13,8 +13,6 @@
 from easydiffraction.project.categories.report import ReportFactory
 from easydiffraction.project.categories.rendering_table import RenderingTable
 from easydiffraction.project.categories.rendering_table import RenderingTableFactory
-from easydiffraction.project.categories.style import Style
-from easydiffraction.project.categories.style import StyleFactory
 from easydiffraction.project.categories.verbosity import Verbosity
 from easydiffraction.project.categories.verbosity import VerbosityFactory
 from easydiffraction.project.categories.rendering_structure import RenderingStructure
@@ -48,7 +46,6 @@ def __init__(
         self._rendering_structure = RenderingStructureFactory.create(RenderingStructureFactory.default_tag())
         self._structure_view = StructureViewFactory.create(StructureViewFactory.default_tag())
         self._structure_style = StructureStyleFactory.create(StructureStyleFactory.default_tag())
-        self._style = StyleFactory.create(StyleFactory.default_tag())
 
     @property
     def info(self) -> ProjectInfo:
@@ -90,11 +87,6 @@ def structure_style(self) -> StructureStyle:
         """Structure-view appearance category."""
         return self._structure_style
 
-    @property
-    def style(self) -> Style:
-        """Structure-view styling category."""
-        return self._style
-
     @property
     def as_cif(self) -> str:
         """Serialize singleton project categories to CIF."""

From e24a42571bef338c95746322b4216c944322eab9 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 12:36:52 +0200
Subject: [PATCH 085/160] Move model.md structure styling to structure_style

---
 docs/docs/user-guide/analysis-workflow/model.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 56e42c620..176925b44 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -197,20 +197,21 @@ project.rendering_structure.type = 'auto'
 ```
 
 Visual styling — independent of the per-element data — is configured on
-`project.style`:
+`project.structure_style`:
 
 ```python
-# List the accepted style settings
-project.style.show_supported()
+# List the accepted values for an enumerated setting (the active one is marked)
+project.structure_style.atom_view.show_supported()
+project.structure_style.color_scheme.show_supported()
 
 # Choose how atoms are depicted, sized, and coloured.
 # atom_view picks a radius-model ball ('vdw'/'covalent'/'ionic')
 # or 'adp' for displacement surfaces (spheres for isotropic sites,
 # ellipsoids for anisotropic ones — driven by each atom's adp_type).
-project.style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', or 'adp'
-project.style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
-project.style.atom_scale = 0.3  # overall ball size (square-root compressed)
-project.style.adp_probability = 0.5  # ADP ellipsoid probability level (0–1)
+project.structure_style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', or 'adp'
+project.structure_style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
+project.structure_style.atom_scale = 0.3  # overall ball size (square-root compressed)
+project.structure_style.adp_probability = 0.5  # ADP ellipsoid probability level (0–1)
 ```
 
 Bonds are generated automatically between atoms whose separation falls

From c164ec5786ca62c26435f10d07029a0e7c4aa170 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:03:34 +0200
Subject: [PATCH 086/160] Show occupancy split as a vertical camera-facing pie

---
 .../display/structure/renderers/raster.py            |  5 +++--
 .../display/structure/templates/structure.html.j2    | 12 ++++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 6d38adc00..e7024c245 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -270,8 +270,9 @@ def _base_colours(dx, dy, base, wedges) -> np.ndarray:
         if not wedges:
             flat = np.asarray(base, dtype=np.float32) / 255.0
             return np.broadcast_to(flat, dx.shape + (3,))
-        # Pie slices by screen-space azimuth (image y is down, so negate dy).
-        angle = (np.arctan2(-dy, dx) / (2.0 * np.pi)) % 1.0
+        # Pie slices by screen-space azimuth measured clockwise from the top, so
+        # a two-way split reads as a vertical seam (image y is down -> negate dy).
+        angle = (np.arctan2(dx, -dy) / (2.0 * np.pi)) % 1.0
         base_rgb = np.empty(dx.shape + (3,), dtype=np.float32)
         lo = 0.0
         for wedge in wedges:
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 941981567..0f575425f 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -149,6 +149,9 @@ for (const a of SCENE.atoms) {
   groups.atoms.add(mesh);
 }
 
+// Occupancy-wedge spheres: carve longitude wedges (proportional phi spans) and
+// orient them toward the camera below, once the view basis is known.
+const wedgeMeshes = [];
 for (const s of SCENE.wedgeSpheres) {
   let phi = 0;
   const parts = s.label.split('/');
@@ -161,6 +164,7 @@ for (const s of SCENE.wedgeSpheres) {
     mesh.userData.element = parts[i] || null;   // null for the vacancy wedge
     mesh.userData.asymmetric = s.asymmetric;
     groups.atoms.add(mesh);
+    wedgeMeshes.push(mesh);
     phi += span;
   });
 }
@@ -277,6 +281,14 @@ if (SCENE.axes && SCENE.axes.arrows.length === 3) {
 const look = viewDir.clone().negate();
 const camRight = new THREE.Vector3().crossVectors(look, viewUp).normalize();
 const camUp = new THREE.Vector3().crossVectors(camRight, look).normalize();
+// Orient occupancy-wedge spheres so their carve pole (+Y) points at the camera
+// (azimuthal spans then project as a proportional pie) and the wedge seam plane
+// is vertical (its normal is camRight), so a two-way split reads as a left/right
+// vertical seam matching the raster figure.
+const wedgeQuat = new THREE.Quaternion().setFromRotationMatrix(
+  new THREE.Matrix4().makeBasis(
+    new THREE.Vector3().crossVectors(viewDir, camRight), viewDir, camRight));
+for (const m of wedgeMeshes) m.quaternion.copy(wedgeQuat);
 let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
 for (const p of fitPoints) {
   const d = p.clone().sub(target);

From 44abff413e4216387e6f9e9adb49197afbbdbe42 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:10:49 +0200
Subject: [PATCH 087/160] Update crysview ADR for the structure-view category
 split

---
 .../crysview-structure-visualization.md       | 28 ++++++++++++++-----
 docs/dev/plans/structure-view-settings.md     | 11 +++++---
 2 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 9d17d6542..871b19085 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -491,6 +491,18 @@ near-vertical edges that the column-major chart code cannot express.
 
 ### 8. Configuring what is shown and how
 
+> **Updated.** This configuration surface was reorganised by the
+> [`structure-view-settings`](../../plans/structure-view-settings.md) plan and
+> the [`value-selector-discovery`](value-selector-discovery.md) ADR; the
+> examples below predate that split and are kept as historical design context.
+> The current surface is three flat categories: `project.rendering_structure`
+> (engine `type` only, CIF `_rendering_structure.type`), `project.structure_view`
+> (`show_labels`, `show_moments`, `range_*`, CIF `_structure_view.*`), and
+> `project.structure_style` (`atom_view`, `color_scheme`, `adp_probability`,
+> `atom_scale`, CIF `_structure_style.*`). Per-selector discovery replaces
+> `project.style.show_supported()` — e.g.
+> `project.structure_style.atom_view.show_supported()`.
+
 The view has two configuration axes — _what_ is shown (content) and
 _how_ it is drawn (engine plus styling) — both reachable from Python and
 persisted to CIF.
@@ -677,13 +689,15 @@ All items below are now **resolved** so the implementation plan can be
 executed autonomously; the plan records the verified data sources and
 the final names.
 
-- **CIF tag spelling — resolved.** Project CIF: `_style.atom_view`,
-  `_style.color_scheme`,
-  `_style.adp_probability`, and `_rendering_structure.type` / `_rendering_structure.show_labels` /
-  `_rendering_structure.show_moments` / `_rendering_structure.range_{a,b,c}_{min,max}`. These are project-internal
-  app/settings tags (`_rendering_structure.type` follows the Display-UX `_rendering_plot.type` /
-  `_rendering_table.type` precedent); the radii and colours are a bundled
-  element-database asset, not CIF-serialized.
+- **CIF tag spelling — resolved (see the §8 *Updated* note for the final
+  split).** Project CIF: `_structure_style.atom_view` /
+  `_structure_style.color_scheme` / `_structure_style.adp_probability` /
+  `_structure_style.atom_scale`; `_structure_view.show_labels` /
+  `_structure_view.show_moments` / `_structure_view.range_{a,b,c}_{min,max}`; and
+  `_rendering_structure.type` (engine only). These are project-internal
+  app/settings tags (`_rendering_structure.type` follows the Display-UX
+  `_rendering_plot.type` / `_rendering_table.type` precedent); the radii and
+  colours are a bundled element-database asset, not CIF-serialized.
 - **Per-structure bond-cutoff category — resolved (standard
   `_geom.*`).** A single-record `structure.geom` category holding the
   cif_core cutoffs `_geom.min_bond_distance_cutoff` (default `0.0` Å)
diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 40b35e179..db3814870 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -254,10 +254,13 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   package, `project.style`, and the bespoke `Style.show_supported()`; drop the
   `_style.*` block and the moved `_rendering_structure.*` tags from CIF
   serialise. Commit: `Remove the old style and rendering_structure surfaces`.
-- [ ] **P1.11 — Docs, ADRs, tutorials.** Update `model.md`, the crysview ADR,
-  the `value-selector-discovery` ADR, and `ed-3/14/17.py`; run
-  `pixi run notebook-prepare`; commit source + regenerated notebooks. Commit:
-  `Move structure-view docs and tutorials to new categories`.
+- [x] **P1.11 — Docs, ADRs, tutorials.** `model.md` updated (commit
+  `e24a42571`); crysview ADR updated with a §8 surface note + final CIF tags;
+  `value-selector-discovery` ADR already current. Tutorials `ed-3/14.py`
+  `project.style.*` migrated in place to `project.structure_style.*` and left
+  **uncommitted** for the user to regenerate (`pixi run notebook-prepare`) and
+  stage (they carry unrelated user edits). Commit: `Update crysview ADR for the
+  structure-view category split`.
 - [ ] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit the
   checklist update alone. Commit: `Reach Phase 1 review gate`.
 

From 4aa349458b3caf5ac4b671fef59dee7116fbf8fa Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:11:08 +0200
Subject: [PATCH 088/160] Reach Phase 1 review gate

---
 docs/dev/plans/structure-view-settings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index db3814870..576911494 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -261,7 +261,7 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   **uncommitted** for the user to regenerate (`pixi run notebook-prepare`) and
   stage (they carry unrelated user edits). Commit: `Update crysview ADR for the
   structure-view category split`.
-- [ ] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit the
+- [x] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit the
   checklist update alone. Commit: `Reach Phase 1 review gate`.
 
 ### Selector classification (P1.2 audit)

From 827edd2c2ab9e0b98796db60b8635b637a1b0678 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:25:32 +0200
Subject: [PATCH 089/160] Reopen Phase 1 gate pending tutorial migration

---
 docs/dev/plans/structure-view-settings.md | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 576911494..233f49d6c 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -254,15 +254,19 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   package, `project.style`, and the bespoke `Style.show_supported()`; drop the
   `_style.*` block and the moved `_rendering_structure.*` tags from CIF
   serialise. Commit: `Remove the old style and rendering_structure surfaces`.
-- [x] **P1.11 — Docs, ADRs, tutorials.** `model.md` updated (commit
-  `e24a42571`); crysview ADR updated with a §8 surface note + final CIF tags;
-  `value-selector-discovery` ADR already current. Tutorials `ed-3/14.py`
-  `project.style.*` migrated in place to `project.structure_style.*` and left
-  **uncommitted** for the user to regenerate (`pixi run notebook-prepare`) and
-  stage (they carry unrelated user edits). Commit: `Update crysview ADR for the
-  structure-view category split`.
-- [x] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit the
-  checklist update alone. Commit: `Reach Phase 1 review gate`.
+- [ ] **P1.11 — Docs, ADRs, tutorials.** Docs done: `model.md` (commit
+  `e24a42571`), crysview ADR §8 surface note + final CIF tags (commit
+  `44abff413`); `value-selector-discovery` ADR already current. **Tutorials not
+  done:** `ed-3/14.py` `project.style.*` migrated in place to
+  `project.structure_style.*` but **uncommitted**, and `ed-3/14.ipynb` still
+  call the removed `project.style` API. They must be regenerated
+  (`pixi run notebook-prepare`) and committed. The tutorial files carry unrelated
+  user playground edits, so completing/committing this is **pending a user
+  decision** (see `_impl-reply-1`).
+- [ ] **P1.12 — Phase 1 review gate.** No-code step. **Reopened** by
+  `_impl-review-1` [P1]: Phase 1 cannot be gated while the committed
+  `ed-3/14.ipynb` still reference the removed `project.style` API. Re-check once
+  P1.11's tutorial migration is committed.
 
 ### Selector classification (P1.2 audit)
 

From 6fb2df3c75f6e7bfc2ddec2514c612c8798ead64 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:31:55 +0200
Subject: [PATCH 090/160] Migrate tutorials to structure_style and regenerate
 notebooks

---
 docs/docs/tutorials/ed-14.ipynb |  40 ++--
 docs/docs/tutorials/ed-14.py    |   5 +-
 docs/docs/tutorials/ed-17.ipynb | 156 ++++++++-----
 docs/docs/tutorials/ed-17.py    |  14 ++
 docs/docs/tutorials/ed-3.ipynb  | 378 ++++++++++++++++++++------------
 docs/docs/tutorials/ed-3.py     |  43 +++-
 6 files changed, 414 insertions(+), 222 deletions(-)

diff --git a/docs/docs/tutorials/ed-14.ipynb b/docs/docs/tutorials/ed-14.ipynb
index 3ad2eaf52..d3700c264 100644
--- a/docs/docs/tutorials/ed-14.ipynb
+++ b/docs/docs/tutorials/ed-14.ipynb
@@ -187,7 +187,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.style.atom_view = 'adp'"
+    "project.structure_style.atom_view = 'adp'"
    ]
   },
   {
@@ -365,7 +365,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.experiments.show_names()"
+    "project.display.structure(struct_name='tbti')"
    ]
   },
   {
@@ -374,13 +374,23 @@
    "id": "33",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.experiments.show_names()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='heidi')"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "34",
+   "id": "35",
    "metadata": {},
    "source": [
     "## Step 5: Perform Analysis (ADP aniso)"
@@ -389,7 +399,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -402,7 +412,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -412,7 +422,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -429,7 +439,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -439,7 +449,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -449,7 +459,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -459,7 +469,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -469,7 +479,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -478,7 +488,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "44",
    "metadata": {},
    "source": [
     "### Structure View after refinement\n",
@@ -492,7 +502,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -501,7 +511,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "46",
    "metadata": {},
    "source": [
     "## Step 6: Generate Report"
@@ -510,7 +520,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "47",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-14.py b/docs/docs/tutorials/ed-14.py
index dda677782..24017b691 100644
--- a/docs/docs/tutorials/ed-14.py
+++ b/docs/docs/tutorials/ed-14.py
@@ -65,7 +65,7 @@
 # view will draw probability ellipsoids for the anisotropic sites.
 
 # %%
-project.style.atom_view = 'adp'
+project.structure_style.atom_view = 'adp'
 
 # %%
 project.display.structure(struct_name='tbti')
@@ -134,6 +134,9 @@
 # %%
 structure.show_as_cif()
 
+# %%
+project.display.structure(struct_name='tbti')
+
 # %%
 project.experiments.show_names()
 
diff --git a/docs/docs/tutorials/ed-17.ipynb b/docs/docs/tutorials/ed-17.ipynb
index 8d7d9d2be..7c5938751 100644
--- a/docs/docs/tutorials/ed-17.ipynb
+++ b/docs/docs/tutorials/ed-17.ipynb
@@ -228,9 +228,55 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "16",
    "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.rendering_structure.type = 'auto'\n",
+    "project.display.structure(struct_name='cosio')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.rendering_structure.type = 'ascii'\n",
+    "project.display.structure(struct_name='cosio')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21",
+   "metadata": {},
    "source": [
     "## Step 3: Define Template Experiment\n",
     "\n",
@@ -245,7 +291,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -254,7 +300,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "18",
+   "id": "23",
    "metadata": {},
    "source": [
     "#### Extract Data Files"
@@ -263,7 +309,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "24",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -276,7 +322,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "20",
+   "id": "25",
    "metadata": {},
    "source": [
     "#### Create Template Experiment from the First File"
@@ -285,7 +331,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -298,7 +344,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "22",
+   "id": "27",
    "metadata": {},
    "source": [
     "#### Set Instrument"
@@ -307,7 +353,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -317,7 +363,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "24",
+   "id": "29",
    "metadata": {},
    "source": [
     "#### Set Peak Profile"
@@ -326,7 +372,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "30",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -338,7 +384,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "26",
+   "id": "31",
    "metadata": {},
    "source": [
     "#### Set Excluded Regions"
@@ -347,7 +393,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -357,7 +403,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "28",
+   "id": "33",
    "metadata": {},
    "source": [
     "#### Set Background"
@@ -366,7 +412,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -388,7 +434,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "30",
+   "id": "35",
    "metadata": {},
    "source": [
     "#### Set Linked Phases"
@@ -397,7 +443,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "31",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -406,7 +452,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "32",
+   "id": "37",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis\n",
@@ -417,7 +463,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "33",
+   "id": "38",
    "metadata": {},
    "source": [
     "#### Set Free Parameters"
@@ -426,7 +472,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -457,7 +503,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -476,7 +522,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "36",
+   "id": "41",
    "metadata": {},
    "source": [
     "#### Set Constraints\n",
@@ -487,7 +533,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -503,7 +549,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "43",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -512,7 +558,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -521,7 +567,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "45",
    "metadata": {},
    "source": [
     "#### Set Minimizer"
@@ -530,7 +576,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -539,7 +585,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "47",
    "metadata": {},
    "source": [
     "#### Run Single Fitting\n",
@@ -553,7 +599,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -563,7 +609,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -572,7 +618,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "50",
    "metadata": {},
    "source": [
     "#### Show parameter correlations"
@@ -581,7 +627,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -590,7 +636,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Compare measured and calculated patterns for the first fit."
@@ -599,7 +645,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -608,7 +654,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "54",
    "metadata": {},
    "source": [
     "#### Run Sequential Fitting\n",
@@ -620,7 +666,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "50",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -629,7 +675,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "51",
+   "id": "56",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -642,7 +688,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -652,7 +698,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "58",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -666,7 +712,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "59",
    "metadata": {},
    "source": [
     "Set the sequential fitting parameters."
@@ -675,7 +721,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "60",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,7 +733,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "56",
+   "id": "61",
    "metadata": {},
    "source": [
     "Run the sequential fit over all data files in the scan directory."
@@ -696,7 +742,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -705,7 +751,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "58",
+   "id": "63",
    "metadata": {},
    "source": [
     "#### Replay a Dataset\n",
@@ -716,7 +762,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "59",
+   "id": "64",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -726,7 +772,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "60",
+   "id": "65",
    "metadata": {},
    "source": [
     "\n",
@@ -736,7 +782,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "61",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -746,7 +792,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "62",
+   "id": "67",
    "metadata": {},
    "source": [
     "#### Plot Parameter Evolution\n",
@@ -756,7 +802,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "68",
    "metadata": {},
    "source": [
     "Plot fit quality metrics vs. temperature."
@@ -765,7 +811,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "69",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -776,7 +822,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "70",
    "metadata": {},
    "source": [
     "Plot unit cell parameters vs. temperature."
@@ -785,7 +831,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "71",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -796,7 +842,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "72",
    "metadata": {},
    "source": [
     "Plot isotropic displacement parameters vs. temperature."
@@ -805,7 +851,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "73",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -818,7 +864,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "69",
+   "id": "74",
    "metadata": {},
    "source": [
     "Plot selected fractional coordinates vs. temperature."
@@ -827,7 +873,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "75",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-17.py b/docs/docs/tutorials/ed-17.py
index 0622b2310..f9e537070 100644
--- a/docs/docs/tutorials/ed-17.py
+++ b/docs/docs/tutorials/ed-17.py
@@ -117,6 +117,20 @@
     adp_iso=0.83,
 )
 
+# %%
+
+# %%
+project.rendering_structure.type = 'auto'
+project.display.structure(struct_name='cosio')
+
+# %%
+project.rendering_structure.type = 'ascii'
+project.display.structure(struct_name='cosio')
+
+# %%
+
+# %%
+
 # %% [markdown]
 # ## Step 3: Define Template Experiment
 #
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index 94a4e0d06..148c4f8cb 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -156,7 +156,7 @@
    "id": "13",
    "metadata": {},
    "source": [
-    "#### Set Up Data Plotter"
+    "#### Set Up Rendering Engines"
    ]
   },
   {
@@ -164,7 +164,7 @@
    "id": "14",
    "metadata": {},
    "source": [
-    "Show supported plotting engines."
+    "Show supported data plotting engines."
    ]
   },
   {
@@ -182,7 +182,7 @@
    "id": "16",
    "metadata": {},
    "source": [
-    "Show current plotting configuration."
+    "Show supported structure plotting engines."
    ]
   },
   {
@@ -192,7 +192,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.rendering_plot.show_supported()"
+    "project.rendering_structure.show_supported()"
    ]
   },
   {
@@ -387,38 +387,49 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "33",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.rendering_structure.help()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34",
+   "metadata": {},
    "source": [
-    "Visual styling — the atom shape, per-element radius model, and colour\n",
-    "scheme — is configured on `project.style`."
+    "Visual styling — the atom view and colour scheme — is configured on\n",
+    "`project.structure_style`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.style.show_supported()"
+    "project.structure_style.atom_view.show_supported()\n",
+    "project.structure_style.color_scheme.show_supported()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.style.atom_view = 'atomic'\n",
-    "project.style.color_scheme = 'jmol'"
+    "project.structure_style.atom_view = 'adp'\n",
+    "project.structure_style.color_scheme = 'jmol'"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "36",
+   "id": "37",
    "metadata": {},
    "source": [
     "Bonds are generated automatically between atoms whose separation lies\n",
@@ -428,7 +439,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -438,7 +449,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "39",
    "metadata": {},
    "source": [
     "List which features the structure data and the active engine can draw."
@@ -447,7 +458,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -456,7 +467,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "41",
    "metadata": {},
    "source": [
     "Draw the structure. With `include='auto'` (the default) every available\n",
@@ -467,7 +478,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -476,7 +487,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "43",
    "metadata": {},
    "source": [
     "For a quick text schematic, switch to the `ascii` engine explicitly,\n",
@@ -486,18 +497,35 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.rendering_structure.type = 'ascii'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.rendering_structure.type = 'ascii'\n",
     "project.display.structure(struct_name='lbco')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -506,7 +534,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "48",
    "metadata": {},
    "source": [
     "#### Save Project State\n",
@@ -519,7 +547,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -528,7 +556,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "50",
    "metadata": {},
    "source": [
     "## Step 3: Define Experiment\n",
@@ -539,7 +567,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "48",
+   "id": "51",
    "metadata": {},
    "source": [
     "#### Download Measured Data\n",
@@ -550,7 +578,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "52",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -559,7 +587,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "53",
    "metadata": {},
    "source": [
     "#### Add Diffraction Experiment"
@@ -568,7 +596,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -583,7 +611,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "55",
    "metadata": {},
    "source": [
     "#### Show Defined Experiments"
@@ -592,7 +620,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "56",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -601,7 +629,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "57",
    "metadata": {},
    "source": [
     "#### Show Measured Data"
@@ -610,7 +638,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "58",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -619,7 +647,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "56",
+   "id": "59",
    "metadata": {},
    "source": [
     "#### Set Instrument\n",
@@ -630,7 +658,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57",
+   "id": "60",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -640,7 +668,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "58",
+   "id": "61",
    "metadata": {},
    "source": [
     "#### Set Peak Profile\n",
@@ -651,7 +679,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "59",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -660,7 +688,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "60",
+   "id": "63",
    "metadata": {},
    "source": [
     "Select the desired peak profile type."
@@ -669,7 +697,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "61",
+   "id": "64",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -678,7 +706,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "62",
+   "id": "65",
    "metadata": {},
    "source": [
     "Modify default peak profile parameters."
@@ -687,7 +715,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "63",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -700,7 +728,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "64",
+   "id": "67",
    "metadata": {},
    "source": [
     "#### Set Background"
@@ -708,7 +736,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "68",
    "metadata": {},
    "source": [
     "Show supported background types."
@@ -717,7 +745,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "69",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -726,7 +754,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "70",
    "metadata": {},
    "source": [
     "Select the desired background type."
@@ -735,7 +763,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "71",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -744,7 +772,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "69",
+   "id": "72",
    "metadata": {},
    "source": [
     "Add background points."
@@ -753,7 +781,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "73",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -766,7 +794,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71",
+   "id": "74",
    "metadata": {},
    "source": [
     "Show current background points."
@@ -775,7 +803,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "72",
+   "id": "75",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -784,7 +812,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "73",
+   "id": "76",
    "metadata": {},
    "source": [
     "#### Set Linked Phases\n",
@@ -795,7 +823,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "74",
+   "id": "77",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -804,7 +832,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "75",
+   "id": "78",
    "metadata": {},
    "source": [
     "#### Show Experiment as CIF"
@@ -813,7 +841,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "76",
+   "id": "79",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -822,7 +850,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "77",
+   "id": "80",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -831,7 +859,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "78",
+   "id": "81",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -840,7 +868,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "79",
+   "id": "82",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis\n",
@@ -856,7 +884,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "80",
+   "id": "83",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -865,7 +893,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "81",
+   "id": "84",
    "metadata": {},
    "source": [
     "Select the desired calculation engine."
@@ -874,7 +902,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "82",
+   "id": "85",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -883,7 +911,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "83",
+   "id": "86",
    "metadata": {},
    "source": [
     "#### Show Calculated Data"
@@ -892,7 +920,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "84",
+   "id": "87",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -901,7 +929,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "85",
+   "id": "88",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -910,7 +938,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "86",
+   "id": "89",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -920,7 +948,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "87",
+   "id": "90",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -929,7 +957,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "88",
+   "id": "91",
    "metadata": {},
    "source": [
     "#### Show Parameters\n",
@@ -940,7 +968,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "89",
+   "id": "92",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -949,7 +977,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "90",
+   "id": "93",
    "metadata": {},
    "source": [
     "Show all fittable parameters."
@@ -958,7 +986,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "91",
+   "id": "94",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -967,7 +995,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "92",
+   "id": "95",
    "metadata": {},
    "source": [
     "Show only free parameters."
@@ -976,7 +1004,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "93",
+   "id": "96",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -985,7 +1013,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "94",
+   "id": "97",
    "metadata": {},
    "source": [
     "Show how to access parameters in the code."
@@ -994,7 +1022,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "95",
+   "id": "98",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1003,7 +1031,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "96",
+   "id": "99",
    "metadata": {},
    "source": [
     "#### Set Fit Mode\n",
@@ -1014,7 +1042,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "97",
+   "id": "100",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1023,7 +1051,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "98",
+   "id": "101",
    "metadata": {},
    "source": [
     "Select desired fit mode."
@@ -1032,7 +1060,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "99",
+   "id": "102",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1041,7 +1069,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "100",
+   "id": "103",
    "metadata": {},
    "source": [
     "#### Set Minimizer\n",
@@ -1052,7 +1080,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "101",
+   "id": "104",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1061,7 +1089,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "102",
+   "id": "105",
    "metadata": {},
    "source": [
     "Select desired fitting engine."
@@ -1070,7 +1098,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "103",
+   "id": "106",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1079,7 +1107,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "104",
+   "id": "107",
    "metadata": {},
    "source": [
     "### Perform Fit 1/5\n",
@@ -1090,7 +1118,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "105",
+   "id": "108",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1099,7 +1127,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "106",
+   "id": "109",
    "metadata": {},
    "source": [
     "Set experiment parameters to be refined."
@@ -1108,7 +1136,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "107",
+   "id": "110",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1123,7 +1151,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "108",
+   "id": "111",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1132,7 +1160,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "109",
+   "id": "112",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1141,7 +1169,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "110",
+   "id": "113",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1150,7 +1178,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "111",
+   "id": "114",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1160,7 +1188,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "112",
+   "id": "115",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1169,7 +1197,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "113",
+   "id": "116",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1179,7 +1207,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "114",
+   "id": "117",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1188,7 +1216,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "115",
+   "id": "118",
    "metadata": {},
    "source": [
     "### Perform Fit 2/5\n",
@@ -1199,7 +1227,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "116",
+   "id": "119",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1211,7 +1239,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "117",
+   "id": "120",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1220,7 +1248,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "118",
+   "id": "121",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1229,7 +1257,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "119",
+   "id": "122",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1238,7 +1266,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "120",
+   "id": "123",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1248,7 +1276,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "121",
+   "id": "124",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1257,7 +1285,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "122",
+   "id": "125",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1267,7 +1295,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "123",
+   "id": "126",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1276,7 +1304,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "124",
+   "id": "127",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -1285,7 +1313,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "125",
+   "id": "128",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1294,7 +1322,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "126",
+   "id": "129",
    "metadata": {},
    "source": [
     "### Perform Fit 3/5\n",
@@ -1305,7 +1333,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "127",
+   "id": "130",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1317,7 +1345,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "128",
+   "id": "131",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1326,7 +1354,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "129",
+   "id": "132",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1335,7 +1363,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "130",
+   "id": "133",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1344,7 +1372,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "131",
+   "id": "134",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1354,7 +1382,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "132",
+   "id": "135",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1363,7 +1391,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "133",
+   "id": "136",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1373,7 +1401,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "134",
+   "id": "137",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1382,7 +1410,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "135",
+   "id": "138",
    "metadata": {},
    "source": [
     "### Perform Fit 4/5\n",
@@ -1395,7 +1423,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "136",
+   "id": "139",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1411,7 +1439,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "137",
+   "id": "140",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -1420,7 +1448,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "138",
+   "id": "141",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1429,7 +1457,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "139",
+   "id": "142",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1438,7 +1466,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "140",
+   "id": "143",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1447,7 +1475,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "141",
+   "id": "144",
    "metadata": {},
    "source": [
     "Show free parameters."
@@ -1456,7 +1484,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "142",
+   "id": "145",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1465,7 +1493,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "143",
+   "id": "146",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1474,7 +1502,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "144",
+   "id": "147",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1484,7 +1512,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "145",
+   "id": "148",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1493,7 +1521,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "146",
+   "id": "149",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1503,7 +1531,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "147",
+   "id": "150",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1512,7 +1540,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "148",
+   "id": "151",
    "metadata": {},
    "source": [
     "### Perform Fit 5/5\n",
@@ -1525,7 +1553,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "149",
+   "id": "152",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1541,7 +1569,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "150",
+   "id": "153",
    "metadata": {},
    "source": [
     "Set more constraints."
@@ -1550,7 +1578,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "151",
+   "id": "154",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1561,7 +1589,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "152",
+   "id": "155",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1570,7 +1598,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "153",
+   "id": "156",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -1581,7 +1609,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "154",
+   "id": "157",
    "metadata": {},
    "source": [
     "Set structure parameters to be refined."
@@ -1590,7 +1618,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "155",
+   "id": "158",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1599,7 +1627,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "156",
+   "id": "159",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1608,7 +1636,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "157",
+   "id": "160",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1617,7 +1645,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "158",
+   "id": "161",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1626,7 +1654,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "159",
+   "id": "162",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1637,7 +1665,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "160",
+   "id": "163",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1646,7 +1674,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "161",
+   "id": "164",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1656,16 +1684,58 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "162",
+   "id": "165",
    "metadata": {},
    "outputs": [],
    "source": [
     "project.display.pattern(expt_name='hrpt', x_min=38, x_max=41)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "166",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "167",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "168",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "169",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "170",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
-   "id": "163",
+   "id": "171",
    "metadata": {},
    "source": [
     "## Step 5: Generate Report\n",
@@ -1685,7 +1755,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "164",
+   "id": "172",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1694,6 +1764,30 @@
     "project.report.pdf = True\n",
     "project.save()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "173",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "174",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "175",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index a33815103..b2b1a0bb4 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -61,19 +61,19 @@
 project.save_as(dir_path='projects/lbco_hrpt')
 
 # %% [markdown]
-# #### Set Up Data Plotter
+# #### Set Up Rendering Engines
 
 # %% [markdown]
-# Show supported plotting engines.
+# Show supported data plotting engines.
 
 # %%
 project.rendering_plot.show_supported()
 
 # %% [markdown]
-# Show current plotting configuration.
+# Show supported structure plotting engines.
 
 # %%
-project.rendering_plot.show_supported()
+project.rendering_structure.show_supported()
 
 # %% [markdown]
 # ## Step 2: Define Structure
@@ -177,16 +177,20 @@
 # %%
 project.rendering_structure.show_supported()
 
+# %%
+project.rendering_structure.help()
+
 # %% [markdown]
-# Visual styling — the atom shape, per-element radius model, and colour
-# scheme — is configured on `project.style`.
+# Visual styling — the atom view and colour scheme — is configured on
+# `project.structure_style`.
 
 # %%
-project.style.show_supported()
+project.structure_style.atom_view.show_supported()
+project.structure_style.color_scheme.show_supported()
 
 # %%
-project.style.atom_view = 'atomic'
-project.style.color_scheme = 'jmol'
+project.structure_style.atom_view = 'adp'
+project.structure_style.color_scheme = 'jmol'
 
 # %% [markdown]
 # Bonds are generated automatically between atoms whose separation lies
@@ -216,8 +220,12 @@
 
 # %%
 project.rendering_structure.type = 'ascii'
+
+# %%
 project.display.structure(struct_name='lbco')
 
+# %%
+
 # %%
 project.rendering_structure.type = 'auto'
 
@@ -667,6 +675,17 @@
 # %%
 project.display.pattern(expt_name='hrpt', x_min=38, x_max=41)
 
+# %%
+project.display.structure(struct_name='lbco')
+
+# %%
+
+# %%
+
+# %%
+
+# %%
+
 # %% [markdown]
 # ## Step 5: Generate Report
 #
@@ -686,3 +705,9 @@
 project.report.tex = True
 project.report.pdf = True
 project.save()
+
+# %%
+
+# %%
+
+# %%

From 1be8564ba56910b35fde11ddea5f343288393e2c Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:32:24 +0200
Subject: [PATCH 091/160] Reach Phase 1 review gate

---
 docs/dev/plans/structure-view-settings.md | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 233f49d6c..c515257c1 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -254,19 +254,16 @@ API. A short bridge period where old and new surfaces coexist is intentional.
   package, `project.style`, and the bespoke `Style.show_supported()`; drop the
   `_style.*` block and the moved `_rendering_structure.*` tags from CIF
   serialise. Commit: `Remove the old style and rendering_structure surfaces`.
-- [ ] **P1.11 — Docs, ADRs, tutorials.** Docs done: `model.md` (commit
-  `e24a42571`), crysview ADR §8 surface note + final CIF tags (commit
-  `44abff413`); `value-selector-discovery` ADR already current. **Tutorials not
-  done:** `ed-3/14.py` `project.style.*` migrated in place to
-  `project.structure_style.*` but **uncommitted**, and `ed-3/14.ipynb` still
-  call the removed `project.style` API. They must be regenerated
-  (`pixi run notebook-prepare`) and committed. The tutorial files carry unrelated
-  user playground edits, so completing/committing this is **pending a user
-  decision** (see `_impl-reply-1`).
-- [ ] **P1.12 — Phase 1 review gate.** No-code step. **Reopened** by
-  `_impl-review-1` [P1]: Phase 1 cannot be gated while the committed
-  `ed-3/14.ipynb` still reference the removed `project.style` API. Re-check once
-  P1.11's tutorial migration is committed.
+- [x] **P1.11 — Docs, ADRs, tutorials.** `model.md` (commit `e24a42571`),
+  crysview ADR §8 surface note + final CIF tags (commit `44abff413`),
+  `value-selector-discovery` ADR already current. Tutorials `ed-3/14/17.py`
+  migrated to `project.structure_style.*` (per-descriptor `show_supported()`)
+  and notebooks regenerated via `pixi run notebook-prepare`, committed in
+  `6fb2df3c7` (user approved committing their playground edits alongside).
+- [x] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit
+  the checklist update alone. (Reopened once by `_impl-review-1` [P1]; re-gated
+  after the tutorial migration landed in `6fb2df3c7`.) Commit:
+  `Reach Phase 1 review gate`.
 
 ### Selector classification (P1.2 audit)
 

From 6ff808d4751aa1f2e4449a7805bd4540c024be7f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 13:41:23 +0200
Subject: [PATCH 092/160] Apply pixi run fix auto-fixes

---
 src/easydiffraction/analysis/enums.py         |  8 +-
 src/easydiffraction/core/variable.py          | 12 ++-
 .../crystallography/crystallography.py        | 16 ++--
 .../categories/experiment_type/default.py     | 16 ++--
 .../categories/extinction/becker_coppens.py   |  5 +-
 .../categories/atom_sites/default.py          |  5 +-
 .../structure/categories/geom/default.py      |  4 +-
 .../display/plotters/plotly.py                | 21 +++--
 .../display/structure/assets/colors.py        | 12 +--
 .../display/structure/assets/elements.py      |  5 +-
 .../display/structure/assets/radii.py         | 10 +--
 .../display/structure/builder.py              | 84 ++++++++++++-------
 .../display/structure/enums.py                | 17 ++--
 .../display/structure/renderers/ascii.py      | 14 +++-
 .../display/structure/renderers/base.py       |  5 +-
 .../display/structure/renderers/raster.py     | 76 ++++++++++++-----
 .../display/structure/renderers/threejs.py    | 25 +++---
 .../display/structure/scene.py                | 11 ++-
 .../display/structure/viewing.py              |  3 +-
 .../categories/rendering_structure/default.py | 14 +++-
 .../categories/structure_style/default.py     | 22 +++--
 .../categories/structure_view/default.py      |  8 +-
 src/easydiffraction/project/display.py        | 35 ++++----
 src/easydiffraction/report/fit_plot.py        |  7 +-
 src/easydiffraction/report/html_renderer.py   |  4 +-
 src/easydiffraction/utils/enums.py            |  4 +-
 26 files changed, 287 insertions(+), 156 deletions(-)

diff --git a/src/easydiffraction/analysis/enums.py b/src/easydiffraction/analysis/enums.py
index 3fd1803dc..e52a8f25e 100644
--- a/src/easydiffraction/analysis/enums.py
+++ b/src/easydiffraction/analysis/enums.py
@@ -42,7 +42,9 @@ def default(cls) -> FitResultKindEnum:
         return cls.DETERMINISTIC
 
     def description(self) -> str:
-        """Return a human-readable description of this fit-result kind."""
+        """
+        Return a human-readable description of this fit-result kind.
+        """
         if self is FitResultKindEnum.DETERMINISTIC:
             return 'Least-squares (point-estimate) fit result.'
         if self is FitResultKindEnum.BAYESIAN:
@@ -62,7 +64,9 @@ def default(cls) -> FitCorrelationSourceEnum:
         return cls.DETERMINISTIC
 
     def description(self) -> str:
-        """Return a human-readable description of this correlation source."""
+        """
+        Return a human-readable description of this correlation source.
+        """
         if self is FitCorrelationSourceEnum.DETERMINISTIC:
             return 'Correlations from the least-squares covariance matrix.'
         if self is FitCorrelationSourceEnum.POSTERIOR:
diff --git a/src/easydiffraction/core/variable.py b/src/easydiffraction/core/variable.py
index 283660995..03dac6b1f 100644
--- a/src/easydiffraction/core/variable.py
+++ b/src/easydiffraction/core/variable.py
@@ -648,11 +648,13 @@ def __init__(
 
 
 class EnumDescriptor(StringDescriptor):
-    """String descriptor bound to a closed ``(str, Enum)`` value set.
+    """
+    String descriptor bound to a closed ``(str, Enum)`` value set.
 
     Derives validation and the default from ``enum`` and exposes
     ``show_supported()`` listing the members with the active one marked,
-    matching the switchable-category table (value-selector-discovery ADR).
+    matching the switchable-category table (value-selector-discovery
+    ADR).
     """
 
     def __init__(
@@ -673,13 +675,15 @@ def __init__(
         name : str
             Local name of the descriptor within its category.
         enum : type[StrEnum]
-            The ``(str, Enum)`` class whose members are the allowed values.
+            The ``(str, Enum)`` class whose members are the allowed
+            values.
         cif_handler : CifHandler
             Object that tracks CIF identifiers.
         description : str | None, default=None
             Optional human-readable description.
         default : str | None, default=None
-            Default value; falls back to ``enum.default()`` when omitted.
+            Default value; falls back to ``enum.default()`` when
+            omitted.
         display_handler : DisplayHandler | None, default=None
             Optional labels and units for display contexts.
         """
diff --git a/src/easydiffraction/crystallography/crystallography.py b/src/easydiffraction/crystallography/crystallography.py
index 555b20352..7e40e593a 100644
--- a/src/easydiffraction/crystallography/crystallography.py
+++ b/src/easydiffraction/crystallography/crystallography.py
@@ -678,7 +678,8 @@ def orthogonalization_matrix(
     Returns
     -------
     np.ndarray
-        The ``(3, 3)`` matrix ``M`` with ``r_cartesian = M @ r_fractional``.
+        The ``(3, 3)`` matrix ``M`` with ``r_cartesian = M @
+        r_fractional``.
     """
     al, be, ga = np.radians([alpha, beta, gamma])
     cos_al, cos_be, cos_ga = np.cos([al, be, ga])
@@ -705,7 +706,7 @@ def fractional_to_cartesian(frac: object, matrix: np.ndarray) -> np.ndarray:
 
     Parameters
     ----------
-    frac : array-like
+    frac : object
         A single ``(3,)`` fractional vector or an ``(n, 3)`` stack.
     matrix : np.ndarray
         The ``(3, 3)`` orthogonalization matrix from
@@ -738,8 +739,9 @@ def adp_principal_axes(tensor: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
     Returns
     -------
     tuple[np.ndarray, np.ndarray]
-        semi_axes : ``(3,)`` RMS principal semi-axis lengths. orientation
-        : ``(3, 3)`` matrix whose columns are the principal directions.
+        semi_axes : ``(3,)`` RMS principal semi-axis lengths.
+        orientation : ``(3, 3)`` matrix whose columns are the principal
+        directions.
     """
     eigenvalues, eigenvectors = np.linalg.eigh(np.asarray(tensor, dtype=float))
     semi_axes = np.sqrt(np.clip(eigenvalues, 0.0, None))
@@ -755,14 +757,14 @@ def symmetry_operators(
 
     Thin public wrapper over the general-position lookup, resolving the
     International Tables number from the Hermann-Mauguin symbol. Falls
-    back to the identity operator (so the asymmetric unit is still drawn)
-    when the space group cannot be resolved.
+    back to the identity operator (so the asymmetric unit is still
+    drawn) when the space group cannot be resolved.
 
     Parameters
     ----------
     name_hm : str
         Hermann-Mauguin symbol of the space group.
-    coord_code : str | None
+    coord_code : str | None, default=None
         IT coordinate system code, when one applies.
 
     Returns
diff --git a/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py b/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py
index 24b3eba5b..958fcb8f4 100644
--- a/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py
+++ b/src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py
@@ -117,8 +117,8 @@ def sample_form(self) -> EnumDescriptor:
         """
         Powder diffraction or single crystal diffraction.
 
-        Reading this property returns the underlying
-        ``EnumDescriptor`` object.
+        Reading this property returns the underlying ``EnumDescriptor``
+        object.
         """
         return self._sample_form
 
@@ -127,8 +127,8 @@ def beam_mode(self) -> EnumDescriptor:
         """
         Constant wavelength (CW) or time-of-flight (TOF) measurement.
 
-        Reading this property returns the underlying
-        ``EnumDescriptor`` object.
+        Reading this property returns the underlying ``EnumDescriptor``
+        object.
         """
         return self._beam_mode
 
@@ -137,8 +137,8 @@ def radiation_probe(self) -> EnumDescriptor:
         """
         Neutron or X-ray diffraction measurement.
 
-        Reading this property returns the underlying
-        ``EnumDescriptor`` object.
+        Reading this property returns the underlying ``EnumDescriptor``
+        object.
         """
         return self._radiation_probe
 
@@ -147,7 +147,7 @@ def scattering_type(self) -> EnumDescriptor:
         """
         Conventional Bragg diffraction or total scattering (PDF).
 
-        Reading this property returns the underlying
-        ``EnumDescriptor`` object.
+        Reading this property returns the underlying ``EnumDescriptor``
+        object.
         """
         return self._scattering_type
diff --git a/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py b/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py
index 6bf58ac63..f4c2b6acc 100644
--- a/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py
+++ b/src/easydiffraction/datablocks/experiment/categories/extinction/becker_coppens.py
@@ -104,9 +104,8 @@ def model(self) -> EnumDescriptor:
         """
         Mosaicity distribution model (``'gauss'`` or ``'lorentz'``).
 
-        Reading this property returns the underlying
-        ``EnumDescriptor`` object. Assigning to it updates the
-        descriptor value.
+        Reading this property returns the underlying ``EnumDescriptor``
+        object. Assigning to it updates the descriptor value.
         """
         return self._model
 
diff --git a/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py b/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py
index 0cae289e4..6f7169c9f 100644
--- a/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py
+++ b/src/easydiffraction/datablocks/structure/categories/atom_sites/default.py
@@ -417,9 +417,8 @@ def adp_type(self) -> EnumDescriptor:
         """
         ADP type used (e.g., Biso, Uiso, Uani, Bani).
 
-        Reading this property returns the underlying
-        ``EnumDescriptor`` object. Assigning to it updates the
-        parameter value.
+        Reading this property returns the underlying ``EnumDescriptor``
+        object. Assigning to it updates the parameter value.
         """
         return self._adp_type
 
diff --git a/src/easydiffraction/datablocks/structure/categories/geom/default.py b/src/easydiffraction/datablocks/structure/categories/geom/default.py
index 4a06bc0b6..64882d71e 100644
--- a/src/easydiffraction/datablocks/structure/categories/geom/default.py
+++ b/src/easydiffraction/datablocks/structure/categories/geom/default.py
@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Per-structure bond-generation cutoffs (standard cif_core ``_geom``)."""
+"""
+Per-structure bond-generation cutoffs (standard cif_core ``_geom``).
+"""
 
 from __future__ import annotations
 
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 34dbbc06d..dabd9df55 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -98,10 +98,11 @@ def single_crystal_axis_range(
     y_meas: object,
     y_meas_su: object,
 ) -> tuple[float, float]:
-    """Return one shared (min, max) range for a single-crystal scatter.
+    """
+    Return one shared (min, max) range for a single-crystal scatter.
 
-    The range spans the calculated values and the measured values widened
-    by their standard uncertainties, then pads both ends by
+    The range spans the calculated values and the measured values
+    widened by their standard uncertainties, then pads both ends by
     ``MAIN_INTENSITY_RANGE_MARGIN_FRACTION``. Applying the same range to
     both axes keeps the y=x diagonal meaningful.
 
@@ -145,12 +146,13 @@ def single_crystal_tick_step(
     maximum: float,
     target_ticks: int = 6,
 ) -> float:
-    """Return a 'nice' tick step covering ``[minimum, maximum]``.
+    """
+    Return a 'nice' tick step covering ``[minimum, maximum]``.
 
     The raw step ``span / target_ticks`` is rounded to the nearest 1/2/5
     multiple of a power of ten (the classic axis-label rounding), so the
-    ticks read as round numbers and the same step gives identical x and y
-    ticks over a shared range. Combined with a tick origin of 0 this
+    ticks read as round numbers and the same step gives identical x and
+    y ticks over a shared range. Combined with a tick origin of 0 this
     reproduces Plotly's own choice (e.g. a 500 step, not 750).
 
     Parameters
@@ -683,9 +685,10 @@ def _get_diagonal_shape(minimum: float, maximum: float) -> dict:
         """
         Create a y=x reference line in data coordinates.
 
-        The line runs from ``(minimum, minimum)`` to ``(maximum, maximum)``
-        in axis (data) coordinates, so it tracks y=x regardless of the
-        axis aspect ratio rather than the paper-rectangle diagonal.
+        The line runs from ``(minimum, minimum)`` to ``(maximum,
+        maximum)`` in axis (data) coordinates, so it tracks y=x
+        regardless of the axis aspect ratio rather than the
+        paper-rectangle diagonal.
 
         Parameters
         ----------
diff --git a/src/easydiffraction/display/structure/assets/colors.py b/src/easydiffraction/display/structure/assets/colors.py
index 3e71aee3f..b945342c6 100644
--- a/src/easydiffraction/display/structure/assets/colors.py
+++ b/src/easydiffraction/display/structure/assets/colors.py
@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Per-element colours, axis colours, and theme-dependent canvas colours."""
+"""
+Per-element colours, axis colours, and theme-dependent canvas colours.
+"""
 
 from __future__ import annotations
 
@@ -26,8 +28,8 @@ def color_for(element: str, scheme: str) -> Rgb:
     """
     Return the RGB colour for an element under a colour scheme.
 
-    Falls back to the element's Jmol colour when the scheme has no entry,
-    and to :data:`DEFAULT_COLOR` when the element is unknown.
+    Falls back to the element's Jmol colour when the scheme has no
+    entry, and to :data:`DEFAULT_COLOR` when the element is unknown.
 
     Parameters
     ----------
@@ -38,7 +40,7 @@ def color_for(element: str, scheme: str) -> Rgb:
 
     Returns
     -------
-    tuple[int, int, int]
+    Rgb
         RGB triple in the 0-255 range.
     """
     entry = ELEMENT_COLORS.get(element)
@@ -61,7 +63,7 @@ def theme_colors(dark: bool) -> dict[str, Rgb]:
 
     Returns
     -------
-    dict[str, tuple[int, int, int]]
+    dict[str, Rgb]
         Mapping with ``'background'`` and ``'foreground'`` colours.
     """
     return DARK_THEME if dark else LIGHT_THEME
diff --git a/src/easydiffraction/display/structure/assets/elements.py b/src/easydiffraction/display/structure/assets/elements.py
index 92b32601c..c614a3c9f 100644
--- a/src/easydiffraction/display/structure/assets/elements.py
+++ b/src/easydiffraction/display/structure/assets/elements.py
@@ -1,6 +1,9 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Bundled per-element radii and colour palettes (generated; see LICENSES.md)."""
+"""
+Bundled per-element radii and colour palettes (generated; see
+LICENSES.md).
+"""
 
 from __future__ import annotations
 
diff --git a/src/easydiffraction/display/structure/assets/radii.py b/src/easydiffraction/display/structure/assets/radii.py
index 5ae7b11e8..bc8ae8562 100644
--- a/src/easydiffraction/display/structure/assets/radii.py
+++ b/src/easydiffraction/display/structure/assets/radii.py
@@ -15,8 +15,8 @@ def radius_for(element: str, model: str) -> tuple[float, bool]:
     Return a sphere radius for an element under a radius model.
 
     Falls back to the element's covalent radius when the selected model
-    has no value for it, and to :data:`DEFAULT_RADIUS` when the element is
-    unknown.
+    has no value for it, and to :data:`DEFAULT_RADIUS` when the element
+    is unknown.
 
     Parameters
     ----------
@@ -28,9 +28,9 @@ def radius_for(element: str, model: str) -> tuple[float, bool]:
     Returns
     -------
     tuple[float, bool]
-        The radius (angstrom) and a ``substituted`` flag that is ``True``
-        when the requested model's value was unavailable and a fallback
-        was used.
+        The radius (angstrom) and a ``substituted`` flag that is
+        ``True`` when the requested model's value was unavailable and a
+        fallback was used.
     """
     entry = ELEMENT_RADII.get(element)
     if entry is None:
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index da9b9623f..bfa2a96bf 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -52,7 +52,9 @@
 
 @dataclass(frozen=True)
 class FeatureAvailability:
-    """What a structure's data supports, for 'auto' resolution + options."""
+    """
+    What a structure's data supports, for 'auto' resolution + options.
+    """
 
     available: frozenset[str]
     radius_substitutions: tuple[str, ...]
@@ -60,7 +62,9 @@ class FeatureAvailability:
 
 @dataclass(frozen=True)
 class _SceneAtom:
-    """An emitted atom primitive plus data needed for bonds and labels."""
+    """
+    An emitted atom primitive plus data needed for bonds and labels.
+    """
 
     primitive: object
     centre: np.ndarray
@@ -110,10 +114,13 @@ def _pos_key(pos: np.ndarray) -> tuple[int, int, int]:
 
 
 def _expand_positions(sites, ops, view_range):
-    """Generate (row_index, fractional position, rotation) for each in-range copy.
+    """
+    Generate (row_index, fractional position, rotation) for each
+    in-range copy.
 
-    The symmetry rotation is kept so an anisotropic ADP tensor can be rotated
-    onto each equivalent site (otherwise every copy reuses one orientation).
+    The symmetry rotation is kept so an anisotropic ADP tensor can be
+    rotated onto each equivalent site (otherwise every copy reuses one
+    orientation).
     """
     generated = []
     identity = np.eye(3)
@@ -129,7 +136,9 @@ def _expand_positions(sites, ops, view_range):
 
 
 def _group_by_position(generated):
-    """Dedup scene atoms (row + position) and cluster coincident positions."""
+    """
+    Dedup scene atoms (row + position) and cluster coincident positions.
+    """
     seen: dict = {}
     for idx, pos, rot, is_au in generated:
         seen.setdefault((idx, _pos_key(pos)), (idx, pos, rot, is_au))
@@ -140,11 +149,12 @@ def _group_by_position(generated):
 
 
 def _cartesian_u(atom, aniso, matrix: np.ndarray, cell, rot: np.ndarray) -> np.ndarray:
-    """Cartesian U tensor for an anisotropic atom (CIF U^ij convention).
+    """
+    Cartesian U tensor for an anisotropic atom (CIF U^ij convention).
 
-    ``rot`` is the fractional symmetry rotation that placed this copy; the
-    tensor is rotated onto the copy in Cartesian space so each equivalent
-    site shows the correctly oriented ellipsoid.
+    ``rot`` is the fractional symmetry rotation that placed this copy;
+    the tensor is rotated onto the copy in Cartesian space so each
+    equivalent site shows the correctly oriented ellipsoid.
     """
     comps = np.array([
         [aniso.adp_11.value, aniso.adp_12.value, aniso.adp_13.value],
@@ -160,16 +170,20 @@ def _cartesian_u(atom, aniso, matrix: np.ndarray, cell, rot: np.ndarray) -> np.n
 
 
 def _display_radius(model_radius: float, style) -> float:
-    """Square-root-compressed ball radius (narrows the heavy/light spread)."""
+    """
+    Square-root-compressed ball radius (narrows the heavy/light spread).
+    """
     return style.atom_scale.value * float(np.sqrt(model_radius))
 
 
 def _atom_shape(atom, *, style, matrix, cell, aniso_collection, rot):
-    """Return an atom's ADP-driven shape and the radius-substitution flag.
+    """
+    Return an atom's ADP-driven shape and the radius-substitution flag.
 
-    The shape is ``('ellipsoid', semi_axes, orientation)`` for an anisotropic
-    atom in the ADP view, otherwise ``('sphere', radius)``. ``rot`` is the
-    symmetry rotation placing this copy (identity for the reference atom).
+    The shape is ``('ellipsoid', semi_axes, orientation)`` for an
+    anisotropic atom in the ADP view, otherwise ``('sphere', radius)``.
+    ``rot`` is the symmetry rotation placing this copy (identity for the
+    reference atom).
     """
     element = _element_symbol(atom.type_symbol.value)
     view = AtomViewEnum(style.atom_view.value)
@@ -212,8 +226,10 @@ def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection, rot,
 
 
 def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection, asymmetric):
-    """Build a shared-site primitive: the major atom's ADP shape split into
-    relative-proportion colour wedges (absolute occupancy ignored)."""
+    """
+    Build a shared-site primitive: the major atom's ADP shape split into
+    relative-proportion colour wedges (absolute occupancy ignored).
+    """
     total = sum(occ for _, occ, _, _, _, _ in rows) or 1.0
     wedges = tuple(OccupancyWedge(occ / total, colour) for _, occ, _, colour, _, _ in rows)
     major_atom, _occ, major_element, major_colour, _radius, major_rot = max(rows, key=lambda r: r[1])
@@ -231,7 +247,9 @@ def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection, asymmetr
 
 
 def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
-    """Return the scene atoms (one per position cluster) and substitutions."""
+    """
+    Return the scene atoms (one per position cluster) and substitutions.
+    """
     scene_atoms = []
     substitutions: set = set()
     radius_model = AtomViewEnum(style.atom_view.value).radius_model()
@@ -266,7 +284,9 @@ def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
 
 
 def _build_bonds(scene_atoms, geom_min: float, geom_incr: float):
-    """Detect bonds via the cif_core _geom rule, pruned to the first shell."""
+    """
+    Detect bonds via the cif_core _geom rule, pruned to the first shell.
+    """
     bonds = []
     count = len(scene_atoms)
     if count < 2:
@@ -314,7 +334,9 @@ def _axis_triad(matrix: np.ndarray) -> AxisTriad:
 
 
 def _legend(sites, style) -> tuple[LegendEntry, ...]:
-    """Return one colour swatch per distinct element, in first-seen order."""
+    """
+    Return one colour swatch per distinct element, in first-seen order.
+    """
     entries: dict[str, tuple[int, int, int]] = {}
     for atom in sites:
         element = _element_symbol(atom.type_symbol.value)
@@ -325,7 +347,8 @@ def _legend(sites, style) -> tuple[LegendEntry, ...]:
 
 def build_scene(structure, *, style, view_range, features) -> StructureScene:
     """
-    Build a renderer-neutral scene from a structure and resolved features.
+    Build a renderer-neutral scene from a structure and resolved
+    features.
 
     Parameters
     ----------
@@ -336,10 +359,12 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
         The ``project.structure_style`` category (atom view, colour
         scheme, ADP probability, atom scale).
     view_range : tuple
-        Per-axis ``((min, max), (min, max), (min, max))`` fractional range.
+        Per-axis ``((min, max), (min, max), (min, max))`` fractional
+        range.
     features : frozenset[str]
-        The already-resolved set of primitives to emit (never ``'auto'``);
-        the builder never re-implements visibility precedence.
+        The already-resolved set of primitives to emit (never
+        ``'auto'``); the builder never re-implements visibility
+        precedence.
 
     Returns
     -------
@@ -386,7 +411,8 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
 
 def structure_feature_availability(structure, *, style) -> FeatureAvailability:
     """
-    Report which features a structure supports, without building a scene.
+    Report which features a structure supports, without building a
+    scene.
 
     Used by the display facade for ``include='auto'`` resolution and by
     ``show_structure_options()``; the builder is the only reader of the
@@ -397,14 +423,14 @@ def structure_feature_availability(structure, *, style) -> FeatureAvailability:
     structure : object
         A structure datablock.
     style : object
-        The ``project.structure_style`` category (its atom view drives the
-        covalent-substitution report).
+        The ``project.structure_style`` category (its atom view drives
+        the covalent-substitution report).
 
     Returns
     -------
     FeatureAvailability
-        Available feature names and the elements whose radius fell back to
-        covalent under the selected model.
+        Available feature names and the elements whose radius fell back
+        to covalent under the selected model.
     """
     sites = list(structure.atom_sites)
     available = {'cell', 'axes'}
diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
index 71480ae32..a5b037963 100644
--- a/src/easydiffraction/display/structure/enums.py
+++ b/src/easydiffraction/display/structure/enums.py
@@ -32,7 +32,8 @@ def description(self) -> str:
 
 
 class AtomViewEnum(StrEnum):
-    """How atoms are sized and shaped in the structure view.
+    """
+    How atoms are sized and shaped in the structure view.
 
     The radius models draw fixed balls; ``adp`` draws displacement
     surfaces (spheres for isotropic sites, ellipsoids for anisotropic).
@@ -50,15 +51,19 @@ def default(cls) -> AtomViewEnum:
 
     @property
     def is_adp(self) -> bool:
-        """Return whether atoms are drawn as displacement surfaces, not balls."""
+        """
+        Return whether atoms are drawn as displacement surfaces, not
+        balls.
+        """
         return self is AtomViewEnum.ADP
 
     def radius_model(self) -> str:
-        """Return the radius-table name for ball sizing.
+        """
+        Return the radius-table name for ball sizing.
 
-        The ``adp`` view still needs ball radii for mixed-occupancy sites
-        and as a fallback for zero-displacement atoms, where it uses
-        covalent radii.
+        The ``adp`` view still needs ball radii for mixed-occupancy
+        sites and as a fallback for zero-displacement atoms, where it
+        uses covalent radii.
         """
         if self is AtomViewEnum.ADP:
             return AtomViewEnum.COVALENT.value
diff --git a/src/easydiffraction/display/structure/renderers/ascii.py b/src/easydiffraction/display/structure/renderers/ascii.py
index d12935e40..cc34279d1 100644
--- a/src/easydiffraction/display/structure/renderers/ascii.py
+++ b/src/easydiffraction/display/structure/renderers/ascii.py
@@ -30,7 +30,9 @@ def _tint(rgb: Rgb, text: str) -> str:
 
 
 def _collect_atoms(scene: StructureScene):
-    """Flatten every drawable atom to (centre, radius, colour, label)."""
+    """
+    Flatten every drawable atom to (centre, radius, colour, label).
+    """
     atoms = [(a.centre, a.radius, a.colour, a.label) for a in scene.atoms]
     atoms += [(s.centre, s.radius, s.wedges[0].colour, s.label) for s in scene.occupancy_spheres]
     atoms += [(e.centre, float(np.mean(e.semi_axes)) or 0.4, e.colour, e.label)
@@ -48,7 +50,9 @@ def supported_features(self) -> frozenset[str]:
         return self.SUPPORTED
 
     def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
-        """Render a schematic ASCII view and announce 3D-only features."""
+        """
+        Render a schematic ASCII view and announce 3D-only features.
+        """
         atoms = _collect_atoms(scene)
         basis = np.array(scene.cell_basis, dtype=float)
         # Match the 3D default orientation (by axis length): longest axis
@@ -161,8 +165,10 @@ def _grid_to_lines(grid):
 
 
 def _annotate_axes(lines, left_col, bottom_row, v_letter, h_letter):
-    """Stack the vertical-axis label above the cell and place the horizontal
-    label at the right end of the bottom border (ANSI-safe: no slicing).
+    """
+    Stack the vertical-axis label above the cell and place the
+    horizontal label at the right end of the bottom border (ANSI-safe:
+    no slicing).
     """
     indent = ' ' * left_col
     header = ['', f'{indent}{v_letter}', f'{indent}↑']  # blank line, letter, arrow
diff --git a/src/easydiffraction/display/structure/renderers/base.py b/src/easydiffraction/display/structure/renderers/base.py
index 5f6173524..4b36633b6 100644
--- a/src/easydiffraction/display/structure/renderers/base.py
+++ b/src/easydiffraction/display/structure/renderers/base.py
@@ -23,8 +23,9 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         scene : StructureScene
             The renderer-neutral primitives to draw.
         features : frozenset[str]
-            The content-resolved feature set from the facade. The renderer
-            draws the features it supports and announces + skips the rest.
+            The content-resolved feature set from the facade. The
+            renderer draws the features it supports and announces +
+            skips the rest.
 
         Returns
         -------
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index e7024c245..632b335b9 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -1,11 +1,13 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Raster renderer: a z-buffered PNG structure image for reports.
+"""
+Raster renderer: a z-buffered PNG structure image for reports.
 
-A tiny software rasteriser with a per-pixel depth buffer, so hidden-surface
-removal is exact for any structure. Spheres, bonds, cell edges, and axis
-arrows are all depth-tested against the same numpy buffer; Pillow then draws
-the a/b/c axis labels and the element legend on top and encodes the PNG.
+A tiny software rasteriser with a per-pixel depth buffer, so
+hidden-surface removal is exact for any structure. Spheres, bonds, cell
+edges, and axis arrows are all depth-tested against the same numpy
+buffer; Pillow then draws the a/b/c axis labels and the element legend
+on top and encodes the PNG.
 """
 
 from __future__ import annotations
@@ -50,12 +52,14 @@ def _unit(vector: np.ndarray) -> np.ndarray:
 
 
 def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Return (view_dir, right, up) for the default view.
+    """
+    Return (view_dir, right, up) for the default view.
 
-    Mirrors the Three.js default camera (by axis length): the longest axis is
-    horizontal, the 2nd-longest points up, the shortest goes into depth, and the
-    scene is viewed along ``0.37 longest + 0.24 middle + 0.90 shortest`` — so the
-    PDF figure and the interactive view orient identically.
+    Mirrors the Three.js default camera (by axis length): the longest
+    axis is horizontal, the 2nd-longest points up, the shortest goes
+    into depth, and the scene is viewed along ``0.37 longest + 0.24
+    middle + 0.90 shortest`` — so the PDF figure and the interactive
+    view orient identically.
     """
     if scene.axes is not None:
         vectors = [np.asarray(ax.vector, dtype=float) for ax in scene.axes.axes]
@@ -73,14 +77,18 @@ def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
 
 
 def _diffuse_intensity(normal: np.ndarray) -> np.ndarray:
-    """Lambertian key-plus-fill intensity for a unit surface-normal field."""
+    """
+    Lambertian key-plus-fill intensity for a unit surface-normal field.
+    """
     key = np.clip(normal @ _LIGHT, 0.0, 1.0)
     fill = 0.4 * np.clip(normal @ _FILL, 0.0, 1.0)
     return np.clip(_AMBIENT + (1.0 - _AMBIENT) * (key + fill), 0.0, 1.0)
 
 
 def _specular(normal: np.ndarray) -> np.ndarray:
-    """Blinn-Phong specular highlight for a unit surface-normal field."""
+    """
+    Blinn-Phong specular highlight for a unit surface-normal field.
+    """
     return _SPEC_STRENGTH * np.clip(normal @ _HALF, 0.0, 1.0) ** _SHININESS
 
 
@@ -122,7 +130,10 @@ class RasterStructureRenderer:
     SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes'})
 
     def render_png(self, scene, *, features: frozenset[str]) -> bytes:
-        """Return PNG bytes of the scene rendered with a per-pixel z-buffer."""
+        """
+        Return PNG bytes of the scene rendered with a per-pixel
+        z-buffer.
+        """
         view_dir, right, up = _view_basis(scene)
         points = _scene_points(scene)
         target = points.mean(axis=0)
@@ -176,7 +187,10 @@ def project(point: object) -> tuple[float, float, float]:
 
     @staticmethod
     def _compose_png(rgb, scene, project, features) -> bytes:
-        """Draw axis labels and the legend with Pillow, then encode the PNG."""
+        """
+        Draw axis labels and the legend with Pillow, then encode the
+        PNG.
+        """
         from PIL import Image  # noqa: PLC0415
         from PIL import ImageDraw  # noqa: PLC0415
 
@@ -192,7 +206,9 @@ def _compose_png(rgb, scene, project, features) -> bytes:
 
     @staticmethod
     def _draw_axis_labels(draw, axes, project) -> None:
-        """Place each axis letter just beyond its arrow tip, always on top."""
+        """
+        Place each axis letter just beyond its arrow tip, always on top.
+        """
         font = _font(int(_CANVAS * _LABEL_FRAC))
         inset = int(_CANVAS * 0.02)
         origin = np.asarray(axes.origin, dtype=float)
@@ -206,7 +222,9 @@ def _draw_axis_labels(draw, axes, project) -> None:
 
     @staticmethod
     def _draw_legend(draw, legend) -> None:
-        """Draw element colour swatches and symbols in a top-left panel."""
+        """
+        Draw element colour swatches and symbols in a top-left panel.
+        """
         font = _font(int(_CANVAS * _LEGEND_FRAC))
         margin = int(_CANVAS * 0.025)
         pad = int(_CANVAS * 0.014)
@@ -266,7 +284,10 @@ def _sphere(colour, depth, project, scale, centre, radius, base, *, wedges=None)
 
     @staticmethod
     def _base_colours(dx, dy, base, wedges) -> np.ndarray:
-        """Per-pixel base colour: a flat tint, or azimuthal occupancy wedges."""
+        """
+        Per-pixel base colour: a flat tint, or azimuthal occupancy
+        wedges.
+        """
         if not wedges:
             flat = np.asarray(base, dtype=np.float32) / 255.0
             return np.broadcast_to(flat, dx.shape + (3,))
@@ -284,7 +305,10 @@ def _base_colours(dx, dy, base, wedges) -> np.ndarray:
 
     @staticmethod
     def _ellipsoid(colour, depth, project, scale, basis, ell) -> None:
-        """Z-tested, shaded oriented ADP ellipsoid (exact ray cast per pixel)."""
+        """
+        Z-tested, shaded oriented ADP ellipsoid (exact ray cast per
+        pixel).
+        """
         right, up, view_dir = basis
         centre = np.asarray(ell.centre, dtype=float)
         semi = np.maximum(np.asarray(ell.semi_axes, dtype=float), 1e-9)
@@ -379,7 +403,10 @@ def _capsule(colour, depth, project, scale, p0, p1, radius, colour0, colour1) ->
 
     @staticmethod
     def _triangle(colour, depth, v0, v1, v2, shade) -> None:
-        """Z-test and fill one flat-shaded triangle from projected vertices."""
+        """
+        Z-test and fill one flat-shaded triangle from projected
+        vertices.
+        """
         size = colour.shape[0]
         (x0, y0, d0), (x1, y1, d1), (x2, y2, d2) = v0, v1, v2
         min_x = max(0, int(min(x0, x1, x2)))
@@ -407,11 +434,14 @@ def _triangle(colour, depth, v0, v1, v2, shade) -> None:
         colour[min_y:max_y, min_x:max_x][update] = shade
 
     def _arrow(self, colour, depth, project, basis, origin, vector, extent, rgb) -> None:
-        """Draw a shaft cylinder and head cone as 3D triangles (orientation-safe).
+        """
+        Draw a shaft cylinder and head cone as 3D triangles
+        (orientation-safe).
 
-        Thickness and head size are fractions of ``extent`` (the fit extent), so
-        the arrow is a constant on-screen size in every cell. ``vector`` already
-        runs to the arrow tip (cell edge plus overhang).
+        Thickness and head size are fractions of ``extent`` (the fit
+        extent), so the arrow is a constant on-screen size in every
+        cell. ``vector`` already runs to the arrow tip (cell edge plus
+        overhang).
         """
         right, up, view_dir = basis
         length = float(np.linalg.norm(vector))
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 45f5d6a31..12c74cb67 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Three.js renderer: an interactive, self-contained HTML structure view."""
+"""
+Three.js renderer: an interactive, self-contained HTML structure view.
+"""
 
 from __future__ import annotations
 
@@ -123,7 +125,9 @@ def _rgb_css(rgb: tuple[int, int, int]) -> str:
 
 
 class ThreeJsStructureRenderer(StructureRendererBase):
-    """Interactive Three.js renderer for notebook and standalone HTML."""
+    """
+    Interactive Three.js renderer for notebook and standalone HTML.
+    """
 
     SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'})
 
@@ -147,15 +151,16 @@ def render(
         scene : StructureScene
             The renderer-neutral primitives to draw.
         features : frozenset[str]
-            The content-resolved feature set; drives the modebar's initial
-            visibility toggles.
-        offline : bool
-            When ``True`` (default), inline the pinned Three.js assets so
-            the view renders with no network; when ``False`` link the CDN.
-        dark : bool | None
+            The content-resolved feature set; drives the modebar's
+            initial visibility toggles.
+        offline : bool, default=True
+            When ``True`` (default), inline the pinned Three.js assets
+            so the view renders with no network; when ``False`` link the
+            CDN.
+        dark : bool | None, default=None
             Force the dark (``True``) or light (``False``) theme. When
-            ``None`` (default), auto-detect from the environment. Reports
-            pass ``False`` so the view matches their light page.
+            ``None`` (default), auto-detect from the environment.
+            Reports pass ``False`` so the view matches their light page.
 
         Returns
         -------
diff --git a/src/easydiffraction/display/structure/scene.py b/src/easydiffraction/display/structure/scene.py
index 4df5196bb..6177ac5a1 100644
--- a/src/easydiffraction/display/structure/scene.py
+++ b/src/easydiffraction/display/structure/scene.py
@@ -52,10 +52,11 @@ class OccupancyWedgeSphere:
 
 @dataclass(frozen=True, slots=True)
 class AdpEllipsoid:
-    """An anisotropic ADP probability ellipsoid for one atom.
+    """
+    An anisotropic ADP probability ellipsoid for one atom.
 
-    ``wedges`` splits a shared site into relative-proportion colour wedges
-    (empty for a single atom, which uses ``colour``).
+    ``wedges`` splits a shared site into relative-proportion colour
+    wedges (empty for a single atom, which uses ``colour``).
     """
 
     centre: Vec3
@@ -130,7 +131,9 @@ class TextLabel:
 
 @dataclass(frozen=True, slots=True)
 class LegendEntry:
-    """One element's colour swatch and symbol for the structure legend."""
+    """
+    One element's colour swatch and symbol for the structure legend.
+    """
 
     symbol: str
     colour: Rgb
diff --git a/src/easydiffraction/display/structure/viewing.py b/src/easydiffraction/display/structure/viewing.py
index 94c1db611..3f89235b9 100644
--- a/src/easydiffraction/display/structure/viewing.py
+++ b/src/easydiffraction/display/structure/viewing.py
@@ -60,7 +60,8 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         Returns
         -------
         str
-            ASCII text or an HTML document, depending on the active engine.
+            ASCII text or an HTML document, depending on the active
+            engine.
         """
         return self._backend.render(scene, features=features)
 
diff --git a/src/easydiffraction/project/categories/rendering_structure/default.py b/src/easydiffraction/project/categories/rendering_structure/default.py
index 8eee95a38..93cfb4b6d 100644
--- a/src/easydiffraction/project/categories/rendering_structure/default.py
+++ b/src/easydiffraction/project/categories/rendering_structure/default.py
@@ -1,6 +1,9 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project structure-rendering_structure category (switchable renderer engine)."""
+"""
+Project structure-rendering_structure category (switchable renderer
+engine).
+"""
 
 from __future__ import annotations
 
@@ -83,7 +86,10 @@ def viewer(self) -> Viewer:
         return self._viewer
 
     def from_cif(self, block: object, idx: int = 0) -> None:
-        """Populate this rendering_structure category from a CIF block, rebinding engine."""
+        """
+        Populate this rendering_structure category from a CIF block,
+        rebinding engine.
+        """
         super().from_cif(block, idx)
         view_type = read_cif_str(block, '_rendering_structure.type')
         if view_type is not None:
@@ -91,5 +97,7 @@ def from_cif(self, block: object, idx: int = 0) -> None:
 
     @property
     def as_cif(self) -> str:
-        """Return CIF representation of this rendering_structure category."""
+        """
+        Return CIF representation of this rendering_structure category.
+        """
         return super().as_cif
diff --git a/src/easydiffraction/project/categories/structure_style/default.py b/src/easydiffraction/project/categories/structure_style/default.py
index 2cc0d9941..0df781bde 100644
--- a/src/easydiffraction/project/categories/structure_style/default.py
+++ b/src/easydiffraction/project/categories/structure_style/default.py
@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project structure_style category (durable structure-view appearance)."""
+"""
+Project structure_style category (durable structure-view appearance).
+"""
 
 from __future__ import annotations
 
@@ -63,7 +65,10 @@ def __init__(self) -> None:
 
     @property
     def atom_view(self) -> EnumDescriptor:
-        """How atoms are sized/shaped (``vdw``/``covalent``/``ionic``/``adp``)."""
+        """
+        How atoms are sized/shaped
+        (``vdw``/``covalent``/``ionic``/``adp``).
+        """
         return self._atom_view
 
     @atom_view.setter
@@ -81,7 +86,9 @@ def color_scheme(self, value: str) -> None:
 
     @property
     def adp_probability(self) -> NumericDescriptor:
-        """ORTEP probability level (fraction in the open interval (0, 1))."""
+        """
+        ORTEP probability level (fraction in the open interval (0, 1)).
+        """
         return self._adp_probability
 
     @adp_probability.setter
@@ -90,7 +97,10 @@ def adp_probability(self, value: float) -> None:
 
     @property
     def atom_scale(self) -> NumericDescriptor:
-        """Overall ball-atom size factor in (0, 1] (square-root compressed)."""
+        """
+        Overall ball-atom size factor in (0, 1] (square-root
+        compressed).
+        """
         return self._atom_scale
 
     @atom_scale.setter
@@ -99,5 +109,7 @@ def atom_scale(self, value: float) -> None:
 
     @property
     def as_cif(self) -> str:
-        """Return CIF representation of this structure_style category."""
+        """
+        Return CIF representation of this structure_style category.
+        """
         return super().as_cif
diff --git a/src/easydiffraction/project/categories/structure_view/default.py b/src/easydiffraction/project/categories/structure_view/default.py
index 0abb81a2e..1c22ba2f1 100644
--- a/src/easydiffraction/project/categories/structure_view/default.py
+++ b/src/easydiffraction/project/categories/structure_view/default.py
@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""Project structure_view category (durable content + region view state)."""
+"""
+Project structure_view category (durable content + region view state).
+"""
 
 from __future__ import annotations
 
@@ -137,7 +139,9 @@ def range_c_max(self, value: float) -> None:
         self._set_bound(self._range_c_max, value, lower=self._range_c_min.value, upper=float('inf'))
 
     def view_range(self) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        """Assemble the per-axis ``((min, max), ...)`` fractional window."""
+        """
+        Assemble the per-axis ``((min, max), ...)`` fractional window.
+        """
         return (
             (self._range_a_min.value, self._range_a_max.value),
             (self._range_b_min.value, self._range_b_max.value),
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 4b77a2dfc..ccf430927 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -481,25 +481,28 @@ def structure(
         Show a 3D structure view for one structure.
 
         Parallels :meth:`pattern`: it draws with the active
-        ``project.rendering_structure`` engine and displays directly (no return value).
-        Feature visibility is resolved per ADR section 8; the renderer
-        announces and skips any feature it cannot draw.
+        ``project.rendering_structure`` engine and displays directly (no
+        return value). Feature visibility is resolved per ADR section 8;
+        the renderer announces and skips any feature it cannot draw.
 
         Parameters
         ----------
         struct_name : str
             Name of the structure to draw.
-        include : str | tuple[str, ...]
-            ``'auto'`` (default) resolves features from data availability,
-            persisted ``project.rendering_structure`` flags, then built-in defaults; an
-            explicit tuple of ``atoms``/``bonds``/``cell``/``axes``/
+        include : str | tuple[str, ...], default='auto'
+            ``'auto'`` (default) resolves features from data
+            availability, persisted ``project.rendering_structure``
+            flags, then built-in defaults; an explicit tuple of
+            ``atoms``/``bonds``/``cell``/``axes``/
             ``moments``/``labels`` wins outright.
-        range : tuple | None
-            Optional per-axis ``((min, max), ...)`` window overriding the
-            persisted ``project.rendering_structure`` range for this call only.
-        path : str | None
+        range : tuple[tuple[float, float], tuple[float, float], tuple[float, float]] | None, default=None
+            Optional per-axis ``((min, max), ...)`` window overriding
+            the persisted ``project.rendering_structure`` range for this
+            call only.
+        path : str | None, default=None
             When given, write the rendered view to this path instead of
-            displaying it (a standalone HTML file for the Three.js engine).
+            displaying it (a standalone HTML file for the Three.js
+            engine).
         """
         from easydiffraction.display.structure.builder import build_scene  # noqa: PLC0415
         from easydiffraction.display.structure.builder import (  # noqa: PLC0415
@@ -526,7 +529,9 @@ def structure(
         self._emit_structure_output(output)
 
     def show_structure_options(self, struct_name: str) -> None:
-        """Show available ``structure(include=...)`` options with reasons."""
+        """
+        Show available ``structure(include=...)`` options with reasons.
+        """
         from easydiffraction.display.structure.builder import (  # noqa: PLC0415
             structure_feature_availability,
         )
@@ -562,7 +567,9 @@ def _resolve_structure_features(
         include: str | tuple[str, ...],
         availability: object,
     ) -> frozenset[str]:
-        """Resolve the concrete feature set per ADR section 8 precedence."""
+        """
+        Resolve the concrete feature set per ADR section 8 precedence.
+        """
         normalized = self._normalize_structure_include(include)
         if normalized != ('auto',):
             return frozenset(normalized)
diff --git a/src/easydiffraction/report/fit_plot.py b/src/easydiffraction/report/fit_plot.py
index 3d1d370d6..1f60fc677 100644
--- a/src/easydiffraction/report/fit_plot.py
+++ b/src/easydiffraction/report/fit_plot.py
@@ -164,11 +164,12 @@ def fit_scatter_geometry() -> dict[str, float]:
 
 
 def fit_scatter_ranges(fit_data: dict[str, Any]) -> dict[str, float]:
-    """Return the shared x/y range, tick step, and y=x diagonal span.
+    """
+    Return the shared x/y range, tick step, and y=x diagonal span.
 
     The x and y axes share one range (computed across the calculated
-    values and the measured values widened by their uncertainties) so the
-    diagonal is a true y=x line and the ticks can match.
+    values and the measured values widened by their uncertainties) so
+    the diagonal is a true y=x line and the ticks can match.
     """
     x_values = _numeric_values(fit_data['x']['values'])
     meas = fit_data['series']['meas']
diff --git a/src/easydiffraction/report/html_renderer.py b/src/easydiffraction/report/html_renderer.py
index 4025ad63e..0d59909cf 100644
--- a/src/easydiffraction/report/html_renderer.py
+++ b/src/easydiffraction/report/html_renderer.py
@@ -197,7 +197,9 @@ def _structure_figure_html_context(
     *,
     offline: bool,
 ) -> dict[str, str]:
-    """Return interactive structure-view HTML snippets by structure name."""
+    """
+    Return interactive structure-view HTML snippets by structure name.
+    """
     from easydiffraction.display.structure.builder import build_scene  # noqa: PLC0415
     from easydiffraction.display.structure.builder import (  # noqa: PLC0415
         structure_feature_availability,
diff --git a/src/easydiffraction/utils/enums.py b/src/easydiffraction/utils/enums.py
index 8de9ac148..44c3ac4dc 100644
--- a/src/easydiffraction/utils/enums.py
+++ b/src/easydiffraction/utils/enums.py
@@ -30,7 +30,9 @@ def default(cls) -> VerbosityEnum:
         return cls.FULL
 
     def description(self) -> str:
-        """Return a human-readable description of this verbosity level."""
+        """
+        Return a human-readable description of this verbosity level.
+        """
         if self is VerbosityEnum.FULL:
             return 'Multi-line output with headers, tables, and details.'
         if self is VerbosityEnum.SHORT:

From ad954e99108610f765ec305fcd748d4019957df4 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:03:07 +0200
Subject: [PATCH 093/160] Pin Logger to WARN in rendering_plot invalid-type
 test

---
 .../categories/rendering_plot/test_default.py        | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py b/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py
index 0b2b236e2..8686b65e3 100644
--- a/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py
+++ b/tests/unit/easydiffraction/project/categories/rendering_plot/test_default.py
@@ -85,12 +85,22 @@ def test_rendering_plot_invalid_type_assignment_raises():
 def test_rendering_plot_from_cif_tolerates_invalid_type(monkeypatch):
     from easydiffraction.project.categories.rendering_plot import default as rendering_plot_mod
     from easydiffraction.project.categories.rendering_plot.default import RenderingPlot
+    from easydiffraction.utils.logging import Logger
+
+    # The descriptor's own from_cif validation routes through the
+    # Logger; force WARN so it logs rather than raises (another test
+    # may have left the Logger in RAISE mode).
+    monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
 
     rendering_plot = RenderingPlot()
     rendering_plot._parent = type(
         'P',
         (),
-        {'_swap_rendering_plot': lambda self, t, *, strict: rendering_plot._set_type(t, strict=strict)},
+        {
+            '_swap_rendering_plot': lambda self, t, *, strict: rendering_plot._set_type(
+                t, strict=strict
+            )
+        },
     )()
     block = gemmi.cif.read_string(
         'data_test\n_rendering_plot.type bogus-engine\n',

From 1b5f2bd7179287ba8b60fbcdbfa2cd9d9d8cd226 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:04:35 +0200
Subject: [PATCH 094/160] Regenerate drifted tutorial notebooks

---
 docs/docs/tutorials/ed-13.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/tutorials/ed-13.ipynb b/docs/docs/tutorials/ed-13.ipynb
index 3dce6bc36..5734acb88 100644
--- a/docs/docs/tutorials/ed-13.ipynb
+++ b/docs/docs/tutorials/ed-13.ipynb
@@ -2648,7 +2648,7 @@
  ],
  "metadata": {
   "jupytext": {
-   "cell_metadata_filter": "tags,title,-all",
+   "cell_metadata_filter": "title,tags,-all",
    "main_language": "python",
    "notebook_metadata_filter": "-all"
   }

From 8dc4aa1269a43a01a3a295d0154f4f9879ebdf27 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:10:46 +0200
Subject: [PATCH 095/160] Ignore vendored structure renderers

---
 .prettierignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.prettierignore b/.prettierignore
index 3891a9359..b894e10fb 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -26,6 +26,7 @@ docs/docs/assets/
 node_modules
 
 # Vendored snapshots
+src/easydiffraction/display/structure/renderers/vendor/
 src/easydiffraction/report/templates/html/vendor/
 src/easydiffraction/report/templates/tex/styles/
 src/easydiffraction/utils/_vendored/jupyter_dark_detect/

From 6d081c8f1dfc2515f268031075af41317d8322e2 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:11:12 +0200
Subject: [PATCH 096/160] Reorder tutorial rendering and fix jupytext metadata

---
 docs/docs/tutorials/ed-13.ipynb |   2 +-
 docs/docs/tutorials/ed-3.ipynb  | 458 +++++++++++++++-----------------
 docs/docs/tutorials/ed-3.py     |  54 ++--
 3 files changed, 235 insertions(+), 279 deletions(-)

diff --git a/docs/docs/tutorials/ed-13.ipynb b/docs/docs/tutorials/ed-13.ipynb
index 5734acb88..3dce6bc36 100644
--- a/docs/docs/tutorials/ed-13.ipynb
+++ b/docs/docs/tutorials/ed-13.ipynb
@@ -2648,7 +2648,7 @@
  ],
  "metadata": {
   "jupytext": {
-   "cell_metadata_filter": "title,tags,-all",
+   "cell_metadata_filter": "tags,title,-all",
    "main_language": "python",
    "notebook_metadata_filter": "-all"
   }
diff --git a/docs/docs/tutorials/ed-3.ipynb b/docs/docs/tutorials/ed-3.ipynb
index 148c4f8cb..08b84e8a7 100644
--- a/docs/docs/tutorials/ed-3.ipynb
+++ b/docs/docs/tutorials/ed-3.ipynb
@@ -155,50 +155,6 @@
    "cell_type": "markdown",
    "id": "13",
    "metadata": {},
-   "source": [
-    "#### Set Up Rendering Engines"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "14",
-   "metadata": {},
-   "source": [
-    "Show supported data plotting engines."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "15",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "project.rendering_plot.show_supported()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "16",
-   "metadata": {},
-   "source": [
-    "Show supported structure plotting engines."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "17",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "project.rendering_structure.show_supported()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "18",
-   "metadata": {},
    "source": [
     "## Step 2: Define Structure\n",
     "\n",
@@ -208,7 +164,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "19",
+   "id": "14",
    "metadata": {},
    "source": [
     "#### Add Structure"
@@ -217,7 +173,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -226,7 +182,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "21",
+   "id": "16",
    "metadata": {},
    "source": [
     "#### Show Defined Structures\n",
@@ -240,7 +196,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -249,7 +205,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "23",
+   "id": "18",
    "metadata": {},
    "source": [
     "#### Set Space Group\n",
@@ -260,7 +216,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -270,7 +226,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "25",
+   "id": "20",
    "metadata": {},
    "source": [
     "#### Set Unit Cell\n",
@@ -281,7 +237,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -290,7 +246,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "27",
+   "id": "22",
    "metadata": {},
    "source": [
     "#### Set Atom Sites\n",
@@ -301,7 +257,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "28",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -347,7 +303,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "29",
+   "id": "24",
    "metadata": {},
    "source": [
     "#### Show Structure as CIF"
@@ -356,7 +312,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -365,10 +321,10 @@
   },
   {
    "cell_type": "markdown",
-   "id": "31",
+   "id": "26",
    "metadata": {},
    "source": [
-    "#### View Structure in 3D\n",
+    "#### View Structure\n",
     "\n",
     "EasyDiffraction can draw the structure that has just been defined. The\n",
     "renderer engine is selected through `project.rendering_structure`. The default `auto`\n",
@@ -379,17 +335,25 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
     "project.rendering_structure.show_supported()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "28",
+   "metadata": {},
+   "source": [
+    "Show all public attributes of the structure rendering engine."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -398,7 +362,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "34",
+   "id": "30",
    "metadata": {},
    "source": [
     "Visual styling — the atom view and colour scheme — is configured on\n",
@@ -408,7 +372,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -419,7 +383,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -429,7 +393,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "37",
+   "id": "33",
    "metadata": {},
    "source": [
     "Bonds are generated automatically between atoms whose separation lies\n",
@@ -439,7 +403,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -449,7 +413,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "39",
+   "id": "35",
    "metadata": {},
    "source": [
     "List which features the structure data and the active engine can draw."
@@ -458,7 +422,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -467,7 +431,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "41",
+   "id": "37",
    "metadata": {},
    "source": [
     "Draw the structure. With `include='auto'` (the default) every available\n",
@@ -478,7 +442,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -487,7 +451,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "39",
    "metadata": {},
    "source": [
     "For a quick text schematic, switch to the `ascii` engine explicitly,\n",
@@ -497,7 +461,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -507,7 +471,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "45",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -517,15 +481,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "47",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -534,7 +490,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "48",
+   "id": "43",
    "metadata": {},
    "source": [
     "#### Save Project State\n",
@@ -547,7 +503,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -556,7 +512,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "45",
    "metadata": {},
    "source": [
     "## Step 3: Define Experiment\n",
@@ -567,7 +523,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "51",
+   "id": "46",
    "metadata": {},
    "source": [
     "#### Download Measured Data\n",
@@ -578,7 +534,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "47",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -587,7 +543,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "53",
+   "id": "48",
    "metadata": {},
    "source": [
     "#### Add Diffraction Experiment"
@@ -596,7 +552,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "54",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -611,7 +567,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "55",
+   "id": "50",
    "metadata": {},
    "source": [
     "#### Show Defined Experiments"
@@ -620,7 +576,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "56",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -629,7 +585,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "57",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Show Measured Data"
@@ -638,7 +594,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -647,7 +603,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "54",
    "metadata": {},
    "source": [
     "#### Set Instrument\n",
@@ -658,7 +614,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -668,7 +624,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "61",
+   "id": "56",
    "metadata": {},
    "source": [
     "#### Set Peak Profile\n",
@@ -679,7 +635,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "62",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -688,7 +644,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "58",
    "metadata": {},
    "source": [
     "Select the desired peak profile type."
@@ -697,7 +653,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "59",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -706,7 +662,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "60",
    "metadata": {},
    "source": [
     "Modify default peak profile parameters."
@@ -715,7 +671,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -728,7 +684,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "62",
    "metadata": {},
    "source": [
     "#### Set Background"
@@ -736,7 +692,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "68",
+   "id": "63",
    "metadata": {},
    "source": [
     "Show supported background types."
@@ -745,7 +701,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "69",
+   "id": "64",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -754,7 +710,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "70",
+   "id": "65",
    "metadata": {},
    "source": [
     "Select the desired background type."
@@ -763,7 +719,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "71",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -772,7 +728,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "72",
+   "id": "67",
    "metadata": {},
    "source": [
     "Add background points."
@@ -781,7 +737,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "73",
+   "id": "68",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -794,7 +750,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "74",
+   "id": "69",
    "metadata": {},
    "source": [
     "Show current background points."
@@ -803,7 +759,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "75",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -812,7 +768,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "76",
+   "id": "71",
    "metadata": {},
    "source": [
     "#### Set Linked Phases\n",
@@ -823,7 +779,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "77",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -832,7 +788,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "78",
+   "id": "73",
    "metadata": {},
    "source": [
     "#### Show Experiment as CIF"
@@ -841,7 +797,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "79",
+   "id": "74",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -850,7 +806,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "80",
+   "id": "75",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -859,7 +815,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "81",
+   "id": "76",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -868,7 +824,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "82",
+   "id": "77",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis\n",
@@ -884,7 +840,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "83",
+   "id": "78",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -893,7 +849,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "84",
+   "id": "79",
    "metadata": {},
    "source": [
     "Select the desired calculation engine."
@@ -902,7 +858,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "85",
+   "id": "80",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -911,7 +867,49 @@
   },
   {
    "cell_type": "markdown",
-   "id": "86",
+   "id": "81",
+   "metadata": {},
+   "source": [
+    "#### Set Up Data Rendering Engine\n",
+    "\n",
+    "EasyDiffraction can plot the measured and calculated patterns using different rendering engines.\n",
+    "The default `auto` engine resolves to an interactive `plotly` view inside Jupyter and a\n",
+    "static `asciichartpy` plot for schematic representation in a terminal.\n",
+    "\n",
+    "Show supported data plotting engines."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.rendering_plot.show_supported()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83",
+   "metadata": {},
+   "source": [
+    "Show all public attributes of the data rendering engine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.rendering_plot.help()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85",
    "metadata": {},
    "source": [
     "#### Show Calculated Data"
@@ -920,7 +918,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "87",
+   "id": "86",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -929,7 +927,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "88",
+   "id": "87",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -938,7 +936,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "89",
+   "id": "88",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -948,7 +946,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "90",
+   "id": "89",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -957,7 +955,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "91",
+   "id": "90",
    "metadata": {},
    "source": [
     "#### Show Parameters\n",
@@ -968,7 +966,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "92",
+   "id": "91",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -977,7 +975,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "93",
+   "id": "92",
    "metadata": {},
    "source": [
     "Show all fittable parameters."
@@ -986,7 +984,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "94",
+   "id": "93",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -995,7 +993,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "95",
+   "id": "94",
    "metadata": {},
    "source": [
     "Show only free parameters."
@@ -1004,7 +1002,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "96",
+   "id": "95",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1013,7 +1011,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "97",
+   "id": "96",
    "metadata": {},
    "source": [
     "Show how to access parameters in the code."
@@ -1022,7 +1020,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "98",
+   "id": "97",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1031,7 +1029,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "99",
+   "id": "98",
    "metadata": {},
    "source": [
     "#### Set Fit Mode\n",
@@ -1042,7 +1040,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "100",
+   "id": "99",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1051,7 +1049,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "101",
+   "id": "100",
    "metadata": {},
    "source": [
     "Select desired fit mode."
@@ -1060,7 +1058,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "102",
+   "id": "101",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1069,7 +1067,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "103",
+   "id": "102",
    "metadata": {},
    "source": [
     "#### Set Minimizer\n",
@@ -1080,7 +1078,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "104",
+   "id": "103",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1089,7 +1087,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "105",
+   "id": "104",
    "metadata": {},
    "source": [
     "Select desired fitting engine."
@@ -1098,7 +1096,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "106",
+   "id": "105",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1107,7 +1105,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "107",
+   "id": "106",
    "metadata": {},
    "source": [
     "### Perform Fit 1/5\n",
@@ -1118,7 +1116,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "108",
+   "id": "107",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1127,7 +1125,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "109",
+   "id": "108",
    "metadata": {},
    "source": [
     "Set experiment parameters to be refined."
@@ -1136,7 +1134,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "110",
+   "id": "109",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1151,7 +1149,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "111",
+   "id": "110",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1160,7 +1158,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "112",
+   "id": "111",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1169,7 +1167,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "113",
+   "id": "112",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1178,7 +1176,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "114",
+   "id": "113",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1188,7 +1186,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "115",
+   "id": "114",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1197,7 +1195,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "116",
+   "id": "115",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1207,7 +1205,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "117",
+   "id": "116",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1216,7 +1214,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "118",
+   "id": "117",
    "metadata": {},
    "source": [
     "### Perform Fit 2/5\n",
@@ -1227,7 +1225,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "119",
+   "id": "118",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1239,7 +1237,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "120",
+   "id": "119",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1248,7 +1246,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "121",
+   "id": "120",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1257,7 +1255,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "122",
+   "id": "121",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1266,7 +1264,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "123",
+   "id": "122",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1276,7 +1274,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "124",
+   "id": "123",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1285,7 +1283,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "125",
+   "id": "124",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1295,7 +1293,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "126",
+   "id": "125",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1304,7 +1302,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "127",
+   "id": "126",
    "metadata": {},
    "source": [
     "#### Save Project State"
@@ -1313,7 +1311,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "128",
+   "id": "127",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1322,7 +1320,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "129",
+   "id": "128",
    "metadata": {},
    "source": [
     "### Perform Fit 3/5\n",
@@ -1333,7 +1331,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "130",
+   "id": "129",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1345,7 +1343,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "131",
+   "id": "130",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1354,7 +1352,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "132",
+   "id": "131",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1363,7 +1361,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "133",
+   "id": "132",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1372,7 +1370,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "134",
+   "id": "133",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1382,7 +1380,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "135",
+   "id": "134",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1391,7 +1389,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "136",
+   "id": "135",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1401,7 +1399,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "137",
+   "id": "136",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1410,7 +1408,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "138",
+   "id": "137",
    "metadata": {},
    "source": [
     "### Perform Fit 4/5\n",
@@ -1423,7 +1421,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "139",
+   "id": "138",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1439,7 +1437,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "140",
+   "id": "139",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -1448,7 +1446,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "141",
+   "id": "140",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1457,7 +1455,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "142",
+   "id": "141",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1466,7 +1464,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "143",
+   "id": "142",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1475,7 +1473,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "144",
+   "id": "143",
    "metadata": {},
    "source": [
     "Show free parameters."
@@ -1484,7 +1482,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "145",
+   "id": "144",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1493,7 +1491,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "146",
+   "id": "145",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1502,7 +1500,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "147",
+   "id": "146",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1512,7 +1510,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "148",
+   "id": "147",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1521,7 +1519,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "149",
+   "id": "148",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1531,7 +1529,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "150",
+   "id": "149",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1540,7 +1538,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "151",
+   "id": "150",
    "metadata": {},
    "source": [
     "### Perform Fit 5/5\n",
@@ -1553,7 +1551,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "152",
+   "id": "151",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1569,7 +1567,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "153",
+   "id": "152",
    "metadata": {},
    "source": [
     "Set more constraints."
@@ -1578,7 +1576,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "154",
+   "id": "153",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1589,7 +1587,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "155",
+   "id": "154",
    "metadata": {},
    "source": [
     "Show defined constraints."
@@ -1598,7 +1596,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "156",
+   "id": "155",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -1609,7 +1607,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "157",
+   "id": "156",
    "metadata": {},
    "source": [
     "Set structure parameters to be refined."
@@ -1618,7 +1616,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "158",
+   "id": "157",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1627,7 +1625,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "159",
+   "id": "158",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -1636,7 +1634,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "160",
+   "id": "159",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1645,7 +1643,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "161",
+   "id": "160",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -1654,7 +1652,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "162",
+   "id": "161",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1665,7 +1663,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "163",
+   "id": "162",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -1674,7 +1672,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "164",
+   "id": "163",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1684,7 +1682,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "165",
+   "id": "164",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1694,7 +1692,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "166",
+   "id": "165",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1702,40 +1700,26 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "167",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "168",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "169",
+   "cell_type": "markdown",
+   "id": "166",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "source": [
+    "#### Plot Structure"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "170",
+   "id": "167",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
   },
   {
    "cell_type": "markdown",
-   "id": "171",
+   "id": "168",
    "metadata": {},
    "source": [
     "## Step 5: Generate Report\n",
@@ -1755,7 +1739,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "172",
+   "id": "169",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1764,30 +1748,6 @@
     "project.report.pdf = True\n",
     "project.save()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "173",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "174",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "175",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/docs/tutorials/ed-3.py b/docs/docs/tutorials/ed-3.py
index b2b1a0bb4..1e1d61711 100644
--- a/docs/docs/tutorials/ed-3.py
+++ b/docs/docs/tutorials/ed-3.py
@@ -60,21 +60,6 @@
 # %%
 project.save_as(dir_path='projects/lbco_hrpt')
 
-# %% [markdown]
-# #### Set Up Rendering Engines
-
-# %% [markdown]
-# Show supported data plotting engines.
-
-# %%
-project.rendering_plot.show_supported()
-
-# %% [markdown]
-# Show supported structure plotting engines.
-
-# %%
-project.rendering_structure.show_supported()
-
 # %% [markdown]
 # ## Step 2: Define Structure
 #
@@ -167,7 +152,7 @@
 project.structures['lbco'].show_as_cif()
 
 # %% [markdown]
-# #### View Structure in 3D
+# #### View Structure
 #
 # EasyDiffraction can draw the structure that has just been defined. The
 # renderer engine is selected through `project.rendering_structure`. The default `auto`
@@ -177,6 +162,9 @@
 # %%
 project.rendering_structure.show_supported()
 
+# %% [markdown]
+# Show all public attributes of the structure rendering engine.
+
 # %%
 project.rendering_structure.help()
 
@@ -224,8 +212,6 @@
 # %%
 project.display.structure(struct_name='lbco')
 
-# %%
-
 # %%
 project.rendering_structure.type = 'auto'
 
@@ -380,6 +366,24 @@
 # %%
 project.experiments['hrpt'].calculator.type = 'cryspy'
 
+# %% [markdown]
+# #### Set Up Data Rendering Engine
+#
+# EasyDiffraction can plot the measured and calculated patterns using different rendering engines.
+# The default `auto` engine resolves to an interactive `plotly` view inside Jupyter and a
+# static `asciichartpy` plot for schematic representation in a terminal.
+#
+# Show supported data plotting engines.
+
+# %%
+project.rendering_plot.show_supported()
+
+# %% [markdown]
+# Show all public attributes of the data rendering engine.
+
+# %%
+project.rendering_plot.help()
+
 # %% [markdown]
 # #### Show Calculated Data
 
@@ -678,13 +682,11 @@
 # %%
 project.display.structure(struct_name='lbco')
 
-# %%
-
-# %%
-
-# %%
+# %% [markdown]
+# #### Plot Structure
 
 # %%
+project.display.structure(struct_name='lbco')
 
 # %% [markdown]
 # ## Step 5: Generate Report
@@ -705,9 +707,3 @@
 project.report.tex = True
 project.report.pdf = True
 project.save()
-
-# %%
-
-# %%
-
-# %%

From 1533398ffef4af34f62dc45078b4d48ad4e002cb Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:11:57 +0200
Subject: [PATCH 097/160] Reduce report margin to 2cm

---
 src/easydiffraction/report/templates/tex/report.tex.j2 |  2 +-
 tests/unit/easydiffraction/report/test_tex_renderer.py | 10 ++++++++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/easydiffraction/report/templates/tex/report.tex.j2 b/src/easydiffraction/report/templates/tex/report.tex.j2
index 52cfc78d0..4c16afdc2 100644
--- a/src/easydiffraction/report/templates/tex/report.tex.j2
+++ b/src/easydiffraction/report/templates/tex/report.tex.j2
@@ -7,7 +7,7 @@
 % ====================================================================
 
 \documentclass[11pt]{article}
-\usepackage[margin=2.5cm]{geometry}
+\usepackage[margin=2cm]{geometry}
 
 % --------------------------------------------------------------------
 %  Packages
diff --git a/tests/unit/easydiffraction/report/test_tex_renderer.py b/tests/unit/easydiffraction/report/test_tex_renderer.py
index c26fe46b6..f12b68f47 100644
--- a/tests/unit/easydiffraction/report/test_tex_renderer.py
+++ b/tests/unit/easydiffraction/report/test_tex_renderer.py
@@ -143,7 +143,7 @@ def test_render_tex_report_renders_default_document():
     tex = render_tex_report(context)
 
     assert r'\documentclass[11pt]{article}' in tex
-    assert r'\usepackage[margin=2.5cm]{geometry}' in tex
+    assert r'\usepackage[margin=2cm]{geometry}' in tex
     assert r'\usepackage{fourier}' in tex
     assert r'\usepackage{longtable}' in tex
     assert r'\usepackage{paratype}' in tex
@@ -476,7 +476,13 @@ def test_save_tex_report_writes_structure_figure_png(tmp_path):
         label='Na', type_symbol='Na', fract_x=0, fract_y=0, fract_z=0, adp_iso=0.5, occupancy=1
     )
     structure.atom_sites.create(
-        label='Cl', type_symbol='Cl', fract_x=0.5, fract_y=0.5, fract_z=0.5, adp_iso=0.5, occupancy=1
+        label='Cl',
+        type_symbol='Cl',
+        fract_x=0.5,
+        fract_y=0.5,
+        fract_z=0.5,
+        adp_iso=0.5,
+        occupancy=1,
     )
 
     tex_path = tmp_path / 'report.tex'

From 2844cb029fd38282b7579294fcab7c70f80e465a Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:17:28 +0200
Subject: [PATCH 098/160] Call theme_colors by keyword in Three.js renderer

---
 .../display/structure/renderers/threejs.py    |   5 +-
 .../structure/renderers/test_threejs.py       | 617 ++++++++++++++++++
 2 files changed, 620 insertions(+), 2 deletions(-)
 create mode 100644 tests/unit/easydiffraction/display/structure/renderers/test_threejs.py

diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 12c74cb67..8509ec4c5 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -130,6 +130,7 @@ class ThreeJsStructureRenderer(StructureRendererBase):
     """
 
     SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'})
+    TEMPLATE_NAME = 'structure.html.j2'
 
     def supported_features(self) -> frozenset[str]:
         """Return the features the Three.js engine can draw."""
@@ -169,10 +170,10 @@ def render(
         """
         if dark is None:
             dark = is_dark()
-        colours = theme_colors(dark)
+        colours = theme_colors(dark=dark)
         payload = json.dumps(_scene_payload(scene)).replace('</', '<\\/')
         import_map = json.dumps({'imports': _import_map(offline=offline)}).replace('</', '<\\/')
-        template = _environment().get_template('structure.html.j2')
+        template = _environment().get_template(self.TEMPLATE_NAME)
         return template.render(
             container_id=f'crysview-{uuid.uuid4().hex}',
             scene_json=payload,
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
new file mode 100644
index 000000000..9e237678a
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -0,0 +1,617 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the Three.js structure renderer."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from easydiffraction.display.structure.enums import ColorSchemeEnum
+from easydiffraction.display.structure.renderers import threejs as MUT
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
+from easydiffraction.display.structure.scene import AdpEllipsoid
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import AxisArrow
+from easydiffraction.display.structure.scene import AxisTriad
+from easydiffraction.display.structure.scene import Bond
+from easydiffraction.display.structure.scene import CellEdge
+from easydiffraction.display.structure.scene import CellEdges
+from easydiffraction.display.structure.scene import LegendEntry
+from easydiffraction.display.structure.scene import OccupancyWedge
+from easydiffraction.display.structure.scene import OccupancyWedgeSphere
+from easydiffraction.display.structure.scene import StructureScene
+from easydiffraction.display.structure.scene import TextLabel
+
+# A representative theme palette returned by the patched ``theme_colors``.
+_PATCHED_THEME = {'background': (10, 20, 30), 'foreground': (240, 240, 240)}
+
+# Identity cell basis shared by the lightweight scenes below.
+_IDENTITY_BASIS = ((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0))
+
+
+def _identity_scene() -> StructureScene:
+    """Return the minimal valid scene (only a cell basis)."""
+    return StructureScene(cell_basis=_IDENTITY_BASIS)
+
+
+def _rich_scene() -> StructureScene:
+    """Return a scene exercising every primitive the payload reads."""
+    atom = AtomSphere(
+        centre=(0.0, 0.0, 0.0),
+        radius=0.5,
+        colour=(255, 0, 0),
+        label='Fe',
+        asymmetric=True,
+    )
+    wedge_sphere = OccupancyWedgeSphere(
+        centre=(0.5, 0.5, 0.5),
+        radius=0.4,
+        wedges=(
+            OccupancyWedge(fraction=0.6, colour=(0, 0, 255)),
+            OccupancyWedge(fraction=0.4, colour=(210, 210, 210)),
+        ),
+        label='La/Ba',
+    )
+    ellipsoid = AdpEllipsoid(
+        centre=(0.25, 0.25, 0.25),
+        semi_axes=(0.3, 0.2, 0.1),
+        orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+        colour=(0, 255, 0),
+        label='O',
+        wedges=(OccupancyWedge(fraction=1.0, colour=(0, 255, 0)),),
+        asymmetric=True,
+    )
+    bond = Bond(
+        start=(0.0, 0.0, 0.0),
+        end=(0.5, 0.5, 0.5),
+        start_colour=(255, 0, 0),
+        end_colour=(0, 0, 255),
+        start_element='Fe',
+        end_element='O',
+    )
+    edges = CellEdges(
+        edges=(
+            CellEdge(start=(0.0, 0.0, 0.0), end=(1.0, 0.0, 0.0)),
+            CellEdge(start=(0.0, 0.0, 0.0), end=(0.0, 1.0, 0.0)),
+        ),
+    )
+    axes = AxisTriad(
+        origin=(0.0, 0.0, 0.0),
+        axes=(
+            AxisArrow(vector=(1.0, 0.0, 0.0), colour=(220, 40, 40), letter='a'),
+            AxisArrow(vector=(0.0, 1.0, 0.0), colour=(40, 180, 40), letter='b'),
+            AxisArrow(vector=(0.0, 0.0, 1.0), colour=(40, 80, 220), letter='c'),
+        ),
+    )
+    return StructureScene(
+        cell_basis=_IDENTITY_BASIS,
+        atoms=(atom,),
+        occupancy_spheres=(wedge_sphere,),
+        ellipsoids=(ellipsoid,),
+        bonds=(bond,),
+        cell_edges=edges,
+        axes=axes,
+        labels=(TextLabel(anchor=(0.1, 0.2, 0.3), text='Fe1'),),
+        legend=(
+            LegendEntry(symbol='Fe', colour=(255, 0, 0)),
+            LegendEntry(symbol='O', colour=(0, 255, 0)),
+        ),
+    )
+
+
+@pytest.fixture
+def patched_theme(monkeypatch):
+    """Patch the module-level ``theme_colors`` to a fixed test palette.
+
+    Isolates the renderer's own templating logic from the concrete
+    ``LIGHT_THEME``/``DARK_THEME`` values so the happy-path assertions
+    below depend only on the renderer. The un-patched integration with
+    the real ``theme_colors`` is covered by
+    :class:`TestRenderUnpatchedIntegration`.
+    """
+    monkeypatch.setattr(MUT, 'theme_colors', lambda *, dark: dict(_PATCHED_THEME))
+
+
+def test_module_import():
+    import easydiffraction.display.structure.renderers.threejs as imported
+
+    expected_module_name = 'easydiffraction.display.structure.renderers.threejs'
+    assert imported.__name__ == expected_module_name
+
+
+# ------------------------------------------------------------------
+#  Module-level constants
+# ------------------------------------------------------------------
+
+
+class TestModuleConstants:
+    def test_cdn_pins_three_version(self):
+        assert MUT._CDN == 'https://cdn.jsdelivr.net/npm/three@0.160.0'
+
+    def test_addon_specifiers(self):
+        assert MUT._ADDON_CONTROLS == 'three/addons/controls/OrbitControls.js'
+        assert MUT._ADDON_CSS2D == 'three/addons/renderers/CSS2DRenderer.js'
+
+    def test_vendor_dir_points_at_threejs_assets(self):
+        assert MUT._VENDOR.name == 'threejs'
+        assert MUT._VENDOR.parent.name == 'vendor'
+
+    def test_vendor_dir_holds_pinned_assets(self):
+        # The offline import map inlines these three vendored files.
+        names = {p.name for p in MUT._VENDOR.iterdir()}
+        assert {'three.module.js', 'OrbitControls.js', 'CSS2DRenderer.js'} <= names
+
+
+# ------------------------------------------------------------------
+#  _environment
+# ------------------------------------------------------------------
+
+
+class TestEnvironment:
+    def test_returns_jinja_environment(self):
+        from jinja2 import Environment
+
+        assert isinstance(MUT._environment(), Environment)
+
+    def test_autoescape_disabled_for_html_payload(self):
+        # The payload is pre-escaped JSON; Jinja must not re-escape it.
+        env = MUT._environment()
+        assert env.trim_blocks is True
+        assert env.lstrip_blocks is True
+
+    def test_can_load_structure_template(self):
+        env = MUT._environment()
+        template = env.get_template(ThreeJsStructureRenderer.TEMPLATE_NAME)
+        assert template is not None
+
+
+# ------------------------------------------------------------------
+#  _data_url
+# ------------------------------------------------------------------
+
+
+class TestDataUrl:
+    def test_encodes_file_as_base64_javascript_data_url(self, tmp_path):
+        import base64
+
+        source = tmp_path / 'snippet.js'
+        payload = b'console.log("hi");'
+        source.write_bytes(payload)
+
+        url = MUT._data_url(source)
+
+        prefix = 'data:text/javascript;base64,'
+        assert url.startswith(prefix)
+        decoded = base64.b64decode(url[len(prefix) :])
+        assert decoded == payload
+
+    def test_roundtrips_arbitrary_bytes(self, tmp_path):
+        import base64
+
+        source = tmp_path / 'bytes.js'
+        payload = bytes(range(256))
+        source.write_bytes(payload)
+
+        url = MUT._data_url(source)
+        decoded = base64.b64decode(url.split('base64,', 1)[1])
+        assert decoded == payload
+
+
+# ------------------------------------------------------------------
+#  _import_map
+# ------------------------------------------------------------------
+
+
+class TestImportMap:
+    def test_online_uses_cdn_urls(self):
+        mapping = MUT._import_map(offline=False)
+
+        assert mapping['three'] == f'{MUT._CDN}/build/three.module.js'
+        assert mapping[MUT._ADDON_CONTROLS].startswith(MUT._CDN)
+        assert mapping[MUT._ADDON_CSS2D].startswith(MUT._CDN)
+        assert mapping[MUT._ADDON_CONTROLS].endswith('OrbitControls.js')
+        assert mapping[MUT._ADDON_CSS2D].endswith('CSS2DRenderer.js')
+
+    def test_offline_inlines_data_urls(self):
+        mapping = MUT._import_map(offline=True)
+
+        prefix = 'data:text/javascript;base64,'
+        assert mapping['three'].startswith(prefix)
+        assert mapping[MUT._ADDON_CONTROLS].startswith(prefix)
+        assert mapping[MUT._ADDON_CSS2D].startswith(prefix)
+
+    def test_both_modes_share_the_same_keys(self):
+        online = MUT._import_map(offline=False)
+        offline = MUT._import_map(offline=True)
+
+        expected_keys = {'three', MUT._ADDON_CONTROLS, MUT._ADDON_CSS2D}
+        assert set(online) == expected_keys
+        assert set(offline) == expected_keys
+
+
+# ------------------------------------------------------------------
+#  _rgb_css
+# ------------------------------------------------------------------
+
+
+class TestRgbCss:
+    def test_formats_triple_as_css_rgb(self):
+        assert MUT._rgb_css((1, 2, 3)) == 'rgb(1, 2, 3)'
+
+    def test_handles_channel_bounds(self):
+        assert MUT._rgb_css((0, 0, 0)) == 'rgb(0, 0, 0)'
+        assert MUT._rgb_css((255, 255, 255)) == 'rgb(255, 255, 255)'
+
+
+# ------------------------------------------------------------------
+#  _scene_payload
+# ------------------------------------------------------------------
+
+
+class TestScenePayloadKeys:
+    def test_payload_exposes_documented_keys(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        expected_keys = {
+            'atoms',
+            'wedgeSpheres',
+            'ellipsoids',
+            'bonds',
+            'cellEdges',
+            'axes',
+            'labels',
+            'legend',
+            'palettes',
+        }
+        assert set(payload) == expected_keys
+
+    def test_payload_is_json_serialisable(self):
+        # The renderer embeds this dict via json.dumps; it must round-trip.
+        payload = MUT._scene_payload(_rich_scene())
+        assert json.loads(json.dumps(payload)) is not None
+
+
+class TestScenePayloadPrimitives:
+    def test_atoms_carry_geometry_colour_and_flags(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        atom = payload['atoms'][0]
+        assert atom['centre'] == (0.0, 0.0, 0.0)
+        assert atom['radius'] == 0.5
+        assert atom['colour'] == (255, 0, 0)
+        assert atom['label'] == 'Fe'
+        assert atom['asymmetric'] is True
+
+    def test_wedge_spheres_expand_fraction_colour_wedges(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        sphere = payload['wedgeSpheres'][0]
+        assert sphere['centre'] == (0.5, 0.5, 0.5)
+        assert sphere['radius'] == 0.4
+        assert sphere['label'] == 'La/Ba'
+        assert sphere['asymmetric'] is False
+        assert sphere['wedges'] == [
+            {'fraction': 0.6, 'colour': (0, 0, 255)},
+            {'fraction': 0.4, 'colour': (210, 210, 210)},
+        ]
+
+    def test_ellipsoids_use_camelcase_semi_axes_and_row_lists(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        ellipsoid = payload['ellipsoids'][0]
+        assert ellipsoid['centre'] == (0.25, 0.25, 0.25)
+        assert ellipsoid['semiAxes'] == (0.3, 0.2, 0.1)
+        # Orientation rows are converted to plain lists for JSON.
+        assert ellipsoid['orientation'] == [
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
+        ]
+        assert ellipsoid['colour'] == (0, 255, 0)
+        assert ellipsoid['label'] == 'O'
+        assert ellipsoid['asymmetric'] is True
+        assert ellipsoid['wedges'] == [{'fraction': 1.0, 'colour': (0, 255, 0)}]
+
+    def test_bonds_split_colour_and_element_at_both_ends(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        bond = payload['bonds'][0]
+        assert bond['start'] == (0.0, 0.0, 0.0)
+        assert bond['end'] == (0.5, 0.5, 0.5)
+        assert bond['startColour'] == (255, 0, 0)
+        assert bond['endColour'] == (0, 0, 255)
+        assert bond['startElement'] == 'Fe'
+        assert bond['endElement'] == 'O'
+
+    def test_cell_edges_expand_to_start_end_segments(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        assert payload['cellEdges'] == [
+            {'start': (0.0, 0.0, 0.0), 'end': (1.0, 0.0, 0.0)},
+            {'start': (0.0, 0.0, 0.0), 'end': (0.0, 1.0, 0.0)},
+        ]
+
+    def test_axes_expose_origin_and_lettered_arrows(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        axes = payload['axes']
+        assert axes['origin'] == (0.0, 0.0, 0.0)
+        letters = [arrow['letter'] for arrow in axes['arrows']]
+        assert letters == ['a', 'b', 'c']
+        assert axes['arrows'][0]['vector'] == (1.0, 0.0, 0.0)
+        assert axes['arrows'][0]['colour'] == (220, 40, 40)
+
+    def test_labels_expose_anchor_and_text(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        assert payload['labels'] == [{'anchor': (0.1, 0.2, 0.3), 'text': 'Fe1'}]
+
+    def test_legend_exposes_symbol_and_colour(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        assert payload['legend'] == [
+            {'symbol': 'Fe', 'colour': (255, 0, 0)},
+            {'symbol': 'O', 'colour': (0, 255, 0)},
+        ]
+
+
+class TestScenePayloadPalettes:
+    def test_palettes_cover_every_colour_scheme(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        expected_schemes = {scheme.value for scheme in ColorSchemeEnum}
+        assert set(payload['palettes']) == expected_schemes
+
+    def test_each_palette_maps_every_legend_symbol(self):
+        payload = MUT._scene_payload(_rich_scene())
+
+        for scheme in ColorSchemeEnum:
+            palette = payload['palettes'][scheme.value]
+            assert set(palette) == {'Fe', 'O'}
+            for rgb in palette.values():
+                assert len(rgb) == 3
+
+    def test_palette_uses_color_for_lookup(self):
+        from easydiffraction.display.structure.assets.colors import color_for
+
+        payload = MUT._scene_payload(_rich_scene())
+        for scheme in ColorSchemeEnum:
+            palette = payload['palettes'][scheme.value]
+            assert palette['Fe'] == color_for('Fe', scheme.value)
+
+
+class TestScenePayloadEmptyScene:
+    def test_empty_scene_yields_empty_collections(self):
+        payload = MUT._scene_payload(_identity_scene())
+
+        assert payload['atoms'] == []
+        assert payload['wedgeSpheres'] == []
+        assert payload['ellipsoids'] == []
+        assert payload['bonds'] == []
+        assert payload['cellEdges'] == []
+        assert payload['labels'] == []
+        assert payload['legend'] == []
+
+    def test_empty_scene_has_no_axes(self):
+        payload = MUT._scene_payload(_identity_scene())
+        assert payload['axes'] is None
+
+    def test_empty_scene_palettes_are_empty_per_scheme(self):
+        payload = MUT._scene_payload(_identity_scene())
+
+        for scheme in ColorSchemeEnum:
+            assert payload['palettes'][scheme.value] == {}
+
+
+# ------------------------------------------------------------------
+#  ThreeJsStructureRenderer — class surface
+# ------------------------------------------------------------------
+
+
+class TestRendererClass:
+    def test_is_structure_renderer_subclass(self):
+        assert issubclass(ThreeJsStructureRenderer, StructureRendererBase)
+
+    def test_instantiation(self):
+        assert ThreeJsStructureRenderer() is not None
+
+    def test_supported_features_returns_frozenset(self):
+        renderer = ThreeJsStructureRenderer()
+        features = renderer.supported_features()
+        assert isinstance(features, frozenset)
+
+    def test_supported_features_match_class_constant(self):
+        renderer = ThreeJsStructureRenderer()
+        assert renderer.supported_features() == ThreeJsStructureRenderer.SUPPORTED
+
+    def test_supported_feature_names(self):
+        expected = frozenset({'atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'})
+        assert expected == ThreeJsStructureRenderer.SUPPORTED
+
+    def test_template_name(self):
+        assert ThreeJsStructureRenderer.TEMPLATE_NAME == 'structure.html.j2'
+
+
+# ------------------------------------------------------------------
+#  ThreeJsStructureRenderer.render — happy path (theme_colors patched)
+# ------------------------------------------------------------------
+
+
+class TestRenderHtmlDocument:
+    def test_returns_complete_html_document(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _rich_scene(),
+            features=frozenset({'atoms', 'bonds'}),
+            offline=True,
+            dark=False,
+        )
+        assert isinstance(html, str)
+        assert '<' in html
+        assert '>' in html
+        assert len(html) > 0
+
+    def test_embeds_unique_container_id(self, patched_theme):
+        renderer = ThreeJsStructureRenderer()
+        scene = _rich_scene()
+        first = renderer.render(scene, features=frozenset({'atoms'}), offline=True, dark=False)
+        second = renderer.render(scene, features=frozenset({'atoms'}), offline=True, dark=False)
+
+        assert 'crysview-' in first
+        assert 'crysview-' in second
+        # Each render mints a fresh uuid4-based container id.
+        assert first != second
+
+    def test_light_theme_marks_document_light(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+        assert 'light' in html
+
+    def test_dark_theme_marks_document_dark(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=True,
+        )
+        assert 'dark' in html
+
+    def test_offline_embeds_inlined_module(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+        # Offline mode inlines the vendored module as a data URL.
+        assert 'data:text/javascript;base64,' in html
+
+    def test_online_links_cdn(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=False,
+            dark=False,
+        )
+        assert MUT._CDN in html
+
+    def test_offline_defaults_to_true(self, patched_theme):
+        # Omitting ``offline`` must inline assets, not link the CDN.
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            dark=False,
+        )
+        assert 'data:text/javascript;base64,' in html
+
+    def test_dark_none_autodetects_via_is_dark(self, patched_theme, monkeypatch):
+        calls = []
+
+        def fake_is_dark():
+            calls.append(True)
+            return True
+
+        monkeypatch.setattr(MUT, 'is_dark', fake_is_dark)
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+        )
+        assert calls == [True]
+        assert 'dark' in html
+
+    def test_features_are_embedded_sorted(self, patched_theme, monkeypatch):
+        captured = {}
+
+        real_dumps = json.dumps
+
+        def spy_dumps(obj, *args, **kwargs):
+            if isinstance(obj, list):
+                captured['features'] = obj
+            return real_dumps(obj, *args, **kwargs)
+
+        monkeypatch.setattr(MUT.json, 'dumps', spy_dumps)
+        ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset({'bonds', 'atoms', 'cell'}),
+            offline=True,
+            dark=False,
+        )
+        assert captured['features'] == ['atoms', 'bonds', 'cell']
+
+
+# ------------------------------------------------------------------
+#  ThreeJsStructureRenderer.render — invalid inputs
+# ------------------------------------------------------------------
+
+
+class TestRenderInvalidInputs:
+    def test_non_iterable_features_raises_type_error(self, patched_theme):
+        # ``render`` sorts ``features``; a non-iterable cannot be sorted.
+        with pytest.raises(TypeError):
+            ThreeJsStructureRenderer().render(
+                _identity_scene(),
+                features=None,  # type: ignore[arg-type]
+                offline=True,
+                dark=False,
+            )
+
+
+# ------------------------------------------------------------------
+#  ThreeJsStructureRenderer.render — un-patched theme_colors integration
+# ------------------------------------------------------------------
+
+
+class TestRenderUnpatchedIntegration:
+    """Exercise ``render`` against the real ``theme_colors`` collaborator.
+
+    These tests deliberately omit the ``patched_theme`` fixture so the
+    production ``theme_colors(dark=dark)`` call runs for real, proving the
+    keyword-only signature is invoked correctly and its light/dark canvas
+    colours reach the document.
+    """
+
+    def test_render_returns_html_document(self):
+        # No ``patched_theme``: the real, keyword-only ``theme_colors``
+        # must accept the call and yield a complete HTML document.
+        html = ThreeJsStructureRenderer().render(
+            _rich_scene(),
+            features=frozenset({'atoms', 'bonds'}),
+            offline=True,
+            dark=False,
+        )
+        assert isinstance(html, str)
+        assert '<' in html
+        assert '>' in html
+        assert 'crysview-' in html
+
+    def test_light_theme_embeds_real_canvas_colours(self):
+        # ``theme_colors(dark=False)`` returns LIGHT_THEME; its background
+        # and foreground must be wired into the document.
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+        assert 'rgb(255, 255, 255)' in html  # LIGHT_THEME background
+        assert 'rgb(33, 33, 33)' in html  # LIGHT_THEME foreground
+        assert 'light' in html
+
+    def test_dark_theme_embeds_real_canvas_colours(self):
+        # ``theme_colors(dark=True)`` returns DARK_THEME instead.
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=True,
+        )
+        assert 'rgb(20, 20, 24)' in html  # DARK_THEME background
+        assert 'rgb(235, 235, 235)' in html  # DARK_THEME foreground
+        assert 'dark' in html

From 2b971e60d6abf0bcc4e9cb13793f1fff052c03ad Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:36:36 +0200
Subject: [PATCH 099/160] Refactor and annotate structure display modules for
 lint

---
 .../crystallography/crystallography.py        |  34 +-
 .../display/plotters/plotly.py                |  26 +-
 .../display/structure/assets/LICENSES.md      |  34 +-
 .../display/structure/assets/colors.py        |   4 +-
 .../display/structure/assets/elements.py      |   7 +-
 .../display/structure/builder.py              | 343 +++++--
 .../display/structure/enums.py                |   5 +-
 .../display/structure/renderers/ascii.py      | 231 +++--
 .../display/structure/renderers/base.py       |  14 +-
 .../display/structure/renderers/raster.py     | 906 ++++++++++++------
 .../display/structure/renderers/threejs.py    |  26 +-
 .../display/structure/scene.py                |   2 +-
 .../display/structure/viewing.py              |   6 +-
 13 files changed, 1141 insertions(+), 497 deletions(-)

diff --git a/src/easydiffraction/crystallography/crystallography.py b/src/easydiffraction/crystallography/crystallography.py
index 7e40e593a..8359d551a 100644
--- a/src/easydiffraction/crystallography/crystallography.py
+++ b/src/easydiffraction/crystallography/crystallography.py
@@ -670,10 +670,18 @@ def orthogonalization_matrix(
 
     Parameters
     ----------
-    a, b, c : float
-        Unit-cell edge lengths (angstrom).
-    alpha, beta, gamma : float
-        Unit-cell angles (degrees).
+    a : float
+        Unit-cell edge length ``a`` (angstrom).
+    b : float
+        Unit-cell edge length ``b`` (angstrom).
+    c : float
+        Unit-cell edge length ``c`` (angstrom).
+    alpha : float
+        Unit-cell angle ``alpha`` (degrees).
+    beta : float
+        Unit-cell angle ``beta`` (degrees).
+    gamma : float
+        Unit-cell angle ``gamma`` (degrees).
 
     Returns
     -------
@@ -685,19 +693,13 @@ def orthogonalization_matrix(
     cos_al, cos_be, cos_ga = np.cos([al, be, ga])
     sin_ga = np.sin(ga)
     volume_factor = np.sqrt(
-        1.0
-        - cos_al**2
-        - cos_be**2
-        - cos_ga**2
-        + 2.0 * cos_al * cos_be * cos_ga
-    )
-    return np.array(
-        [
-            [a, b * cos_ga, c * cos_be],
-            [0.0, b * sin_ga, c * (cos_al - cos_be * cos_ga) / sin_ga],
-            [0.0, 0.0, c * volume_factor / sin_ga],
-        ]
+        1.0 - cos_al**2 - cos_be**2 - cos_ga**2 + 2.0 * cos_al * cos_be * cos_ga
     )
+    return np.array([
+        [a, b * cos_ga, c * cos_be],
+        [0.0, b * sin_ga, c * (cos_al - cos_be * cos_ga) / sin_ga],
+        [0.0, 0.0, c * volume_factor / sin_ga],
+    ])
 
 
 def fractional_to_cartesian(frac: object, matrix: np.ndarray) -> np.ndarray:
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index dabd9df55..153f3d2fd 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -55,11 +55,14 @@
 DARK_AXIS_FRAME_COLOR = 'rgba(110, 145, 190, 0.35)'
 LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
 DARK_LEGEND_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0.5)'
-# Single source for the y=x reference-line colour, shared with the report
-# axis gray (report.style.REPORT_AXIS_RGB) and imported by report.fit_plot
-# so the diagonal looks identical in the Plotly and pgfplots renderers.
+# Single source for the y=x reference-line colour, shared with the
+# report axis gray (report.style.REPORT_AXIS_RGB) and imported by
+# report.fit_plot so the diagonal looks identical in the Plotly and
+# pgfplots renderers.
 DIAGONAL_LINE_RGB = (190, 199, 208)
-DIAGONAL_LINE_COLOR = f'rgb({DIAGONAL_LINE_RGB[0]}, {DIAGONAL_LINE_RGB[1]}, {DIAGONAL_LINE_RGB[2]})'
+DIAGONAL_LINE_COLOR = (
+    f'rgb({DIAGONAL_LINE_RGB[0]}, {DIAGONAL_LINE_RGB[1]}, {DIAGONAL_LINE_RGB[2]})'
+)
 DIAGONAL_LINE_WIDTH = 0.5
 
 BRAGG_TICK_COLORS = (
@@ -71,6 +74,7 @@
 )
 
 NICE_AXIS_FRACTIONS = (1.0, 2.0, 5.0, 10.0)
+NICE_AXIS_FRACTION_THRESHOLDS = (1.5, 3.0, 7.0)
 DISPLAY_TICK_FRACTIONS = (1.0, 2.0, 2.5, 4.0, 5.0, 7.5, 10.0)
 PLOTLY_HEIGHT_PER_UNIT = 24
 BRAGG_TICK_MARKER_SIZE = 12
@@ -176,11 +180,11 @@ def single_crystal_tick_step(
     exponent = float(np.floor(np.log10(raw_step)))
     base = 10.0**exponent
     fraction = raw_step / base
-    if fraction < 1.5:
+    if fraction < NICE_AXIS_FRACTION_THRESHOLDS[0]:
         nice_fraction = 1.0
-    elif fraction < 3.0:
+    elif fraction < NICE_AXIS_FRACTION_THRESHOLDS[1]:
         nice_fraction = 2.0
-    elif fraction < 7.0:
+    elif fraction < NICE_AXIS_FRACTION_THRESHOLDS[2]:
         nice_fraction = 5.0
     else:
         nice_fraction = 10.0
@@ -661,8 +665,8 @@ def _get_single_crystal_trace(
             marker={
                 'symbol': 'circle',
                 'size': MEASURED_MARKER_SIZE,
-                # Stroke colour matches the fill (like the pgfplots PDF) so
-                # there is no contrasting ring around the markers.
+                # Stroke colour matches the fill (like the pgfplots
+                # PDF) so there is no contrasting ring around markers.
                 'line': {
                     'width': SINGLE_CRYSTAL_MARKER_LINE_WIDTH,
                     'color': DEFAULT_COLORS['meas'],
@@ -1224,8 +1228,8 @@ def _get_layout(
                 axis['range'] = list(axis_range)
         if axis_dtick is not None:
             for axis in (xaxis, yaxis):
-                # Anchor ticks at 0 so they read as round numbers (0, 500,
-                # 1000, ...) instead of starting at the padded minimum.
+                # Anchor ticks at 0 so they read as round numbers
+                # (0, 500, 1000, ...) instead of at the padded minimum.
                 axis['tick0'] = 0
                 axis['dtick'] = axis_dtick
         return go.Layout(
diff --git a/src/easydiffraction/display/structure/assets/LICENSES.md b/src/easydiffraction/display/structure/assets/LICENSES.md
index b63af1830..b901be175 100644
--- a/src/easydiffraction/display/structure/assets/LICENSES.md
+++ b/src/easydiffraction/display/structure/assets/LICENSES.md
@@ -5,20 +5,20 @@ permissive licences; the underlying values are scientific data.
 
 ## Sources
 
-| Data | Source | Licence |
-| --- | --- | --- |
+| Data                                                  | Source                                                                                                                 | Licence      |
+| ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------ |
 | Jmol/CPK colours, covalent radii, van der Waals radii | EasyDiffractionBeta `easyDiffractionApp/Logic/Tables.py` `PERIODIC_TABLE` (github.com/easyscience/EasyDiffractionBeta) | BSD-3-Clause |
-| Ionic (Shannon) radii | pymatgen `dev_scripts/periodic_table_resources/Shannon_Radii.csv` | MIT |
-| Atomic radii | pymatgen `dev_scripts/periodic_table_resources/radii.csv` (`Atomic radius`) | MIT |
-| VESTA colours | pymatgen `src/pymatgen/vis/ElementColorSchemes.yaml` (`VESTA`) | MIT |
-| Oxidation states (for Shannon selection) | pymatgen `dev_scripts/periodic_table_resources/oxidation_states.yaml` | MIT |
+| Ionic (Shannon) radii                                 | pymatgen `dev_scripts/periodic_table_resources/Shannon_Radii.csv`                                                      | MIT          |
+| Atomic radii                                          | pymatgen `dev_scripts/periodic_table_resources/radii.csv` (`Atomic radius`)                                            | MIT          |
+| VESTA colours                                         | pymatgen `src/pymatgen/vis/ElementColorSchemes.yaml` (`VESTA`)                                                         | MIT          |
+| Oxidation states (for Shannon selection)              | pymatgen `dev_scripts/periodic_table_resources/oxidation_states.yaml`                                                  | MIT          |
 
 Primary scientific references:
 
-- R. D. Shannon, *Revised effective ionic radii and systematic studies of
-  interatomic distances in halides and chalcogenides*, Acta Cryst. (1976)
-  **A32**, 751.
-- K. Momma and F. Izumi, *VESTA 3*, J. Appl. Cryst. (2011) **44**, 1272
+- R. D. Shannon, _Revised effective ionic radii and systematic studies
+  of interatomic distances in halides and chalcogenides_, Acta Cryst.
+  (1976) **A32**, 751.
+- K. Momma and F. Izumi, _VESTA 3_, J. Appl. Cryst. (2011) **44**, 1272
   (element colour palette).
 
 pymatgen raw files were fetched from
@@ -26,19 +26,21 @@ pymatgen raw files were fetched from
 
 ## Shannon representative-radius selection
 
-The atom-site model carries only an element symbol, so one representative
-Shannon row is chosen per element by a fixed, reproducible rule:
+The atom-site model carries only an element symbol, so one
+representative Shannon row is chosen per element by a fixed,
+reproducible rule:
 
-1. consider the element's oxidation states from `oxidation_states.yaml`, in
-   listed order, keeping those that have a Shannon entry; then any
+1. consider the element's oxidation states from `oxidation_states.yaml`,
+   in listed order, keeping those that have a Shannon entry; then any
    remaining Shannon charges, lowest `|charge|` first;
 2. for the first such charge, prefer coordination `VI`, else the lowest
    coordination present; prefer high-spin where a spin state is listed;
 3. take the `Ionic Radius` column; skip non-physical entries (e.g. the
    negative H+ value) and fall back to the covalent radius.
 
-Elements with no usable Shannon entry (noble gases and a few others) carry
-`ionic = None` and fall back to the covalent radius at lookup time.
+Elements with no usable Shannon entry (noble gases and a few others)
+carry `ionic = None` and fall back to the covalent radius at lookup
+time.
 
 ## Chosen (charge / coordination) per element
 
diff --git a/src/easydiffraction/display/structure/assets/colors.py b/src/easydiffraction/display/structure/assets/colors.py
index b945342c6..8d15ced82 100644
--- a/src/easydiffraction/display/structure/assets/colors.py
+++ b/src/easydiffraction/display/structure/assets/colors.py
@@ -16,7 +16,7 @@
 # Crystallographic axis colours (a=red, b=green, c=blue), as in VESTA.
 AXIS_COLORS: dict[str, Rgb] = {'a': (220, 40, 40), 'b': (40, 180, 40), 'c': (40, 80, 220)}
 
-# Neutral wedge colour for the vacant fraction of a mixed-occupancy site.
+# Neutral wedge colour for the vacant fraction of a mixed site.
 VACANCY_COLOR: Rgb = (210, 210, 210)
 
 # Canvas + annotation colours selected by the detected light/dark theme.
@@ -52,7 +52,7 @@ def color_for(element: str, scheme: str) -> Rgb:
     return entry.get('jmol') or DEFAULT_COLOR
 
 
-def theme_colors(dark: bool) -> dict[str, Rgb]:
+def theme_colors(*, dark: bool) -> dict[str, Rgb]:
     """
     Return canvas/annotation colours for the detected theme.
 
diff --git a/src/easydiffraction/display/structure/assets/elements.py b/src/easydiffraction/display/structure/assets/elements.py
index c614a3c9f..4b7ef2772 100644
--- a/src/easydiffraction/display/structure/assets/elements.py
+++ b/src/easydiffraction/display/structure/assets/elements.py
@@ -1,8 +1,9 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
 """
-Bundled per-element radii and colour palettes (generated; see
-LICENSES.md).
+Bundled per-element radii and colour palettes.
+
+Generated data module; see LICENSES.md for provenance.
 """
 
 from __future__ import annotations
@@ -129,7 +130,7 @@
     'Og': {'vdw': 2, 'covalent': 1.6, 'ionic': None, 'atomic': None},
 }
 
-# RGB 0-255; vesta is None where VESTA lacks an entry (falls back to jmol).
+# RGB 0-255; vesta is None where VESTA has no entry (uses jmol).
 ELEMENT_COLORS: dict[str, dict[str, tuple[int, int, int] | None]] = {
     'H': {'jmol': (255, 255, 255), 'vesta': (255, 204, 204)},
     'He': {'jmol': (217, 255, 255), 'vesta': (252, 232, 206)},
diff --git a/src/easydiffraction/display/structure/builder.py b/src/easydiffraction/display/structure/builder.py
index bfa2a96bf..4f77ae7aa 100644
--- a/src/easydiffraction/display/structure/builder.py
+++ b/src/easydiffraction/display/structure/builder.py
@@ -15,6 +15,9 @@
 import re
 from dataclasses import dataclass
 from itertools import product
+from itertools import starmap
+from operator import itemgetter
+from typing import TYPE_CHECKING
 
 import numpy as np
 from scipy.stats import chi
@@ -38,17 +41,35 @@
 from easydiffraction.display.structure.scene import StructureScene
 from easydiffraction.display.structure.scene import TextLabel
 
-# Tolerance (fractional units) for scene-atom identity and occupancy grouping.
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+# Tolerance (fractional units) for scene-atom identity and
+# occupancy grouping.
 IDENTITY_TOL = 1e-4
 EIGHT_PI_SQ = 8.0 * np.pi**2
 DEFAULT_BOND_INCR = 0.25
-# Prune bonds to the first coordination shell: keep a contact only if it is
-# within this multiple of the nearer atom's nearest-neighbour distance. Stops
-# large ionic-cation covalent radii (e.g. La/Ba) from bonding to every anion
-# (see open issue #108 for the full near-neighbour approach).
+# Prune bonds to the first coordination shell: keep a contact only
+# if it is within this multiple of the nearer atom's nearest-neighbour
+# distance. Stops large ionic-cation covalent radii (e.g. La/Ba) from
+# bonding to every anion (see open issue #108 for the full
+# near-neighbour approach).
 COORDINATION_SHELL_FACTOR = 1.3
+# Smallest atom count that can form a bond.
+MIN_BONDABLE_ATOMS = 2
 ALL_FEATURES = ('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels')
 
+# Per-axis ``((min, max), (min, max), (min, max))`` fractional range.
+ViewRange = tuple[tuple[float, float], tuple[float, float], tuple[float, float]]
+# One expanded copy: ``(row_index, position, rotation, is_au)``.
+GeneratedCopy = tuple[int, np.ndarray, np.ndarray, bool]
+# Atom-shape descriptor: ``('sphere', radius)`` or
+# ``('ellipsoid', semi_axes, orientation)``.
+AtomShape = tuple[object, ...]
+# One shared-site row:
+# ``(atom, occupancy, element, colour, radius, rotation)``.
+WedgeRow = tuple[object, float, str, tuple[int, int, int], float, np.ndarray]
+
 
 @dataclass(frozen=True)
 class FeatureAvailability:
@@ -60,6 +81,22 @@ class FeatureAvailability:
     radius_substitutions: tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class _RenderContext:
+    """
+    Scene-wide inputs shared by every atom in one ``build_scene`` call.
+
+    Bundles the values that do not vary per atom or per symmetry copy so
+    the atom-building helpers thread a single context instead of four
+    parallel arguments.
+    """
+
+    style: object
+    matrix: np.ndarray
+    cell: object
+    aniso_collection: object
+
+
 @dataclass(frozen=True)
 class _SceneAtom:
     """
@@ -79,18 +116,24 @@ def _element_symbol(type_symbol: str) -> str:
     return match.group() if match else type_symbol.strip()
 
 
-def _vec3(values) -> tuple[float, float, float]:
+def _vec3(values: np.ndarray | tuple[float, ...]) -> tuple[float, float, float]:
     return (float(values[0]), float(values[1]), float(values[2]))
 
 
-def _cell_lengths_angles(cell) -> tuple[float, float, float, float, float, float]:
+def _cell_lengths_angles(
+    cell: object,
+) -> tuple[float, float, float, float, float, float]:
     return (
-        cell.length_a.value, cell.length_b.value, cell.length_c.value,
-        cell.angle_alpha.value, cell.angle_beta.value, cell.angle_gamma.value,
+        cell.length_a.value,
+        cell.length_b.value,
+        cell.length_c.value,
+        cell.angle_alpha.value,
+        cell.angle_beta.value,
+        cell.angle_gamma.value,
     )
 
 
-def _reciprocal_lengths(cell) -> np.ndarray:
+def _reciprocal_lengths(cell: object) -> np.ndarray:
     a, b, c, alpha, beta, gamma = _cell_lengths_angles(cell)
     al, be, ga = np.radians([alpha, beta, gamma])
     ca, cb, cg = np.cos([al, be, ga])
@@ -98,7 +141,10 @@ def _reciprocal_lengths(cell) -> np.ndarray:
     return np.array([np.sin(al) / (a * omega), np.sin(be) / (b * omega), np.sin(ga) / (c * omega)])
 
 
-def _lattice_shifts(pos: np.ndarray, view_range):
+def _lattice_shifts(
+    pos: np.ndarray,
+    view_range: ViewRange,
+) -> Iterator[np.ndarray]:
     axis_ranges = []
     for i in range(3):
         lo, hi = view_range[i]
@@ -110,13 +156,19 @@ def _lattice_shifts(pos: np.ndarray, view_range):
 
 
 def _pos_key(pos: np.ndarray) -> tuple[int, int, int]:
-    return tuple(int(round(v / IDENTITY_TOL)) for v in pos)
+    return tuple(round(v / IDENTITY_TOL) for v in pos)
 
 
-def _expand_positions(sites, ops, view_range):
+def _expand_positions(
+    sites: list[object],
+    ops: list[tuple[np.ndarray, np.ndarray]],
+    view_range: ViewRange,
+) -> list[GeneratedCopy]:
     """
-    Generate (row_index, fractional position, rotation) for each
-    in-range copy.
+    Generate per-copy placement data for each in-range image.
+
+    Yields ``(row_index, fractional position, rotation,
+    is_asymmetric_unit)`` for each in-range copy.
 
     The symmetry rotation is kept so an anisotropic ADP tensor can be
     rotated onto each equivalent site (otherwise every copy reuses one
@@ -135,20 +187,31 @@ def _expand_positions(sites, ops, view_range):
     return generated
 
 
-def _group_by_position(generated):
+def _group_by_position(
+    generated: list[GeneratedCopy],
+) -> dict[tuple[int, int, int], list[GeneratedCopy]]:
     """
-    Dedup scene atoms (row + position) and cluster coincident positions.
+    Dedup scene atoms and cluster coincident positions.
+
+    Deduplicates by ``(row, position)`` and groups copies that share a
+    position.
     """
-    seen: dict = {}
+    seen: dict[tuple[int, tuple[int, int, int]], GeneratedCopy] = {}
     for idx, pos, rot, is_au in generated:
         seen.setdefault((idx, _pos_key(pos)), (idx, pos, rot, is_au))
-    clusters: dict = {}
+    clusters: dict[tuple[int, int, int], list[GeneratedCopy]] = {}
     for idx, pos, rot, is_au in seen.values():
         clusters.setdefault(_pos_key(pos), []).append((idx, pos, rot, is_au))
     return clusters
 
 
-def _cartesian_u(atom, aniso, matrix: np.ndarray, cell, rot: np.ndarray) -> np.ndarray:
+def _cartesian_u(
+    atom: object,
+    aniso: object,
+    matrix: np.ndarray,
+    cell: object,
+    rot: np.ndarray,
+) -> np.ndarray:
     """
     Cartesian U tensor for an anisotropic atom (CIF U^ij convention).
 
@@ -156,35 +219,43 @@ def _cartesian_u(atom, aniso, matrix: np.ndarray, cell, rot: np.ndarray) -> np.n
     the tensor is rotated onto the copy in Cartesian space so each
     equivalent site shows the correctly oriented ellipsoid.
     """
-    comps = np.array([
-        [aniso.adp_11.value, aniso.adp_12.value, aniso.adp_13.value],
-        [aniso.adp_12.value, aniso.adp_22.value, aniso.adp_23.value],
-        [aniso.adp_13.value, aniso.adp_23.value, aniso.adp_33.value],
-    ], dtype=float)
+    comps = np.array(
+        [
+            [aniso.adp_11.value, aniso.adp_12.value, aniso.adp_13.value],
+            [aniso.adp_12.value, aniso.adp_22.value, aniso.adp_23.value],
+            [aniso.adp_13.value, aniso.adp_23.value, aniso.adp_33.value],
+        ],
+        dtype=float,
+    )
     if AdpTypeEnum(atom.adp_type.value) is AdpTypeEnum.BANI:
-        comps = comps / EIGHT_PI_SQ
+        comps /= EIGHT_PI_SQ
     mn = matrix @ np.diag(_reciprocal_lengths(cell))
     u_cart = mn @ comps @ mn.T
     r_cart = matrix @ rot @ np.linalg.inv(matrix)
     return r_cart @ u_cart @ r_cart.T
 
 
-def _display_radius(model_radius: float, style) -> float:
+def _display_radius(model_radius: float, style: object) -> float:
     """
-    Square-root-compressed ball radius (narrows the heavy/light spread).
+    Square-root-compressed ball radius (narrows heavy/light spread).
     """
     return style.atom_scale.value * float(np.sqrt(model_radius))
 
 
-def _atom_shape(atom, *, style, matrix, cell, aniso_collection, rot):
+def _atom_shape(
+    atom: object,
+    ctx: _RenderContext,
+    rot: np.ndarray,
+) -> tuple[AtomShape, bool]:
     """
-    Return an atom's ADP-driven shape and the radius-substitution flag.
+    Return an atom's ADP-driven shape and the substitution flag.
 
     The shape is ``('ellipsoid', semi_axes, orientation)`` for an
     anisotropic atom in the ADP view, otherwise ``('sphere', radius)``.
     ``rot`` is the symmetry rotation placing this copy (identity for the
     reference atom).
     """
+    style = ctx.style
     element = _element_symbol(atom.type_symbol.value)
     view = AtomViewEnum(style.atom_view.value)
     radius, substituted = radius_for(element, view.radius_model())
@@ -192,16 +263,22 @@ def _atom_shape(atom, *, style, matrix, cell, aniso_collection, rot):
     label = atom.label.value
     adp_type = AdpTypeEnum(atom.adp_type.value)
     scale = float(chi.ppf(style.adp_probability.value, 3))
-    if view.is_adp and adp_type in {AdpTypeEnum.UANI, AdpTypeEnum.BANI} \
-            and label in aniso_collection:
-        u_cart = _cartesian_u(atom, aniso_collection[label], matrix, cell, rot)
+    if (
+        view.is_adp
+        and adp_type in {AdpTypeEnum.UANI, AdpTypeEnum.BANI}
+        and label in ctx.aniso_collection
+    ):
+        u_cart = _cartesian_u(atom, ctx.aniso_collection[label], ctx.matrix, ctx.cell, rot)
         semi, orient = ecr.adp_principal_axes(u_cart)
-        shape = ('ellipsoid', _vec3(semi * scale),
-                 tuple(_vec3(orient[:, i]) for i in range(3)))
+        shape = (
+            'ellipsoid',
+            _vec3(semi * scale),
+            tuple(_vec3(orient[:, i]) for i in range(3)),
+        )
     elif view.is_adp and adp_type in {AdpTypeEnum.UISO, AdpTypeEnum.BISO}:
         u_iso = atom.adp_iso.value
         if adp_type is AdpTypeEnum.BISO:
-            u_iso = u_iso / EIGHT_PI_SQ
+            u_iso /= EIGHT_PI_SQ
         iso_radius = float(np.sqrt(max(u_iso, 0.0))) * scale
         shape = ('sphere', iso_radius or ball_radius)
     else:
@@ -209,87 +286,118 @@ def _atom_shape(atom, *, style, matrix, cell, aniso_collection, rot):
     return shape, substituted
 
 
-def _atom_primitive(atom, centre, *, style, matrix, cell, aniso_collection, rot, asymmetric):
+def _atom_primitive(
+    atom: object,
+    centre: np.ndarray,
+    ctx: _RenderContext,
+    rot: np.ndarray,
+    *,
+    asymmetric: bool,
+) -> tuple[_SceneAtom, bool]:
     """Build a solid sphere/ellipsoid primitive for a single atom."""
     element = _element_symbol(atom.type_symbol.value)
-    colour = color_for(element, style.color_scheme.value)
-    shape, substituted = _atom_shape(
-        atom, style=style, matrix=matrix, cell=cell, aniso_collection=aniso_collection, rot=rot,
-    )
+    colour = color_for(element, ctx.style.color_scheme.value)
+    shape, substituted = _atom_shape(atom, ctx, rot)
     if shape[0] == 'ellipsoid':
-        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], colour,
-                                 atom.label.value, asymmetric=asymmetric)
+        primitive = AdpEllipsoid(
+            _vec3(centre),
+            shape[1],
+            shape[2],
+            colour,
+            atom.label.value,
+            asymmetric=asymmetric,
+        )
     else:
-        primitive = AtomSphere(_vec3(centre), shape[1], colour, atom.label.value,
-                               asymmetric=asymmetric)
-    return _SceneAtom(primitive, centre, element, colour, atom.label.value), substituted
+        primitive = AtomSphere(
+            _vec3(centre),
+            shape[1],
+            colour,
+            atom.label.value,
+            asymmetric=asymmetric,
+        )
+    return (
+        _SceneAtom(primitive, centre, element, colour, atom.label.value),
+        substituted,
+    )
 
 
-def _wedge_atom(rows, centre, *, style, matrix, cell, aniso_collection, asymmetric):
+def _wedge_atom(
+    rows: list[WedgeRow],
+    centre: np.ndarray,
+    ctx: _RenderContext,
+    *,
+    asymmetric: bool,
+) -> _SceneAtom:
     """
-    Build a shared-site primitive: the major atom's ADP shape split into
-    relative-proportion colour wedges (absolute occupancy ignored).
+    Build a shared-site primitive split into colour wedges.
+
+    The major atom's ADP shape is split into relative-proportion colour
+    wedges (absolute occupancy is ignored).
     """
     total = sum(occ for _, occ, _, _, _, _ in rows) or 1.0
     wedges = tuple(OccupancyWedge(occ / total, colour) for _, occ, _, colour, _, _ in rows)
-    major_atom, _occ, major_element, major_colour, _radius, major_rot = max(rows, key=lambda r: r[1])
-    label = '/'.join(r[0].label.value for r in rows)
-    shape, _ = _atom_shape(
-        major_atom, style=style, matrix=matrix, cell=cell,
-        aniso_collection=aniso_collection, rot=major_rot,
+    major_atom, _occ, major_element, major_colour, _radius, major_rot = max(
+        rows, key=itemgetter(1)
     )
+    label = '/'.join(r[0].label.value for r in rows)
+    shape, _ = _atom_shape(major_atom, ctx, major_rot)
     if shape[0] == 'ellipsoid':
-        primitive = AdpEllipsoid(_vec3(centre), shape[1], shape[2], major_colour,
-                                 label, wedges, asymmetric)
+        primitive = AdpEllipsoid(
+            _vec3(centre), shape[1], shape[2], major_colour, label, wedges, asymmetric
+        )
     else:
         primitive = OccupancyWedgeSphere(_vec3(centre), shape[1], wedges, label, asymmetric)
     return _SceneAtom(primitive, centre, major_element, major_colour, label)
 
 
-def _build_atoms(sites, clusters, *, style, matrix, cell, aniso_collection):
+def _build_atoms(
+    sites: list[object],
+    clusters: dict[tuple[int, int, int], list[GeneratedCopy]],
+    ctx: _RenderContext,
+) -> tuple[list[_SceneAtom], set[str]]:
     """
-    Return the scene atoms (one per position cluster) and substitutions.
+    Return the scene atoms (one per cluster) and substitutions.
     """
-    scene_atoms = []
-    substitutions: set = set()
-    radius_model = AtomViewEnum(style.atom_view.value).radius_model()
+    scene_atoms: list[_SceneAtom] = []
+    substitutions: set[str] = set()
+    radius_model = AtomViewEnum(ctx.style.atom_view.value).radius_model()
     for members in clusters.values():
-        centre = ecr.fractional_to_cartesian(members[0][1], matrix)
+        centre = ecr.fractional_to_cartesian(members[0][1], ctx.matrix)
         cluster_au = any(member[3] for member in members)
         if len(members) == 1:
             idx, _pos, rot, _au = members[0]
             atom = sites[idx]
             scene_atom, substituted = _atom_primitive(
-                atom, centre, style=style, matrix=matrix, cell=cell,
-                aniso_collection=aniso_collection, rot=rot, asymmetric=cluster_au,
+                atom, centre, ctx, rot, asymmetric=cluster_au
             )
             scene_atoms.append(scene_atom)
             if substituted:
                 substitutions.add(_element_symbol(atom.type_symbol.value))
             continue
-        rows = []
+        rows: list[WedgeRow] = []
         for idx, _pos, rot, _au in members:
             atom = sites[idx]
             element = _element_symbol(atom.type_symbol.value)
-            colour = color_for(element, style.color_scheme.value)
+            colour = color_for(element, ctx.style.color_scheme.value)
             radius, substituted = radius_for(element, radius_model)
             rows.append((atom, atom.occupancy.value, element, colour, radius, rot))
             if substituted:
                 substitutions.add(element)
-        scene_atoms.append(_wedge_atom(
-            rows, centre, style=style, matrix=matrix, cell=cell,
-            aniso_collection=aniso_collection, asymmetric=cluster_au,
-        ))
+        scene_atoms.append(_wedge_atom(rows, centre, ctx, asymmetric=cluster_au))
     return scene_atoms, substitutions
 
 
-def _build_bonds(scene_atoms, geom_min: float, geom_incr: float):
+def _build_bonds(
+    scene_atoms: list[_SceneAtom],
+    geom_min: float,
+    geom_incr: float,
+) -> list[Bond]:
     """
-    Detect bonds via the cif_core _geom rule, pruned to the first shell.
+    Detect bonds via the cif_core _geom rule, pruned to first shell.
     """
-    bonds = []
+    bonds: list[Bond] = []
     count = len(scene_atoms)
-    if count < 2:
+    if count < MIN_BONDABLE_ATOMS:
         return bonds
     radii = [radius_for(a.element, 'covalent')[0] for a in scene_atoms]
     centres = np.array([a.centre for a in scene_atoms], dtype=float)
@@ -303,21 +411,29 @@ def _build_bonds(scene_atoms, geom_min: float, geom_incr: float):
             shell = min(nearest[i], nearest[j]) * COORDINATION_SHELL_FACTOR
             covalent_cutoff = radii[i] + radii[j] + geom_incr
             if geom_min <= distance <= min(covalent_cutoff, shell):
-                bonds.append(Bond(_vec3(atom_i.centre), _vec3(atom_j.centre),
-                                  atom_i.colour, atom_j.colour,
-                                  atom_i.element, atom_j.element))
+                bonds.append(
+                    Bond(
+                        _vec3(atom_i.centre),
+                        _vec3(atom_j.centre),
+                        atom_i.colour,
+                        atom_j.colour,
+                        atom_i.element,
+                        atom_j.element,
+                    )
+                )
     return bonds
 
 
 def _cell_edges(matrix: np.ndarray) -> CellEdges:
-    corners = {tuple(c): _vec3(matrix @ np.array(c, dtype=float))
-               for c in product((0, 1), repeat=3)}
+    corners = {
+        tuple(c): _vec3(matrix @ np.array(c, dtype=float)) for c in product((0, 1), repeat=3)
+    }
     edges = []
-    for c in corners:
+    for c, corner in corners.items():
         for axis in range(3):
             if c[axis] == 0:
                 neighbour = tuple(1 if k == axis else c[k] for k in range(3))
-                edges.append(CellEdge(corners[c], corners[neighbour]))
+                edges.append(CellEdge(corner, corners[neighbour]))
     return CellEdges(tuple(edges))
 
 
@@ -333,21 +449,29 @@ def _axis_triad(matrix: np.ndarray) -> AxisTriad:
     return AxisTriad((0.0, 0.0, 0.0), (arrows[0], arrows[1], arrows[2]))
 
 
-def _legend(sites, style) -> tuple[LegendEntry, ...]:
+def _legend(sites: list[object], style: object) -> tuple[LegendEntry, ...]:
     """
-    Return one colour swatch per distinct element, in first-seen order.
+    Return one colour swatch per element, in first-seen order.
     """
     entries: dict[str, tuple[int, int, int]] = {}
     for atom in sites:
         element = _element_symbol(atom.type_symbol.value)
         if element not in entries:
             entries[element] = color_for(element, style.color_scheme.value)
-    return tuple(LegendEntry(symbol, colour) for symbol, colour in entries.items())
+    return tuple(starmap(LegendEntry, entries.items()))
 
 
-def build_scene(structure, *, style, view_range, features) -> StructureScene:
+def build_scene(
+    structure: object,
+    *,
+    style: object,
+    view_range: ViewRange,
+    features: frozenset[str],
+) -> StructureScene:
     """
-    Build a renderer-neutral scene from a structure and resolved
+    Build a renderer-neutral scene from a structure.
+
+    Builds the scene from the structure and the already-resolved
     features.
 
     Parameters
@@ -358,7 +482,7 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
     style : object
         The ``project.structure_style`` category (atom view, colour
         scheme, ADP probability, atom scale).
-    view_range : tuple
+    view_range : ViewRange
         Per-axis ``((min, max), (min, max), (min, max))`` fractional
         range.
     features : frozenset[str]
@@ -377,13 +501,16 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
     ops = ecr.symmetry_operators(sg.name_h_m.value, sg.it_coordinate_system_code.value)
     sites = list(structure.atom_sites)
 
-    clusters = _group_by_position(_expand_positions(sites, ops, view_range))
-    scene_atoms, _ = _build_atoms(
-        sites, clusters, style=style, matrix=matrix, cell=cell,
+    ctx = _RenderContext(
+        style=style,
+        matrix=matrix,
+        cell=cell,
         aniso_collection=structure.atom_site_aniso,
     )
+    clusters = _group_by_position(_expand_positions(sites, ops, view_range))
+    scene_atoms, _ = _build_atoms(sites, clusters, ctx)
 
-    bonds: tuple = ()
+    bonds: tuple[Bond, ...] = ()
     if 'bonds' in features:
         geom = getattr(structure, 'geom', None)
         geom_min = geom.min_bond_distance_cutoff.value if geom is not None else 0.0
@@ -393,28 +520,40 @@ def build_scene(structure, *, style, view_range, features) -> StructureScene:
     show_atoms = 'atoms' in features
     return StructureScene(
         cell_basis=tuple(_vec3(matrix[:, i]) for i in range(3)),
-        atoms=tuple(a.primitive for a in scene_atoms
-                    if show_atoms and isinstance(a.primitive, AtomSphere)),
-        occupancy_spheres=tuple(a.primitive for a in scene_atoms
-                                if show_atoms and isinstance(a.primitive, OccupancyWedgeSphere)),
-        ellipsoids=tuple(a.primitive for a in scene_atoms
-                         if show_atoms and isinstance(a.primitive, AdpEllipsoid)),
+        atoms=tuple(
+            a.primitive for a in scene_atoms if show_atoms and isinstance(a.primitive, AtomSphere)
+        ),
+        occupancy_spheres=tuple(
+            a.primitive
+            for a in scene_atoms
+            if show_atoms and isinstance(a.primitive, OccupancyWedgeSphere)
+        ),
+        ellipsoids=tuple(
+            a.primitive
+            for a in scene_atoms
+            if show_atoms and isinstance(a.primitive, AdpEllipsoid)
+        ),
         bonds=bonds,
         moments=(),
         cell_edges=_cell_edges(matrix) if 'cell' in features else None,
         axes=_axis_triad(matrix) if 'axes' in features else None,
         labels=tuple(TextLabel(_vec3(a.centre), a.label) for a in scene_atoms)
-        if 'labels' in features else (),
+        if 'labels' in features
+        else (),
         legend=_legend(sites, style) if 'atoms' in features else (),
     )
 
 
-def structure_feature_availability(structure, *, style) -> FeatureAvailability:
+def structure_feature_availability(
+    structure: object,
+    *,
+    style: object,
+) -> FeatureAvailability:
     """
-    Report which features a structure supports, without building a
-    scene.
+    Report which features a structure supports.
 
-    Used by the display facade for ``include='auto'`` resolution and by
+    Computes availability without building a scene. Used by the display
+    facade for ``include='auto'`` resolution and by
     ``show_structure_options()``; the builder is the only reader of the
     structure, so availability is computed once here.
 
diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
index a5b037963..2ea0480bb 100644
--- a/src/easydiffraction/display/structure/enums.py
+++ b/src/easydiffraction/display/structure/enums.py
@@ -51,10 +51,7 @@ def default(cls) -> AtomViewEnum:
 
     @property
     def is_adp(self) -> bool:
-        """
-        Return whether atoms are drawn as displacement surfaces, not
-        balls.
-        """
+        """Return whether atoms are drawn as displacement surfaces."""
         return self is AtomViewEnum.ADP
 
     def radius_model(self) -> str:
diff --git a/src/easydiffraction/display/structure/renderers/ascii.py b/src/easydiffraction/display/structure/renderers/ascii.py
index cc34279d1..ad51cd18a 100644
--- a/src/easydiffraction/display/structure/renderers/ascii.py
+++ b/src/easydiffraction/display/structure/renderers/ascii.py
@@ -4,16 +4,40 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from easydiffraction.display.structure.renderers.base import StructureRendererBase
-from easydiffraction.display.structure.scene import StructureScene
 
 Rgb = tuple[int, int, int]
-
-# Single-width glyphs only: '⬤' (U+2B24) is absent from common monospace fonts
-# and falls back to a proportional glyph, which renders wider than one cell and
-# pushes the cell's right border out of alignment.
+# Grid cell coordinate (row, column) from a placement closure.
+Cell = tuple[int, int]
+# A projected 2D point (horizontal, vertical) in cell space.
+Point2D = tuple[float, float]
+# Maps cell coordinates to (glyph, colour); plus a '_size' entry.
+Grid = dict
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Sequence
+
+    from easydiffraction.display.structure.scene import StructureScene
+    from easydiffraction.display.structure.scene import Vec3
+
+    # Coordinates fed to the projection/placement closures.
+    Coords = Sequence[float] | np.ndarray
+    # A flattened drawable atom: (centre, radius, colour, label).
+    Atom = tuple[Vec3, float, Rgb, str]
+    # A placement closure mapping coordinates to a grid cell.
+    Place = Callable[[Coords], Cell]
+    # A 2D projection closure mapping coordinates to a point.
+    Project = Callable[[Coords], Point2D]
+
+# Single-width glyphs only: '⬤' (U+2B24) is absent from common
+# monospace fonts and falls back to a proportional glyph, which renders
+# wider than one cell and pushes the right border out of alignment.
 GLYPH_RAMP = ('·', '•', '●')
 GRID_WIDTH = 56
 PAD = 2
@@ -22,24 +46,36 @@
 
 def _ansi256(rgb: Rgb) -> int:
     """Map an RGB triple to the nearest xterm-256 cube colour."""
-    return 16 + 36 * round(rgb[0] / 255 * 5) + 6 * round(rgb[1] / 255 * 5) + round(rgb[2] / 255 * 5)
+    return (
+        16 + 36 * round(rgb[0] / 255 * 5) + 6 * round(rgb[1] / 255 * 5) + round(rgb[2] / 255 * 5)
+    )
 
 
 def _tint(rgb: Rgb, text: str) -> str:
     return f'\x1b[38;5;{_ansi256(rgb)}m{text}\x1b[0m'
 
 
-def _collect_atoms(scene: StructureScene):
-    """
-    Flatten every drawable atom to (centre, radius, colour, label).
-    """
+def _collect_atoms(scene: StructureScene) -> list[Atom]:
+    """Flatten each drawable atom to (centre, radius, colour, label)."""
     atoms = [(a.centre, a.radius, a.colour, a.label) for a in scene.atoms]
     atoms += [(s.centre, s.radius, s.wedges[0].colour, s.label) for s in scene.occupancy_spheres]
-    atoms += [(e.centre, float(np.mean(e.semi_axes)) or 0.4, e.colour, e.label)
-              for e in scene.ellipsoids]
+    atoms += [
+        (e.centre, float(np.mean(e.semi_axes)) or 0.4, e.colour, e.label) for e in scene.ellipsoids
+    ]
     return atoms
 
 
+@dataclass(frozen=True, slots=True)
+class _Orientation:
+    """The 2D projection setup for the schematic single-cell view."""
+
+    project: Project
+    h_vec: np.ndarray
+    v_vec: np.ndarray
+    v_idx: int
+    h_idx: int
+
+
 class AsciiStructureRenderer(StructureRendererBase):
     """Reduced-fidelity terminal renderer (one schematic cell)."""
 
@@ -49,15 +85,26 @@ def supported_features(self) -> frozenset[str]:
         """Return the features the ASCII engine can draw."""
         return self.SUPPORTED
 
-    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+    @staticmethod
+    def _orient(basis: np.ndarray) -> _Orientation:
         """
-        Render a schematic ASCII view and announce 3D-only features.
+        Build the projection closure and the in-plane cell axes.
+
+        Match the 3D default orientation by axis length: longest axis
+        horizontal, second-longest vertical, shortest the dropped depth
+        axis, so the ASCII and 3D engines share the up axis and the
+        width-to-height ratio.
+
+        Parameters
+        ----------
+        basis : np.ndarray
+            The 3x3 Cartesian cell basis, one row per cell vector.
+
+        Returns
+        -------
+        _Orientation
+            The projection closure and the in-plane cell axes.
         """
-        atoms = _collect_atoms(scene)
-        basis = np.array(scene.cell_basis, dtype=float)
-        # Match the 3D default orientation (by axis length): longest axis
-        # horizontal, 2nd-longest vertical, shortest the dropped depth axis — so
-        # the ASCII and 3D engines share the up axis and width:height ratio.
         lengths = [float(np.linalg.norm(v)) for v in basis]
         order = sorted(range(3), key=lambda i: lengths[i], reverse=True)
         h_idx, v_idx = order[0], order[1]
@@ -66,11 +113,78 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         h_hat = h_vec / (np.linalg.norm(h_vec) or 1.0)
         v_hat = v_vec / (np.linalg.norm(v_vec) or 1.0)
 
-        def project(point) -> tuple[float, float]:
+        def project(point: Coords) -> Point2D:
             p = np.array(point, dtype=float)
             return float(p @ h_hat), float(p @ v_hat)
 
-        corners = [project((0, 0, 0)), project(h_vec), project(v_vec), project(h_vec + v_vec)]
+        return _Orientation(project, h_vec, v_vec, v_idx, h_idx)
+
+    @staticmethod
+    def _annotate_with_axes(
+        lines: list[str],
+        place: Place,
+        corners: list[Point2D],
+        v_letter: str,
+        h_letter: str,
+    ) -> list[str]:
+        """
+        Add the a/b/c axis labels around the schematic cell.
+
+        Parameters
+        ----------
+        lines : list[str]
+            The rendered grid rows (ANSI-tinted).
+        place : Place
+            The grid-placement closure from :func:`_make_grid`.
+        corners : list[Point2D]
+            The four projected cell corners.
+        v_letter : str
+            The vertical-axis crystallographic letter.
+        h_letter : str
+            The horizontal-axis crystallographic letter.
+
+        Returns
+        -------
+        list[str]
+            The grid rows with axis labels added.
+        """
+        cells = [place(c) for c in corners]
+        left_col = min(c for _, c in cells)
+        bottom_row = max(r for r, _ in cells)
+        # Collapse the grid's blank top-padding rows to a single spacer
+        # between the vertical-axis label and the cell's top border.
+        while len(lines) > 1 and not lines[0] and not lines[1]:
+            lines.pop(0)
+            bottom_row -= 1
+        return _annotate_axes(lines, left_col, bottom_row, v_letter, h_letter)
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        """
+        Render a schematic ASCII view and announce 3D-only features.
+
+        Parameters
+        ----------
+        scene : StructureScene
+            The renderer-neutral primitives to draw.
+        features : frozenset[str]
+            The content-resolved feature set from the facade.
+
+        Returns
+        -------
+        str
+            The schematic single-cell ASCII view.
+        """
+        atoms = _collect_atoms(scene)
+        basis = np.array(scene.cell_basis, dtype=float)
+        orient = self._orient(basis)
+        project = orient.project
+
+        corners = [
+            project((0, 0, 0)),
+            project(orient.h_vec),
+            project(orient.v_vec),
+            project(orient.h_vec + orient.v_vec),
+        ]
         points = [project(a[0]) for a in atoms] + corners
         grid, place = _make_grid(points)
 
@@ -81,22 +195,15 @@ def project(point) -> tuple[float, float]:
 
         lines = _grid_to_lines(grid)
         if 'axes' in features:
-            cells = [place(c) for c in corners]
-            left_col = min(c for _, c in cells)
-            bottom_row = max(r for r, _ in cells)
-            # Collapse the grid's blank top-padding rows to a single spacer
-            # between the vertical-axis label and the cell's top border.
-            while len(lines) > 1 and lines[0] == '' and lines[1] == '':
-                lines.pop(0)
-                bottom_row -= 1
-            lines = _annotate_axes(lines, left_col, bottom_row, 'abc'[v_idx], 'abc'[h_idx])
+            v_letter, h_letter = 'abc'[orient.v_idx], 'abc'[orient.h_idx]
+            lines = self._annotate_with_axes(lines, place, corners, v_letter, h_letter)
         text = '\n'.join(lines)
         if 'atoms' in features and atoms:
             text += '\n\n' + _legend(atoms)
         return text
 
 
-def _make_grid(points):
+def _make_grid(points: list[Point2D]) -> tuple[Grid, Place]:
     xs = [p[0] for p in points] or [0.0]
     ys = [p[1] for p in points] or [0.0]
     min_x, max_x, min_y, max_y = min(xs), max(xs), min(ys), max(ys)
@@ -104,9 +211,9 @@ def _make_grid(points):
     span_y = (max_y - min_y) or 1.0
     width = GRID_WIDTH
     height = max(8, int((width - 2 * PAD) * span_y / span_x * CHAR_ASPECT))
-    grid: dict = {}
+    grid: Grid = {}
 
-    def place(point) -> tuple[int, int]:
+    def place(point: Coords) -> Cell:
         col = PAD + int((point[0] - min_x) / span_x * (width - 1 - 2 * PAD))
         row = PAD + int((max_y - point[1]) / span_y * (height - 1 - 2 * PAD))
         return row, col
@@ -115,11 +222,12 @@ def place(point) -> tuple[int, int]:
     return grid, place
 
 
-def _draw_cell(grid, place, corners):
-    # Draw the projected cell as a clean, closed rectangle (the bounding box of
-    # the four projected corners). Integer-rounding the corners independently
-    # otherwise leaves the borders one row/column out of step. This snaps the
-    # slant of oblique cells to an upright box, which the schematic accepts.
+def _draw_cell(grid: Grid, place: Place, corners: list[Point2D]) -> None:
+    # Draw the projected cell as a clean, closed rectangle (the
+    # bounding box of the four projected corners). Integer-rounding
+    # the corners independently otherwise leaves the borders one
+    # row/column out of step. This snaps the slant of oblique cells
+    # to an upright box, which the schematic accepts.
     grey = (150, 150, 150)
     cells = [place(c) for c in corners]
     rows = [r for r, _ in cells]
@@ -132,27 +240,32 @@ def _draw_cell(grid, place, corners):
     for row in range(top, bottom + 1):
         grid.setdefault((row, left), ('│', grey))
         grid.setdefault((row, right), ('│', grey))
-    for cell, glyph in (((top, left), '╭'), ((top, right), '╮'),
-                        ((bottom, left), '╰'), ((bottom, right), '╯')):
+    for cell, glyph in (
+        ((top, left), '╭'),
+        ((top, right), '╮'),
+        ((bottom, left), '╰'),
+        ((bottom, right), '╯'),
+    ):
         grid[cell] = (glyph, grey)
 
 
-def _draw_atoms(grid, place, atoms):
+def _draw_atoms(grid: Grid, place: Place, atoms: list[Atom]) -> None:
     max_radius = max(a[1] for a in atoms) or 1.0
     placed: dict = {}
     for centre, radius, colour, _label in atoms:
         row, col = place(centre)
-        # Skip near-duplicates: a same-colour atom already in this or an
-        # adjacent cell (periodic images projecting to nearly one spot).
-        if any(placed.get((row + dr, col + dc)) == colour
-               for dr in (-1, 0, 1) for dc in (-1, 0, 1)):
+        # Skip near-duplicates: a same-colour atom already in this or
+        # an adjacent cell (periodic images projecting to one spot).
+        if any(
+            placed.get((row + dr, col + dc)) == colour for dr in (-1, 0, 1) for dc in (-1, 0, 1)
+        ):
             continue
         bucket = min(len(GLYPH_RAMP) - 1, int(radius / max_radius * len(GLYPH_RAMP)))
-        grid[(row, col)] = (GLYPH_RAMP[bucket], colour)
-        placed[(row, col)] = colour
+        grid[row, col] = (GLYPH_RAMP[bucket], colour)
+        placed[row, col] = colour
 
 
-def _grid_to_lines(grid):
+def _grid_to_lines(grid: Grid) -> list[str]:
     height, width = grid['_size']
     lines = []
     for row in range(height):
@@ -164,24 +277,32 @@ def _grid_to_lines(grid):
     return lines
 
 
-def _annotate_axes(lines, left_col, bottom_row, v_letter, h_letter):
+def _annotate_axes(
+    lines: list[str],
+    left_col: int,
+    bottom_row: int,
+    v_letter: str,
+    h_letter: str,
+) -> list[str]:
     """
-    Stack the vertical-axis label above the cell and place the
-    horizontal label at the right end of the bottom border (ANSI-safe:
-    no slicing).
+    Add the vertical- and horizontal-axis labels to the grid.
+
+    Stack the vertical-axis label above the cell and append the
+    horizontal label at the right end of the bottom border. ANSI-safe:
+    no slicing of tinted rows.
     """
     indent = ' ' * left_col
     header = ['', f'{indent}{v_letter}', f'{indent}↑']  # blank line, letter, arrow
     body = list(lines)
     if 0 <= bottom_row < len(body):
-        body[bottom_row] = body[bottom_row] + f'  → {h_letter}'
+        body[bottom_row] += f'  → {h_letter}'
     return header + body
 
 
-def _legend(atoms) -> str:
+def _legend(atoms: list[Atom]) -> str:
     seen: dict = {}
     for _centre, radius, colour, label in atoms:
-        # Keep '/' so a shared site reads 'La/Ba', not 'LaBa'; drop digits.
+        # Keep '/' so a shared site reads 'La/Ba', not 'LaBa'; no digits
         element = ''.join(ch for ch in label if ch.isalpha() or ch == '/') or label
         seen.setdefault(element, (radius, colour))
     max_radius = max(r for r, _ in seen.values()) or 1.0
diff --git a/src/easydiffraction/display/structure/renderers/base.py b/src/easydiffraction/display/structure/renderers/base.py
index 4b36633b6..51dda85a0 100644
--- a/src/easydiffraction/display/structure/renderers/base.py
+++ b/src/easydiffraction/display/structure/renderers/base.py
@@ -6,8 +6,10 @@
 
 from abc import ABC
 from abc import abstractmethod
+from typing import TYPE_CHECKING
 
-from easydiffraction.display.structure.scene import StructureScene
+if TYPE_CHECKING:
+    from easydiffraction.display.structure.scene import StructureScene
 
 
 class StructureRendererBase(ABC):
@@ -31,6 +33,11 @@ def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
         -------
         str
             ASCII text or an HTML document, depending on the engine.
+
+        Raises
+        ------
+        NotImplementedError
+            Always; subclasses must override this method.
         """
         raise NotImplementedError
 
@@ -44,5 +51,10 @@ def supported_features(self) -> frozenset[str]:
         frozenset[str]
             Subset of ``atoms``, ``bonds``, ``cell``, ``axes``,
             ``moments``, ``labels``.
+
+        Raises
+        ------
+        NotImplementedError
+            Always; subclasses must override this method.
         """
         raise NotImplementedError
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 632b335b9..c30883edc 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -13,45 +13,75 @@
 from __future__ import annotations
 
 import io
+from collections.abc import Callable
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 import numpy as np
 
 if TYPE_CHECKING:
+    from PIL import ImageDraw
     from PIL import ImageFont
 
+    from easydiffraction.display.structure.scene import AdpEllipsoid
+    from easydiffraction.display.structure.scene import AxisTriad
+    from easydiffraction.display.structure.scene import LegendEntry
+    from easydiffraction.display.structure.scene import OccupancyWedge
+    from easydiffraction.display.structure.scene import Rgb
+    from easydiffraction.display.structure.scene import StructureScene
+    from easydiffraction.display.structure.scene import Vec3
+
+# A 3D point projected to (screen_x, screen_y, view_depth).
+Projector = Callable[[object], 'tuple[float, float, float]']
+# Camera basis vectors (right, up, view_dir) as unit numpy arrays.
+Basis = 'tuple[np.ndarray, np.ndarray, np.ndarray]'
+# Inclusive-exclusive pixel tile bounds (y0, y1, x0, x1).
+Region = 'tuple[int, int, int, int]'
+
 _CANVAS = 1800
 _SUPERSAMPLE = 2
 _MARGIN_FRAC = 0.06
 _BOND_RADIUS = 0.06
+_EDGE_RADIUS = 0.012
 _AMBIENT = 0.5  # broad fill so most of each atom stays bright and saturated
 _LIGHT = np.array([0.3, 0.45, 0.85])  # (right, up, toward-camera); frontal key
-_LIGHT = _LIGHT / np.linalg.norm(_LIGHT)
+_LIGHT /= np.linalg.norm(_LIGHT)
 _FILL = np.array([-0.4, -0.2, -0.45])  # back-fill, mirrors the Three.js fill light
-_FILL = _FILL / np.linalg.norm(_FILL)
-_HALF = _LIGHT + np.array([0.0, 0.0, 1.0])  # Blinn-Phong half-vector (view = toward camera)
-_HALF = _HALF / np.linalg.norm(_HALF)
+_FILL /= np.linalg.norm(_FILL)
+_HALF = _LIGHT + np.array([0.0, 0.0, 1.0])  # Blinn-Phong half-vector (view = camera)
+_HALF /= np.linalg.norm(_HALF)
 _SHININESS = 36.0  # specular exponent
 _SPEC_STRENGTH = 0.28  # small, subtle highlight (not a hard white spot)
 _LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
 _LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
-# Axis-arrow proportions, as fractions of the fit extent, so the arrows are a
-# constant on-screen size in every cell (mirrors the Three.js defaults). The fit
-# extent is ~2x the Three.js half-height reference, hence ~half its fractions.
+# Axis-arrow proportions, as fractions of the fit extent, so the arrows
+# are a constant on-screen size in every cell (mirrors the Three.js
+# defaults). The fit extent is ~2x the Three.js half-height reference,
+# hence ~half its fractions.
 _AXIS_SHAFT_RADIUS_FRAC = 0.0045
 _AXIS_HEAD_RADIUS_FRAC = 0.014
 _AXIS_HEAD_LENGTH_FRAC = 0.043
 _AXIS_OVERHANG_FRAC = 0.045  # minimum overhang past the cell corner
 _AXIS_GAP_FRAC = 0.02  # clear gap between a corner atom and the head base
+_AXIS_SEGMENTS = 32  # tessellation of the shaft cylinder and head cone
+_AXIS_RESERVE = 1.24  # extent multiplier reserving room for the arrows
+_AXIS_PERP_THRESHOLD = 0.9  # pick a fallback up-vector when nearly vertical
+
+_EPS = 1e-9  # degenerate length / denominator guard
+_EPS_NORM = 1e-12  # surface-normal renormalisation guard
+_MIN_SPHERE_PX = 0.5  # skip spheres smaller than this radius in pixels
+_MIN_CAPSULE_PX = 0.6  # floor on the capsule radius in pixels
+_BOND_SPLIT = 0.5  # parametric midpoint where a bond changes colour
+_FILL_GAIN = 0.4  # weight of the back-fill light in the diffuse term
 
 
 def _unit(vector: np.ndarray) -> np.ndarray:
     """Return the unit vector, or the input when it has no length."""
     length = float(np.linalg.norm(vector))
-    return vector / length if length > 1e-9 else vector
+    return vector / length if length > _EPS else vector
 
 
-def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+def _view_basis(scene: StructureScene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     Return (view_dir, right, up) for the default view.
 
@@ -63,9 +93,8 @@ def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     if scene.axes is not None:
         vectors = [np.asarray(ax.vector, dtype=float) for ax in scene.axes.axes]
-        longest, middle, shortest = (
-            _unit(vectors[i]) for i in sorted(range(3), key=lambda i: np.linalg.norm(vectors[i]), reverse=True)
-        )
+        order = sorted(range(3), key=lambda i: np.linalg.norm(vectors[i]), reverse=True)
+        longest, middle, shortest = (_unit(vectors[i]) for i in order)
         view_up = middle
         view_dir = _unit(0.37 * longest + 0.24 * middle + 0.90 * shortest)
     else:
@@ -77,18 +106,14 @@ def _view_basis(scene) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
 
 
 def _diffuse_intensity(normal: np.ndarray) -> np.ndarray:
-    """
-    Lambertian key-plus-fill intensity for a unit surface-normal field.
-    """
+    """Lambertian key-plus-fill intensity for a unit-normal field."""
     key = np.clip(normal @ _LIGHT, 0.0, 1.0)
-    fill = 0.4 * np.clip(normal @ _FILL, 0.0, 1.0)
+    fill = _FILL_GAIN * np.clip(normal @ _FILL, 0.0, 1.0)
     return np.clip(_AMBIENT + (1.0 - _AMBIENT) * (key + fill), 0.0, 1.0)
 
 
 def _specular(normal: np.ndarray) -> np.ndarray:
-    """
-    Blinn-Phong specular highlight for a unit surface-normal field.
-    """
+    """Blinn-Phong specular highlight for a unit-normal field."""
     return _SPEC_STRENGTH * np.clip(normal @ _HALF, 0.0, 1.0) ** _SHININESS
 
 
@@ -99,24 +124,23 @@ def _font(pixels: int) -> ImageFont.FreeTypeFont:
     return ImageFont.load_default(size=pixels)
 
 
-def _scene_points(scene) -> np.ndarray:
+def _scene_points(scene: StructureScene) -> np.ndarray:
     """Return all 3D anchor points used to centre and scale the view."""
-    points: list[tuple[float, float, float]] = []
+    points: list[Vec3] = []
     points.extend(a.centre for a in scene.atoms)
     points.extend(s.centre for s in scene.occupancy_spheres)
     points.extend(e.centre for e in scene.ellipsoids)
     if scene.cell_edges is not None:
         for edge in scene.cell_edges.edges:
-            points.append(edge.start)
-            points.append(edge.end)
+            points.extend((edge.start, edge.end))
     if scene.axes is not None:
-        # Only the cell origin; the axis arrows are sized from the fit extent and
-        # reserved with a margin, not enclosed point-by-point.
+        # Only the cell origin; the axis arrows are sized from the fit
+        # extent and reserved with a margin, not enclosed per-point.
         points.append(scene.axes.origin)
     return np.array(points, dtype=float) if points else np.zeros((1, 3))
 
 
-def _max_radius(scene) -> float:
+def _max_radius(scene: StructureScene) -> float:
     """Return the largest drawn atom radius (for view padding)."""
     radii = [a.radius for a in scene.atoms]
     radii += [s.radius for s in scene.occupancy_spheres]
@@ -124,32 +148,195 @@ def _max_radius(scene) -> float:
     return max(radii) if radii else 0.0
 
 
+def _base_colours(
+    dx: np.ndarray,
+    dy: np.ndarray,
+    base: Rgb,
+    wedges: tuple[OccupancyWedge, ...] | None,
+) -> np.ndarray:
+    """Per-pixel colour: flat tint, or azimuthal occupancy wedges."""
+    if not wedges:
+        flat = np.asarray(base, dtype=np.float32) / 255.0
+        return np.broadcast_to(flat, (*dx.shape, 3))
+    # Pie slices by screen-space azimuth measured clockwise from the
+    # top, so a two-way split reads as a vertical seam (image y is down,
+    # hence negate dy).
+    angle = (np.arctan2(dx, -dy) / (2.0 * np.pi)) % 1.0
+    base_rgb = np.empty((*dx.shape, 3), dtype=np.float32)
+    lo = 0.0
+    for wedge in wedges:
+        mask = (angle >= lo) & (angle < lo + wedge.fraction)
+        base_rgb[mask] = np.asarray(wedge.colour, dtype=np.float32) / 255.0
+        lo += wedge.fraction
+    base_rgb[angle >= lo] = np.asarray(wedges[-1].colour, dtype=np.float32) / 255.0
+    return base_rgb
+
+
+@dataclass(frozen=True, slots=True)
+class _Canvas:
+    """Pixel buffers and the 3D-to-screen projection for one frame."""
+
+    colour: np.ndarray
+    depth: np.ndarray
+    project: Projector
+    scale: float
+
+    def depth_tile(self, region: Region) -> np.ndarray:
+        """Return a view of the depth buffer over one pixel tile."""
+        y0, y1, x0, x1 = region
+        return self.depth[y0:y1, x0:x1]
+
+    def composite(
+        self,
+        region: Region,
+        update: np.ndarray,
+        surf_depth: np.ndarray,
+        shade: np.ndarray,
+    ) -> None:
+        """Z-test one tile: keep nearer pixels and write their shade."""
+        y0, y1, x0, x1 = region
+        self.depth[y0:y1, x0:x1][update] = surf_depth[update]
+        self.colour[y0:y1, x0:x1][update] = shade[update]
+
+    def composite_flat(
+        self,
+        region: Region,
+        update: np.ndarray,
+        surf_depth: np.ndarray,
+        shade: np.ndarray,
+    ) -> None:
+        """Z-test one tile, writing a single flat colour everywhere."""
+        y0, y1, x0, x1 = region
+        self.depth[y0:y1, x0:x1][update] = surf_depth[update]
+        self.colour[y0:y1, x0:x1][update] = shade
+
+
+def _tile_bounds(size: int, lo_x: float, hi_x: float, lo_y: float, hi_y: float) -> Region | None:
+    """Clamp a screen-space box to the canvas, or None if empty."""
+    x0, x1 = max(0, int(lo_x)), min(size, int(hi_x) + 1)
+    y0, y1 = max(0, int(lo_y)), min(size, int(hi_y) + 1)
+    if x0 >= x1 or y0 >= y1:
+        return None
+    return y0, y1, x0, x1
+
+
+def _disc_grid(
+    region: Region,
+    cx: float,
+    cy: float,
+    r_px: float,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Return unit pixel offsets, hemisphere height, and coverage."""
+    y0, y1, x0, x1 = region
+    ys, xs = np.mgrid[y0:y1, x0:x1]
+    dx = (xs - cx) / r_px
+    dy = (ys - cy) / r_px
+    rho2 = dx * dx + dy * dy
+    nz = np.sqrt(np.clip(1.0 - rho2, 0.0, 1.0))
+    return dx, dy, nz, rho2 <= 1.0
+
+
+def _capsule_coverage(
+    region: Region,
+    a: tuple[float, float],
+    b: tuple[float, float],
+    r_px: float,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Parametric position, surface normal, and segment coverage."""
+    y0, y1, x0, x1 = region
+    ys, xs = np.mgrid[y0:y1, x0:x1]
+    seg = np.array([b[0] - a[0], b[1] - a[1]], dtype=float)
+    length2 = float(seg @ seg) or 1.0
+    t = np.clip(((xs - a[0]) * seg[0] + (ys - a[1]) * seg[1]) / length2, 0.0, 1.0)
+    proj_x = a[0] + t * seg[0]
+    proj_y = a[1] + t * seg[1]
+    dist = np.hypot(xs - proj_x, ys - proj_y)
+    nz = np.sqrt(np.clip(1.0 - (dist / r_px) ** 2, 0.0, 1.0))
+    return t, (xs - proj_x) / r_px, -(ys - proj_y) / r_px, nz, dist <= r_px
+
+
+def _capsule_shade(colour0: Rgb, colour1: Rgb, t: np.ndarray, normal: np.ndarray) -> np.ndarray:
+    """Diffuse-shaded capsule colour, split at the bond midpoint."""
+    c0 = np.asarray(colour0, dtype=np.float32) / 255.0
+    c1 = np.asarray(colour1, dtype=np.float32) / 255.0
+    base = np.where((t < _BOND_SPLIT)[..., None], c0, c1)
+    return np.clip(base * _diffuse_intensity(normal)[..., None], 0, 1)
+
+
+def _barycentric(
+    region: Region,
+    v0: tuple[float, float, float],
+    v1: tuple[float, float, float],
+    v2: tuple[float, float, float],
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:
+    """Barycentric weights and inside-mask over a triangle's tile."""
+    # Vertices as (sx, sy, depth); only sx, sy enter the weights.
+    denom = (v1[1] - v2[1]) * (v0[0] - v2[0]) + (v2[0] - v1[0]) * (v0[1] - v2[1])
+    if abs(denom) < _EPS:
+        return None
+    min_y, max_y, min_x, max_x = region
+    ys, xs = np.mgrid[min_y:max_y, min_x:max_x]
+    w0 = ((v1[1] - v2[1]) * (xs - v2[0]) + (v2[0] - v1[0]) * (ys - v2[1])) / denom
+    w1 = ((v2[1] - v0[1]) * (xs - v2[0]) + (v0[0] - v2[0]) * (ys - v2[1])) / denom
+    w2 = 1.0 - w0 - w1
+    return w0, w1, w2, (w0 >= 0.0) & (w1 >= 0.0) & (w2 >= 0.0)
+
+
+def _screen_fit(
+    points: np.ndarray,
+    target: np.ndarray,
+    right: np.ndarray,
+    up: np.ndarray,
+    pad: float,
+    *,
+    reserve_axes: bool,
+) -> tuple[float, np.ndarray, float]:
+    """Return (scale, screen-centre, extent) that fit the points."""
+    size = _CANVAS * _SUPERSAMPLE
+    relative = points - target
+    screen = np.column_stack((relative @ right, relative @ up))
+    lo = screen.min(axis=0) - pad
+    hi = screen.max(axis=0) + pad
+    content_extent = float((hi - lo).max()) or 1.0
+    # Reserve room for the axis arrows (drawn beyond the cell) so their
+    # heads and letters stay inside the frame.
+    extent = content_extent * (_AXIS_RESERVE if reserve_axes else 1.0)
+    scale = (size * (1.0 - 2.0 * _MARGIN_FRAC)) / extent
+    return scale, (lo + hi) / 2.0, extent
+
+
 class RasterStructureRenderer:
     """Render a structure scene as a z-buffered PNG image."""
 
     SUPPORTED = frozenset({'atoms', 'bonds', 'cell', 'axes'})
 
-    def render_png(self, scene, *, features: frozenset[str]) -> bytes:
-        """
-        Return PNG bytes of the scene rendered with a per-pixel
-        z-buffer.
-        """
+    def render_png(self, scene: StructureScene, *, features: frozenset[str]) -> bytes:
+        """Return PNG bytes of the scene with a per-pixel z-buffer."""
         view_dir, right, up = _view_basis(scene)
+        canvas, project, extent, pad = self._make_canvas(scene, view_dir, right, up)
+        basis = (right, up, view_dir)
+        self._draw_features(canvas, scene, features, basis, extent, pad)
+        downsampled = canvas.colour.reshape(_CANVAS, _SUPERSAMPLE, _CANVAS, _SUPERSAMPLE, 3).mean(
+            axis=(1, 3)
+        )
+        rgb = np.clip(downsampled * 255.0, 0, 255).astype(np.uint8)
+        return self._compose_png(rgb, scene, project, features)
+
+    @staticmethod
+    def _make_canvas(
+        scene: StructureScene,
+        view_dir: np.ndarray,
+        right: np.ndarray,
+        up: np.ndarray,
+    ) -> tuple[_Canvas, Projector, float, float]:
+        """Build the pixel buffers and the fitted projection closure."""
         points = _scene_points(scene)
         target = points.mean(axis=0)
-
         size = _CANVAS * _SUPERSAMPLE
-        relative = points - target
-        screen = np.column_stack((relative @ right, relative @ up))
         pad = _max_radius(scene)
-        lo = screen.min(axis=0) - pad
-        hi = screen.max(axis=0) + pad
-        content_extent = float((hi - lo).max()) or 1.0
-        # Reserve room for the axis arrows (drawn beyond the cell, sized from the
-        # extent below) so their heads and letters stay inside the frame.
-        extent = content_extent * (1.24 if scene.axes is not None else 1.0)
-        scale = (size * (1.0 - 2.0 * _MARGIN_FRAC)) / extent
-        centre2d = (lo + hi) / 2.0
+        scale, centre2d, extent = _screen_fit(
+            points, target, right, up, pad, reserve_axes=scene.axes is not None
+        )
 
         def project(point: object) -> tuple[float, float, float]:
             rel = np.asarray(point, dtype=float) - target
@@ -159,38 +346,48 @@ def project(point: object) -> tuple[float, float, float]:
 
         colour = np.ones((size, size, 3), dtype=np.float32)
         depth = np.full((size, size), -np.inf, dtype=np.float32)
-
+        return _Canvas(colour, depth, project, scale), project, extent, pad
+
+    def _draw_features(
+        self,
+        canvas: _Canvas,
+        scene: StructureScene,
+        features: frozenset[str],
+        basis: Basis,
+        extent: float,
+        pad: float,
+    ) -> None:
+        """Depth-test every requested primitive into the canvas."""
         if 'cell' in features and scene.cell_edges is not None:
             for edge in scene.cell_edges.edges:
-                self._capsule(colour, depth, project, scale, edge.start, edge.end,
-                              0.012, (90, 90, 90), (90, 90, 90))
+                self._capsule(
+                    canvas, edge.start, edge.end, _EDGE_RADIUS, (90, 90, 90), (90, 90, 90)
+                )
         if 'axes' in features and scene.axes is not None:
-            self._axes(colour, depth, project, (right, up, view_dir), scene.axes, extent, pad)
+            self._axes(canvas, basis, scene.axes, extent, pad)
         if 'bonds' in features:
             for bond in scene.bonds:
-                self._capsule(colour, depth, project, scale, bond.start, bond.end,
-                              _BOND_RADIUS, bond.start_colour, bond.end_colour)
+                self._capsule(
+                    canvas, bond.start, bond.end, _BOND_RADIUS, bond.start_colour, bond.end_colour
+                )
         if 'atoms' in features:
             for atom in scene.atoms:
-                self._sphere(colour, depth, project, scale, atom.centre, atom.radius, atom.colour)
+                self._sphere(canvas, atom.centre, atom.radius, atom.colour)
             for sphere in scene.occupancy_spheres:
-                self._sphere(colour, depth, project, scale, sphere.centre, sphere.radius,
-                             (128, 128, 128), wedges=sphere.wedges)
+                self._sphere(
+                    canvas, sphere.centre, sphere.radius, (128, 128, 128), wedges=sphere.wedges
+                )
             for ellipsoid in scene.ellipsoids:
-                self._ellipsoid(colour, depth, project, scale, (right, up, view_dir), ellipsoid)
-
-        downsampled = (
-            colour.reshape(_CANVAS, _SUPERSAMPLE, _CANVAS, _SUPERSAMPLE, 3).mean(axis=(1, 3))
-        )
-        rgb = np.clip(downsampled * 255.0, 0, 255).astype(np.uint8)
-        return self._compose_png(rgb, scene, project, features)
+                self._ellipsoid(canvas, basis, ellipsoid)
 
     @staticmethod
-    def _compose_png(rgb, scene, project, features) -> bytes:
-        """
-        Draw axis labels and the legend with Pillow, then encode the
-        PNG.
-        """
+    def _compose_png(
+        rgb: np.ndarray,
+        scene: StructureScene,
+        project: Projector,
+        features: frozenset[str],
+    ) -> bytes:
+        """Draw axis labels and the legend with Pillow, then encode."""
         from PIL import Image  # noqa: PLC0415
         from PIL import ImageDraw  # noqa: PLC0415
 
@@ -205,10 +402,8 @@ def _compose_png(rgb, scene, project, features) -> bytes:
         return buffer.getvalue()
 
     @staticmethod
-    def _draw_axis_labels(draw, axes, project) -> None:
-        """
-        Place each axis letter just beyond its arrow tip, always on top.
-        """
+    def _draw_axis_labels(draw: ImageDraw.ImageDraw, axes: AxisTriad, project: Projector) -> None:
+        """Place each axis letter just beyond its tip, always on top."""
         font = _font(int(_CANVAS * _LABEL_FRAC))
         inset = int(_CANVAS * 0.02)
         origin = np.asarray(axes.origin, dtype=float)
@@ -221,10 +416,8 @@ def _draw_axis_labels(draw, axes, project) -> None:
             draw.text((lx, ly), arrow.letter, font=font, fill=tuple(arrow.colour), anchor='mm')
 
     @staticmethod
-    def _draw_legend(draw, legend) -> None:
-        """
-        Draw element colour swatches and symbols in a top-left panel.
-        """
+    def _draw_legend(draw: ImageDraw.ImageDraw, legend: tuple[LegendEntry, ...]) -> None:
+        """Draw element colour swatches and labels in a panel."""
         font = _font(int(_CANVAS * _LEGEND_FRAC))
         margin = int(_CANVAS * 0.025)
         pad = int(_CANVAS * 0.014)
@@ -236,7 +429,9 @@ def _draw_legend(draw, legend) -> None:
         panel_height = pad + len(legend) * pitch
         draw.rounded_rectangle(
             (margin, margin, margin + panel_width, margin + panel_height),
-            radius=int(_CANVAS * 0.01), fill=(255, 255, 255), outline=(170, 170, 170),
+            radius=int(_CANVAS * 0.01),
+            fill=(255, 255, 255),
+            outline=(170, 170, 170),
             width=max(1, int(_CANVAS * 0.0015)),
         )
         for index, entry in enumerate(legend):
@@ -244,260 +439,413 @@ def _draw_legend(draw, legend) -> None:
             cy = margin + pad + radius + index * pitch
             draw.ellipse(
                 (cx, cy - radius, cx + 2 * radius, cy + radius),
-                fill=tuple(entry.colour), outline=(60, 60, 60), width=max(1, int(_CANVAS * 0.0012)),
+                fill=tuple(entry.colour),
+                outline=(60, 60, 60),
+                width=max(1, int(_CANVAS * 0.0012)),
+            )
+            draw.text(
+                (cx + 2 * radius + gap, cy),
+                entry.symbol,
+                font=font,
+                fill=(40, 40, 40),
+                anchor='lm',
             )
-            draw.text((cx + 2 * radius + gap, cy), entry.symbol,
-                      font=font, fill=(40, 40, 40), anchor='lm')
 
     @staticmethod
-    def _sphere(colour, depth, project, scale, centre, radius, base, *, wedges=None) -> None:
-        size = colour.shape[0]
-        cx, cy, cd = project(centre)
-        r_px = radius * scale
-        if r_px < 0.5:
+    def _sphere(
+        canvas: _Canvas,
+        centre: Vec3,
+        radius: float,
+        base: Rgb,
+        *,
+        wedges: tuple[OccupancyWedge, ...] | None = None,
+    ) -> None:
+        """Z-test and shade one matte sphere of the given radius."""
+        size = canvas.colour.shape[0]
+        cx, cy, cd = canvas.project(centre)
+        r_px = radius * canvas.scale
+        if r_px < _MIN_SPHERE_PX:
             return
-        x0, x1 = max(0, int(cx - r_px)), min(size, int(cx + r_px) + 1)
-        y0, y1 = max(0, int(cy - r_px)), min(size, int(cy + r_px) + 1)
-        if x0 >= x1 or y0 >= y1:
+        region = _tile_bounds(size, cx - r_px, cx + r_px, cy - r_px, cy + r_px)
+        if region is None:
             return
-        ys, xs = np.mgrid[y0:y1, x0:x1]
-        dx = (xs - cx) / r_px
-        dy = (ys - cy) / r_px
-        rho2 = dx * dx + dy * dy
-        inside = rho2 <= 1.0
+        dx, dy, nz, inside = _disc_grid(region, cx, cy, r_px)
         if not inside.any():
             return
-        nz = np.sqrt(np.clip(1.0 - rho2, 0.0, 1.0))
         surf_depth = cd + nz * radius
-        sub = depth[y0:y1, x0:x1]
-        update = inside & (surf_depth > sub)
+        update = inside & (surf_depth > canvas.depth_tile(region))
         if not update.any():
             return
-        # Matte (Lambertian) shading to match the Three.js MeshStandardMaterial:
-        # normal in (right, up, toward-camera) space; image y is down.
+        # Matte (Lambertian) shading to match the Three.js
+        # MeshStandardMaterial: normal in (right, up, toward-camera)
+        # space; image y is down.
         normal = np.stack((dx, -dy, nz), axis=-1)
-        intensity = _diffuse_intensity(normal)[..., None]
-        base_rgb = RasterStructureRenderer._base_colours(dx, dy, base, wedges)
-        shade = np.clip(base_rgb * intensity + _specular(normal)[..., None], 0, 1)
-        sub[update] = surf_depth[update]
-        colour[y0:y1, x0:x1][update] = shade[update]
+        shade = _shade_normals(normal, _base_colours(dx, dy, base, wedges))
+        canvas.composite(region, update, surf_depth, shade)
 
     @staticmethod
-    def _base_colours(dx, dy, base, wedges) -> np.ndarray:
-        """
-        Per-pixel base colour: a flat tint, or azimuthal occupancy
-        wedges.
-        """
-        if not wedges:
-            flat = np.asarray(base, dtype=np.float32) / 255.0
-            return np.broadcast_to(flat, dx.shape + (3,))
-        # Pie slices by screen-space azimuth measured clockwise from the top, so
-        # a two-way split reads as a vertical seam (image y is down -> negate dy).
-        angle = (np.arctan2(dx, -dy) / (2.0 * np.pi)) % 1.0
-        base_rgb = np.empty(dx.shape + (3,), dtype=np.float32)
-        lo = 0.0
-        for wedge in wedges:
-            mask = (angle >= lo) & (angle < lo + wedge.fraction)
-            base_rgb[mask] = np.asarray(wedge.colour, dtype=np.float32) / 255.0
-            lo += wedge.fraction
-        base_rgb[angle >= lo] = np.asarray(wedges[-1].colour, dtype=np.float32) / 255.0
-        return base_rgb
-
-    @staticmethod
-    def _ellipsoid(colour, depth, project, scale, basis, ell) -> None:
-        """
-        Z-tested, shaded oriented ADP ellipsoid (exact ray cast per
-        pixel).
-        """
-        right, up, view_dir = basis
-        centre = np.asarray(ell.centre, dtype=float)
-        semi = np.maximum(np.asarray(ell.semi_axes, dtype=float), 1e-9)
+    def _ellipsoid(
+        canvas: _Canvas,
+        basis: Basis,
+        ell: AdpEllipsoid,
+    ) -> None:
+        """Z-tested, shaded ADP ellipsoid (exact ray cast per pixel)."""
+        semi = np.maximum(np.asarray(ell.semi_axes, dtype=float), _EPS)
         axes = [np.asarray(vec, dtype=float) for vec in ell.orientation]
-        cx, cy, cd = project(centre)
-        half_x = scale * float(np.sqrt(sum((semi[k] * (axes[k] @ right)) ** 2 for k in range(3))))
-        half_y = scale * float(np.sqrt(sum((semi[k] * (axes[k] @ up)) ** 2 for k in range(3))))
-        size = colour.shape[0]
-        x0, x1 = max(0, int(cx - half_x)), min(size, int(cx + half_x) + 1)
-        y0, y1 = max(0, int(cy - half_y)), min(size, int(cy + half_y) + 1)
-        if x0 >= x1 or y0 >= y1:
-            return
-        # Camera-frame components of each principal axis.
-        r = [float(axes[k] @ right) for k in range(3)]
-        u = [float(axes[k] @ up) for k in range(3)]
-        v = [float(axes[k] @ view_dir) for k in range(3)]
-        a_coeff = sum((v[k] / semi[k]) ** 2 for k in range(3))
-        if a_coeff <= 0.0:
+        cx, cy, cd = canvas.project(ell.centre)
+        region = _ellipsoid_bounds(canvas, semi, axes, basis, cx, cy)
+        if region is None:
             return
-        # Solve |S^-1 R^T (q)|^2 = 1 along the view ray q = image-plane + t*view_dir.
-        ys, xs = np.mgrid[y0:y1, x0:x1]
-        offset_right = (xs - cx) / scale
-        offset_up = -(ys - cy) / scale
-        base = [offset_right * r[k] + offset_up * u[k] for k in range(3)]
-        b_coeff = sum(2.0 * base[k] * v[k] / semi[k] ** 2 for k in range(3))
-        c_coeff = sum((base[k] / semi[k]) ** 2 for k in range(3)) - 1.0
-        disc = b_coeff * b_coeff - 4.0 * a_coeff * c_coeff
-        inside = disc >= 0.0
-        if not inside.any():
+        cast = _ellipsoid_raycast(region, semi, axes, basis, canvas.scale, (cx, cy))
+        if cast is None:
             return
-        t = (-b_coeff + np.sqrt(np.clip(disc, 0.0, None))) / (2.0 * a_coeff)
-        surf_depth = cd + t
-        sub = depth[y0:y1, x0:x1]
-        update = inside & (surf_depth > sub)
-        if not update.any():
+        result = _ellipsoid_update(canvas, region, cd, basis, (semi, axes), cast)
+        if result is None:
             return
-        local = [(base[k] + t * v[k]) / semi[k] for k in range(3)]
-        nx = sum(local[k] / semi[k] * axes[k][0] for k in range(3))
-        ny = sum(local[k] / semi[k] * axes[k][1] for k in range(3))
-        nz = sum(local[k] / semi[k] * axes[k][2] for k in range(3))
-        norm = np.sqrt(nx * nx + ny * ny + nz * nz)
-        norm = np.where(norm > 1e-12, norm, 1.0)
-        normal = np.stack((
-            (nx * right[0] + ny * right[1] + nz * right[2]) / norm,
-            (nx * up[0] + ny * up[1] + nz * up[2]) / norm,
-            (nx * view_dir[0] + ny * view_dir[1] + nz * view_dir[2]) / norm,
-        ), axis=-1)
-        intensity = _diffuse_intensity(normal)[..., None]
-        base_rgb = RasterStructureRenderer._base_colours(xs - cx, ys - cy, ell.colour, ell.wedges)
-        shade = np.clip(base_rgb * intensity + _specular(normal)[..., None], 0, 1)
-        sub[update] = surf_depth[update]
-        colour[y0:y1, x0:x1][update] = shade[update]
+        update, surf_depth, normal = result
+        ys, xs = np.mgrid[region[0] : region[1], region[2] : region[3]]
+        base_rgb = _base_colours(xs - cx, ys - cy, ell.colour, ell.wedges)
+        canvas.composite(region, update, surf_depth, _shade_normals(normal, base_rgb))
 
     @staticmethod
-    def _capsule(colour, depth, project, scale, p0, p1, radius, colour0, colour1) -> None:
-        size = colour.shape[0]
-        ax, ay, ad = project(p0)
-        bx, by, bd = project(p1)
-        r_px = max(radius * scale, 0.6)
-        x0 = max(0, int(min(ax, bx) - r_px))
-        x1 = min(size, int(max(ax, bx) + r_px) + 1)
-        y0 = max(0, int(min(ay, by) - r_px))
-        y1 = min(size, int(max(ay, by) + r_px) + 1)
-        if x0 >= x1 or y0 >= y1:
+    def _capsule(
+        canvas: _Canvas, p0: Vec3, p1: Vec3, radius: float, colour0: Rgb, colour1: Rgb
+    ) -> None:
+        """Z-test and shade one split-coloured cylindrical capsule."""
+        size = canvas.colour.shape[0]
+        a = canvas.project(p0)
+        b = canvas.project(p1)
+        r_px = max(radius * canvas.scale, _MIN_CAPSULE_PX)
+        region = _tile_bounds(
+            size,
+            min(a[0], b[0]) - r_px,
+            max(a[0], b[0]) + r_px,
+            min(a[1], b[1]) - r_px,
+            max(a[1], b[1]) + r_px,
+        )
+        if region is None:
             return
-        ys, xs = np.mgrid[y0:y1, x0:x1]
-        seg = np.array([bx - ax, by - ay], dtype=float)
-        length2 = float(seg @ seg) or 1.0
-        t = np.clip(((xs - ax) * seg[0] + (ys - ay) * seg[1]) / length2, 0.0, 1.0)
-        proj_x = ax + t * seg[0]
-        proj_y = ay + t * seg[1]
-        dist = np.hypot(xs - proj_x, ys - proj_y)
-        inside = dist <= r_px
+        t, nx, ny, nz, inside = _capsule_coverage(region, a[:2], b[:2], r_px)
         if not inside.any():
             return
-        nz = np.sqrt(np.clip(1.0 - (dist / r_px) ** 2, 0.0, 1.0))
-        surf_depth = ad + t * (bd - ad) + nz * radius
-        sub = depth[y0:y1, x0:x1]
-        update = inside & (surf_depth > sub)
+        surf_depth = a[2] + t * (b[2] - a[2]) + nz * radius
+        update = inside & (surf_depth > canvas.depth_tile(region))
         if not update.any():
             return
-        # Directional cylinder shading: normal perpendicular to the projected
-        # axis (image y is down), with the bulge as the toward-camera component.
-        normal = np.stack(((xs - proj_x) / r_px, -(ys - proj_y) / r_px, nz), axis=-1)
-        intensity = _diffuse_intensity(normal)[..., None]
-        c0 = np.asarray(colour0, dtype=np.float32) / 255.0
-        c1 = np.asarray(colour1, dtype=np.float32) / 255.0
-        base = np.where((t < 0.5)[..., None], c0, c1)
-        shade = np.clip(base * intensity, 0, 1)
-        sub[update] = surf_depth[update]
-        colour[y0:y1, x0:x1][update] = shade[update]
+        # Directional cylinder shading: normal perpendicular to the
+        # projected axis (image y is down), with the bulge as the
+        # toward-camera component.
+        shade = _capsule_shade(colour0, colour1, t, np.stack((nx, ny, nz), axis=-1))
+        canvas.composite(region, update, surf_depth, shade)
 
     @staticmethod
-    def _triangle(colour, depth, v0, v1, v2, shade) -> None:
-        """
-        Z-test and fill one flat-shaded triangle from projected
-        vertices.
-        """
-        size = colour.shape[0]
-        (x0, y0, d0), (x1, y1, d1), (x2, y2, d2) = v0, v1, v2
-        min_x = max(0, int(min(x0, x1, x2)))
-        max_x = min(size, int(max(x0, x1, x2)) + 1)
-        min_y = max(0, int(min(y0, y1, y2)))
-        max_y = min(size, int(max(y0, y1, y2)) + 1)
-        if min_x >= max_x or min_y >= max_y:
+    def _triangle(
+        canvas: _Canvas,
+        v0: tuple[float, float, float],
+        v1: tuple[float, float, float],
+        v2: tuple[float, float, float],
+        shade: np.ndarray,
+    ) -> None:
+        """Z-test and fill one flat-shaded triangle from projections."""
+        size = canvas.colour.shape[0]
+        region = _tile_bounds(
+            size,
+            min(v0[0], v1[0], v2[0]),
+            max(v0[0], v1[0], v2[0]),
+            min(v0[1], v1[1], v2[1]),
+            max(v0[1], v1[1], v2[1]),
+        )
+        if region is None:
             return
-        denom = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2)
-        if abs(denom) < 1e-9:
+        bary = _barycentric(region, v0, v1, v2)
+        if bary is None:
             return
-        ys, xs = np.mgrid[min_y:max_y, min_x:max_x]
-        w0 = ((y1 - y2) * (xs - x2) + (x2 - x1) * (ys - y2)) / denom
-        w1 = ((y2 - y0) * (xs - x2) + (x0 - x2) * (ys - y2)) / denom
-        w2 = 1.0 - w0 - w1
-        inside = (w0 >= 0.0) & (w1 >= 0.0) & (w2 >= 0.0)
+        w0, w1, w2, inside = bary
         if not inside.any():
             return
-        tri_depth = w0 * d0 + w1 * d1 + w2 * d2
-        sub = depth[min_y:max_y, min_x:max_x]
-        update = inside & (tri_depth > sub)
+        tri_depth = w0 * v0[2] + w1 * v1[2] + w2 * v2[2]
+        update = inside & (tri_depth > canvas.depth_tile(region))
         if not update.any():
             return
-        sub[update] = tri_depth[update]
-        colour[min_y:max_y, min_x:max_x][update] = shade
-
-    def _arrow(self, colour, depth, project, basis, origin, vector, extent, rgb) -> None:
+        canvas.composite_flat(region, update, tri_depth, shade)
+
+    def _arrow(
+        self,
+        canvas: _Canvas,
+        basis: Basis,
+        origin: np.ndarray,
+        vector: np.ndarray,
+        extent: float,
+        rgb: Rgb,
+    ) -> None:
         """
-        Draw a shaft cylinder and head cone as 3D triangles
-        (orientation-safe).
+        Draw a shaft cylinder and head cone as 3D triangles.
 
         Thickness and head size are fractions of ``extent`` (the fit
         extent), so the arrow is a constant on-screen size in every
         cell. ``vector`` already runs to the arrow tip (cell edge plus
         overhang).
         """
-        right, up, view_dir = basis
-        length = float(np.linalg.norm(vector))
-        if length < 1e-9:
+        geometry = _arrow_geometry(origin, vector, extent)
+        if geometry is None:
             return
-        axis = vector / length
-        perp = np.array([0.0, 0.0, 1.0]) if abs(axis[2]) < 0.9 else np.array([0.0, 1.0, 0.0])
-        u = _unit(np.cross(perp, axis))
-        v = np.cross(axis, u)
-        shaft_r = _AXIS_SHAFT_RADIUS_FRAC * extent
-        head_r = _AXIS_HEAD_RADIUS_FRAC * extent
-        base = origin + axis * max(length - _AXIS_HEAD_LENGTH_FRAC * extent, 1e-3)
-        tip = origin + vector
+        axis, u, v, base, tip = geometry
+        radii = (_AXIS_SHAFT_RADIUS_FRAC * extent, _AXIS_HEAD_RADIUS_FRAC * extent)
         flat = np.asarray(rgb, dtype=np.float32) / 255.0
+        ring = [
+            np.cos(angle) * u + np.sin(angle) * v
+            for angle in (2.0 * np.pi * i / _AXIS_SEGMENTS for i in range(_AXIS_SEGMENTS))
+        ]
+        for i in range(_AXIS_SEGMENTS):
+            self._arrow_segment(canvas, ring, i, (origin, base, tip), radii, (axis, basis, flat))
+
+    def _arrow_segment(
+        self,
+        canvas: _Canvas,
+        ring: list[np.ndarray],
+        i: int,
+        anchors: tuple[np.ndarray, np.ndarray, np.ndarray],
+        radii: tuple[float, float],
+        shading: tuple[np.ndarray, Basis, np.ndarray],
+    ) -> None:
+        """Emit the shaft and head triangles for one ring segment."""
+        origin, base, tip = anchors
+        shaft_r, head_r = radii
+        _axis, basis, flat = shading
+        pair = (ring[i], ring[(i + 1) % _AXIS_SEGMENTS])
+        shaft_shade = _arrow_shade(_unit(pair[0] + pair[1]), basis, flat)
+        self._arrow_shaft(canvas, origin, base, shaft_r, pair, shaft_shade)
+        self._arrow_head(canvas, base, tip, head_r, pair, shading)
+
+    def _arrow_shaft(
+        self,
+        canvas: _Canvas,
+        origin: np.ndarray,
+        base: np.ndarray,
+        shaft_r: float,
+        pair: tuple[np.ndarray, np.ndarray],
+        shade: np.ndarray,
+    ) -> None:
+        """Emit the two shaft-cylinder triangles for one segment."""
+        d0, d1 = pair
+        project = canvas.project
+        o0 = project(tuple(origin + shaft_r * d0))
+        o1 = project(tuple(origin + shaft_r * d1))
+        s0 = project(tuple(base + shaft_r * d0))
+        s1 = project(tuple(base + shaft_r * d1))
+        self._triangle(canvas, o0, o1, s1, shade)
+        self._triangle(canvas, o0, s1, s0, shade)
+
+    def _arrow_head(
+        self,
+        canvas: _Canvas,
+        base: np.ndarray,
+        tip: np.ndarray,
+        head_r: float,
+        pair: tuple[np.ndarray, np.ndarray],
+        shading: tuple[np.ndarray, Basis, np.ndarray],
+    ) -> None:
+        """Emit the cone-face and base triangles for one segment."""
+        axis, basis, flat = shading
+        d0, d1 = pair
+        project = canvas.project
+        b0 = base + head_r * d0
+        b1 = base + head_r * d1
+        normal = _unit(np.cross(b1 - b0, tip - b0))
+        if normal @ (d0 + d1) < 0.0:
+            normal = -normal
+        self._triangle(
+            canvas,
+            project(tuple(b0)),
+            project(tuple(b1)),
+            project(tuple(tip)),
+            _arrow_shade(normal, basis, flat),
+        )
+        self._triangle(
+            canvas,
+            project(tuple(base)),
+            project(tuple(b1)),
+            project(tuple(b0)),
+            _arrow_shade(-axis, basis, flat),
+        )
 
-        def shade_for(world_normal: np.ndarray) -> np.ndarray:
-            cam = np.array([world_normal @ right, world_normal @ up, world_normal @ view_dir])
-            return np.clip(flat * float(_diffuse_intensity(cam)), 0.0, 1.0)
-
-        segments = 32
-        ring = [np.cos(angle) * u + np.sin(angle) * v
-                for angle in (2.0 * np.pi * i / segments for i in range(segments))]
-        for i in range(segments):
-            d0 = ring[i]
-            d1 = ring[(i + 1) % segments]
-            shaft_shade = shade_for(_unit(d0 + d1))
-            o0 = project(tuple(origin + shaft_r * d0))
-            o1 = project(tuple(origin + shaft_r * d1))
-            s0 = project(tuple(base + shaft_r * d0))
-            s1 = project(tuple(base + shaft_r * d1))
-            self._triangle(colour, depth, o0, o1, s1, shaft_shade)
-            self._triangle(colour, depth, o0, s1, s0, shaft_shade)
-            b0 = base + head_r * d0
-            b1 = base + head_r * d1
-            normal = _unit(np.cross(b1 - b0, tip - b0))
-            if normal @ (d0 + d1) < 0.0:
-                normal = -normal
-            self._triangle(colour, depth, project(tuple(b0)), project(tuple(b1)),
-                           project(tuple(tip)), shade_for(normal))
-            self._triangle(colour, depth, project(tuple(base)), project(tuple(b1)),
-                           project(tuple(b0)), shade_for(-axis))
-
-    def _axes(self, colour, depth, project, basis, axes, extent, max_atom_r) -> None:
+    def _axes(
+        self,
+        canvas: _Canvas,
+        basis: Basis,
+        axes: AxisTriad,
+        extent: float,
+        max_atom_r: float,
+    ) -> None:
+        """Draw the a/b/c arrow triad beyond the cell corners."""
         origin = np.asarray(axes.origin, dtype=float)
         vectors = [np.asarray(a.vector, dtype=float) for a in axes.axes]
-        # Recover the longest cell edge (the builder adds a 0.3*max overhang).
+        # Recover the longest cell edge (the builder adds a 0.3*max
+        # overhang).
         max_axis = max((float(np.linalg.norm(v)) for v in vectors), default=1.0) / 1.3
         head_len = _AXIS_HEAD_LENGTH_FRAC * extent
-        # Overhang clears the largest atom (so corner atoms never hide the head),
-        # plus the head length and a small gap.
-        overhang = max(_AXIS_OVERHANG_FRAC * extent, max_atom_r + head_len + _AXIS_GAP_FRAC * extent)
-        for arrow, vector in zip(axes.axes, vectors):
+        # Overhang clears the largest atom (so corner atoms never hide
+        # the head), plus the head length and a small gap.
+        overhang = max(
+            _AXIS_OVERHANG_FRAC * extent, max_atom_r + head_len + _AXIS_GAP_FRAC * extent
+        )
+        for arrow, vector in zip(axes.axes, vectors, strict=True):
             length = float(np.linalg.norm(vector))
-            if length < 1e-9:
+            if length < _EPS:
                 continue
             axis = vector / length
             axis_len = max(length - 0.3 * max_axis, 1e-3)
-            self._arrow(colour, depth, project, basis, origin,
-                        axis * (axis_len + overhang), extent, arrow.colour)
+            self._arrow(canvas, basis, origin, axis * (axis_len + overhang), extent, arrow.colour)
+
+
+def _shade_normals(normal: np.ndarray, base_rgb: np.ndarray) -> np.ndarray:
+    """Combine diffuse and specular terms over a base-colour field."""
+    intensity = _diffuse_intensity(normal)[..., None]
+    return np.clip(base_rgb * intensity + _specular(normal)[..., None], 0, 1)
+
+
+def _camera_components(
+    axes: list[np.ndarray],
+    basis: Basis,
+) -> tuple[list[float], list[float], list[float]]:
+    """Camera-frame (right, up, view) components of each axis."""
+    right, up, view_dir = basis
+    return (
+        [float(axes[k] @ right) for k in range(3)],
+        [float(axes[k] @ up) for k in range(3)],
+        [float(axes[k] @ view_dir) for k in range(3)],
+    )
+
+
+def _ellipsoid_bounds(
+    canvas: _Canvas,
+    semi: np.ndarray,
+    axes: list[np.ndarray],
+    basis: Basis,
+    cx: float,
+    cy: float,
+) -> Region | None:
+    """Screen-space bounding tile of a projected ADP ellipsoid."""
+    right, up = basis[0], basis[1]
+    size = canvas.colour.shape[0]
+    half_x = canvas.scale * float(
+        np.sqrt(sum((semi[k] * (axes[k] @ right)) ** 2 for k in range(3)))
+    )
+    half_y = canvas.scale * float(np.sqrt(sum((semi[k] * (axes[k] @ up)) ** 2 for k in range(3))))
+    return _tile_bounds(size, cx - half_x, cx + half_x, cy - half_y, cy + half_y)
+
+
+def _ellipsoid_offsets(
+    region: Region,
+    scale: float,
+    centre2d: tuple[float, float],
+) -> tuple[np.ndarray, np.ndarray]:
+    """Image-plane right/up offsets (world units) over a pixel tile."""
+    cx, cy = centre2d
+    y0, y1, x0, x1 = region
+    ys, xs = np.mgrid[y0:y1, x0:x1]
+    return (xs - cx) / scale, -(ys - cy) / scale
+
+
+def _ellipsoid_raycast(
+    region: Region,
+    semi: np.ndarray,
+    axes: list[np.ndarray],
+    basis: Basis,
+    scale: float,
+    centre2d: tuple[float, float],
+) -> tuple[np.ndarray, list[np.ndarray], np.ndarray] | None:
+    """Solve the view-ray/ellipsoid intersection over a pixel tile."""
+    r, u, v = _camera_components(axes, basis)
+    a_coeff = sum((v[k] / semi[k]) ** 2 for k in range(3))
+    if a_coeff <= 0.0:
+        return None
+    # Solve |S^-1 R^T q|^2 = 1 along the ray q = image-plane + t*view.
+    offset_right, offset_up = _ellipsoid_offsets(region, scale, centre2d)
+    base = [offset_right * r[k] + offset_up * u[k] for k in range(3)]
+    b_coeff = sum(2.0 * base[k] * v[k] / semi[k] ** 2 for k in range(3))
+    c_coeff = sum((base[k] / semi[k]) ** 2 for k in range(3)) - 1.0
+    disc = b_coeff * b_coeff - 4.0 * a_coeff * c_coeff
+    inside = disc >= 0.0
+    if not inside.any():
+        return None
+    t = (-b_coeff + np.sqrt(np.clip(disc, 0.0, None))) / (2.0 * a_coeff)
+    return t, base, inside
+
+
+def _ellipsoid_update(
+    canvas: _Canvas,
+    region: Region,
+    cd: float,
+    basis: Basis,
+    geom: tuple[np.ndarray, list[np.ndarray]],
+    cast: tuple[np.ndarray, list[np.ndarray], np.ndarray],
+) -> tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+    """Depth-test the cast hits and return (update, depth, normal)."""
+    semi, axes = geom
+    local_t, base, inside = cast
+    surf_depth = cd + local_t
+    update = inside & (surf_depth > canvas.depth_tile(region))
+    if not update.any():
+        return None
+    normal = _ellipsoid_normals(base, local_t, semi, axes, basis)
+    return update, surf_depth, normal
+
+
+def _ellipsoid_normals(
+    base: list[np.ndarray],
+    t: np.ndarray,
+    semi: np.ndarray,
+    axes: list[np.ndarray],
+    basis: Basis,
+) -> np.ndarray:
+    """Camera-frame unit surface normals on the ellipsoid hit points."""
+    right, up, view_dir = basis
+    v = [float(axes[k] @ view_dir) for k in range(3)]
+    local = [(base[k] + t * v[k]) / semi[k] for k in range(3)]
+    nx = sum(local[k] / semi[k] * axes[k][0] for k in range(3))
+    ny = sum(local[k] / semi[k] * axes[k][1] for k in range(3))
+    nz = sum(local[k] / semi[k] * axes[k][2] for k in range(3))
+    norm = np.sqrt(nx * nx + ny * ny + nz * nz)
+    norm = np.where(norm > _EPS_NORM, norm, 1.0)
+    return np.stack(
+        (
+            (nx * right[0] + ny * right[1] + nz * right[2]) / norm,
+            (nx * up[0] + ny * up[1] + nz * up[2]) / norm,
+            (nx * view_dir[0] + ny * view_dir[1] + nz * view_dir[2]) / norm,
+        ),
+        axis=-1,
+    )
+
+
+def _arrow_geometry(
+    origin: np.ndarray,
+    vector: np.ndarray,
+    extent: float,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:
+    """Axis frame, shaft base, and tip for one arrow, or None."""
+    length = float(np.linalg.norm(vector))
+    if length < _EPS:
+        return None
+    axis = vector / length
+    perp = (
+        np.array([0.0, 0.0, 1.0])
+        if abs(axis[2]) < _AXIS_PERP_THRESHOLD
+        else np.array([0.0, 1.0, 0.0])
+    )
+    u = _unit(np.cross(perp, axis))
+    v = np.cross(axis, u)
+    base = origin + axis * max(length - _AXIS_HEAD_LENGTH_FRAC * extent, 1e-3)
+    tip = origin + vector
+    return axis, u, v, base, tip
+
+
+def _arrow_shade(
+    world_normal: np.ndarray,
+    basis: Basis,
+    flat: np.ndarray,
+) -> np.ndarray:
+    """Flat colour scaled by the diffuse term for one arrow facet."""
+    right, up, view_dir = basis
+    cam = np.array([world_normal @ right, world_normal @ up, world_normal @ view_dir])
+    return np.clip(flat * float(_diffuse_intensity(cam)), 0.0, 1.0)
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 8509ec4c5..4a8ceed06 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -10,17 +10,21 @@
 import json
 import pathlib
 import uuid
+from typing import TYPE_CHECKING
 
 from jinja2 import Environment
 from jinja2 import PackageLoader
+from jinja2 import select_autoescape
 
 from easydiffraction.display.structure.assets.colors import color_for
 from easydiffraction.display.structure.assets.colors import theme_colors
 from easydiffraction.display.structure.enums import ColorSchemeEnum
 from easydiffraction.display.structure.renderers.base import StructureRendererBase
-from easydiffraction.display.structure.scene import StructureScene
 from easydiffraction.utils._vendored.theme_detect import is_dark
 
+if TYPE_CHECKING:
+    from easydiffraction.display.structure.scene import StructureScene
+
 _VENDOR = pathlib.Path(__file__).parent / 'vendor' / 'threejs'
 _CDN = 'https://cdn.jsdelivr.net/npm/three@0.160.0'
 _ADDON_CONTROLS = 'three/addons/controls/OrbitControls.js'
@@ -31,7 +35,11 @@ def _environment() -> Environment:
     """Return the Jinja environment for structure-view templates."""
     return Environment(
         loader=PackageLoader('easydiffraction.display.structure', 'templates'),
-        autoescape=False,
+        autoescape=select_autoescape(
+            enabled_extensions=(),
+            default_for_string=False,
+            default=False,
+        ),
         trim_blocks=True,
         lstrip_blocks=True,
     )
@@ -71,8 +79,13 @@ def _scene_payload(scene: StructureScene) -> dict:
         edges = [{'start': edge.start, 'end': edge.end} for edge in scene.cell_edges.edges]
     return {
         'atoms': [
-            {'centre': a.centre, 'radius': a.radius, 'colour': a.colour, 'label': a.label,
-             'asymmetric': a.asymmetric}
+            {
+                'centre': a.centre,
+                'radius': a.radius,
+                'colour': a.colour,
+                'label': a.label,
+                'asymmetric': a.asymmetric,
+            }
             for a in scene.atoms
         ],
         'wedgeSpheres': [
@@ -113,8 +126,9 @@ def _scene_payload(scene: StructureScene) -> dict:
         'labels': [{'anchor': label.anchor, 'text': label.text} for label in scene.labels],
         'legend': [{'symbol': entry.symbol, 'colour': entry.colour} for entry in scene.legend],
         'palettes': {
-            scheme.value: {entry.symbol: color_for(entry.symbol, scheme.value)
-                           for entry in scene.legend}
+            scheme.value: {
+                entry.symbol: color_for(entry.symbol, scheme.value) for entry in scene.legend
+            }
             for scheme in ColorSchemeEnum
         },
     }
diff --git a/src/easydiffraction/display/structure/scene.py b/src/easydiffraction/display/structure/scene.py
index 6177ac5a1..ca2a88bbc 100644
--- a/src/easydiffraction/display/structure/scene.py
+++ b/src/easydiffraction/display/structure/scene.py
@@ -14,7 +14,7 @@
 
 from dataclasses import dataclass
 
-# Plain, serialisable coordinate/colour aliases (no numpy, no domain types).
+# Plain, serialisable coordinate/colour aliases (no numpy, no domain).
 Vec3 = tuple[float, float, float]
 Rgb = tuple[int, int, int]
 Mat3 = tuple[Vec3, Vec3, Vec3]
diff --git a/src/easydiffraction/display/structure/viewing.py b/src/easydiffraction/display/structure/viewing.py
index 3f89235b9..7548f2ef8 100644
--- a/src/easydiffraction/display/structure/viewing.py
+++ b/src/easydiffraction/display/structure/viewing.py
@@ -4,12 +4,16 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from easydiffraction.display.base import RendererBase
 from easydiffraction.display.base import RendererFactoryBase
 from easydiffraction.display.structure.enums import ViewerEngineEnum
 from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
 from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
-from easydiffraction.display.structure.scene import StructureScene
+
+if TYPE_CHECKING:
+    from easydiffraction.display.structure.scene import StructureScene
 
 
 class ViewerFactory(RendererFactoryBase):

From ce8530269d7474b6b61e79cdb0920f4fd5bf190f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:36:43 +0200
Subject: [PATCH 100/160] Annotate project view categories and config for lint

---
 .../rendering_structure/__init__.py           |  4 +-
 .../categories/rendering_structure/default.py | 21 +++-----
 .../categories/structure_style/default.py     | 18 ++-----
 .../categories/structure_view/default.py      | 51 ++++++++++++++++---
 src/easydiffraction/project/display.py        | 24 ++++++---
 src/easydiffraction/project/project.py        |  6 +--
 src/easydiffraction/project/project_config.py | 24 +++++----
 7 files changed, 91 insertions(+), 57 deletions(-)

diff --git a/src/easydiffraction/project/categories/rendering_structure/__init__.py b/src/easydiffraction/project/categories/rendering_structure/__init__.py
index 6ecfff1ee..228378d45 100644
--- a/src/easydiffraction/project/categories/rendering_structure/__init__.py
+++ b/src/easydiffraction/project/categories/rendering_structure/__init__.py
@@ -5,4 +5,6 @@
 from __future__ import annotations
 
 from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
-from easydiffraction.project.categories.rendering_structure.factory import RenderingStructureFactory
+from easydiffraction.project.categories.rendering_structure.factory import (
+    RenderingStructureFactory,
+)
diff --git a/src/easydiffraction/project/categories/rendering_structure/default.py b/src/easydiffraction/project/categories/rendering_structure/default.py
index 93cfb4b6d..5a59ec7d4 100644
--- a/src/easydiffraction/project/categories/rendering_structure/default.py
+++ b/src/easydiffraction/project/categories/rendering_structure/default.py
@@ -1,9 +1,6 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
-"""
-Project structure-rendering_structure category (switchable renderer
-engine).
-"""
+"""Project rendering_structure category (switchable renderer engine)."""
 
 from __future__ import annotations
 
@@ -18,7 +15,9 @@
 from easydiffraction.display.structure.viewing import ViewerFactory
 from easydiffraction.io.cif.handler import CifHandler
 from easydiffraction.io.cif.parse import read_cif_str
-from easydiffraction.project.categories.rendering_structure.factory import RenderingStructureFactory
+from easydiffraction.project.categories.rendering_structure.factory import (
+    RenderingStructureFactory,
+)
 from easydiffraction.utils.logging import log
 
 AUTO_ENGINE = 'auto'
@@ -62,7 +61,8 @@ def _resolved_engine(value: str) -> str:
     def _set_type(self, value: str, *, strict: bool = True) -> None:
         if value not in VIEW_ENGINE_OPTIONS:
             msg = (
-                f"Unsupported rendering_structure type '{value}'. Supported: {VIEW_ENGINE_OPTIONS}. "
+                f"Unsupported rendering_structure type '{value}'. "
+                f'Supported: {VIEW_ENGINE_OPTIONS}. '
                 f"For more information, use 'rendering_structure.show_supported()'"
             )
             if strict:
@@ -86,10 +86,7 @@ def viewer(self) -> Viewer:
         return self._viewer
 
     def from_cif(self, block: object, idx: int = 0) -> None:
-        """
-        Populate this rendering_structure category from a CIF block,
-        rebinding engine.
-        """
+        """Populate this category from a CIF block, rebinding engine."""
         super().from_cif(block, idx)
         view_type = read_cif_str(block, '_rendering_structure.type')
         if view_type is not None:
@@ -97,7 +94,5 @@ def from_cif(self, block: object, idx: int = 0) -> None:
 
     @property
     def as_cif(self) -> str:
-        """
-        Return CIF representation of this rendering_structure category.
-        """
+        """Return the CIF text for this rendering_structure category."""
         return super().as_cif
diff --git a/src/easydiffraction/project/categories/structure_style/default.py b/src/easydiffraction/project/categories/structure_style/default.py
index 0df781bde..10ec8ac5f 100644
--- a/src/easydiffraction/project/categories/structure_style/default.py
+++ b/src/easydiffraction/project/categories/structure_style/default.py
@@ -65,10 +65,7 @@ def __init__(self) -> None:
 
     @property
     def atom_view(self) -> EnumDescriptor:
-        """
-        How atoms are sized/shaped
-        (``vdw``/``covalent``/``ionic``/``adp``).
-        """
+        """How atoms are sized/shaped (vdw/covalent/ionic/adp)."""
         return self._atom_view
 
     @atom_view.setter
@@ -86,9 +83,7 @@ def color_scheme(self, value: str) -> None:
 
     @property
     def adp_probability(self) -> NumericDescriptor:
-        """
-        ORTEP probability level (fraction in the open interval (0, 1)).
-        """
+        """ORTEP probability level (fraction in interval (0, 1))."""
         return self._adp_probability
 
     @adp_probability.setter
@@ -97,10 +92,7 @@ def adp_probability(self, value: float) -> None:
 
     @property
     def atom_scale(self) -> NumericDescriptor:
-        """
-        Overall ball-atom size factor in (0, 1] (square-root
-        compressed).
-        """
+        """Overall ball-atom size factor in (0, 1] (sqrt compressed)."""
         return self._atom_scale
 
     @atom_scale.setter
@@ -109,7 +101,5 @@ def atom_scale(self, value: float) -> None:
 
     @property
     def as_cif(self) -> str:
-        """
-        Return CIF representation of this structure_style category.
-        """
+        """Return CIF text for this structure_style category."""
         return super().as_cif
diff --git a/src/easydiffraction/project/categories/structure_view/default.py b/src/easydiffraction/project/categories/structure_view/default.py
index 1c22ba2f1..bf8ef46a4 100644
--- a/src/easydiffraction/project/categories/structure_view/default.py
+++ b/src/easydiffraction/project/categories/structure_view/default.py
@@ -76,7 +76,14 @@ def show_moments(self) -> BoolDescriptor:
     def show_moments(self, value: bool) -> None:
         self._show_moments.value = value
 
-    def _set_bound(self, descriptor: NumericDescriptor, value: float, *, lower: float, upper: float) -> None:
+    @staticmethod
+    def _set_bound(
+        descriptor: NumericDescriptor,
+        value: float,
+        *,
+        lower: float,
+        upper: float,
+    ) -> None:
         if not lower < value < upper:
             log.warning(
                 f"'{descriptor.name}' = {value} violates min < max on its axis; ignored.",
@@ -91,7 +98,12 @@ def range_a_min(self) -> NumericDescriptor:
 
     @range_a_min.setter
     def range_a_min(self, value: float) -> None:
-        self._set_bound(self._range_a_min, value, lower=float('-inf'), upper=self._range_a_max.value)
+        self._set_bound(
+            self._range_a_min,
+            value,
+            lower=float('-inf'),
+            upper=self._range_a_max.value,
+        )
 
     @property
     def range_a_max(self) -> NumericDescriptor:
@@ -100,7 +112,12 @@ def range_a_max(self) -> NumericDescriptor:
 
     @range_a_max.setter
     def range_a_max(self, value: float) -> None:
-        self._set_bound(self._range_a_max, value, lower=self._range_a_min.value, upper=float('inf'))
+        self._set_bound(
+            self._range_a_max,
+            value,
+            lower=self._range_a_min.value,
+            upper=float('inf'),
+        )
 
     @property
     def range_b_min(self) -> NumericDescriptor:
@@ -109,7 +126,12 @@ def range_b_min(self) -> NumericDescriptor:
 
     @range_b_min.setter
     def range_b_min(self, value: float) -> None:
-        self._set_bound(self._range_b_min, value, lower=float('-inf'), upper=self._range_b_max.value)
+        self._set_bound(
+            self._range_b_min,
+            value,
+            lower=float('-inf'),
+            upper=self._range_b_max.value,
+        )
 
     @property
     def range_b_max(self) -> NumericDescriptor:
@@ -118,7 +140,12 @@ def range_b_max(self) -> NumericDescriptor:
 
     @range_b_max.setter
     def range_b_max(self, value: float) -> None:
-        self._set_bound(self._range_b_max, value, lower=self._range_b_min.value, upper=float('inf'))
+        self._set_bound(
+            self._range_b_max,
+            value,
+            lower=self._range_b_min.value,
+            upper=float('inf'),
+        )
 
     @property
     def range_c_min(self) -> NumericDescriptor:
@@ -127,7 +154,12 @@ def range_c_min(self) -> NumericDescriptor:
 
     @range_c_min.setter
     def range_c_min(self, value: float) -> None:
-        self._set_bound(self._range_c_min, value, lower=float('-inf'), upper=self._range_c_max.value)
+        self._set_bound(
+            self._range_c_min,
+            value,
+            lower=float('-inf'),
+            upper=self._range_c_max.value,
+        )
 
     @property
     def range_c_max(self) -> NumericDescriptor:
@@ -136,7 +168,12 @@ def range_c_max(self) -> NumericDescriptor:
 
     @range_c_max.setter
     def range_c_max(self, value: float) -> None:
-        self._set_bound(self._range_c_max, value, lower=self._range_c_min.value, upper=float('inf'))
+        self._set_bound(
+            self._range_c_max,
+            value,
+            lower=self._range_c_min.value,
+            upper=float('inf'),
+        )
 
     def view_range(self) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
         """
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index ccf430927..3b87c27d8 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -27,6 +27,9 @@
     from easydiffraction.project.project import Project
 
 
+StructureViewRange = tuple[tuple[float, float], tuple[float, float], tuple[float, float]]
+
+
 _PATTERN_OPTION_DESCRIPTIONS: dict[str, str] = {
     'auto': 'Show the most informative available pattern view.',
     'measured': 'Measured diffraction intensities.',
@@ -474,7 +477,7 @@ def structure(
         self,
         struct_name: str,
         include: str | tuple[str, ...] = 'auto',
-        range: tuple[tuple[float, float], tuple[float, float], tuple[float, float]] | None = None,
+        range: StructureViewRange | None = None,
         path: str | None = None,
     ) -> None:
         """
@@ -495,7 +498,7 @@ def structure(
             flags, then built-in defaults; an explicit tuple of
             ``atoms``/``bonds``/``cell``/``axes``/
             ``moments``/``labels`` wins outright.
-        range : tuple[tuple[float, float], tuple[float, float], tuple[float, float]] | None, default=None
+        range : StructureViewRange | None, default=None
             Optional per-axis ``((min, max), ...)`` window overriding
             the persisted ``project.rendering_structure`` range for this
             call only.
@@ -510,7 +513,9 @@ def structure(
         )
 
         structure = self._project.structures[struct_name]
-        availability = structure_feature_availability(structure, style=self._project.structure_style)
+        availability = structure_feature_availability(
+            structure, style=self._project.structure_style
+        )
         features = self._resolve_structure_features(include, availability)
         window = range if range is not None else self._project.structure_view.view_range()
         scene = build_scene(
@@ -523,7 +528,7 @@ def structure(
         if path is not None:
             import pathlib  # noqa: PLC0415
 
-            pathlib.Path(path).write_text(output)
+            pathlib.Path(path).write_text(output, encoding='utf-8')
             return
         console.paragraph(f"Structure 🧩 '{struct_name}'")
         self._emit_structure_output(output)
@@ -537,7 +542,9 @@ def show_structure_options(self, struct_name: str) -> None:
         )
 
         structure = self._project.structures[struct_name]
-        availability = structure_feature_availability(structure, style=self._project.structure_style)
+        availability = structure_feature_availability(
+            structure, style=self._project.structure_style
+        )
         supported = self._project.rendering_structure.viewer.supported_features()
         auto = self._resolve_structure_features('auto', availability)
 
@@ -615,9 +622,10 @@ def _emit_structure_output(self, output: str) -> None:
         from easydiffraction.utils.environment import in_jupyter  # noqa: PLC0415
 
         if self._project.rendering_structure.viewer.engine == ViewerEngineEnum.ASCII.value:
-            # Built-in print preserves the renderer's raw ANSI colour codes
-            # (Jupyter and terminals interpret them); Rich's console.print
-            # would escape and garble them. Mirrors the ASCII pattern plotter.
+            # Built-in print keeps the renderer's raw ANSI colour
+            # codes (Jupyter and terminals interpret them); Rich's
+            # console.print would escape and garble them. Mirrors
+            # the ASCII pattern plotter.
             print(output)
             return
         if in_jupyter():
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index a2b71160e..66b80e973 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -37,11 +37,11 @@
     from collections.abc import Callable
 
     from easydiffraction.project.categories.rendering_plot import RenderingPlot
-    from easydiffraction.project.categories.rendering_table import RenderingTable
-    from easydiffraction.project.categories.verbosity import Verbosity
     from easydiffraction.project.categories.rendering_structure import RenderingStructure
-    from easydiffraction.project.categories.structure_view import StructureView
+    from easydiffraction.project.categories.rendering_table import RenderingTable
     from easydiffraction.project.categories.structure_style import StructureStyle
+    from easydiffraction.project.categories.structure_view import StructureView
+    from easydiffraction.project.categories.verbosity import Verbosity
     from easydiffraction.project.project_info import ProjectInfo
     from easydiffraction.report import Report
 
diff --git a/src/easydiffraction/project/project_config.py b/src/easydiffraction/project/project_config.py
index 36384887e..a8f13af08 100644
--- a/src/easydiffraction/project/project_config.py
+++ b/src/easydiffraction/project/project_config.py
@@ -5,22 +5,22 @@
 from __future__ import annotations
 
 from easydiffraction.core.category_owner import CategoryOwner
-from easydiffraction.project.categories.rendering_plot import RenderingPlot
-from easydiffraction.project.categories.rendering_plot import RenderingPlotFactory
 from easydiffraction.project.categories.info import ProjectInfo
 from easydiffraction.project.categories.info import ProjectInfoFactory
-from easydiffraction.project.categories.report import Report
-from easydiffraction.project.categories.report import ReportFactory
-from easydiffraction.project.categories.rendering_table import RenderingTable
-from easydiffraction.project.categories.rendering_table import RenderingTableFactory
-from easydiffraction.project.categories.verbosity import Verbosity
-from easydiffraction.project.categories.verbosity import VerbosityFactory
+from easydiffraction.project.categories.rendering_plot import RenderingPlot
+from easydiffraction.project.categories.rendering_plot import RenderingPlotFactory
 from easydiffraction.project.categories.rendering_structure import RenderingStructure
 from easydiffraction.project.categories.rendering_structure import RenderingStructureFactory
-from easydiffraction.project.categories.structure_view import StructureView
-from easydiffraction.project.categories.structure_view import StructureViewFactory
+from easydiffraction.project.categories.rendering_table import RenderingTable
+from easydiffraction.project.categories.rendering_table import RenderingTableFactory
+from easydiffraction.project.categories.report import Report
+from easydiffraction.project.categories.report import ReportFactory
 from easydiffraction.project.categories.structure_style import StructureStyle
 from easydiffraction.project.categories.structure_style import StructureStyleFactory
+from easydiffraction.project.categories.structure_view import StructureView
+from easydiffraction.project.categories.structure_view import StructureViewFactory
+from easydiffraction.project.categories.verbosity import Verbosity
+from easydiffraction.project.categories.verbosity import VerbosityFactory
 
 
 class ProjectConfig(CategoryOwner):
@@ -43,7 +43,9 @@ def __init__(
         self._report = ReportFactory.create(ReportFactory.default_tag())
         self._rendering_table = RenderingTableFactory.create(RenderingTableFactory.default_tag())
         self._verbosity = VerbosityFactory.create(VerbosityFactory.default_tag())
-        self._rendering_structure = RenderingStructureFactory.create(RenderingStructureFactory.default_tag())
+        self._rendering_structure = RenderingStructureFactory.create(
+            RenderingStructureFactory.default_tag()
+        )
         self._structure_view = StructureViewFactory.create(StructureViewFactory.default_tag())
         self._structure_style = StructureStyleFactory.create(StructureStyleFactory.default_tag())
 

From 19575fc24a2fbc34097c2597cab155d387c48e9e Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:36:51 +0200
Subject: [PATCH 101/160] Add unit tests for structure display and view
 categories

---
 .../structure/categories/geom/test_default.py | 250 +++++++
 .../structure/categories/geom/test_factory.py | 112 +++
 .../display/structure/assets/test_colors.py   | 194 +++++
 .../display/structure/assets/test_elements.py | 221 ++++++
 .../display/structure/assets/test_radii.py    | 174 +++++
 .../display/structure/renderers/test_ascii.py | 547 ++++++++++++++
 .../display/structure/renderers/test_base.py  | 199 +++++
 .../structure/renderers/test_raster.py        | 388 ++++++++++
 .../display/structure/test_builder.py         | 688 ++++++++++++++++++
 .../display/structure/test_enums.py           | 162 +++++
 .../display/structure/test_scene.py           | 511 +++++++++++++
 .../display/structure/test_viewing.py         | 296 ++++++++
 .../rendering_structure/test_default.py       | 394 ++++++++++
 .../rendering_structure/test_factory.py       | 113 +++
 .../structure_style/test_default.py           | 387 ++++++++++
 .../structure_style/test_factory.py           | 334 +++++++++
 .../categories/structure_view/test_default.py | 359 +++++++++
 .../categories/structure_view/test_factory.py | 113 +++
 18 files changed, 5442 insertions(+)
 create mode 100644 tests/unit/easydiffraction/datablocks/structure/categories/geom/test_default.py
 create mode 100644 tests/unit/easydiffraction/datablocks/structure/categories/geom/test_factory.py
 create mode 100644 tests/unit/easydiffraction/display/structure/assets/test_colors.py
 create mode 100644 tests/unit/easydiffraction/display/structure/assets/test_elements.py
 create mode 100644 tests/unit/easydiffraction/display/structure/assets/test_radii.py
 create mode 100644 tests/unit/easydiffraction/display/structure/renderers/test_ascii.py
 create mode 100644 tests/unit/easydiffraction/display/structure/renderers/test_base.py
 create mode 100644 tests/unit/easydiffraction/display/structure/renderers/test_raster.py
 create mode 100644 tests/unit/easydiffraction/display/structure/test_builder.py
 create mode 100644 tests/unit/easydiffraction/display/structure/test_enums.py
 create mode 100644 tests/unit/easydiffraction/display/structure/test_scene.py
 create mode 100644 tests/unit/easydiffraction/display/structure/test_viewing.py
 create mode 100644 tests/unit/easydiffraction/project/categories/rendering_structure/test_default.py
 create mode 100644 tests/unit/easydiffraction/project/categories/rendering_structure/test_factory.py
 create mode 100644 tests/unit/easydiffraction/project/categories/structure_style/test_default.py
 create mode 100644 tests/unit/easydiffraction/project/categories/structure_style/test_factory.py
 create mode 100644 tests/unit/easydiffraction/project/categories/structure_view/test_default.py
 create mode 100644 tests/unit/easydiffraction/project/categories/structure_view/test_factory.py

diff --git a/tests/unit/easydiffraction/datablocks/structure/categories/geom/test_default.py b/tests/unit/easydiffraction/datablocks/structure/categories/geom/test_default.py
new file mode 100644
index 000000000..e8e514cce
--- /dev/null
+++ b/tests/unit/easydiffraction/datablocks/structure/categories/geom/test_default.py
@@ -0,0 +1,250 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the geom category default module (Geom)."""
+
+from __future__ import annotations
+
+import pytest
+
+from easydiffraction.core.category import CategoryItem
+from easydiffraction.core.metadata import TypeInfo
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.datablocks.structure.categories.geom.default import Geom
+from easydiffraction.utils.logging import Logger
+
+
+def test_module_import():
+    import easydiffraction.datablocks.structure.categories.geom.default as MUT
+
+    expected_module_name = 'easydiffraction.datablocks.structure.categories.geom.default'
+    assert MUT.__name__ == expected_module_name
+
+
+# ----------------------------------------------------------------------
+#  Class-level metadata
+# ----------------------------------------------------------------------
+
+
+class TestGeomClass:
+    def test_is_category_item_subclass(self):
+        assert issubclass(Geom, CategoryItem)
+
+    def test_category_code(self):
+        assert Geom._category_code == 'geom'
+
+    def test_type_info_is_type_info(self):
+        assert isinstance(Geom.type_info, TypeInfo)
+
+    def test_type_info_tag(self):
+        assert Geom.type_info.tag == 'default'
+
+    def test_type_info_description(self):
+        assert Geom.type_info.description == 'Structure bond-geometry cutoffs'
+
+
+# ----------------------------------------------------------------------
+#  Construction and defaults
+# ----------------------------------------------------------------------
+
+
+class TestGeomConstruction:
+    def test_instantiation(self):
+        geom = Geom()
+        assert geom is not None
+
+    def test_instantiation_returns_fresh_instances(self):
+        first = Geom()
+        second = Geom()
+        assert first is not second
+
+    def test_identity_category_code(self):
+        geom = Geom()
+        assert geom._identity.category_code == 'geom'
+
+    def test_min_bond_distance_cutoff_is_numeric_descriptor(self):
+        geom = Geom()
+        assert isinstance(geom.min_bond_distance_cutoff, NumericDescriptor)
+
+    def test_bond_distance_incr_is_numeric_descriptor(self):
+        geom = Geom()
+        assert isinstance(geom.bond_distance_incr, NumericDescriptor)
+
+    def test_default_min_bond_distance_cutoff(self):
+        geom = Geom()
+        assert geom.min_bond_distance_cutoff.value == 0.0
+
+    def test_default_bond_distance_incr(self):
+        geom = Geom()
+        assert geom.bond_distance_incr.value == 0.25
+
+    def test_descriptor_names(self):
+        geom = Geom()
+        assert geom.min_bond_distance_cutoff.name == 'min_bond_distance_cutoff'
+        assert geom.bond_distance_incr.name == 'bond_distance_incr'
+
+    def test_descriptor_descriptions(self):
+        geom = Geom()
+        assert geom.min_bond_distance_cutoff.description == (
+            'Minimum permitted bonded distance (angstrom).'
+        )
+        assert geom.bond_distance_incr.description == (
+            'Increment added to the summed bonding radii (angstrom).'
+        )
+
+    def test_parameters_lists_both_descriptors(self):
+        geom = Geom()
+        names = {p.name for p in geom.parameters}
+        assert names == {'min_bond_distance_cutoff', 'bond_distance_incr'}
+
+
+# ----------------------------------------------------------------------
+#  CIF handler names (cif_core ``_geom``)
+# ----------------------------------------------------------------------
+
+
+class TestGeomCifHandlers:
+    def test_min_bond_distance_cutoff_cif_name(self):
+        geom = Geom()
+        assert geom.min_bond_distance_cutoff._cif_handler.names == [
+            '_geom.min_bond_distance_cutoff',
+        ]
+
+    def test_bond_distance_incr_cif_name(self):
+        geom = Geom()
+        assert geom.bond_distance_incr._cif_handler.names == [
+            '_geom.bond_distance_incr',
+        ]
+
+
+# ----------------------------------------------------------------------
+#  Setters — valid values
+# ----------------------------------------------------------------------
+
+
+class TestGeomSettersValid:
+    def test_set_min_bond_distance_cutoff(self):
+        geom = Geom()
+        geom.min_bond_distance_cutoff = 0.5
+        assert geom.min_bond_distance_cutoff.value == 0.5
+
+    def test_set_bond_distance_incr(self):
+        geom = Geom()
+        geom.bond_distance_incr = 0.4
+        assert geom.bond_distance_incr.value == 0.4
+
+    def test_set_min_bond_distance_cutoff_to_zero_boundary(self):
+        # The validator allows ge=0.0, so the lower boundary is valid.
+        geom = Geom()
+        geom.min_bond_distance_cutoff = 1.0
+        geom.min_bond_distance_cutoff = 0.0
+        assert geom.min_bond_distance_cutoff.value == 0.0
+
+    def test_set_bond_distance_incr_to_zero_boundary(self):
+        geom = Geom()
+        geom.bond_distance_incr = 0.0
+        assert geom.bond_distance_incr.value == 0.0
+
+    def test_set_min_bond_distance_cutoff_accepts_int(self):
+        geom = Geom()
+        geom.min_bond_distance_cutoff = 2
+        assert geom.min_bond_distance_cutoff.value == 2
+
+
+# ----------------------------------------------------------------------
+#  Setters — invalid values
+#
+#  RangeValidator routes out-of-range values through
+#  ``Diagnostics.range_mismatch`` -> ``log.error(..., exc_type=TypeError)``.
+#  In RAISE mode this raises ``TypeError``; in WARN mode the current
+#  value is kept.  Tests pin the Logger reaction with monkeypatch so they
+#  do not depend on global logger state leaked by other tests.
+# ----------------------------------------------------------------------
+
+
+class TestGeomSettersInvalid:
+    def test_negative_min_bond_distance_cutoff_raises_in_raise_mode(self, monkeypatch):
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        geom = Geom()
+        with pytest.raises(TypeError):
+            geom.min_bond_distance_cutoff = -1.0
+
+    def test_negative_bond_distance_incr_raises_in_raise_mode(self, monkeypatch):
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        geom = Geom()
+        with pytest.raises(TypeError):
+            geom.bond_distance_incr = -0.5
+
+    def test_negative_min_bond_distance_cutoff_kept_in_warn_mode(self, monkeypatch):
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+        geom = Geom()
+        geom.min_bond_distance_cutoff = -1.0
+        # The out-of-range write is rejected; the default is retained.
+        assert geom.min_bond_distance_cutoff.value == 0.0
+
+    def test_negative_bond_distance_incr_kept_in_warn_mode(self, monkeypatch):
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+        geom = Geom()
+        geom.bond_distance_incr = -0.5
+        assert geom.bond_distance_incr.value == 0.25
+
+    def test_wrong_type_min_bond_distance_cutoff_kept_in_warn_mode(self, monkeypatch):
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+        geom = Geom()
+        geom.min_bond_distance_cutoff = 'not-a-number'
+        assert geom.min_bond_distance_cutoff.value == 0.0
+
+    def test_wrong_type_bond_distance_incr_raises_in_raise_mode(self, monkeypatch):
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        geom = Geom()
+        with pytest.raises(TypeError):
+            geom.bond_distance_incr = 'not-a-number'
+
+
+# ----------------------------------------------------------------------
+#  CIF serialisation and round-trip
+# ----------------------------------------------------------------------
+
+
+class TestGeomAsCif:
+    def test_as_cif_is_string(self):
+        geom = Geom()
+        assert isinstance(geom.as_cif, str)
+
+    def test_as_cif_contains_both_tags(self):
+        geom = Geom()
+        cif = geom.as_cif
+        assert '_geom.min_bond_distance_cutoff' in cif
+        assert '_geom.bond_distance_incr' in cif
+
+    def test_as_cif_default_lines(self):
+        geom = Geom()
+        lines = geom.as_cif.splitlines()
+        assert lines == [
+            '_geom.min_bond_distance_cutoff 0.',
+            '_geom.bond_distance_incr 0.25',
+        ]
+
+    def test_as_cif_reflects_updated_values(self):
+        geom = Geom()
+        geom.min_bond_distance_cutoff = 0.8
+        geom.bond_distance_incr = 0.3
+        cif = geom.as_cif
+        assert '_geom.min_bond_distance_cutoff 0.8' in cif
+        assert '_geom.bond_distance_incr 0.3' in cif
+
+    def test_from_cif_round_trip(self):
+        import gemmi
+
+        # All values are in range, so no validation error is triggered;
+        # the round-trip is independent of the global Logger reaction.
+        source = Geom()
+        source.min_bond_distance_cutoff = 0.6
+        source.bond_distance_incr = 0.45
+
+        block = gemmi.cif.read_string(f'data_test\n\n{source.as_cif}\n').sole_block()
+
+        restored = Geom()
+        restored.from_cif(block)
+
+        assert restored.min_bond_distance_cutoff.value == 0.6
+        assert restored.bond_distance_incr.value == 0.45
diff --git a/tests/unit/easydiffraction/datablocks/structure/categories/geom/test_factory.py b/tests/unit/easydiffraction/datablocks/structure/categories/geom/test_factory.py
new file mode 100644
index 000000000..f023c2d7e
--- /dev/null
+++ b/tests/unit/easydiffraction/datablocks/structure/categories/geom/test_factory.py
@@ -0,0 +1,112 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the geom category factory."""
+
+from __future__ import annotations
+
+import pytest
+
+from easydiffraction.core.factory import FactoryBase
+from easydiffraction.datablocks.structure.categories.geom.default import Geom
+from easydiffraction.datablocks.structure.categories.geom.factory import GeomFactory
+
+
+def test_module_import():
+    import easydiffraction.datablocks.structure.categories.geom.factory as MUT
+
+    expected_module_name = 'easydiffraction.datablocks.structure.categories.geom.factory'
+    assert MUT.__name__ == expected_module_name
+
+
+class TestGeomFactoryClass:
+    def test_is_factory_base_subclass(self):
+        assert issubclass(GeomFactory, FactoryBase)
+
+    def test_default_rules_universal_fallback(self):
+        # The only rule is the universal (empty-condition) fallback.
+        assert GeomFactory._default_rules == {frozenset(): 'default'}
+
+    def test_registry_is_independent_from_base(self):
+        # __init_subclass__ gives each subclass its own registry list.
+        assert GeomFactory._registry is not FactoryBase._registry
+
+    def test_geom_is_registered(self):
+        assert Geom in GeomFactory._registry
+
+
+class TestSupportedTags:
+    def test_supported_tags_returns_list(self):
+        tags = GeomFactory.supported_tags()
+        assert isinstance(tags, list)
+
+    def test_default_tag_is_supported(self):
+        assert 'default' in GeomFactory.supported_tags()
+
+    def test_supported_map_links_tag_to_class(self):
+        supported = GeomFactory._supported_map()
+        assert supported['default'] is Geom
+
+
+class TestDefaultTag:
+    def test_default_tag_no_conditions(self):
+        assert GeomFactory.default_tag() == 'default'
+
+    def test_default_tag_ignores_extra_conditions(self):
+        # The universal fallback still wins for unrelated conditions.
+        assert GeomFactory.default_tag(scattering_type='bragg') == 'default'
+
+
+class TestCreate:
+    def test_create_default_returns_geom(self):
+        obj = GeomFactory.create('default')
+        assert isinstance(obj, Geom)
+
+    def test_create_returns_fresh_instances(self):
+        first = GeomFactory.create('default')
+        second = GeomFactory.create('default')
+        assert first is not second
+
+    def test_create_unknown_tag_raises_value_error(self):
+        with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
+            GeomFactory.create('missing')
+
+    def test_create_default_has_expected_defaults(self):
+        geom = GeomFactory.create('default')
+        assert geom.min_bond_distance_cutoff.value == 0.0
+        assert geom.bond_distance_incr.value == 0.25
+
+
+class TestCreateDefaultFor:
+    def test_create_default_for_no_conditions(self):
+        obj = GeomFactory.create_default_for()
+        assert isinstance(obj, Geom)
+
+
+class TestSupportedFor:
+    def test_supported_for_no_filters_includes_geom(self):
+        result = GeomFactory.supported_for()
+        assert Geom in result
+
+    def test_supported_for_calculator_filter_does_not_exclude(self):
+        # Geom declares no calculator_support, so the filter cannot
+        # exclude it.
+        result = GeomFactory.supported_for(calculator='cryspy')
+        assert Geom in result
+
+    def test_supported_for_sample_form_filter_does_not_exclude(self):
+        # Geom declares no compatibility, so axis filters cannot
+        # exclude it.
+        result = GeomFactory.supported_for(sample_form='powder')
+        assert Geom in result
+
+
+class TestShowSupported:
+    def test_show_supported_prints_table(self, capsys):
+        GeomFactory.show_supported()
+        out = capsys.readouterr().out
+        assert 'Supported types' in out
+
+    def test_show_supported_lists_default_tag(self, capsys):
+        GeomFactory.show_supported()
+        out = capsys.readouterr().out
+        assert 'default' in out
diff --git a/tests/unit/easydiffraction/display/structure/assets/test_colors.py b/tests/unit/easydiffraction/display/structure/assets/test_colors.py
new file mode 100644
index 000000000..31813c33d
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/assets/test_colors.py
@@ -0,0 +1,194 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the structure-view colour palette module."""
+
+from __future__ import annotations
+
+import pytest
+
+from easydiffraction.display.structure.assets import colors
+from easydiffraction.display.structure.assets.colors import AXIS_COLORS
+from easydiffraction.display.structure.assets.colors import DARK_THEME
+from easydiffraction.display.structure.assets.colors import DEFAULT_COLOR
+from easydiffraction.display.structure.assets.colors import LIGHT_THEME
+from easydiffraction.display.structure.assets.colors import VACANCY_COLOR
+from easydiffraction.display.structure.assets.colors import color_for
+from easydiffraction.display.structure.assets.colors import theme_colors
+from easydiffraction.display.structure.assets.elements import ELEMENT_COLORS
+
+
+def _is_rgb(value):
+    """Return True when value is an in-range 0-255 RGB triple."""
+    return (
+        isinstance(value, tuple)
+        and len(value) == 3
+        and all(isinstance(channel, int) for channel in value)
+        and all(0 <= channel <= 255 for channel in value)
+    )
+
+
+# ------------------------------------------------------------------
+#  Module surface
+# ------------------------------------------------------------------
+
+
+class TestModule:
+    def test_module_import(self):
+        expected_module_name = 'easydiffraction.display.structure.assets.colors'
+        assert colors.__name__ == expected_module_name
+
+    def test_public_callables_present(self):
+        assert callable(colors.color_for)
+        assert callable(colors.theme_colors)
+
+
+# ------------------------------------------------------------------
+#  Module-level constants
+# ------------------------------------------------------------------
+
+
+class TestConstants:
+    def test_default_color_value(self):
+        assert DEFAULT_COLOR == (255, 192, 203)
+
+    def test_default_color_is_rgb(self):
+        assert _is_rgb(DEFAULT_COLOR)
+
+    def test_vacancy_color_value(self):
+        assert VACANCY_COLOR == (210, 210, 210)
+
+    def test_vacancy_color_is_rgb(self):
+        assert _is_rgb(VACANCY_COLOR)
+
+    def test_axis_colors_keys(self):
+        assert set(AXIS_COLORS) == {'a', 'b', 'c'}
+
+    def test_axis_colors_values(self):
+        assert AXIS_COLORS['a'] == (220, 40, 40)
+        assert AXIS_COLORS['b'] == (40, 180, 40)
+        assert AXIS_COLORS['c'] == (40, 80, 220)
+
+    def test_axis_colors_all_rgb(self):
+        assert all(_is_rgb(value) for value in AXIS_COLORS.values())
+
+    def test_axis_colors_red_green_blue_dominance(self):
+        # a=red, b=green, c=blue (VESTA convention): the named channel
+        # is the strongest component of each axis colour.
+        assert AXIS_COLORS['a'][0] == max(AXIS_COLORS['a'])
+        assert AXIS_COLORS['b'][1] == max(AXIS_COLORS['b'])
+        assert AXIS_COLORS['c'][2] == max(AXIS_COLORS['c'])
+
+    def test_light_theme_keys(self):
+        assert set(LIGHT_THEME) == {'background', 'foreground'}
+
+    def test_dark_theme_keys(self):
+        assert set(DARK_THEME) == {'background', 'foreground'}
+
+    def test_light_theme_values(self):
+        assert LIGHT_THEME['background'] == (255, 255, 255)
+        assert LIGHT_THEME['foreground'] == (33, 33, 33)
+
+    def test_dark_theme_values(self):
+        assert DARK_THEME['background'] == (20, 20, 24)
+        assert DARK_THEME['foreground'] == (235, 235, 235)
+
+    def test_theme_values_all_rgb(self):
+        for theme in (LIGHT_THEME, DARK_THEME):
+            assert all(_is_rgb(value) for value in theme.values())
+
+    def test_light_and_dark_backgrounds_differ(self):
+        assert LIGHT_THEME['background'] != DARK_THEME['background']
+
+    def test_rgb_type_alias(self):
+        assert colors.Rgb == tuple[int, int, int]
+
+
+# ------------------------------------------------------------------
+#  color_for
+# ------------------------------------------------------------------
+
+
+class TestColorFor:
+    def test_known_element_known_scheme_returns_scheme_color(self):
+        # Si has distinct jmol and vesta entries; requesting vesta must
+        # return the vesta value, not the jmol fallback.
+        assert color_for('Si', 'vesta') == (27, 59, 250)
+
+    def test_jmol_scheme_returns_jmol_color(self):
+        assert color_for('Si', 'jmol') == (240, 200, 160)
+
+    def test_scheme_colors_can_differ(self):
+        assert color_for('Si', 'jmol') != color_for('Si', 'vesta')
+
+    def test_returns_exact_palette_reference(self):
+        # The function returns the stored tuple, not a copy or recolour.
+        assert color_for('Fe', 'vesta') == ELEMENT_COLORS['Fe']['vesta']
+        assert color_for('Fe', 'jmol') == ELEMENT_COLORS['Fe']['jmol']
+
+    def test_unknown_scheme_falls_back_to_jmol(self):
+        # 'cpk' is not a stored scheme key, so the element's jmol colour
+        # is used as the fallback.
+        assert color_for('Fe', 'cpk') == ELEMENT_COLORS['Fe']['jmol']
+
+    def test_none_scheme_value_falls_back_to_jmol(self):
+        # Some heavy elements store vesta=None; requesting vesta must
+        # fall through to the jmol colour rather than return None.
+        element = next(el for el, data in ELEMENT_COLORS.items() if data.get('vesta') is None)
+        result = color_for(element, 'vesta')
+        assert result == ELEMENT_COLORS[element]['jmol']
+        assert result is not None
+
+    def test_unknown_element_returns_default(self):
+        assert color_for('Xx', 'jmol') == DEFAULT_COLOR
+
+    def test_unknown_element_returns_default_for_any_scheme(self):
+        assert color_for('Zz', 'vesta') == DEFAULT_COLOR
+
+    def test_empty_element_returns_default(self):
+        assert color_for('', 'jmol') == DEFAULT_COLOR
+
+    def test_case_sensitive_lookup(self):
+        # Symbols are stored title-cased; a lower-cased symbol is unknown.
+        assert color_for('fe', 'jmol') == DEFAULT_COLOR
+
+    @pytest.mark.parametrize('scheme', ['jmol', 'vesta'])
+    def test_all_elements_return_rgb(self, scheme):
+        for element in ELEMENT_COLORS:
+            assert _is_rgb(color_for(element, scheme))
+
+    def test_never_returns_none(self):
+        # Covers the `entry.get('jmol') or DEFAULT_COLOR` guard for every
+        # element under both schemes.
+        for element in ELEMENT_COLORS:
+            assert color_for(element, 'vesta') is not None
+            assert color_for(element, 'jmol') is not None
+
+
+# ------------------------------------------------------------------
+#  theme_colors
+# ------------------------------------------------------------------
+
+
+class TestThemeColors:
+    def test_dark_returns_dark_theme(self):
+        assert theme_colors(dark=True) == DARK_THEME
+
+    def test_light_returns_light_theme(self):
+        assert theme_colors(dark=False) == LIGHT_THEME
+
+    def test_dark_returns_module_dict_reference(self):
+        assert theme_colors(dark=True) is DARK_THEME
+
+    def test_light_returns_module_dict_reference(self):
+        assert theme_colors(dark=False) is LIGHT_THEME
+
+    def test_result_has_background_and_foreground(self):
+        result = theme_colors(dark=False)
+        assert set(result) == {'background', 'foreground'}
+
+    def test_dark_is_keyword_only(self):
+        # `dark` is a keyword-only parameter; passing it positionally
+        # is a TypeError.
+        dark_flag = True
+        with pytest.raises(TypeError):
+            theme_colors(dark_flag)
diff --git a/tests/unit/easydiffraction/display/structure/assets/test_elements.py b/tests/unit/easydiffraction/display/structure/assets/test_elements.py
new file mode 100644
index 000000000..559be523e
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/assets/test_elements.py
@@ -0,0 +1,221 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the bundled per-element radii and colour palettes."""
+
+from __future__ import annotations
+
+import easydiffraction.display.structure.assets.elements as elements_module
+from easydiffraction.display.structure.assets.elements import ELEMENT_COLORS
+from easydiffraction.display.structure.assets.elements import ELEMENT_RADII
+
+# Model/scheme keys every entry must carry, matching the consumers in
+# radii.py (radius_for) and colors.py (color_for).
+RADIUS_MODELS = ('vdw', 'covalent', 'ionic', 'atomic')
+COLOR_SCHEMES = ('jmol', 'vesta')
+
+
+def test_module_import():
+    expected_module_name = 'easydiffraction.display.structure.assets.elements'
+    actual_module_name = elements_module.__name__
+    assert expected_module_name == actual_module_name
+
+
+# ------------------------------------------------------------------
+#  ELEMENT_RADII — container shape
+# ------------------------------------------------------------------
+
+
+class TestElementRadiiContainer:
+    def test_is_dict(self):
+        assert isinstance(ELEMENT_RADII, dict)
+
+    def test_not_empty(self):
+        assert len(ELEMENT_RADII) > 0
+
+    def test_covers_full_periodic_table(self):
+        # Hydrogen through oganesson: 118 elements.
+        assert len(ELEMENT_RADII) == 118
+
+    def test_first_and_last_symbols(self):
+        symbols = list(ELEMENT_RADII)
+        assert symbols[0] == 'H'
+        assert symbols[-1] == 'Og'
+
+    def test_known_symbols_present(self):
+        for symbol in ('H', 'C', 'N', 'O', 'Fe', 'Si', 'U', 'Og'):
+            assert symbol in ELEMENT_RADII
+
+    def test_keys_are_titlecase_element_symbols(self):
+        for symbol in ELEMENT_RADII:
+            assert isinstance(symbol, str)
+            assert 1 <= len(symbol) <= 2
+            assert symbol[0].isupper()
+            assert symbol.istitle()
+
+
+# ------------------------------------------------------------------
+#  ELEMENT_RADII — per-entry contract
+# ------------------------------------------------------------------
+
+
+class TestElementRadiiEntries:
+    def test_every_entry_is_a_dict(self):
+        for entry in ELEMENT_RADII.values():
+            assert isinstance(entry, dict)
+
+    def test_every_entry_has_exactly_the_model_keys(self):
+        expected_keys = set(RADIUS_MODELS)
+        for symbol, entry in ELEMENT_RADII.items():
+            assert set(entry) == expected_keys, symbol
+
+    def test_values_are_float_or_none(self):
+        for symbol, entry in ELEMENT_RADII.items():
+            for model in RADIUS_MODELS:
+                value = entry[model]
+                assert value is None or isinstance(value, (int, float)), (symbol, model)
+
+    def test_non_none_values_are_positive(self):
+        for symbol, entry in ELEMENT_RADII.items():
+            for model in RADIUS_MODELS:
+                value = entry[model]
+                if value is not None:
+                    assert value > 0.0, (symbol, model)
+
+    def test_covalent_radius_always_present(self):
+        # radius_for() relies on covalent as the universal fallback, so
+        # no bundled element may have a None covalent radius.
+        for symbol, entry in ELEMENT_RADII.items():
+            assert entry['covalent'] is not None, symbol
+            assert entry['covalent'] > 0.0, symbol
+
+
+# ------------------------------------------------------------------
+#  ELEMENT_RADII — spot-checked known values
+# ------------------------------------------------------------------
+
+
+class TestElementRadiiKnownValues:
+    def test_hydrogen(self):
+        assert ELEMENT_RADII['H'] == {
+            'vdw': 1.1,
+            'covalent': 0.31,
+            'ionic': None,
+            'atomic': 0.25,
+        }
+
+    def test_iron(self):
+        assert ELEMENT_RADII['Fe'] == {
+            'vdw': 1.72,
+            'covalent': 1.32,
+            'ionic': 0.78,
+            'atomic': 1.4,
+        }
+
+    def test_helium_has_no_ionic_or_atomic(self):
+        assert ELEMENT_RADII['He']['ionic'] is None
+        assert ELEMENT_RADII['He']['atomic'] is None
+        assert ELEMENT_RADII['He']['covalent'] == 0.28
+
+
+# ------------------------------------------------------------------
+#  ELEMENT_COLORS — container shape
+# ------------------------------------------------------------------
+
+
+class TestElementColorsContainer:
+    def test_is_dict(self):
+        assert isinstance(ELEMENT_COLORS, dict)
+
+    def test_not_empty(self):
+        assert len(ELEMENT_COLORS) > 0
+
+    def test_covers_full_periodic_table(self):
+        assert len(ELEMENT_COLORS) == 118
+
+    def test_first_and_last_symbols(self):
+        symbols = list(ELEMENT_COLORS)
+        assert symbols[0] == 'H'
+        assert symbols[-1] == 'Og'
+
+    def test_keys_are_titlecase_element_symbols(self):
+        for symbol in ELEMENT_COLORS:
+            assert isinstance(symbol, str)
+            assert 1 <= len(symbol) <= 2
+            assert symbol[0].isupper()
+            assert symbol.istitle()
+
+
+# ------------------------------------------------------------------
+#  ELEMENT_COLORS — per-entry contract
+# ------------------------------------------------------------------
+
+
+def _assert_valid_rgb(value, context):
+    assert isinstance(value, tuple), context
+    assert len(value) == 3, context
+    for component in value:
+        assert isinstance(component, int), context
+        assert 0 <= component <= 255, context
+
+
+class TestElementColorsEntries:
+    def test_every_entry_is_a_dict(self):
+        for entry in ELEMENT_COLORS.values():
+            assert isinstance(entry, dict)
+
+    def test_every_entry_has_exactly_the_scheme_keys(self):
+        expected_keys = set(COLOR_SCHEMES)
+        for symbol, entry in ELEMENT_COLORS.items():
+            assert set(entry) == expected_keys, symbol
+
+    def test_jmol_always_present_and_valid_rgb(self):
+        # color_for() falls back to the jmol colour, so every element
+        # must have a usable jmol RGB triple.
+        for symbol, entry in ELEMENT_COLORS.items():
+            assert entry['jmol'] is not None, symbol
+            _assert_valid_rgb(entry['jmol'], symbol)
+
+    def test_vesta_is_rgb_or_none(self):
+        for symbol, entry in ELEMENT_COLORS.items():
+            value = entry['vesta']
+            if value is not None:
+                _assert_valid_rgb(value, symbol)
+
+
+# ------------------------------------------------------------------
+#  ELEMENT_COLORS — spot-checked known values
+# ------------------------------------------------------------------
+
+
+class TestElementColorsKnownValues:
+    def test_hydrogen_is_white_in_jmol(self):
+        assert ELEMENT_COLORS['H']['jmol'] == (255, 255, 255)
+
+    def test_oxygen_is_red_in_jmol(self):
+        assert ELEMENT_COLORS['O']['jmol'] == (255, 13, 13)
+
+    def test_nobelium_has_no_vesta_entry(self):
+        # No has a jmol colour but no VESTA override (falls back to jmol).
+        assert ELEMENT_COLORS['No']['vesta'] is None
+        assert ELEMENT_COLORS['No']['jmol'] == (189, 13, 135)
+
+    def test_some_elements_have_a_vesta_override(self):
+        # At least one element must carry a non-None VESTA colour,
+        # otherwise the second scheme would be dead data.
+        with_vesta = [s for s, e in ELEMENT_COLORS.items() if e['vesta'] is not None]
+        assert with_vesta
+
+
+# ------------------------------------------------------------------
+#  Cross-dictionary consistency
+# ------------------------------------------------------------------
+
+
+class TestRadiiAndColorsConsistency:
+    def test_same_element_set(self):
+        # Every element resolvable for a radius must also resolve for a
+        # colour, and vice versa.
+        assert set(ELEMENT_RADII) == set(ELEMENT_COLORS)
+
+    def test_same_ordering(self):
+        assert list(ELEMENT_RADII) == list(ELEMENT_COLORS)
diff --git a/tests/unit/easydiffraction/display/structure/assets/test_radii.py b/tests/unit/easydiffraction/display/structure/assets/test_radii.py
new file mode 100644
index 000000000..a38aa41a9
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/assets/test_radii.py
@@ -0,0 +1,174 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for per-element radius lookup with covalent fallback."""
+
+from __future__ import annotations
+
+import easydiffraction.display.structure.assets.radii as radii_module
+from easydiffraction.display.structure.assets.elements import ELEMENT_RADII
+from easydiffraction.display.structure.assets.radii import DEFAULT_RADIUS
+from easydiffraction.display.structure.assets.radii import radius_for
+
+
+def test_module_import():
+    expected_module_name = 'easydiffraction.display.structure.assets.radii'
+    actual_module_name = radii_module.__name__
+    assert expected_module_name == actual_module_name
+
+
+class TestDefaultRadius:
+    def test_value(self):
+        assert DEFAULT_RADIUS == 1.0
+
+    def test_is_float(self):
+        assert isinstance(DEFAULT_RADIUS, float)
+
+
+class TestRadiusForDirectModelHit:
+    """Element present and the requested model has a value: no fallback."""
+
+    def test_vdw(self):
+        radius, substituted = radius_for('Fe', 'vdw')
+        assert radius == ELEMENT_RADII['Fe']['vdw']
+        assert radius == 1.72
+        assert substituted is False
+
+    def test_covalent(self):
+        radius, substituted = radius_for('Fe', 'covalent')
+        assert radius == ELEMENT_RADII['Fe']['covalent']
+        assert radius == 1.32
+        assert substituted is False
+
+    def test_ionic(self):
+        radius, substituted = radius_for('Fe', 'ionic')
+        assert radius == ELEMENT_RADII['Fe']['ionic']
+        assert radius == 0.78
+        assert substituted is False
+
+    def test_atomic(self):
+        radius, substituted = radius_for('Fe', 'atomic')
+        assert radius == ELEMENT_RADII['Fe']['atomic']
+        assert radius == 1.4
+        assert substituted is False
+
+    def test_returns_tuple_of_float_and_bool(self):
+        result = radius_for('Fe', 'vdw')
+        assert isinstance(result, tuple)
+        assert len(result) == 2
+        radius, substituted = result
+        assert isinstance(radius, float)
+        assert isinstance(substituted, bool)
+
+
+class TestRadiusForCovalentFallback:
+    """Element present but the requested model is None: covalent is used."""
+
+    def test_ionic_missing_falls_back_to_covalent(self):
+        # H has ionic=None but covalent=0.31.
+        assert ELEMENT_RADII['H']['ionic'] is None
+        radius, substituted = radius_for('H', 'ionic')
+        assert radius == ELEMENT_RADII['H']['covalent']
+        assert radius == 0.31
+        assert substituted is True
+
+    def test_atomic_missing_falls_back_to_covalent(self):
+        # He has atomic=None but covalent=0.28.
+        assert ELEMENT_RADII['He']['atomic'] is None
+        radius, substituted = radius_for('He', 'atomic')
+        assert radius == ELEMENT_RADII['He']['covalent']
+        assert radius == 0.28
+        assert substituted is True
+
+
+class TestRadiusForUnknownElement:
+    """Element absent from the database: DEFAULT_RADIUS, substituted."""
+
+    def test_unknown_symbol(self):
+        radius, substituted = radius_for('Zz', 'vdw')
+        assert radius == DEFAULT_RADIUS
+        assert substituted is True
+
+    def test_empty_symbol(self):
+        radius, substituted = radius_for('', 'vdw')
+        assert radius == DEFAULT_RADIUS
+        assert substituted is True
+
+    def test_unknown_element_ignores_model(self):
+        # Model is irrelevant once the element is unknown.
+        for model in ('vdw', 'covalent', 'ionic', 'atomic', 'nonsense'):
+            radius, substituted = radius_for('Qq', model)
+            assert radius == DEFAULT_RADIUS
+            assert substituted is True
+
+
+class TestRadiusForUnknownModel:
+    """Element present but the model key is unknown: covalent fallback."""
+
+    def test_unknown_model_falls_back_to_covalent(self):
+        # 'bogus' is not a key in any entry, so entry.get returns None
+        # and the covalent radius is substituted.
+        radius, substituted = radius_for('Fe', 'bogus')
+        assert radius == ELEMENT_RADII['Fe']['covalent']
+        assert substituted is True
+
+
+class TestRadiusForDefaultFallback:
+    """Entry exists, requested model None, and covalent also None.
+
+    No real element has a None covalent radius, so this last-resort
+    branch is exercised by patching the database with a synthetic
+    entry whose every radius is None.
+    """
+
+    def test_default_radius_when_covalent_is_none(self, monkeypatch):
+        patched = dict(ELEMENT_RADII)
+        patched['Xx'] = {'vdw': None, 'covalent': None, 'ionic': None, 'atomic': None}
+        monkeypatch.setattr(radii_module, 'ELEMENT_RADII', patched)
+
+        radius, substituted = radius_for('Xx', 'vdw')
+        assert radius == DEFAULT_RADIUS
+        assert substituted is True
+
+    def test_default_radius_when_model_and_covalent_none(self, monkeypatch):
+        patched = dict(ELEMENT_RADII)
+        patched['Xx'] = {'vdw': 2.0, 'covalent': None, 'ionic': None, 'atomic': None}
+        monkeypatch.setattr(radii_module, 'ELEMENT_RADII', patched)
+
+        # ionic is None and covalent is None -> last-resort default.
+        radius, substituted = radius_for('Xx', 'ionic')
+        assert radius == DEFAULT_RADIUS
+        assert substituted is True
+
+    def test_still_uses_model_value_when_present(self, monkeypatch):
+        patched = dict(ELEMENT_RADII)
+        patched['Xx'] = {'vdw': 2.0, 'covalent': None, 'ionic': None, 'atomic': None}
+        monkeypatch.setattr(radii_module, 'ELEMENT_RADII', patched)
+
+        # The requested model has a value, so no fallback happens.
+        radius, substituted = radius_for('Xx', 'vdw')
+        assert radius == 2.0
+        assert substituted is False
+
+
+class TestRadiusForAllRealElements:
+    """Smoke check across the whole bundled database."""
+
+    def test_every_element_resolves_to_positive_radius(self):
+        # A handful of bundled entries store integer literals (e.g. Pa
+        # covalent=2, Cn vdw=2), and radius_for passes the stored value
+        # through unchanged, so accept any real number here.
+        for element in ELEMENT_RADII:
+            for model in ('vdw', 'covalent', 'ionic', 'atomic'):
+                radius, substituted = radius_for(element, model)
+                assert isinstance(radius, (int, float))
+                assert radius > 0.0
+                assert isinstance(substituted, bool)
+
+    def test_substituted_flag_matches_database(self):
+        # When the model value is present, substituted must be False;
+        # otherwise (covalent fallback) it must be True, because no
+        # bundled element has a None covalent radius.
+        for element, entry in ELEMENT_RADII.items():
+            for model in ('vdw', 'covalent', 'ionic', 'atomic'):
+                _, substituted = radius_for(element, model)
+                assert substituted is (entry.get(model) is None)
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_ascii.py b/tests/unit/easydiffraction/display/structure/renderers/test_ascii.py
new file mode 100644
index 000000000..042d5463c
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_ascii.py
@@ -0,0 +1,547 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the ASCII single-cell structure renderer."""
+
+from __future__ import annotations
+
+import re
+
+import numpy as np
+
+from easydiffraction.display.structure.renderers import ascii as MUT
+from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.scene import AdpEllipsoid
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import OccupancyWedge
+from easydiffraction.display.structure.scene import OccupancyWedgeSphere
+from easydiffraction.display.structure.scene import StructureScene
+
+# ANSI escape sequence matcher used to strip colour tinting from output.
+_ANSI = re.compile(r'\x1b\[[0-9;]*m')
+
+# A cubic 5 Angstrom cell basis (rows are the cell vectors).
+_CUBIC_BASIS = ((5.0, 0.0, 0.0), (0.0, 5.0, 0.0), (0.0, 0.0, 5.0))
+
+ALL_FEATURES = frozenset({'atoms', 'cell', 'axes'})
+
+
+def _strip_ansi(text: str) -> str:
+    """Remove ANSI colour codes so glyphs can be asserted directly."""
+    return _ANSI.sub('', text)
+
+
+def _atom(centre=(0.0, 0.0, 0.0), radius=1.0, colour=(255, 0, 0), label='Fe'):
+    return AtomSphere(centre=centre, radius=radius, colour=colour, label=label)
+
+
+def _scene(atoms=(), occupancy_spheres=(), ellipsoids=(), basis=_CUBIC_BASIS):
+    return StructureScene(
+        cell_basis=basis,
+        atoms=tuple(atoms),
+        occupancy_spheres=tuple(occupancy_spheres),
+        ellipsoids=tuple(ellipsoids),
+    )
+
+
+# ----------------------------------------------------------------------
+#  Module + class basics
+# ----------------------------------------------------------------------
+
+
+def test_module_import():
+    expected_module_name = 'easydiffraction.display.structure.renderers.ascii'
+    assert MUT.__name__ == expected_module_name
+
+
+def test_renderer_is_subclass_of_base():
+    assert issubclass(AsciiStructureRenderer, StructureRendererBase)
+
+
+def test_renderer_instantiates():
+    assert AsciiStructureRenderer() is not None
+
+
+def test_module_constants():
+    assert MUT.GLYPH_RAMP == ('·', '•', '●')
+    assert MUT.GRID_WIDTH == 56
+    assert MUT.PAD == 2
+    assert MUT.CHAR_ASPECT == 0.5
+
+
+# ----------------------------------------------------------------------
+#  supported_features
+# ----------------------------------------------------------------------
+
+
+def test_supported_features_value():
+    renderer = AsciiStructureRenderer()
+    assert renderer.supported_features() == frozenset({'atoms', 'cell', 'axes'})
+
+
+def test_supported_features_matches_class_attribute():
+    renderer = AsciiStructureRenderer()
+    assert renderer.supported_features() is AsciiStructureRenderer.SUPPORTED
+
+
+def test_supported_features_is_frozenset():
+    assert isinstance(AsciiStructureRenderer().supported_features(), frozenset)
+
+
+# ----------------------------------------------------------------------
+#  render — feature gating
+# ----------------------------------------------------------------------
+
+
+def test_render_returns_str():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=ALL_FEATURES)
+    assert isinstance(out, str)
+
+
+def test_render_with_no_features_is_blank():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=frozenset())
+    # No cell, no atoms, no axes: only whitespace rows remain.
+    assert _strip_ansi(out).strip() == ''
+
+
+def test_render_cell_only_draws_border_not_atoms():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=frozenset({'cell'}))
+    plain = _strip_ansi(out)
+    # Cell corners present, no legend (atoms feature is off).
+    for corner in ('╭', '╮', '╰', '╯'):
+        assert corner in plain
+    assert 'Legend:' not in plain
+
+
+def test_render_atoms_only_has_glyph_and_legend_but_no_border():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=frozenset({'atoms'}))
+    plain = _strip_ansi(out)
+    assert 'Legend:' in plain
+    assert any(g in plain for g in MUT.GLYPH_RAMP)
+    assert '╭' not in plain
+
+
+def test_render_axes_only_adds_vertical_label():
+    # With an empty body (no cell, no drawn atoms) only the vertical
+    # axis header survives; the horizontal label needs a non-blank
+    # bottom border row to attach to.
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[]), features=frozenset({'axes'}))
+    plain = _strip_ansi(out)
+    # Cubic cell: longest axis horizontal, second-longest (b) vertical.
+    assert 'b' in plain
+    assert '↑' in plain
+
+
+def test_render_axes_with_atoms_adds_both_labels():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=frozenset({'atoms', 'axes'}))
+    plain = _strip_ansi(out)
+    assert '↑' in plain
+    assert '→' in plain
+
+
+def test_render_all_features_includes_border_atoms_axes_legend():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=ALL_FEATURES)
+    plain = _strip_ansi(out)
+    assert '╭' in plain
+    assert any(g in plain for g in MUT.GLYPH_RAMP)
+    assert '↑' in plain
+    assert '→' in plain
+    assert 'Legend:' in plain
+
+
+def test_render_atoms_feature_without_atoms_skips_legend():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[]), features=ALL_FEATURES)
+    plain = _strip_ansi(out)
+    # Atoms requested but the scene has none: border + axes only.
+    assert 'Legend:' not in plain
+    assert '╭' in plain
+
+
+def test_render_output_is_ansi_tinted():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom()]), features=ALL_FEATURES)
+    # Coloured glyphs must carry ANSI escape codes.
+    assert '\x1b[' in out
+
+
+# ----------------------------------------------------------------------
+#  render — scene primitive coverage
+# ----------------------------------------------------------------------
+
+
+def test_render_includes_atom_label_in_legend():
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(atoms=[_atom(label='Fe1')]), features=ALL_FEATURES)
+    plain = _strip_ansi(out)
+    # Digits are stripped from the legend element name.
+    assert 'Fe' in plain
+    assert 'Fe1' not in plain
+
+
+def test_render_occupancy_sphere_uses_first_wedge_colour():
+    sphere = OccupancyWedgeSphere(
+        centre=(2.5, 2.5, 2.5),
+        radius=1.2,
+        wedges=(OccupancyWedge(0.6, (10, 20, 30)), OccupancyWedge(0.4, (40, 50, 60))),
+        label='La/Ba',
+    )
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(occupancy_spheres=[sphere]), features=ALL_FEATURES)
+    plain = _strip_ansi(out)
+    # The slash is preserved so a shared site reads 'La/Ba'.
+    assert 'La/Ba' in plain
+    assert 'Legend:' in plain
+
+
+def test_render_ellipsoid_uses_mean_semi_axes():
+    ellipsoid = AdpEllipsoid(
+        centre=(1.0, 1.0, 1.0),
+        semi_axes=(0.3, 0.5, 0.7),
+        orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+        colour=(0, 200, 0),
+        label='O',
+    )
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(_scene(ellipsoids=[ellipsoid]), features=ALL_FEATURES)
+    plain = _strip_ansi(out)
+    assert 'O' in plain
+    assert any(g in plain for g in MUT.GLYPH_RAMP)
+
+
+def test_render_mixed_primitives_all_appear_in_legend():
+    atoms = [_atom(centre=(0.0, 0.0, 0.0), label='Fe', colour=(255, 0, 0))]
+    spheres = [
+        OccupancyWedgeSphere(
+            centre=(2.5, 2.5, 2.5),
+            radius=1.0,
+            wedges=(OccupancyWedge(1.0, (0, 0, 255)),),
+            label='Na',
+        )
+    ]
+    ellipsoids = [
+        AdpEllipsoid(
+            centre=(4.0, 4.0, 4.0),
+            semi_axes=(0.4, 0.4, 0.4),
+            orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+            colour=(0, 255, 0),
+            label='O',
+        )
+    ]
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(
+        _scene(atoms=atoms, occupancy_spheres=spheres, ellipsoids=ellipsoids),
+        features=ALL_FEATURES,
+    )
+    plain = _strip_ansi(out)
+    for element in ('Fe', 'Na', 'O'):
+        assert element in plain
+
+
+def test_render_axes_letters_track_axis_lengths():
+    # Make c the longest axis and a the shortest; b stays second-longest.
+    basis = ((2.0, 0.0, 0.0), (0.0, 5.0, 0.0), (0.0, 0.0, 9.0))
+    renderer = AsciiStructureRenderer()
+    out = renderer.render(
+        _scene(atoms=[_atom()], basis=basis),
+        features=frozenset({'atoms', 'axes'}),
+    )
+    plain = _strip_ansi(out)
+    # Longest (c) horizontal, second-longest (b) vertical.
+    assert '→ c' in plain
+    assert 'b' in plain
+
+
+# ----------------------------------------------------------------------
+#  _collect_atoms
+# ----------------------------------------------------------------------
+
+
+def test_collect_atoms_flattens_every_primitive():
+    sphere = OccupancyWedgeSphere(
+        centre=(1.0, 1.0, 1.0),
+        radius=0.9,
+        wedges=(OccupancyWedge(1.0, (1, 2, 3)),),
+        label='Na',
+    )
+    ellipsoid = AdpEllipsoid(
+        centre=(2.0, 2.0, 2.0),
+        semi_axes=(0.2, 0.4, 0.6),
+        orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+        colour=(4, 5, 6),
+        label='O',
+    )
+    scene = _scene(atoms=[_atom(label='Fe')], occupancy_spheres=[sphere], ellipsoids=[ellipsoid])
+
+    flattened = MUT._collect_atoms(scene)
+
+    assert len(flattened) == 3
+    labels = [item[3] for item in flattened]
+    assert labels == ['Fe', 'Na', 'O']
+    # Occupancy sphere inherits its first wedge colour.
+    assert flattened[1][2] == (1, 2, 3)
+    # Ellipsoid radius is the mean of its semi-axes.
+    assert flattened[2][1] == np.mean((0.2, 0.4, 0.6))
+
+
+def test_collect_atoms_ellipsoid_zero_mean_falls_back_to_default_radius():
+    ellipsoid = AdpEllipsoid(
+        centre=(0.0, 0.0, 0.0),
+        semi_axes=(0.0, 0.0, 0.0),
+        orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+        colour=(7, 8, 9),
+        label='X',
+    )
+    flattened = MUT._collect_atoms(_scene(ellipsoids=[ellipsoid]))
+    assert flattened[0][1] == 0.4
+
+
+def test_collect_atoms_empty_scene_returns_empty_list():
+    assert MUT._collect_atoms(_scene()) == []
+
+
+# ----------------------------------------------------------------------
+#  _ansi256 / _tint
+# ----------------------------------------------------------------------
+
+
+def test_ansi256_black_and_white_bounds():
+    assert MUT._ansi256((0, 0, 0)) == 16
+    assert MUT._ansi256((255, 255, 255)) == 231
+
+
+def test_ansi256_pure_red():
+    # 16 + 36*5 = 196 for full-red, no green, no blue.
+    assert MUT._ansi256((255, 0, 0)) == 196
+
+
+def test_tint_wraps_text_in_escape_codes():
+    tinted = MUT._tint((255, 0, 0), 'X')
+    assert tinted.startswith('\x1b[38;5;196m')
+    assert tinted.endswith('\x1b[0m')
+    assert _strip_ansi(tinted) == 'X'
+
+
+# ----------------------------------------------------------------------
+#  _make_grid
+# ----------------------------------------------------------------------
+
+
+def test_make_grid_size_and_placement():
+    points = [(0.0, 0.0), (10.0, 4.0)]
+    grid, place = MUT._make_grid(points)
+    height, width = grid['_size']
+    assert width == MUT.GRID_WIDTH
+    assert height >= 8
+    # The extreme corners land within the padded interior.
+    r0, c0 = place((0.0, 0.0))
+    r1, c1 = place((10.0, 4.0))
+    assert c0 == MUT.PAD
+    assert MUT.PAD <= c1 <= width - 1
+    # Higher y maps to a smaller row (top of the grid).
+    assert r1 < r0
+
+
+def test_make_grid_handles_empty_points():
+    grid, place = MUT._make_grid([])
+    height, width = grid['_size']
+    assert width == MUT.GRID_WIDTH
+    assert height >= 8
+    # A degenerate span must not raise and should place at the origin pad.
+    assert place((0.0, 0.0)) == (MUT.PAD, MUT.PAD)
+
+
+def test_make_grid_handles_zero_span():
+    # All points identical: span guards prevent division by zero.
+    _grid, place = MUT._make_grid([(3.0, 3.0), (3.0, 3.0)])
+    assert place((3.0, 3.0)) == (MUT.PAD, MUT.PAD)
+
+
+# ----------------------------------------------------------------------
+#  _draw_cell
+# ----------------------------------------------------------------------
+
+
+def test_draw_cell_writes_closed_rectangle_with_corners():
+    corners = [(0.0, 0.0), (10.0, 0.0), (0.0, 4.0), (10.0, 4.0)]
+    grid, place = MUT._make_grid(corners)
+    MUT._draw_cell(grid, place, corners)
+    glyphs = {cell: val[0] for cell, val in grid.items() if cell != '_size'}
+    assert '╭' in glyphs.values()
+    assert '╮' in glyphs.values()
+    assert '╰' in glyphs.values()
+    assert '╯' in glyphs.values()
+    assert '─' in glyphs.values()
+    assert '│' in glyphs.values()
+
+
+def test_draw_cell_corner_overrides_border():
+    corners = [(0.0, 0.0), (10.0, 0.0), (0.0, 4.0), (10.0, 4.0)]
+    grid, place = MUT._make_grid(corners)
+    MUT._draw_cell(grid, place, corners)
+    cells = [place(c) for c in corners]
+    rows = [r for r, _ in cells]
+    cols = [c for _, c in cells]
+    top_left = (min(rows), min(cols))
+    # The shared corner cell is a corner glyph, never a straight edge.
+    assert grid[top_left][0] == '╭'
+
+
+# ----------------------------------------------------------------------
+#  _draw_atoms
+# ----------------------------------------------------------------------
+
+
+def test_draw_atoms_places_glyph_by_radius_bucket():
+    # Two atoms: the larger radius gets the densest glyph.
+    atoms = [
+        ((0.0, 0.0, 0.0), 0.2, (255, 0, 0), 'A'),
+        ((10.0, 4.0, 0.0), 1.0, (0, 0, 255), 'B'),
+    ]
+    points = [(0.0, 0.0), (10.0, 4.0)]
+    grid, place = MUT._make_grid(points)
+    MUT._draw_atoms(grid, place, atoms)
+    small = grid[place((0.0, 0.0))]
+    large = grid[place((10.0, 4.0))]
+    assert large[0] == '●'  # densest bucket for the largest radius
+    assert MUT.GLYPH_RAMP.index(small[0]) <= MUT.GLYPH_RAMP.index(large[0])
+
+
+def test_draw_atoms_skips_same_colour_duplicate_in_adjacent_cell():
+    # Two same-colour atoms projecting to the same cell: only one drawn.
+    atoms = [
+        ((0.0, 0.0, 0.0), 1.0, (255, 0, 0), 'A'),
+        ((0.0, 0.0, 0.0), 1.0, (255, 0, 0), 'A'),
+    ]
+    grid, place = MUT._make_grid([(0.0, 0.0)])
+    MUT._draw_atoms(grid, place, atoms)
+    drawn = [cell for cell in grid if cell != '_size']
+    assert len(drawn) == 1
+
+
+def test_draw_atoms_keeps_different_colour_in_same_cell():
+    # Different colours are not treated as duplicates.
+    atoms = [
+        ((0.0, 0.0, 0.0), 1.0, (255, 0, 0), 'A'),
+        ((0.0, 0.0, 0.0), 1.0, (0, 0, 255), 'B'),
+    ]
+    grid, place = MUT._make_grid([(0.0, 0.0)])
+    MUT._draw_atoms(grid, place, atoms)
+    drawn = [cell for cell in grid if cell != '_size']
+    # Same cell, different colour: the second overwrites the first, but
+    # it is not skipped as a duplicate (one occupied cell, last colour).
+    assert len(drawn) == 1
+    assert grid[place((0.0, 0.0))][1] == (0, 0, 255)
+
+
+# ----------------------------------------------------------------------
+#  _grid_to_lines
+# ----------------------------------------------------------------------
+
+
+def test_grid_to_lines_dimensions_and_blank_fill():
+    grid = {'_size': (3, 6)}
+    grid[0, 0] = ('●', (255, 0, 0))
+    lines = MUT._grid_to_lines(grid)
+    assert len(lines) == 3
+    # Empty rows are right-stripped to the empty string.
+    assert lines[1] == ''
+    assert lines[2] == ''
+    # The tinted glyph survives in the first row.
+    assert '●' in _strip_ansi(lines[0])
+
+
+def test_grid_to_lines_rstrips_trailing_blanks():
+    grid = {'_size': (1, 10)}
+    grid[0, 2] = ('•', (1, 2, 3))
+    lines = MUT._grid_to_lines(grid)
+    # Trailing blank cells past the glyph are removed.
+    assert not lines[0].endswith(' ')
+
+
+# ----------------------------------------------------------------------
+#  _annotate_axes
+# ----------------------------------------------------------------------
+
+
+def test_annotate_axes_adds_vertical_header_and_horizontal_label():
+    lines = ['row0', 'row1', 'row2']
+    out = MUT._annotate_axes(lines, left_col=3, bottom_row=2, v_letter='b', h_letter='a')
+    # Header: blank line, letter, arrow; all indented by left_col.
+    assert out[0] == ''
+    assert out[1] == '   b'
+    assert out[2] == '   ↑'
+    # Horizontal label appended to the bottom row.
+    assert out[-1].endswith('→ a')
+
+
+def test_annotate_axes_out_of_range_bottom_row_leaves_body_unchanged():
+    lines = ['only']
+    out = MUT._annotate_axes(lines, left_col=0, bottom_row=99, v_letter='c', h_letter='a')
+    # Header still added, but no horizontal label since row is out of range.
+    assert out[:3] == ['', 'c', '↑']
+    assert out[3] == 'only'
+    assert '→' not in out[3]
+
+
+# ----------------------------------------------------------------------
+#  _legend
+# ----------------------------------------------------------------------
+
+
+def test_legend_strips_digits_keeps_slash():
+    atoms = [
+        ((0.0, 0.0, 0.0), 1.0, (255, 0, 0), 'Fe1'),
+        ((0.0, 0.0, 0.0), 1.0, (0, 0, 255), 'La/Ba'),
+    ]
+    legend = MUT._legend(atoms)
+    plain = _strip_ansi(legend)
+    assert plain.startswith('Legend:')
+    assert 'Fe' in plain
+    assert 'Fe1' not in plain
+    assert 'La/Ba' in plain
+
+
+def test_legend_deduplicates_by_element():
+    atoms = [
+        ((0.0, 0.0, 0.0), 1.0, (255, 0, 0), 'Fe1'),
+        ((1.0, 1.0, 1.0), 1.0, (255, 0, 0), 'Fe2'),
+    ]
+    legend = MUT._legend(atoms)
+    plain = _strip_ansi(legend)
+    # Two Fe sites collapse to a single 'Fe' legend entry.
+    assert plain.count('Fe') == 1
+
+
+def test_legend_glyph_scales_with_radius():
+    atoms = [
+        ((0.0, 0.0, 0.0), 0.2, (255, 0, 0), 'H'),
+        ((1.0, 1.0, 1.0), 1.0, (0, 0, 255), 'U'),
+    ]
+    legend = MUT._legend(atoms)
+    plain = _strip_ansi(legend)
+    # Largest radius element uses the densest glyph.
+    assert '● U' in plain
+    assert '· H' in plain or '• H' in plain
+
+
+def test_legend_all_zero_radius_does_not_divide_by_zero():
+    atoms = [((0.0, 0.0, 0.0), 0.0, (1, 2, 3), 'X')]
+    legend = MUT._legend(atoms)
+    plain = _strip_ansi(legend)
+    assert 'X' in plain
+
+
+def test_legend_label_with_no_alpha_falls_back_to_label():
+    # A purely numeric label keeps the raw label (the 'or label' branch).
+    atoms = [((0.0, 0.0, 0.0), 1.0, (1, 2, 3), '123')]
+    legend = MUT._legend(atoms)
+    plain = _strip_ansi(legend)
+    assert '123' in plain
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_base.py b/tests/unit/easydiffraction/display/structure/renderers/test_base.py
new file mode 100644
index 000000000..239c1d1e2
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_base.py
@@ -0,0 +1,199 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for display/structure/renderers/base.py (StructureRendererBase)."""
+
+from __future__ import annotations
+
+from abc import ABC
+
+import pytest
+
+from easydiffraction.display.structure.renderers.base import StructureRendererBase
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import StructureScene
+
+
+# ------------------------------------------------------------------
+#  Test doubles
+# ------------------------------------------------------------------
+
+
+class _CompleteRenderer(StructureRendererBase):
+    """A minimal concrete renderer overriding both abstract methods."""
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        return f'atoms={len(scene.atoms)} features={sorted(features)}'
+
+    def supported_features(self) -> frozenset[str]:
+        return frozenset({'atoms', 'cell'})
+
+
+class _RenderOnlyRenderer(StructureRendererBase):
+    """Overrides only ``render`` so the class stays abstract."""
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        return ''
+
+
+class _FeaturesOnlyRenderer(StructureRendererBase):
+    """Overrides only ``supported_features`` so the class stays abstract."""
+
+    def supported_features(self) -> frozenset[str]:
+        return frozenset()
+
+
+class _DelegatingRenderer(StructureRendererBase):
+    """Calls the base-class bodies via ``super()`` to hit their raises."""
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        return super().render(scene, features=features)
+
+    def supported_features(self) -> frozenset[str]:
+        return super().supported_features()
+
+
+# ------------------------------------------------------------------
+#  Fixtures
+# ------------------------------------------------------------------
+
+
+def _minimal_scene() -> StructureScene:
+    """Build a tiny renderer-neutral scene without any engine."""
+    basis = (
+        (1.0, 0.0, 0.0),
+        (0.0, 1.0, 0.0),
+        (0.0, 0.0, 1.0),
+    )
+    atom = AtomSphere(centre=(0.0, 0.0, 0.0), radius=0.5, colour=(255, 0, 0), label='Fe')
+    return StructureScene(cell_basis=basis, atoms=(atom,))
+
+
+# ------------------------------------------------------------------
+#  Module / class identity
+# ------------------------------------------------------------------
+
+
+def test_module_import():
+    import easydiffraction.display.structure.renderers.base as MUT
+
+    expected_module_name = 'easydiffraction.display.structure.renderers.base'
+    actual_module_name = MUT.__name__
+    assert expected_module_name == actual_module_name
+
+
+def test_is_abstract_base_class():
+    assert issubclass(StructureRendererBase, ABC)
+
+
+def test_abstractmethods_are_exactly_render_and_supported_features():
+    assert StructureRendererBase.__abstractmethods__ == frozenset({'render', 'supported_features'})
+
+
+def test_render_marked_abstract():
+    assert StructureRendererBase.render.__isabstractmethod__ is True
+
+
+def test_supported_features_marked_abstract():
+    assert StructureRendererBase.supported_features.__isabstractmethod__ is True
+
+
+# ------------------------------------------------------------------
+#  Instantiation contract
+# ------------------------------------------------------------------
+
+
+def test_cannot_instantiate_base_directly():
+    with pytest.raises(TypeError):
+        StructureRendererBase()
+
+
+def test_cannot_instantiate_with_only_render_overridden():
+    with pytest.raises(TypeError):
+        _RenderOnlyRenderer()
+
+
+def test_cannot_instantiate_with_only_supported_features_overridden():
+    with pytest.raises(TypeError):
+        _FeaturesOnlyRenderer()
+
+
+def test_complete_subclass_instantiates():
+    renderer = _CompleteRenderer()
+    assert isinstance(renderer, StructureRendererBase)
+
+
+# ------------------------------------------------------------------
+#  Subclass honours the contract
+# ------------------------------------------------------------------
+
+
+def test_supported_features_returns_frozenset():
+    renderer = _CompleteRenderer()
+    result = renderer.supported_features()
+    assert isinstance(result, frozenset)
+    assert result == frozenset({'atoms', 'cell'})
+
+
+def test_render_returns_string_using_scene_and_features():
+    renderer = _CompleteRenderer()
+    scene = _minimal_scene()
+    output = renderer.render(scene, features=frozenset({'atoms', 'cell'}))
+    assert isinstance(output, str)
+    assert 'atoms=1' in output
+    assert "features=['atoms', 'cell']" in output
+
+
+def test_render_features_is_keyword_only():
+    renderer = _CompleteRenderer()
+    scene = _minimal_scene()
+    with pytest.raises(TypeError):
+        renderer.render(scene, frozenset({'atoms'}))
+
+
+# ------------------------------------------------------------------
+#  Base-class method bodies raise NotImplementedError
+# ------------------------------------------------------------------
+
+
+def test_super_render_raises_not_implemented():
+    renderer = _DelegatingRenderer()
+    scene = _minimal_scene()
+    with pytest.raises(NotImplementedError):
+        renderer.render(scene, features=frozenset())
+
+
+def test_super_supported_features_raises_not_implemented():
+    renderer = _DelegatingRenderer()
+    with pytest.raises(NotImplementedError):
+        renderer.supported_features()
+
+
+# ------------------------------------------------------------------
+#  Real concrete renderer satisfies the contract (no engine needed)
+# ------------------------------------------------------------------
+
+
+def test_ascii_renderer_is_a_structure_renderer_base():
+    from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+
+    renderer = AsciiStructureRenderer()
+    assert isinstance(renderer, StructureRendererBase)
+
+
+def test_ascii_renderer_supported_features_is_a_subset_of_the_documented_names():
+    from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+
+    documented = frozenset({'atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'})
+    features = AsciiStructureRenderer().supported_features()
+    assert isinstance(features, frozenset)
+    assert features <= documented
+
+
+def test_ascii_renderer_render_returns_text():
+    from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+
+    renderer = AsciiStructureRenderer()
+    scene = _minimal_scene()
+    output = renderer.render(scene, features=renderer.supported_features())
+    assert isinstance(output, str)
+    assert output != ''
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
new file mode 100644
index 000000000..fa5596b96
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
@@ -0,0 +1,388 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the z-buffered raster structure renderer."""
+
+from __future__ import annotations
+
+import io
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from easydiffraction.display.structure.renderers.raster import RasterStructureRenderer
+from easydiffraction.display.structure.scene import AdpEllipsoid
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import AxisArrow
+from easydiffraction.display.structure.scene import AxisTriad
+from easydiffraction.display.structure.scene import Bond
+from easydiffraction.display.structure.scene import CellEdge
+from easydiffraction.display.structure.scene import CellEdges
+from easydiffraction.display.structure.scene import LegendEntry
+from easydiffraction.display.structure.scene import OccupancyWedge
+from easydiffraction.display.structure.scene import OccupancyWedgeSphere
+from easydiffraction.display.structure.scene import StructureScene
+
+# The 8-byte PNG file signature.
+PNG_MAGIC = b'\x89PNG\r\n\x1a\n'
+
+# A simple orthogonal 5x5x5 cell shared by most scenes.
+CUBIC_BASIS = ((5.0, 0.0, 0.0), (0.0, 5.0, 0.0), (0.0, 0.0, 5.0))
+
+
+def _open(png: bytes) -> Image.Image:
+    """Decode rendered PNG bytes into a Pillow image."""
+    return Image.open(io.BytesIO(png))
+
+
+def _pixels(png: bytes) -> np.ndarray:
+    """Return the rendered image as an (H, W, 3) uint8 array."""
+    return np.asarray(_open(png))
+
+
+def _has_drawn_pixels(png: bytes) -> bool:
+    """True when any pixel departs from the white background."""
+    return bool((_pixels(png) != 255).any())
+
+
+def _atom_scene() -> StructureScene:
+    """A single red atom centred in the cubic cell."""
+    return StructureScene(
+        cell_basis=CUBIC_BASIS,
+        atoms=(AtomSphere(centre=(0.0, 0.0, 0.0), radius=1.0, colour=(255, 0, 0), label='Fe'),),
+    )
+
+
+def _axis_triad() -> AxisTriad:
+    """An a/b/c axis triad along the cubic cell edges."""
+    return AxisTriad(
+        origin=(0.0, 0.0, 0.0),
+        axes=(
+            AxisArrow(vector=(5.0, 0.0, 0.0), colour=(255, 0, 0), letter='a'),
+            AxisArrow(vector=(0.0, 5.0, 0.0), colour=(0, 255, 0), letter='b'),
+            AxisArrow(vector=(0.0, 0.0, 5.0), colour=(0, 0, 255), letter='c'),
+        ),
+    )
+
+
+def _full_scene() -> StructureScene:
+    """A scene exercising every supported primitive plus a legend."""
+    return StructureScene(
+        cell_basis=CUBIC_BASIS,
+        atoms=(
+            AtomSphere(centre=(0.0, 0.0, 0.0), radius=0.8, colour=(255, 0, 0), label='Fe'),
+            AtomSphere(centre=(5.0, 5.0, 5.0), radius=0.8, colour=(0, 0, 255), label='O'),
+        ),
+        occupancy_spheres=(
+            OccupancyWedgeSphere(
+                centre=(2.5, 2.5, 2.5),
+                radius=0.7,
+                wedges=(
+                    OccupancyWedge(fraction=0.5, colour=(255, 0, 0)),
+                    OccupancyWedge(fraction=0.5, colour=(0, 255, 0)),
+                ),
+                label='Mix',
+            ),
+        ),
+        ellipsoids=(
+            AdpEllipsoid(
+                centre=(1.0, 1.0, 1.0),
+                semi_axes=(0.5, 0.4, 0.3),
+                orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+                colour=(0, 200, 0),
+                label='Ell',
+            ),
+        ),
+        bonds=(
+            Bond(
+                start=(0.0, 0.0, 0.0),
+                end=(5.0, 5.0, 5.0),
+                start_colour=(255, 0, 0),
+                end_colour=(0, 0, 255),
+            ),
+        ),
+        cell_edges=CellEdges(
+            edges=(
+                CellEdge(start=(0.0, 0.0, 0.0), end=(5.0, 0.0, 0.0)),
+                CellEdge(start=(0.0, 0.0, 0.0), end=(0.0, 5.0, 0.0)),
+                CellEdge(start=(0.0, 0.0, 0.0), end=(0.0, 0.0, 5.0)),
+            )
+        ),
+        axes=_axis_triad(),
+        legend=(
+            LegendEntry(symbol='Fe', colour=(255, 0, 0)),
+            LegendEntry(symbol='O', colour=(0, 0, 255)),
+        ),
+    )
+
+
+def test_module_import():
+    import easydiffraction.display.structure.renderers.raster as MUT
+
+    expected_module_name = 'easydiffraction.display.structure.renderers.raster'
+    actual_module_name = MUT.__name__
+    assert expected_module_name == actual_module_name
+
+
+class TestSupported:
+    def test_supported_is_frozenset(self):
+        assert isinstance(RasterStructureRenderer.SUPPORTED, frozenset)
+
+    def test_supported_members(self):
+        assert frozenset({'atoms', 'bonds', 'cell', 'axes'}) == RasterStructureRenderer.SUPPORTED
+
+    def test_supported_shared_across_instances(self):
+        # SUPPORTED is a class-level constant, not rebuilt per instance.
+        assert RasterStructureRenderer().SUPPORTED is RasterStructureRenderer.SUPPORTED
+
+
+class TestConstruction:
+    def test_instantiation(self):
+        renderer = RasterStructureRenderer()
+        assert renderer is not None
+
+    def test_render_png_is_callable(self):
+        assert callable(RasterStructureRenderer().render_png)
+
+
+class TestRenderPngOutput:
+    def test_returns_bytes(self):
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert isinstance(png, bytes)
+
+    def test_has_png_signature(self):
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert png[:8] == PNG_MAGIC
+
+    def test_decodes_as_png(self):
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert _open(png).format == 'PNG'
+
+    def test_canvas_dimensions(self):
+        # The supersampled buffer is downsampled to a fixed 1800x1800 frame.
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert _open(png).size == (1800, 1800)
+
+    def test_rgb_mode(self):
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert _open(png).mode == 'RGB'
+
+    def test_deterministic_for_same_scene(self):
+        scene = _atom_scene()
+        first = RasterStructureRenderer().render_png(scene, features=frozenset({'atoms'}))
+        second = RasterStructureRenderer().render_png(scene, features=frozenset({'atoms'}))
+        assert first == second
+
+
+class TestRenderPngFeatures:
+    def test_atom_is_drawn(self):
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert _has_drawn_pixels(png)
+
+    def test_empty_scene_is_blank(self):
+        # No primitives and no features -> a pristine white canvas.
+        scene = StructureScene(cell_basis=CUBIC_BASIS)
+        png = RasterStructureRenderer().render_png(scene, features=frozenset())
+        assert bool((_pixels(png) == 255).all())
+
+    def test_feature_gating_skips_unrequested_atoms(self):
+        # The scene has an atom, but 'atoms' is absent from the feature
+        # set, so nothing is drawn.
+        scene = _atom_scene()
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
+        assert bool((_pixels(png) == 255).all())
+
+    def test_unknown_feature_names_are_ignored(self):
+        # Feature names outside SUPPORTED never trigger a draw and never
+        # raise; only 'atoms' here does any work.
+        scene = _atom_scene()
+        png = RasterStructureRenderer().render_png(
+            scene, features=frozenset({'atoms', 'bogus', 'labels', 'moments'})
+        )
+        assert _has_drawn_pixels(png)
+
+    def test_cell_only_is_drawn(self):
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            cell_edges=CellEdges(edges=(CellEdge(start=(0.0, 0.0, 0.0), end=(5.0, 0.0, 0.0)),)),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
+        assert _has_drawn_pixels(png)
+
+    def test_bonds_only_is_drawn(self):
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            bonds=(
+                Bond(
+                    start=(0.0, 0.0, 0.0),
+                    end=(5.0, 5.0, 5.0),
+                    start_colour=(255, 0, 0),
+                    end_colour=(0, 0, 255),
+                ),
+            ),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'bonds'}))
+        assert _has_drawn_pixels(png)
+
+    def test_axes_only_is_drawn(self):
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            atoms=(AtomSphere(centre=(0.0, 0.0, 0.0), radius=1.0, colour=(0, 0, 0), label='X'),),
+            axes=_axis_triad(),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'axes'}))
+        assert _has_drawn_pixels(png)
+
+    def test_axes_feature_without_triad_is_blank(self):
+        # 'axes' requested but scene.axes is None -> no crash, blank.
+        scene = StructureScene(cell_basis=CUBIC_BASIS)
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'axes'}))
+        assert bool((_pixels(png) == 255).all())
+
+    def test_cell_feature_without_edges_is_blank(self):
+        # 'cell' requested but scene.cell_edges is None -> no crash.
+        scene = StructureScene(cell_basis=CUBIC_BASIS)
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
+        assert bool((_pixels(png) == 255).all())
+
+    def test_full_scene_renders(self):
+        png = RasterStructureRenderer().render_png(
+            _full_scene(), features=RasterStructureRenderer.SUPPORTED
+        )
+        assert png[:8] == PNG_MAGIC
+        assert _open(png).size == (1800, 1800)
+        assert _has_drawn_pixels(png)
+
+
+class TestRenderPngPrimitives:
+    def test_occupancy_wedge_sphere_renders(self):
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            occupancy_spheres=(
+                OccupancyWedgeSphere(
+                    centre=(2.5, 2.5, 2.5),
+                    radius=1.0,
+                    wedges=(
+                        OccupancyWedge(fraction=0.6, colour=(255, 0, 0)),
+                        OccupancyWedge(fraction=0.4, colour=(0, 0, 255)),
+                    ),
+                    label='Mix',
+                ),
+            ),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'atoms'}))
+        assert _has_drawn_pixels(png)
+
+    def test_ellipsoid_renders(self):
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            ellipsoids=(
+                AdpEllipsoid(
+                    centre=(2.5, 2.5, 2.5),
+                    semi_axes=(1.0, 0.6, 0.4),
+                    orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+                    colour=(0, 200, 0),
+                    label='Ell',
+                ),
+            ),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'atoms'}))
+        assert _has_drawn_pixels(png)
+
+    def test_ellipsoid_with_wedges_renders(self):
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            ellipsoids=(
+                AdpEllipsoid(
+                    centre=(2.5, 2.5, 2.5),
+                    semi_axes=(1.0, 1.0, 1.0),
+                    orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+                    colour=(0, 200, 0),
+                    label='Ell',
+                    wedges=(
+                        OccupancyWedge(fraction=0.5, colour=(255, 0, 0)),
+                        OccupancyWedge(fraction=0.5, colour=(0, 0, 255)),
+                    ),
+                ),
+            ),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'atoms'}))
+        assert _has_drawn_pixels(png)
+
+    def test_tiny_atom_is_skipped_without_error(self):
+        # A sub-pixel radius atom is dropped by the minimum-size guard;
+        # the larger atom still renders and the call succeeds.
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            atoms=(
+                AtomSphere(centre=(0.0, 0.0, 0.0), radius=1.0, colour=(255, 0, 0), label='Fe'),
+                AtomSphere(centre=(5.0, 5.0, 5.0), radius=1e-6, colour=(0, 0, 255), label='O'),
+            ),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset({'atoms'}))
+        assert png[:8] == PNG_MAGIC
+        assert _has_drawn_pixels(png)
+
+
+class TestLegend:
+    def test_legend_is_drawn_independent_of_features(self):
+        # The legend panel is composited regardless of the feature set
+        # (it is not gated by 'atoms'/'bonds'/...).
+        scene = StructureScene(
+            cell_basis=CUBIC_BASIS,
+            legend=(LegendEntry(symbol='Fe', colour=(255, 0, 0)),),
+        )
+        png = RasterStructureRenderer().render_png(scene, features=frozenset())
+        assert _has_drawn_pixels(png)
+
+    def test_no_legend_leaves_top_left_white(self):
+        # Without a legend, the empty scene stays fully white.
+        scene = StructureScene(cell_basis=CUBIC_BASIS)
+        png = RasterStructureRenderer().render_png(scene, features=frozenset())
+        assert bool((_pixels(png) == 255).all())
+
+
+class TestViewBasis:
+    def test_anisotropic_cell_renders(self):
+        # An 8x5x3 cell drives the longest/middle/shortest axis ordering
+        # in the default-view basis selection.
+        scene = StructureScene(
+            cell_basis=((8.0, 0.0, 0.0), (0.0, 5.0, 0.0), (0.0, 0.0, 3.0)),
+            atoms=(
+                AtomSphere(centre=(4.0, 2.5, 1.5), radius=1.0, colour=(10, 20, 30), label='X'),
+            ),
+            axes=AxisTriad(
+                origin=(0.0, 0.0, 0.0),
+                axes=(
+                    AxisArrow(vector=(8.0, 0.0, 0.0), colour=(255, 0, 0), letter='a'),
+                    AxisArrow(vector=(0.0, 5.0, 0.0), colour=(0, 255, 0), letter='b'),
+                    AxisArrow(vector=(0.0, 0.0, 3.0), colour=(0, 0, 255), letter='c'),
+                ),
+            ),
+        )
+        png = RasterStructureRenderer().render_png(
+            scene, features=RasterStructureRenderer.SUPPORTED
+        )
+        assert png[:8] == PNG_MAGIC
+        assert _has_drawn_pixels(png)
+
+    def test_scene_without_axes_uses_default_basis(self):
+        # No axis triad -> the fixed fallback camera basis is used; the
+        # atom still renders.
+        png = RasterStructureRenderer().render_png(_atom_scene(), features=frozenset({'atoms'}))
+        assert _has_drawn_pixels(png)
+
+
+class TestRenderPngSignature:
+    def test_features_is_keyword_only(self):
+        # render_png(scene, *, features=...) — passing features
+        # positionally is a TypeError.
+        with pytest.raises(TypeError):
+            RasterStructureRenderer().render_png(
+                StructureScene(cell_basis=CUBIC_BASIS), frozenset()
+            )
+
+    def test_features_is_required(self):
+        # Omitting the keyword-only 'features' argument is a TypeError.
+        with pytest.raises(TypeError):
+            RasterStructureRenderer().render_png(StructureScene(cell_basis=CUBIC_BASIS))
diff --git a/tests/unit/easydiffraction/display/structure/test_builder.py b/tests/unit/easydiffraction/display/structure/test_builder.py
new file mode 100644
index 000000000..5c6fb2ae2
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/test_builder.py
@@ -0,0 +1,688 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for display/structure/builder.py (scene builder)."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from easydiffraction.datablocks.structure.item.base import Structure
+from easydiffraction.display.structure import builder as MUT
+from easydiffraction.display.structure.builder import ALL_FEATURES
+from easydiffraction.display.structure.builder import FeatureAvailability
+from easydiffraction.display.structure.builder import build_scene
+from easydiffraction.display.structure.builder import structure_feature_availability
+from easydiffraction.display.structure.enums import AtomViewEnum
+from easydiffraction.display.structure.enums import ColorSchemeEnum
+from easydiffraction.display.structure.scene import AdpEllipsoid
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import AxisTriad
+from easydiffraction.display.structure.scene import Bond
+from easydiffraction.display.structure.scene import CellEdges
+from easydiffraction.display.structure.scene import LegendEntry
+from easydiffraction.display.structure.scene import OccupancyWedgeSphere
+from easydiffraction.display.structure.scene import StructureScene
+from easydiffraction.display.structure.scene import TextLabel
+from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+# A view range covering only the asymmetric unit (no lattice images),
+# keeping P 1 scene-atom counts deterministic and equal to the number
+# of in-range sites.
+ASYMMETRIC_UNIT = ((0.0, 0.5), (0.0, 0.5), (0.0, 0.5))
+# The full conventional cell; in P 1 the cell-corner lattice images of a
+# site at the origin are deduplicated, so counts grow predictably.
+FULL_CELL = ((0.0, 1.0), (0.0, 1.0), (0.0, 1.0))
+
+
+def _make_structure(name='test', *, space_group='P 1'):
+    """Build a minimal cubic P 1 structure (no calculation engine)."""
+    structure = Structure(name=name)
+    structure.cell.length_a = 5.0
+    structure.cell.length_b = 5.0
+    structure.cell.length_c = 5.0
+    structure.space_group.name_h_m = space_group
+    return structure
+
+
+def _add_atom(
+    structure,
+    *,
+    label,
+    type_symbol,
+    fract_x=0.0,
+    fract_y=0.0,
+    fract_z=0.0,
+    occupancy=1.0,
+    adp_type='Biso',
+    adp_iso=0.5,
+):
+    structure.atom_sites.create(
+        label=label,
+        type_symbol=type_symbol,
+        fract_x=fract_x,
+        fract_y=fract_y,
+        fract_z=fract_z,
+        occupancy=occupancy,
+        adp_type=adp_type,
+        adp_iso=adp_iso,
+    )
+
+
+def _two_atom_structure(name='two', *, view_positions=True):
+    """Two distinct in-range sites (Fe + O) for bond/atom tests."""
+    structure = _make_structure(name)
+    offset = (0.1, 0.1, 0.1) if view_positions else (0.0, 0.0, 0.0)
+    _add_atom(
+        structure,
+        label='Fe1',
+        type_symbol='Fe',
+        fract_x=offset[0],
+        fract_y=offset[1],
+        fract_z=offset[2],
+    )
+    _add_atom(
+        structure,
+        label='O1',
+        type_symbol='O',
+        fract_x=offset[0] + 0.2,
+        fract_y=offset[1],
+        fract_z=offset[2],
+    )
+    structure._sync_atom_site_aniso()
+    return structure
+
+
+def _anisotropic_structure(name='aniso'):
+    """One anisotropic (Uani) Fe site with a non-spherical U tensor.
+
+    Created isotropic first, then flipped to ``Uani`` on the existing
+    site (the supported edit path) before the aniso components are set.
+    """
+    structure = _make_structure(name)
+    _add_atom(
+        structure,
+        label='Fe1',
+        type_symbol='Fe',
+        fract_x=0.1,
+        fract_y=0.1,
+        fract_z=0.1,
+        adp_type='Uiso',
+        adp_iso=0.01,
+    )
+    structure.atom_sites['Fe1'].adp_type = 'Uani'
+    structure._sync_atom_site_aniso()
+    aniso = structure.atom_site_aniso['Fe1']
+    aniso.adp_11 = 0.01
+    aniso.adp_22 = 0.02
+    aniso.adp_33 = 0.03
+    return structure
+
+
+# ======================================================================
+#  Module import + public surface
+# ======================================================================
+
+
+class TestModule:
+    def test_module_import(self):
+        assert MUT.__name__ == 'easydiffraction.display.structure.builder'
+
+    def test_all_features_constant(self):
+        # The resolved feature names the facade can ask the builder for.
+        assert set(ALL_FEATURES) == {'atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'}
+
+    def test_all_features_is_tuple(self):
+        # A stable, immutable ordering for UI listings.
+        assert isinstance(ALL_FEATURES, tuple)
+
+
+# ======================================================================
+#  FeatureAvailability dataclass
+# ======================================================================
+
+
+class TestFeatureAvailability:
+    def test_construction_and_fields(self):
+        availability = FeatureAvailability(
+            available=frozenset({'atoms', 'cell'}),
+            radius_substitutions=('H', 'He'),
+        )
+        assert availability.available == frozenset({'atoms', 'cell'})
+        assert availability.radius_substitutions == ('H', 'He')
+
+    def test_is_frozen(self):
+        availability = FeatureAvailability(available=frozenset(), radius_substitutions=())
+        with pytest.raises((AttributeError, TypeError)):
+            availability.available = frozenset({'atoms'})
+
+
+# ======================================================================
+#  structure_feature_availability
+# ======================================================================
+
+
+class TestStructureFeatureAvailability:
+    def test_returns_feature_availability(self):
+        structure = _two_atom_structure()
+        result = structure_feature_availability(structure, style=StructureStyle())
+        assert isinstance(result, FeatureAvailability)
+
+    def test_populated_structure_supports_all_features(self):
+        structure = _two_atom_structure()
+        result = structure_feature_availability(structure, style=StructureStyle())
+        assert result.available == frozenset({'atoms', 'bonds', 'cell', 'axes', 'labels'})
+
+    def test_empty_structure_supports_only_cell_and_axes(self):
+        # With no atom sites, only the cell box and axis triad are drawable.
+        structure = _make_structure('empty')
+        result = structure_feature_availability(structure, style=StructureStyle())
+        assert result.available == frozenset({'cell', 'axes'})
+
+    def test_no_substitutions_for_well_covered_elements(self):
+        structure = _two_atom_structure()
+        result = structure_feature_availability(structure, style=StructureStyle())
+        assert result.radius_substitutions == ()
+
+    def test_reports_ionic_substitution_for_hydrogen(self):
+        # H has no ionic radius, so the ionic view falls back to covalent
+        # and reports the substitution.
+        structure = _make_structure('hydride')
+        _add_atom(structure, label='H1', type_symbol='H', fract_x=0.1, fract_y=0.1, fract_z=0.1)
+        structure._sync_atom_site_aniso()
+        style = StructureStyle()
+        style.atom_view = 'ionic'
+        result = structure_feature_availability(structure, style=style)
+        assert result.radius_substitutions == ('H',)
+
+    def test_substitutions_sorted_and_deduplicated(self):
+        # Two H atoms and one He atom under the ionic view -> one entry per
+        # element, alphabetically sorted.
+        structure = _make_structure('light')
+        _add_atom(structure, label='H1', type_symbol='H', fract_x=0.1, fract_y=0.1, fract_z=0.1)
+        _add_atom(structure, label='H2', type_symbol='H', fract_x=0.2, fract_y=0.2, fract_z=0.2)
+        _add_atom(structure, label='He1', type_symbol='He', fract_x=0.3, fract_y=0.3, fract_z=0.3)
+        structure._sync_atom_site_aniso()
+        style = StructureStyle()
+        style.atom_view = 'ionic'
+        result = structure_feature_availability(structure, style=style)
+        assert result.radius_substitutions == ('H', 'He')
+
+
+# ======================================================================
+#  build_scene — return type and cell basis
+# ======================================================================
+
+
+class TestBuildSceneBasics:
+    def test_returns_structure_scene(self):
+        scene = build_scene(
+            _two_atom_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset(ALL_FEATURES),
+        )
+        assert isinstance(scene, StructureScene)
+
+    def test_cell_basis_matches_cubic_cell(self):
+        scene = build_scene(
+            _two_atom_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset(),
+        )
+        # Cubic 5 angstrom cell -> orthogonal basis with 5 on the diagonal.
+        basis = np.array(scene.cell_basis)
+        assert np.allclose(basis, np.diag([5.0, 5.0, 5.0]), atol=1e-6)
+
+
+# ======================================================================
+#  build_scene — feature gating
+# ======================================================================
+
+
+class TestBuildSceneFeatureGating:
+    def _scene(self, features):
+        return build_scene(
+            _two_atom_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset(features),
+        )
+
+    def test_empty_features_emits_nothing_drawable(self):
+        scene = self._scene(frozenset())
+        assert scene.atoms == ()
+        assert scene.occupancy_spheres == ()
+        assert scene.ellipsoids == ()
+        assert scene.bonds == ()
+        assert scene.labels == ()
+        assert scene.legend == ()
+        assert scene.cell_edges is None
+        assert scene.axes is None
+        # cell_basis is always present regardless of features.
+        assert scene.cell_basis is not None
+
+    def test_atoms_feature_emits_atoms_and_legend(self):
+        scene = self._scene({'atoms'})
+        assert len(scene.atoms) == 2
+        assert len(scene.legend) == 2
+        # No other features requested.
+        assert scene.bonds == ()
+        assert scene.cell_edges is None
+        assert scene.axes is None
+        assert scene.labels == ()
+
+    def test_legend_omitted_without_atoms_feature(self):
+        scene = self._scene({'cell'})
+        assert scene.legend == ()
+
+    def test_bonds_feature_emits_bonds(self):
+        scene = self._scene({'atoms', 'bonds'})
+        assert len(scene.bonds) == 1
+
+    def test_bonds_omitted_without_bonds_feature(self):
+        scene = self._scene({'atoms'})
+        assert scene.bonds == ()
+
+    def test_cell_feature_emits_twelve_edges(self):
+        scene = self._scene({'cell'})
+        assert isinstance(scene.cell_edges, CellEdges)
+        assert len(scene.cell_edges.edges) == 12
+
+    def test_axes_feature_emits_triad(self):
+        scene = self._scene({'axes'})
+        assert isinstance(scene.axes, AxisTriad)
+        assert len(scene.axes.axes) == 3
+
+    def test_labels_feature_emits_one_label_per_atom(self):
+        scene = self._scene({'labels'})
+        assert len(scene.labels) == 2
+        assert all(isinstance(label, TextLabel) for label in scene.labels)
+
+    def test_full_features_emit_every_section(self):
+        scene = self._scene(ALL_FEATURES)
+        assert len(scene.atoms) == 2
+        assert len(scene.bonds) == 1
+        assert len(scene.labels) == 2
+        assert len(scene.legend) == 2
+        assert scene.cell_edges is not None
+        assert scene.axes is not None
+
+
+# ======================================================================
+#  build_scene — atom primitives
+# ======================================================================
+
+
+class TestBuildSceneAtomPrimitives:
+    def test_ball_view_emits_atom_spheres(self):
+        style = StructureStyle()
+        style.atom_view = 'vdw'
+        scene = build_scene(
+            _two_atom_structure(),
+            style=style,
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        assert all(isinstance(atom, AtomSphere) for atom in scene.atoms)
+        assert all(atom.radius > 0.0 for atom in scene.atoms)
+        assert scene.ellipsoids == ()
+
+    def test_atom_scale_grows_ball_radius(self):
+        small = StructureStyle()
+        small.atom_view = 'vdw'
+        small.atom_scale = 0.2
+        large = StructureStyle()
+        large.atom_view = 'vdw'
+        large.atom_scale = 0.8
+        structure = _two_atom_structure()
+        scene_small = build_scene(
+            structure, style=small, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        scene_large = build_scene(
+            structure, style=large, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        assert scene_large.atoms[0].radius > scene_small.atoms[0].radius
+
+    def test_adp_view_anisotropic_atom_emits_ellipsoid(self):
+        structure = _anisotropic_structure()
+        style = StructureStyle()
+        style.atom_view = 'adp'
+        scene = build_scene(
+            structure, style=style, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        assert len(scene.ellipsoids) == 1
+        assert scene.atoms == ()
+        ellipsoid = scene.ellipsoids[0]
+        assert isinstance(ellipsoid, AdpEllipsoid)
+        assert all(axis > 0.0 for axis in ellipsoid.semi_axes)
+
+    def test_adp_probability_scales_ellipsoid_size(self):
+        structure = _anisotropic_structure()
+        low = StructureStyle()
+        low.atom_view = 'adp'
+        low.adp_probability = 0.5
+        high = StructureStyle()
+        high.atom_view = 'adp'
+        high.adp_probability = 0.99
+        scene_low = build_scene(
+            structure, style=low, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        scene_high = build_scene(
+            structure, style=high, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        # Higher probability -> larger principal semi-axes.
+        assert scene_high.ellipsoids[0].semi_axes[0] > scene_low.ellipsoids[0].semi_axes[0]
+
+    def test_reference_atom_marked_asymmetric(self):
+        # The atom at the asymmetric-unit reference position is flagged so
+        # renderers can offer an asymmetric-unit-only toggle.
+        structure = _two_atom_structure()
+        scene = build_scene(
+            structure,
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        assert any(atom.asymmetric for atom in scene.atoms)
+
+
+# ======================================================================
+#  build_scene — mixed-occupancy (wedge) sites
+# ======================================================================
+
+
+class TestBuildSceneOccupancyWedges:
+    def _shared_site_structure(self):
+        structure = _make_structure('mixed')
+        _add_atom(
+            structure,
+            label='Fe1',
+            type_symbol='Fe',
+            fract_x=0.1,
+            fract_y=0.1,
+            fract_z=0.1,
+            occupancy=0.6,
+        )
+        _add_atom(
+            structure,
+            label='Mn1',
+            type_symbol='Mn',
+            fract_x=0.1,
+            fract_y=0.1,
+            fract_z=0.1,
+            occupancy=0.4,
+        )
+        structure._sync_atom_site_aniso()
+        return structure
+
+    def test_shared_site_emits_occupancy_wedge_sphere(self):
+        style = StructureStyle()
+        style.atom_view = 'vdw'
+        scene = build_scene(
+            self._shared_site_structure(),
+            style=style,
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        assert scene.atoms == ()
+        assert len(scene.occupancy_spheres) == 1
+        assert isinstance(scene.occupancy_spheres[0], OccupancyWedgeSphere)
+
+    def test_wedge_label_joins_member_labels(self):
+        scene = build_scene(
+            self._shared_site_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        sphere = scene.occupancy_spheres[0]
+        assert sphere.label == 'Fe1/Mn1'
+
+    def test_wedges_use_relative_proportions(self):
+        scene = build_scene(
+            self._shared_site_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        fractions = [wedge.fraction for wedge in scene.occupancy_spheres[0].wedges]
+        assert pytest.approx(sum(fractions), abs=1e-9) == 1.0
+        assert pytest.approx(fractions[0], abs=1e-9) == 0.6
+        assert pytest.approx(fractions[1], abs=1e-9) == 0.4
+
+
+# ======================================================================
+#  build_scene — bonds
+# ======================================================================
+
+
+class TestBuildSceneBonds:
+    def test_single_atom_has_no_bonds(self):
+        structure = _make_structure('single')
+        _add_atom(structure, label='Fe1', type_symbol='Fe', fract_x=0.1, fract_y=0.1, fract_z=0.1)
+        structure._sync_atom_site_aniso()
+        scene = build_scene(
+            structure,
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'bonds'}),
+        )
+        assert scene.bonds == ()
+
+    def test_close_atoms_bond(self):
+        scene = build_scene(
+            _two_atom_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'bonds'}),
+        )
+        assert len(scene.bonds) == 1
+        bond = scene.bonds[0]
+        assert isinstance(bond, Bond)
+        assert {bond.start_element, bond.end_element} == {'Fe', 'O'}
+
+    def test_min_distance_cutoff_suppresses_bond(self):
+        # Raising the minimum bonded distance above the actual Fe-O
+        # distance removes the bond.
+        structure = _two_atom_structure()
+        structure.geom.min_bond_distance_cutoff = 5.0
+        scene = build_scene(
+            structure,
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'bonds'}),
+        )
+        assert scene.bonds == ()
+
+    def test_bond_distance_incr_enables_distant_bond(self):
+        # Two atoms 2.5 angstrom apart (beyond summed covalent radii)
+        # bond only once the increment is generous enough.
+        structure = _make_structure('stretch')
+        _add_atom(structure, label='Fe1', type_symbol='Fe', fract_x=0.0, fract_y=0.0, fract_z=0.0)
+        _add_atom(structure, label='Fe2', type_symbol='Fe', fract_x=0.5, fract_y=0.0, fract_z=0.0)
+        structure._sync_atom_site_aniso()
+
+        structure.geom.bond_distance_incr = 0.0
+        scene_tight = build_scene(
+            structure,
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'bonds'}),
+        )
+
+        structure.geom.bond_distance_incr = 5.0
+        scene_loose = build_scene(
+            structure,
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'bonds'}),
+        )
+
+        assert len(scene_loose.bonds) >= len(scene_tight.bonds)
+        assert len(scene_loose.bonds) >= 1
+
+
+# ======================================================================
+#  build_scene — colour scheme + legend
+# ======================================================================
+
+
+class TestBuildSceneColours:
+    def test_legend_has_one_entry_per_element(self):
+        scene = build_scene(
+            _two_atom_structure(),
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        symbols = [entry.symbol for entry in scene.legend]
+        assert symbols == ['Fe', 'O']
+        assert all(isinstance(entry, LegendEntry) for entry in scene.legend)
+
+    def test_colour_scheme_changes_atom_colour(self):
+        structure = _two_atom_structure()
+        jmol = StructureStyle()
+        jmol.atom_view = 'vdw'
+        jmol.color_scheme = 'jmol'
+        vesta = StructureStyle()
+        vesta.atom_view = 'vdw'
+        vesta.color_scheme = 'vesta'
+        scene_jmol = build_scene(
+            structure, style=jmol, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        scene_vesta = build_scene(
+            structure, style=vesta, view_range=ASYMMETRIC_UNIT, features=frozenset({'atoms'})
+        )
+        jmol_colours = {atom.label: atom.colour for atom in scene_jmol.atoms}
+        vesta_colours = {atom.label: atom.colour for atom in scene_vesta.atoms}
+        # At least one element is coloured differently between schemes.
+        assert jmol_colours != vesta_colours
+
+
+# ======================================================================
+#  build_scene — symmetry expansion
+# ======================================================================
+
+
+class TestBuildSceneSymmetry:
+    def test_higher_symmetry_generates_more_atoms(self):
+        # The same single site expands to more scene atoms under a
+        # higher-symmetry space group than under P 1.
+        p1 = _make_structure('p1', space_group='P 1')
+        _add_atom(p1, label='Fe1', type_symbol='Fe', fract_x=0.3, fract_y=0.1, fract_z=0.2)
+        p1._sync_atom_site_aniso()
+        scene_p1 = build_scene(
+            p1, style=StructureStyle(), view_range=FULL_CELL, features=frozenset({'atoms'})
+        )
+
+        cubic = _make_structure('cubic', space_group='P m -3 m')
+        _add_atom(cubic, label='Fe1', type_symbol='Fe', fract_x=0.3, fract_y=0.1, fract_z=0.2)
+        cubic._sync_atom_site_aniso()
+        scene_cubic = build_scene(
+            cubic, style=StructureStyle(), view_range=FULL_CELL, features=frozenset({'atoms'})
+        )
+
+        n_cubic = (
+            len(scene_cubic.atoms)
+            + len(scene_cubic.occupancy_spheres)
+            + len(scene_cubic.ellipsoids)
+        )
+        n_p1 = len(scene_p1.atoms) + len(scene_p1.occupancy_spheres) + len(scene_p1.ellipsoids)
+        assert n_cubic > n_p1
+
+    def test_p1_emits_one_atom_per_in_range_site(self):
+        # In P 1 the only operator is the identity, so within the
+        # asymmetric-unit range each site yields exactly one scene atom.
+        structure = _make_structure('p1', space_group='P 1')
+        _add_atom(structure, label='Fe1', type_symbol='Fe', fract_x=0.1, fract_y=0.1, fract_z=0.1)
+        _add_atom(structure, label='O1', type_symbol='O', fract_x=0.3, fract_y=0.2, fract_z=0.2)
+        structure._sync_atom_site_aniso()
+        scene = build_scene(
+            structure,
+            style=StructureStyle(),
+            view_range=ASYMMETRIC_UNIT,
+            features=frozenset({'atoms'}),
+        )
+        assert len(scene.atoms) == 2
+
+
+# ======================================================================
+#  Value selectors (EnumDescriptor.show_supported) driving the builder
+# ======================================================================
+
+
+class TestValueSelectors:
+    def test_atom_view_show_supported_lists_all_values(self, capsys):
+        StructureStyle().atom_view.show_supported()
+        out = capsys.readouterr().out
+        for member in AtomViewEnum:
+            assert member.value in out
+
+    def test_color_scheme_show_supported_lists_all_values(self, capsys):
+        StructureStyle().color_scheme.show_supported()
+        out = capsys.readouterr().out
+        for member in ColorSchemeEnum:
+            assert member.value in out
+
+    def test_atom_view_enum_backing(self):
+        # The selector is bound to the closed AtomViewEnum value set.
+        assert StructureStyle().atom_view.enum is AtomViewEnum
+
+    def test_color_scheme_enum_backing(self):
+        assert StructureStyle().color_scheme.enum is ColorSchemeEnum
+
+
+# ======================================================================
+#  StructureStyle wiring (the style object the builder reads)
+# ======================================================================
+
+
+class TestStructureStyleInputs:
+    def test_default_atom_view_is_adp(self):
+        assert StructureStyle().atom_view.value == AtomViewEnum.ADP.value
+
+    def test_default_color_scheme_is_jmol(self):
+        assert StructureStyle().color_scheme.value == ColorSchemeEnum.JMOL.value
+
+    def test_atom_view_cif_handler_name(self):
+        assert StructureStyle().atom_view._cif_handler.names == ['_structure_style.atom_view']
+
+    def test_color_scheme_cif_handler_name(self):
+        assert StructureStyle().color_scheme._cif_handler.names == [
+            '_structure_style.color_scheme'
+        ]
+
+    def test_invalid_atom_view_rejected(self):
+        with pytest.raises(ValueError, match='not a valid AtomViewEnum'):
+            StructureStyle().atom_view = 'not-a-view'
+
+    def test_invalid_color_scheme_rejected(self):
+        with pytest.raises(ValueError, match='not a valid ColorSchemeEnum'):
+            StructureStyle().color_scheme = 'not-a-scheme'
+
+
+# ======================================================================
+#  Pure helper functions (load-bearing for element/colour mapping)
+# ======================================================================
+
+
+class TestHelpers:
+    @pytest.mark.parametrize(
+        ('type_symbol', 'expected'),
+        [
+            ('Fe', 'Fe'),
+            ('Fe3+', 'Fe'),
+            ('O2-', 'O'),
+            ('Cl', 'Cl'),
+            ('  Na+ ', 'Na'),
+        ],
+    )
+    def test_element_symbol_extraction(self, type_symbol, expected):
+        assert MUT._element_symbol(type_symbol) == expected
+
+    def test_vec3_casts_to_float_tuple(self):
+        result = MUT._vec3(np.array([1, 2, 3]))
+        assert result == (1.0, 2.0, 3.0)
+        assert all(isinstance(component, float) for component in result)
diff --git a/tests/unit/easydiffraction/display/structure/test_enums.py b/tests/unit/easydiffraction/display/structure/test_enums.py
new file mode 100644
index 000000000..9ca8def6d
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/test_enums.py
@@ -0,0 +1,162 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the crysview structure-view enumerations."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+import pytest
+
+import easydiffraction.display.structure.enums as enums_mod
+from easydiffraction.display.structure.enums import AtomViewEnum
+from easydiffraction.display.structure.enums import ColorSchemeEnum
+from easydiffraction.display.structure.enums import ViewerEngineEnum
+
+
+def test_module_import():
+    expected_module_name = 'easydiffraction.display.structure.enums'
+    assert enums_mod.__name__ == expected_module_name
+
+
+# ----------------------------------------------------------------------
+# ViewerEngineEnum
+# ----------------------------------------------------------------------
+
+
+class TestViewerEngineEnum:
+    def test_is_str_enum(self):
+        assert issubclass(ViewerEngineEnum, StrEnum)
+
+    def test_members(self):
+        assert ViewerEngineEnum.ASCII == 'ascii'
+        assert ViewerEngineEnum.THREEJS == 'threejs'
+
+    def test_member_count(self):
+        assert {member.value for member in ViewerEngineEnum} == {'ascii', 'threejs'}
+
+    def test_from_string(self):
+        assert ViewerEngineEnum('ascii') is ViewerEngineEnum.ASCII
+        assert ViewerEngineEnum('threejs') is ViewerEngineEnum.THREEJS
+
+    def test_invalid_string(self):
+        with pytest.raises(ValueError, match='is not a valid ViewerEngineEnum'):
+            ViewerEngineEnum('opengl')
+
+    def test_default_is_ascii_outside_jupyter(self, monkeypatch):
+        monkeypatch.setattr(enums_mod, 'in_jupyter', lambda: False)
+        assert ViewerEngineEnum.default() is ViewerEngineEnum.ASCII
+
+    def test_default_is_threejs_in_jupyter(self, monkeypatch):
+        monkeypatch.setattr(enums_mod, 'in_jupyter', lambda: True)
+        assert ViewerEngineEnum.default() is ViewerEngineEnum.THREEJS
+
+    def test_description_ascii(self):
+        assert ViewerEngineEnum.ASCII.description() == 'Console ASCII schematic structure view'
+
+    def test_description_threejs(self):
+        assert ViewerEngineEnum.THREEJS.description() == 'Interactive Three.js 3D structure view'
+
+    def test_every_member_has_nonempty_description(self):
+        for member in ViewerEngineEnum:
+            assert member.description()
+
+
+# ----------------------------------------------------------------------
+# AtomViewEnum
+# ----------------------------------------------------------------------
+
+
+class TestAtomViewEnum:
+    def test_is_str_enum(self):
+        assert issubclass(AtomViewEnum, StrEnum)
+
+    def test_members(self):
+        assert AtomViewEnum.VDW == 'vdw'
+        assert AtomViewEnum.COVALENT == 'covalent'
+        assert AtomViewEnum.IONIC == 'ionic'
+        assert AtomViewEnum.ADP == 'adp'
+
+    def test_member_count(self):
+        assert {member.value for member in AtomViewEnum} == {
+            'vdw',
+            'covalent',
+            'ionic',
+            'adp',
+        }
+
+    def test_from_string(self):
+        assert AtomViewEnum('vdw') is AtomViewEnum.VDW
+        assert AtomViewEnum('covalent') is AtomViewEnum.COVALENT
+        assert AtomViewEnum('ionic') is AtomViewEnum.IONIC
+        assert AtomViewEnum('adp') is AtomViewEnum.ADP
+
+    def test_invalid_string(self):
+        with pytest.raises(ValueError, match='is not a valid AtomViewEnum'):
+            AtomViewEnum('atomic')
+
+    def test_default_is_adp(self):
+        assert AtomViewEnum.default() is AtomViewEnum.ADP
+
+    def test_is_adp_true_only_for_adp(self):
+        assert AtomViewEnum.ADP.is_adp is True
+        assert AtomViewEnum.VDW.is_adp is False
+        assert AtomViewEnum.COVALENT.is_adp is False
+        assert AtomViewEnum.IONIC.is_adp is False
+
+    def test_radius_model_radius_views_return_own_value(self):
+        assert AtomViewEnum.VDW.radius_model() == 'vdw'
+        assert AtomViewEnum.COVALENT.radius_model() == 'covalent'
+        assert AtomViewEnum.IONIC.radius_model() == 'ionic'
+
+    def test_radius_model_adp_falls_back_to_covalent(self):
+        assert AtomViewEnum.ADP.radius_model() == AtomViewEnum.COVALENT.value
+        assert AtomViewEnum.ADP.radius_model() == 'covalent'
+
+    def test_description_per_member(self):
+        assert AtomViewEnum.VDW.description() == 'Van der Waals radius balls'
+        assert AtomViewEnum.COVALENT.description() == 'Covalent radius balls'
+        assert AtomViewEnum.IONIC.description() == 'Ionic (Shannon) radius balls'
+        assert AtomViewEnum.ADP.description() == 'ADP probability surfaces (spheres / ellipsoids)'
+
+    def test_every_member_has_nonempty_description(self):
+        for member in AtomViewEnum:
+            assert member.description()
+
+
+# ----------------------------------------------------------------------
+# ColorSchemeEnum
+# ----------------------------------------------------------------------
+
+
+class TestColorSchemeEnum:
+    def test_is_str_enum(self):
+        assert issubclass(ColorSchemeEnum, StrEnum)
+
+    def test_members(self):
+        assert ColorSchemeEnum.JMOL == 'jmol'
+        assert ColorSchemeEnum.VESTA == 'vesta'
+
+    def test_member_count(self):
+        assert {member.value for member in ColorSchemeEnum} == {'jmol', 'vesta'}
+
+    def test_from_string(self):
+        assert ColorSchemeEnum('jmol') is ColorSchemeEnum.JMOL
+        assert ColorSchemeEnum('vesta') is ColorSchemeEnum.VESTA
+
+    def test_invalid_string(self):
+        with pytest.raises(ValueError, match='is not a valid ColorSchemeEnum'):
+            ColorSchemeEnum('cpk')
+
+    def test_default_is_jmol(self):
+        assert ColorSchemeEnum.default() is ColorSchemeEnum.JMOL
+
+    def test_description_jmol(self):
+        assert ColorSchemeEnum.JMOL.description() == 'Jmol / CPK colour scheme'
+
+    def test_description_vesta(self):
+        assert ColorSchemeEnum.VESTA.description() == 'VESTA colour scheme'
+
+    def test_every_member_has_nonempty_description(self):
+        for member in ColorSchemeEnum:
+            assert member.description()
diff --git a/tests/unit/easydiffraction/display/structure/test_scene.py b/tests/unit/easydiffraction/display/structure/test_scene.py
new file mode 100644
index 000000000..1dcdde0cd
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/test_scene.py
@@ -0,0 +1,511 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for renderer-neutral structure scene primitives."""
+
+from __future__ import annotations
+
+import dataclasses
+
+import pytest
+
+import easydiffraction.display.structure.scene as scene_module
+from easydiffraction.display.structure.scene import AdpEllipsoid
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import AxisArrow
+from easydiffraction.display.structure.scene import AxisTriad
+from easydiffraction.display.structure.scene import Bond
+from easydiffraction.display.structure.scene import CellEdge
+from easydiffraction.display.structure.scene import CellEdges
+from easydiffraction.display.structure.scene import LegendEntry
+from easydiffraction.display.structure.scene import MomentArrow
+from easydiffraction.display.structure.scene import OccupancyWedge
+from easydiffraction.display.structure.scene import OccupancyWedgeSphere
+from easydiffraction.display.structure.scene import StructureScene
+from easydiffraction.display.structure.scene import TextLabel
+
+# ------------------------------------------------------------------
+#  Shared minimal building blocks (no engine, no domain types)
+# ------------------------------------------------------------------
+
+ORIGIN = (0.0, 0.0, 0.0)
+IDENTITY_BASIS = (
+    (1.0, 0.0, 0.0),
+    (0.0, 1.0, 0.0),
+    (0.0, 0.0, 1.0),
+)
+RED = (255, 0, 0)
+GREEN = (0, 255, 0)
+BLUE = (0, 0, 255)
+
+# Every primitive dataclass declared in the module, used by the
+# cross-cutting structural tests below.
+ALL_PRIMITIVES = (
+    AtomSphere,
+    OccupancyWedge,
+    OccupancyWedgeSphere,
+    AdpEllipsoid,
+    Bond,
+    MomentArrow,
+    CellEdge,
+    CellEdges,
+    AxisArrow,
+    AxisTriad,
+    TextLabel,
+    LegendEntry,
+    StructureScene,
+)
+
+
+# ------------------------------------------------------------------
+#  Module identity and import surface
+# ------------------------------------------------------------------
+
+
+def test_module_import():
+    expected_module_name = 'easydiffraction.display.structure.scene'
+    actual_module_name = scene_module.__name__
+    assert expected_module_name == actual_module_name
+
+
+def test_type_aliases_present():
+    # The plain coordinate/colour aliases are part of the public surface
+    # and must stay free of numpy/domain types (they are plain tuples).
+    assert scene_module.Vec3 == tuple[float, float, float]
+    assert scene_module.Rgb == tuple[int, int, int]
+    assert scene_module.Mat3 == tuple[scene_module.Vec3, scene_module.Vec3, scene_module.Vec3]
+
+
+# ------------------------------------------------------------------
+#  Cross-cutting dataclass contract: frozen + slots
+# ------------------------------------------------------------------
+
+
+class TestDataclassContract:
+    """Every primitive is a frozen, slotted dataclass."""
+
+    @pytest.mark.parametrize('cls', ALL_PRIMITIVES)
+    def test_is_dataclass(self, cls):
+        assert dataclasses.is_dataclass(cls)
+
+    @pytest.mark.parametrize('cls', ALL_PRIMITIVES)
+    def test_is_frozen(self, cls):
+        params = cls.__dataclass_params__
+        assert params.frozen is True
+
+    @pytest.mark.parametrize('cls', ALL_PRIMITIVES)
+    def test_uses_slots(self, cls):
+        # slots=True classes have a __slots__ and no per-instance __dict__.
+        assert hasattr(cls, '__slots__')
+        assert '__dict__' not in cls.__slots__
+
+
+# ------------------------------------------------------------------
+#  AtomSphere
+# ------------------------------------------------------------------
+
+
+class TestAtomSphere:
+    def test_construction_and_fields(self):
+        atom = AtomSphere(centre=(1.0, 2.0, 3.0), radius=0.5, colour=RED, label='Fe')
+        assert atom.centre == (1.0, 2.0, 3.0)
+        assert atom.radius == 0.5
+        assert atom.colour == RED
+        assert atom.label == 'Fe'
+
+    def test_asymmetric_defaults_false(self):
+        atom = AtomSphere(centre=ORIGIN, radius=1.0, colour=BLUE, label='O')
+        assert atom.asymmetric is False
+
+    def test_asymmetric_can_be_set(self):
+        atom = AtomSphere(centre=ORIGIN, radius=1.0, colour=BLUE, label='O', asymmetric=True)
+        assert atom.asymmetric is True
+
+    def test_frozen_rejects_mutation(self):
+        atom = AtomSphere(centre=ORIGIN, radius=1.0, colour=RED, label='Fe')
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            atom.radius = 2.0
+
+    def test_equality_by_value(self):
+        a = AtomSphere(centre=ORIGIN, radius=1.0, colour=RED, label='Fe')
+        b = AtomSphere(centre=ORIGIN, radius=1.0, colour=RED, label='Fe')
+        assert a == b
+
+
+# ------------------------------------------------------------------
+#  OccupancyWedge
+# ------------------------------------------------------------------
+
+
+class TestOccupancyWedge:
+    def test_construction_and_fields(self):
+        wedge = OccupancyWedge(fraction=0.25, colour=GREEN)
+        assert wedge.fraction == 0.25
+        assert wedge.colour == GREEN
+
+    def test_frozen_rejects_mutation(self):
+        wedge = OccupancyWedge(fraction=0.25, colour=GREEN)
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            wedge.fraction = 0.5
+
+
+# ------------------------------------------------------------------
+#  OccupancyWedgeSphere
+# ------------------------------------------------------------------
+
+
+class TestOccupancyWedgeSphere:
+    def test_construction_and_fields(self):
+        wedges = (
+            OccupancyWedge(fraction=0.7, colour=RED),
+            OccupancyWedge(fraction=0.3, colour=BLUE),
+        )
+        sphere = OccupancyWedgeSphere(
+            centre=(0.5, 0.5, 0.5),
+            radius=0.8,
+            wedges=wedges,
+            label='Fe/Mn',
+        )
+        assert sphere.centre == (0.5, 0.5, 0.5)
+        assert sphere.radius == 0.8
+        assert sphere.wedges == wedges
+        assert sphere.label == 'Fe/Mn'
+
+    def test_asymmetric_defaults_false(self):
+        sphere = OccupancyWedgeSphere(centre=ORIGIN, radius=1.0, wedges=(), label='X')
+        assert sphere.asymmetric is False
+
+    def test_asymmetric_can_be_set(self):
+        sphere = OccupancyWedgeSphere(
+            centre=ORIGIN,
+            radius=1.0,
+            wedges=(),
+            label='X',
+            asymmetric=True,
+        )
+        assert sphere.asymmetric is True
+
+    def test_frozen_rejects_mutation(self):
+        sphere = OccupancyWedgeSphere(centre=ORIGIN, radius=1.0, wedges=(), label='X')
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            sphere.radius = 2.0
+
+
+# ------------------------------------------------------------------
+#  AdpEllipsoid
+# ------------------------------------------------------------------
+
+
+class TestAdpEllipsoid:
+    def test_construction_and_fields(self):
+        ellipsoid = AdpEllipsoid(
+            centre=(0.1, 0.2, 0.3),
+            semi_axes=(0.4, 0.5, 0.6),
+            orientation=IDENTITY_BASIS,
+            colour=RED,
+            label='Fe',
+        )
+        assert ellipsoid.centre == (0.1, 0.2, 0.3)
+        assert ellipsoid.semi_axes == (0.4, 0.5, 0.6)
+        assert ellipsoid.orientation == IDENTITY_BASIS
+        assert ellipsoid.colour == RED
+        assert ellipsoid.label == 'Fe'
+
+    def test_wedges_default_empty(self):
+        ellipsoid = AdpEllipsoid(
+            centre=ORIGIN,
+            semi_axes=(1.0, 1.0, 1.0),
+            orientation=IDENTITY_BASIS,
+            colour=RED,
+            label='Fe',
+        )
+        assert ellipsoid.wedges == ()
+
+    def test_asymmetric_defaults_false(self):
+        ellipsoid = AdpEllipsoid(
+            centre=ORIGIN,
+            semi_axes=(1.0, 1.0, 1.0),
+            orientation=IDENTITY_BASIS,
+            colour=RED,
+            label='Fe',
+        )
+        assert ellipsoid.asymmetric is False
+
+    def test_optional_fields_can_be_set(self):
+        wedges = (OccupancyWedge(fraction=0.5, colour=RED),)
+        ellipsoid = AdpEllipsoid(
+            centre=ORIGIN,
+            semi_axes=(1.0, 1.0, 1.0),
+            orientation=IDENTITY_BASIS,
+            colour=RED,
+            label='Fe',
+            wedges=wedges,
+            asymmetric=True,
+        )
+        assert ellipsoid.wedges == wedges
+        assert ellipsoid.asymmetric is True
+
+    def test_frozen_rejects_mutation(self):
+        ellipsoid = AdpEllipsoid(
+            centre=ORIGIN,
+            semi_axes=(1.0, 1.0, 1.0),
+            orientation=IDENTITY_BASIS,
+            colour=RED,
+            label='Fe',
+        )
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            ellipsoid.colour = BLUE
+
+
+# ------------------------------------------------------------------
+#  Bond
+# ------------------------------------------------------------------
+
+
+class TestBond:
+    def test_construction_and_fields(self):
+        bond = Bond(
+            start=ORIGIN,
+            end=(1.0, 1.0, 1.0),
+            start_colour=RED,
+            end_colour=BLUE,
+        )
+        assert bond.start == ORIGIN
+        assert bond.end == (1.0, 1.0, 1.0)
+        assert bond.start_colour == RED
+        assert bond.end_colour == BLUE
+
+    def test_element_fields_default_empty(self):
+        bond = Bond(start=ORIGIN, end=(1.0, 0.0, 0.0), start_colour=RED, end_colour=BLUE)
+        assert bond.start_element == ''
+        assert bond.end_element == ''
+
+    def test_element_fields_can_be_set(self):
+        bond = Bond(
+            start=ORIGIN,
+            end=(1.0, 0.0, 0.0),
+            start_colour=RED,
+            end_colour=BLUE,
+            start_element='Fe',
+            end_element='O',
+        )
+        assert bond.start_element == 'Fe'
+        assert bond.end_element == 'O'
+
+    def test_frozen_rejects_mutation(self):
+        bond = Bond(start=ORIGIN, end=(1.0, 0.0, 0.0), start_colour=RED, end_colour=BLUE)
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            bond.start_colour = GREEN
+
+
+# ------------------------------------------------------------------
+#  MomentArrow
+# ------------------------------------------------------------------
+
+
+class TestMomentArrow:
+    def test_construction_and_fields(self):
+        moment = MomentArrow(origin=ORIGIN, vector=(0.0, 0.0, 1.0), colour=RED)
+        assert moment.origin == ORIGIN
+        assert moment.vector == (0.0, 0.0, 1.0)
+        assert moment.colour == RED
+
+    def test_frozen_rejects_mutation(self):
+        moment = MomentArrow(origin=ORIGIN, vector=(0.0, 0.0, 1.0), colour=RED)
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            moment.vector = (1.0, 0.0, 0.0)
+
+
+# ------------------------------------------------------------------
+#  CellEdge / CellEdges
+# ------------------------------------------------------------------
+
+
+class TestCellEdge:
+    def test_construction_and_fields(self):
+        edge = CellEdge(start=ORIGIN, end=(1.0, 0.0, 0.0))
+        assert edge.start == ORIGIN
+        assert edge.end == (1.0, 0.0, 0.0)
+
+    def test_frozen_rejects_mutation(self):
+        edge = CellEdge(start=ORIGIN, end=(1.0, 0.0, 0.0))
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            edge.end = (2.0, 0.0, 0.0)
+
+
+class TestCellEdges:
+    def test_construction_and_fields(self):
+        edges = (
+            CellEdge(start=ORIGIN, end=(1.0, 0.0, 0.0)),
+            CellEdge(start=ORIGIN, end=(0.0, 1.0, 0.0)),
+        )
+        cell_edges = CellEdges(edges=edges)
+        assert cell_edges.edges == edges
+        assert len(cell_edges.edges) == 2
+
+    def test_frozen_rejects_mutation(self):
+        cell_edges = CellEdges(edges=())
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            cell_edges.edges = (CellEdge(start=ORIGIN, end=ORIGIN),)
+
+
+# ------------------------------------------------------------------
+#  AxisArrow / AxisTriad
+# ------------------------------------------------------------------
+
+
+class TestAxisArrow:
+    def test_construction_and_fields(self):
+        arrow = AxisArrow(vector=(1.0, 0.0, 0.0), colour=RED, letter='a')
+        assert arrow.vector == (1.0, 0.0, 0.0)
+        assert arrow.colour == RED
+        assert arrow.letter == 'a'
+
+    def test_frozen_rejects_mutation(self):
+        arrow = AxisArrow(vector=(1.0, 0.0, 0.0), colour=RED, letter='a')
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            arrow.letter = 'b'
+
+
+class TestAxisTriad:
+    def _triad(self):
+        return AxisTriad(
+            origin=ORIGIN,
+            axes=(
+                AxisArrow(vector=(1.0, 0.0, 0.0), colour=RED, letter='a'),
+                AxisArrow(vector=(0.0, 1.0, 0.0), colour=GREEN, letter='b'),
+                AxisArrow(vector=(0.0, 0.0, 1.0), colour=BLUE, letter='c'),
+            ),
+        )
+
+    def test_construction_and_fields(self):
+        triad = self._triad()
+        assert triad.origin == ORIGIN
+        assert len(triad.axes) == 3
+        assert [arrow.letter for arrow in triad.axes] == ['a', 'b', 'c']
+
+    def test_frozen_rejects_mutation(self):
+        triad = self._triad()
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            triad.origin = (1.0, 1.0, 1.0)
+
+
+# ------------------------------------------------------------------
+#  TextLabel
+# ------------------------------------------------------------------
+
+
+class TestTextLabel:
+    def test_construction_and_fields(self):
+        label = TextLabel(anchor=(0.5, 0.5, 0.5), text='Fe1')
+        assert label.anchor == (0.5, 0.5, 0.5)
+        assert label.text == 'Fe1'
+
+    def test_frozen_rejects_mutation(self):
+        label = TextLabel(anchor=ORIGIN, text='Fe1')
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            label.text = 'O1'
+
+
+# ------------------------------------------------------------------
+#  LegendEntry
+# ------------------------------------------------------------------
+
+
+class TestLegendEntry:
+    def test_construction_and_fields(self):
+        entry = LegendEntry(symbol='Fe', colour=RED)
+        assert entry.symbol == 'Fe'
+        assert entry.colour == RED
+
+    def test_frozen_rejects_mutation(self):
+        entry = LegendEntry(symbol='Fe', colour=RED)
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            entry.symbol = 'O'
+
+
+# ------------------------------------------------------------------
+#  StructureScene (the aggregate root)
+# ------------------------------------------------------------------
+
+
+class TestStructureScene:
+    def test_minimal_construction_only_basis(self):
+        scene = StructureScene(cell_basis=IDENTITY_BASIS)
+        assert scene.cell_basis == IDENTITY_BASIS
+
+    def test_collection_fields_default_empty(self):
+        scene = StructureScene(cell_basis=IDENTITY_BASIS)
+        assert scene.atoms == ()
+        assert scene.occupancy_spheres == ()
+        assert scene.ellipsoids == ()
+        assert scene.bonds == ()
+        assert scene.moments == ()
+        assert scene.labels == ()
+        assert scene.legend == ()
+
+    def test_optional_singletons_default_none(self):
+        scene = StructureScene(cell_basis=IDENTITY_BASIS)
+        assert scene.cell_edges is None
+        assert scene.axes is None
+
+    def test_fully_populated_scene(self):
+        atom = AtomSphere(centre=ORIGIN, radius=0.5, colour=RED, label='Fe')
+        occ = OccupancyWedgeSphere(
+            centre=(0.5, 0.5, 0.5),
+            radius=0.6,
+            wedges=(OccupancyWedge(fraction=1.0, colour=BLUE),),
+            label='Mn',
+        )
+        ellipsoid = AdpEllipsoid(
+            centre=(0.25, 0.25, 0.25),
+            semi_axes=(0.1, 0.2, 0.3),
+            orientation=IDENTITY_BASIS,
+            colour=GREEN,
+            label='O',
+        )
+        bond = Bond(start=ORIGIN, end=(0.5, 0.5, 0.5), start_colour=RED, end_colour=BLUE)
+        moment = MomentArrow(origin=ORIGIN, vector=(0.0, 0.0, 1.0), colour=RED)
+        cell_edges = CellEdges(edges=(CellEdge(start=ORIGIN, end=(1.0, 0.0, 0.0)),))
+        axes = AxisTriad(
+            origin=ORIGIN,
+            axes=(
+                AxisArrow(vector=(1.0, 0.0, 0.0), colour=RED, letter='a'),
+                AxisArrow(vector=(0.0, 1.0, 0.0), colour=GREEN, letter='b'),
+                AxisArrow(vector=(0.0, 0.0, 1.0), colour=BLUE, letter='c'),
+            ),
+        )
+        label = TextLabel(anchor=ORIGIN, text='Fe1')
+        legend = (LegendEntry(symbol='Fe', colour=RED),)
+
+        scene = StructureScene(
+            cell_basis=IDENTITY_BASIS,
+            atoms=(atom,),
+            occupancy_spheres=(occ,),
+            ellipsoids=(ellipsoid,),
+            bonds=(bond,),
+            moments=(moment,),
+            cell_edges=cell_edges,
+            axes=axes,
+            labels=(label,),
+            legend=legend,
+        )
+
+        assert scene.atoms == (atom,)
+        assert scene.occupancy_spheres == (occ,)
+        assert scene.ellipsoids == (ellipsoid,)
+        assert scene.bonds == (bond,)
+        assert scene.moments == (moment,)
+        assert scene.cell_edges is cell_edges
+        assert scene.axes is axes
+        assert scene.labels == (label,)
+        assert scene.legend == legend
+
+    def test_frozen_rejects_mutation(self):
+        scene = StructureScene(cell_basis=IDENTITY_BASIS)
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            scene.atoms = (AtomSphere(centre=ORIGIN, radius=1.0, colour=RED, label='Fe'),)
+
+    def test_equality_by_value(self):
+        a = StructureScene(cell_basis=IDENTITY_BASIS)
+        b = StructureScene(cell_basis=IDENTITY_BASIS)
+        assert a == b
diff --git a/tests/unit/easydiffraction/display/structure/test_viewing.py b/tests/unit/easydiffraction/display/structure/test_viewing.py
new file mode 100644
index 000000000..ad423b281
--- /dev/null
+++ b/tests/unit/easydiffraction/display/structure/test_viewing.py
@@ -0,0 +1,296 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for display/structure/viewing.py (Viewer and ViewerFactory)."""
+
+from __future__ import annotations
+
+import pytest
+
+from easydiffraction.core.singleton import SingletonBase
+from easydiffraction.display.base import RendererBase
+from easydiffraction.display.base import RendererFactoryBase
+from easydiffraction.display.structure.enums import ViewerEngineEnum
+from easydiffraction.display.structure.renderers.ascii import AsciiStructureRenderer
+from easydiffraction.display.structure.renderers.threejs import ThreeJsStructureRenderer
+from easydiffraction.display.structure.scene import AtomSphere
+from easydiffraction.display.structure.scene import StructureScene
+from easydiffraction.display.structure.viewing import Viewer
+from easydiffraction.display.structure.viewing import ViewerFactory
+
+
+# ------------------------------------------------------------------
+#  Test doubles and fixtures
+# ------------------------------------------------------------------
+
+
+class _StubBackend:
+    """A renderer-shaped stub used to verify facade delegation."""
+
+    def render(self, scene: StructureScene, *, features: frozenset[str]) -> str:
+        return f'stub atoms={len(scene.atoms)} features={sorted(features)}'
+
+    def supported_features(self) -> frozenset[str]:
+        return frozenset({'atoms', 'cell'})
+
+
+@pytest.fixture
+def viewer(monkeypatch):
+    """Yield a fresh Viewer with the singleton reset before and after."""
+    monkeypatch.setattr(Viewer, '_instance', None)
+    yield Viewer()
+    monkeypatch.setattr(Viewer, '_instance', None)
+
+
+def _minimal_scene() -> StructureScene:
+    """Build a tiny renderer-neutral scene without any engine."""
+    basis = (
+        (1.0, 0.0, 0.0),
+        (0.0, 1.0, 0.0),
+        (0.0, 0.0, 1.0),
+    )
+    atom = AtomSphere(centre=(0.0, 0.0, 0.0), radius=0.5, colour=(255, 0, 0), label='Fe')
+    return StructureScene(cell_basis=basis, atoms=(atom,))
+
+
+# ------------------------------------------------------------------
+#  Module / class identity
+# ------------------------------------------------------------------
+
+
+def test_module_import():
+    import easydiffraction.display.structure.viewing as MUT
+
+    expected_module_name = 'easydiffraction.display.structure.viewing'
+    actual_module_name = MUT.__name__
+    assert expected_module_name == actual_module_name
+
+
+def test_viewer_is_renderer_base():
+    assert issubclass(Viewer, RendererBase)
+
+
+def test_viewer_is_singleton():
+    assert issubclass(Viewer, SingletonBase)
+
+
+def test_factory_is_renderer_factory_base():
+    assert issubclass(ViewerFactory, RendererFactoryBase)
+
+
+# ------------------------------------------------------------------
+#  ViewerFactory
+# ------------------------------------------------------------------
+
+
+class TestViewerFactory:
+    def test_registry_keys(self):
+        registry = ViewerFactory._registry()
+        assert set(registry) == {
+            ViewerEngineEnum.ASCII.value,
+            ViewerEngineEnum.THREEJS.value,
+        }
+
+    def test_registry_entries_have_description_and_class(self):
+        registry = ViewerFactory._registry()
+        for config in registry.values():
+            assert isinstance(config['description'], str)
+            assert config['description']
+            assert isinstance(config['class'], type)
+
+    def test_supported_engines(self):
+        engines = ViewerFactory.supported_engines()
+        assert engines == ['ascii', 'threejs']
+
+    def test_descriptions_pairs(self):
+        descriptions = dict(ViewerFactory.descriptions())
+        assert descriptions['ascii'] == ViewerEngineEnum.ASCII.description()
+        assert descriptions['threejs'] == ViewerEngineEnum.THREEJS.description()
+
+    def test_create_ascii(self):
+        backend = ViewerFactory.create('ascii')
+        assert isinstance(backend, AsciiStructureRenderer)
+
+    def test_create_threejs(self):
+        backend = ViewerFactory.create('threejs')
+        assert isinstance(backend, ThreeJsStructureRenderer)
+
+    def test_create_invalid_raises(self):
+        with pytest.raises(ValueError, match='Unsupported engine'):
+            ViewerFactory.create('nonexistent')
+
+
+# ------------------------------------------------------------------
+#  Construction / defaults
+# ------------------------------------------------------------------
+
+
+class TestViewerConstruction:
+    def test_factory_classmethod_returns_viewer_factory(self):
+        assert Viewer._factory() is ViewerFactory
+
+    def test_default_engine_classmethod_matches_enum_default(self):
+        assert Viewer._default_engine() == ViewerEngineEnum.default().value
+
+    def test_default_engine_is_a_supported_engine(self):
+        assert Viewer._default_engine() in ViewerFactory.supported_engines()
+
+    def test_new_instance_uses_default_engine(self, viewer):
+        assert viewer.engine == Viewer._default_engine()
+
+    def test_new_instance_backend_matches_default_engine(self, viewer):
+        # Outside Jupyter the default engine is ASCII.
+        assert viewer.engine == ViewerEngineEnum.ASCII.value
+        assert isinstance(viewer._backend, AsciiStructureRenderer)
+
+
+# ------------------------------------------------------------------
+#  engine property (getter / setter)
+# ------------------------------------------------------------------
+
+
+class TestEngineProperty:
+    def test_engine_getter_returns_str(self, viewer):
+        assert isinstance(viewer.engine, str)
+
+    def test_switch_to_threejs_updates_engine_and_backend(self, viewer):
+        viewer.engine = 'threejs'
+        assert viewer.engine == 'threejs'
+        assert isinstance(viewer._backend, ThreeJsStructureRenderer)
+
+    def test_switch_to_ascii_updates_engine_and_backend(self, viewer):
+        viewer.engine = 'threejs'
+        viewer.engine = 'ascii'
+        assert viewer.engine == 'ascii'
+        assert isinstance(viewer._backend, AsciiStructureRenderer)
+
+    def test_switch_emits_change_notice(self, viewer, capsys):
+        viewer.engine = 'threejs'
+        out = capsys.readouterr().out
+        assert 'threejs' in out.lower()
+
+    def test_setting_same_engine_is_a_noop(self, viewer):
+        original_backend = viewer._backend
+        viewer.engine = viewer.engine
+        # Engine unchanged and backend instance not rebuilt.
+        assert viewer.engine == ViewerEngineEnum.ASCII.value
+        assert viewer._backend is original_backend
+
+    def test_invalid_engine_leaves_engine_unchanged(self, viewer):
+        original_engine = viewer.engine
+        original_backend = viewer._backend
+        viewer.engine = 'bogus'
+        assert viewer.engine == original_engine
+        assert viewer._backend is original_backend
+
+    def test_invalid_engine_does_not_raise(self, viewer):
+        # The setter logs a friendly warning instead of raising.
+        viewer.engine = 'bogus'
+
+    def test_non_string_engine_treated_as_unsupported(self, viewer):
+        # The setter is not @typechecked: a non-string value is simply an
+        # unsupported engine, so it warns and leaves the engine unchanged.
+        original_engine = viewer.engine
+        original_backend = viewer._backend
+        viewer.engine = 123
+        assert viewer.engine == original_engine
+        assert viewer._backend is original_backend
+
+
+# ------------------------------------------------------------------
+#  render (delegation + real ASCII engine)
+# ------------------------------------------------------------------
+
+
+class TestRender:
+    def test_render_delegates_to_backend(self, viewer):
+        viewer._backend = _StubBackend()
+        scene = _minimal_scene()
+        output = viewer.render(scene, features=frozenset({'atoms'}))
+        assert output == "stub atoms=1 features=['atoms']"
+
+    def test_render_features_is_keyword_only(self, viewer):
+        viewer._backend = _StubBackend()
+        scene = _minimal_scene()
+        with pytest.raises(TypeError):
+            viewer.render(scene, frozenset({'atoms'}))
+
+    def test_render_with_real_ascii_engine_returns_text(self, viewer):
+        # Default engine is ASCII outside Jupyter; render end to end with
+        # no calculation engine and no network.
+        scene = _minimal_scene()
+        output = viewer.render(scene, features=viewer.supported_features())
+        assert isinstance(output, str)
+        assert output != ''
+
+
+# ------------------------------------------------------------------
+#  supported_features (delegation + real engines)
+# ------------------------------------------------------------------
+
+
+class TestSupportedFeatures:
+    def test_supported_features_delegates_to_backend(self, viewer):
+        viewer._backend = _StubBackend()
+        assert viewer.supported_features() == frozenset({'atoms', 'cell'})
+
+    def test_ascii_supported_features(self, viewer):
+        assert viewer.engine == ViewerEngineEnum.ASCII.value
+        features = viewer.supported_features()
+        assert isinstance(features, frozenset)
+        assert features == AsciiStructureRenderer.SUPPORTED
+
+    def test_threejs_supported_features(self, viewer):
+        viewer.engine = 'threejs'
+        features = viewer.supported_features()
+        assert isinstance(features, frozenset)
+        assert features == ThreeJsStructureRenderer.SUPPORTED
+
+
+# ------------------------------------------------------------------
+#  show_config and inherited inspection helpers
+# ------------------------------------------------------------------
+
+
+class TestShowHelpers:
+    def test_show_config_reports_current_engine(self, viewer, capsys):
+        viewer.show_config()
+        out = capsys.readouterr().out
+        assert ViewerEngineEnum.ASCII.value in out.lower()
+
+    def test_show_config_reflects_active_engine(self, viewer, capsys):
+        viewer.engine = 'threejs'
+        capsys.readouterr()  # drop the engine-change notice
+        viewer.show_config()
+        out = capsys.readouterr().out
+        assert 'threejs' in out.lower()
+
+    def test_show_current_engine_outputs_engine(self, viewer, capsys):
+        viewer.show_current_engine()
+        out = capsys.readouterr().out
+        assert viewer.engine in out.lower()
+
+    def test_show_supported_engines_lists_every_engine(self, viewer, capsys):
+        viewer.show_supported_engines()
+        out = capsys.readouterr().out.lower()
+        for member in ViewerEngineEnum:
+            assert member.value in out
+
+
+# ------------------------------------------------------------------
+#  ViewerEngineEnum (the value selector backing the engine setting)
+# ------------------------------------------------------------------
+
+
+class TestViewerEngineEnum:
+    def test_members(self):
+        assert ViewerEngineEnum.ASCII == 'ascii'
+        assert ViewerEngineEnum.THREEJS == 'threejs'
+
+    def test_default_is_a_member(self):
+        assert ViewerEngineEnum.default() in set(ViewerEngineEnum)
+
+    def test_every_member_has_a_nonempty_description(self):
+        for member in ViewerEngineEnum:
+            description = member.description()
+            assert isinstance(description, str)
+            assert description
diff --git a/tests/unit/easydiffraction/project/categories/rendering_structure/test_default.py b/tests/unit/easydiffraction/project/categories/rendering_structure/test_default.py
new file mode 100644
index 000000000..68152b9a1
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/rendering_structure/test_default.py
@@ -0,0 +1,394 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for rendering_structure category (default switchable engine)."""
+
+from __future__ import annotations
+
+import gemmi
+import pytest
+
+from easydiffraction.display.structure.enums import ViewerEngineEnum
+from easydiffraction.display.structure.viewing import Viewer
+from easydiffraction.display.structure.viewing import ViewerFactory
+from easydiffraction.project.categories.rendering_structure import default as rs_mod
+from easydiffraction.project.categories.rendering_structure.default import AUTO_DESCRIPTION
+from easydiffraction.project.categories.rendering_structure.default import AUTO_ENGINE
+from easydiffraction.project.categories.rendering_structure.default import VIEW_ENGINE_OPTIONS
+from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
+from easydiffraction.project.categories.rendering_structure.factory import (
+    RenderingStructureFactory,
+)
+from easydiffraction.utils.logging import Logger
+
+
+def _default_engine() -> str:
+    """Resolve the environment default engine deterministically."""
+    return ViewerEngineEnum.default().value
+
+
+# ----------------------------------------------------------------------
+# Module-level constants
+# ----------------------------------------------------------------------
+
+
+class TestModuleConstants:
+    def test_auto_engine_constant(self):
+        assert AUTO_ENGINE == 'auto'
+
+    def test_auto_description_is_nonempty_str(self):
+        assert isinstance(AUTO_DESCRIPTION, str)
+        assert AUTO_DESCRIPTION
+
+    def test_view_engine_options_lists_auto_first(self):
+        assert VIEW_ENGINE_OPTIONS[0] == AUTO_ENGINE
+
+    def test_view_engine_options_includes_every_enum_member(self):
+        for member in ViewerEngineEnum:
+            assert member.value in VIEW_ENGINE_OPTIONS
+
+    def test_view_engine_options_has_no_extra_entries(self):
+        expected = {AUTO_ENGINE, *(m.value for m in ViewerEngineEnum)}
+        assert set(VIEW_ENGINE_OPTIONS) == expected
+
+
+# ----------------------------------------------------------------------
+# Factory registration
+# ----------------------------------------------------------------------
+
+
+class TestRenderingStructureFactory:
+    def test_supported_tags(self):
+        assert 'default' in RenderingStructureFactory.supported_tags()
+
+    def test_default_tag(self):
+        assert RenderingStructureFactory.default_tag() == 'default'
+
+    def test_create_returns_rendering_structure(self):
+        obj = RenderingStructureFactory.create('default')
+        assert isinstance(obj, RenderingStructure)
+
+
+# ----------------------------------------------------------------------
+# Construction / defaults
+# ----------------------------------------------------------------------
+
+
+class TestConstructionAndDefaults:
+    def test_type_info_tag(self):
+        assert RenderingStructure.type_info.tag == 'default'
+
+    def test_category_class_attrs(self):
+        assert RenderingStructure._category_code == 'rendering_structure'
+        assert RenderingStructure._owner_attr_name == 'rendering_structure'
+        assert RenderingStructure._swap_method_name == '_swap_rendering_structure'
+
+    def test_identity_category_code(self):
+        rs = RenderingStructure()
+        assert rs._identity.category_code == 'rendering_structure'
+
+    def test_default_type_is_auto(self):
+        rs = RenderingStructure()
+        assert rs.type == AUTO_ENGINE
+
+    def test_default_type_descriptor_value(self):
+        rs = RenderingStructure()
+        assert rs._type.value == AUTO_ENGINE
+
+    def test_viewer_is_viewer_instance(self):
+        rs = RenderingStructure()
+        assert isinstance(rs.viewer, Viewer)
+
+    def test_viewer_engine_is_environment_default(self):
+        rs = RenderingStructure()
+        assert rs.viewer.engine == _default_engine()
+
+    def test_viewer_engine_is_supported(self):
+        rs = RenderingStructure()
+        assert rs.viewer.engine in ViewerFactory.supported_engines()
+
+    def test_type_cif_handler_name(self):
+        rs = RenderingStructure()
+        assert rs._type._cif_handler.names == ['_rendering_structure.type']
+
+    def test_parent_starts_detached(self):
+        rs = RenderingStructure()
+        assert rs._parent is None
+
+
+# ----------------------------------------------------------------------
+# viewer property
+# ----------------------------------------------------------------------
+
+
+class TestViewerProperty:
+    def test_viewer_is_stable_reference(self):
+        rs = RenderingStructure()
+        assert rs.viewer is rs.viewer
+
+    def test_distinct_instances_have_distinct_viewers(self):
+        first = RenderingStructure()
+        second = RenderingStructure()
+        # Viewer is constructed (not fetched as singleton) per category,
+        # so each category owns an independent facade.
+        assert first.viewer is not second.viewer
+
+
+# ----------------------------------------------------------------------
+# _resolved_engine
+# ----------------------------------------------------------------------
+
+
+class TestResolvedEngine:
+    def test_auto_resolves_to_environment_default(self):
+        assert RenderingStructure._resolved_engine(AUTO_ENGINE) == _default_engine()
+
+    def test_explicit_ascii_passes_through(self):
+        assert RenderingStructure._resolved_engine('ascii') == 'ascii'
+
+    def test_explicit_threejs_passes_through(self):
+        assert RenderingStructure._resolved_engine('threejs') == 'threejs'
+
+
+# ----------------------------------------------------------------------
+# _set_type (validator: valid + invalid)
+# ----------------------------------------------------------------------
+
+
+class TestSetType:
+    def test_set_explicit_engine_updates_type_and_viewer(self):
+        rs = RenderingStructure()
+        rs._set_type('threejs')
+        assert rs.type == 'threejs'
+        assert rs.viewer.engine == 'threejs'
+
+    def test_set_ascii_updates_viewer_engine(self):
+        rs = RenderingStructure()
+        rs._set_type('ascii')
+        assert rs.type == 'ascii'
+        assert rs.viewer.engine == 'ascii'
+
+    def test_set_auto_resolves_viewer_to_environment_default(self):
+        rs = RenderingStructure()
+        rs._set_type('threejs')
+        rs._set_type('auto')
+        assert rs.type == 'auto'
+        assert rs.viewer.engine == _default_engine()
+
+    def test_invalid_type_strict_raises_value_error(self):
+        rs = RenderingStructure()
+        initial = rs.type
+        with pytest.raises(ValueError, match='Unsupported rendering_structure type'):
+            rs._set_type('bogus-engine')
+        assert rs.type == initial
+
+    def test_invalid_type_strict_leaves_viewer_unchanged(self):
+        rs = RenderingStructure()
+        engine_before = rs.viewer.engine
+        with pytest.raises(ValueError, match='Unsupported rendering_structure type'):
+            rs._set_type('bogus-engine')
+        assert rs.viewer.engine == engine_before
+
+    def test_invalid_type_non_strict_warns_and_keeps_value(self, monkeypatch):
+        rs = RenderingStructure()
+        warnings: list[str] = []
+        monkeypatch.setattr(rs_mod.log, 'warning', warnings.append)
+        rs._set_type('bogus-engine', strict=False)
+        assert rs.type == AUTO_ENGINE
+        assert any('Unsupported rendering_structure type' in w for w in warnings)
+
+    def test_strict_error_message_points_to_show_supported(self):
+        rs = RenderingStructure()
+        with pytest.raises(ValueError, match=r'rendering_structure\.show_supported'):
+            rs._set_type('nope')
+
+
+# ----------------------------------------------------------------------
+# _supported_types
+# ----------------------------------------------------------------------
+
+
+class TestSupportedTypes:
+    def test_includes_auto_pair_first(self):
+        pairs = RenderingStructure._supported_types({})
+        assert pairs[0] == (AUTO_ENGINE, AUTO_DESCRIPTION)
+
+    def test_lists_every_engine_from_factory(self):
+        pairs = RenderingStructure._supported_types({})
+        tags = [tag for tag, _ in pairs]
+        for engine in ViewerFactory.supported_engines():
+            assert engine in tags
+
+    def test_descriptions_are_strings(self):
+        pairs = RenderingStructure._supported_types({})
+        assert all(isinstance(desc, str) and desc for _, desc in pairs)
+
+    def test_filters_argument_is_ignored(self):
+        with_filters = RenderingStructure._supported_types({'anything': object()})
+        without_filters = RenderingStructure._supported_types({})
+        assert with_filters == without_filters
+
+
+# ----------------------------------------------------------------------
+# show_supported (inherited; lists enum values)
+# ----------------------------------------------------------------------
+
+
+class TestShowSupported:
+    def test_runs_without_parent(self, capsys):
+        rs = RenderingStructure()
+        rs.show_supported()
+        out = capsys.readouterr().out
+        assert out  # produced a table
+
+    def test_lists_auto_and_every_engine(self, capsys):
+        rs = RenderingStructure()
+        rs.show_supported()
+        out = capsys.readouterr().out
+        assert AUTO_ENGINE in out
+        for member in ViewerEngineEnum:
+            assert member.value in out
+
+    def test_marks_active_type(self, capsys):
+        rs = RenderingStructure()
+        rs._set_type('threejs')
+        rs.show_supported()
+        out = capsys.readouterr().out
+        assert '*' in out
+        assert 'threejs' in out
+
+
+# ----------------------------------------------------------------------
+# type setter (SwitchableCategoryBase contract via parent)
+# ----------------------------------------------------------------------
+
+
+class TestTypeSetter:
+    def test_detached_instance_raises_runtime_error(self):
+        rs = RenderingStructure()
+        with pytest.raises(RuntimeError, match='detached'):
+            rs.type = 'threejs'
+
+    def test_setter_routes_through_owner_swap(self):
+        rs = RenderingStructure()
+
+        class _Owner:
+            rendering_structure = rs
+
+            @staticmethod
+            def _supported_filters_for(_category):
+                return {}
+
+            def _swap_rendering_structure(self, new_type, *, strict=True):
+                rs._set_type(new_type, strict=strict)
+
+        rs._parent = _Owner()
+        rs.type = 'threejs'
+        assert rs.type == 'threejs'
+        assert rs.viewer.engine == 'threejs'
+
+    def test_setter_on_stale_instance_raises(self):
+        rs = RenderingStructure()
+        live = RenderingStructure()
+
+        class _Owner:
+            # Owner's live category is a different instance.
+            rendering_structure = live
+
+            def _swap_rendering_structure(self, new_type, *, strict=True):  # pragma: no cover
+                live._set_type(new_type, strict=strict)
+
+        rs._parent = _Owner()
+        with pytest.raises(RuntimeError, match='no longer the live category'):
+            rs.type = 'threejs'
+
+
+# ----------------------------------------------------------------------
+# from_cif
+# ----------------------------------------------------------------------
+
+
+class TestFromCif:
+    def _block(self, cif_text: str):
+        return gemmi.cif.read_string(cif_text).sole_block()
+
+    def test_restores_type_via_parent_swap(self):
+        rs = RenderingStructure()
+        swapped: list[tuple[str, dict]] = []
+
+        class _Parent:
+            def _swap_rendering_structure(self, new_type, *, strict):
+                swapped.append((new_type, {'strict': strict}))
+                rs._set_type(new_type, strict=strict)
+
+        rs._parent = _Parent()
+        block = self._block('data_test\n_rendering_structure.type threejs\n')
+        rs.from_cif(block)
+        assert swapped == [('threejs', {'strict': False})]
+        assert rs.type == 'threejs'
+        assert rs.viewer.engine == 'threejs'
+
+    def test_tolerates_invalid_type(self, monkeypatch):
+        # The descriptor's own from_cif validation routes through the
+        # Logger; force WARN so it logs rather than raises (another test
+        # may have left the Logger in RAISE mode).
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+
+        rs = RenderingStructure()
+
+        class _Parent:
+            def _swap_rendering_structure(self, new_type, *, strict):
+                rs._set_type(new_type, strict=strict)
+
+        rs._parent = _Parent()
+        block = self._block('data_test\n_rendering_structure.type bogus-engine\n')
+        warnings: list[str] = []
+        monkeypatch.setattr(rs_mod.log, 'warning', warnings.append)
+        rs.from_cif(block)
+        assert rs.type == AUTO_ENGINE
+        assert any('Unsupported rendering_structure type' in w for w in warnings)
+
+    def test_missing_type_leaves_default(self):
+        rs = RenderingStructure()
+        called: list[str] = []
+
+        class _Parent:
+            def _swap_rendering_structure(self, new_type, *, strict):  # pragma: no cover
+                called.append(new_type)
+
+        rs._parent = _Parent()
+        block = self._block('data_test\n_other.value 1\n')
+        rs.from_cif(block)
+        assert rs.type == AUTO_ENGINE
+        assert called == []
+
+
+# ----------------------------------------------------------------------
+# as_cif (round-trip)
+# ----------------------------------------------------------------------
+
+
+class TestAsCif:
+    def test_as_cif_contains_handler_name(self):
+        rs = RenderingStructure()
+        assert '_rendering_structure.type' in rs.as_cif
+
+    def test_as_cif_reflects_explicit_engine(self):
+        rs = RenderingStructure()
+        rs._set_type('threejs')
+        assert 'threejs' in rs.as_cif
+
+    def test_as_cif_round_trip_restores_type(self):
+        rs = RenderingStructure()
+        rs._set_type('threejs')
+        cif_text = rs.as_cif
+
+        restored = RenderingStructure()
+
+        class _Parent:
+            def _swap_rendering_structure(self, new_type, *, strict):
+                restored._set_type(new_type, strict=strict)
+
+        restored._parent = _Parent()
+        block = gemmi.cif.read_string(f'data_test\n{cif_text}\n').sole_block()
+        restored.from_cif(block)
+        assert restored.type == 'threejs'
diff --git a/tests/unit/easydiffraction/project/categories/rendering_structure/test_factory.py b/tests/unit/easydiffraction/project/categories/rendering_structure/test_factory.py
new file mode 100644
index 000000000..40e0bb399
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/rendering_structure/test_factory.py
@@ -0,0 +1,113 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the project rendering_structure factory."""
+
+from __future__ import annotations
+
+import pytest
+
+
+def test_module_import():
+    import easydiffraction.project.categories.rendering_structure.factory as MUT
+
+    expected_module_name = 'easydiffraction.project.categories.rendering_structure.factory'
+    assert MUT.__name__ == expected_module_name
+
+
+def test_default_rules_universal_fallback():
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    # The factory declares a single universal-fallback rule.
+    assert RenderingStructureFactory._default_rules == {frozenset(): 'default'}
+
+
+def test_supported_tags_lists_default():
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    tags = RenderingStructureFactory.supported_tags()
+    assert isinstance(tags, list)
+    assert 'default' in tags
+
+
+def test_default_tag_without_conditions():
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    assert RenderingStructureFactory.default_tag() == 'default'
+
+
+def test_default_tag_with_unmatched_conditions_falls_back():
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    # Extra conditions still match the empty-key universal fallback.
+    assert RenderingStructureFactory.default_tag(scattering_type='bragg') == 'default'
+
+
+def test_create_returns_rendering_structure():
+    from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    rendering_structure = RenderingStructureFactory.create('default')
+    assert isinstance(rendering_structure, RenderingStructure)
+
+
+def test_create_rejects_unknown_tag():
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
+        RenderingStructureFactory.create('missing')
+
+
+def test_create_default_for_returns_rendering_structure():
+    from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    rendering_structure = RenderingStructureFactory.create_default_for()
+    assert isinstance(rendering_structure, RenderingStructure)
+
+
+def test_supported_for_includes_registered_class():
+    from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    supported = RenderingStructureFactory.supported_for()
+    assert RenderingStructure in supported
+
+
+def test_show_supported_lists_default(capsys):
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    RenderingStructureFactory.show_supported()
+    out = capsys.readouterr().out
+    assert 'Supported types' in out
+    assert 'default' in out
+
+
+def test_registry_is_independent_from_base():
+    from easydiffraction.core.factory import FactoryBase
+    from easydiffraction.project.categories.rendering_structure.default import RenderingStructure
+    from easydiffraction.project.categories.rendering_structure.factory import (
+        RenderingStructureFactory,
+    )
+
+    # __init_subclass__ gives each factory its own registry; the
+    # registered concrete class must not leak onto the shared base.
+    assert RenderingStructure in RenderingStructureFactory._registry
+    assert RenderingStructure not in FactoryBase._registry
diff --git a/tests/unit/easydiffraction/project/categories/structure_style/test_default.py b/tests/unit/easydiffraction/project/categories/structure_style/test_default.py
new file mode 100644
index 000000000..a0e264a40
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/structure_style/test_default.py
@@ -0,0 +1,387 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the project structure_style category (default)."""
+
+from __future__ import annotations
+
+import gemmi
+import pytest
+
+
+def test_module_import():
+    import easydiffraction.project.categories.structure_style.default as MUT
+
+    expected_module_name = 'easydiffraction.project.categories.structure_style.default'
+    assert MUT.__name__ == expected_module_name
+
+
+# ----------------------------------------------------------------------
+#  Factory registration
+# ----------------------------------------------------------------------
+
+
+class TestStructureStyleFactory:
+    def test_supported_tags(self):
+        from easydiffraction.project.categories.structure_style.factory import (
+            StructureStyleFactory,
+        )
+
+        assert 'default' in StructureStyleFactory.supported_tags()
+
+    def test_default_tag(self):
+        from easydiffraction.project.categories.structure_style.factory import (
+            StructureStyleFactory,
+        )
+
+        assert StructureStyleFactory.default_tag() == 'default'
+
+    def test_create_returns_structure_style(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.project.categories.structure_style.factory import (
+            StructureStyleFactory,
+        )
+
+        obj = StructureStyleFactory.create('default')
+        assert isinstance(obj, StructureStyle)
+
+
+# ----------------------------------------------------------------------
+#  Identity, type_info and defaults
+# ----------------------------------------------------------------------
+
+
+class TestStructureStyleIdentityAndDefaults:
+    def test_type_info(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        assert StructureStyle.type_info.tag == 'default'
+        assert StructureStyle.type_info.description != ''
+
+    def test_category_code(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        assert style._identity.category_code == 'structure_style'
+
+    def test_instantiation(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        assert style is not None
+
+    def test_default_values(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        assert style.atom_view.value == 'adp'
+        assert style.color_scheme.value == 'jmol'
+        assert style.adp_probability.value == 0.99
+        assert style.atom_scale.value == 0.3
+
+    def test_defaults_track_enum_defaults(self):
+        from easydiffraction.display.structure.enums import AtomViewEnum
+        from easydiffraction.display.structure.enums import ColorSchemeEnum
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        assert style.atom_view.value == AtomViewEnum.default().value
+        assert style.color_scheme.value == ColorSchemeEnum.default().value
+
+    def test_enum_descriptors_expose_backing_enum(self):
+        from easydiffraction.display.structure.enums import AtomViewEnum
+        from easydiffraction.display.structure.enums import ColorSchemeEnum
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        assert style.atom_view.enum is AtomViewEnum
+        assert style.color_scheme.enum is ColorSchemeEnum
+
+    def test_parameters_collects_all_descriptors(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        names = {param.name for param in style.parameters}
+        assert names == {'atom_view', 'color_scheme', 'adp_probability', 'atom_scale'}
+
+
+# ----------------------------------------------------------------------
+#  CIF handler names
+# ----------------------------------------------------------------------
+
+
+class TestStructureStyleCifHandlerNames:
+    def test_cif_handler_names(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        assert style.atom_view._cif_handler.names == ['_structure_style.atom_view']
+        assert style.color_scheme._cif_handler.names == ['_structure_style.color_scheme']
+        assert style.adp_probability._cif_handler.names == ['_structure_style.adp_probability']
+        assert style.atom_scale._cif_handler.names == ['_structure_style.atom_scale']
+
+
+# ----------------------------------------------------------------------
+#  atom_view selector
+# ----------------------------------------------------------------------
+
+
+class TestAtomViewSelector:
+    def test_setter_accepts_valid_values(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        for value in ('vdw', 'covalent', 'ionic', 'adp'):
+            style.atom_view = value
+            assert style.atom_view.value == value
+
+    def test_setter_rejects_invalid_value(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        with pytest.raises(ValueError, match='not a valid AtomViewEnum'):
+            style.atom_view = 'bogus'
+
+    def test_invalid_value_keeps_previous(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_view = 'vdw'
+        with pytest.raises(ValueError, match='not a valid AtomViewEnum'):
+            style.atom_view = 'bogus'
+        assert style.atom_view.value == 'vdw'
+
+    def test_show_supported_lists_all_enum_values(self, capsys):
+        from easydiffraction.display.structure.enums import AtomViewEnum
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_view.show_supported()
+
+        out = capsys.readouterr().out
+        for member in AtomViewEnum:
+            assert member.value in out
+
+    def test_show_supported_marks_active_value(self, capsys):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_view = 'ionic'
+        style.atom_view.show_supported()
+
+        out = capsys.readouterr().out
+        # Active value is annotated with an asterisk in its row.
+        marked_line = next(line for line in out.splitlines() if 'ionic' in line)
+        assert '*' in marked_line
+
+
+# ----------------------------------------------------------------------
+#  color_scheme selector
+# ----------------------------------------------------------------------
+
+
+class TestColorSchemeSelector:
+    def test_setter_accepts_valid_values(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        for value in ('jmol', 'vesta'):
+            style.color_scheme = value
+            assert style.color_scheme.value == value
+
+    def test_setter_rejects_invalid_value(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        with pytest.raises(ValueError, match='not a valid ColorSchemeEnum'):
+            style.color_scheme = 'bogus'
+
+    def test_invalid_value_keeps_previous(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.color_scheme = 'vesta'
+        with pytest.raises(ValueError, match='not a valid ColorSchemeEnum'):
+            style.color_scheme = 'bogus'
+        assert style.color_scheme.value == 'vesta'
+
+    def test_show_supported_lists_all_enum_values(self, capsys):
+        from easydiffraction.display.structure.enums import ColorSchemeEnum
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.color_scheme.show_supported()
+
+        out = capsys.readouterr().out
+        for member in ColorSchemeEnum:
+            assert member.value in out
+
+
+# ----------------------------------------------------------------------
+#  adp_probability numeric descriptor
+# ----------------------------------------------------------------------
+
+
+class TestAdpProbability:
+    def test_setter_accepts_value_in_open_interval(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.adp_probability = 0.5
+        assert style.adp_probability.value == 0.5
+
+    def test_out_of_range_raises_in_raise_mode(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        style = StructureStyle()
+
+        with pytest.raises(TypeError, match='outside'):
+            style.adp_probability = 1.5
+
+    def test_boundaries_are_exclusive(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        style = StructureStyle()
+
+        with pytest.raises(TypeError, match='outside'):
+            style.adp_probability = 0.0
+        with pytest.raises(TypeError, match='outside'):
+            style.adp_probability = 1.0
+
+    def test_out_of_range_keeps_current_in_warn_mode(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+        style = StructureStyle()
+
+        style.adp_probability = 1.5  # rejected, current value kept
+        assert style.adp_probability.value == 0.99
+
+    def test_wrong_type_raises_in_raise_mode(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        style = StructureStyle()
+
+        with pytest.raises(TypeError, match='Type mismatch'):
+            style.adp_probability = 'not-a-number'
+
+
+# ----------------------------------------------------------------------
+#  atom_scale numeric descriptor
+# ----------------------------------------------------------------------
+
+
+class TestAtomScale:
+    def test_setter_accepts_value_in_range(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_scale = 0.8
+        assert style.atom_scale.value == 0.8
+
+    def test_upper_boundary_is_inclusive(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_scale = 1.0
+        assert style.atom_scale.value == 1.0
+
+    def test_lower_boundary_is_exclusive(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        style = StructureStyle()
+
+        with pytest.raises(TypeError, match='outside'):
+            style.atom_scale = 0.0
+
+    def test_above_upper_boundary_raises_in_raise_mode(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+        style = StructureStyle()
+
+        with pytest.raises(TypeError, match='outside'):
+            style.atom_scale = 1.5
+
+    def test_out_of_range_keeps_current_in_warn_mode(self, monkeypatch):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+        from easydiffraction.utils.logging import Logger
+
+        monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+        style = StructureStyle()
+
+        style.atom_scale = 5.0  # rejected, current value kept
+        assert style.atom_scale.value == 0.3
+
+
+# ----------------------------------------------------------------------
+#  CIF serialization / round-trip
+# ----------------------------------------------------------------------
+
+
+class TestStructureStyleCif:
+    def test_as_cif_default_output(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        cif = style.as_cif
+        assert '_structure_style.atom_view adp' in cif
+        assert '_structure_style.color_scheme jmol' in cif
+        assert '_structure_style.adp_probability 0.99' in cif
+        assert '_structure_style.atom_scale 0.3' in cif
+
+    def test_as_cif_reflects_updated_values(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_view = 'vdw'
+        style.color_scheme = 'vesta'
+
+        cif = style.as_cif
+        assert '_structure_style.atom_view vdw' in cif
+        assert '_structure_style.color_scheme vesta' in cif
+
+    def test_from_cif_restores_all_fields(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        block = gemmi.cif.read_string(
+            'data_test\n'
+            '_structure_style.atom_view vdw\n'
+            '_structure_style.color_scheme vesta\n'
+            '_structure_style.adp_probability 0.5\n'
+            '_structure_style.atom_scale 0.7\n',
+        ).sole_block()
+
+        style.from_cif(block)
+
+        assert style.atom_view.value == 'vdw'
+        assert style.color_scheme.value == 'vesta'
+        assert style.adp_probability.value == 0.5
+        assert style.atom_scale.value == 0.7
+
+    def test_cif_round_trip_is_stable(self):
+        from easydiffraction.project.categories.structure_style.default import StructureStyle
+
+        style = StructureStyle()
+        style.atom_view = 'covalent'
+        style.color_scheme = 'vesta'
+        style.adp_probability = 0.5
+        style.atom_scale = 0.7
+
+        first_cif = style.as_cif
+        block = gemmi.cif.read_string(f'data_test\n{first_cif}\n').sole_block()
+
+        restored = StructureStyle()
+        restored.from_cif(block)
+
+        assert restored.as_cif == first_cif
diff --git a/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py b/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py
new file mode 100644
index 000000000..745a511ba
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py
@@ -0,0 +1,334 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the project structure_style factory."""
+
+from __future__ import annotations
+
+import gemmi
+import pytest
+
+from easydiffraction.utils.logging import Logger
+
+
+@pytest.fixture
+def raise_on_error(monkeypatch):
+    """Force Logger into RAISE mode for invalid-input assertions.
+
+    Another test may have leaked WARN mode onto the shared Logger,
+    so validators that route through ``log.error()`` would silently
+    fall back instead of raising. Pin RAISE for the test body.
+    """
+    monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+
+
+# ----------------------------------------------------------------------
+#  Module / factory surface
+# ----------------------------------------------------------------------
+
+
+def test_module_import():
+    import easydiffraction.project.categories.structure_style.factory as MUT
+
+    expected_module_name = 'easydiffraction.project.categories.structure_style.factory'
+    assert MUT.__name__ == expected_module_name
+
+
+def test_default_rules_universal_fallback():
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    # The factory declares a single universal-fallback rule.
+    assert StructureStyleFactory._default_rules == {frozenset(): 'default'}
+
+
+def test_supported_tags_lists_default():
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    tags = StructureStyleFactory.supported_tags()
+    assert isinstance(tags, list)
+    assert tags == ['default']
+
+
+def test_default_tag_without_conditions():
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    assert StructureStyleFactory.default_tag() == 'default'
+
+
+def test_default_tag_with_unmatched_conditions_falls_back():
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    # Extra conditions still match the empty-key universal fallback.
+    assert StructureStyleFactory.default_tag(scattering_type='bragg') == 'default'
+
+
+def test_create_returns_structure_style():
+    from easydiffraction.project.categories.structure_style.default import StructureStyle
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    structure_style = StructureStyleFactory.create('default')
+    assert isinstance(structure_style, StructureStyle)
+
+
+def test_create_rejects_unknown_tag():
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
+        StructureStyleFactory.create('missing')
+
+
+def test_create_default_for_returns_structure_style():
+    from easydiffraction.project.categories.structure_style.default import StructureStyle
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    structure_style = StructureStyleFactory.create_default_for()
+    assert isinstance(structure_style, StructureStyle)
+
+
+def test_supported_for_includes_registered_class():
+    from easydiffraction.project.categories.structure_style.default import StructureStyle
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    supported = StructureStyleFactory.supported_for()
+    assert StructureStyle in supported
+
+
+def test_show_supported_lists_default(capsys):
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    StructureStyleFactory.show_supported()
+    out = capsys.readouterr().out
+    assert 'Supported types' in out
+    assert 'default' in out
+
+
+def test_registry_is_independent_from_base():
+    from easydiffraction.core.factory import FactoryBase
+    from easydiffraction.project.categories.structure_style.default import StructureStyle
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    # __init_subclass__ gives each factory its own registry; the
+    # registered concrete class must not leak onto the shared base.
+    assert StructureStyle in StructureStyleFactory._registry
+    assert StructureStyle not in FactoryBase._registry
+
+
+# ----------------------------------------------------------------------
+#  Created StructureStyle instance: identity, defaults, CIF handlers
+# ----------------------------------------------------------------------
+
+
+def _make_style():
+    from easydiffraction.project.categories.structure_style.factory import StructureStyleFactory
+
+    return StructureStyleFactory.create('default')
+
+
+def test_created_instance_identity():
+    structure_style = _make_style()
+
+    assert structure_style.type_info.tag == 'default'
+    assert structure_style._category_code == 'structure_style'
+
+
+def test_created_instance_defaults():
+    structure_style = _make_style()
+
+    assert structure_style.atom_view.value == 'adp'
+    assert structure_style.color_scheme.value == 'jmol'
+    assert structure_style.adp_probability.value == 0.99
+    assert structure_style.atom_scale.value == 0.3
+
+
+def test_cif_handler_names():
+    structure_style = _make_style()
+
+    assert structure_style.atom_view._cif_handler.names == ['_structure_style.atom_view']
+    assert structure_style.color_scheme._cif_handler.names == ['_structure_style.color_scheme']
+    assert structure_style.adp_probability._cif_handler.names == [
+        '_structure_style.adp_probability',
+    ]
+    assert structure_style.atom_scale._cif_handler.names == ['_structure_style.atom_scale']
+
+
+# ----------------------------------------------------------------------
+#  Enum-backed selectors: valid setters and show_supported()
+# ----------------------------------------------------------------------
+
+
+def test_atom_view_enum_backing():
+    from easydiffraction.display.structure.enums import AtomViewEnum
+
+    structure_style = _make_style()
+
+    assert structure_style.atom_view.enum is AtomViewEnum
+
+
+def test_color_scheme_enum_backing():
+    from easydiffraction.display.structure.enums import ColorSchemeEnum
+
+    structure_style = _make_style()
+
+    assert structure_style.color_scheme.enum is ColorSchemeEnum
+
+
+def test_atom_view_setter_accepts_each_member():
+    from easydiffraction.display.structure.enums import AtomViewEnum
+
+    structure_style = _make_style()
+    for member in AtomViewEnum:
+        structure_style.atom_view = member.value
+        assert structure_style.atom_view.value == member.value
+
+
+def test_color_scheme_setter_accepts_each_member():
+    from easydiffraction.display.structure.enums import ColorSchemeEnum
+
+    structure_style = _make_style()
+    for member in ColorSchemeEnum:
+        structure_style.color_scheme = member.value
+        assert structure_style.color_scheme.value == member.value
+
+
+def test_atom_view_setter_rejects_unknown_value():
+    structure_style = _make_style()
+
+    # The setter wraps the value in the enum constructor, which rejects
+    # unknown strings with ValueError before the descriptor is touched.
+    with pytest.raises(ValueError, match='not a valid AtomViewEnum'):
+        structure_style.atom_view = 'nope'
+
+
+def test_color_scheme_setter_rejects_unknown_value():
+    structure_style = _make_style()
+
+    with pytest.raises(ValueError, match='not a valid ColorSchemeEnum'):
+        structure_style.color_scheme = 'nope'
+
+
+def test_atom_view_show_supported_lists_all_members(capsys):
+    from easydiffraction.display.structure.enums import AtomViewEnum
+
+    structure_style = _make_style()
+    structure_style.atom_view.show_supported()
+    out = capsys.readouterr().out
+
+    assert 'Atom View types' in out
+    for member in AtomViewEnum:
+        assert member.value in out
+    # The active (default) value is marked.
+    assert '*' in out
+
+
+def test_color_scheme_show_supported_lists_all_members(capsys):
+    from easydiffraction.display.structure.enums import ColorSchemeEnum
+
+    structure_style = _make_style()
+    structure_style.color_scheme.show_supported()
+    out = capsys.readouterr().out
+
+    assert 'Color Scheme types' in out
+    for member in ColorSchemeEnum:
+        assert member.value in out
+    assert '*' in out
+
+
+# ----------------------------------------------------------------------
+#  Numeric selectors: range validation (valid + invalid)
+# ----------------------------------------------------------------------
+
+
+def test_adp_probability_setter_accepts_in_range():
+    structure_style = _make_style()
+
+    structure_style.adp_probability = 0.5
+    assert structure_style.adp_probability.value == 0.5
+
+
+def test_atom_scale_setter_accepts_in_range():
+    structure_style = _make_style()
+
+    structure_style.atom_scale = 1.0  # le=1.0 boundary is allowed
+    assert structure_style.atom_scale.value == 1.0
+
+
+def test_adp_probability_rejects_value_at_or_above_one(raise_on_error):
+    structure_style = _make_style()
+
+    with pytest.raises(TypeError, match=r'structure_style\.adp_probability'):
+        structure_style.adp_probability = 1.0
+
+
+def test_adp_probability_rejects_value_at_or_below_zero(raise_on_error):
+    structure_style = _make_style()
+
+    with pytest.raises(TypeError, match=r'structure_style\.adp_probability'):
+        structure_style.adp_probability = 0.0
+
+
+def test_atom_scale_rejects_value_above_one(raise_on_error):
+    structure_style = _make_style()
+
+    with pytest.raises(TypeError, match=r'structure_style\.atom_scale'):
+        structure_style.atom_scale = 2.0
+
+
+def test_atom_scale_rejects_value_at_or_below_zero(raise_on_error):
+    structure_style = _make_style()
+
+    with pytest.raises(TypeError, match=r'structure_style\.atom_scale'):
+        structure_style.atom_scale = 0.0
+
+
+# ----------------------------------------------------------------------
+#  CIF serialisation round-trip
+# ----------------------------------------------------------------------
+
+
+def test_as_cif_emits_all_handlers():
+    structure_style = _make_style()
+    structure_style.atom_view = 'vdw'
+    structure_style.color_scheme = 'vesta'
+    structure_style.adp_probability = 0.5
+    structure_style.atom_scale = 0.8
+
+    cif = structure_style.as_cif
+
+    assert '_structure_style.atom_view vdw' in cif
+    assert '_structure_style.color_scheme vesta' in cif
+    assert '_structure_style.adp_probability 0.5' in cif
+    assert '_structure_style.atom_scale 0.8' in cif
+
+
+def test_from_cif_restores_all_fields():
+    structure_style = _make_style()
+    block = gemmi.cif.read_string(
+        'data_t\n'
+        '_structure_style.atom_view covalent\n'
+        '_structure_style.color_scheme vesta\n'
+        '_structure_style.adp_probability 0.5\n'
+        '_structure_style.atom_scale 0.8\n'
+    ).sole_block()
+
+    structure_style.from_cif(block)
+
+    assert structure_style.atom_view.value == 'covalent'
+    assert structure_style.color_scheme.value == 'vesta'
+    assert structure_style.adp_probability.value == 0.5
+    assert structure_style.atom_scale.value == 0.8
+
+
+def test_cif_round_trip_preserves_values():
+    structure_style = _make_style()
+    structure_style.atom_view = 'ionic'
+    structure_style.color_scheme = 'vesta'
+    structure_style.adp_probability = 0.75
+    structure_style.atom_scale = 0.6
+
+    block = gemmi.cif.read_string(f'data_t\n{structure_style.as_cif}\n').sole_block()
+    restored = _make_style()
+    restored.from_cif(block)
+
+    assert restored.atom_view.value == 'ionic'
+    assert restored.color_scheme.value == 'vesta'
+    assert restored.adp_probability.value == 0.75
+    assert restored.atom_scale.value == 0.6
diff --git a/tests/unit/easydiffraction/project/categories/structure_view/test_default.py b/tests/unit/easydiffraction/project/categories/structure_view/test_default.py
new file mode 100644
index 000000000..0655ebc28
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/structure_view/test_default.py
@@ -0,0 +1,359 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the project structure_view default category."""
+
+from __future__ import annotations
+
+import pytest
+
+from easydiffraction.core.variable import BoolDescriptor
+from easydiffraction.core.variable import NumericDescriptor
+from easydiffraction.project.categories.structure_view.default import StructureView
+from easydiffraction.utils.logging import Logger
+
+
+@pytest.fixture
+def view() -> StructureView:
+    """Return a freshly constructed StructureView."""
+    return StructureView()
+
+
+@pytest.fixture
+def raise_mode(monkeypatch) -> None:
+    """Force the shared Logger into RAISE mode for this test.
+
+    Another test may have leaked WARN mode into the process-global
+    Logger, so validation-failure tests pin RAISE explicitly.
+    """
+    monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+
+
+# ----------------------------------------------------------------------
+#  Module / class identity
+# ----------------------------------------------------------------------
+
+
+def test_module_import():
+    import easydiffraction.project.categories.structure_view.default as MUT
+
+    expected_module_name = 'easydiffraction.project.categories.structure_view.default'
+    assert MUT.__name__ == expected_module_name
+
+
+def test_type_info_tag():
+    assert StructureView.type_info.tag == 'default'
+
+
+def test_type_info_description():
+    assert StructureView.type_info.description == 'Project structure_view category'
+
+
+def test_category_code_class_attr():
+    assert StructureView._category_code == 'structure_view'
+
+
+def test_instantiation(view):
+    assert view is not None
+
+
+def test_identity_category_code(view):
+    assert view._identity.category_code == 'structure_view'
+
+
+def test_registered_with_factory():
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    # The @StructureViewFactory.register decorator in default.py must
+    # register the concrete class under its type_info tag.
+    assert StructureView in StructureViewFactory._registry
+
+
+# ----------------------------------------------------------------------
+#  Descriptor types
+# ----------------------------------------------------------------------
+
+
+def test_boolean_descriptor_types(view):
+    assert isinstance(view.show_labels, BoolDescriptor)
+    assert isinstance(view.show_moments, BoolDescriptor)
+
+
+def test_range_descriptor_types(view):
+    for descriptor in (
+        view.range_a_min,
+        view.range_a_max,
+        view.range_b_min,
+        view.range_b_max,
+        view.range_c_min,
+        view.range_c_max,
+    ):
+        assert isinstance(descriptor, NumericDescriptor)
+
+
+# ----------------------------------------------------------------------
+#  Defaults
+# ----------------------------------------------------------------------
+
+
+def test_default_show_labels(view):
+    assert view.show_labels.value is False
+
+
+def test_default_show_moments(view):
+    assert view.show_moments.value is True
+
+
+def test_default_range_minimums(view):
+    assert view.range_a_min.value == 0.0
+    assert view.range_b_min.value == 0.0
+    assert view.range_c_min.value == 0.0
+
+
+def test_default_range_maximums(view):
+    assert view.range_a_max.value == 1.0
+    assert view.range_b_max.value == 1.0
+    assert view.range_c_max.value == 1.0
+
+
+# ----------------------------------------------------------------------
+#  CIF handler names
+# ----------------------------------------------------------------------
+
+
+def test_boolean_cif_handler_names(view):
+    assert view.show_labels._cif_handler.names == ['_structure_view.show_labels']
+    assert view.show_moments._cif_handler.names == ['_structure_view.show_moments']
+
+
+def test_range_cif_handler_names(view):
+    expected = {
+        'range_a_min': ['_structure_view.range_a_min'],
+        'range_a_max': ['_structure_view.range_a_max'],
+        'range_b_min': ['_structure_view.range_b_min'],
+        'range_b_max': ['_structure_view.range_b_max'],
+        'range_c_min': ['_structure_view.range_c_min'],
+        'range_c_max': ['_structure_view.range_c_max'],
+    }
+    for attr, names in expected.items():
+        assert getattr(view, attr)._cif_handler.names == names
+
+
+def test_descriptor_names_match_attribute(view):
+    assert view.show_labels.name == 'show_labels'
+    assert view.show_moments.name == 'show_moments'
+    assert view.range_a_min.name == 'range_a_min'
+    assert view.range_c_max.name == 'range_c_max'
+
+
+# ----------------------------------------------------------------------
+#  Boolean setters
+# ----------------------------------------------------------------------
+
+
+def test_show_labels_setter(view):
+    view.show_labels = True
+    assert view.show_labels.value is True
+
+
+def test_show_moments_setter(view):
+    view.show_moments = False
+    assert view.show_moments.value is False
+
+
+def test_show_labels_setter_rejects_non_bool(view, raise_mode):
+    with pytest.raises(TypeError):
+        view.show_labels = 'nope'
+
+
+def test_show_moments_setter_rejects_non_bool(view, raise_mode):
+    with pytest.raises(TypeError):
+        view.show_moments = 'yes'
+
+
+def test_show_labels_setter_keeps_current_in_warn_mode(view, monkeypatch):
+    # In WARN mode a bad-type assignment logs and keeps the current
+    # value rather than raising.
+    monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+    view.show_labels = 'nope'
+    assert view.show_labels.value is False
+
+
+# ----------------------------------------------------------------------
+#  Range setters — valid values
+# ----------------------------------------------------------------------
+
+
+def test_range_a_setters_valid(view):
+    view.range_a_min = 0.25
+    view.range_a_max = 0.75
+    assert view.range_a_min.value == 0.25
+    assert view.range_a_max.value == 0.75
+
+
+def test_range_b_setters_valid(view):
+    view.range_b_min = 0.1
+    view.range_b_max = 0.9
+    assert view.range_b_min.value == 0.1
+    assert view.range_b_max.value == 0.9
+
+
+def test_range_c_setters_valid(view):
+    view.range_c_min = 0.2
+    view.range_c_max = 0.8
+    assert view.range_c_min.value == 0.2
+    assert view.range_c_max.value == 0.8
+
+
+# ----------------------------------------------------------------------
+#  Range setters — ordering guard (min < max, strict)
+# ----------------------------------------------------------------------
+
+
+def test_range_min_above_max_is_ignored(view, raise_mode):
+    # Default window is (0.0, 1.0); a min of 0.9 still satisfies
+    # min < max, so set max low first to create the violation.
+    view.range_a_max = 0.3
+    # 0.5 is not < 0.3, so the assignment must be rejected and the
+    # ordering guard must NOT raise (it only warns).
+    view.range_a_min = 0.5
+    assert view.range_a_min.value == 0.0
+
+
+def test_range_max_below_min_is_ignored(view, raise_mode):
+    view.range_a_min = 0.6
+    # 0.3 is not > 0.6, so the assignment is rejected; value unchanged.
+    view.range_a_max = 0.3
+    assert view.range_a_max.value == 1.0
+
+
+def test_range_equal_bounds_are_ignored(view, raise_mode):
+    # Strict inequality: min == max must be rejected.
+    view.range_a_min = 0.4
+    view.range_a_max = 0.4
+    assert view.range_a_max.value == 1.0
+
+
+def test_ordering_guard_does_not_raise_even_in_raise_mode(view, raise_mode):
+    # The ordering guard logs a warning without exc_type, so it must
+    # never raise regardless of the Logger reaction mode.
+    view.range_b_max = 0.2
+    view.range_b_min = 0.9  # rejected, but no exception
+    assert view.range_b_min.value == 0.0
+
+
+def test_ordering_guard_warns(view, monkeypatch, capsys):
+    monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+    view.range_c_max = 0.2
+    view.range_c_min = 0.9
+    out = capsys.readouterr().out
+    assert 'range_c_min' in out
+    assert 'min < max' in out
+
+
+# ----------------------------------------------------------------------
+#  Range setters — non-numeric input
+# ----------------------------------------------------------------------
+
+
+def test_range_setter_rejects_non_numeric(view, raise_mode):
+    # A non-numeric value fails the ``lower < value < upper`` comparison
+    # inside the guard, raising a plain TypeError.
+    with pytest.raises(TypeError):
+        view.range_a_min = 'oops'
+
+
+def test_range_setter_rejects_non_numeric_in_warn_mode(view, monkeypatch):
+    # The comparison TypeError is raised by Python itself, so it
+    # surfaces irrespective of the Logger reaction mode.
+    monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.WARN, raising=True)
+    with pytest.raises(TypeError):
+        view.range_b_max = 'oops'
+
+
+# ----------------------------------------------------------------------
+#  view_range()
+# ----------------------------------------------------------------------
+
+
+def test_view_range_defaults(view):
+    assert view.view_range() == (
+        (0.0, 1.0),
+        (0.0, 1.0),
+        (0.0, 1.0),
+    )
+
+
+def test_view_range_reflects_updates(view):
+    view.range_a_min = 0.1
+    view.range_a_max = 0.6
+    view.range_b_min = 0.2
+    view.range_b_max = 0.7
+    view.range_c_min = 0.3
+    view.range_c_max = 0.8
+    assert view.view_range() == (
+        (0.1, 0.6),
+        (0.2, 0.7),
+        (0.3, 0.8),
+    )
+
+
+def test_view_range_is_per_axis_min_max(view):
+    view.range_b_min = 0.25
+    view.range_b_max = 0.75
+    axis_a, axis_b, axis_c = view.view_range()
+    assert axis_a == (0.0, 1.0)
+    assert axis_b == (0.25, 0.75)
+    assert axis_c == (0.0, 1.0)
+
+
+# ----------------------------------------------------------------------
+#  as_cif
+# ----------------------------------------------------------------------
+
+
+def test_as_cif_returns_str(view):
+    assert isinstance(view.as_cif, str)
+
+
+def test_as_cif_contains_all_handlers(view):
+    cif = view.as_cif
+    for name in (
+        '_structure_view.show_labels',
+        '_structure_view.show_moments',
+        '_structure_view.range_a_min',
+        '_structure_view.range_a_max',
+        '_structure_view.range_b_min',
+        '_structure_view.range_b_max',
+        '_structure_view.range_c_min',
+        '_structure_view.range_c_max',
+    ):
+        assert name in cif
+
+
+def test_as_cif_reflects_boolean_values(view):
+    view.show_labels = True
+    view.show_moments = False
+    cif = view.as_cif
+    assert '_structure_view.show_labels true' in cif
+    assert '_structure_view.show_moments false' in cif
+
+
+# ----------------------------------------------------------------------
+#  parameters collection
+# ----------------------------------------------------------------------
+
+
+def test_parameters_lists_all_descriptors(view):
+    names = {param.name for param in view.parameters}
+    assert names == {
+        'show_labels',
+        'show_moments',
+        'range_a_min',
+        'range_a_max',
+        'range_b_min',
+        'range_b_max',
+        'range_c_min',
+        'range_c_max',
+    }
diff --git a/tests/unit/easydiffraction/project/categories/structure_view/test_factory.py b/tests/unit/easydiffraction/project/categories/structure_view/test_factory.py
new file mode 100644
index 000000000..aca39d25f
--- /dev/null
+++ b/tests/unit/easydiffraction/project/categories/structure_view/test_factory.py
@@ -0,0 +1,113 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Tests for the project structure_view factory."""
+
+from __future__ import annotations
+
+import pytest
+
+
+def test_module_import():
+    import easydiffraction.project.categories.structure_view.factory as MUT
+
+    expected_module_name = 'easydiffraction.project.categories.structure_view.factory'
+    assert MUT.__name__ == expected_module_name
+
+
+def test_default_rules_universal_fallback():
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    # The factory declares a single universal-fallback rule.
+    assert StructureViewFactory._default_rules == {frozenset(): 'default'}
+
+
+def test_supported_tags_lists_default():
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    tags = StructureViewFactory.supported_tags()
+    assert isinstance(tags, list)
+    assert 'default' in tags
+
+
+def test_default_tag_without_conditions():
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    assert StructureViewFactory.default_tag() == 'default'
+
+
+def test_default_tag_with_unmatched_conditions_falls_back():
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    # Extra conditions still match the empty-key universal fallback.
+    assert StructureViewFactory.default_tag(scattering_type='bragg') == 'default'
+
+
+def test_create_returns_structure_view():
+    from easydiffraction.project.categories.structure_view.default import StructureView
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    structure_view = StructureViewFactory.create('default')
+    assert isinstance(structure_view, StructureView)
+
+
+def test_create_rejects_unknown_tag():
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
+        StructureViewFactory.create('missing')
+
+
+def test_create_default_for_returns_structure_view():
+    from easydiffraction.project.categories.structure_view.default import StructureView
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    structure_view = StructureViewFactory.create_default_for()
+    assert isinstance(structure_view, StructureView)
+
+
+def test_supported_for_includes_registered_class():
+    from easydiffraction.project.categories.structure_view.default import StructureView
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    supported = StructureViewFactory.supported_for()
+    assert StructureView in supported
+
+
+def test_show_supported_lists_default(capsys):
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    StructureViewFactory.show_supported()
+    out = capsys.readouterr().out
+    assert 'Supported types' in out
+    assert 'default' in out
+
+
+def test_registry_is_independent_from_base():
+    from easydiffraction.core.factory import FactoryBase
+    from easydiffraction.project.categories.structure_view.default import StructureView
+    from easydiffraction.project.categories.structure_view.factory import (
+        StructureViewFactory,
+    )
+
+    # __init_subclass__ gives each factory its own registry; the
+    # registered concrete class must not leak onto the shared base.
+    assert StructureView in StructureViewFactory._registry
+    assert StructureView not in FactoryBase._registry

From 2f63ef929aea99a091aedda863eff9d1de56ae80 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:36:59 +0200
Subject: [PATCH 102/160] Repoint stale tests to renamed and split categories

---
 .../unit/easydiffraction/analysis/test_analysis_coverage.py | 2 +-
 tests/unit/easydiffraction/project/test_project_config.py   | 6 ++++--
 tests/unit/easydiffraction/project/test_project_load.py     | 4 ++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/unit/easydiffraction/analysis/test_analysis_coverage.py b/tests/unit/easydiffraction/analysis/test_analysis_coverage.py
index 1c52735fe..ee0873277 100644
--- a/tests/unit/easydiffraction/analysis/test_analysis_coverage.py
+++ b/tests/unit/easydiffraction/analysis/test_analysis_coverage.py
@@ -261,7 +261,7 @@ def __getitem__(self, name):
         project = SimpleNamespace(
             experiments=Experiments(),
             structures=object(),
-            chart=SimpleNamespace(plotter=Plotter()),
+            rendering_plot=SimpleNamespace(plotter=Plotter()),
             _varname='proj',
         )
         analysis = Analysis(project=project)
diff --git a/tests/unit/easydiffraction/project/test_project_config.py b/tests/unit/easydiffraction/project/test_project_config.py
index 617f3d871..0cc111398 100644
--- a/tests/unit/easydiffraction/project/test_project_config.py
+++ b/tests/unit/easydiffraction/project/test_project_config.py
@@ -40,7 +40,8 @@ def test_project_config_exposes_project_info_chart_and_table_categories():
         config.rendering_table,
         config.verbosity,
         config.rendering_structure,
-        config.style,
+        config.structure_view,
+        config.structure_style,
     ]
     assert config.parameters == (
         config.info.parameters
@@ -49,7 +50,8 @@ def test_project_config_exposes_project_info_chart_and_table_categories():
         + config.rendering_table.parameters
         + config.verbosity.parameters
         + config.rendering_structure.parameters
-        + config.style.parameters
+        + config.structure_view.parameters
+        + config.structure_style.parameters
     )
 
 
diff --git a/tests/unit/easydiffraction/project/test_project_load.py b/tests/unit/easydiffraction/project/test_project_load.py
index 4d07b07f3..2a5c1b4a0 100644
--- a/tests/unit/easydiffraction/project/test_project_load.py
+++ b/tests/unit/easydiffraction/project/test_project_load.py
@@ -86,7 +86,7 @@ def test_round_trips_display_engine_configuration(self, tmp_path):
         original.rendering_plot.type = 'asciichartpy'
         original.rendering_table.type = 'rich'
         original.rendering_structure.type = 'ascii'
-        original.style.atom_view = 'vdw'
+        original.structure_style.atom_view = 'vdw'
         original.save_as(str(tmp_path / 'proj'))
 
         loaded = Project.load(str(tmp_path / 'proj'))
@@ -94,7 +94,7 @@ def test_round_trips_display_engine_configuration(self, tmp_path):
         assert loaded.rendering_plot.type == 'asciichartpy'
         assert loaded.rendering_table.type == 'rich'
         assert loaded.rendering_structure.type == 'ascii'
-        assert loaded.style.atom_view.value == 'vdw'
+        assert loaded.structure_style.atom_view.value == 'vdw'
 
     def test_round_trips_constraints(self, tmp_path):
         original = Project(name='c1')

From 374fab1f16165dadb7a4afc2f1a7981018ca21f0 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:37:08 +0200
Subject: [PATCH 103/160] Reflow docs and regenerate package structure

---
 .../adrs/accepted/category-owner-sections.md  |   6 +-
 docs/dev/adrs/accepted/display-ux.md          |   3 +-
 .../adrs/accepted/iucr-cif-tag-alignment.md   |   4 +-
 .../project-facade-and-persistence.md         |   7 +-
 .../accepted/project-summary-rendering.md     |  62 +--
 docs/dev/adrs/accepted/selector-families.md   |  10 +-
 .../switchable-category-owned-selectors.md    |  73 +--
 docs/dev/adrs/index.md                        |  76 +--
 .../crysview-structure-visualization.md       | 220 ++++----
 .../python-cif-category-correspondence.md     |  82 +--
 .../suggestions/value-selector-discovery.md   |  86 +--
 docs/dev/issues/open.md                       |  21 +-
 docs/dev/package-structure/full.md            |  90 +++-
 docs/dev/package-structure/short.md           |  46 +-
 .../plans/crysview-structure-visualization.md | 279 +++++-----
 docs/dev/plans/structure-view-settings.md     | 509 ++++++++++--------
 .../user-guide/analysis-workflow/model.md     |  20 +-
 17 files changed, 891 insertions(+), 703 deletions(-)

diff --git a/docs/dev/adrs/accepted/category-owner-sections.md b/docs/dev/adrs/accepted/category-owner-sections.md
index 29ebcd199..0091b4c59 100644
--- a/docs/dev/adrs/accepted/category-owner-sections.md
+++ b/docs/dev/adrs/accepted/category-owner-sections.md
@@ -89,9 +89,9 @@ The public API stays flat and user-facing:
 - `project.rendering_table`
 
 Saved `project.cif` remains a section file without a `data_` header. It
-serializes the `_project.*` metadata category plus the `_rendering_plot.*` and
-`_rendering_table.*` configuration categories without pretending that the project
-config is a real datablock.
+serializes the `_project.*` metadata category plus the
+`_rendering_plot.*` and `_rendering_table.*` configuration categories
+without pretending that the project config is a real datablock.
 
 ### 4. CIF serialization is split by responsibility
 
diff --git a/docs/dev/adrs/accepted/display-ux.md b/docs/dev/adrs/accepted/display-ux.md
index 1b7379fb4..40ee2c0d1 100644
--- a/docs/dev/adrs/accepted/display-ux.md
+++ b/docs/dev/adrs/accepted/display-ux.md
@@ -43,7 +43,8 @@ defaults.
 
 Use `project.display` as the user-facing facade for display actions.
 Move serialized renderer settings out of that facade and into separate
-project categories named `project.rendering_plot` and `project.rendering_table`.
+project categories named `project.rendering_plot` and
+`project.rendering_table`.
 
 Renderer settings:
 
diff --git a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
index 1d7faddee..ddb3f05c6 100644
--- a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
+++ b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
@@ -109,8 +109,8 @@ Out of scope:
   IUCr export emits the publication-metadata categories per §2.3a with
   `?` placeholders where the project has no source data.
 - imgCIF (`cif_img.dic`); no raw image persistence path exists.
-- Project-level singleton categories `_info.*`, `_rendering_plot.*`, `_rendering_table.*`,
-  `_verbosity.*` — out of scope here; see
+- Project-level singleton categories `_info.*`, `_rendering_plot.*`,
+  `_rendering_table.*`, `_verbosity.*` — out of scope here; see
   `python-cif-category-correspondence`.
 
 ## Design Philosophy: Tiered Default Save + Separate IUCr Export
diff --git a/docs/dev/adrs/accepted/project-facade-and-persistence.md b/docs/dev/adrs/accepted/project-facade-and-persistence.md
index a70108091..31ecec72a 100644
--- a/docs/dev/adrs/accepted/project-facade-and-persistence.md
+++ b/docs/dev/adrs/accepted/project-facade-and-persistence.md
@@ -90,9 +90,10 @@ serialized project-information field. If the path is exposed in Python,
 it must not emit a `_project.path` CIF item.
 
 The project-level singleton categories currently persisted in
-`project.cif` are `_project.*`, `_rendering_plot.*`, `_report.*`, `_rendering_table.*`,
-`_verbosity.*`, `_journal.*`, `_journal_date.*`, `_journal_coeditor.*`,
-`_publ_contact_author.*`, `_publ_body.*`, and the `_publ_author.*` loop.
+`project.cif` are `_project.*`, `_rendering_plot.*`, `_report.*`,
+`_rendering_table.*`, `_verbosity.*`, `_journal.*`, `_journal_date.*`,
+`_journal_coeditor.*`, `_publ_contact_author.*`, `_publ_body.*`, and the
+`_publ_author.*` loop.
 
 ## Consequences
 
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index 1b0ecd116..8804d9eaf 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -172,7 +172,8 @@ Out of scope:
   Covered by the alignment ADR; the output file lives at
   `reports/<project>.cif` and is opt-in via `project.report.cif = True`.
 - Pre-existing project-level singleton categories (`_info.*`,
-  `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*`). Covered by the in-flight
+  `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*`). Covered by
+  the in-flight
   [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md).
   This ADR **does** add one new project-level singleton category,
   `_report.*`, alongside them (see §1.3 and the ADRs-amended list); that
@@ -213,9 +214,9 @@ The alignment ADR has already created the `project.report` facade
 extends it along two axes:
 
 - A new **configuration category** on `project.report` — persisted in
-  `project.cif`, matching the existing `project.rendering_plot`, `project.rendering_table`,
-  `project.verbosity` config pattern — that records _which_ report
-  formats `project.save()` emits and _how_.
+  `project.cif`, matching the existing `project.rendering_plot`,
+  `project.rendering_table`, `project.verbosity` config pattern — that
+  records _which_ report formats `project.save()` emits and _how_.
 - A new set of **ad-hoc per-format methods** for explicit one-off writes
   that bypass the configuration.
 
@@ -242,9 +243,10 @@ read by `project.save()` thereafter:
 
 Four per-format scalar booleans (`cif`, `html`, `tex`, `pdf`) plus
 `html_offline` — **five fields total**, all single-row in CIF. Matches
-the existing `project.rendering_plot`, `project.rendering_table`, `project.verbosity`
-scalar-config shape verbatim. All booleans default to `False`, so an
-unconfigured project produces no `reports/` directory at all.
+the existing `project.rendering_plot`, `project.rendering_table`,
+`project.verbosity` scalar-config shape verbatim. All booleans default
+to `False`, so an unconfigured project produces no `reports/` directory
+at all.
 
 There is no `style` field. The LaTeX output ships exactly one class
 (`iucrjournals`); adding another style is deferred work, not a v1
@@ -388,9 +390,9 @@ unconditionally. They are explicit one-offs.
 #### 1.3 CIF persistence of the configuration
 
 The configuration category serialises to `project.cif` next to the other
-project-level singleton categories (`_info.*`, `_rendering_plot.*`, `_rendering_table.*`,
-`_verbosity.*`). The CIF tag prefix is `_report.*` — a Set category with
-five scalar items, no loops:
+project-level singleton categories (`_info.*`, `_rendering_plot.*`,
+`_rendering_table.*`, `_verbosity.*`). The CIF tag prefix is `_report.*`
+— a Set category with five scalar items, no loops:
 
 ```text
 data_<project>
@@ -416,9 +418,9 @@ _report.html_offline  no
 
 All five items are scalar DDLm dotted entries — the category is declared
 `_definition.class Set` so a single value per item, no loops permitted.
-Matches the existing `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*` category
-shape exactly. The `yes`/`no` boolean encoding follows the project's
-existing CIF boolean convention.
+Matches the existing `_rendering_plot.*`, `_rendering_table.*`,
+`_verbosity.*` category shape exactly. The `yes`/`no` boolean encoding
+follows the project's existing CIF boolean convention.
 
 The default unconfigured state writes four explicit `no` values for the
 format booleans (not an absent or empty representation), so the "no
@@ -463,8 +465,8 @@ The split is summarised below.
 | Slot                                 | Pattern | CIF location                             | Python shape                                         |
 | ------------------------------------ | ------- | ---------------------------------------- | ---------------------------------------------------- |
 | `project.info`                       | A       | `project.cif` (`_info.*`)                | small `CategoryItem`                                 |
-| `project.rendering_plot`                      | A       | `project.cif` (`_rendering_plot.*`)               | `CategoryItem` (one field)                           |
-| `project.rendering_table`                      | A       | `project.cif` (`_rendering_table.*`)               | `CategoryItem` (one field)                           |
+| `project.rendering_plot`             | A       | `project.cif` (`_rendering_plot.*`)      | `CategoryItem` (one field)                           |
+| `project.rendering_table`            | A       | `project.cif` (`_rendering_table.*`)     | `CategoryItem` (one field)                           |
 | `project.verbosity`                  | A       | `project.cif` (`_verbosity.*`)           | `CategoryItem` (one field)                           |
 | **`project.report`** (this ADR)      | **A**   | **`project.cif` (`_report.*`)**          | **`CategoryItem` (five fields) plus action methods** |
 | `project.publication` (this ADR, §5) | A       | `project.cif` (`_publ_*` / `_journal_*`) | `CategoryOwner` of six sibling categories            |
@@ -484,10 +486,10 @@ Reasons `project.report` is Pattern A, not Pattern B:
   they are all project-level preferences, not domain data.
 
 What makes `project.report` look heavier than `project.rendering_plot` /
-`project.rendering_table` / `project.verbosity` is the action methods on the
-facade (`save_cif()`, `save_html()`, `show_report()`, `data_context()`,
-etc.). Those live on the Python class alongside the configuration
-fields, which is the facade-hybrid amendment to
+`project.rendering_table` / `project.verbosity` is the action methods on
+the facade (`save_cif()`, `save_html()`, `show_report()`,
+`data_context()`, etc.). Those live on the Python class alongside the
+configuration fields, which is the facade-hybrid amendment to
 `project-facade-and-persistence.md` already recorded in the ADRs-amended
 list. The action methods do not change where the configuration persists
 — that stays in `project.cif`.
@@ -893,9 +895,9 @@ Rationale for the config category (replacing the earlier flag-based and
 "auto on every save" positions):
 
 - Reports are a _project preference_, not a per-call argument.
-  `project.rendering_plot.type`, `project.rendering_table.type`, `project.verbosity.fit`
-  follow the same pattern — set once, persisted in `project.cif`,
-  applied on every save.
+  `project.rendering_plot.type`, `project.rendering_table.type`,
+  `project.verbosity.fit` follow the same pattern — set once, persisted
+  in `project.cif`, applied on every save.
 - `project.save()` has one job: save the project. With all report
   booleans `False`, the report behaviour is unchanged from before this
   ADR; with `project.report.html = True`, HTML appears on every save
@@ -1955,8 +1957,8 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      `_report.html_offline`). Set the configuration once through those
      booleans; `project.save()` applies it on every save thereafter.
      Replaces the flag with persisted configuration, matching the
-     existing `project.rendering_plot`, `project.rendering_table`, `project.verbosity`
-     pattern.
+     existing `project.rendering_plot`, `project.rendering_table`,
+     `project.verbosity` pattern.
   2. **`project.report.save()` surface redesigned.** The accepted
      `project.report.save()` is now a no-argument convenience that reads
      the configuration category (raises `ValueError` when no formats are
@@ -2035,12 +2037,12 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      `project.analysis`, `project.report`. Persisted to `project.cif`
      next to the other project-level singleton categories.
   3. **Project-level singleton category enumeration extended.** The
-     accepted ADR enumerates `_info.*`, `_rendering_plot.*`, `_rendering_table.*`,
-     `_verbosity.*` as the project-level singleton categories owned by
-     `project.cif`. This ADR adds two more to that enumeration:
-     `_report.*` (this ADR §1.3) and `_publication.*` family (this ADR
-     §5; concrete sub-prefixes are `_publ_*` and `_journal_*` per IUCr
-     coreCIF).
+     accepted ADR enumerates `_info.*`, `_rendering_plot.*`,
+     `_rendering_table.*`, `_verbosity.*` as the project-level singleton
+     categories owned by `project.cif`. This ADR adds two more to that
+     enumeration: `_report.*` (this ADR §1.3) and `_publication.*`
+     family (this ADR §5; concrete sub-prefixes are `_publ_*` and
+     `_journal_*` per IUCr coreCIF).
 - [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
   — owns the Python-to-CIF correspondence rule for two new project-level
   singleton surfaces:
diff --git a/docs/dev/adrs/accepted/selector-families.md b/docs/dev/adrs/accepted/selector-families.md
index fefeb1d04..1d84f0a33 100644
--- a/docs/dev/adrs/accepted/selector-families.md
+++ b/docs/dev/adrs/accepted/selector-families.md
@@ -38,11 +38,11 @@ or activates sibling categories.
 
 Recognize three selector families:
 
-| Family                       | User intent                     | Examples                                                                        |
-| ---------------------------- | ------------------------------- | ------------------------------------------------------------------------------- |
-| Backend selector             | Pick an execution backend       | `experiment.calculator.type`, `project.rendering_plot.type`, `project.rendering_table.type`        |
-| Switchable-category selector | Swap a category implementation  | `analysis.minimizer.type`, `experiment.background.type`, `experiment.peak.type` |
-| Active-sibling selector      | Pick the active sibling surface | `analysis.fitting_mode.type`                                                    |
+| Family                       | User intent                     | Examples                                                                                    |
+| ---------------------------- | ------------------------------- | ------------------------------------------------------------------------------------------- |
+| Backend selector             | Pick an execution backend       | `experiment.calculator.type`, `project.rendering_plot.type`, `project.rendering_table.type` |
+| Switchable-category selector | Swap a category implementation  | `analysis.minimizer.type`, `experiment.background.type`, `experiment.peak.type`             |
+| Active-sibling selector      | Pick the active sibling surface | `analysis.fitting_mode.type`                                                                |
 
 Backend selectors live on dedicated configuration categories.
 Switchable-category selectors live on the category they replace, and the
diff --git a/docs/dev/adrs/accepted/switchable-category-owned-selectors.md b/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
index ab276cffb..fec95ffb4 100644
--- a/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
+++ b/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
@@ -140,16 +140,16 @@ the `Calculation` category is renamed (see §8); one is new
 (`_fitting_mode`) because the active-sibling selector is promoted to its
 own category (also §8).
 
-| Today                                 | Replacement          | Mechanism family ¹ |
-| ------------------------------------- | -------------------- | ------------------ |
-| `_fitting.minimizer_type`             | `_minimizer.type`    | A                  |
-| `_peak.profile_type`                  | `_peak.type`         | A                  |
-| (none — only `_pd_background.*` loop) | `_background.type`   | A                  |
-| (none — only active-class fields)     | `_extinction.type`   | A                  |
-| `_calculation.calculator_type`        | `_calculator.type`   | B (and §8 rename)  |
-| `_rendering.chart_engine`             | `_rendering_plot.type`        | B (and §8 split)   |
-| `_rendering.table_engine`             | `_rendering_table.type`        | B (and §8 split)   |
-| `_fitting.mode_type`                  | `_fitting_mode.type` | C (and §8 promote) |
+| Today                                 | Replacement             | Mechanism family ¹ |
+| ------------------------------------- | ----------------------- | ------------------ |
+| `_fitting.minimizer_type`             | `_minimizer.type`       | A                  |
+| `_peak.profile_type`                  | `_peak.type`            | A                  |
+| (none — only `_pd_background.*` loop) | `_background.type`      | A                  |
+| (none — only active-class fields)     | `_extinction.type`      | A                  |
+| `_calculation.calculator_type`        | `_calculator.type`      | B (and §8 rename)  |
+| `_rendering.chart_engine`             | `_rendering_plot.type`  | B (and §8 split)   |
+| `_rendering.table_engine`             | `_rendering_table.type` | B (and §8 split)   |
+| `_fitting.mode_type`                  | `_fitting_mode.type`    | C (and §8 promote) |
 
 ¹ Mechanism family per [`selector-families.md`](selector-families.md): A
 swaps the category instance, B swaps the live engine behind a singleton
@@ -461,11 +461,11 @@ Owners contribute only the filter dict via
 `_supported_filters_for(category)`.
 
 The Family-B swap hooks (e.g. `Experiment._swap_calculator`,
-`Project._swap_rendering_plot`, `Project._swap_rendering_table`) follow the same shape but
-rebind the live engine rather than the category instance. The Family-C
-swap hook (`Analysis._swap_fitting_mode`) performs the existing
-sibling-activation logic. The mixin does not care which mechanism the
-owner uses; it only routes the writable surface.
+`Project._swap_rendering_plot`, `Project._swap_rendering_table`) follow
+the same shape but rebind the live engine rather than the category
+instance. The Family-C swap hook (`Analysis._swap_fitting_mode`)
+performs the existing sibling-activation logic. The mixin does not care
+which mechanism the owner uses; it only routes the writable surface.
 
 CIF read path becomes:
 
@@ -599,12 +599,13 @@ levels).
 The `Rendering` category is **removed**. Two new sibling categories
 appear on `Project`:
 
-- `project.rendering_plot` — `CategoryItem` with one writable selector `type`
-  (`PlotterEngineEnum` plus the `'auto'` sentinel) and the live
-  `Plotter` facade as a private internal. CIF block: `_rendering_plot.*`.
-- `project.rendering_table` — `CategoryItem` with one writable selector `type`
-  (`TableEngineEnum` plus `'auto'`) and the live `TableRenderer` facade
-  as a private internal. CIF block: `_rendering_table.*`.
+- `project.rendering_plot` — `CategoryItem` with one writable selector
+  `type` (`PlotterEngineEnum` plus the `'auto'` sentinel) and the live
+  `Plotter` facade as a private internal. CIF block:
+  `_rendering_plot.*`.
+- `project.rendering_table` — `CategoryItem` with one writable selector
+  `type` (`TableEngineEnum` plus `'auto'`) and the live `TableRenderer`
+  facade as a private internal. CIF block: `_rendering_table.*`.
 
 Both follow the §4 mechanism — Family B (engine swap), `category.type`
 surface — and become natural homes for future chart-only and table-only
@@ -685,16 +686,16 @@ separate, smaller table.
 
 ### In scope — every selector with a writable type surface
 
-| #   | Owner      | Today                                          | Proposed Python                    | CIF today                               | CIF proposed         | Mech           | Source                                            |
-| --- | ---------- | ---------------------------------------------- | ---------------------------------- | --------------------------------------- | -------------------- | -------------- | ------------------------------------------------- |
-| 1   | analysis   | `analysis.minimizer_type = 'X'`                | `analysis.minimizer.type = 'X'`    | `_fitting.minimizer_type`               | `_minimizer.type`    | A              | `analysis/analysis.py:1022`                       |
-| 2   | experiment | `experiment.peak_profile_type = 'X'`           | `experiment.peak.type = 'X'`       | `_peak.profile_type`                    | `_peak.type`         | A              | `experiment/item/base.py:514`                     |
-| 3   | experiment | `experiment.background_type = 'X'`             | `experiment.background.type = 'X'` | (none — only `_pd_background.*` loop)   | `_background.type`   | A              | `experiment/item/bragg_pd.py:184`                 |
-| 4   | experiment | `experiment.extinction_type = 'X'`             | `experiment.extinction.type = 'X'` | (none — only active class's own fields) | `_extinction.type`   | A              | `experiment/item/base.py:312`                     |
-| 5   | experiment | `experiment.calculation.calculator_type = 'X'` | `experiment.calculator.type = 'X'` | `_calculation.calculator_type`          | `_calculator.type`   | B + §8 rename  | `experiment/categories/calculation/default.py:50` |
-| 6   | project    | `project.rendering.chart_engine = 'X'`         | `project.rendering_plot.type = 'X'`         | `_rendering.chart_engine`               | `_rendering_plot.type`        | B + §8 split   | `project/categories/rendering/default.py:100`     |
-| 7   | project    | `project.rendering.table_engine = 'X'`         | `project.rendering_table.type = 'X'`         | `_rendering.table_engine`               | `_rendering_table.type`        | B + §8 split   | `project/categories/rendering/default.py:109`     |
-| 8   | analysis   | `analysis.fitting_mode_type = 'X'`             | `analysis.fitting_mode.type = 'X'` | `_fitting.mode_type`                    | `_fitting_mode.type` | C + §8 promote | `analysis/analysis.py:960`                        |
+| #   | Owner      | Today                                          | Proposed Python                      | CIF today                               | CIF proposed            | Mech           | Source                                            |
+| --- | ---------- | ---------------------------------------------- | ------------------------------------ | --------------------------------------- | ----------------------- | -------------- | ------------------------------------------------- |
+| 1   | analysis   | `analysis.minimizer_type = 'X'`                | `analysis.minimizer.type = 'X'`      | `_fitting.minimizer_type`               | `_minimizer.type`       | A              | `analysis/analysis.py:1022`                       |
+| 2   | experiment | `experiment.peak_profile_type = 'X'`           | `experiment.peak.type = 'X'`         | `_peak.profile_type`                    | `_peak.type`            | A              | `experiment/item/base.py:514`                     |
+| 3   | experiment | `experiment.background_type = 'X'`             | `experiment.background.type = 'X'`   | (none — only `_pd_background.*` loop)   | `_background.type`      | A              | `experiment/item/bragg_pd.py:184`                 |
+| 4   | experiment | `experiment.extinction_type = 'X'`             | `experiment.extinction.type = 'X'`   | (none — only active class's own fields) | `_extinction.type`      | A              | `experiment/item/base.py:312`                     |
+| 5   | experiment | `experiment.calculation.calculator_type = 'X'` | `experiment.calculator.type = 'X'`   | `_calculation.calculator_type`          | `_calculator.type`      | B + §8 rename  | `experiment/categories/calculation/default.py:50` |
+| 6   | project    | `project.rendering.chart_engine = 'X'`         | `project.rendering_plot.type = 'X'`  | `_rendering.chart_engine`               | `_rendering_plot.type`  | B + §8 split   | `project/categories/rendering/default.py:100`     |
+| 7   | project    | `project.rendering.table_engine = 'X'`         | `project.rendering_table.type = 'X'` | `_rendering.table_engine`               | `_rendering_table.type` | B + §8 split   | `project/categories/rendering/default.py:109`     |
+| 8   | analysis   | `analysis.fitting_mode_type = 'X'`             | `analysis.fitting_mode.type = 'X'`   | `_fitting.mode_type`                    | `_fitting_mode.type`    | C + §8 promote | `analysis/analysis.py:960`                        |
 
 Mechanism legend (recap):
 
@@ -837,11 +838,11 @@ member and exposes `category.type` plus `category.show_supported()`.
 - [`display-ux.md`](display-ux.md) — replace every reference to
   `project.rendering`, `_rendering.chart_engine`, and
   `_rendering.table_engine` with the post-§8a shape:
-  `project.rendering_plot.type`, `project.rendering_table.type`, CIF blocks `_rendering_plot.*` and
-  `_rendering_table.*`. Drop the writable-selector contract that puts chart/table
-  engines on the `rendering` category; document instead that each
-  renderer lives on its own category with the canonical `category.type`
-  surface.
+  `project.rendering_plot.type`, `project.rendering_table.type`, CIF
+  blocks `_rendering_plot.*` and `_rendering_table.*`. Drop the
+  writable-selector contract that puts chart/table engines on the
+  `rendering` category; document instead that each renderer lives on its
+  own category with the canonical `category.type` surface.
 - [`category-owner-sections.md`](category-owner-sections.md) — update
   the `ProjectConfig` children list: drop `Rendering`; add `Chart` and
   `Table` as siblings. Update the `_rendering.*` CIF block reference to
diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index 622dc9980..2757030f7 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -13,42 +13,42 @@ folders.
 
 ## ADR Index
 
-| Group                | Status     | Title                                     | Short description                                                                                                  | Link                                                                                         |
-| -------------------- | ---------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
-| Analysis and fitting | Accepted   | Fit Mode Categories and Fit Execution API | Splits fitting configuration from execution and defines active sibling fit-mode categories.                        | [`fit-mode-categories.md`](accepted/fit-mode-categories.md)                                  |
-| Analysis and fitting | Accepted   | Runtime Fit Results                       | Keeps full fit outputs runtime-only in the current design unless a narrower persistence ADR is accepted.           | [`runtime-fit-results.md`](accepted/runtime-fit-results.md)                                  |
-| Analysis and fitting | Accepted   | Analysis CIF Fit State                    | Defines the persisted fit-state projection in `analysis/analysis.cif` and `analysis/results.h5`.                   | [`analysis-cif-fit-state.md`](accepted/analysis-cif-fit-state.md)                            |
-| Analysis and fitting | Accepted   | Parameter Correlation Persistence         | Persists deterministic and posterior correlation summaries in `_fit_parameter_correlation`                         | [`parameter-correlation-persistence.md`](accepted/parameter-correlation-persistence.md)      |
-| Analysis and fitting | Suggestion | Fit Output Files and Data Exports         | Narrows remaining archive/export questions after adopting `results.csv` and `results.h5`.                          | [`fit-output-files-and-data-exports.md`](suggestions/fit-output-files-and-data-exports.md)   |
-| Analysis and fitting | Accepted   | Minimizer Category Consolidation          | Collapses the seven Bayesian categories into one owner-level switchable `minimizer` category with HDF5 sidecar.    | [`minimizer-category-consolidation.md`](accepted/minimizer-category-consolidation.md)        |
-| Analysis and fitting | Accepted   | Minimizer Input/Output Split              | Keeps `analysis.minimizer` input-only and moves scalar fit outputs to paired `analysis.fit_result` classes.        | [`minimizer-input-output-split.md`](accepted/minimizer-input-output-split.md)                |
-| Analysis and fitting | Superseded | Parameter-Level Posterior Projection      | Superseded by minimizer-category consolidation; kept as historical context for `parameter.posterior`.              | [`parameter-posterior-summary.md`](suggestions/parameter-posterior-summary.md)               |
-| Analysis and fitting | Accepted   | Undo Fit                                  | Builds rollback semantics and CLI behavior on already-persisted pre-fit scalar snapshots.                          | [`undo-fit.md`](accepted/undo-fit.md)                                                        |
-| Core model           | Accepted   | Category Owners and Real Datablocks       | Introduces `CategoryOwner` so singleton sections do not pretend to be real CIF datablocks.                         | [`category-owner-sections.md`](accepted/category-owner-sections.md)                          |
-| Core model           | Accepted   | Enum-Backed Closed Value Sets             | Requires finite option sets to use `(str, Enum)` classes for validation and dispatch.                              | [`enum-backed-closed-values.md`](accepted/enum-backed-closed-values.md)                      |
-| Core model           | Accepted   | Guarded Public Properties                 | Uses property setters as the public writability contract for guarded objects.                                      | [`guarded-public-properties.md`](accepted/guarded-public-properties.md)                      |
-| Core model           | Accepted   | Two-Level Category Parameter Access       | Keeps parameter access to `datablock.category.parameter` or `datablock.collection[id].parameter`.                  | [`category-parameter-access.md`](accepted/category-parameter-access.md)                      |
-| Documentation        | Accepted   | Descriptor Property Docstring Template    | Makes descriptor metadata the source of truth for public property docstrings and annotations.                      | [`property-docstring-template.md`](accepted/property-docstring-template.md)                  |
-| Documentation        | Accepted   | Development Documentation Structure       | Defines the `docs/dev` layout for ADRs, issues, plans, package structure, and roadmap.                             | [`development-docs-structure.md`](accepted/development-docs-structure.md)                    |
-| Documentation        | Accepted   | Help Method Discoverability               | Requires primary public objects and facades to expose consistent `help()` output.                                  | [`help-discoverability.md`](accepted/help-discoverability.md)                                |
-| Documentation        | Accepted   | Notebook Generation Source of Truth       | Treats tutorial `.py` files as editable sources and notebooks as generated artifacts.                              | [`notebook-generation.md`](accepted/notebook-generation.md)                                  |
-| Experiment model     | Accepted   | Immutable Experiment Type                 | Makes experiment type axes creation-time state rather than mutable runtime state.                                  | [`immutable-experiment-type.md`](accepted/immutable-experiment-type.md)                      |
-| Factories            | Accepted   | Factory Contracts and Metadata            | Standardizes factory construction, metadata, compatibility, and registration behavior.                             | [`factory-contracts.md`](accepted/factory-contracts.md)                                      |
-| Naming               | Accepted   | Factory Tag Naming                        | Defines canonical factory tag style and standard abbreviations.                                                    | [`factory-tag-naming.md`](accepted/factory-tag-naming.md)                                    |
-| Persistence          | Accepted   | Free-Flag CIF Encoding                    | Encodes fit free/fixed state through CIF uncertainty syntax instead of a separate free list.                       | [`free-flag-cif-encoding.md`](accepted/free-flag-cif-encoding.md)                            |
-| Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                    | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                    |
-| Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                 | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)            |
-| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds an IUCr submission report export.                          | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
-| Persistence          | Suggestion | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then proposes scoped one-to-one mapping for project-level categories.  | [`python-cif-category-correspondence.md`](suggestions/python-cif-category-correspondence.md) |
-| Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
-| Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                       | [`test-strategy.md`](accepted/test-strategy.md)                                              |
-| Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                      | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                  |
-| User-facing API      | Suggestion | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures. | [`crysview-structure-visualization.md`](suggestions/crysview-structure-visualization.md)     |
-| User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                       | [`display-ux.md`](accepted/display-ux.md)                                                    |
-| User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.    | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                    |
-| User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and publication metadata surfaces.             | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
-| User-facing API      | Accepted   | Selector Families                         | Distinguishes backend selectors, switchable-category selectors, and active-sibling selectors.                      | [`selector-families.md`](accepted/selector-families.md)                                      |
-| User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                      | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)      |
-| User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.  | [`switchable-category-api.md`](accepted/switchable-category-api.md)                          |
-| User-facing API      | Accepted   | Switchable Category Owned Selectors       | Moves the writable `type` selector and `show_supported()` onto the category itself; collapses the CIF duplication. | [`switchable-category-owned-selectors.md`](accepted/switchable-category-owned-selectors.md)  |
+| Group                | Status     | Title                                     | Short description                                                                                                     | Link                                                                                         |
+| -------------------- | ---------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| Analysis and fitting | Accepted   | Fit Mode Categories and Fit Execution API | Splits fitting configuration from execution and defines active sibling fit-mode categories.                           | [`fit-mode-categories.md`](accepted/fit-mode-categories.md)                                  |
+| Analysis and fitting | Accepted   | Runtime Fit Results                       | Keeps full fit outputs runtime-only in the current design unless a narrower persistence ADR is accepted.              | [`runtime-fit-results.md`](accepted/runtime-fit-results.md)                                  |
+| Analysis and fitting | Accepted   | Analysis CIF Fit State                    | Defines the persisted fit-state projection in `analysis/analysis.cif` and `analysis/results.h5`.                      | [`analysis-cif-fit-state.md`](accepted/analysis-cif-fit-state.md)                            |
+| Analysis and fitting | Accepted   | Parameter Correlation Persistence         | Persists deterministic and posterior correlation summaries in `_fit_parameter_correlation`                            | [`parameter-correlation-persistence.md`](accepted/parameter-correlation-persistence.md)      |
+| Analysis and fitting | Suggestion | Fit Output Files and Data Exports         | Narrows remaining archive/export questions after adopting `results.csv` and `results.h5`.                             | [`fit-output-files-and-data-exports.md`](suggestions/fit-output-files-and-data-exports.md)   |
+| Analysis and fitting | Accepted   | Minimizer Category Consolidation          | Collapses the seven Bayesian categories into one owner-level switchable `minimizer` category with HDF5 sidecar.       | [`minimizer-category-consolidation.md`](accepted/minimizer-category-consolidation.md)        |
+| Analysis and fitting | Accepted   | Minimizer Input/Output Split              | Keeps `analysis.minimizer` input-only and moves scalar fit outputs to paired `analysis.fit_result` classes.           | [`minimizer-input-output-split.md`](accepted/minimizer-input-output-split.md)                |
+| Analysis and fitting | Superseded | Parameter-Level Posterior Projection      | Superseded by minimizer-category consolidation; kept as historical context for `parameter.posterior`.                 | [`parameter-posterior-summary.md`](suggestions/parameter-posterior-summary.md)               |
+| Analysis and fitting | Accepted   | Undo Fit                                  | Builds rollback semantics and CLI behavior on already-persisted pre-fit scalar snapshots.                             | [`undo-fit.md`](accepted/undo-fit.md)                                                        |
+| Core model           | Accepted   | Category Owners and Real Datablocks       | Introduces `CategoryOwner` so singleton sections do not pretend to be real CIF datablocks.                            | [`category-owner-sections.md`](accepted/category-owner-sections.md)                          |
+| Core model           | Accepted   | Enum-Backed Closed Value Sets             | Requires finite option sets to use `(str, Enum)` classes for validation and dispatch.                                 | [`enum-backed-closed-values.md`](accepted/enum-backed-closed-values.md)                      |
+| Core model           | Accepted   | Guarded Public Properties                 | Uses property setters as the public writability contract for guarded objects.                                         | [`guarded-public-properties.md`](accepted/guarded-public-properties.md)                      |
+| Core model           | Accepted   | Two-Level Category Parameter Access       | Keeps parameter access to `datablock.category.parameter` or `datablock.collection[id].parameter`.                     | [`category-parameter-access.md`](accepted/category-parameter-access.md)                      |
+| Documentation        | Accepted   | Descriptor Property Docstring Template    | Makes descriptor metadata the source of truth for public property docstrings and annotations.                         | [`property-docstring-template.md`](accepted/property-docstring-template.md)                  |
+| Documentation        | Accepted   | Development Documentation Structure       | Defines the `docs/dev` layout for ADRs, issues, plans, package structure, and roadmap.                                | [`development-docs-structure.md`](accepted/development-docs-structure.md)                    |
+| Documentation        | Accepted   | Help Method Discoverability               | Requires primary public objects and facades to expose consistent `help()` output.                                     | [`help-discoverability.md`](accepted/help-discoverability.md)                                |
+| Documentation        | Accepted   | Notebook Generation Source of Truth       | Treats tutorial `.py` files as editable sources and notebooks as generated artifacts.                                 | [`notebook-generation.md`](accepted/notebook-generation.md)                                  |
+| Experiment model     | Accepted   | Immutable Experiment Type                 | Makes experiment type axes creation-time state rather than mutable runtime state.                                     | [`immutable-experiment-type.md`](accepted/immutable-experiment-type.md)                      |
+| Factories            | Accepted   | Factory Contracts and Metadata            | Standardizes factory construction, metadata, compatibility, and registration behavior.                                | [`factory-contracts.md`](accepted/factory-contracts.md)                                      |
+| Naming               | Accepted   | Factory Tag Naming                        | Defines canonical factory tag style and standard abbreviations.                                                       | [`factory-tag-naming.md`](accepted/factory-tag-naming.md)                                    |
+| Persistence          | Accepted   | Free-Flag CIF Encoding                    | Encodes fit free/fixed state through CIF uncertainty syntax instead of a separate free list.                          | [`free-flag-cif-encoding.md`](accepted/free-flag-cif-encoding.md)                            |
+| Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                       | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                    |
+| Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                    | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)            |
+| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds an IUCr submission report export.                             | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
+| Persistence          | Suggestion | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then proposes scoped one-to-one mapping for project-level categories.     | [`python-cif-category-correspondence.md`](suggestions/python-cif-category-correspondence.md) |
+| Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
+| Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                              |
+| Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                         | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                  |
+| User-facing API      | Suggestion | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures.   | [`crysview-structure-visualization.md`](suggestions/crysview-structure-visualization.md)     |
+| User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                          | [`display-ux.md`](accepted/display-ux.md)                                                    |
+| User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.       | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                    |
+| User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and publication metadata surfaces.                | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
+| User-facing API      | Accepted   | Selector Families                         | Distinguishes backend selectors, switchable-category selectors, and active-sibling selectors.                         | [`selector-families.md`](accepted/selector-families.md)                                      |
+| User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                         | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)      |
+| User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.     | [`switchable-category-api.md`](accepted/switchable-category-api.md)                          |
+| User-facing API      | Accepted   | Switchable Category Owned Selectors       | Moves the writable `type` selector and `show_supported()` onto the category itself; collapses the CIF duplication.    | [`switchable-category-owned-selectors.md`](accepted/switchable-category-owned-selectors.md)  |
 | User-facing API      | Suggestion | Value-Selector Discovery                  | Gives enumerated value fields a per-descriptor `show_supported()`, beside the three category-level selector families. | [`value-selector-discovery.md`](suggestions/value-selector-discovery.md)                     |
diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
index 871b19085..64cd2ee2f 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/suggestions/crysview-structure-visualization.md
@@ -48,11 +48,11 @@ Relevant facts about the current codebase:
   `atom_sites` (fractional coordinates, occupancy, isotropic ADP),
   `atom_site_aniso` (anisotropic ADP), and `space_group`.
 - The 1D charting subsystem already uses a switchable-engine pattern.
-  `project.rendering_plot.type` selects a plotter engine implemented under
-  `src/easydiffraction/display/plotters/` (`ascii.py`, `plotly.py`), and
-  `project.rendering_table.type` selects a tabler. These follow the
-  switchable-category ADRs, with CIF tags `_rendering_plot.type` and
-  `_rendering_table.type`.
+  `project.rendering_plot.type` selects a plotter engine implemented
+  under `src/easydiffraction/display/plotters/` (`ascii.py`,
+  `plotly.py`), and `project.rendering_table.type` selects a tabler.
+  These follow the switchable-category ADRs, with CIF tags
+  `_rendering_plot.type` and `_rendering_table.type`.
 - `easycrystallography` is **not** a dependency today and is not
   imported anywhere in `src/`. Any layering that places a separate
   visualization package between `easycrystallography` and
@@ -108,13 +108,14 @@ logic. Renderer choice mirrors `project.rendering_plot.type`:
   bonds, cell edges, and axes all occlude correctly). It is **not** a
   user-selectable engine (it is invoked by the report, like `pgfplots`
   is for the fit plot). The z-buffer rasterisation is plain numpy; it
-  uses `Pillow` to draw the a/b/c axis labels and the element legend
-  and to encode the PNG;
+  uses `Pillow` to draw the a/b/c axis labels and the element legend and
+  to encode the PNG;
 - a Qt Quick 3D renderer for the GUI is planned.
 
-ASCII and Three.js are the initial interactive engines, shipping together
-exactly as the `ascii` and `plotly` chart engines do; the raster renderer
-serves the TeX/PDF report, and Qt Quick 3D follows for the GUI.
+ASCII and Three.js are the initial interactive engines, shipping
+together exactly as the `ascii` and `plotly` chart engines do; the
+raster renderer serves the TeX/PDF report, and Qt Quick 3D follows for
+the GUI.
 
 A switchable engine selector is added on the project owner, parallel to
 `project.rendering_plot` / `project.rendering_table`. It is named
@@ -126,15 +127,17 @@ project.rendering_structure.show_supported()
 ```
 
 with CIF tag `_rendering_structure.type`. The name parallels
-`rendering_plot` / `rendering_table`, and follows the category-owned selector contract:
-`project.rendering_structure` is a read-only attribute on the owner;
-`project.rendering_structure.type` is the writable selector;
-`project.rendering_structure.show_supported()` lists engines. Switching `type` calls
-the owner's private `_swap_rendering_structure` hook, which rebinds the active renderer
-— the same Family B rebinding the plot engine selector uses — so no
-public `rendering_structure_type` setter or `show_supported_rendering_structure_types()` is added. The
-default is `auto`, which resolves at draw time to `threejs` in a Jupyter
-notebook and `ascii` in a terminal — exactly as `_rendering_plot.type` /
+`rendering_plot` / `rendering_table`, and follows the category-owned
+selector contract: `project.rendering_structure` is a read-only
+attribute on the owner; `project.rendering_structure.type` is the
+writable selector; `project.rendering_structure.show_supported()` lists
+engines. Switching `type` calls the owner's private
+`_swap_rendering_structure` hook, which rebinds the active renderer —
+the same Family B rebinding the plot engine selector uses — so no public
+`rendering_structure_type` setter or
+`show_supported_rendering_structure_types()` is added. The default is
+`auto`, which resolves at draw time to `threejs` in a Jupyter notebook
+and `ascii` in a terminal — exactly as `_rendering_plot.type` /
 `_rendering_table.type` resolve their environment defaults.
 
 ### 3. Add a `structure()` entry point on the display facade
@@ -239,9 +242,9 @@ carry.
 Because expansion happens in the scene builder (section 1), the 3D
 engines draw this expanded set in full. The `ascii` engine is the
 reduced-fidelity sibling (section 7): it always renders the single
-default cell and reports a wider view range as a 3D-only
-capability through `show_structure_options()`, the same way it announces
-the other features only the 3D engines draw.
+default cell and reports a wider view range as a 3D-only capability
+through `show_structure_options()`, the same way it announces the other
+features only the 3D engines draw.
 
 ### 4. Start internal, design for later extraction
 
@@ -298,11 +301,10 @@ How an atom is sized and shaped is a single **display-style switch**,
 surface are alternative depictions and a view shows one of them at a
 time:
 
-- `'vdw'`, `'covalent'`, `'ionic'` draw every atom as a
-  **radius-model sphere** for the named standard radius table;
-  displacement parameters do not affect size. This is the familiar
-  ball-and-stick depiction and works for any structure, with or without
-  ADP.
+- `'vdw'`, `'covalent'`, `'ionic'` draw every atom as a **radius-model
+  sphere** for the named standard radius table; displacement parameters
+  do not affect size. This is the familiar ball-and-stick depiction and
+  works for any structure, with or without ADP.
 - `'adp'` draws each atom as its **ADP probability surface** — a sphere
   for an atom with only isotropic ADP, an ellipsoid (semi-axes and
   orientation from the ADP tensor) for an anisotropic one. Atoms that
@@ -310,23 +312,24 @@ time:
   thermal-ellipsoid (ORTEP) depiction crystallographers use to inspect
   the displacement parameters a refinement adjusts.
 
-The default is `'adp'`, because this is a refinement tool and the thermal
-ellipsoids are usually the point; a structure with no ADP simply renders
-as covalent-radius spheres.
+The default is `'adp'`, because this is a refinement tool and the
+thermal ellipsoids are usually the point; a structure with no ADP simply
+renders as covalent-radius spheres.
 
 > **Amendment — `atom_view` merge.** An earlier design split this into
 > two settings: `atom_shape` (`ball`/`ortep`) and `radius_model`
 > (`vdw`/`covalent`/`ionic`/`atomic`). They were merged into the single
-> `atom_view` selector because `radius_model` was meaningful only in ball
-> mode, so the two-field form carried four degenerate `ortep`×radius-model
-> combinations. The flat list removes the dead states and matches how
-> VESTA/Mercury present the choice. The `atomic`/empirical option was then
-> dropped, leaving `{vdw, covalent, ionic, adp}`: its radii are within a
-> few percent of `covalent` for most elements (and identical for some), so
-> after ball-size compression it was visually indistinguishable and added
-> a redundant choice. The atomic radii remain in the element database,
-> unused by the public selector. The `adp` view still uses covalent radii
-> for the ball fallback and for mixed-occupancy sites. CIF field:
+> `atom_view` selector because `radius_model` was meaningful only in
+> ball mode, so the two-field form carried four degenerate
+> `ortep`×radius-model combinations. The flat list removes the dead
+> states and matches how VESTA/Mercury present the choice. The
+> `atomic`/empirical option was then dropped, leaving
+> `{vdw, covalent, ionic, adp}`: its radii are within a few percent of
+> `covalent` for most elements (and identical for some), so after
+> ball-size compression it was visually indistinguishable and added a
+> redundant choice. The atomic radii remain in the element database,
+> unused by the public selector. The `adp` view still uses covalent
+> radii for the ball fallback and for mixed-occupancy sites. CIF field:
 > `_style.atom_view`.
 
 In `'adp'` the surfaces are drawn at one **probability level**,
@@ -344,23 +347,23 @@ where the per-type bonding radius `r_bond` is `_atom_type.radius_bond`
 when the structure carries it, otherwise the element's covalent radius
 from the bundled database. Matches are then pruned to the first
 coordination shell — a contact is kept only when it is within `1.3×` the
-nearer atom's nearest-neighbour distance — so the large covalent radii of
-ionic A-site cations do not bond to every surrounding anion (a heuristic
-stop-gap; see open issue #108 for the full near-neighbour approach). These
-two cutoffs live on the **structure**
-and persist in the structure's own CIF (see section 8), not in
-`project.style`. The `atom_view` radius models (vdw / covalent / ionic)
-change only the rendered sphere _size_ — they never decide which
-bonds appear; bond detection is governed solely by the `_geom` cutoffs
-and the per-type bonding radius. Version 1 draws bonds computed on the
-fly from this rule while the scene is built and persists no bond table.
-The full computed bond and angle geometry — the standard `_geom_bond`
-and `_geom_angle` loops, with distances, angles, symmetry codes, and
-standard uncertainties — is a separate, related feature that reuses the
-same symmetry-expansion and distance math (see Deferred Work).
-
-`atom_view` and `color_scheme` are finite, closed
-value sets, so each is a `(str, Enum)` validated on assignment per the
+nearer atom's nearest-neighbour distance — so the large covalent radii
+of ionic A-site cations do not bond to every surrounding anion (a
+heuristic stop-gap; see open issue #108 for the full near-neighbour
+approach). These two cutoffs live on the **structure** and persist in
+the structure's own CIF (see section 8), not in `project.style`. The
+`atom_view` radius models (vdw / covalent / ionic) change only the
+rendered sphere _size_ — they never decide which bonds appear; bond
+detection is governed solely by the `_geom` cutoffs and the per-type
+bonding radius. Version 1 draws bonds computed on the fly from this rule
+while the scene is built and persists no bond table. The full computed
+bond and angle geometry — the standard `_geom_bond` and `_geom_angle`
+loops, with distances, angles, symmetry codes, and standard
+uncertainties — is a separate, related feature that reuses the same
+symmetry-expansion and distance math (see Deferred Work).
+
+`atom_view` and `color_scheme` are finite, closed value sets, so each is
+a `(str, Enum)` validated on assignment per the
 [Enum-Backed Closed Value Sets](../../../docs/dev/adrs/accepted/enum-backed-closed-values.md)
 ADR, and `project.style.show_supported()` lists the accepted values for
 every styling setting — the same discoverability the engine selectors
@@ -368,10 +371,10 @@ give through `show_supported()`. `style` is a plain category, not a
 switchable one: it has no factory-swapped `type`, only these validated
 value settings.
 
-The defaults are the **`adp`** atom view and the **Jmol/CPK**
-colour scheme, so the view looks right with no configuration. Covalent
-radii — the `adp` ball fallback and the `atom_view = 'covalent'` option —
-are preferred because they are backed by complete, well-documented
+The defaults are the **`adp`** atom view and the **Jmol/CPK** colour
+scheme, so the view looks right with no configuration. Covalent radii —
+the `adp` ball fallback and the `atom_view = 'covalent'` option — are
+preferred because they are backed by complete, well-documented
 per-element data and needs no oxidation state: today's atom-site model
 carries only an element symbol — no charge, oxidation-state, or
 coordination field — so a model that depends on charge cannot be
@@ -384,8 +387,8 @@ scheme are selected. The database carries, per element, the van der
 Waals, covalent, ionic (a representative Shannon radius at a documented
 default oxidation state and coordination), and atomic/empirical radii,
 plus the Jmol/CPK and VESTA colour palettes, each value carrying a
-documented provenance. The ionic entries let `atom_view = 'ionic'`
-work today against the documented default oxidation state; when a future
+documented provenance. The ionic entries let `atom_view = 'ionic'` work
+today against the documented default oxidation state; when a future
 atom-site charge field exists the ionic model will prefer the site's
 charge. An element with no entry for the selected radius model falls
 back to its covalent radius, and `show_structure_options()` reports the
@@ -418,11 +421,11 @@ sibling of the 3D engines: one schematic projection, one unit cell, and
 no bonds, labels, ADP ellipsoids, or moment arrows. When an `include=`
 request asks for one of those features, the engine announces it is
 available with the 3D engines and skips it, just as the ascii chart
-engine does for Plotly-only features. A view range wider than
-the default single cell is treated the same way: the terminal view
-always draws one cell and announces that multi-cell and margin ranges
-are honored only by the 3D engines, so its schematic stays uncluttered
-and the single parallelogram never disagrees with the atoms it frames.
+engine does for Plotly-only features. A view range wider than the
+default single cell is treated the same way: the terminal view always
+draws one cell and announces that multi-cell and margin ranges are
+honored only by the 3D engines, so its schematic stays uncluttered and
+the single parallelogram never disagrees with the atoms it frames.
 
 Like the other engines it consumes the same renderer-neutral scene
 (section 1): it projects the scene's Cartesian atom centres and
@@ -492,16 +495,17 @@ near-vertical edges that the column-major chart code cannot express.
 ### 8. Configuring what is shown and how
 
 > **Updated.** This configuration surface was reorganised by the
-> [`structure-view-settings`](../../plans/structure-view-settings.md) plan and
-> the [`value-selector-discovery`](value-selector-discovery.md) ADR; the
-> examples below predate that split and are kept as historical design context.
-> The current surface is three flat categories: `project.rendering_structure`
-> (engine `type` only, CIF `_rendering_structure.type`), `project.structure_view`
-> (`show_labels`, `show_moments`, `range_*`, CIF `_structure_view.*`), and
-> `project.structure_style` (`atom_view`, `color_scheme`, `adp_probability`,
-> `atom_scale`, CIF `_structure_style.*`). Per-selector discovery replaces
-> `project.style.show_supported()` — e.g.
-> `project.structure_style.atom_view.show_supported()`.
+> [`structure-view-settings`](../../plans/structure-view-settings.md)
+> plan and the [`value-selector-discovery`](value-selector-discovery.md)
+> ADR; the examples below predate that split and are kept as historical
+> design context. The current surface is three flat categories:
+> `project.rendering_structure` (engine `type` only, CIF
+> `_rendering_structure.type`), `project.structure_view` (`show_labels`,
+> `show_moments`, `range_*`, CIF `_structure_view.*`), and
+> `project.structure_style` (`atom_view`, `color_scheme`,
+> `adp_probability`, `atom_scale`, CIF `_structure_style.*`).
+> Per-selector discovery replaces `project.style.show_supported()` —
+> e.g. `project.structure_style.atom_view.show_supported()`.
 
 The view has two configuration axes — _what_ is shown (content) and
 _how_ it is drawn (engine plus styling) — both reachable from Python and
@@ -571,9 +575,10 @@ _geom.min_bond_distance_cutoff   0.0
 _geom.bond_distance_incr         0.25
 ```
 
-The `_rendering_structure.type` tag follows `_rendering_plot.type` / `_rendering_table.type` from the
-Display UX Facade ADR, including their `auto` environment-default
-convention (resolved to `threejs` in Jupyter, `ascii` in a terminal); `_geom.min_bond_distance_cutoff` and
+The `_rendering_structure.type` tag follows `_rendering_plot.type` /
+`_rendering_table.type` from the Display UX Facade ADR, including their
+`auto` environment-default convention (resolved to `threejs` in Jupyter,
+`ascii` in a terminal); `_geom.min_bond_distance_cutoff` and
 `_geom.bond_distance_incr` are the **standard cif_core** bond-cutoff
 tags (`_atom_type.radius_bond` is the standard per-type bonding radius,
 used when present). The `_style.*` and `_rendering_structure.*` tags are
@@ -584,19 +589,20 @@ Initial visibility resolves in a fixed order, so a reopened project and
 a per-call request behave predictably:
 
 1. **An explicit `include=(...)` tuple wins outright.** The view opens
-   showing exactly those features; persisted `_rendering_structure.show_*` flags are
-   ignored for that call. So `include=('atoms',)` shows only atoms even
-   when `show_labels=True` is persisted.
+   showing exactly those features; persisted
+   `_rendering_structure.show_*` flags are ignored for that call. So
+   `include=('atoms',)` shows only atoms even when `show_labels=True` is
+   persisted.
 2. **`include='auto'`** — the default, and what a bare `structure()`
    call uses — resolves each feature in turn from: data availability
    first (a feature with no data is off, such as moments without moment
-   fields), then the persisted `_rendering_structure.show_*` flag where one exists,
-   then the built-in default otherwise. Version 1 persists flags only
-   for the two features whose default a scientist most often flips —
-   `show_labels` (off) and `show_moments` (on where data exists); atoms,
-   bonds, cell, and axes follow their built-in 'auto' defaults and are
-   set per call through an explicit `include=` tuple. So
-   `show_labels=True` with `include='auto'` opens with labels on.
+   fields), then the persisted `_rendering_structure.show_*` flag where
+   one exists, then the built-in default otherwise. Version 1 persists
+   flags only for the two features whose default a scientist most often
+   flips — `show_labels` (off) and `show_moments` (on where data
+   exists); atoms, bonds, cell, and axes follow their built-in 'auto'
+   defaults and are set per call through an explicit `include=` tuple.
+   So `show_labels=True` with `include='auto'` opens with labels on.
 3. **Unsupported options are skipped and announced, never errored.**
    Whether it arrived through an explicit tuple or 'auto', a feature the
    engine cannot draw (any 3D-only feature under `ascii`) or the data
@@ -604,9 +610,9 @@ a per-call request behave predictably:
    `show_structure_options()` and at draw time.
 4. **Live modebar changes apply on top of that initial state and are
    runtime-only.** Toggling a feature in the Three.js modebar never
-   rewrites the persisted `_rendering_structure.show_*` flags or the `include=` set, so
-   reopening the project restores the resolved initial state rather than
-   the last live toggle.
+   rewrites the persisted `_rendering_structure.show_*` flags or the
+   `include=` set, so reopening the project restores the resolved
+   initial state rather than the last live toggle.
 
 ## Consequences
 
@@ -618,11 +624,12 @@ a per-call request behave predictably:
   structure and engine is discoverable with reasons.
 - Keeping crystallography in the scene builder and out of renderers lets
   several front-ends (Three.js now, Qt Quick 3D later) share one model.
-- A new switchable `view` category (`project.rendering_structure.type`, CIF
-  `_rendering_structure.type`) must be added per the switchable-category and
-  category-owner ADRs, alongside a plain (non-switchable) `style`
-  category: `style` has no factory-swapped `type`, only enum-backed
-  value settings discoverable through `show_supported()`.
+- A new switchable `view` category (`project.rendering_structure.type`,
+  CIF `_rendering_structure.type`) must be added per the
+  switchable-category and category-owner ADRs, alongside a plain
+  (non-switchable) `style` category: `style` has no factory-swapped
+  `type`, only enum-backed value settings discoverable through
+  `show_supported()`.
 - The `ascii` and `threejs` engines ship together, mirroring the chart
   engines: `ascii` needs no JavaScript and renders a schematic view in
   the terminal, CLI, and headless contexts, while `threejs` covers
@@ -689,15 +696,16 @@ All items below are now **resolved** so the implementation plan can be
 executed autonomously; the plan records the verified data sources and
 the final names.
 
-- **CIF tag spelling — resolved (see the §8 *Updated* note for the final
+- **CIF tag spelling — resolved (see the §8 _Updated_ note for the final
   split).** Project CIF: `_structure_style.atom_view` /
   `_structure_style.color_scheme` / `_structure_style.adp_probability` /
   `_structure_style.atom_scale`; `_structure_view.show_labels` /
-  `_structure_view.show_moments` / `_structure_view.range_{a,b,c}_{min,max}`; and
+  `_structure_view.show_moments` /
+  `_structure_view.range_{a,b,c}_{min,max}`; and
   `_rendering_structure.type` (engine only). These are project-internal
   app/settings tags (`_rendering_structure.type` follows the Display-UX
-  `_rendering_plot.type` / `_rendering_table.type` precedent); the radii and
-  colours are a bundled element-database asset, not CIF-serialized.
+  `_rendering_plot.type` / `_rendering_table.type` precedent); the radii
+  and colours are a bundled element-database asset, not CIF-serialized.
 - **Per-structure bond-cutoff category — resolved (standard
   `_geom.*`).** A single-record `structure.geom` category holding the
   cif_core cutoffs `_geom.min_bond_distance_cutoff` (default `0.0` Å)
@@ -718,9 +726,9 @@ the final names.
   only atoms inside the range (borders included) and bonds only between
   in-scene atoms — no out-of-range partner atoms or edge-coordination
   completion. The range is persisted as six scalar tags
-  `_rendering_structure.range_{a,b,c}_{min,max}` (one number each, defaults 0 and 1),
-  mirroring the six scalar cell parameters; a per-call `range=` tuple on
-  `structure()` overrides them for one call.
+  `_rendering_structure.range_{a,b,c}_{min,max}` (one number each,
+  defaults 0 and 1), mirroring the six scalar cell parameters; a
+  per-call `range=` tuple on `structure()` overrides them for one call.
 
 ## Deferred Work
 
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
index 65561e670..126483394 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
@@ -16,10 +16,11 @@ saved in:
 project.cif
 ```
 
-Inside that file, generic category names such as `_info.*`, `_rendering_plot.*`,
-`_rendering_table.*`, and `_verbosity.*` are less ambiguous than they would be in
-a single monolithic CIF file. This opens the option of a strict
-one-to-one correspondence for project-owned singleton categories:
+Inside that file, generic category names such as `_info.*`,
+`_rendering_plot.*`, `_rendering_table.*`, and `_verbosity.*` are less
+ambiguous than they would be in a single monolithic CIF file. This opens
+the option of a strict one-to-one correspondence for project-owned
+singleton categories:
 
 ```text
 project.info.title        -> project.cif: _info.title
@@ -53,34 +54,34 @@ to objects reached from the current `Project` root, for example
 
 ## Current Persistence Layout
 
-| Current Python surface                           | Current saved location   | Current CIF block form | Notes                                                                                 |
-| ------------------------------------------------ | ------------------------ | ---------------------- | ------------------------------------------------------------------------------------- |
+| Current Python surface                                              | Current saved location   | Current CIF block form | Notes                                                                                 |
+| ------------------------------------------------------------------- | ------------------------ | ---------------------- | ------------------------------------------------------------------------------------- |
 | `project.info`, `project.rendering_plot`, `project.rendering_table` | `project.cif`            | bare categories        | Project-level singleton config.                                                       |
-| `project.report`                                 | `project.cif`            | bare category          | Project-owned report-output config; report methods render artifacts under `reports/`. |
-| `project.publication`                            | `project.cif`            | bare categories + loop | Journal-submission metadata under `_journal_*` / `_publ_*` categories.                |
-| `project.verbosity`                              | `project.cif`            | bare category          | Project-owned fit-output verbosity category backed by `VerbosityEnum`.                |
-| `project.structures[name]`                       | `structures/<name>.cif`  | `data_<name>`          | Each structure is one CIF data block.                                                 |
-| `project.experiments[name]`                      | `experiments/<name>.cif` | `data_<name>`          | Each experiment is one CIF data block.                                                |
-| `project.analysis`                               | `analysis/analysis.cif`  | bare categories        | Loader also accepts legacy root-level `analysis.cif`.                                 |
-| `project.summary`                                | `summary.cif`            | placeholder text       | Summary persistence exists as a file but `summary_to_cif()` is not implemented yet.   |
+| `project.report`                                                    | `project.cif`            | bare category          | Project-owned report-output config; report methods render artifacts under `reports/`. |
+| `project.publication`                                               | `project.cif`            | bare categories + loop | Journal-submission metadata under `_journal_*` / `_publ_*` categories.                |
+| `project.verbosity`                                                 | `project.cif`            | bare category          | Project-owned fit-output verbosity category backed by `VerbosityEnum`.                |
+| `project.structures[name]`                                          | `structures/<name>.cif`  | `data_<name>`          | Each structure is one CIF data block.                                                 |
+| `project.experiments[name]`                                         | `experiments/<name>.cif` | `data_<name>`          | Each experiment is one CIF data block.                                                |
+| `project.analysis`                                                  | `analysis/analysis.cif`  | bare categories        | Loader also accepts legacy root-level `analysis.cif`.                                 |
+| `project.summary`                                                   | `summary.cif`            | placeholder text       | Summary persistence exists as a file but `summary_to_cif()` is not implemented yet.   |
 
 ## Current Correspondence
 
 ### Project-Level Configuration
 
-| Current Python path          | Current CIF path         | Match? | Notes                                                                                              |
-| ---------------------------- | ------------------------ | ------ | -------------------------------------------------------------------------------------------------- |
-| `project.info.name`          | `_project.id`            | No     | Python uses user-facing `name`; CIF uses `id`; category is `info` in Python but `_project` in CIF. |
-| `project.info.title`         | `_project.title`         | Partly | Field name matches, category name does not.                                                        |
-| `project.info.description`   | `_project.description`   | Partly | Field name matches, category name does not.                                                        |
-| `project.info.created`       | `_project.created`       | Partly | Field name matches, category name does not.                                                        |
-| `project.info.last_modified` | `_project.last_modified` | Partly | Field name matches, category name does not.                                                        |
-| `project.info.path`          | none                     | No     | Runtime storage path, not a CIF field.                                                             |
-| `project.rendering_plot.type`         | `_rendering_plot.type`            | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.report.*`           | `_report.*`              | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.publication.*`      | `_journal.*` / `_publ_*` | Partly | Python keeps one owner with sibling categories; CIF uses journal and publication dictionary names. |
-| `project.rendering_table.type`         | `_rendering_table.type`            | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.verbosity.fit`      | `_verbosity.fit`         | Yes    | Direct category and field mapping for fitting process output verbosity.                            |
+| Current Python path            | Current CIF path         | Match? | Notes                                                                                              |
+| ------------------------------ | ------------------------ | ------ | -------------------------------------------------------------------------------------------------- |
+| `project.info.name`            | `_project.id`            | No     | Python uses user-facing `name`; CIF uses `id`; category is `info` in Python but `_project` in CIF. |
+| `project.info.title`           | `_project.title`         | Partly | Field name matches, category name does not.                                                        |
+| `project.info.description`     | `_project.description`   | Partly | Field name matches, category name does not.                                                        |
+| `project.info.created`         | `_project.created`       | Partly | Field name matches, category name does not.                                                        |
+| `project.info.last_modified`   | `_project.last_modified` | Partly | Field name matches, category name does not.                                                        |
+| `project.info.path`            | none                     | No     | Runtime storage path, not a CIF field.                                                             |
+| `project.rendering_plot.type`  | `_rendering_plot.type`   | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.report.*`             | `_report.*`              | Yes    | Direct project-owned report-output configuration mapping.                                          |
+| `project.publication.*`        | `_journal.*` / `_publ_*` | Partly | Python keeps one owner with sibling categories; CIF uses journal and publication dictionary names. |
+| `project.rendering_table.type` | `_rendering_table.type`  | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.verbosity.fit`        | `_verbosity.fit`         | Yes    | Direct category and field mapping for fitting process output verbosity.                            |
 
 ### Analysis Configuration
 
@@ -242,16 +243,16 @@ should gain additional coverage-specific fields.
 Possible strict-correspondence target if a future ADR explicitly changes
 the accepted `_project.*` baseline:
 
-| Python path                  | Target CIF path       | Current state                                    |
-| ---------------------------- | --------------------- | ------------------------------------------------ |
-| `project.info.name`          | `_info.name`          | Currently `_project.id`.                         |
-| `project.info.title`         | `_info.title`         | Currently `_project.title`.                      |
-| `project.info.description`   | `_info.description`   | Currently `_project.description`.                |
-| `project.info.created`       | `_info.created`       | Currently `_project.created`.                    |
-| `project.info.last_modified` | `_info.last_modified` | Currently `_project.last_modified`.              |
-| `project.rendering_plot.type`         | `_rendering_plot.type`         | Already matches.                                 |
-| `project.rendering_table.type`         | `_rendering_table.type`         | Already matches.                                 |
-| `project.verbosity.fit`      | `_verbosity.fit`      | Implemented direct fit-output verbosity mapping. |
+| Python path                    | Target CIF path         | Current state                                    |
+| ------------------------------ | ----------------------- | ------------------------------------------------ |
+| `project.info.name`            | `_info.name`            | Currently `_project.id`.                         |
+| `project.info.title`           | `_info.title`           | Currently `_project.title`.                      |
+| `project.info.description`     | `_info.description`     | Currently `_project.description`.                |
+| `project.info.created`         | `_info.created`         | Currently `_project.created`.                    |
+| `project.info.last_modified`   | `_info.last_modified`   | Currently `_project.last_modified`.              |
+| `project.rendering_plot.type`  | `_rendering_plot.type`  | Already matches.                                 |
+| `project.rendering_table.type` | `_rendering_table.type` | Already matches.                                 |
+| `project.verbosity.fit`        | `_verbosity.fit`        | Implemented direct fit-output verbosity mapping. |
 
 Alternative target if the project identity field should be called `id`
 rather than `name`:
@@ -330,15 +331,16 @@ underlying API pattern.
   `project.verbosity.fit`, leaving room for future coverage-specific
   verbosity fields.
 - Chart and table renderers are separate selector categories
-  (`project.rendering_plot.type`, `project.rendering_table.type`), so a future collapsed
-  renderer setting would need a separate ADR.
+  (`project.rendering_plot.type`, `project.rendering_table.type`), so a
+  future collapsed renderer setting would need a separate ADR.
 
 ## Open Questions
 
 - Should the project identity remain `project.info.name`, or should it
   become `project.info.id` to mirror the saved identifier field?
-- Should `project.rendering_plot.type` and `project.rendering_table.type` remain separate,
-  or should the public API and CIF collapse to one renderer field?
+- Should `project.rendering_plot.type` and
+  `project.rendering_table.type` remain separate, or should the public
+  API and CIF collapse to one renderer field?
 - Should `project.verbosity = 'short'` remain as a convenience alias for
   `project.verbosity.fit = 'short'`, or should strict correspondence
   remove the alias?
diff --git a/docs/dev/adrs/suggestions/value-selector-discovery.md b/docs/dev/adrs/suggestions/value-selector-discovery.md
index 8bf4b2169..640126a62 100644
--- a/docs/dev/adrs/suggestions/value-selector-discovery.md
+++ b/docs/dev/adrs/suggestions/value-selector-discovery.md
@@ -20,10 +20,10 @@ place.
 
 Two accepted ADRs set up that expectation but only half-deliver it:
 
-- [`enum-backed-closed-values.md`](enum-backed-closed-values.md) requires
-  every finite closed set to be a `(str, Enum)` and names "finite choices
-  are discoverable" as a consequence. It also makes enum members the
-  source of truth for **descriptions**.
+- [`enum-backed-closed-values.md`](enum-backed-closed-values.md)
+  requires every finite closed set to be a `(str, Enum)` and names
+  "finite choices are discoverable" as a consequence. It also makes enum
+  members the source of truth for **descriptions**.
 - [`switchable-category-owned-selectors.md`](switchable-category-owned-selectors.md)
   gives the three category-level selector families from
   [`selector-families.md`](selector-families.md) — backend,
@@ -34,12 +34,12 @@ Two accepted ADRs set up that expectation but only half-deliver it:
   category.show_supported()
   ```
 
-  All three are *category-level* selectors: each has an owner
+  All three are _category-level_ selectors: each has an owner
   `_swap_<name>` hook, the category **is** the single selector, and
   `show_supported()` lives on the category.
 
 But many enumerated choices are **not** category-level selectors. They
-are plain enumerated *fields* inside a category — there is no backend or
+are plain enumerated _fields_ inside a category — there is no backend or
 category to swap, only a value the consumer reads. Examples today:
 
 - `structure_style.atom_view`, `structure_style.color_scheme`
@@ -71,13 +71,13 @@ a discovery surface symmetric with the three category-level families.
 1. **Definition.** A value selector is an enumerated descriptor field
    over a **project-owned, static `(str, Enum)`** closed set (per
    [`enum-backed-closed-values.md`](enum-backed-closed-values.md)) whose
-   assignment sets a value (no class swap, no `_swap_<name>` hook). It is
-   distinct from the three category-level families in
+   assignment sets a value (no class swap, no `_swap_<name>` hook). It
+   is distinct from the three category-level families in
    [`selector-families.md`](selector-families.md), which swap a category
-   instance, rebind a backend, or activate siblings. A field whose allowed
-   set is **dynamic, external, or context-dependent** (validated against a
-   database or another field rather than a closed enum) is **not** a value
-   selector and is out of scope — see Decision 4.
+   instance, rebind a backend, or activate siblings. A field whose
+   allowed set is **dynamic, external, or context-dependent** (validated
+   against a database or another field rather than a closed enum) is
+   **not** a value selector and is out of scope — see Decision 4.
 
 2. **Discovery lives on the descriptor.** A value selector exposes
    `show_supported()` on the descriptor itself, reusing the **same**
@@ -119,16 +119,17 @@ a discovery surface symmetric with the three category-level families.
      they keep their category-level `show_supported()`.
    - **Dynamic / external / context-dependent** membership validators —
      `atom_sites.type_symbol`, `atom_sites.wyckoff_letter`,
-     `space_group.name_h_m`, `space_group.it_coordinate_system_code`, and
-     any field whose allowed values come from a database, another field,
-     or runtime context. These keep their existing `MembershipValidator`
-     and current validation behavior; they do **not** become
-     `EnumDescriptor`s and do **not** gain `show_supported()` under this
-     ADR. A separate dynamic-choice discovery surface is deferred.
-
-   An implementation audit classifies each `MembershipValidator` field as
-   value selector, category-level selector, or dynamic/external before
-   any migration.
+     `space_group.name_h_m`, `space_group.it_coordinate_system_code`,
+     and any field whose allowed values come from a database, another
+     field, or runtime context. These keep their existing
+     `MembershipValidator` and current validation behavior; they do
+     **not** become `EnumDescriptor`s and do **not** gain
+     `show_supported()` under this ADR. A separate dynamic-choice
+     discovery surface is deferred.
+
+   An implementation audit classifies each `MembershipValidator` field
+   as value selector, category-level selector, or dynamic/external
+   before any migration.
 
 5. **No category-level `show_supported()` on bundle categories.** A
    category that holds several value selectors (e.g. `structure_style`,
@@ -154,24 +155,24 @@ a discovery surface symmetric with the three category-level families.
 - Every finite choice is discoverable at its own selector, finally
   delivering the enum-backed ADR's "discoverable" promise for value
   fields, with one table format shared across all selector shapes.
-- The public surface is uniform: *every* selector answers
+- The public surface is uniform: _every_ selector answers
   `show_supported()`. Category-level selectors answer at
   `category.show_supported()`; value selectors at
   `category.field.show_supported()`. The asymmetry is intentional — a
-  category-level selector *is* the category, whereas a value field is one
-  of several on its category.
+  category-level selector _is_ the category, whereas a value field is
+  one of several on its category.
 - No deeper category tree: `show_supported()` is a method on the
   descriptor the getter already returns, not a nested sub-category.
 - Immutable categories (per
   [`immutable-experiment-type.md`](immutable-experiment-type.md)) still
   expose `show_supported()` as read-only discovery, even where the value
   is creation-time only.
-- This is a project-wide migration of the **enum-backed** value selectors
-  only (the audit pins the exact set; the dynamic/external validators
-  above are excluded and keep their current behavior). Affected enums gain
-  `.default()`/`.description` where missing. The phased rollout — and the
-  matching narrowing of which `atom_sites`/`space_group` fields are touched
-  — is tracked by the
+- This is a project-wide migration of the **enum-backed** value
+  selectors only (the audit pins the exact set; the dynamic/external
+  validators above are excluded and keep their current behavior).
+  Affected enums gain `.default()`/`.description` where missing. The
+  phased rollout — and the matching narrowing of which
+  `atom_sites`/`space_group` fields are touched — is tracked by the
   [`structure-view-settings`](../../plans/structure-view-settings.md)
   implementation plan, which also reorganizes the structure-view
   categories that motivated this ADR.
@@ -184,31 +185,32 @@ a discovery surface symmetric with the three category-level families.
   hook; a colour scheme or atom-view mode swaps nothing. Forcing that
   machinery would either nest a category under a category
   (`structure_style.color_scheme.type` — a deeper tree, which violates
-  the flat-sibling rule) or pollute the top level (`project.color_scheme`).
+  the flat-sibling rule) or pollute the top level
+  (`project.color_scheme`).
 - **Category-level `show_supported()` listing every enumerated field on
   the bundle.** Rejected as the primary surface: ambiguous on a
-  multi-field category and redundant with the per-descriptor method. Kept
-  open only as an optional, clearly-named grouped overview for related
-  axis bundles (Deferred Work).
+  multi-field category and redundant with the per-descriptor method.
+  Kept open only as an optional, clearly-named grouped overview for
+  related axis bundles (Deferred Work).
 - **Rely on `help()`, docstrings, and validation errors.** Rejected:
   `help()` describes the field but does not enumerate accepted values
   with the active one marked, and users should not have to trigger an
   error to learn the options.
-- **Keep `StringDescriptor + MembershipValidator(allowed=[...])` and bolt
-  on `show_supported()` per site.** Rejected: duplicates the
+- **Keep `StringDescriptor + MembershipValidator(allowed=[...])` and
+  bolt on `show_supported()` per site.** Rejected: duplicates the
   enum-to-allowed wiring, is easy to forget, and has no single source of
   truth. `EnumDescriptor` binds the enum once and derives validation,
   default, and discovery together.
 
 ## Deferred Work
 
-- A separate **dynamic-choice descriptor** giving a discovery surface
-  (a `show_supported()`-style listing) to fields whose allowed set is
+- A separate **dynamic-choice descriptor** giving a discovery surface (a
+  `show_supported()`-style listing) to fields whose allowed set is
   dynamic, external, or context-dependent — `atom_sites.type_symbol`,
   `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
-  `space_group.it_coordinate_system_code`, and similar. Out of scope here;
-  these keep their current `MembershipValidator` until such a descriptor
-  exists.
+  `space_group.it_coordinate_system_code`, and similar. Out of scope
+  here; these keep their current `MembershipValidator` until such a
+  descriptor exists.
 - An optional, clearly-named grouped overview for tightly-related axis
   bundles (notably `experiment.experiment_type`'s four axes shown
   together). Not part of the initial rollout.
diff --git a/docs/dev/issues/open.md b/docs/dev/issues/open.md
index afead8846..4576913da 100644
--- a/docs/dev/issues/open.md
+++ b/docs/dev/issues/open.md
@@ -1806,16 +1806,17 @@ Jahn–Teller octahedra) or under-prune others, and it is not yet
 user-configurable.
 
 **Fix:** consider a robust, configurable near-neighbour algorithm for
-automatic "reasonable" bonding — e.g. a Voronoi / solid-angle method such
-as pymatgen's `CrystalNN` or `VoronoiNN`, which weights neighbours by
-solid angle instead of a single relative cutoff. The Voronoi route is the
-most robust across arbitrary structures but introduces a heavyweight
-dependency (pymatgen), so it needs a dependency decision; an ASE/Jmol-style
-multiplicative covalent tolerance is lighter but, like the current factor,
-cannot separate shells when ionic-cation covalent radii are large.
-
-**Depends on:** dependency decision for pymatgen (if the Voronoi route is
-chosen).
+automatic "reasonable" bonding — e.g. a Voronoi / solid-angle method
+such as pymatgen's `CrystalNN` or `VoronoiNN`, which weights neighbours
+by solid angle instead of a single relative cutoff. The Voronoi route is
+the most robust across arbitrary structures but introduces a heavyweight
+dependency (pymatgen), so it needs a dependency decision; an
+ASE/Jmol-style multiplicative covalent tolerance is lighter but, like
+the current factor, cannot separate shells when ionic-cation covalent
+radii are large.
+
+**Depends on:** dependency decision for pymatgen (if the Voronoi route
+is chosen).
 
 ---
 
diff --git a/docs/dev/package-structure/full.md b/docs/dev/package-structure/full.md
index c6d7fb0e7..fdcf3c8d7 100644
--- a/docs/dev/package-structure/full.md
+++ b/docs/dev/package-structure/full.md
@@ -254,6 +254,7 @@
 │       ├── 🏷️ class GenericIntegerDescriptor
 │       ├── 🏷️ class GenericParameter
 │       ├── 🏷️ class StringDescriptor
+│       ├── 🏷️ class EnumDescriptor
 │       ├── 🏷️ class BoolDescriptor
 │       ├── 🏷️ class NumericDescriptor
 │       ├── 🏷️ class IntegerDescriptor
@@ -452,6 +453,12 @@
 │   │   │   │   │   └── 🏷️ class Cell
 │   │   │   │   └── 📄 factory.py
 │   │   │   │       └── 🏷️ class CellFactory
+│   │   │   ├── 📁 geom
+│   │   │   │   ├── 📄 __init__.py
+│   │   │   │   ├── 📄 default.py
+│   │   │   │   │   └── 🏷️ class Geom
+│   │   │   │   └── 📄 factory.py
+│   │   │   │       └── 🏷️ class GeomFactory
 │   │   │   ├── 📁 space_group
 │   │   │   │   ├── 📄 __init__.py
 │   │   │   │   ├── 📄 default.py
@@ -482,6 +489,53 @@
 │   │   └── 📄 plotly.py
 │   │       ├── 🏷️ class PowderCompositeRows
 │   │       └── 🏷️ class PlotlyPlotter
+│   ├── 📁 structure
+│   │   ├── 📁 assets
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 colors.py
+│   │   │   ├── 📄 elements.py
+│   │   │   └── 📄 radii.py
+│   │   ├── 📁 renderers
+│   │   │   ├── 📁 vendor
+│   │   │   │   └── 📁 threejs
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 ascii.py
+│   │   │   │   ├── 🏷️ class _Orientation
+│   │   │   │   └── 🏷️ class AsciiStructureRenderer
+│   │   │   ├── 📄 base.py
+│   │   │   │   └── 🏷️ class StructureRendererBase
+│   │   │   ├── 📄 raster.py
+│   │   │   │   ├── 🏷️ class _Canvas
+│   │   │   │   └── 🏷️ class RasterStructureRenderer
+│   │   │   └── 📄 threejs.py
+│   │   │       └── 🏷️ class ThreeJsStructureRenderer
+│   │   ├── 📁 templates
+│   │   ├── 📄 __init__.py
+│   │   ├── 📄 builder.py
+│   │   │   ├── 🏷️ class FeatureAvailability
+│   │   │   ├── 🏷️ class _RenderContext
+│   │   │   └── 🏷️ class _SceneAtom
+│   │   ├── 📄 enums.py
+│   │   │   ├── 🏷️ class ViewerEngineEnum
+│   │   │   ├── 🏷️ class AtomViewEnum
+│   │   │   └── 🏷️ class ColorSchemeEnum
+│   │   ├── 📄 scene.py
+│   │   │   ├── 🏷️ class AtomSphere
+│   │   │   ├── 🏷️ class OccupancyWedge
+│   │   │   ├── 🏷️ class OccupancyWedgeSphere
+│   │   │   ├── 🏷️ class AdpEllipsoid
+│   │   │   ├── 🏷️ class Bond
+│   │   │   ├── 🏷️ class MomentArrow
+│   │   │   ├── 🏷️ class CellEdge
+│   │   │   ├── 🏷️ class CellEdges
+│   │   │   ├── 🏷️ class AxisArrow
+│   │   │   ├── 🏷️ class AxisTriad
+│   │   │   ├── 🏷️ class TextLabel
+│   │   │   ├── 🏷️ class LegendEntry
+│   │   │   └── 🏷️ class StructureScene
+│   │   └── 📄 viewing.py
+│   │       ├── 🏷️ class ViewerFactory
+│   │       └── 🏷️ class Viewer
 │   ├── 📁 tablers
 │   │   ├── 📄 __init__.py
 │   │   ├── 📄 base.py
@@ -541,12 +595,6 @@
 │   └── 📄 results_sidecar.py
 ├── 📁 project
 │   ├── 📁 categories
-│   │   ├── 📁 chart
-│   │   │   ├── 📄 __init__.py
-│   │   │   ├── 📄 default.py
-│   │   │   │   └── 🏷️ class Chart
-│   │   │   └── 📄 factory.py
-│   │   │       └── 🏷️ class ChartFactory
 │   │   ├── 📁 info
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
@@ -568,18 +616,42 @@
 │   │   │   └── 📄 factory.py
 │   │   │       └── 🏷️ class PublicationFactory
 │   │   ├── 📁 rendering
+│   │   ├── 📁 rendering_plot
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   │   └── 🏷️ class RenderingPlot
+│   │   │   └── 📄 factory.py
+│   │   │       └── 🏷️ class RenderingPlotFactory
+│   │   ├── 📁 rendering_structure
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   │   └── 🏷️ class RenderingStructure
+│   │   │   └── 📄 factory.py
+│   │   │       └── 🏷️ class RenderingStructureFactory
+│   │   ├── 📁 rendering_table
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   │   └── 🏷️ class RenderingTable
+│   │   │   └── 📄 factory.py
+│   │   │       └── 🏷️ class RenderingTableFactory
 │   │   ├── 📁 report
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
 │   │   │   │   └── 🏷️ class Report
 │   │   │   └── 📄 factory.py
 │   │   │       └── 🏷️ class ReportFactory
-│   │   ├── 📁 table
+│   │   ├── 📁 structure_style
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   │   └── 🏷️ class StructureStyle
+│   │   │   └── 📄 factory.py
+│   │   │       └── 🏷️ class StructureStyleFactory
+│   │   ├── 📁 structure_view
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
-│   │   │   │   └── 🏷️ class Table
+│   │   │   │   └── 🏷️ class StructureView
 │   │   │   └── 📄 factory.py
-│   │   │       └── 🏷️ class TableFactory
+│   │   │       └── 🏷️ class StructureViewFactory
 │   │   ├── 📁 verbosity
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
diff --git a/docs/dev/package-structure/short.md b/docs/dev/package-structure/short.md
index 26f42e63d..d805b8011 100644
--- a/docs/dev/package-structure/short.md
+++ b/docs/dev/package-structure/short.md
@@ -214,6 +214,10 @@
 │   │   │   │   ├── 📄 __init__.py
 │   │   │   │   ├── 📄 default.py
 │   │   │   │   └── 📄 factory.py
+│   │   │   ├── 📁 geom
+│   │   │   │   ├── 📄 __init__.py
+│   │   │   │   ├── 📄 default.py
+│   │   │   │   └── 📄 factory.py
 │   │   │   ├── 📁 space_group
 │   │   │   │   ├── 📄 __init__.py
 │   │   │   │   ├── 📄 default.py
@@ -232,6 +236,26 @@
 │   │   ├── 📄 ascii.py
 │   │   ├── 📄 base.py
 │   │   └── 📄 plotly.py
+│   ├── 📁 structure
+│   │   ├── 📁 assets
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 colors.py
+│   │   │   ├── 📄 elements.py
+│   │   │   └── 📄 radii.py
+│   │   ├── 📁 renderers
+│   │   │   ├── 📁 vendor
+│   │   │   │   └── 📁 threejs
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 ascii.py
+│   │   │   ├── 📄 base.py
+│   │   │   ├── 📄 raster.py
+│   │   │   └── 📄 threejs.py
+│   │   ├── 📁 templates
+│   │   ├── 📄 __init__.py
+│   │   ├── 📄 builder.py
+│   │   ├── 📄 enums.py
+│   │   ├── 📄 scene.py
+│   │   └── 📄 viewing.py
 │   ├── 📁 tablers
 │   │   ├── 📄 __init__.py
 │   │   ├── 📄 base.py
@@ -256,10 +280,6 @@
 │   └── 📄 results_sidecar.py
 ├── 📁 project
 │   ├── 📁 categories
-│   │   ├── 📁 chart
-│   │   │   ├── 📄 __init__.py
-│   │   │   ├── 📄 default.py
-│   │   │   └── 📄 factory.py
 │   │   ├── 📁 info
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
@@ -269,11 +289,27 @@
 │   │   │   ├── 📄 default.py
 │   │   │   └── 📄 factory.py
 │   │   ├── 📁 rendering
+│   │   ├── 📁 rendering_plot
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   └── 📄 factory.py
+│   │   ├── 📁 rendering_structure
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   └── 📄 factory.py
+│   │   ├── 📁 rendering_table
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   └── 📄 factory.py
 │   │   ├── 📁 report
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
 │   │   │   └── 📄 factory.py
-│   │   ├── 📁 table
+│   │   ├── 📁 structure_style
+│   │   │   ├── 📄 __init__.py
+│   │   │   ├── 📄 default.py
+│   │   │   └── 📄 factory.py
+│   │   ├── 📁 structure_view
 │   │   │   ├── 📄 __init__.py
 │   │   │   ├── 📄 default.py
 │   │   │   └── 📄 factory.py
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index 5cb7c7aea..bc1fffdf5 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -8,14 +8,14 @@ exceptions to those instructions.
 > **Status (updated).** Phase 1 (code) shipped on this branch — the
 > feature is implemented. **Phase 2 (tests) was never executed**; its
 > unit-test files are discharged by the
-> [`structure-view-settings`](structure-view-settings.md) plan's Phase 2,
-> written once against the final API. Some prose below is kept only as a
-> historical design record and predates two later changes: the
+> [`structure-view-settings`](structure-view-settings.md) plan's Phase
+> 2, written once against the final API. Some prose below is kept only
+> as a historical design record and predates two later changes: the
 > `atom_shape`/`radius_model` → `atom_view` merge (commit `f31996da7`)
-> and the `structure-view-settings` split of `style` / `rendering_structure`
-> into `rendering_structure` (engine) + `structure_view` + `structure_style`.
-> See the crysview ADR and the `structure-view-settings` plan for the
-> current design.
+> and the `structure-view-settings` split of `style` /
+> `rendering_structure` into `rendering_structure` (engine) +
+> `structure_view` + `structure_style`. See the crysview ADR and the
+> `structure-view-settings` plan for the current design.
 
 > **Context for this plan.** This is a **greenfield feature**: there is
 > no prior crysview implementation on the branch. The ADR review cycle
@@ -52,9 +52,10 @@ exceptions to those instructions.
     and
     [`switchable-category-api.md`](../adrs/accepted/switchable-category-api.md)
     — the contract the new switchable `view` category follows
-    (`project.rendering_structure` read-only attribute; `project.rendering_structure.type` writable
-    selector; `project.rendering_structure.show_supported()`; private `_swap_rendering_structure`
-    hook, Family B engine rebind).
+    (`project.rendering_structure` read-only attribute;
+    `project.rendering_structure.type` writable selector;
+    `project.rendering_structure.show_supported()`; private
+    `_swap_rendering_structure` hook, Family B engine rebind).
   - [`selector-families.md`](../adrs/accepted/selector-families.md) —
     `view` is a switchable-category selector (Family B), like `chart` /
     `table`.
@@ -98,11 +99,13 @@ plan-level structural choices confirmed with the author at plan start.
   `threejs` (notebook + standalone HTML), shipping together exactly as
   the `asciichartpy` and `plotly` chart engines do. Qt Quick 3D is
   deferred.
-- **Switchable `rendering_structure` selector** (§2): `project.rendering_structure.type` (`'auto'`
-  default, resolving to `'threejs'` in Jupyter / `'ascii'` in a
-  terminal), CIF `_rendering_structure.type`, following the category-owned selector
-  contract with a private `_swap_rendering_structure` Family B rebind. No `rendering_structure_type`
-  setter, no `show_supported_rendering_structure_types()`.
+- **Switchable `rendering_structure` selector** (§2):
+  `project.rendering_structure.type` (`'auto'` default, resolving to
+  `'threejs'` in Jupyter / `'ascii'` in a terminal), CIF
+  `_rendering_structure.type`, following the category-owned selector
+  contract with a private `_swap_rendering_structure` Family B rebind.
+  No `rendering_structure_type` setter, no
+  `show_supported_rendering_structure_types()`.
 - **`structure()` entry point** (§3):
   `project.display.structure(struct_name=...)` parallel to
   `pattern(expt_name=...)`, with `include=` reusing the pattern
@@ -111,10 +114,11 @@ plan-level structural choices confirmed with the author at plan start.
   mirrors `show_pattern_options()`. Notebook embeds an interactive view
   (IPython HTML repr); a standalone HTML file can be written to a path.
 - **Per-axis fractional range** (§3): six scalar bounds
-  `project.rendering_structure.range_{a,b,c}_{min,max}` (defaults 0 and 1 = full cell,
-  **borders included**), mirroring the six scalar cell parameters;
-  non-integer allowed, validated min < max per axis, persisted; a
-  per-call `range=` tuple on `structure()` overrides for one call.
+  `project.rendering_structure.range_{a,b,c}_{min,max}` (defaults 0 and
+  1 = full cell, **borders included**), mirroring the six scalar cell
+  parameters; non-integer allowed, validated min < max per axis,
+  persisted; a per-call `range=` tuple on `structure()` overrides for
+  one call.
 - **Scene-atom identity rule** (§3): two generated atoms are the same
   scene atom iff same atom-site row **and** fractional coordinates
   coincide within `1e-4` (fractional units); keep one, drop the rest.
@@ -165,11 +169,12 @@ plan-level structural choices confirmed with the author at plan start.
   `html_offline` flag — the same switch that already governs
   Plotly/MathJax.
 - **Visibility precedence** (§8): explicit `include=(...)` tuple wins
-  outright (ignores persisted `_rendering_structure.show_*`); `include='auto'` resolves
-  each feature from data-availability → persisted flag (only
-  `show_labels` off, `show_moments` on-where-data) → built-in default;
-  unsupported options are skipped and announced, never errored; live
-  modebar toggles are runtime-only and never rewrite persisted state.
+  outright (ignores persisted `_rendering_structure.show_*`);
+  `include='auto'` resolves each feature from data-availability →
+  persisted flag (only `show_labels` off, `show_moments` on-where-data)
+  → built-in default; unsupported options are skipped and announced,
+  never errored; live modebar toggles are runtime-only and never rewrite
+  persisted state.
 - **Moments stay gated** (§3, Deferred Work): the scene model carries a
   moment-arrow primitive, but the builder never emits it because the
   structure model has no moment fields today; `show_moments` is inert
@@ -211,20 +216,25 @@ below were verified reachable (HTTP 200).
 - **Exact CIF tag spelling for `style`, `view`, and `geom`** (ADR Open
   Question 1) — **Resolved (final).** Project CIF: `_style.atom_shape`,
   `_style.radius_model`, `_style.color_scheme`,
-  `_style.adp_probability`, and `_rendering_structure.type`, `_rendering_structure.show_labels`,
-  `_rendering_structure.show_moments`, plus the per-axis range as six scalar tags
-  `_rendering_structure.range_a_min` / `_rendering_structure.range_a_max` / `_rendering_structure.range_b_min` /
-  `_rendering_structure.range_b_max` / `_rendering_structure.range_c_min` / `_rendering_structure.range_c_max` (one
-  number each, defaults 0 and 1), mirroring the cell parameters. Structure
-  CIF (per-structure): the **standard
-  cif_core** bond cutoffs `_geom.min_bond_distance_cutoff` (default
-  `0.0`) and `_geom.bond_distance_incr` (default `0.25`), plus the
-  per-type bonding radius `_atom_type.radius_bond` when present (P1.11).
-  `_rendering_structure.type` follows the Display-UX ADR (`_rendering_plot.type` /
-  `_rendering_table.type`); `_style.*` and `_rendering_structure.*` are project-internal
-  app/settings tags; the bond cutoffs use the standard `_geom.*`
-  category `cif_core.dic` defines (`_geom.min_bond_distance_cutoff` dic
-  13084, `_geom.bond_distance_incr` dic 13044), while the computed
+  `_style.adp_probability`, and `_rendering_structure.type`,
+  `_rendering_structure.show_labels`,
+  `_rendering_structure.show_moments`, plus the per-axis range as six
+  scalar tags `_rendering_structure.range_a_min` /
+  `_rendering_structure.range_a_max` /
+  `_rendering_structure.range_b_min` /
+  `_rendering_structure.range_b_max` /
+  `_rendering_structure.range_c_min` /
+  `_rendering_structure.range_c_max` (one number each, defaults 0 and
+  1), mirroring the cell parameters. Structure CIF (per-structure): the
+  **standard cif_core** bond cutoffs `_geom.min_bond_distance_cutoff`
+  (default `0.0`) and `_geom.bond_distance_incr` (default `0.25`), plus
+  the per-type bonding radius `_atom_type.radius_bond` when present
+  (P1.11). `_rendering_structure.type` follows the Display-UX ADR
+  (`_rendering_plot.type` / `_rendering_table.type`); `_style.*` and
+  `_rendering_structure.*` are project-internal app/settings tags; the
+  bond cutoffs use the standard `_geom.*` category `cif_core.dic`
+  defines (`_geom.min_bond_distance_cutoff` dic 13084,
+  `_geom.bond_distance_incr` dic 13044), while the computed
   `_geom_bond.*` / `_geom_angle.*` loops are a separate, deferred
   concern. No further confirmation needed during implementation.
 - **ASCII rendering details** (ADR Open Question 2) — **Resolved (final
@@ -360,15 +370,16 @@ below were verified reachable (HTTP 200).
 **Project wiring + persistence:**
 
 - `src/easydiffraction/project/project.py` (existing — add `view` /
-  `style` read-only properties and the private `_swap_rendering_structure` hook,
-  mirroring `_swap_rendering_plot` at `project.py:238`).
+  `style` read-only properties and the private
+  `_swap_rendering_structure` hook, mirroring `_swap_rendering_plot` at
+  `project.py:238`).
 - `src/easydiffraction/project/project_config.py` (existing — import +
-  instantiate `RenderingStructureFactory` / `StyleFactory` defaults, mirroring the
-  chart/table wiring at `project_config.py:36`).
+  instantiate `RenderingStructureFactory` / `StyleFactory` defaults,
+  mirroring the chart/table wiring at `project_config.py:36`).
 - The CIF read-side hook that restores chart/table (in
   `project_config.py` / the project-config CIF deserializer) — extend to
-  restore `_rendering_structure.*` / `_style.*` (mirrors the chart `from_cif` at
-  `project/categories/rendering_plot/default.py:94`).
+  restore `_rendering_structure.*` / `_style.*` (mirrors the chart
+  `from_cif` at `project/categories/rendering_plot/default.py:94`).
 
 **Display facade:**
 
@@ -416,8 +427,8 @@ P1.16):**
   `pixi run notebook-prepare`).
 - `docs/docs/tutorials/*.ipynb` (regenerated artefacts).
 - `docs/docs/user-guide/` and `docs/docs/api-reference/` (existing — add
-  `project.display.structure()`, `project.rendering_structure`, `project.style`
-  reference + a short user-guide section).
+  `project.display.structure()`, `project.rendering_structure`,
+  `project.style` reference + a short user-guide section).
 
 ## Commit discipline
 
@@ -444,12 +455,13 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     ADR, each with a `default()` classmethod (model on
     `PlotterEngineEnum` at `display/plotting.py:50`):
     - `ViewerEngineEnum`: `ASCII = 'ascii'`, `THREEJS = 'threejs'`, with
-      an **environment-aware `default()`** (`threejs` in Jupyter, `ascii`
-      in a terminal), matching `PlotterEngineEnum` / `TableEngineEnum`.
-      The `view` category adds an `'auto'` selector sentinel resolved
-      through `default()`, so `project.rendering_structure.type` defaults to `auto` and
-      the ADR §8 persisted example is `_rendering_structure.type auto`; see P1.9 and the
-      headless note there.
+      an **environment-aware `default()`** (`threejs` in Jupyter,
+      `ascii` in a terminal), matching `PlotterEngineEnum` /
+      `TableEngineEnum`. The `view` category adds an `'auto'` selector
+      sentinel resolved through `default()`, so
+      `project.rendering_structure.type` defaults to `auto` and the ADR
+      §8 persisted example is `_rendering_structure.type auto`; see P1.9
+      and the headless note there.
     - `AtomShapeEnum`: `BALL = 'ball'`, `ORTEP = 'ortep'` (default
       `ORTEP`).
     - `RadiusModelEnum`: `VDW = 'vdw'`, `COVALENT = 'covalent'`,
@@ -687,9 +699,9 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     (`display/plotting.py:5980`) and `TableRendererFactory` /
     `TableRenderer` (`display/tables.py:142`): a `_registry()` of
     `{engine: {'description', 'class'}}`, `descriptions()`, and the
-    active-engine binding the `_swap_rendering_structure` hook rebinds. Add the
-    `@ViewerFactory.register` decorator to `AsciiStructureRenderer` in
-    this step (the factory now exists).
+    active-engine binding the `_swap_rendering_structure` hook rebinds.
+    Add the `@ViewerFactory.register` decorator to
+    `AsciiStructureRenderer` in this step (the factory now exists).
   - **Registration wiring (AGENTS.md §Architecture).**
     `display/structure/__init__.py` explicitly imports the `renderers`
     package (which imports the concrete renderer classes, P1.6) **and**
@@ -737,51 +749,57 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     `src/easydiffraction/project/categories/rendering_structure/__init__.py`,
     `default.py`, `factory.py`.
   - `View(CategoryItem, SwitchableCategoryBase)` modelled on `Chart`
-    (`project/categories/rendering_plot/default.py`): `_category_code='view'`,
-    `_owner_attr_name='view'`, `_swap_method_name='_swap_rendering_structure'`; a
-    `type` `StringDescriptor` with CIF `_rendering_structure.type` validated against
-    `['auto', *ViewerEngineEnum]` + `ViewerFactory.descriptions()` and
-    **defaulting to `'auto'`** (resolved to a concrete engine through
-    `ViewerEngineEnum.default()`, exactly as `Chart` resolves its
-    `'auto'`), matching P1.1; `from_cif` calling `self._parent._swap_rendering_structure`. Plus persisted
-    view-state descriptors: `show_labels` (`BoolDescriptor`, default off),
-    `show_moments` (`BoolDescriptor`, default on-where-data), and the
-    per-axis range as **six scalar `NumericDescriptor`s**
+    (`project/categories/rendering_plot/default.py`):
+    `_category_code='view'`, `_owner_attr_name='view'`,
+    `_swap_method_name='_swap_rendering_structure'`; a `type`
+    `StringDescriptor` with CIF `_rendering_structure.type` validated
+    against `['auto', *ViewerEngineEnum]` +
+    `ViewerFactory.descriptions()` and **defaulting to `'auto'`**
+    (resolved to a concrete engine through `ViewerEngineEnum.default()`,
+    exactly as `Chart` resolves its `'auto'`), matching P1.1; `from_cif`
+    calling `self._parent._swap_rendering_structure`. Plus persisted
+    view-state descriptors: `show_labels` (`BoolDescriptor`, default
+    off), `show_moments` (`BoolDescriptor`, default on-where-data), and
+    the per-axis range as **six scalar `NumericDescriptor`s**
     `range_a_min` / `range_a_max` / `range_b_min` / `range_b_max` /
-    `range_c_min` / `range_c_max` (CIF `_rendering_structure.range_a_min` … , defaults 0
-    and 1, each axis validated `min < max` in the setter), mirroring the
-    six scalar cell parameters; `structure()`'s `range=` tuple arg
-    overrides them per call. `show_supported()` lists engines.
+    `range_c_min` / `range_c_max` (CIF
+    `_rendering_structure.range_a_min` … , defaults 0 and 1, each axis
+    validated `min < max` in the setter), mirroring the six scalar cell
+    parameters; `structure()`'s `range=` tuple arg overrides them per
+    call. `show_supported()` lists engines.
   - **Headless implication of the `auto` default.** In Jupyter (and
     under nbmake `script-tests`, which run a Jupyter kernel) `auto`
     resolves to `threejs`, so `project.display.structure(...)`
     returns/writes an HTML string and needs **no browser** — it runs
     unattended out of the box. In a bare terminal `auto` resolves to the
     `ascii` engine the ADR §2 names; `threejs` can still be forced via
-    `project.rendering_structure.type = 'threejs'`. The P1.16 tutorial and the Phase 2
-    script-test coverage item therefore exercise **both** paths: the
-    `threejs` HTML emission and an explicit `view.type = 'ascii'`
-    terminal render (see the Phase 2 "Integration / script-test
-    coverage" item).
-  - Register `View` in `project/categories/rendering_structure/__init__.py`.
+    `project.rendering_structure.type = 'threejs'`. The P1.16 tutorial
+    and the Phase 2 script-test coverage item therefore exercise
+    **both** paths: the `threejs` HTML emission and an explicit
+    `view.type = 'ascii'` terminal render (see the Phase 2 "Integration
+    / script-test coverage" item).
+  - Register `View` in
+    `project/categories/rendering_structure/__init__.py`.
   - Commit: `Add switchable view category for renderer selection`.
 
-- [x] **P1.10 — Wire `project.rendering_structure` / `project.style` + CIF
-      persistence**
+- [x] **P1.10 — Wire `project.rendering_structure` / `project.style` +
+      CIF persistence**
   - Files: existing `src/easydiffraction/project/project.py`,
     `src/easydiffraction/project/project_config.py` (+ the
     project-config CIF deserializer hook).
-  - Add read-only `rendering_structure` / `style` properties on `Project` (mirror
-    `rendering_plot` / `rendering_table` at `project.py:315`) and the private `_swap_rendering_structure`
-    hook (mirror `_swap_rendering_plot` at `project.py:238`) that rebinds the
+  - Add read-only `rendering_structure` / `style` properties on
+    `Project` (mirror `rendering_plot` / `rendering_table` at
+    `project.py:315`) and the private `_swap_rendering_structure` hook
+    (mirror `_swap_rendering_plot` at `project.py:238`) that rebinds the
     active `Viewer` engine.
   - Instantiate `RenderingStructureFactory` / `StyleFactory` defaults in
     `project_config.py` (mirror `project_config.py:36`) and extend the
-    CIF read side to restore `_rendering_structure.*` / `_style.*` (mirror the chart
-    `from_cif`).
+    CIF read side to restore `_rendering_structure.*` / `_style.*`
+    (mirror the chart `from_cif`).
   - Round-trip check is deferred to the Phase 2 tests; this step only
     wires the surfaces.
-  - Commit: `Wire project.rendering_structure and project.style with CIF persistence`.
+  - Commit:
+    `Wire project.rendering_structure and project.style with CIF persistence`.
 
 - [x] **P1.11 — Add the per-structure `geom` bond-cutoff category**
   - Files: new
@@ -823,15 +841,15 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
       `structure_feature_availability(structure, style=project.style)`;
       build the scene via
       `build_scene(structure, style=project.style, view_range=<resolved range>, features=<resolved set>)`
-      (per-call `range` overrides the persisted view range for
-      that call); render with the active `project.rendering_structure` engine.
-      **Signature mirrors `pattern()`**: `structure(...) -> None`,
-      displaying directly as a side effect (notebook: `IPython.display`
-      of the engine's HTML; terminal: print the ASCII view); when `path`
-      is given, also write a standalone, self-contained HTML file
-      (Three.js embedded). (`pattern()` is `-> None` and displays
-      directly — verified in `display.py` — so no open signature
-      decision remains.)
+      (per-call `range` overrides the persisted view range for that
+      call); render with the active `project.rendering_structure`
+      engine. **Signature mirrors `pattern()`**:
+      `structure(...) -> None`, displaying directly as a side effect
+      (notebook: `IPython.display` of the engine's HTML; terminal: print
+      the ASCII view); when `path` is given, also write a standalone,
+      self-contained HTML file (Three.js embedded). (`pattern()` is
+      `-> None` and displays directly — verified in `display.py` — so no
+      open signature decision remains.)
     - `show_structure_options(struct_name)`: mirror
       `show_pattern_options()` — list each `include=` option with engine
       - data support and the reason when unavailable, reading the
@@ -946,9 +964,9 @@ reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
     `project.display.structure(...)`, `show_structure_options(...)`);
     regenerate notebooks via `pixi run notebook-prepare` and stage the
     `.py` + regenerated `.ipynb` together.
-  - Add `project.display.structure()` / `project.rendering_structure` / `project.style`
-    and the per-structure `structure.geom` bond cutoffs to the API
-    reference and a short user-guide section.
+  - Add `project.display.structure()` / `project.rendering_structure` /
+    `project.style` and the per-structure `structure.geom` bond cutoffs
+    to the API reference and a short user-guide section.
   - Commit: `Document structure view in tutorials and reference`.
 
 - [x] **P1.17 — Reach Phase 1 review gate**
@@ -1041,16 +1059,17 @@ coverage (configured in P1.13).
       setting's accepted values; `_style.*` CIF round-trips. P1.8.
 - [ ] **`tests/unit/easydiffraction/project/categories/rendering_structure/test_rendering_structure.py`**
       (new) — `type` validates against `['auto', *ViewerEngineEnum]` and
-      defaults to `'auto'`; setting
-      `type` calls `_swap_rendering_structure`; a `range_a_max` below `range_a_min` is
-      rejected (per-axis `min < max`); `_rendering_structure.type` / `_rendering_structure.show_*` /
-      `_rendering_structure.range_a_min` … `_rendering_structure.range_c_max` CIF round-trip;
+      defaults to `'auto'`; setting `type` calls
+      `_swap_rendering_structure`; a `range_a_max` below `range_a_min`
+      is rejected (per-axis `min < max`); `_rendering_structure.type` /
+      `_rendering_structure.show_*` / `_rendering_structure.range_a_min`
+      … `_rendering_structure.range_c_max` CIF round-trip;
       `show_supported()` lists engines. P1.9.
 - [ ] **`tests/unit/easydiffraction/project/test_project.py`** (extend)
-      — `project.rendering_structure` / `project.style` are read-only attributes;
-      switching `project.rendering_structure.type` rebinds the active engine; a saved +
-      reloaded project restores `_rendering_structure.*` / `_style.*` identically.
-      P1.10.
+      — `project.rendering_structure` / `project.style` are read-only
+      attributes; switching `project.rendering_structure.type` rebinds
+      the active engine; a saved + reloaded project restores
+      `_rendering_structure.*` / `_style.*` identically. P1.10.
 - [ ] **`tests/unit/easydiffraction/datablocks/structure/categories/geom/test_geom.py`**
       (new — single parent-level test if the package is only
       `default.py`/`factory.py`) — defaults are
@@ -1069,17 +1088,17 @@ coverage (configured in P1.13).
       3D-only, moments gated, ionic→covalent substitution). P1.12.
 - [ ] **`tests/unit/easydiffraction/display/structure/renderers/test_threejs.py`**
       (new) — the renderer emits an HTML string containing the scene
-      JSON and the modebar controls; the emitted `<script
-      type="importmap">` parses to JSON with a top-level **`imports`**
-      key mapping `three` (regression guard: a bare specifier map with no
-      `imports` wrapper silently fails to resolve and renders blank);
-      **offline** mode embeds the
-      Three.js asset text inline (no CDN URL), online mode links it; the
-      standalone write path produces a self-contained file; the resolved
-      dark/light theme drives the canvas/annotation colours (assert the
-      dark vs light background differs when `is_dark()` is
-      monkeypatched), while element colours stay scheme-driven. Assert
-      on emitted markup, not a live browser. P1.14.
+      JSON and the modebar controls; the emitted
+      `<script     type="importmap">` parses to JSON with a top-level
+      **`imports`** key mapping `three` (regression guard: a bare
+      specifier map with no `imports` wrapper silently fails to resolve
+      and renders blank); **offline** mode embeds the Three.js asset
+      text inline (no CDN URL), online mode links it; the standalone
+      write path produces a self-contained file; the resolved dark/light
+      theme drives the canvas/annotation colours (assert the dark vs
+      light background differs when `is_dark()` is monkeypatched), while
+      element colours stay scheme-driven. Assert on emitted markup, not
+      a live browser. P1.14.
 - [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
       (extend) — `html_offline=True` embeds the Three.js assets next to
       / inside the report; `html_offline=False` links them; the
@@ -1092,9 +1111,9 @@ coverage (configured in P1.13).
       `pixi run script-tests` exercises the tutorial that calls
       `project.display.structure(...)` along **both** engine paths: the
       **`auto` default** (which resolves to `threejs` under nbmake's
-      Jupyter kernel) HTML emission (no browser, runs headless in CI) and
-      an explicit `project.rendering_structure.type = 'ascii'` terminal render.
-      Extend a tutorial if not. P1.16.
+      Jupyter kernel) HTML emission (no browser, runs headless in CI)
+      and an explicit `project.rendering_structure.type = 'ascii'`
+      terminal render. Extend a tutorial if not. P1.16.
 
 Use `pixi run test-structure-check` to confirm the unit-test layout
 mirrors the source tree per AGENTS.md §Testing.
@@ -1145,23 +1164,23 @@ ellipsoids — alongside the existing 1D pattern view.
   `project.display.show_structure_options('lbco')` lists what each
   engine and the current structure can show, with reasons when something
   is unavailable.
-- **Choose the engine and the styling, once.** `project.rendering_structure.type`
-  selects `threejs` or `ascii`; `project.style` picks the depiction
-  (`ortep` thermal ellipsoids — the default — or `ball`-and-stick), a
-  standard radius model (covalent by default, or vdw/ionic/atomic), and
-  a colour scheme (Jmol/CPK, VESTA) and ADP probability level — standard
-  models drawn from a built-in element database, not dozens of
-  per-element rows. The view also follows your notebook's dark or light
-  theme automatically. It all persists to `project.cif`, so a reopened
-  project looks the same.
+- **Choose the engine and the styling, once.**
+  `project.rendering_structure.type` selects `threejs` or `ascii`;
+  `project.style` picks the depiction (`ortep` thermal ellipsoids — the
+  default — or `ball`-and-stick), a standard radius model (covalent by
+  default, or vdw/ionic/atomic), and a colour scheme (Jmol/CPK, VESTA)
+  and ADP probability level — standard models drawn from a built-in
+  element database, not dozens of per-element rows. The view also
+  follows your notebook's dark or light theme automatically. It all
+  persists to `project.cif`, so a reopened project looks the same.
 - **Tune which bonds are drawn, per structure.** `structure.geom` sets
   the standard bond cut-offs (a minimum distance and a tolerance added
   to the atoms' bonding radii) for each structure, saved in that
   structure's own file, so different phases can use different cut-offs.
-- **See a single cell, a margin, or several cells.** `project.rendering_structure` sets
-  a per-axis fractional range (default: the
-  full cell with border atoms drawn); widen it for a margin or multiple
-  cells.
+- **See a single cell, a margin, or several cells.**
+  `project.rendering_structure` sets a per-axis fractional range
+  (default: the full cell with border atoms drawn); widen it for a
+  margin or multiple cells.
 - **Works offline.** The notebook and standalone-HTML views embed a
   pinned Three.js so they render with no network, and a structure figure
   can be embedded in the HTML report under the existing
diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index c515257c1..b4c2e1c39 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -1,125 +1,139 @@
 # Plan: Uniform value-selector discovery + structure-view settings split
 
-Follows [`AGENTS.md`](../../../AGENTS.md). It applies the standard two-phase
-workflow, with one deliberate exception — the implementation branch (see
-**Branch & PR** below). The slug `structure-view-settings` is
-retained for continuity (it began as the `project.style` consolidation), but the
-scope has broadened: Part A introduces a project-wide selector-discovery
-convention, and Part B reorganises the structure-view settings on top of it.
+Follows [`AGENTS.md`](../../../AGENTS.md). It applies the standard
+two-phase workflow, with one deliberate exception — the implementation
+branch (see **Branch & PR** below). The slug `structure-view-settings`
+is retained for continuity (it began as the `project.style`
+consolidation), but the scope has broadened: Part A introduces a
+project-wide selector-discovery convention, and Part B reorganises the
+structure-view settings on top of it.
 
 **Branch & PR (deliberate exception).** §Planning asks for a flat-slug
-`structure-view-settings` branch off `develop`. This plan deliberately deviates:
-the work continues on the in-flight `crysview-structure-visualization` branch
-because it builds directly on the structure-view rendering commits already there
-(not yet on `develop`) and ships as part of the same crysview feature delivery.
-The PR still targets `develop`, not `master`. If the convention work is later
-split from the visualization PR, a dedicated `structure-view-settings` branch off
-`develop` is the fallback.
+`structure-view-settings` branch off `develop`. This plan deliberately
+deviates: the work continues on the in-flight
+`crysview-structure-visualization` branch because it builds directly on
+the structure-view rendering commits already there (not yet on
+`develop`) and ships as part of the same crysview feature delivery. The
+PR still targets `develop`, not `master`. If the convention work is
+later split from the visualization PR, a dedicated
+`structure-view-settings` branch off `develop` is the fallback.
 
 ## ADR
 
 This plan now needs ADR work (it was previously "no ADR required"):
 
-- **New ADR — `value-selector-discovery`** (draft via `/draft-adr` before
-  Phase 1, or accept alongside this plan). Recognises a **fourth** selector
-  shape beyond the three category-level families in
+- **New ADR — `value-selector-discovery`** (draft via `/draft-adr`
+  before Phase 1, or accept alongside this plan). Recognises a
+  **fourth** selector shape beyond the three category-level families in
   [`selector-families.md`](../adrs/accepted/selector-families.md):
   - **Category-level selectors** — the backend, switchable-category, and
-    active-sibling families. Each *is* a category and owns `<category>.type` +
-    category-level `<category>.show_supported()` per
+    active-sibling families. Each _is_ a category and owns
+    `<category>.type` + category-level `<category>.show_supported()` per
     [`switchable-category-owned-selectors.md`](../adrs/accepted/switchable-category-owned-selectors.md).
     **Unchanged by this plan.**
-  - **Value selectors** — enumerated descriptor *fields* over a project-owned
-    static `(str, Enum)` (no class swap, no `_swap_<name>` hook). They gain a
-    descriptor-level `show_supported()` reusing the **same** `render_table` and
-    `*`-marks-current convention. This is the new half.
+  - **Value selectors** — enumerated descriptor _fields_ over a
+    project-owned static `(str, Enum)` (no class swap, no `_swap_<name>`
+    hook). They gain a descriptor-level `show_supported()` reusing the
+    **same** `render_table` and `*`-marks-current convention. This is
+    the new half.
 - **Update — crysview ADR**
   ([`crysview-structure-visualization.md`](../adrs/suggestions/crysview-structure-visualization.md)):
   the structure-view surface becomes three categories; `_style.*` →
   `_structure_style.*`; `show_labels`/`show_moments`/`range_*` move to
   `_structure_view.*`; `_rendering_structure.*` reduces to `type`;
-  `atom_view`/`color_scheme` become value selectors with `show_supported()`.
+  `atom_view`/`color_scheme` become value selectors with
+  `show_supported()`.
 
 ## Motivation
 
-Two long-standing inconsistencies, fixed together because Part B depends on
-Part A:
+Two long-standing inconsistencies, fixed together because Part B depends
+on Part A:
 
 1. **Selector discovery is half-built.** Switchable categories expose
    `show_supported()` (e.g. `rendering_plot.show_supported()`), but the
-   project-owned enum-backed *value* selectors (`experiment.experiment_type`
-   axes, `verbosity`, the structure `atom_view`/`color_scheme`, …) have **no**
-   uniform way to list their accepted values. Scientists must read source or
-   trigger a validation error to learn the options. (Fields with dynamic or
-   external membership — `atom_sites.type_symbol`, `space_group.name_h_m`, … —
-   are *not* value selectors and are out of scope; see the ADR.)
-2. **Structure-view settings are split awkwardly.** `project.rendering_structure`
-   carries engine + content + region; `project.style` (generic `_style.*`)
-   carries appearance — but `rendering_plot`/`rendering_table` are pure engine
-   selectors. The structure view should match that layering and isolate the
-   appearance settings that will keep growing (bonds, polyhedra, lighting,
-   moment scale).
+   project-owned enum-backed _value_ selectors
+   (`experiment.experiment_type` axes, `verbosity`, the structure
+   `atom_view`/`color_scheme`, …) have **no** uniform way to list their
+   accepted values. Scientists must read source or trigger a validation
+   error to learn the options. (Fields with dynamic or external
+   membership — `atom_sites.type_symbol`, `space_group.name_h_m`, … —
+   are _not_ value selectors and are out of scope; see the ADR.)
+2. **Structure-view settings are split awkwardly.**
+   `project.rendering_structure` carries engine + content + region;
+   `project.style` (generic `_style.*`) carries appearance — but
+   `rendering_plot`/`rendering_table` are pure engine selectors. The
+   structure view should match that layering and isolate the appearance
+   settings that will keep growing (bonds, polyhedra, lighting, moment
+   scale).
 
 ## Decisions
 
-- **`EnumDescriptor` (Part A).** A new `core/variable.py` descriptor bound to a
-  `(str, Enum)`. It derives `allowed` (the `MembershipValidator`) and the
-  default (`Enum.default()`) from the enum, stores the enum class, and exposes
-  `show_supported()` rendering `render_table(['', 'Value', 'Description'])` with
-  `*` on the current value and descriptions from `Enum.description`. Replaces the
-  manual `StringDescriptor(... MembershipValidator(allowed=[m.value for m in E]))`
+- **`EnumDescriptor` (Part A).** A new `core/variable.py` descriptor
+  bound to a `(str, Enum)`. It derives `allowed` (the
+  `MembershipValidator`) and the default (`Enum.default()`) from the
+  enum, stores the enum class, and exposes `show_supported()` rendering
+  `render_table(['', 'Value', 'Description'])` with `*` on the current
+  value and descriptions from `Enum.description`. Replaces the manual
+  `StringDescriptor(... MembershipValidator(allowed=[m.value for m in E]))`
   pattern for value selectors.
-- **Enums gain `.default()` and `.description` (Part A).** Every enum behind a
-  value selector must expose both; add them where missing. Wording is concise,
-  scientist-facing.
+- **Enums gain `.default()` and `.description` (Part A).** Every enum
+  behind a value selector must expose both; add them where missing.
+  Wording is concise, scientist-facing.
 - **Scope is project-owned static enum sets only.** A field migrates to
   `EnumDescriptor` only when its allowed set is a project-owned, static
-  `(str, Enum)` closed set (`atom_view`, `color_scheme`, the `experiment_type`
-  axes, `verbosity`). Two buckets are out of scope and unchanged: (a) category-level
-  `.type` selectors — the backend, switchable-category, and active-sibling
-  families — keep their category-level `show_supported()` per the
-  selector-families and switchable ADRs; (b) **dynamic / external /
-  context-dependent** membership validators —
-  `atom_sites.type_symbol`, `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
+  `(str, Enum)` closed set (`atom_view`, `color_scheme`, the
+  `experiment_type` axes, `verbosity`). Two buckets are out of scope and
+  unchanged: (a) category-level `.type` selectors — the backend,
+  switchable-category, and active-sibling families — keep their
+  category-level `show_supported()` per the selector-families and
+  switchable ADRs; (b) **dynamic / external / context-dependent**
+  membership validators — `atom_sites.type_symbol`,
+  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
   `space_group.it_coordinate_system_code` — keep their current
-  `MembershipValidator` (a dynamic-choice discovery surface is deferred per the
-  ADR). The P1.2 audit sorts every field into one of these three buckets.
-- **Numerics stay plain.** `adp_probability`, `atom_scale`, the `range_*`
-  scalars, and similar bounded numbers remain `NumericDescriptor`s; their limits
-  live in the docstring + validation error, not in a `show_supported()` table
-  (nothing to enumerate). This resolves the earlier "list all vs enumerated
-  only" question: selectors list, scalars document.
+  `MembershipValidator` (a dynamic-choice discovery surface is deferred
+  per the ADR). The P1.2 audit sorts every field into one of these three
+  buckets.
+- **Numerics stay plain.** `adp_probability`, `atom_scale`, the
+  `range_*` scalars, and similar bounded numbers remain
+  `NumericDescriptor`s; their limits live in the docstring + validation
+  error, not in a `show_supported()` table (nothing to enumerate). This
+  resolves the earlier "list all vs enumerated only" question: selectors
+  list, scalars document.
 - **Three flat sibling categories (Part B).**
-  - `rendering_structure` — engine only: `type` (+ the live `viewer` facade),
-    `show_supported()` already lists engines. CIF: `_rendering_structure.type`.
-  - `structure_view` — durable content/region: `show_labels`, `show_moments`,
-    and six flat `range_{a,b,c}_{min,max}` scalars. CIF: `_structure_view.*`.
+  - `rendering_structure` — engine only: `type` (+ the live `viewer`
+    facade), `show_supported()` already lists engines. CIF:
+    `_rendering_structure.type`.
+  - `structure_view` — durable content/region: `show_labels`,
+    `show_moments`, and six flat `range_{a,b,c}_{min,max}` scalars. CIF:
+    `_structure_view.*`.
   - `structure_style` — durable appearance: `atom_view`, `color_scheme`
     (`EnumDescriptor`s), `adp_probability`, `atom_scale`. CIF:
     `_structure_style.*`.
-- **Range stays six flat scalars.** API is `range_a_min … range_c_max` (six
-  setters), 1:1 with the six CIF tags, mirroring the six `_cell.*` parameters.
-  Keep the internal `view_range()` helper that assembles the
-  `((a_min,a_max),(b_min,b_max),(c_min,c_max))` tuple, and the per-call `range=`
-  override on `display.structure()` (per the crysview ADR). No tuple-valued
-  public setter.
-- **Per-descriptor discovery only.** `show_supported()` lives on the value
-  selector itself (`structure_style.color_scheme.show_supported()`), never on the
-  bundle category. Switchable categories keep their category-level
-  `show_supported()` because the category *is* a single selector; a multi-setting
-  bundle has no single "supported values", so a method there would be ambiguous
-  and redundant. An `experiment_type` overview (its four axes shown together) may
-  be added later as a clearly-named convenience — deferred, not part of this
-  change.
-- **No nesting, no deeper tree.** `color_scheme.show_supported()` is a method on
-  the descriptor the getter already returns — not a sub-category. The category
-  tree depth is unchanged.
-- **CIF renames (beta → no shim).** `_style.*` is dropped; `_structure_view.*`
-  and `_structure_style.*` are added; `_rendering_structure.*` reduces to
-  `type`. No backward-compatible reader.
+- **Range stays six flat scalars.** API is `range_a_min … range_c_max`
+  (six setters), 1:1 with the six CIF tags, mirroring the six `_cell.*`
+  parameters. Keep the internal `view_range()` helper that assembles the
+  `((a_min,a_max),(b_min,b_max),(c_min,c_max))` tuple, and the per-call
+  `range=` override on `display.structure()` (per the crysview ADR). No
+  tuple-valued public setter.
+- **Per-descriptor discovery only.** `show_supported()` lives on the
+  value selector itself
+  (`structure_style.color_scheme.show_supported()`), never on the bundle
+  category. Switchable categories keep their category-level
+  `show_supported()` because the category _is_ a single selector; a
+  multi-setting bundle has no single "supported values", so a method
+  there would be ambiguous and redundant. An `experiment_type` overview
+  (its four axes shown together) may be added later as a clearly-named
+  convenience — deferred, not part of this change.
+- **No nesting, no deeper tree.** `color_scheme.show_supported()` is a
+  method on the descriptor the getter already returns — not a
+  sub-category. The category tree depth is unchanged.
+- **CIF renames (beta → no shim).** `_style.*` is dropped;
+  `_structure_view.*` and `_structure_style.*` are added;
+  `_rendering_structure.*` reduces to `type`. No backward-compatible
+  reader.
 - **Defaults preserved.** Keep current defaults during the move
-  (`adp_probability`, `atom_scale`, the show flags, range bounds, every migrated
-  selector's default).
+  (`adp_probability`, `atom_scale`, the show flags, range bounds, every
+  migrated selector's default).
 
 ## Open questions
 
@@ -127,11 +141,12 @@ None outstanding:
 
 - **Naming — resolved.** `structure_view` / `structure_style` (CIF
   `_structure_view.*` / `_structure_style.*`), confirmed.
-- **Discovery surface — resolved.** Per-descriptor `show_supported()` only; no
-  category-level method on the non-switchable bundle categories (see Decisions).
-- **Selector classification** is handled by the P1.2 audit (three buckets:
-  value selector / category-level selector / dynamic-external) and recorded in
-  this plan during implementation.
+- **Discovery surface — resolved.** Per-descriptor `show_supported()`
+  only; no category-level method on the non-switchable bundle categories
+  (see Decisions).
+- **Selector classification** is handled by the P1.2 audit (three
+  buckets: value selector / category-level selector / dynamic-external)
+  and recorded in this plan during implementation.
 
 ## Concrete files likely to change
 
@@ -139,35 +154,42 @@ None outstanding:
 
 - `src/easydiffraction/core/variable.py` — add `EnumDescriptor`; reuse
   `render_table` from `utils/utils.py`.
-- `src/easydiffraction/core/validation.py` — only if a small helper eases
-  deriving `allowed` from an enum.
+- `src/easydiffraction/core/validation.py` — only if a small helper
+  eases deriving `allowed` from an enum.
 - Value-selector enums (add `.default()`/`.description` where missing):
   `display/structure/enums.py` (`AtomViewEnum`, `ColorSchemeEnum`),
-  `datablocks/experiment/categories/experiment_type/*` (sample_form, beam_mode,
-  radiation_probe, scattering_type), `project/categories/verbosity/*`, and any
-  others the audit confirms as project-owned closed sets. **Excluded** (dynamic
-  or external membership, unchanged): `atom_sites.type_symbol`,
+  `datablocks/experiment/categories/experiment_type/*` (sample_form,
+  beam_mode, radiation_probe, scattering_type),
+  `project/categories/verbosity/*`, and any others the audit confirms as
+  project-owned closed sets. **Excluded** (dynamic or external
+  membership, unchanged): `atom_sites.type_symbol`,
   `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
   `space_group.it_coordinate_system_code`.
-- The category files that declare those value selectors → switch the field
-  declarations to `EnumDescriptor` (one commit per area; see Phase 1).
+- The category files that declare those value selectors → switch the
+  field declarations to `EnumDescriptor` (one commit per area; see Phase
+  1).
 
 **Part B — structure-view three-way split**
 
-- `src/easydiffraction/project/categories/rendering_structure/default.py` —
-  remove `show_labels`/`show_moments`/`range_*`; keep `type` + `viewer`.
-- `src/easydiffraction/project/categories/structure_view/` — **new** package
-  (`__init__.py`, `default.py`, `factory.py`): the moved content/region settings
-  + `view_range()`.
-- `src/easydiffraction/project/categories/structure_style/` — **renamed** from
-  `style/`: `atom_view`/`color_scheme` as `EnumDescriptor`, `adp_probability`/
-  `atom_scale` as `NumericDescriptor`; CIF `_structure_style.*`.
+- `src/easydiffraction/project/categories/rendering_structure/default.py`
+  — remove `show_labels`/`show_moments`/`range_*`; keep `type` +
+  `viewer`.
+- `src/easydiffraction/project/categories/structure_view/` — **new**
+  package (`__init__.py`, `default.py`, `factory.py`): the moved
+  content/region settings
+  - `view_range()`.
+- `src/easydiffraction/project/categories/structure_style/` —
+  **renamed** from `style/`: `atom_view`/`color_scheme` as
+  `EnumDescriptor`, `adp_probability`/ `atom_scale` as
+  `NumericDescriptor`; CIF `_structure_style.*`.
 - `src/easydiffraction/project/categories/style/` — **removed**.
 - `src/easydiffraction/project/project.py`,
   `src/easydiffraction/project/project_config.py` — add
-  `project.structure_view` / `project.structure_style`; drop `project.style`.
-- `src/easydiffraction/io/cif/serialize.py` — swap the `style` block for the
-  `structure_view` + `structure_style` blocks; trim `rendering_structure`.
+  `project.structure_view` / `project.structure_style`; drop
+  `project.style`.
+- `src/easydiffraction/io/cif/serialize.py` — swap the `style` block for
+  the `structure_view` + `structure_style` blocks; trim
+  `rendering_structure`.
 - `src/easydiffraction/display/structure/builder.py`,
   `src/easydiffraction/project/display.py`,
   `src/easydiffraction/report/html_renderer.py`,
@@ -177,93 +199,104 @@ None outstanding:
 
 **Docs / tutorials / tests**
 
-- `docs/docs/user-guide/analysis-workflow/model.md` (the `project.style.*`
-  examples); the crysview ADR; the new `value-selector-discovery` ADR.
-- `docs/docs/tutorials/ed-3.py`, `ed-14.py`, `ed-17.py` (any `project.style.*`),
-  then `pixi run notebook-prepare`.
-- Tests mirroring every changed module: `EnumDescriptor` + `show_supported`,
-  each migrated category, new `structure_view`/`structure_style`, removed
-  `style`; repoint `tests/.../project/test_project_config.py`,
-  `test_project_load.py`, `display/plotters/test_plotly.py`. Verify the mirror
-  with `pixi run test-structure-check`.
+- `docs/docs/user-guide/analysis-workflow/model.md` (the
+  `project.style.*` examples); the crysview ADR; the new
+  `value-selector-discovery` ADR.
+- `docs/docs/tutorials/ed-3.py`, `ed-14.py`, `ed-17.py` (any
+  `project.style.*`), then `pixi run notebook-prepare`.
+- Tests mirroring every changed module: `EnumDescriptor` +
+  `show_supported`, each migrated category, new
+  `structure_view`/`structure_style`, removed `style`; repoint
+  `tests/.../project/test_project_config.py`, `test_project_load.py`,
+  `display/plotters/test_plotly.py`. Verify the mirror with
+  `pixi run test-structure-check`.
 
 ## Implementation steps (Phase 1)
 
-Each step is one atomic commit (stage explicit paths; commit before the next)
-per §Commits. When an AI agent follows this plan, every completed Phase 1 step
-is staged and committed locally before moving on.
+Each step is one atomic commit (stage explicit paths; commit before the
+next) per §Commits. When an AI agent follows this plan, every completed
+Phase 1 step is staged and committed locally before moving on.
 
 **Part A — value-selector discovery convention**
 
-- [x] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py` with the
-  `show_supported()` table (reuse `render_table`). Commit:
-  `Add EnumDescriptor with show_supported listing`.
-- [x] **P1.2 — Classify selectors.** Audit every `MembershipValidator` usage;
-  record a three-bucket table in this plan (value selector / category-level
-  selector / dynamic-external), doc-only. See *Selector classification* below.
-  Commit: `Classify enumerated selectors for discovery`.
-- [x] **P1.3 — Enum metadata.** Add `.default()`/`.description()` to the in-scope
-  value-selector enums that lack them (no field migration yet). Commit:
-  `Add default and description to value-selector enums`. *(Only `VerbosityEnum`,
-  `FitResultKindEnum`, `FitCorrelationSourceEnum` lacked `description()`; the
-  rest already had both.)*
-- [x] **P1.4 — Migrate experiment_type axes.** `sample_form`, `beam_mode`,
-  `radiation_probe`, `scattering_type` → `EnumDescriptor`. Commit:
-  `Use EnumDescriptor for experiment_type axes`.
+- [x] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py`
+      with the `show_supported()` table (reuse `render_table`). Commit:
+      `Add EnumDescriptor with show_supported listing`.
+- [x] **P1.2 — Classify selectors.** Audit every `MembershipValidator`
+      usage; record a three-bucket table in this plan (value selector /
+      category-level selector / dynamic-external), doc-only. See
+      _Selector classification_ below. Commit:
+      `Classify enumerated selectors for discovery`.
+- [x] **P1.3 — Enum metadata.** Add `.default()`/`.description()` to the
+      in-scope value-selector enums that lack them (no field migration
+      yet). Commit:
+      `Add default and description to value-selector enums`. _(Only
+      `VerbosityEnum`, `FitResultKindEnum`, `FitCorrelationSourceEnum`
+      lacked `description()`; the rest already had both.)_
+- [x] **P1.4 — Migrate experiment_type axes.** `sample_form`,
+      `beam_mode`, `radiation_probe`, `scattering_type` →
+      `EnumDescriptor`. Commit:
+      `Use EnumDescriptor for experiment_type axes`.
 - [x] **P1.5 — Migrate `atom_sites.adp_type`.** The P1.2 audit confirms
-  `adp_type` (`AdpTypeEnum`) is the one in-scope structure-data value selector →
-  `EnumDescriptor` (preserve its dual CIF names `_atom_site.ADP_type` /
-  `_atom_site.adp_type` and the category's `adp_type` setter). The
-  dynamic/external validators (`atom_sites.type_symbol`,
-  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
-  `space_group.it_coordinate_system_code`) are **out of scope** and keep their
-  current `MembershipValidator`. Commit:
-  `Use EnumDescriptor for atom_sites adp_type`.
+      `adp_type` (`AdpTypeEnum`) is the one in-scope structure-data
+      value selector → `EnumDescriptor` (preserve its dual CIF names
+      `_atom_site.ADP_type` / `_atom_site.adp_type` and the category's
+      `adp_type` setter). The dynamic/external validators
+      (`atom_sites.type_symbol`, `atom_sites.wyckoff_letter`,
+      `space_group.name_h_m`, `space_group.it_coordinate_system_code`)
+      are **out of scope** and keep their current `MembershipValidator`.
+      Commit: `Use EnumDescriptor for atom_sites adp_type`.
 - [x] **P1.6 — Migrate remaining value selectors.** Per the P1.2 audit:
-  `verbosity.fit` (`VerbosityEnum`), `fit_result.result_kind`
-  (`FitResultKindEnum`), `fit_parameter_correlations.source_kind`
-  (`FitCorrelationSourceEnum`), and `extinction.model` (`ExtinctionModelEnum`)
-  → `EnumDescriptor`, one commit per area. Commit (per area):
-  `Use EnumDescriptor for <area> selector`.
-
-**Part B — structure-view three-way split.** Ordered additive-first: the new
-categories and their consumers land before the old surfaces are removed, so
-**every commit imports and renders** — no intermediate revision loses a live
-API. A short bridge period where old and new surfaces coexist is intentional.
+      `verbosity.fit` (`VerbosityEnum`), `fit_result.result_kind`
+      (`FitResultKindEnum`), `fit_parameter_correlations.source_kind`
+      (`FitCorrelationSourceEnum`), and `extinction.model`
+      (`ExtinctionModelEnum`) → `EnumDescriptor`, one commit per area.
+      Commit (per area): `Use EnumDescriptor for <area> selector`.
+
+**Part B — structure-view three-way split.** Ordered additive-first: the
+new categories and their consumers land before the old surfaces are
+removed, so **every commit imports and renders** — no intermediate
+revision loses a live API. A short bridge period where old and new
+surfaces coexist is intentional.
 
 - [x] **P1.7 — Add `structure_view` (additive).** New category +
-  `project.structure_view` + a new `_structure_view.*` CIF block carrying
-  `show_labels`, `show_moments`, six `range_*` scalars, and `view_range()`.
-  `rendering_structure` keeps its copies for now. Commit:
-  `Add structure_view content/region category`.
+      `project.structure_view` + a new `_structure_view.*` CIF block
+      carrying `show_labels`, `show_moments`, six `range_*` scalars, and
+      `view_range()`. `rendering_structure` keeps its copies for now.
+      Commit: `Add structure_view content/region category`.
 - [x] **P1.8 — Add `structure_style` (additive).** New category +
-  `project.structure_style` + a new `_structure_style.*` CIF block;
-  `atom_view`/`color_scheme` as `EnumDescriptor`, `adp_probability`/`atom_scale`
-  as `NumericDescriptor`. The old `style` category / `project.style` stay for
-  now. Commit: `Add structure_style appearance category`.
-- [x] **P1.9 — Repoint consumers to the new categories.** Builder, display
-  facade, and report renderers read appearance from `project.structure_style`
-  and the window/flags from `project.structure_view` (`builder.py`,
-  `display.py`, `html_renderer.py`, `tex_renderer.py`). After this commit
-  nothing reads `project.style` or `rendering_structure.view_range()`, but both
-  still exist — so the revision builds and renders. Commit:
-  `Read structure view and style from new categories`.
-- [x] **P1.10 — Remove the old surfaces.** Now that no consumer uses them:
-  remove `show_labels`/`show_moments`/`range_*`/`view_range()` from
-  `rendering_structure` (leaving engine `type` + `viewer`); remove the `style`
-  package, `project.style`, and the bespoke `Style.show_supported()`; drop the
-  `_style.*` block and the moved `_rendering_structure.*` tags from CIF
-  serialise. Commit: `Remove the old style and rendering_structure surfaces`.
-- [x] **P1.11 — Docs, ADRs, tutorials.** `model.md` (commit `e24a42571`),
-  crysview ADR §8 surface note + final CIF tags (commit `44abff413`),
-  `value-selector-discovery` ADR already current. Tutorials `ed-3/14/17.py`
-  migrated to `project.structure_style.*` (per-descriptor `show_supported()`)
-  and notebooks regenerated via `pixi run notebook-prepare`, committed in
-  `6fb2df3c7` (user approved committing their playground edits alongside).
-- [x] **P1.12 — Phase 1 review gate.** No-code step: mark complete and commit
-  the checklist update alone. (Reopened once by `_impl-review-1` [P1]; re-gated
-  after the tutorial migration landed in `6fb2df3c7`.) Commit:
-  `Reach Phase 1 review gate`.
+      `project.structure_style` + a new `_structure_style.*` CIF block;
+      `atom_view`/`color_scheme` as `EnumDescriptor`,
+      `adp_probability`/`atom_scale` as `NumericDescriptor`. The old
+      `style` category / `project.style` stay for now. Commit:
+      `Add structure_style appearance category`.
+- [x] **P1.9 — Repoint consumers to the new categories.** Builder,
+      display facade, and report renderers read appearance from
+      `project.structure_style` and the window/flags from
+      `project.structure_view` (`builder.py`, `display.py`,
+      `html_renderer.py`, `tex_renderer.py`). After this commit nothing
+      reads `project.style` or `rendering_structure.view_range()`, but
+      both still exist — so the revision builds and renders. Commit:
+      `Read structure view and style from new categories`.
+- [x] **P1.10 — Remove the old surfaces.** Now that no consumer uses
+      them: remove `show_labels`/`show_moments`/`range_*`/`view_range()`
+      from `rendering_structure` (leaving engine `type` + `viewer`);
+      remove the `style` package, `project.style`, and the bespoke
+      `Style.show_supported()`; drop the `_style.*` block and the moved
+      `_rendering_structure.*` tags from CIF serialise. Commit:
+      `Remove the old style and rendering_structure surfaces`.
+- [x] **P1.11 — Docs, ADRs, tutorials.** `model.md` (commit
+      `e24a42571`), crysview ADR §8 surface note + final CIF tags
+      (commit `44abff413`), `value-selector-discovery` ADR already
+      current. Tutorials `ed-3/14/17.py` migrated to
+      `project.structure_style.*` (per-descriptor `show_supported()`)
+      and notebooks regenerated via `pixi run notebook-prepare`,
+      committed in `6fb2df3c7` (user approved committing their
+      playground edits alongside).
+- [x] **P1.12 — Phase 1 review gate.** No-code step: mark complete and
+      commit the checklist update alone. (Reopened once by
+      `_impl-review-1` [P1]; re-gated after the tutorial migration
+      landed in `6fb2df3c7`.) Commit: `Reach Phase 1 review gate`.
 
 ### Selector classification (P1.2 audit)
 
@@ -272,54 +305,60 @@ Every `MembershipValidator` site, sorted into the three buckets from the
 
 **Migrate to `EnumDescriptor` (project-owned static `(str, Enum)`):**
 
-| Field | Enum | Step | Note |
-| --- | --- | --- | --- |
-| `experiment_type.sample_form` | `SampleFormEnum` | P1.4 | has `display_handler` |
-| `experiment_type.beam_mode` | `BeamModeEnum` | P1.4 | has `display_handler` |
-| `experiment_type.radiation_probe` | `RadiationProbeEnum` | P1.4 | has `display_handler` |
-| `experiment_type.scattering_type` | `ScatteringTypeEnum` | P1.4 | has `display_handler` |
-| `atom_sites.adp_type` | `AdpTypeEnum` | P1.5 | dual CIF names; category setter |
-| `verbosity.fit` | `VerbosityEnum` | P1.6 | |
-| `fit_result.result_kind` | `FitResultKindEnum` | P1.6 | |
-| `fit_parameter_correlations.source_kind` | `FitCorrelationSourceEnum` | P1.6 | |
-| `extinction.model` | `ExtinctionModelEnum` | P1.6 | |
-| `style.atom_view` | `AtomViewEnum` | P1.8 | already has metadata |
-| `style.color_scheme` | `ColorSchemeEnum` | P1.8 | already has metadata |
-
-**Category-level `.type` selectors — unchanged** (backend / switchable-category
-/ active-sibling families): `rendering_plot`, `rendering_table`,
-`rendering_structure`, `minimizer`, `background`, `peak`, `calculator`,
-`extinction`, `fitting_mode`.
+| Field                                    | Enum                       | Step | Note                            |
+| ---------------------------------------- | -------------------------- | ---- | ------------------------------- |
+| `experiment_type.sample_form`            | `SampleFormEnum`           | P1.4 | has `display_handler`           |
+| `experiment_type.beam_mode`              | `BeamModeEnum`             | P1.4 | has `display_handler`           |
+| `experiment_type.radiation_probe`        | `RadiationProbeEnum`       | P1.4 | has `display_handler`           |
+| `experiment_type.scattering_type`        | `ScatteringTypeEnum`       | P1.4 | has `display_handler`           |
+| `atom_sites.adp_type`                    | `AdpTypeEnum`              | P1.5 | dual CIF names; category setter |
+| `verbosity.fit`                          | `VerbosityEnum`            | P1.6 |                                 |
+| `fit_result.result_kind`                 | `FitResultKindEnum`        | P1.6 |                                 |
+| `fit_parameter_correlations.source_kind` | `FitCorrelationSourceEnum` | P1.6 |                                 |
+| `extinction.model`                       | `ExtinctionModelEnum`      | P1.6 |                                 |
+| `style.atom_view`                        | `AtomViewEnum`             | P1.8 | already has metadata            |
+| `style.color_scheme`                     | `ColorSchemeEnum`          | P1.8 | already has metadata            |
+
+**Category-level `.type` selectors — unchanged** (backend /
+switchable-category / active-sibling families): `rendering_plot`,
+`rendering_table`, `rendering_structure`, `minimizer`, `background`,
+`peak`, `calculator`, `extinction`, `fitting_mode`.
 
 **Dynamic / external / context-dependent — unchanged:**
 `atom_sites.type_symbol` (isotope database), `atom_sites.wyckoff_letter`
 (space-group dependent), `space_group.name_h_m` /
-`space_group.it_coordinate_system_code` (callable, H-M-derived), minimizer
-`initialization_method` (per-class enum **subset**, not the full set).
+`space_group.it_coordinate_system_code` (callable, H-M-derived),
+minimizer `initialization_method` (per-class enum **subset**, not the
+full set).
 
-**Bucket 4 — closed but not `(str, Enum)`, out of scope** (candidates for a
-future enum-ification per `enum-backed-closed-values`, tracked separately):
-`data.calc_status` (`['incl', 'excl']`), `emcee.proposal_moves` (raw tuple).
+**Bucket 4 — closed but not `(str, Enum)`, out of scope** (candidates
+for a future enum-ification per `enum-backed-closed-values`, tracked
+separately): `data.calc_status` (`['incl', 'excl']`),
+`emcee.proposal_moves` (raw tuple).
 
 ## Phase 2 — Verification
 
-This Phase 2 also discharges the crysview feature's never-written unit tests
-(the [`crysview-structure-visualization`](crysview-structure-visualization.md)
-plan's Phase 2 was never executed — `display/structure/` has no unit tests),
-written **once** against the final post-split API:
-
-- **This plan's surfaces:** `EnumDescriptor` + per-selector `show_supported()`;
-  each migrated value selector; the new `structure_view` / `structure_style`
-  categories; removal of `style`; the slimmed `rendering_structure`.
-- **Crysview surfaces still untested:** `display/structure/` — `test_enums.py`,
-  `test_scene.py`, `test_builder.py`, `renderers/test_ascii.py`,
-  `renderers/test_raster.py`, `renderers/test_threejs.py`, `test_viewing.py`;
-  the crystallography geometry helpers; the element-radii asset;
+This Phase 2 also discharges the crysview feature's never-written unit
+tests (the
+[`crysview-structure-visualization`](crysview-structure-visualization.md)
+plan's Phase 2 was never executed — `display/structure/` has no unit
+tests), written **once** against the final post-split API:
+
+- **This plan's surfaces:** `EnumDescriptor` + per-selector
+  `show_supported()`; each migrated value selector; the new
+  `structure_view` / `structure_style` categories; removal of `style`;
+  the slimmed `rendering_structure`.
+- **Crysview surfaces still untested:** `display/structure/` —
+  `test_enums.py`, `test_scene.py`, `test_builder.py`,
+  `renderers/test_ascii.py`, `renderers/test_raster.py`,
+  `renderers/test_threejs.py`, `test_viewing.py`; the crystallography
+  geometry helpers; the element-radii asset;
   `report/test_html_renderer.py` (structure figure); and the structure
   surfaces of `project/test_display.py`.
 
-Mirror the source tree per §Testing (verify with `pixi run test-structure-check`),
-then run, capturing logs with the zsh-safe pattern:
+Mirror the source tree per §Testing (verify with
+`pixi run test-structure-check`), then run, capturing logs with the
+zsh-safe pattern:
 
 ```sh
 pixi run fix
@@ -332,14 +371,16 @@ pixi run script-tests > /tmp/easydiffraction-script.log 2>&1; script_tests_exit_
 
 ## Suggested Pull Request
 
-**Title:** Make every option list discoverable, and tidy structure-view settings
-
-**Description:** Any setting that takes one of a fixed list of values — the
-experiment type, atom depiction, colour scheme, verbosity, and more — can now
-show its options the same way, with the active one marked,
-via `show_supported()`. Separately, the structure-view settings are reorganised
-to match the rest of the project: `project.rendering_structure` now just selects
-the engine, `project.structure_view` holds what and where to draw, and
-`project.structure_style` holds how it looks. Structure-view settings saved by
-older versions (the `_style.*` block) need re-applying (beta: no automatic
-migration).
+**Title:** Make every option list discoverable, and tidy structure-view
+settings
+
+**Description:** Any setting that takes one of a fixed list of values —
+the experiment type, atom depiction, colour scheme, verbosity, and more
+— can now show its options the same way, with the active one marked, via
+`show_supported()`. Separately, the structure-view settings are
+reorganised to match the rest of the project:
+`project.rendering_structure` now just selects the engine,
+`project.structure_view` holds what and where to draw, and
+`project.structure_style` holds how it looks. Structure-view settings
+saved by older versions (the `_style.*` block) need re-applying (beta:
+no automatic migration).
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 176925b44..5c20838ab 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -182,11 +182,12 @@ Structure 🧩 'lbco' as cif
 
 ## Viewing a Model in 3D
 
-EasyDiffraction can render a defined structure as an interactive 3D view.
-The renderer engine is chosen through `project.rendering_structure`. The default `auto`
-engine resolves to the interactive Three.js view in Jupyter and the
-terminal-friendly ASCII schematic in a console — mirroring how
-`project.rendering_plot` and `project.rendering_table` pick their environment defaults.
+EasyDiffraction can render a defined structure as an interactive 3D
+view. The renderer engine is chosen through
+`project.rendering_structure`. The default `auto` engine resolves to the
+interactive Three.js view in Jupyter and the terminal-friendly ASCII
+schematic in a console — mirroring how `project.rendering_plot` and
+`project.rendering_table` pick their environment defaults.
 
 ```python
 # List the available renderer engines
@@ -215,8 +216,8 @@ project.structure_style.adp_probability = 0.5  # ADP ellipsoid probability level
 ```
 
 Bonds are generated automatically between atoms whose separation falls
-within the per-structure cutoffs stored on `structure.geom` (the standard
-cif_core `_geom` parameters):
+within the per-structure cutoffs stored on `structure.geom` (the
+standard cif_core `_geom` parameters):
 
 ```python
 # Tune the per-structure bond-generation cutoffs (angstrom)
@@ -242,8 +243,9 @@ project.display.structure(
 ```
 
 The same view is embedded automatically in the generated reports — an
-interactive Three.js view in the HTML report and a static, depth-rendered
-image in the TeX/PDF report (see the [Report](report.md) section).
+interactive Three.js view in the HTML report and a static,
+depth-rendered image in the TeX/PDF report (see the [Report](report.md)
+section).
 
 ## Saving a Model
 

From eb9f3d5ae2c23bc580bf378625d0eda7ea4974e1 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:37:43 +0200
Subject: [PATCH 104/160] Update ed-17 tutorial to demonstrate structure_style

---
 docs/docs/tutorials/ed-17.ipynb | 164 +++++++++++++++-----------------
 docs/docs/tutorials/ed-17.py    |  20 ++--
 2 files changed, 88 insertions(+), 96 deletions(-)

diff --git a/docs/docs/tutorials/ed-17.ipynb b/docs/docs/tutorials/ed-17.ipynb
index 7c5938751..1e9e140a9 100644
--- a/docs/docs/tutorials/ed-17.ipynb
+++ b/docs/docs/tutorials/ed-17.ipynb
@@ -228,54 +228,27 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "id": "16",
    "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "17",
-   "metadata": {},
-   "outputs": [],
    "source": [
-    "project.rendering_structure.type = 'auto'\n",
-    "project.display.structure(struct_name='cosio')"
+    "#### Plot Structure"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.rendering_structure.type = 'ascii'\n",
+    "project.structure_style.atom_view = 'adp'\n",
     "project.display.structure(struct_name='cosio')"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "19",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "20",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "markdown",
-   "id": "21",
+   "id": "18",
    "metadata": {},
    "source": [
     "## Step 3: Define Template Experiment\n",
@@ -291,7 +264,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -300,7 +273,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "23",
+   "id": "20",
    "metadata": {},
    "source": [
     "#### Extract Data Files"
@@ -309,7 +282,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -322,7 +295,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "25",
+   "id": "22",
    "metadata": {},
    "source": [
     "#### Create Template Experiment from the First File"
@@ -331,7 +304,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -344,7 +317,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "27",
+   "id": "24",
    "metadata": {},
    "source": [
     "#### Set Instrument"
@@ -353,7 +326,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "28",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -363,7 +336,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "29",
+   "id": "26",
    "metadata": {},
    "source": [
     "#### Set Peak Profile"
@@ -372,7 +345,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -384,7 +357,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "31",
+   "id": "28",
    "metadata": {},
    "source": [
     "#### Set Excluded Regions"
@@ -393,7 +366,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -403,7 +376,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "33",
+   "id": "30",
    "metadata": {},
    "source": [
     "#### Set Background"
@@ -412,7 +385,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -434,7 +407,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "32",
    "metadata": {},
    "source": [
     "#### Set Linked Phases"
@@ -443,7 +416,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "33",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -452,7 +425,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "37",
+   "id": "34",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis\n",
@@ -463,7 +436,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "35",
    "metadata": {},
    "source": [
     "#### Set Free Parameters"
@@ -472,7 +445,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -503,7 +476,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -522,7 +495,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "41",
+   "id": "38",
    "metadata": {},
    "source": [
     "#### Set Constraints\n",
@@ -533,7 +506,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -549,7 +522,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "40",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -558,7 +531,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -567,7 +540,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "42",
    "metadata": {},
    "source": [
     "#### Set Minimizer"
@@ -576,7 +549,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -585,7 +558,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "44",
    "metadata": {},
    "source": [
     "#### Run Single Fitting\n",
@@ -599,7 +572,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -609,7 +582,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -618,7 +591,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "47",
    "metadata": {},
    "source": [
     "#### Show parameter correlations"
@@ -627,7 +600,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -636,7 +609,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "49",
    "metadata": {},
    "source": [
     "#### Compare measured and calculated patterns for the first fit."
@@ -645,7 +618,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -654,7 +627,26 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "51",
+   "metadata": {},
+   "source": [
+    "#### Plot structure after the first fit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.structure_style.atom_view = 'adp'\n",
+    "project.display.structure(struct_name='cosio')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53",
    "metadata": {},
    "source": [
     "#### Run Sequential Fitting\n",
@@ -666,7 +658,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -675,7 +667,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "56",
+   "id": "55",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -688,7 +680,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57",
+   "id": "56",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -698,7 +690,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -712,7 +704,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "58",
    "metadata": {},
    "source": [
     "Set the sequential fitting parameters."
@@ -721,7 +713,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "59",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -733,7 +725,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "61",
+   "id": "60",
    "metadata": {},
    "source": [
     "Run the sequential fit over all data files in the scan directory."
@@ -742,7 +734,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "62",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -751,7 +743,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "62",
    "metadata": {},
    "source": [
     "#### Replay a Dataset\n",
@@ -762,7 +754,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "63",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -772,7 +764,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "64",
    "metadata": {},
    "source": [
     "\n",
@@ -782,7 +774,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "65",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -792,7 +784,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "66",
    "metadata": {},
    "source": [
     "#### Plot Parameter Evolution\n",
@@ -802,7 +794,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "68",
+   "id": "67",
    "metadata": {},
    "source": [
     "Plot fit quality metrics vs. temperature."
@@ -811,7 +803,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "69",
+   "id": "68",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -822,7 +814,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "70",
+   "id": "69",
    "metadata": {},
    "source": [
     "Plot unit cell parameters vs. temperature."
@@ -831,7 +823,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "71",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -842,7 +834,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "72",
+   "id": "71",
    "metadata": {},
    "source": [
     "Plot isotropic displacement parameters vs. temperature."
@@ -851,7 +843,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "73",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -864,7 +856,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "74",
+   "id": "73",
    "metadata": {},
    "source": [
     "Plot selected fractional coordinates vs. temperature."
@@ -873,7 +865,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "75",
+   "id": "74",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-17.py b/docs/docs/tutorials/ed-17.py
index f9e537070..fb4438a75 100644
--- a/docs/docs/tutorials/ed-17.py
+++ b/docs/docs/tutorials/ed-17.py
@@ -117,20 +117,13 @@
     adp_iso=0.83,
 )
 
-# %%
-
-# %%
-project.rendering_structure.type = 'auto'
-project.display.structure(struct_name='cosio')
+# %% [markdown]
+# #### Plot Structure
 
 # %%
-project.rendering_structure.type = 'ascii'
+project.structure_style.atom_view = 'adp'
 project.display.structure(struct_name='cosio')
 
-# %%
-
-# %%
-
 # %% [markdown]
 # ## Step 3: Define Template Experiment
 #
@@ -311,6 +304,13 @@
 # %%
 display.pattern(expt_name='d20')
 
+# %% [markdown]
+# #### Plot structure after the first fit.
+
+# %%
+project.structure_style.atom_view = 'adp'
+project.display.structure(struct_name='cosio')
+
 # %% [markdown]
 # #### Run Sequential Fitting
 #

From 02d6026d290c4448ee06526274d95a23056efe9d Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 15:58:28 +0200
Subject: [PATCH 105/160] Add structure view to remaining tutorials

---
 docs/docs/tutorials/ed-1.ipynb  |  39 ++--
 docs/docs/tutorials/ed-1.py     |   4 +
 docs/docs/tutorials/ed-10.ipynb |  38 +++-
 docs/docs/tutorials/ed-10.py    |   6 +
 docs/docs/tutorials/ed-11.ipynb |  38 +++-
 docs/docs/tutorials/ed-11.py    |   6 +
 docs/docs/tutorials/ed-12.ipynb |  44 +++--
 docs/docs/tutorials/ed-12.py    |   6 +
 docs/docs/tutorials/ed-13.ipynb | 334 ++++++++++++++++++--------------
 docs/docs/tutorials/ed-13.py    |  18 ++
 docs/docs/tutorials/ed-15.ipynb |  64 +++---
 docs/docs/tutorials/ed-15.py    |   3 +
 docs/docs/tutorials/ed-16.ipynb |  48 +++--
 docs/docs/tutorials/ed-16.py    |   6 +
 docs/docs/tutorials/ed-18.ipynb |  28 ++-
 docs/docs/tutorials/ed-18.py    |   6 +
 docs/docs/tutorials/ed-2.ipynb  |  74 ++++---
 docs/docs/tutorials/ed-2.py     |   3 +
 docs/docs/tutorials/ed-20.ipynb |  69 ++++---
 docs/docs/tutorials/ed-20.py    |   7 +
 docs/docs/tutorials/ed-21.ipynb | 111 ++++++-----
 docs/docs/tutorials/ed-21.py    |   7 +
 docs/docs/tutorials/ed-22.ipynb |  97 ++++++----
 docs/docs/tutorials/ed-22.py    |   7 +
 docs/docs/tutorials/ed-23.ipynb |  42 ++--
 docs/docs/tutorials/ed-23.py    |   8 +
 docs/docs/tutorials/ed-24.ipynb |  40 +++-
 docs/docs/tutorials/ed-24.py    |   8 +
 docs/docs/tutorials/ed-25.ipynb | 109 ++++++-----
 docs/docs/tutorials/ed-25.py    |   7 +
 docs/docs/tutorials/ed-26.ipynb |  54 ++++--
 docs/docs/tutorials/ed-26.py    |   8 +
 docs/docs/tutorials/ed-4.ipynb  |  22 ++-
 docs/docs/tutorials/ed-4.py     |   6 +
 docs/docs/tutorials/ed-5.ipynb  |  56 ++++--
 docs/docs/tutorials/ed-5.py     |   6 +
 docs/docs/tutorials/ed-6.ipynb  | 106 +++++-----
 docs/docs/tutorials/ed-6.py     |   6 +
 docs/docs/tutorials/ed-7.ipynb  | 134 +++++++------
 docs/docs/tutorials/ed-7.py     |   6 +
 docs/docs/tutorials/ed-8.ipynb  |  34 +++-
 docs/docs/tutorials/ed-8.py     |   6 +
 docs/docs/tutorials/ed-9.ipynb  |  53 +++--
 docs/docs/tutorials/ed-9.py     |   7 +
 44 files changed, 1168 insertions(+), 613 deletions(-)

diff --git a/docs/docs/tutorials/ed-1.ipynb b/docs/docs/tutorials/ed-1.ipynb
index f108a808b..3da28c97d 100644
--- a/docs/docs/tutorials/ed-1.ipynb
+++ b/docs/docs/tutorials/ed-1.ipynb
@@ -110,9 +110,20 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "9",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the crystal structure\n",
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10",
+   "metadata": {},
    "source": [
     "## Step 3: Define Experiment"
    ]
@@ -120,7 +131,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "10",
+   "id": "11",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -131,7 +142,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "11",
+   "id": "12",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -141,7 +152,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "12",
+   "id": "13",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis (no constraints)"
@@ -150,7 +161,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -162,7 +173,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -173,7 +184,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -183,7 +194,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "16",
+   "id": "17",
    "metadata": {},
    "source": [
     "## Step 5: Perform Analysis (with constraints)"
@@ -192,7 +203,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -217,7 +228,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -229,7 +240,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -240,7 +251,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -251,7 +262,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -262,7 +273,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-1.py b/docs/docs/tutorials/ed-1.py
index e6312d4ac..5d552dc3a 100644
--- a/docs/docs/tutorials/ed-1.py
+++ b/docs/docs/tutorials/ed-1.py
@@ -40,6 +40,10 @@
 # Add structure from downloaded CIF
 project.structures.add_from_cif_path(structure_path)
 
+# %%
+# Plot the crystal structure
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Step 3: Define Experiment
 
diff --git a/docs/docs/tutorials/ed-10.ipynb b/docs/docs/tutorials/ed-10.ipynb
index 2b23af884..debd33e35 100644
--- a/docs/docs/tutorials/ed-10.ipynb
+++ b/docs/docs/tutorials/ed-10.ipynb
@@ -114,7 +114,7 @@
    "id": "9",
    "metadata": {},
    "source": [
-    "## Add Experiment"
+    "## Plot Structure"
    ]
   },
   {
@@ -123,6 +123,24 @@
    "id": "10",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='ni')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11",
+   "metadata": {},
+   "source": [
+    "## Add Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "data_path = ed.download_data(id=6, destination='data')"
    ]
@@ -130,7 +148,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "11",
+   "id": "13",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -147,7 +165,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "12",
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -162,7 +180,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "13",
+   "id": "15",
    "metadata": {},
    "source": [
     "## Select Fitting Parameters"
@@ -171,7 +189,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -182,7 +200,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -193,7 +211,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "source": [
     "## Run Fitting"
@@ -202,7 +220,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -213,7 +231,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "source": [
     "## Plot Measured vs Calculated"
@@ -222,7 +240,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-10.py b/docs/docs/tutorials/ed-10.py
index 9fb0b9c61..fc788d923 100644
--- a/docs/docs/tutorials/ed-10.py
+++ b/docs/docs/tutorials/ed-10.py
@@ -40,6 +40,12 @@
     adp_iso=0.5,
 )
 
+# %% [markdown]
+# ## Plot Structure
+
+# %%
+project.display.structure(struct_name='ni')
+
 # %% [markdown]
 # ## Add Experiment
 
diff --git a/docs/docs/tutorials/ed-11.ipynb b/docs/docs/tutorials/ed-11.ipynb
index d8753eeac..0e9d8cf6d 100644
--- a/docs/docs/tutorials/ed-11.ipynb
+++ b/docs/docs/tutorials/ed-11.ipynb
@@ -141,7 +141,7 @@
    "id": "12",
    "metadata": {},
    "source": [
-    "## Add Experiment"
+    "## Plot Structure"
    ]
   },
   {
@@ -150,6 +150,24 @@
    "id": "13",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='si')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14",
+   "metadata": {},
+   "source": [
+    "## Add Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "data_path = ed.download_data(id=5, destination='data')"
    ]
@@ -157,7 +175,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -174,7 +192,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -190,7 +208,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "source": [
     "## Select Fitting Parameters"
@@ -199,7 +217,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -211,7 +229,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -223,7 +241,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "source": [
     "## Run Fitting"
@@ -232,7 +250,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -243,7 +261,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "21",
+   "id": "23",
    "metadata": {},
    "source": [
     "## Plot Measured vs Calculated"
@@ -252,7 +270,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "24",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-11.py b/docs/docs/tutorials/ed-11.py
index b85ede086..9125b432b 100644
--- a/docs/docs/tutorials/ed-11.py
+++ b/docs/docs/tutorials/ed-11.py
@@ -48,6 +48,12 @@
     adp_iso=0.5,
 )
 
+# %% [markdown]
+# ## Plot Structure
+
+# %%
+project.display.structure(struct_name='si')
+
 # %% [markdown]
 # ## Add Experiment
 
diff --git a/docs/docs/tutorials/ed-12.ipynb b/docs/docs/tutorials/ed-12.ipynb
index 8941526a3..28b12b58c 100644
--- a/docs/docs/tutorials/ed-12.ipynb
+++ b/docs/docs/tutorials/ed-12.ipynb
@@ -155,7 +155,7 @@
    "id": "12",
    "metadata": {},
    "source": [
-    "## Add Experiment"
+    "## Plot Structure"
    ]
   },
   {
@@ -164,6 +164,24 @@
    "id": "13",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='nacl')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14",
+   "metadata": {},
+   "source": [
+    "## Add Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "data_path = ed.download_data(id=4, destination='data')"
    ]
@@ -171,7 +189,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -188,7 +206,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -198,7 +216,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -208,7 +226,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -223,7 +241,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -232,7 +250,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "source": [
     "## Select Fitting Parameters"
@@ -241,7 +259,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -253,7 +271,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -264,7 +282,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "22",
+   "id": "24",
    "metadata": {},
    "source": [
     "## Run Fitting"
@@ -273,7 +291,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -284,7 +302,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "24",
+   "id": "26",
    "metadata": {},
    "source": [
     "## Plot Measured vs Calculated"
@@ -293,7 +311,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-12.py b/docs/docs/tutorials/ed-12.py
index 88251255c..834adfcd3 100644
--- a/docs/docs/tutorials/ed-12.py
+++ b/docs/docs/tutorials/ed-12.py
@@ -62,6 +62,12 @@
     adp_iso=1.0,
 )
 
+# %% [markdown]
+# ## Plot Structure
+
+# %%
+project.display.structure(struct_name='nacl')
+
 # %% [markdown]
 # ## Add Experiment
 
diff --git a/docs/docs/tutorials/ed-13.ipynb b/docs/docs/tutorials/ed-13.ipynb
index 3dce6bc36..bd3e2ba96 100644
--- a/docs/docs/tutorials/ed-13.ipynb
+++ b/docs/docs/tutorials/ed-13.ipynb
@@ -850,6 +850,27 @@
    "cell_type": "markdown",
    "id": "58",
    "metadata": {},
+   "source": [
+    "#### Visualize Structure\n",
+    "\n",
+    "Render the Si structure to confirm the model was built correctly before\n",
+    "linking it to the experiment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project_1.display.structure(struct_name='si')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60",
+   "metadata": {},
    "source": [
     "### 🔗 Assign Structure to Experiment\n",
     "\n",
@@ -861,7 +882,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "source": [
     "📖 See\n",
@@ -872,7 +893,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -881,7 +902,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "61",
+   "id": "63",
    "metadata": {},
    "source": [
     "### 🚀 Analyze and Fit the Data\n",
@@ -903,7 +924,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "62",
+   "id": "64",
    "metadata": {
     "title": "**Reminder:**"
    },
@@ -920,7 +941,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "65",
    "metadata": {},
    "source": [
     "📖 See\n",
@@ -930,7 +951,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "64",
+   "id": "66",
    "metadata": {},
    "source": [
     "#### Set Fit Parameters\n",
@@ -953,7 +974,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "65",
+   "id": "67",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -973,7 +994,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "66",
+   "id": "68",
    "metadata": {},
    "source": [
     "#### Show Free Parameters\n",
@@ -984,7 +1005,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "69",
    "metadata": {},
    "source": [
     "📖 See\n",
@@ -998,7 +1019,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1007,7 +1028,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "69",
+   "id": "71",
    "metadata": {},
    "source": [
     "#### Visualize Diffraction Patterns\n",
@@ -1023,7 +1044,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1032,7 +1053,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71",
+   "id": "73",
    "metadata": {},
    "source": [
     "#### Run Fitting\n",
@@ -1043,7 +1064,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "72",
+   "id": "74",
    "metadata": {},
    "source": [
     "📖 See\n",
@@ -1054,7 +1075,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "73",
+   "id": "75",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1064,7 +1085,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "74",
+   "id": "76",
    "metadata": {},
    "source": [
     "#### Check Fit Results\n",
@@ -1083,7 +1104,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "75",
+   "id": "77",
    "metadata": {},
    "source": [
     "#### Visualize Fit Results\n",
@@ -1097,7 +1118,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "76",
+   "id": "78",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1106,7 +1127,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "77",
+   "id": "79",
    "metadata": {},
    "source": [
     "#### TOF vs d-spacing\n",
@@ -1140,7 +1161,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "78",
+   "id": "80",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1149,7 +1170,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "79",
+   "id": "81",
    "metadata": {},
    "source": [
     "As you can see, the calculated diffraction pattern now matches the\n",
@@ -1175,7 +1196,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "80",
+   "id": "82",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1184,7 +1205,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "81",
+   "id": "83",
    "metadata": {},
    "source": [
     "## 💪 Exercise: Complex Fit – LBCO\n",
@@ -1205,7 +1226,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "82",
+   "id": "84",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1213,7 +1234,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "83",
+   "id": "85",
    "metadata": {},
    "source": [
     "You can use the same approach as in the previous part of the notebook,\n",
@@ -1222,7 +1243,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "84",
+   "id": "86",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1231,7 +1252,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "85",
+   "id": "87",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1242,7 +1263,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "86",
+   "id": "88",
    "metadata": {},
    "source": [
     "### 🔬 Exercise 2: Define an Experiment\n",
@@ -1255,7 +1276,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "87",
+   "id": "89",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1263,7 +1284,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "88",
+   "id": "90",
    "metadata": {},
    "source": [
     "You can use the same approach as in the previous part of the notebook,\n",
@@ -1272,7 +1293,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "89",
+   "id": "91",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1281,7 +1302,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "90",
+   "id": "92",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1304,7 +1325,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "91",
+   "id": "93",
    "metadata": {},
    "source": [
     "#### Exercise 2.1: Inspect Measured Data\n",
@@ -1316,7 +1337,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "92",
+   "id": "94",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1324,7 +1345,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "93",
+   "id": "95",
    "metadata": {},
    "source": [
     "You can use the `plot_meas` method of the project to visualize the\n",
@@ -1335,7 +1356,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "94",
+   "id": "96",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1344,7 +1365,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "95",
+   "id": "97",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1358,7 +1379,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "96",
+   "id": "98",
    "metadata": {},
    "source": [
     "#### Exercise 2.2: Set Instrument Parameters\n",
@@ -1368,7 +1389,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "97",
+   "id": "99",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1376,7 +1397,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "98",
+   "id": "100",
    "metadata": {},
    "source": [
     "Use the values from the data reduction process for the LBCO and\n",
@@ -1385,7 +1406,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "99",
+   "id": "101",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1394,7 +1415,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "100",
+   "id": "102",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1408,7 +1429,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "101",
+   "id": "103",
    "metadata": {},
    "source": [
     "#### Exercise 2.3: Set Peak Profile Parameters\n",
@@ -1418,7 +1439,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "102",
+   "id": "104",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1426,7 +1447,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "103",
+   "id": "105",
    "metadata": {},
    "source": [
     "Use the values from the\n",
@@ -1438,7 +1459,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "104",
+   "id": "106",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1447,7 +1468,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "105",
+   "id": "107",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1466,7 +1487,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "106",
+   "id": "108",
    "metadata": {},
    "source": [
     "#### Exercise 2.4: Set Background\n",
@@ -1477,7 +1498,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "107",
+   "id": "109",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1485,7 +1506,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "108",
+   "id": "110",
    "metadata": {},
    "source": [
     "Use the same approach as in the previous part of the notebook, but\n",
@@ -1496,7 +1517,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "109",
+   "id": "111",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1505,7 +1526,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "110",
+   "id": "112",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1520,7 +1541,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "111",
+   "id": "113",
    "metadata": {},
    "source": [
     "### 🧩 Exercise 3: Define a Structure – LBCO\n",
@@ -1536,7 +1557,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "112",
+   "id": "114",
    "metadata": {},
    "source": [
     "```\n",
@@ -1571,7 +1592,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "113",
+   "id": "115",
    "metadata": {},
    "source": [
     "Note that the `occupancy` of the La and Ba atoms is 0.5\n",
@@ -1601,7 +1622,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "114",
+   "id": "116",
    "metadata": {},
    "source": [
     "#### Exercise 3.1: Create Structure\n",
@@ -1612,7 +1633,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "115",
+   "id": "117",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1620,7 +1641,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "116",
+   "id": "118",
    "metadata": {},
    "source": [
     "You can use the same approach as in the previous part of the notebook,\n",
@@ -1630,7 +1651,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "117",
+   "id": "119",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1639,7 +1660,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "118",
+   "id": "120",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1648,7 +1669,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "119",
+   "id": "121",
    "metadata": {},
    "source": [
     "#### Exercise 3.2: Set Space Group\n",
@@ -1658,7 +1679,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "120",
+   "id": "122",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1666,7 +1687,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "121",
+   "id": "123",
    "metadata": {},
    "source": [
     "Use the space group name and IT coordinate system code from the CIF\n",
@@ -1675,7 +1696,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "122",
+   "id": "124",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1684,7 +1705,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "123",
+   "id": "125",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1694,7 +1715,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "124",
+   "id": "126",
    "metadata": {},
    "source": [
     "#### Exercise 3.3: Set Lattice Parameters\n",
@@ -1704,7 +1725,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "125",
+   "id": "127",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1712,7 +1733,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "126",
+   "id": "128",
    "metadata": {},
    "source": [
     "Use the lattice parameters from the CIF data."
@@ -1720,7 +1741,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "127",
+   "id": "129",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1729,7 +1750,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "128",
+   "id": "130",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1738,7 +1759,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "129",
+   "id": "131",
    "metadata": {},
    "source": [
     "#### Exercise 3.4: Set Atom Sites\n",
@@ -1748,7 +1769,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "130",
+   "id": "132",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1756,7 +1777,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "131",
+   "id": "133",
    "metadata": {},
    "source": [
     "Use the atom sites from the CIF data. You can use the `add` method of\n",
@@ -1765,7 +1786,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "132",
+   "id": "134",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1774,7 +1795,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "133",
+   "id": "135",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1820,7 +1841,28 @@
   },
   {
    "cell_type": "markdown",
-   "id": "134",
+   "id": "136",
+   "metadata": {},
+   "source": [
+    "#### Visualize Structure\n",
+    "\n",
+    "Render the LBCO structure you just built before linking it to the\n",
+    "experiment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "137",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project_2.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "138",
    "metadata": {},
    "source": [
     "### 🔗 Exercise 4: Assign Structure to Experiment\n",
@@ -1830,7 +1872,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "135",
+   "id": "139",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1838,7 +1880,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "136",
+   "id": "140",
    "metadata": {},
    "source": [
     "Use the `linked_phases` attribute of the experiment to link the\n",
@@ -1847,7 +1889,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "137",
+   "id": "141",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1856,7 +1898,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "138",
+   "id": "142",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1865,7 +1907,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "139",
+   "id": "143",
    "metadata": {},
    "source": [
     "### 🚀 Exercise 5: Analyze and Fit the Data\n",
@@ -1878,7 +1920,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "140",
+   "id": "144",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1886,7 +1928,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "141",
+   "id": "145",
    "metadata": {},
    "source": [
     "You can start with the scale factor and the background points, as in\n",
@@ -1895,7 +1937,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "142",
+   "id": "146",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1904,7 +1946,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "143",
+   "id": "147",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1916,7 +1958,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "144",
+   "id": "148",
    "metadata": {},
    "source": [
     "#### Exercise 5.2: Run Fitting\n",
@@ -1927,7 +1969,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "145",
+   "id": "149",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1935,7 +1977,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "146",
+   "id": "150",
    "metadata": {},
    "source": [
     "Use the `pattern` method of the project's `display` facade to\n",
@@ -1946,7 +1988,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "147",
+   "id": "151",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -1955,7 +1997,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "148",
+   "id": "152",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1967,7 +2009,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "149",
+   "id": "153",
    "metadata": {},
    "source": [
     "#### Exercise 5.3: Find the Misfit in the Fit\n",
@@ -1982,7 +2024,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "150",
+   "id": "154",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -1990,7 +2032,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "151",
+   "id": "155",
    "metadata": {},
    "source": [
     "Consider the following options:\n",
@@ -2002,7 +2044,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "152",
+   "id": "156",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2010,7 +2052,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "153",
+   "id": "157",
    "metadata": {},
    "source": [
     "\n",
@@ -2032,7 +2074,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "154",
+   "id": "158",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2041,7 +2083,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "155",
+   "id": "159",
    "metadata": {},
    "source": [
     "#### Exercise 5.4: Refine the LBCO Lattice Parameter\n",
@@ -2051,7 +2093,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "156",
+   "id": "160",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2059,7 +2101,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "157",
+   "id": "161",
    "metadata": {},
    "source": [
     "To achieve this, we will set the `free` attribute of the `length_a`\n",
@@ -2074,7 +2116,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "158",
+   "id": "162",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2083,7 +2125,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "159",
+   "id": "163",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2097,7 +2139,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "160",
+   "id": "164",
    "metadata": {},
    "source": [
     "One of the main goals of this study was to refine the lattice\n",
@@ -2110,7 +2152,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "161",
+   "id": "165",
    "metadata": {},
    "source": [
     "#### Exercise 5.5: Visualize the Fit Results in d-spacing\n",
@@ -2121,7 +2163,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "162",
+   "id": "166",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2129,7 +2171,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "163",
+   "id": "167",
    "metadata": {},
    "source": [
     "Use the `pattern` method of the project's `display` facade and set\n",
@@ -2138,7 +2180,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "164",
+   "id": "168",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2147,7 +2189,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "165",
+   "id": "169",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2156,7 +2198,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "166",
+   "id": "170",
    "metadata": {},
    "source": [
     "#### Exercise 5.6: Refine the Peak Profile Parameters\n",
@@ -2176,7 +2218,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "167",
+   "id": "171",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2185,7 +2227,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "168",
+   "id": "172",
    "metadata": {},
    "source": [
     "The peak profile parameters are determined based on both the\n",
@@ -2199,7 +2241,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "169",
+   "id": "173",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2207,7 +2249,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "170",
+   "id": "174",
    "metadata": {},
    "source": [
     "You can set the `free` attribute of the peak profile parameters to\n",
@@ -2218,7 +2260,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "171",
+   "id": "175",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2227,7 +2269,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "172",
+   "id": "176",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2247,7 +2289,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "173",
+   "id": "177",
    "metadata": {},
    "source": [
     "#### Exercise 5.7: Find Undefined Features\n",
@@ -2259,7 +2301,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "174",
+   "id": "178",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2267,7 +2309,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "175",
+   "id": "179",
    "metadata": {},
    "source": [
     "While the fit is now significantly better, there are still some\n",
@@ -2279,7 +2321,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "176",
+   "id": "180",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2288,7 +2330,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "177",
+   "id": "181",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2297,7 +2339,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "178",
+   "id": "182",
    "metadata": {},
    "source": [
     "#### Exercise 5.8: Identify the Cause of the Unexplained Peaks\n",
@@ -2310,7 +2352,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "179",
+   "id": "183",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2318,7 +2360,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "180",
+   "id": "184",
    "metadata": {},
    "source": [
     "Consider the following options:\n",
@@ -2330,7 +2372,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "181",
+   "id": "185",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2338,7 +2380,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "182",
+   "id": "186",
    "metadata": {},
    "source": [
     "1. ❌ In principle, this could be the case, as sometimes the presence\n",
@@ -2358,7 +2400,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "183",
+   "id": "187",
    "metadata": {},
    "source": [
     "#### Exercise 5.9: Identify the impurity phase\n",
@@ -2369,7 +2411,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "184",
+   "id": "188",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2377,7 +2419,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "185",
+   "id": "189",
    "metadata": {},
    "source": [
     "Check the positions of the unexplained peaks in the diffraction\n",
@@ -2387,7 +2429,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "186",
+   "id": "190",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2395,7 +2437,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "187",
+   "id": "191",
    "metadata": {},
    "source": [
     "The unexplained peaks are likely due to the presence of a small amount\n",
@@ -2410,7 +2452,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "188",
+   "id": "192",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2420,7 +2462,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "189",
+   "id": "193",
    "metadata": {},
    "source": [
     "#### Exercise 5.10: Create a Second Structure – Si as Impurity\n",
@@ -2432,7 +2474,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "190",
+   "id": "194",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2440,7 +2482,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "191",
+   "id": "195",
    "metadata": {},
    "source": [
     "You can use the same approach as in the previous part of the notebook,\n",
@@ -2450,7 +2492,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "192",
+   "id": "196",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2459,7 +2501,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "193",
+   "id": "197",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2488,7 +2530,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "194",
+   "id": "198",
    "metadata": {},
    "source": [
     "#### Exercise 5.11: Refine the Scale of the Si Phase\n",
@@ -2501,7 +2543,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "195",
+   "id": "199",
    "metadata": {},
    "source": [
     "**Hint:**"
@@ -2509,7 +2551,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "196",
+   "id": "200",
    "metadata": {},
    "source": [
     "You can use the `pattern` method of the project's `display` facade to\n",
@@ -2520,7 +2562,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "197",
+   "id": "201",
    "metadata": {},
    "source": [
     "**Solution:**"
@@ -2529,7 +2571,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "198",
+   "id": "202",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2558,7 +2600,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "199",
+   "id": "203",
    "metadata": {},
    "source": [
     "All previously unexplained peaks are now accounted for in the pattern,\n",
@@ -2581,7 +2623,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "200",
+   "id": "204",
    "metadata": {},
    "source": [
     "Finally, we save the project to disk to preserve the current state of\n",
@@ -2591,7 +2633,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "201",
+   "id": "205",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2600,7 +2642,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "202",
+   "id": "206",
    "metadata": {},
    "source": [
     "#### Final Remarks\n",
@@ -2619,7 +2661,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "203",
+   "id": "207",
    "metadata": {},
    "source": [
     "## 🎁 Bonus\n",
@@ -2648,7 +2690,7 @@
  ],
  "metadata": {
   "jupytext": {
-   "cell_metadata_filter": "tags,title,-all",
+   "cell_metadata_filter": "title,tags,-all",
    "main_language": "python",
    "notebook_metadata_filter": "-all"
   }
diff --git a/docs/docs/tutorials/ed-13.py b/docs/docs/tutorials/ed-13.py
index 4436d76b4..655e270b3 100644
--- a/docs/docs/tutorials/ed-13.py
+++ b/docs/docs/tutorials/ed-13.py
@@ -500,6 +500,15 @@
     adp_iso=0.89,
 )
 
+# %% [markdown]
+# #### Visualize Structure
+#
+# Render the Si structure to confirm the model was built correctly before
+# linking it to the experiment.
+
+# %%
+project_1.display.structure(struct_name='si')
+
 # %% [markdown]
 # ### 🔗 Assign Structure to Experiment
 #
@@ -1054,6 +1063,15 @@
     adp_iso=1.66,
 )
 
+# %% [markdown]
+# #### Visualize Structure
+#
+# Render the LBCO structure you just built before linking it to the
+# experiment.
+
+# %%
+project_2.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ### 🔗 Exercise 4: Assign Structure to Experiment
 #
diff --git a/docs/docs/tutorials/ed-15.ipynb b/docs/docs/tutorials/ed-15.ipynb
index bdc9385cc..90fbc0d1c 100644
--- a/docs/docs/tutorials/ed-15.ipynb
+++ b/docs/docs/tutorials/ed-15.ipynb
@@ -127,9 +127,19 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "12",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='taurine')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13",
+   "metadata": {},
    "source": [
     "## Step 3: Define Experiment"
    ]
@@ -137,7 +147,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -148,7 +158,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -164,7 +174,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -174,7 +184,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -185,7 +195,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -195,7 +205,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "18",
+   "id": "19",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis I (ADP iso)"
@@ -204,7 +214,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -214,7 +224,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -225,7 +235,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -235,7 +245,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -245,7 +255,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "24",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -256,7 +266,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -268,7 +278,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -279,7 +289,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -289,7 +299,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -299,7 +309,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "28",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,7 +318,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "29",
+   "id": "30",
    "metadata": {},
    "source": [
     "## Step 5: Perform Analysis (ADP aniso)"
@@ -317,7 +327,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -328,7 +338,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "31",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -341,7 +351,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "33",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -351,7 +361,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -361,7 +371,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -371,7 +381,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -381,7 +391,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -391,7 +401,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -401,7 +411,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-15.py b/docs/docs/tutorials/ed-15.py
index cc9776288..611e46941 100644
--- a/docs/docs/tutorials/ed-15.py
+++ b/docs/docs/tutorials/ed-15.py
@@ -36,6 +36,9 @@
 # %%
 structure.show_as_cif()
 
+# %%
+project.display.structure(struct_name='taurine')
+
 # %% [markdown]
 # ## Step 3: Define Experiment
 
diff --git a/docs/docs/tutorials/ed-16.ipynb b/docs/docs/tutorials/ed-16.ipynb
index c57d1cd95..ade621279 100644
--- a/docs/docs/tutorials/ed-16.ipynb
+++ b/docs/docs/tutorials/ed-16.ipynb
@@ -445,7 +445,7 @@
    "id": "40",
    "metadata": {},
    "source": [
-    "#### Plot Measured vs Calculated (Before Fit)"
+    "#### Plot Structure"
    ]
   },
   {
@@ -454,6 +454,24 @@
    "id": "41",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='si')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated (Before Fit)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='sepd')"
    ]
@@ -461,7 +479,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -470,7 +488,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "source": [
     "#### Set Fitting Parameters\n",
@@ -482,7 +500,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -492,7 +510,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "source": [
     "Bragg experiment parameters."
@@ -501,7 +519,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -516,7 +534,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "source": [
     "PDF experiment parameters."
@@ -525,7 +543,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -538,7 +556,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "source": [
     "#### Show Free Parameters"
@@ -547,7 +565,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -556,7 +574,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -565,7 +583,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -576,7 +594,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated (After Fit)"
@@ -585,7 +603,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -595,7 +613,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-16.py b/docs/docs/tutorials/ed-16.py
index 7f3074c61..f7345b7f2 100644
--- a/docs/docs/tutorials/ed-16.py
+++ b/docs/docs/tutorials/ed-16.py
@@ -186,6 +186,12 @@
 project.analysis.joint_fit.create(experiment_id='sepd', weight=0.7)
 project.analysis.joint_fit.create(experiment_id='nomad', weight=0.3)
 
+# %% [markdown]
+# #### Plot Structure
+
+# %%
+project.display.structure(struct_name='si')
+
 # %% [markdown]
 # #### Plot Measured vs Calculated (Before Fit)
 
diff --git a/docs/docs/tutorials/ed-18.ipynb b/docs/docs/tutorials/ed-18.ipynb
index 7473bc6e5..e4b40ffbb 100644
--- a/docs/docs/tutorials/ed-18.ipynb
+++ b/docs/docs/tutorials/ed-18.ipynb
@@ -97,7 +97,7 @@
    "id": "8",
    "metadata": {},
    "source": [
-    "## Perform Analysis"
+    "## View Structure"
    ]
   },
   {
@@ -107,7 +107,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "project.analysis.fit()"
+    "project.display.structure(struct_name='lbco')"
    ]
   },
   {
@@ -115,7 +115,7 @@
    "id": "10",
    "metadata": {},
    "source": [
-    "## Show Results"
+    "## Perform Analysis"
    ]
   },
   {
@@ -124,6 +124,24 @@
    "id": "11",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.analysis.fit()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12",
+   "metadata": {},
+   "source": [
+    "## Show Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.fit.results()"
    ]
@@ -131,7 +149,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "12",
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -141,7 +159,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-18.py b/docs/docs/tutorials/ed-18.py
index 31e903c04..0ab4d168b 100644
--- a/docs/docs/tutorials/ed-18.py
+++ b/docs/docs/tutorials/ed-18.py
@@ -30,6 +30,12 @@
 # %%
 project = Project.load(project_dir)
 
+# %% [markdown]
+# ## View Structure
+
+# %%
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Perform Analysis
 
diff --git a/docs/docs/tutorials/ed-2.ipynb b/docs/docs/tutorials/ed-2.ipynb
index fb664c97e..017a5ae43 100644
--- a/docs/docs/tutorials/ed-2.ipynb
+++ b/docs/docs/tutorials/ed-2.ipynb
@@ -180,9 +180,19 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "12",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13",
+   "metadata": {},
    "source": [
     "## Step 3: Define Experiment"
    ]
@@ -190,7 +200,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -200,7 +210,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -216,7 +226,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -226,7 +236,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -237,7 +247,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -250,7 +260,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -264,7 +274,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -275,7 +285,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -284,7 +294,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "21",
+   "id": "22",
    "metadata": {},
    "source": [
     "## Step 4: Perform Analysis (no constraints)"
@@ -293,7 +303,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,7 +318,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "24",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -331,7 +341,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -341,7 +351,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -351,7 +361,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -361,7 +371,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -370,7 +380,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "28",
+   "id": "29",
    "metadata": {},
    "source": [
     "## Step 5: Perform Analysis (with constraints)"
@@ -379,7 +389,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "30",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -404,7 +414,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -415,7 +425,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "31",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -425,7 +435,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "33",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -435,7 +445,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -445,7 +455,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -454,7 +464,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "36",
    "metadata": {},
    "source": [
     "## Step 6: Switch calculator engine"
@@ -463,7 +473,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -473,7 +483,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -483,7 +493,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -493,7 +503,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -503,7 +513,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -513,7 +523,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -522,7 +532,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "43",
    "metadata": {},
    "source": [
     "## Step 7: Save Project"
@@ -531,7 +541,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-2.py b/docs/docs/tutorials/ed-2.py
index 097720a88..21fd3184b 100644
--- a/docs/docs/tutorials/ed-2.py
+++ b/docs/docs/tutorials/ed-2.py
@@ -89,6 +89,9 @@
     adp_iso=0.5,
 )
 
+# %%
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Step 3: Define Experiment
 
diff --git a/docs/docs/tutorials/ed-20.ipynb b/docs/docs/tutorials/ed-20.ipynb
index a4bc863f5..f4f596dbb 100644
--- a/docs/docs/tutorials/ed-20.ipynb
+++ b/docs/docs/tutorials/ed-20.ipynb
@@ -505,7 +505,7 @@
    "id": "39",
    "metadata": {},
    "source": [
-    "#### Plot Measured vs Calculated"
+    "#### Plot Structures"
    ]
   },
   {
@@ -514,6 +514,25 @@
    "id": "40",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='ferrite')\n",
+    "project.display.structure(struct_name='austenite')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "42",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='expt_s2')"
    ]
@@ -521,7 +540,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -530,7 +549,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "source": [
     "## Perform Analysis\n",
@@ -544,7 +563,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -554,7 +573,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -563,7 +582,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "source": [
     "#### Set Free Parameters"
@@ -572,7 +591,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -582,7 +601,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -593,7 +612,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -614,7 +633,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -634,7 +653,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Add Constraints"
@@ -643,7 +662,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -667,7 +686,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "source": [
     "#### Run Fitting\n",
@@ -678,7 +697,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,7 +706,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "source": [
     "Fix background and run fitting again."
@@ -696,7 +715,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -709,7 +728,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "56",
+   "id": "58",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -718,7 +737,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "57",
+   "id": "59",
    "metadata": {},
    "source": [
     "Show fit results and parameter correlations."
@@ -727,7 +746,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "60",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -737,7 +756,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated\n",
@@ -748,7 +767,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -758,7 +777,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "61",
+   "id": "63",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -767,7 +786,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "62",
+   "id": "64",
    "metadata": {},
    "source": [
     "Show selected peaks in d-spacing."
@@ -776,7 +795,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "63",
+   "id": "65",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -791,7 +810,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-20.py b/docs/docs/tutorials/ed-20.py
index edb4b0269..da4a663ce 100644
--- a/docs/docs/tutorials/ed-20.py
+++ b/docs/docs/tutorials/ed-20.py
@@ -241,6 +241,13 @@
 project.experiments.add(expt_s2)
 project.experiments.add(expt_n2)
 
+# %% [markdown]
+# #### Plot Structures
+
+# %%
+project.display.structure(struct_name='ferrite')
+project.display.structure(struct_name='austenite')
+
 # %% [markdown]
 # #### Plot Measured vs Calculated
 
diff --git a/docs/docs/tutorials/ed-21.ipynb b/docs/docs/tutorials/ed-21.ipynb
index 285084dc5..7dea23531 100644
--- a/docs/docs/tutorials/ed-21.ipynb
+++ b/docs/docs/tutorials/ed-21.ipynb
@@ -218,6 +218,25 @@
    "cell_type": "markdown",
    "id": "14",
    "metadata": {},
+   "source": [
+    "With the structural model complete, render it to confirm the perovskite\n",
+    "framework before configuring the experiment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16",
+   "metadata": {},
    "source": [
     "## Step 3: Define the Diffraction Experiment\n",
     "\n",
@@ -228,7 +247,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "source": [
     "Download the measured data from the repository. Alternatively, you\n",
@@ -239,7 +258,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -248,7 +267,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "source": [
     "Create the experiment object and specify the sample form, beam mode,\n",
@@ -258,7 +277,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -274,7 +293,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -283,7 +302,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "20",
+   "id": "22",
    "metadata": {},
    "source": [
     "Link the structural phase to the experiment."
@@ -292,7 +311,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -301,7 +320,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "22",
+   "id": "24",
    "metadata": {},
    "source": [
     "Set instrument and peak profile parameters.\n",
@@ -313,7 +332,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -324,7 +343,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +355,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "25",
+   "id": "27",
    "metadata": {},
    "source": [
     "Add background points and excluded regions.\n",
@@ -348,7 +367,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -361,7 +380,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -371,7 +390,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "28",
+   "id": "30",
    "metadata": {},
    "source": [
     "## Step 4: Run an Initial Local Refinement\n",
@@ -391,7 +410,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -401,7 +420,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -413,7 +432,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "31",
+   "id": "33",
    "metadata": {},
    "source": [
     "We choose the BUMPS Levenberg-Marquardt minimizer as a fast local\n",
@@ -424,7 +443,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -434,7 +453,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -444,7 +463,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -454,7 +473,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -463,7 +482,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "36",
+   "id": "38",
    "metadata": {},
    "source": [
     "The correlation plot shows how strongly the fitted parameters move\n",
@@ -475,7 +494,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -485,7 +504,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -494,7 +513,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "39",
+   "id": "41",
    "metadata": {},
    "source": [
     "## Step 5: Prepare for Bayesian Sampling\n",
@@ -516,7 +535,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -525,7 +544,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "source": [
     "Set fit bounds for all free parameters using the default multiplier of\n",
@@ -537,7 +556,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -547,7 +566,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "source": [
     "Displaying the free parameters again is a convenient way to confirm\n",
@@ -558,7 +577,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -567,7 +586,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "source": [
     "## Step 6: Configure and Run DREAM\n",
@@ -593,7 +612,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -603,7 +622,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -613,7 +632,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -624,7 +643,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -633,7 +652,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "source": [
     "## Step 7: Inspect Bayesian Results\n",
@@ -646,7 +665,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -655,7 +674,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "source": [
     "The correlation and posterior-pair plots are complementary:\n",
@@ -672,7 +691,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -682,7 +701,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -691,7 +710,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "source": [
     "The one-dimensional posterior distributions below make it easier to\n",
@@ -702,7 +721,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "56",
+   "id": "58",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -711,7 +730,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "57",
+   "id": "59",
    "metadata": {},
    "source": [
     "Finally, the posterior predictive plot propagates the sampled parameter\n",
@@ -723,7 +742,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "60",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -732,7 +751,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "source": [
     "A final zoomed measured-vs-calculated plot is useful for checking how\n",
@@ -743,7 +762,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-21.py b/docs/docs/tutorials/ed-21.py
index 13838dbb2..341f4896f 100644
--- a/docs/docs/tutorials/ed-21.py
+++ b/docs/docs/tutorials/ed-21.py
@@ -112,6 +112,13 @@
     adp_iso=1.3916,
 )
 
+# %% [markdown]
+# With the structural model complete, render it to confirm the perovskite
+# framework before configuring the experiment.
+
+# %%
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Step 3: Define the Diffraction Experiment
 #
diff --git a/docs/docs/tutorials/ed-22.ipynb b/docs/docs/tutorials/ed-22.ipynb
index fa0c91566..7df92a7ff 100644
--- a/docs/docs/tutorials/ed-22.ipynb
+++ b/docs/docs/tutorials/ed-22.ipynb
@@ -144,6 +144,25 @@
    "cell_type": "markdown",
    "id": "11",
    "metadata": {},
+   "source": [
+    "Render the structure to confirm the pyrochlore model loaded from CIF as\n",
+    "expected before configuring the experiment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='tbti')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13",
+   "metadata": {},
    "source": [
     "## Step 3: Define the Diffraction Experiment\n",
     "\n",
@@ -155,7 +174,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "12",
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -165,7 +184,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -181,7 +200,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -190,7 +209,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "source": [
     "Link the crystal structure to the experiment and set its scale factor."
@@ -199,7 +218,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -209,7 +228,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "source": [
     "Set the instrument wavelength and starting extinction parameters.\n",
@@ -220,7 +239,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -230,7 +249,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -240,7 +259,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "20",
+   "id": "22",
    "metadata": {},
    "source": [
     "## Step 4: Run an Initial Local Refinement\n",
@@ -260,7 +279,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -279,7 +298,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "24",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -289,7 +308,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "23",
+   "id": "25",
    "metadata": {},
    "source": [
     "We keep using the default LMFIT Levenberg-Marquardt minimizer as a fast local\n",
@@ -300,7 +319,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -310,7 +329,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -319,7 +338,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "26",
+   "id": "28",
    "metadata": {},
    "source": [
     "The fit-results display summarizes the locally refined values and their\n",
@@ -329,7 +348,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -338,7 +357,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "28",
+   "id": "30",
    "metadata": {},
    "source": [
     "The correlation plot shows how strongly the refined parameters move\n",
@@ -350,7 +369,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -360,7 +379,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -369,7 +388,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "31",
+   "id": "33",
    "metadata": {},
    "source": [
     "## Step 5: Prepare for Bayesian Sampling\n",
@@ -393,7 +412,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -402,7 +421,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "33",
+   "id": "35",
    "metadata": {},
    "source": [
     "Set fit bounds for all free parameters using `multiplier=1.5`. In this\n",
@@ -414,7 +433,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -424,7 +443,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "37",
    "metadata": {},
    "source": [
     "Displaying the free parameters again is a convenient way to confirm\n",
@@ -435,7 +454,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -444,7 +463,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "37",
+   "id": "39",
    "metadata": {},
    "source": [
     "## Step 6: Configure and Run emcee\n",
@@ -465,7 +484,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -475,7 +494,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -485,7 +504,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -497,7 +516,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -506,7 +525,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "source": [
     "## Step 7: Inspect Bayesian Results\n",
@@ -519,7 +538,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -528,7 +547,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "source": [
     "The correlation and posterior-pair plots are complementary:\n",
@@ -545,7 +564,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -555,7 +574,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -564,7 +583,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "source": [
     "The one-dimensional posterior distributions below make it easier to\n",
@@ -575,7 +594,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -584,7 +603,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "source": [
     "Finally, the posterior predictive plot propagates the sampled\n",
@@ -595,7 +614,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-22.py b/docs/docs/tutorials/ed-22.py
index 52fd31662..855a791a5 100644
--- a/docs/docs/tutorials/ed-22.py
+++ b/docs/docs/tutorials/ed-22.py
@@ -57,6 +57,13 @@
 # %%
 structure = project.structures['tbti']
 
+# %% [markdown]
+# Render the structure to confirm the pyrochlore model loaded from CIF as
+# expected before configuring the experiment.
+
+# %%
+project.display.structure(struct_name='tbti')
+
 # %% [markdown]
 # ## Step 3: Define the Diffraction Experiment
 #
diff --git a/docs/docs/tutorials/ed-23.ipynb b/docs/docs/tutorials/ed-23.ipynb
index 11a28c791..4a49a859f 100644
--- a/docs/docs/tutorials/ed-23.ipynb
+++ b/docs/docs/tutorials/ed-23.ipynb
@@ -95,6 +95,26 @@
    "cell_type": "markdown",
    "id": "8",
    "metadata": {},
+   "source": [
+    "## View Structure\n",
+    "\n",
+    "Render the Co2SiO4 structure restored from the saved project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='cosio')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10",
+   "metadata": {},
    "source": [
     "## Resume Sequential Analysis\n",
     "\n",
@@ -107,7 +127,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "9",
+   "id": "11",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -116,7 +136,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "10",
+   "id": "12",
    "metadata": {},
    "source": [
     "## Replay Fitted Datasets\n",
@@ -127,7 +147,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "11",
+   "id": "13",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -137,7 +157,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "12",
+   "id": "14",
    "metadata": {},
    "source": [
     "\n",
@@ -147,7 +167,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -157,7 +177,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "source": [
     "## Plot Parameter Evolution\n",
@@ -169,7 +189,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -178,7 +198,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "source": [
     "Plot fit quality metrics vs. temperature."
@@ -187,7 +207,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -207,7 +227,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "source": [
     "Omitting `param` plots every fitted parameter one after another."
@@ -216,7 +236,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-23.py b/docs/docs/tutorials/ed-23.py
index a4dbc8ed7..581a1003a 100644
--- a/docs/docs/tutorials/ed-23.py
+++ b/docs/docs/tutorials/ed-23.py
@@ -29,6 +29,14 @@
 # %%
 project = ed.Project.load(project_dir)
 
+# %% [markdown]
+# ## View Structure
+#
+# Render the Co2SiO4 structure restored from the saved project.
+
+# %%
+project.display.structure(struct_name='cosio')
+
 # %% [markdown]
 # ## Resume Sequential Analysis
 #
diff --git a/docs/docs/tutorials/ed-24.ipynb b/docs/docs/tutorials/ed-24.ipynb
index 904635418..72e16dc06 100644
--- a/docs/docs/tutorials/ed-24.ipynb
+++ b/docs/docs/tutorials/ed-24.ipynb
@@ -99,6 +99,26 @@
    "cell_type": "markdown",
    "id": "8",
    "metadata": {},
+   "source": [
+    "## View Structure\n",
+    "\n",
+    "Render the La0.5Ba0.5CoO3 structure restored from the saved project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10",
+   "metadata": {},
    "source": [
     "## Review the Saved Fit Summary\n",
     "\n",
@@ -110,7 +130,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "9",
+   "id": "11",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -119,7 +139,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "10",
+   "id": "12",
    "metadata": {},
    "source": [
     "## Show Correlations\n",
@@ -130,7 +150,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "11",
+   "id": "13",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -139,7 +159,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "12",
+   "id": "14",
    "metadata": {},
    "source": [
     "## Inspect Posterior Densities and Pair Structure\n",
@@ -151,7 +171,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -161,7 +181,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -170,7 +190,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "source": [
     "## Plot Posterior Predictive Checks\n",
@@ -184,7 +204,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -193,7 +213,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "source": [
     "A zoomed view is useful for checking the propagated uncertainty in a\n",
@@ -203,7 +223,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-24.py b/docs/docs/tutorials/ed-24.py
index f0330bc95..e900b9000 100644
--- a/docs/docs/tutorials/ed-24.py
+++ b/docs/docs/tutorials/ed-24.py
@@ -33,6 +33,14 @@
 # %%
 project = ed.Project.load(project_dir)
 
+# %% [markdown]
+# ## View Structure
+#
+# Render the La0.5Ba0.5CoO3 structure restored from the saved project.
+
+# %%
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Review the Saved Fit Summary
 #
diff --git a/docs/docs/tutorials/ed-25.ipynb b/docs/docs/tutorials/ed-25.ipynb
index d24eecfd3..e1f46e151 100644
--- a/docs/docs/tutorials/ed-25.ipynb
+++ b/docs/docs/tutorials/ed-25.ipynb
@@ -218,6 +218,25 @@
    "cell_type": "markdown",
    "id": "14",
    "metadata": {},
+   "source": [
+    "With the structural model complete, render it to confirm the perovskite\n",
+    "framework before configuring the experiment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16",
+   "metadata": {},
    "source": [
     "## Step 3: Define the Diffraction Experiment\n",
     "\n",
@@ -228,7 +247,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "source": [
     "Download the measured data from the repository. Alternatively, you\n",
@@ -239,7 +258,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -248,7 +267,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "source": [
     "Create the experiment object and specify the sample form, beam mode,\n",
@@ -258,7 +277,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -274,7 +293,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -283,7 +302,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "20",
+   "id": "22",
    "metadata": {},
    "source": [
     "Link the structural phase to the experiment."
@@ -292,7 +311,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -301,7 +320,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "22",
+   "id": "24",
    "metadata": {},
    "source": [
     "Set instrument and peak profile parameters.\n",
@@ -313,7 +332,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -324,7 +343,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +355,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "25",
+   "id": "27",
    "metadata": {},
    "source": [
     "Add background points and excluded regions.\n",
@@ -348,7 +367,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "26",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -361,7 +380,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "27",
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -371,7 +390,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "28",
+   "id": "30",
    "metadata": {},
    "source": [
     "## Step 4: Run an Initial Local Refinement\n",
@@ -391,7 +410,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -401,7 +420,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "30",
+   "id": "32",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -413,7 +432,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "31",
+   "id": "33",
    "metadata": {},
    "source": [
     "We keep LMFIT Levenberg-Marquardt minimizer as a fast local optimizer.\n",
@@ -424,7 +443,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -434,7 +453,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -444,7 +463,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -453,7 +472,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "37",
    "metadata": {},
    "source": [
     "The correlation plot shows how strongly the fitted parameters move\n",
@@ -465,7 +484,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -475,7 +494,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -484,7 +503,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "40",
    "metadata": {},
    "source": [
     "## Step 5: Prepare for Bayesian Sampling\n",
@@ -506,7 +525,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -515,7 +534,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "42",
    "metadata": {},
    "source": [
     "Set fit bounds for all free parameters using the default multiplier of\n",
@@ -527,7 +546,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -537,7 +556,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "source": [
     "Displaying the free parameters again is a convenient way to confirm\n",
@@ -548,7 +567,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -557,7 +576,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "source": [
     "## Step 6: Configure and Run emcee\n",
@@ -578,7 +597,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -588,7 +607,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -598,7 +617,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -610,7 +629,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -619,7 +638,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "source": [
     "## Step 7: Inspect Bayesian Results\n",
@@ -632,7 +651,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -641,7 +660,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "source": [
     "The correlation and posterior-pair plots are complementary:\n",
@@ -658,7 +677,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -668,7 +687,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -677,7 +696,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "source": [
     "The one-dimensional posterior distributions below make it easier to\n",
@@ -688,7 +707,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -697,7 +716,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "56",
+   "id": "58",
    "metadata": {},
    "source": [
     "Finally, the posterior predictive plot propagates the sampled parameter\n",
@@ -709,7 +728,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57",
+   "id": "59",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -718,7 +737,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "58",
+   "id": "60",
    "metadata": {},
    "source": [
     "A final zoomed measured-vs-calculated plot is useful for checking how\n",
@@ -729,7 +748,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-25.py b/docs/docs/tutorials/ed-25.py
index 3a66d1950..2eb8d0a49 100644
--- a/docs/docs/tutorials/ed-25.py
+++ b/docs/docs/tutorials/ed-25.py
@@ -112,6 +112,13 @@
     adp_iso=1.3916,
 )
 
+# %% [markdown]
+# With the structural model complete, render it to confirm the perovskite
+# framework before configuring the experiment.
+
+# %%
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Step 3: Define the Diffraction Experiment
 #
diff --git a/docs/docs/tutorials/ed-26.ipynb b/docs/docs/tutorials/ed-26.ipynb
index 7e14253de..224fd618e 100644
--- a/docs/docs/tutorials/ed-26.ipynb
+++ b/docs/docs/tutorials/ed-26.ipynb
@@ -116,6 +116,26 @@
    "cell_type": "markdown",
    "id": "8",
    "metadata": {},
+   "source": [
+    "## View Structure\n",
+    "\n",
+    "Render the La0.5Ba0.5CoO3 structure restored from the saved project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10",
+   "metadata": {},
    "source": [
     "## Review the Saved Fit Summary\n",
     "\n",
@@ -127,7 +147,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "9",
+   "id": "11",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -136,7 +156,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "10",
+   "id": "12",
    "metadata": {},
    "source": [
     "## Show Correlations\n",
@@ -147,7 +167,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "11",
+   "id": "13",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -156,7 +176,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "12",
+   "id": "14",
    "metadata": {},
    "source": [
     "## Inspect Posterior Densities and Pair Structure\n",
@@ -168,7 +188,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "13",
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -178,7 +198,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -187,7 +207,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "15",
+   "id": "17",
    "metadata": {},
    "source": [
     "## Plot Posterior Predictive Checks\n",
@@ -201,7 +221,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -210,7 +230,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "17",
+   "id": "19",
    "metadata": {},
    "source": [
     "A zoomed view is useful for checking the propagated uncertainty in a\n",
@@ -220,7 +240,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "18",
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -229,7 +249,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "19",
+   "id": "21",
    "metadata": {},
    "source": [
     "## Resume emcee Sampling\n",
@@ -243,7 +263,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -253,7 +273,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "21",
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -262,7 +282,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "22",
+   "id": "24",
    "metadata": {},
    "source": [
     "## Inspect the Resumed Posterior\n",
@@ -273,7 +293,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "23",
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -283,7 +303,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -293,7 +313,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25",
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-26.py b/docs/docs/tutorials/ed-26.py
index 2d72379df..bac28bb82 100644
--- a/docs/docs/tutorials/ed-26.py
+++ b/docs/docs/tutorials/ed-26.py
@@ -50,6 +50,14 @@
 # %%
 project = ed.Project.load(project_dir)
 
+# %% [markdown]
+# ## View Structure
+#
+# Render the La0.5Ba0.5CoO3 structure restored from the saved project.
+
+# %%
+project.display.structure(struct_name='lbco')
+
 # %% [markdown]
 # ## Review the Saved Fit Summary
 #
diff --git a/docs/docs/tutorials/ed-4.ipynb b/docs/docs/tutorials/ed-4.ipynb
index c80f9f46e..d7bb2c771 100644
--- a/docs/docs/tutorials/ed-4.ipynb
+++ b/docs/docs/tutorials/ed-4.ipynb
@@ -677,7 +677,7 @@
    "id": "58",
    "metadata": {},
    "source": [
-    "#### Plot Measured vs Calculated"
+    "#### Plot Structure"
    ]
   },
   {
@@ -686,6 +686,24 @@
    "id": "59",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='pbso4')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "61",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='npd', x_min=35.5, x_max=38.3)"
    ]
@@ -693,7 +711,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-4.py b/docs/docs/tutorials/ed-4.py
index 5c1047360..b6beefa68 100644
--- a/docs/docs/tutorials/ed-4.py
+++ b/docs/docs/tutorials/ed-4.py
@@ -311,6 +311,12 @@
 # %% [markdown]
 # #### Perform Fit
 
+# %% [markdown]
+# #### Plot Structure
+
+# %%
+project.display.structure(struct_name='pbso4')
+
 # %% [markdown]
 # #### Plot Measured vs Calculated
 
diff --git a/docs/docs/tutorials/ed-5.ipynb b/docs/docs/tutorials/ed-5.ipynb
index b51972e87..c60cf0cd0 100644
--- a/docs/docs/tutorials/ed-5.ipynb
+++ b/docs/docs/tutorials/ed-5.ipynb
@@ -426,7 +426,7 @@
     "This section shows the analysis process, including how to set up\n",
     "calculation and fitting engines.\n",
     "\n",
-    "#### Plot Measured vs Calculated"
+    "#### Plot Structure"
    ]
   },
   {
@@ -435,6 +435,24 @@
    "id": "35",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='cosio')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='d20')"
    ]
@@ -442,7 +460,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -451,7 +469,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "37",
+   "id": "39",
    "metadata": {},
    "source": [
     "#### Set Free Parameters"
@@ -460,7 +478,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -483,7 +501,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -504,7 +522,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "42",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -513,7 +531,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -522,7 +540,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "source": [
     "#### Set Constraints\n",
@@ -533,7 +551,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -549,7 +567,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "source": [
     "Set constraints."
@@ -558,7 +576,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "45",
+   "id": "47",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -569,7 +587,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -578,7 +596,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -588,7 +606,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -598,7 +616,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -607,7 +625,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -616,7 +634,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -626,7 +644,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -635,7 +653,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "source": [
     "## Report\n",
diff --git a/docs/docs/tutorials/ed-5.py b/docs/docs/tutorials/ed-5.py
index 95eb36c17..046db1f37 100644
--- a/docs/docs/tutorials/ed-5.py
+++ b/docs/docs/tutorials/ed-5.py
@@ -200,6 +200,12 @@
 # This section shows the analysis process, including how to set up
 # calculation and fitting engines.
 #
+# #### Plot Structure
+
+# %%
+project.display.structure(struct_name='cosio')
+
+# %% [markdown]
 # #### Plot Measured vs Calculated
 
 # %%
diff --git a/docs/docs/tutorials/ed-6.ipynb b/docs/docs/tutorials/ed-6.ipynb
index ccc3f6833..a83b47313 100644
--- a/docs/docs/tutorials/ed-6.ipynb
+++ b/docs/docs/tutorials/ed-6.ipynb
@@ -375,7 +375,7 @@
     "calculation and fitting engines.\n",
     "\n",
     "\n",
-    "#### Plot Measured vs Calculated"
+    "#### Plot Structure"
    ]
   },
   {
@@ -384,6 +384,24 @@
    "id": "31",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='hs')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "33",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='hrpt')"
    ]
@@ -391,7 +409,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "32",
+   "id": "34",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -400,7 +418,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "33",
+   "id": "35",
    "metadata": {},
    "source": [
     "### Perform Fit 1/4\n",
@@ -411,7 +429,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "34",
+   "id": "36",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -424,7 +442,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "35",
+   "id": "37",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -433,7 +451,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "36",
+   "id": "38",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -442,7 +460,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "37",
+   "id": "39",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -451,7 +469,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "38",
+   "id": "40",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -461,7 +479,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -470,7 +488,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "40",
+   "id": "42",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -479,7 +497,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -489,7 +507,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -498,7 +516,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "source": [
     "### Perform Fit 2/4\n",
@@ -509,7 +527,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -524,7 +542,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -533,7 +551,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -542,7 +560,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -551,7 +569,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -561,7 +579,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -570,7 +588,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -579,7 +597,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -589,7 +607,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -598,7 +616,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "source": [
     "### Perform Fit 3/4\n",
@@ -609,7 +627,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -622,7 +640,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -631,7 +649,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "56",
+   "id": "58",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -640,7 +658,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "57",
+   "id": "59",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -649,7 +667,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "60",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -659,7 +677,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -668,7 +686,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -677,7 +695,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "61",
+   "id": "63",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,7 +705,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "62",
+   "id": "64",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -696,7 +714,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "65",
    "metadata": {},
    "source": [
     "### Perform Fit 4/4\n",
@@ -707,7 +725,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -725,7 +743,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "67",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -734,7 +752,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "68",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -743,7 +761,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "69",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -752,7 +770,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -762,7 +780,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "69",
+   "id": "71",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -772,7 +790,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -781,7 +799,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71",
+   "id": "73",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -790,7 +808,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "72",
+   "id": "74",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -800,7 +818,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "73",
+   "id": "75",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -809,7 +827,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "74",
+   "id": "76",
    "metadata": {},
    "source": [
     "## Report\n",
diff --git a/docs/docs/tutorials/ed-6.py b/docs/docs/tutorials/ed-6.py
index 8204d4d76..bea61203e 100644
--- a/docs/docs/tutorials/ed-6.py
+++ b/docs/docs/tutorials/ed-6.py
@@ -176,6 +176,12 @@
 # calculation and fitting engines.
 #
 #
+# #### Plot Structure
+
+# %%
+project.display.structure(struct_name='hs')
+
+# %% [markdown]
 # #### Plot Measured vs Calculated
 
 # %%
diff --git a/docs/docs/tutorials/ed-7.ipynb b/docs/docs/tutorials/ed-7.ipynb
index cf5f0d0e9..843ca694d 100644
--- a/docs/docs/tutorials/ed-7.ipynb
+++ b/docs/docs/tutorials/ed-7.ipynb
@@ -335,7 +335,7 @@
     "This section shows the analysis process, including how to set up\n",
     "calculation and fitting engines.\n",
     "\n",
-    "#### Plot Measured vs Calculated"
+    "#### Plot Structure"
    ]
   },
   {
@@ -344,6 +344,24 @@
    "id": "31",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='si')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "33",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='sepd')\n",
     "project.display.pattern(expt_name='sepd', x_min=23200, x_max=23700)"
@@ -351,7 +369,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "32",
+   "id": "34",
    "metadata": {},
    "source": [
     "### Perform Fit 1/5\n",
@@ -362,7 +380,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "33",
+   "id": "35",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -374,7 +392,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "34",
+   "id": "36",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -383,7 +401,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "35",
+   "id": "37",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -392,7 +410,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "36",
+   "id": "38",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -401,7 +419,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "37",
+   "id": "39",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -411,7 +429,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "38",
+   "id": "40",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -420,7 +438,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "39",
+   "id": "41",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -430,7 +448,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "40",
+   "id": "42",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -439,7 +457,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "41",
+   "id": "43",
    "metadata": {},
    "source": [
     "### Perform Fit 2/5\n",
@@ -450,7 +468,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "42",
+   "id": "44",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -460,7 +478,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "43",
+   "id": "45",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -469,7 +487,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -478,7 +496,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -487,7 +505,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -497,7 +515,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -506,7 +524,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -516,7 +534,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -525,7 +543,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "source": [
     "### Perform Fit 3/5\n",
@@ -536,7 +554,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -546,7 +564,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "source": [
     "Set more parameters to be refined."
@@ -555,7 +573,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -566,7 +584,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -575,7 +593,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -584,7 +602,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "56",
+   "id": "58",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -593,7 +611,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57",
+   "id": "59",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -603,7 +621,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "58",
+   "id": "60",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -612,7 +630,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -622,7 +640,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -631,7 +649,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "61",
+   "id": "63",
    "metadata": {},
    "source": [
     "### Perform Fit 4/5\n",
@@ -642,7 +660,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "62",
+   "id": "64",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -655,7 +673,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "63",
+   "id": "65",
    "metadata": {},
    "source": [
     "Show free parameters after selection."
@@ -664,7 +682,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "64",
+   "id": "66",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -673,7 +691,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "65",
+   "id": "67",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -682,7 +700,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "66",
+   "id": "68",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -692,7 +710,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67",
+   "id": "69",
    "metadata": {},
    "source": [
     "#### Show parameter correlations"
@@ -701,7 +719,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "68",
+   "id": "70",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -710,7 +728,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "69",
+   "id": "71",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -719,7 +737,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "70",
+   "id": "72",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -729,7 +747,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "71",
+   "id": "73",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -739,7 +757,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "72",
+   "id": "74",
    "metadata": {
     "lines_to_next_cell": 2
    },
@@ -750,7 +768,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "73",
+   "id": "75",
    "metadata": {},
    "source": [
     "### Perform Fit 5/5\n",
@@ -761,7 +779,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "74",
+   "id": "76",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -771,7 +789,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "75",
+   "id": "77",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -780,7 +798,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "76",
+   "id": "78",
    "metadata": {},
    "source": [
     "#### Change peak profile type"
@@ -789,7 +807,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "77",
+   "id": "79",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -799,7 +817,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "78",
+   "id": "80",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -809,7 +827,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "79",
+   "id": "81",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -823,7 +841,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "80",
+   "id": "82",
    "metadata": {},
    "source": [
     "#### Add new free parameters"
@@ -832,7 +850,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "81",
+   "id": "83",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -846,7 +864,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "82",
+   "id": "84",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -855,7 +873,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "83",
+   "id": "85",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -865,7 +883,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "84",
+   "id": "86",
    "metadata": {},
    "source": [
     "#### Show parameter correlations"
@@ -874,7 +892,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "85",
+   "id": "87",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -883,7 +901,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "86",
+   "id": "88",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -892,7 +910,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "87",
+   "id": "89",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -902,7 +920,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "88",
+   "id": "90",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-7.py b/docs/docs/tutorials/ed-7.py
index 5f1c3b432..45974a561 100644
--- a/docs/docs/tutorials/ed-7.py
+++ b/docs/docs/tutorials/ed-7.py
@@ -137,6 +137,12 @@
 # This section shows the analysis process, including how to set up
 # calculation and fitting engines.
 #
+# #### Plot Structure
+
+# %%
+project.display.structure(struct_name='si')
+
+# %% [markdown]
 # #### Plot Measured vs Calculated
 
 # %%
diff --git a/docs/docs/tutorials/ed-8.ipynb b/docs/docs/tutorials/ed-8.ipynb
index ebc82e436..b27530631 100644
--- a/docs/docs/tutorials/ed-8.ipynb
+++ b/docs/docs/tutorials/ed-8.ipynb
@@ -620,7 +620,7 @@
    "id": "44",
    "metadata": {},
    "source": [
-    "#### Plot Measured vs Calculated"
+    "#### Plot Structure"
    ]
   },
   {
@@ -629,6 +629,24 @@
    "id": "45",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='ncaf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46",
+   "metadata": {},
+   "source": [
+    "#### Plot Measured vs Calculated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "project.display.pattern(expt_name='wish_5_6')"
    ]
@@ -636,7 +654,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -645,7 +663,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "source": [
     "#### Run Fitting"
@@ -654,7 +672,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -665,7 +683,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -674,7 +692,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -684,7 +702,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -693,7 +711,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "source": [
     "## Report\n",
diff --git a/docs/docs/tutorials/ed-8.py b/docs/docs/tutorials/ed-8.py
index fb92224f5..790c09d51 100644
--- a/docs/docs/tutorials/ed-8.py
+++ b/docs/docs/tutorials/ed-8.py
@@ -329,6 +329,12 @@
 expt47.peak.exp_decay_beta_1.free = True
 expt47.peak.exp_rise_alpha_1.free = True
 
+# %% [markdown]
+# #### Plot Structure
+
+# %%
+project.display.structure(struct_name='ncaf')
+
 # %% [markdown]
 # #### Plot Measured vs Calculated
 
diff --git a/docs/docs/tutorials/ed-9.ipynb b/docs/docs/tutorials/ed-9.ipynb
index 25a26b141..6737251b3 100644
--- a/docs/docs/tutorials/ed-9.ipynb
+++ b/docs/docs/tutorials/ed-9.ipynb
@@ -496,6 +496,25 @@
    "cell_type": "markdown",
    "id": "43",
    "metadata": {},
+   "source": [
+    "#### Plot Structures"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project.display.structure(struct_name='lbco')\n",
+    "project.display.structure(struct_name='si')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45",
+   "metadata": {},
    "source": [
     "#### Set Excluded Regions\n",
     "\n",
@@ -505,7 +524,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "44",
+   "id": "46",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -514,7 +533,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "45",
+   "id": "47",
    "metadata": {},
    "source": [
     "Add excluded regions."
@@ -523,7 +542,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46",
+   "id": "48",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -533,7 +552,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "47",
+   "id": "49",
    "metadata": {},
    "source": [
     "Show excluded regions."
@@ -542,7 +561,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "48",
+   "id": "50",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -551,7 +570,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "49",
+   "id": "51",
    "metadata": {},
    "source": [
     "Show measured data after adding excluded regions."
@@ -560,7 +579,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "50",
+   "id": "52",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -569,7 +588,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "51",
+   "id": "53",
    "metadata": {},
    "source": [
     "Show experiment as CIF."
@@ -578,7 +597,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "52",
+   "id": "54",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -587,7 +606,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "53",
+   "id": "55",
    "metadata": {},
    "source": [
     "## Perform Analysis\n",
@@ -603,7 +622,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "54",
+   "id": "56",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -616,7 +635,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "55",
+   "id": "57",
    "metadata": {},
    "source": [
     "Set experiment parameters to be optimized."
@@ -625,7 +644,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "56",
+   "id": "58",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -646,7 +665,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "57",
+   "id": "59",
    "metadata": {},
    "source": [
     "#### Perform Fit"
@@ -655,7 +674,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "58",
+   "id": "60",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -666,7 +685,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "59",
+   "id": "61",
    "metadata": {},
    "source": [
     "#### Plot Measured vs Calculated"
@@ -675,7 +694,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "60",
+   "id": "62",
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/docs/tutorials/ed-9.py b/docs/docs/tutorials/ed-9.py
index 383670730..be0cfa6ff 100644
--- a/docs/docs/tutorials/ed-9.py
+++ b/docs/docs/tutorials/ed-9.py
@@ -221,6 +221,13 @@
 # %%
 project.experiments.add(experiment)
 
+# %% [markdown]
+# #### Plot Structures
+
+# %%
+project.display.structure(struct_name='lbco')
+project.display.structure(struct_name='si')
+
 # %% [markdown]
 # #### Set Excluded Regions
 #

From 8a7345b999e3761a6bddca6df4e36695315cdf98 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 16:03:46 +0200
Subject: [PATCH 106/160] Frame the raster structure image with a container
 border

---
 .../display/structure/renderers/raster.py     | 15 +++++++
 .../structure/renderers/test_raster.py        | 39 +++++++++++++++----
 2 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index c30883edc..3e0fdf0fe 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -54,6 +54,8 @@
 _SPEC_STRENGTH = 0.28  # small, subtle highlight (not a hard white spot)
 _LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
 _LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
+_BORDER_RGB = (217, 217, 217)  # interactive view's rgba(128,128,128,0.3) frame over white
+_BORDER_PX = 3  # subtle hairline frame, at canvas resolution
 # Axis-arrow proportions, as fractions of the fit extent, so the arrows
 # are a constant on-screen size in every cell (mirrors the Three.js
 # defaults). The fit extent is ~2x the Three.js half-height reference,
@@ -397,10 +399,23 @@ def _compose_png(
             RasterStructureRenderer._draw_axis_labels(draw, scene.axes, project)
         if scene.legend:
             RasterStructureRenderer._draw_legend(draw, scene.legend)
+        RasterStructureRenderer._draw_border(draw, image.size)
         buffer = io.BytesIO()
         image.save(buffer, format='PNG')
         return buffer.getvalue()
 
+    @staticmethod
+    def _draw_border(draw: ImageDraw.ImageDraw, size: tuple[int, int]) -> None:
+        """
+        Frame the canvas to match the interactive view's container.
+        """
+        width, height = size
+        draw.rectangle(
+            (0, 0, width - 1, height - 1),
+            outline=_BORDER_RGB,
+            width=_BORDER_PX,
+        )
+
     @staticmethod
     def _draw_axis_labels(draw: ImageDraw.ImageDraw, axes: AxisTriad, project: Projector) -> None:
         """Place each axis letter just beyond its tip, always on top."""
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
index fa5596b96..bd84d4e2b 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
@@ -40,9 +40,22 @@ def _pixels(png: bytes) -> np.ndarray:
     return np.asarray(_open(png))
 
 
+_FRAME_INSET = 8  # crop past the always-drawn frame border when inspecting content
+
+
+def _interior(png: bytes) -> np.ndarray:
+    """Return the canvas interior, excluding the always-drawn frame border."""
+    return _pixels(png)[_FRAME_INSET:-_FRAME_INSET, _FRAME_INSET:-_FRAME_INSET]
+
+
 def _has_drawn_pixels(png: bytes) -> bool:
-    """True when any pixel departs from the white background."""
-    return bool((_pixels(png) != 255).any())
+    """True when any interior pixel departs from the white background."""
+    return bool((_interior(png) != 255).any())
+
+
+def _has_blank_interior(png: bytes) -> bool:
+    """True when the interior is pristine white, frame border excluded."""
+    return bool((_interior(png) == 255).all())
 
 
 def _atom_scene() -> StructureScene:
@@ -180,17 +193,27 @@ def test_atom_is_drawn(self):
         assert _has_drawn_pixels(png)
 
     def test_empty_scene_is_blank(self):
-        # No primitives and no features -> a pristine white canvas.
+        # No primitives and no features -> a blank interior (only the frame).
+        scene = StructureScene(cell_basis=CUBIC_BASIS)
+        png = RasterStructureRenderer().render_png(scene, features=frozenset())
+        assert _has_blank_interior(png)
+
+    def test_frame_border_is_drawn(self):
+        # Every render is framed to mirror the interactive view's container
+        # border, even when the scene carries no structure content.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset())
-        assert bool((_pixels(png) == 255).all())
+        pixels = _pixels(png)
+        assert tuple(pixels[0, 0]) != (255, 255, 255)
+        assert tuple(pixels[-1, -1]) != (255, 255, 255)
+        assert _has_blank_interior(png)
 
     def test_feature_gating_skips_unrequested_atoms(self):
         # The scene has an atom, but 'atoms' is absent from the feature
         # set, so nothing is drawn.
         scene = _atom_scene()
         png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
-        assert bool((_pixels(png) == 255).all())
+        assert _has_blank_interior(png)
 
     def test_unknown_feature_names_are_ignored(self):
         # Feature names outside SUPPORTED never trigger a draw and never
@@ -237,13 +260,13 @@ def test_axes_feature_without_triad_is_blank(self):
         # 'axes' requested but scene.axes is None -> no crash, blank.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset({'axes'}))
-        assert bool((_pixels(png) == 255).all())
+        assert _has_blank_interior(png)
 
     def test_cell_feature_without_edges_is_blank(self):
         # 'cell' requested but scene.cell_edges is None -> no crash.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
-        assert bool((_pixels(png) == 255).all())
+        assert _has_blank_interior(png)
 
     def test_full_scene_renders(self):
         png = RasterStructureRenderer().render_png(
@@ -339,7 +362,7 @@ def test_no_legend_leaves_top_left_white(self):
         # Without a legend, the empty scene stays fully white.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset())
-        assert bool((_pixels(png) == 255).all())
+        assert _has_blank_interior(png)
 
 
 class TestViewBasis:

From b8f75157efb7a2561e630cdd6f4c7d293a990fe6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 16:03:46 +0200
Subject: [PATCH 107/160] Flatten report headings and widen the structure
 figure

---
 src/easydiffraction/report/templates/html/report.html.j2 | 2 --
 src/easydiffraction/report/templates/tex/report.tex.j2   | 6 +-----
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/easydiffraction/report/templates/html/report.html.j2 b/src/easydiffraction/report/templates/html/report.html.j2
index eabd0fc3e..1f9069788 100644
--- a/src/easydiffraction/report/templates/html/report.html.j2
+++ b/src/easydiffraction/report/templates/html/report.html.j2
@@ -141,7 +141,6 @@
         <h3>{{ structure.id }}</h3>
 
         {% if structure_figures[structure.id] %}
-        <h4>Structure view</h4>
         <div class="figure">{{ structure_figures[structure.id] | safe }}</div>
         {% endif %}
 
@@ -206,7 +205,6 @@
         <h3>{{ experiment.id }}</h3>
 
         {% if fit_figures[experiment.id] %}
-        <h4>Fit quality</h4>
         <div class="figure">{{ fit_figures[experiment.id] | safe }}</div>
         {% endif %}
 
diff --git a/src/easydiffraction/report/templates/tex/report.tex.j2 b/src/easydiffraction/report/templates/tex/report.tex.j2
index 4c16afdc2..de0614aa5 100644
--- a/src/easydiffraction/report/templates/tex/report.tex.j2
+++ b/src/easydiffraction/report/templates/tex/report.tex.j2
@@ -195,11 +195,9 @@ Minimizer & {{ tex_software_name(analysis.software.minimizer) }} & {{ analysis.s
 \subsection{ {{- structure.id | tex -}} }
 
 {% if tex.structure_figure_paths[structure.id] %}
-\subsubsection*{Structure view}
-
 \begin{figure}[H]
 \centering
-\includegraphics[width=0.6\linewidth]{ {{- tex.structure_figure_paths[structure.id] -}} }
+\includegraphics[width=\linewidth]{ {{- tex.structure_figure_paths[structure.id] -}} }
 \end{figure}
 {% endif %}
 
@@ -249,8 +247,6 @@ Minimizer & {{ tex_software_name(analysis.software.minimizer) }} & {{ analysis.s
 \subsection{ {{- experiment.id | tex -}} }
 
 {% if experiment.fit_data and tex.fit_figure_paths[experiment.id] %}
-\subsubsection*{Fit quality}
-
 \begin{figure}[H]
 \centering
 Measured and calculated fit for {{ experiment.id | tex }}.

From 818831fa6256cfb555dc1c53951286c595f7de25 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 16:36:18 +0200
Subject: [PATCH 108/160] Frame structure figure within half page height, full
 width

---
 .../display/structure/renderers/raster.py     | 15 -------
 .../report/templates/tex/report.tex.j2        |  7 +++-
 .../structure/renderers/test_raster.py        | 39 ++++---------------
 3 files changed, 14 insertions(+), 47 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index 3e0fdf0fe..c30883edc 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -54,8 +54,6 @@
 _SPEC_STRENGTH = 0.28  # small, subtle highlight (not a hard white spot)
 _LABEL_FRAC = 0.040  # axis-letter font size, as a fraction of the canvas
 _LEGEND_FRAC = 0.032  # legend font size, as a fraction of the canvas
-_BORDER_RGB = (217, 217, 217)  # interactive view's rgba(128,128,128,0.3) frame over white
-_BORDER_PX = 3  # subtle hairline frame, at canvas resolution
 # Axis-arrow proportions, as fractions of the fit extent, so the arrows
 # are a constant on-screen size in every cell (mirrors the Three.js
 # defaults). The fit extent is ~2x the Three.js half-height reference,
@@ -399,23 +397,10 @@ def _compose_png(
             RasterStructureRenderer._draw_axis_labels(draw, scene.axes, project)
         if scene.legend:
             RasterStructureRenderer._draw_legend(draw, scene.legend)
-        RasterStructureRenderer._draw_border(draw, image.size)
         buffer = io.BytesIO()
         image.save(buffer, format='PNG')
         return buffer.getvalue()
 
-    @staticmethod
-    def _draw_border(draw: ImageDraw.ImageDraw, size: tuple[int, int]) -> None:
-        """
-        Frame the canvas to match the interactive view's container.
-        """
-        width, height = size
-        draw.rectangle(
-            (0, 0, width - 1, height - 1),
-            outline=_BORDER_RGB,
-            width=_BORDER_PX,
-        )
-
     @staticmethod
     def _draw_axis_labels(draw: ImageDraw.ImageDraw, axes: AxisTriad, project: Projector) -> None:
         """Place each axis letter just beyond its tip, always on top."""
diff --git a/src/easydiffraction/report/templates/tex/report.tex.j2 b/src/easydiffraction/report/templates/tex/report.tex.j2
index de0614aa5..548dfbcd4 100644
--- a/src/easydiffraction/report/templates/tex/report.tex.j2
+++ b/src/easydiffraction/report/templates/tex/report.tex.j2
@@ -41,6 +41,7 @@
 \definecolor{rowshade}{RGB}{ {{- report_style.row_rgb -}} }
 \definecolor{tableborder}{RGB}{ {{- report_style.axis_rgb -}} }
 \definecolor{linkblue}{RGB}{ {{- report_style.link_rgb -}} }
+\definecolor{structframe}{RGB}{217, 217, 217}  % structure-figure frame; matches the interactive view
 \arrayrulecolor{tableborder}
 \hypersetup{colorlinks=true, urlcolor=linkblue}
 
@@ -197,7 +198,11 @@ Minimizer & {{ tex_software_name(analysis.software.minimizer) }} & {{ analysis.s
 {% if tex.structure_figure_paths[structure.id] %}
 \begin{figure}[H]
 \centering
-\includegraphics[width=\linewidth]{ {{- tex.structure_figure_paths[structure.id] -}} }
+\begingroup
+\setlength{\fboxsep}{0pt}
+\setlength{\fboxrule}{0.4pt}
+\fcolorbox{structframe}{white}{\makebox[\dimexpr\linewidth-2\fboxrule\relax][c]{\includegraphics[width=\dimexpr\linewidth-2\fboxrule\relax,height=0.5\textheight,keepaspectratio]{ {{- tex.structure_figure_paths[structure.id] -}} }}}
+\endgroup
 \end{figure}
 {% endif %}
 
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
index bd84d4e2b..fa5596b96 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
@@ -40,22 +40,9 @@ def _pixels(png: bytes) -> np.ndarray:
     return np.asarray(_open(png))
 
 
-_FRAME_INSET = 8  # crop past the always-drawn frame border when inspecting content
-
-
-def _interior(png: bytes) -> np.ndarray:
-    """Return the canvas interior, excluding the always-drawn frame border."""
-    return _pixels(png)[_FRAME_INSET:-_FRAME_INSET, _FRAME_INSET:-_FRAME_INSET]
-
-
 def _has_drawn_pixels(png: bytes) -> bool:
-    """True when any interior pixel departs from the white background."""
-    return bool((_interior(png) != 255).any())
-
-
-def _has_blank_interior(png: bytes) -> bool:
-    """True when the interior is pristine white, frame border excluded."""
-    return bool((_interior(png) == 255).all())
+    """True when any pixel departs from the white background."""
+    return bool((_pixels(png) != 255).any())
 
 
 def _atom_scene() -> StructureScene:
@@ -193,27 +180,17 @@ def test_atom_is_drawn(self):
         assert _has_drawn_pixels(png)
 
     def test_empty_scene_is_blank(self):
-        # No primitives and no features -> a blank interior (only the frame).
-        scene = StructureScene(cell_basis=CUBIC_BASIS)
-        png = RasterStructureRenderer().render_png(scene, features=frozenset())
-        assert _has_blank_interior(png)
-
-    def test_frame_border_is_drawn(self):
-        # Every render is framed to mirror the interactive view's container
-        # border, even when the scene carries no structure content.
+        # No primitives and no features -> a pristine white canvas.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset())
-        pixels = _pixels(png)
-        assert tuple(pixels[0, 0]) != (255, 255, 255)
-        assert tuple(pixels[-1, -1]) != (255, 255, 255)
-        assert _has_blank_interior(png)
+        assert bool((_pixels(png) == 255).all())
 
     def test_feature_gating_skips_unrequested_atoms(self):
         # The scene has an atom, but 'atoms' is absent from the feature
         # set, so nothing is drawn.
         scene = _atom_scene()
         png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
-        assert _has_blank_interior(png)
+        assert bool((_pixels(png) == 255).all())
 
     def test_unknown_feature_names_are_ignored(self):
         # Feature names outside SUPPORTED never trigger a draw and never
@@ -260,13 +237,13 @@ def test_axes_feature_without_triad_is_blank(self):
         # 'axes' requested but scene.axes is None -> no crash, blank.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset({'axes'}))
-        assert _has_blank_interior(png)
+        assert bool((_pixels(png) == 255).all())
 
     def test_cell_feature_without_edges_is_blank(self):
         # 'cell' requested but scene.cell_edges is None -> no crash.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset({'cell'}))
-        assert _has_blank_interior(png)
+        assert bool((_pixels(png) == 255).all())
 
     def test_full_scene_renders(self):
         png = RasterStructureRenderer().render_png(
@@ -362,7 +339,7 @@ def test_no_legend_leaves_top_left_white(self):
         # Without a legend, the empty scene stays fully white.
         scene = StructureScene(cell_basis=CUBIC_BASIS)
         png = RasterStructureRenderer().render_png(scene, features=frozenset())
-        assert _has_blank_interior(png)
+        assert bool((_pixels(png) == 255).all())
 
 
 class TestViewBasis:

From a565ee6508cda45931f00c69df87e85e082f357f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 18:11:38 +0200
Subject: [PATCH 109/160] Document report figure layout in summary-rendering
 ADR

---
 .../adrs/accepted/project-summary-rendering.md   | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index 8804d9eaf..550c76c7d 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -832,9 +832,11 @@ rather than maintaining hand-written summary tables:
   descriptors first as key-value tables and loop items as loop tables
   with headers. Experiment data categories (`pd_data`, `total_data`,
   `refln`) are skipped because they are plotted or too large for report
-  tables. The fit-quality plot remains the first experiment
-  sub-subsection, and publication metadata remains source data only — it
-  is not added to HTML, TeX, or PDF reports.
+  tables. The structure view and the fit-quality plot sit directly under
+  their parent subsection — the structure or experiment record (e.g.
+  `3.1 lbco`, `4.1 hrpt`) — as its first content, with no extra
+  sub-subsection heading. Publication metadata remains source data only
+  — it is not added to HTML, TeX, or PDF reports.
 - **DisplayHandler names and units.** All table labels and units use the
   per-context `DisplayHandler` resolution chain, so TeX sees LaTeX names
   (`$2\theta$ offset`, `$U_{\mathrm{iso}}$`), HTML sees MathJax-capable
@@ -869,6 +871,14 @@ rather than maintaining hand-written summary tables:
   report styling code and passed to HTML CSS, TeX tables, and
   Plotly/pgfplots figures. Body rows alternate with the first body row
   filled, regardless of whether the table has a header.
+- **Framed structure figure.** In the TeX/PDF report the structure view
+  is wrapped in an `\fcolorbox` that is always the full line width; the
+  raster PNG is scaled to fit within half the text height or the line
+  width, whichever binds first (aspect preserved), so the box height
+  follows the image automatically. The frame uses the same light grey as
+  the interactive view's container, keeping the static report figure and
+  the Jupyter view visually consistent. The HTML report keeps the
+  interactive Three.js view, which already draws that container border.
 - **Predictable table widths.** HTML and TeX key-value tables use at
   least half of the available text width. Loop tables are classified
   from their rendered content: compact loops use half width, while wider

From 67a99967f01ef51c54553e3065fcb3e891c03557 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 18:38:34 +0200
Subject: [PATCH 110/160] Refresh structures before display scene building

---
 src/easydiffraction/project/display.py        |  2 +
 .../easydiffraction/project/test_display.py   | 83 +++++++++++++++++++
 2 files changed, 85 insertions(+)

diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 3b87c27d8..6da991c40 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -513,6 +513,7 @@ def structure(
         )
 
         structure = self._project.structures[struct_name]
+        structure._update_categories()
         availability = structure_feature_availability(
             structure, style=self._project.structure_style
         )
@@ -542,6 +543,7 @@ def show_structure_options(self, struct_name: str) -> None:
         )
 
         structure = self._project.structures[struct_name]
+        structure._update_categories()
         availability = structure_feature_availability(
             structure, style=self._project.structure_style
         )
diff --git a/tests/unit/easydiffraction/project/test_display.py b/tests/unit/easydiffraction/project/test_display.py
index 1c635823e..2dd0d27fa 100644
--- a/tests/unit/easydiffraction/project/test_display.py
+++ b/tests/unit/easydiffraction/project/test_display.py
@@ -11,8 +11,11 @@
 
 from easydiffraction.datablocks.experiment.item.enums import SampleFormEnum
 from easydiffraction.datablocks.experiment.item.enums import ScatteringTypeEnum
+from easydiffraction.datablocks.structure.item.base import Structure
 from easydiffraction.display.progress import ACTIVITY_LABEL_PROCESSING
 from easydiffraction.display.plotting import _MeasVsCalcPlotOptions
+from easydiffraction.display.structure.builder import FeatureAvailability
+from easydiffraction.project.categories.structure_style.default import StructureStyle
 from easydiffraction.project.display import PatternOptionStatus
 from easydiffraction.project.display import ProjectDisplay
 from easydiffraction.utils.enums import VerbosityEnum
@@ -71,6 +74,24 @@ def _recorder(*args, **kwargs):
     return project, calls
 
 
+def _make_structure_display_project(structure: object) -> SimpleNamespace:
+    return SimpleNamespace(
+        structures={'lbco': structure},
+        structure_style=StructureStyle(),
+        structure_view=SimpleNamespace(
+            view_range=lambda: ((0.0, 1.0), (0.0, 1.0), (0.0, 1.0)),
+            show_labels=SimpleNamespace(value=False),
+            show_moments=SimpleNamespace(value=False),
+        ),
+        rendering_structure=SimpleNamespace(
+            viewer=SimpleNamespace(
+                render=lambda scene, *, features: '<html></html>',
+                supported_features=lambda: frozenset({'atoms', 'bonds', 'cell', 'axes'}),
+            ),
+        ),
+    )
+
+
 def _make_statuses(
     *,
     measured: bool = False,
@@ -663,3 +684,65 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
     assert captured['columns_alignment'] == ['left', 'left', 'center', 'center', 'left']
     assert captured['columns_data'][0][0] == 'auto'
     assert captured['columns_data'][1][0] == 'measured'
+
+
+def test_structure_updates_categories_before_building_scene(monkeypatch, tmp_path):
+    structure = Structure(name='lbco')
+    structure.space_group.name_h_m = 'P m -3 m'
+    structure.cell.length_a = 3.88
+    assert structure.cell.length_b.value == 10.0
+
+    project = _make_structure_display_project(structure)
+    display = ProjectDisplay(project)
+    captured: dict[str, object] = {}
+
+    def fake_build_scene(structure_arg, *, style, view_range, features):
+        captured['cell_lengths'] = (
+            structure_arg.cell.length_a.value,
+            structure_arg.cell.length_b.value,
+            structure_arg.cell.length_c.value,
+        )
+        captured['style'] = style
+        captured['view_range'] = view_range
+        captured['features'] = features
+        return SimpleNamespace()
+
+    monkeypatch.setattr(
+        'easydiffraction.display.structure.builder.build_scene',
+        fake_build_scene,
+    )
+
+    display.structure('lbco', path=str(tmp_path / 'lbco.html'))
+
+    assert captured['cell_lengths'] == pytest.approx((3.88, 3.88, 3.88))
+    assert captured['style'] is project.structure_style
+    assert captured['view_range'] == ((0.0, 1.0), (0.0, 1.0), (0.0, 1.0))
+    assert captured['features'] == frozenset({'cell', 'axes'})
+
+
+def test_show_structure_options_updates_categories_before_availability(monkeypatch):
+    calls: list[str] = []
+    structure = SimpleNamespace(updated=False)
+
+    def update_categories():
+        calls.append('update')
+        structure.updated = True
+
+    def fake_structure_feature_availability(structure_arg, *, style):
+        calls.append('availability')
+        assert structure_arg.updated is True
+        return FeatureAvailability(frozenset({'cell', 'axes'}), ())
+
+    structure._update_categories = update_categories
+    project = _make_structure_display_project(structure)
+    display = ProjectDisplay(project)
+
+    monkeypatch.setattr(
+        'easydiffraction.display.structure.builder.structure_feature_availability',
+        fake_structure_feature_availability,
+    )
+    monkeypatch.setattr('easydiffraction.project.display.render_table', lambda **kwargs: None)
+
+    display.show_structure_options('lbco')
+
+    assert calls == ['update', 'availability']

From 85ab48f2c88a321a3c2946a3155e6f89579ddc61 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 19:12:36 +0200
Subject: [PATCH 111/160] Clean up implemented ADR and plan docs

---
 .../crysview-structure-visualization.md       | 184 +++++++++---------
 .../crysview-threejs-demo.html                |   0
 .../minimizer-category-consolidation.md       |   8 +-
 .../accepted/project-summary-rendering.md     |  66 +++----
 .../value-selector-discovery.md               |   2 +-
 docs/dev/adrs/index.md                        |   4 +-
 .../plans/crysview-structure-visualization.md |  57 +++---
 docs/dev/plans/iucr-cif-tag-alignment.md      |   7 +
 docs/dev/plans/project-summary-rendering.md   |   6 +
 docs/dev/plans/structure-view-settings.md     |  23 ++-
 .../user-guide/analysis-workflow/model.md     |   2 +-
 11 files changed, 177 insertions(+), 182 deletions(-)
 rename docs/dev/adrs/{suggestions => accepted}/crysview-structure-visualization.md (85%)
 rename docs/dev/adrs/{suggestions => accepted}/crysview-threejs-demo.html (100%)
 rename docs/dev/adrs/{suggestions => accepted}/value-selector-discovery.md (99%)

diff --git a/docs/dev/adrs/suggestions/crysview-structure-visualization.md b/docs/dev/adrs/accepted/crysview-structure-visualization.md
similarity index 85%
rename from docs/dev/adrs/suggestions/crysview-structure-visualization.md
rename to docs/dev/adrs/accepted/crysview-structure-visualization.md
index 64cd2ee2f..8fa04b273 100644
--- a/docs/dev/adrs/suggestions/crysview-structure-visualization.md
+++ b/docs/dev/adrs/accepted/crysview-structure-visualization.md
@@ -2,15 +2,14 @@
 
 ## Status
 
-Proposed.
+Accepted.
 
-**Date:** 2026-05-29
+**Date:** 2026-05-31
 
 ## Context
 
 EasyDiffraction refines crystal structures but offers no interactive 3D
-view of them. The accepted
-[Display UX Facade](../../../docs/dev/adrs/accepted/display-ux.md) ADR
+view of them. The accepted [Display UX Facade](display-ux.md) ADR
 defines `project.display` for 1D pattern charts and for parameter, fit,
 and posterior tables and plots, but nothing spatial: there is no way to
 look at the atoms, the unit cell, or the anisotropic displacement
@@ -65,10 +64,10 @@ safe defaults take priority over developer ergonomics.
 
 ## Decision
 
-This is the first version of the decision, written for review. The
-points that earlier reviews left open are now settled in the sections
-below; the remaining genuinely-open items are listed under Open
-Questions.
+This ADR records the accepted first version of the structure viewer.
+Points that earlier reviews left open are settled in the sections below;
+the historical open questions are retained only to document the final
+choices.
 
 ### 1. Build a renderer-neutral structure scene
 
@@ -201,8 +200,8 @@ persisted and overridable per call:
 # Persisted per-axis bounds — six scalar settings, like the cell
 # parameters (defaults 0 and 1 on each axis = the full cell, borders
 # included):
-project.rendering_structure.range_a_max = 2                       # two cells along a
-project.rendering_structure.range_c_min, project.rendering_structure.range_c_max = -0.2, 1.2   # margin on c
+project.structure_view.range_a_max = 2                       # two cells along a
+project.structure_view.range_c_min, project.structure_view.range_c_max = -0.2, 1.2   # margin on c
 
 # A convenience tuple overrides the persisted range for one call only:
 project.display.structure(
@@ -291,9 +290,10 @@ A scientist picks one model and one scheme instead of editing dozens of
 per-element rows, which keeps the view consistent and reproducible:
 
 ```python
-project.style.atom_view = 'adp'           # vdw | covalent | ionic | adp (default adp)
-project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
-project.style.show_supported()            # accepted values per setting
+project.structure_style.atom_view = 'adp'      # vdw | covalent | ionic | adp
+project.structure_style.color_scheme = 'jmol'  # jmol | vesta
+project.structure_style.atom_view.show_supported()
+project.structure_style.color_scheme.show_supported()
 ```
 
 How an atom is sized and shaped is a single **display-style switch**,
@@ -330,7 +330,7 @@ renders as covalent-radius spheres.
 > redundant choice. The atomic radii remain in the element database,
 > unused by the public selector. The `adp` view still uses covalent
 > radii for the ball fallback and for mixed-occupancy sites. CIF field:
-> `_style.atom_view`.
+> `_structure_style.atom_view`.
 
 In `'adp'` the surfaces are drawn at one **probability level**,
 `adp_probability`, a fraction in the open interval (0, 1) — not a
@@ -351,25 +351,26 @@ nearer atom's nearest-neighbour distance — so the large covalent radii
 of ionic A-site cations do not bond to every surrounding anion (a
 heuristic stop-gap; see open issue #108 for the full near-neighbour
 approach). These two cutoffs live on the **structure** and persist in
-the structure's own CIF (see section 8), not in `project.style`. The
-`atom_view` radius models (vdw / covalent / ionic) change only the
-rendered sphere _size_ — they never decide which bonds appear; bond
-detection is governed solely by the `_geom` cutoffs and the per-type
-bonding radius. Version 1 draws bonds computed on the fly from this rule
-while the scene is built and persists no bond table. The full computed
-bond and angle geometry — the standard `_geom_bond` and `_geom_angle`
-loops, with distances, angles, symmetry codes, and standard
-uncertainties — is a separate, related feature that reuses the same
-symmetry-expansion and distance math (see Deferred Work).
+the structure's own CIF (see section 8), not in
+`project.structure_style`. The `atom_view` radius models (vdw / covalent
+/ ionic) change only the rendered sphere _size_ — they never decide
+which bonds appear; bond detection is governed solely by the `_geom`
+cutoffs and the per-type bonding radius. Version 1 draws bonds computed
+on the fly from this rule while the scene is built and persists no bond
+table. The full computed bond and angle geometry — the standard
+`_geom_bond` and `_geom_angle` loops, with distances, angles, symmetry
+codes, and standard uncertainties — is a separate, related feature that
+reuses the same symmetry-expansion and distance math (see Deferred
+Work).
 
 `atom_view` and `color_scheme` are finite, closed value sets, so each is
 a `(str, Enum)` validated on assignment per the
-[Enum-Backed Closed Value Sets](../../../docs/dev/adrs/accepted/enum-backed-closed-values.md)
-ADR, and `project.style.show_supported()` lists the accepted values for
-every styling setting — the same discoverability the engine selectors
-give through `show_supported()`. `style` is a plain category, not a
-switchable one: it has no factory-swapped `type`, only these validated
-value settings.
+[Enum-Backed Closed Value Sets](enum-backed-closed-values.md) ADR, and
+each selector lists its accepted values through descriptor-level
+`show_supported()` — for example
+`project.structure_style.atom_view.show_supported()`. `structure_style`
+is a plain category, not a switchable one: it has no factory-swapped
+`type`, only these validated value settings.
 
 The defaults are the **`adp`** atom view and the **Jmol/CPK** colour
 scheme, so the view looks right with no configuration. Covalent radii —
@@ -494,22 +495,13 @@ near-vertical edges that the column-major chart code cannot express.
 
 ### 8. Configuring what is shown and how
 
-> **Updated.** This configuration surface was reorganised by the
-> [`structure-view-settings`](../../plans/structure-view-settings.md)
-> plan and the [`value-selector-discovery`](value-selector-discovery.md)
-> ADR; the examples below predate that split and are kept as historical
-> design context. The current surface is three flat categories:
-> `project.rendering_structure` (engine `type` only, CIF
-> `_rendering_structure.type`), `project.structure_view` (`show_labels`,
-> `show_moments`, `range_*`, CIF `_structure_view.*`), and
-> `project.structure_style` (`atom_view`, `color_scheme`,
-> `adp_probability`, `atom_scale`, CIF `_structure_style.*`).
-> Per-selector discovery replaces `project.style.show_supported()` —
-> e.g. `project.structure_style.atom_view.show_supported()`.
-
-The view has two configuration axes — _what_ is shown (content) and
-_how_ it is drawn (engine plus styling) — both reachable from Python and
-persisted to CIF.
+The view has three configuration axes — _which engine_ draws it, _what_
+is shown, and _how_ it is styled. They are three flat project
+categories, all persisted to CIF:
+
+- `project.rendering_structure` selects the renderer engine only.
+- `project.structure_view` stores durable content and region settings.
+- `project.structure_style` stores durable appearance settings.
 
 ```python
 # How: renderer engine
@@ -517,11 +509,12 @@ project.rendering_structure.type = 'auto'           # default: 'threejs' in Jupy
 project.rendering_structure.show_supported()
 
 # How: standard styling models, not per-element values (visual only)
-project.style.atom_view = 'adp'           # vdw | covalent | ionic | adp (default adp)
-project.style.color_scheme = 'jmol'       # jmol | vesta | ... (default jmol)
-project.style.adp_probability = 0.5       # adp only; fraction in (0, 1)
-project.style.atom_scale = 0.3            # radius-model views only; size, sqrt-compressed (0, 1]
-project.style.show_supported()            # accepted values per setting
+project.structure_style.atom_view = 'adp'      # vdw | covalent | ionic | adp
+project.structure_style.color_scheme = 'jmol'  # jmol | vesta
+project.structure_style.adp_probability = 0.5  # ADP probability level (0, 1)
+project.structure_style.atom_scale = 0.3       # overall atom scale (0, 1]
+project.structure_style.atom_view.show_supported()
+project.structure_style.color_scheme.show_supported()
 
 # Which bonds exist: a per-structure geometric property, not styling.
 # Standard cif_core _geom auto-bonding (r_bond defaults to covalent radius):
@@ -541,14 +534,14 @@ project.display.structure(
 # Three.js modebar stays active, so the user can still toggle each
 # feature live afterwards. show_moments stays inert until the structure
 # model carries moment fields (see Deferred Work).
-project.rendering_structure.show_labels = False
-project.rendering_structure.show_moments = True
+project.structure_view.show_labels = False
+project.structure_view.show_moments = True
 
 # What region (persisted): six per-axis fractional bounds (defaults 0 and
 # 1 = full cell, borders included), mirroring the six scalar cell
 # parameters.
-project.rendering_structure.range_a_min = 0
-project.rendering_structure.range_a_max = 1   # range_b_min/max and range_c_min/max likewise
+project.structure_view.range_a_min = 0
+project.structure_view.range_a_max = 1   # range_b_min/max and range_c_min/max likewise
 ```
 
 The persisted equivalent in the project CIF:
@@ -556,19 +549,20 @@ The persisted equivalent in the project CIF:
 ```
 # In the project CIF (project-level view + style):
 _rendering_structure.type           auto
-_rendering_structure.show_labels    false
-_rendering_structure.show_moments   true
-_rendering_structure.range_a_min    0
-_rendering_structure.range_a_max    1
-_rendering_structure.range_b_min    0
-_rendering_structure.range_b_max    1
-_rendering_structure.range_c_min    0
-_rendering_structure.range_c_max    1
-
-_style.atom_view        adp
-_style.color_scheme     jmol
-_style.adp_probability  0.5
-_style.atom_scale       0.3
+
+_structure_view.show_labels    false
+_structure_view.show_moments   true
+_structure_view.range_a_min    0
+_structure_view.range_a_max    1
+_structure_view.range_b_min    0
+_structure_view.range_b_max    1
+_structure_view.range_c_min    0
+_structure_view.range_c_max    1
+
+_structure_style.atom_view        adp
+_structure_style.color_scheme     jmol
+_structure_style.adp_probability  0.5
+_structure_style.atom_scale       0.3
 
 # In the structure (sample) CIF, beside _cell / _atom_site (per-structure):
 _geom.min_bond_distance_cutoff   0.0
@@ -581,28 +575,26 @@ The `_rendering_structure.type` tag follows `_rendering_plot.type` /
 `ascii` in a terminal); `_geom.min_bond_distance_cutoff` and
 `_geom.bond_distance_incr` are the **standard cif_core** bond-cutoff
 tags (`_atom_type.radius_bond` is the standard per-type bonding radius,
-used when present). The `_style.*` and `_rendering_structure.*` tags are
-project-internal app settings whose exact spelling is finalized in the
-implementation plan (see sections 6, 8 and Open Questions).
+used when present). The `_structure_view.*`, `_structure_style.*`, and
+`_rendering_structure.type` tags are project-internal app settings.
 
 Initial visibility resolves in a fixed order, so a reopened project and
 a per-call request behave predictably:
 
 1. **An explicit `include=(...)` tuple wins outright.** The view opens
-   showing exactly those features; persisted
-   `_rendering_structure.show_*` flags are ignored for that call. So
-   `include=('atoms',)` shows only atoms even when `show_labels=True` is
-   persisted.
+   showing exactly those features; persisted `_structure_view.show_*`
+   flags are ignored for that call. So `include=('atoms',)` shows only
+   atoms even when `show_labels=True` is persisted.
 2. **`include='auto'`** — the default, and what a bare `structure()`
    call uses — resolves each feature in turn from: data availability
    first (a feature with no data is off, such as moments without moment
-   fields), then the persisted `_rendering_structure.show_*` flag where
-   one exists, then the built-in default otherwise. Version 1 persists
-   flags only for the two features whose default a scientist most often
-   flips — `show_labels` (off) and `show_moments` (on where data
-   exists); atoms, bonds, cell, and axes follow their built-in 'auto'
-   defaults and are set per call through an explicit `include=` tuple.
-   So `show_labels=True` with `include='auto'` opens with labels on.
+   fields), then the persisted `_structure_view.show_*` flag where one
+   exists, then the built-in default otherwise. Version 1 persists flags
+   only for the two features whose default a scientist most often flips
+   — `show_labels` (off) and `show_moments` (on where data exists);
+   atoms, bonds, cell, and axes follow their built-in 'auto' defaults
+   and are set per call through an explicit `include=` tuple. So
+   `show_labels=True` with `include='auto'` opens with labels on.
 3. **Unsupported options are skipped and announced, never errored.**
    Whether it arrived through an explicit tuple or 'auto', a feature the
    engine cannot draw (any 3D-only feature under `ascii`) or the data
@@ -610,7 +602,7 @@ a per-call request behave predictably:
    `show_structure_options()` and at draw time.
 4. **Live modebar changes apply on top of that initial state and are
    runtime-only.** Toggling a feature in the Three.js modebar never
-   rewrites the persisted `_rendering_structure.show_*` flags or the
+   rewrites the persisted `_structure_view.show_*` flags or the
    `include=` set, so reopening the project restores the resolved
    initial state rather than the last live toggle.
 
@@ -624,12 +616,11 @@ a per-call request behave predictably:
   structure and engine is discoverable with reasons.
 - Keeping crystallography in the scene builder and out of renderers lets
   several front-ends (Three.js now, Qt Quick 3D later) share one model.
-- A new switchable `view` category (`project.rendering_structure.type`,
-  CIF `_rendering_structure.type`) must be added per the
-  switchable-category and category-owner ADRs, alongside a plain
-  (non-switchable) `style` category: `style` has no factory-swapped
-  `type`, only enum-backed value settings discoverable through
-  `show_supported()`.
+- A switchable `rendering_structure` category
+  (`project.rendering_structure.type`, CIF `_rendering_structure.type`)
+  selects only the engine, per the switchable-category and
+  category-owner ADRs. Plain `structure_view` and `structure_style`
+  sibling categories hold content/region and appearance settings.
 - The `ascii` and `threejs` engines ship together, mirroring the chart
   engines: `ascii` needs no JavaScript and renders a schematic view in
   the terminal, CLI, and headless contexts, while `threejs` covers
@@ -644,10 +635,9 @@ a per-call request behave predictably:
   margin, or several cells need no new primitives. The 3D engines draw
   the expanded set; the `ascii` engine draws the single default cell and
   reports wider ranges as a 3D-only capability.
-- The styling category lets scientists choose an atom-shape mode
-  (ball-and-stick or ORTEP), a standard radius model (defaulting to
-  covalent, the model with complete charge-free per-element data), a
-  colour scheme, and an ADP probability level — not hand-edit
+- The styling category lets scientists choose a standard atom view
+  (`vdw`, `covalent`, `ionic`, or `adp`), a colour scheme, an ADP
+  probability level, and an overall atom scale — not hand-edit
   per-element rows — all CIF-persisted, with defaults that work
   unconfigured. The radii and colours come from a bundled element
   database (covalent, vdW, ionic, and atomic radii; Jmol/CPK and VESTA
@@ -657,7 +647,7 @@ a per-call request behave predictably:
   (`_geom.min_bond_distance_cutoff`, `_geom.bond_distance_incr`) plus a
   per-type bonding radius (`_atom_type.radius_bond`, defaulting to the
   covalent radius), all on the structure and persisted in the structure
-  CIF — not in `project.style`, and independent of the display
+  CIF — not in `project.structure_style`, and independent of the display
   `atom_view`. Version 1 draws bonds on the fly and persists no bond
   table; the full computed `_geom_bond` / `_geom_angle` tables are
   deferred to a separate feature.
@@ -726,9 +716,9 @@ the final names.
   only atoms inside the range (borders included) and bonds only between
   in-scene atoms — no out-of-range partner atoms or edge-coordination
   completion. The range is persisted as six scalar tags
-  `_rendering_structure.range_{a,b,c}_{min,max}` (one number each,
-  defaults 0 and 1), mirroring the six scalar cell parameters; a
-  per-call `range=` tuple on `structure()` overrides them for one call.
+  `_structure_view.range_{a,b,c}_{min,max}` (one number each, defaults 0
+  and 1), mirroring the six scalar cell parameters; a per-call `range=`
+  tuple on `structure()` overrides them for one call.
 
 ## Deferred Work
 
diff --git a/docs/dev/adrs/suggestions/crysview-threejs-demo.html b/docs/dev/adrs/accepted/crysview-threejs-demo.html
similarity index 100%
rename from docs/dev/adrs/suggestions/crysview-threejs-demo.html
rename to docs/dev/adrs/accepted/crysview-threejs-demo.html
diff --git a/docs/dev/adrs/accepted/minimizer-category-consolidation.md b/docs/dev/adrs/accepted/minimizer-category-consolidation.md
index f7a1cdb30..b0f374f19 100644
--- a/docs/dev/adrs/accepted/minimizer-category-consolidation.md
+++ b/docs/dev/adrs/accepted/minimizer-category-consolidation.md
@@ -115,7 +115,7 @@ owner, category as a read-only attribute that gets swapped.
 ### 3. Per-parameter posterior data lives on `Parameter.posterior`
 
 Adopt the proposal from
-[`parameter-posterior-summary.md`](parameter-posterior-summary.md):
+[`parameter-posterior-summary.md`](../suggestions/parameter-posterior-summary.md):
 `GenericParameter.posterior` is `None` for deterministic fits and a
 `PosteriorParameterSummary` for Bayesian fits. The
 `_bayesian_parameter_posterior` CIF loop is removed; posterior summary
@@ -457,9 +457,9 @@ category's class-level `_engine_metadata` dict.
 
 ### Suggestions superseded or absorbed
 
-- [`parameter-posterior-summary.md`](parameter-posterior-summary.md) —
-  absorbed by §3 of this ADR. When this ADR is accepted, that suggestion
-  can be closed and a pointer added.
+- [`parameter-posterior-summary.md`](../suggestions/parameter-posterior-summary.md)
+  — absorbed by §3 of this ADR. When this ADR is accepted, that
+  suggestion can be closed and a pointer added.
 
 ## Alternatives Considered
 
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index 550c76c7d..260bf459d 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -78,7 +78,7 @@ Also touches:
   top-level `project.publication` owner is added alongside the existing
   `project.info`, `project.structures`, `project.experiments`,
   `project.analysis`, `project.report` facade slots (see §5).
-- [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
+- [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
   — owns the Python↔CIF correspondence rule for **two** new
   project-level singleton surfaces: `project.report.* ↔ _report.*` (five
   scalar items, §1.3) and `project.publication.*` sibling categories ↔
@@ -88,12 +88,12 @@ Also touches:
 
 The library today has four shapes of summary output:
 
-- `Report.show_report()` and friends — terminal/Jupyter rendering of
-  project metadata, crystallographic data per phase, experimental
+- `project.report` — report configuration and per-format export methods
+  for project metadata, crystallographic data per phase, experimental
   configuration, and fit metrics
-  ([report.py](../../../../src/easydiffraction/report/report.py)).
-  (Pre-PR #184 this was `Summary.show_report()` on `project.summary`;
-  the IUCr alignment ADR replaced the unimplemented placeholder.)
+  ([default.py](../../../../src/easydiffraction/project/categories/report/default.py)).
+  The IUCr alignment ADR replaced the earlier unimplemented
+  `project.summary` placeholder with this facade.
 - `summary.cif` — was written into the project root on every
   `project.save()` as the literal string `"To be added..."` until PR
   #184 removed both the writer call and the placeholder method. Not a
@@ -127,18 +127,16 @@ the unresolved design question. The alignment ADR has since replaced the
 unimplemented `project.summary` slot with a `project.report` facade
 scoped to IUCr CIF generation (`reports/<project>.cif`). That resolves
 the CIF half of the question but leaves the GUI Summary tab, the
-terminal `show_report()`, the human-readable HTML, and the
-manuscript-bound LaTeX/PDF without a definition. This ADR fills the gap
-by extending the same `project.report` facade with non-CIF rendering
-surfaces.
+human-readable HTML, and the manuscript-bound LaTeX/PDF without a
+definition. This ADR fills the gap by extending the same
+`project.report` facade with non-CIF rendering surfaces.
 
 ## Scope
 
 In scope:
 
-- Extend the alignment ADR's `project.report` facade with
-  terminal/Jupyter, HTML, and LaTeX rendering surfaces, a configuration
-  category (five scalar fields —
+- Extend the alignment ADR's `project.report` facade with HTML and LaTeX
+  rendering surfaces, a configuration category (five scalar fields —
   `project.report.{cif, html, tex, pdf, html_offline}` — persisted in
   `project.cif`), and ad-hoc per-format save methods. **All report
   formats are opt-in via the configuration; every format defaults to
@@ -174,7 +172,7 @@ Out of scope:
 - Pre-existing project-level singleton categories (`_info.*`,
   `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*`). Covered by
   the in-flight
-  [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md).
+  [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md).
   This ADR **does** add one new project-level singleton category,
   `_report.*`, alongside them (see §1.3 and the ADRs-amended list); that
   surface is not delegated to the correspondence ADR.
@@ -323,13 +321,6 @@ project.report.as_tex() -> str
 # Shared data context (for GUI Summary tab + Jinja templates):
 project.report.data_context() -> dict
 
-# Terminal / Jupyter renderers (existing methods, migrated to
-# project.report by PR #184 — names preserved):
-project.report.show_report()              # full report — sections below
-project.report.show_project_info()
-project.report.show_crystallographic_data()
-project.report.show_experimental_data()
-project.report.show_fitting_details()
 ```
 
 Per-format method signatures only carry the args that apply to that
@@ -487,12 +478,11 @@ Reasons `project.report` is Pattern A, not Pattern B:
 
 What makes `project.report` look heavier than `project.rendering_plot` /
 `project.rendering_table` / `project.verbosity` is the action methods on
-the facade (`save_cif()`, `save_html()`, `show_report()`,
-`data_context()`, etc.). Those live on the Python class alongside the
-configuration fields, which is the facade-hybrid amendment to
-`project-facade-and-persistence.md` already recorded in the ADRs-amended
-list. The action methods do not change where the configuration persists
-— that stays in `project.cif`.
+the facade (`save_cif()`, `save_html()`, `data_context()`, etc.). Those
+live on the Python class alongside the configuration fields, which is
+the facade-hybrid amendment to `project-facade-and-persistence.md`
+already recorded in the ADRs-amended list. The action methods do not
+change where the configuration persists — that stays in `project.cif`.
 
 #### 1.4 Validation moves internal — CIF only, writer-correctness only
 
@@ -653,7 +643,7 @@ self._u_iso = Parameter(
 | ---------------------------------------- | --------------------------- | ---------------------------- |
 | LaTeX (`save_tex`)                       | `$U_{\mathrm{iso}}$`        | `\AA$^2$`                    |
 | HTML (`save_html`, MathJax-rendered)     | `$U_{\mathrm{iso}}$`        | `\AA$^2$`                    |
-| HTML pre-MathJax / GUI / `show_report()` | `Uiso`                      | `Ų`                         |
+| HTML pre-MathJax / GUI                   | `Uiso`                      | `Ų`                         |
 | `project.report.data_context()` raw dict | both available              | both available               |
 | CIF emission                             | `_atom_site.U_iso_or_equiv` | (no `_units.code` row today) |
 | Python code / repr                       | `u_iso`                     | `angstrom_squared`           |
@@ -672,9 +662,9 @@ per-context fallback chain:
   additionally surrounds `handler.latex_name` / `handler.latex_units`
   with `\(...\)` math delimiters so MathJax picks them up where the
   descriptor has typeset variants — i.e., HTML can show the same
-  `$U_{\mathrm{iso}}$` the PDF shows, while a GUI tooltip or
-  `show_report()` printout falls back to `display_*`.
-- **GUI / terminal / `show_*()` context**:
+  `$U_{\mathrm{iso}}$` the PDF shows, while a GUI tooltip falls back to
+  `display_*`.
+- **GUI / plain-text context**:
   `handler.display_name or descriptor.name`,
   `handler.display_units or descriptor.units`.
 
@@ -1568,12 +1558,12 @@ successful return — pre-fit calls, failed fits, and projects loaded from
 a save predating this ADR all start out **without** the snapshot. The
 public API surface treats missing provenance uniformly:
 
-- **Rendering (`project.report.show_report()`, HTML, TeX).** Each
-  role-row prints `"(not available)"` for `name`, omits version and URL,
-  and adds a one-line footer "Software-provenance snapshot not yet
-  recorded — call `Analysis.fit()` once to populate." No warning, no
-  exception; the report still renders end-to-end so users iterating on a
-  configuration before fitting see the rest of the page.
+- **Rendering (HTML, TeX).** Each role-row prints `"(not available)"`
+  for `name`, omits version and URL, and adds a one-line footer
+  "Software-provenance snapshot not yet recorded — call `Analysis.fit()`
+  once to populate." No warning, no exception; the report still renders
+  end-to-end so users iterating on a configuration before fitting see
+  the rest of the page.
 - **IUCr CIF export (`project.report.cif = True`).** The
   `_easydiffraction_software.{framework, calculator, minimizer}` triple
   emits `?` placeholders consistent with the IUCr ADR's unset-field
@@ -2053,7 +2043,7 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      enumeration: `_report.*` (this ADR §1.3) and `_publication.*`
      family (this ADR §5; concrete sub-prefixes are `_publ_*` and
      `_journal_*` per IUCr coreCIF).
-- [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
+- [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
   — owns the Python-to-CIF correspondence rule for two new project-level
   singleton surfaces:
   - `project.report.*` ↔ `_report.*` — five scalar items (four format
diff --git a/docs/dev/adrs/suggestions/value-selector-discovery.md b/docs/dev/adrs/accepted/value-selector-discovery.md
similarity index 99%
rename from docs/dev/adrs/suggestions/value-selector-discovery.md
rename to docs/dev/adrs/accepted/value-selector-discovery.md
index 640126a62..c7bbc7831 100644
--- a/docs/dev/adrs/suggestions/value-selector-discovery.md
+++ b/docs/dev/adrs/accepted/value-selector-discovery.md
@@ -2,7 +2,7 @@
 
 ## Status
 
-Proposed.
+Accepted.
 
 ## Date
 
diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index 2757030f7..f362f485f 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -43,7 +43,7 @@ folders.
 | Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
 | Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                              |
 | Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                         | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                  |
-| User-facing API      | Suggestion | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures.   | [`crysview-structure-visualization.md`](suggestions/crysview-structure-visualization.md)     |
+| User-facing API      | Accepted   | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures.   | [`crysview-structure-visualization.md`](accepted/crysview-structure-visualization.md)        |
 | User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                          | [`display-ux.md`](accepted/display-ux.md)                                                    |
 | User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.       | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                    |
 | User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and publication metadata surfaces.                | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
@@ -51,4 +51,4 @@ folders.
 | User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                         | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)      |
 | User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.     | [`switchable-category-api.md`](accepted/switchable-category-api.md)                          |
 | User-facing API      | Accepted   | Switchable Category Owned Selectors       | Moves the writable `type` selector and `show_supported()` onto the category itself; collapses the CIF duplication.    | [`switchable-category-owned-selectors.md`](accepted/switchable-category-owned-selectors.md)  |
-| User-facing API      | Suggestion | Value-Selector Discovery                  | Gives enumerated value fields a per-descriptor `show_supported()`, beside the three category-level selector families. | [`value-selector-discovery.md`](suggestions/value-selector-discovery.md)                     |
+| User-facing API      | Accepted   | Value-Selector Discovery                  | Gives enumerated value fields a per-descriptor `show_supported()`, beside the three category-level selector families. | [`value-selector-discovery.md`](accepted/value-selector-discovery.md)                        |
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
index bc1fffdf5..37f823392 100644
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ b/docs/dev/plans/crysview-structure-visualization.md
@@ -1,28 +1,29 @@
 # Plan: crysview Structure Visualization
 
 Implementation plan for the
-[`crysview-structure-visualization`](../adrs/suggestions/crysview-structure-visualization.md)
+[`crysview-structure-visualization`](../adrs/accepted/crysview-structure-visualization.md)
 ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
 exceptions to those instructions.
 
-> **Status (updated).** Phase 1 (code) shipped on this branch — the
-> feature is implemented. **Phase 2 (tests) was never executed**; its
-> unit-test files are discharged by the
-> [`structure-view-settings`](structure-view-settings.md) plan's Phase
-> 2, written once against the final API. Some prose below is kept only
-> as a historical design record and predates two later changes: the
+> **Status (closed).** The feature has shipped on this branch and the
+> ADR has been promoted to accepted. The original Phase 2 checklist
+> below is retained as historical planning detail; active verification
+> was completed once against the final API through the
+> [`structure-view-settings`](structure-view-settings.md) plan. Some
+> prose below predates two later changes: the
 > `atom_shape`/`radius_model` → `atom_view` merge (commit `f31996da7`)
 > and the `structure-view-settings` split of `style` /
 > `rendering_structure` into `rendering_structure` (engine) +
-> `structure_view` + `structure_style`. See the crysview ADR and the
-> `structure-view-settings` plan for the current design.
-
-> **Context for this plan.** This is a **greenfield feature**: there is
-> no prior crysview implementation on the branch. The ADR review cycle
-> closed at the review-5 sentinel ("No findings. Ready to commit."), so
-> the design below is settled; this plan only makes it concrete. It is a
-> **single comprehensive plan** covering both shipping engines (ASCII +
-> Three.js), the new `view` and `style` categories, the
+> `structure_view` + `structure_style`. See the accepted crysview ADR
+> and the `structure-view-settings` plan for the current design.
+
+> **Context for this plan.** This started as a **greenfield feature**:
+> there was no prior crysview implementation on the branch. The ADR
+> review cycle closed at the review-5 sentinel ("No findings. Ready to
+> commit."), so the design below is settled; this plan only makes it
+> concrete. It is a **single comprehensive plan** covering both shipping
+> engines (ASCII + Three.js), the original `view` and `style` categories
+> later split by `structure-view-settings`, the
 > `project.display.structure()` surface, CIF persistence, Three.js
 > bundling, the HTML-report structure figure, and tutorials — one
 > branch, one PR — matching the slug invoked and the project precedent
@@ -34,14 +35,10 @@ exceptions to those instructions.
 ## ADR cross-reference
 
 - **Primary (owned) ADR:**
-  [`crysview-structure-visualization.md`](../adrs/suggestions/crysview-structure-visualization.md)
-  (Status: Proposed; ADR review cycle closed at the review-5 sentinel).
-  This plan **owns** the ADR — it was drafted via `/draft-adr` and is
-  not yet committed. `/draft-impl-1` Phase A only commits the ADR
-  suggestion and the plan and removes their design-phase `_review-*.md`
-  / `_reply-*.md` siblings — it does **not** edit
-  [`docs/dev/adrs/index.md`](../adrs/index.md). The **User-facing API**
-  index row is a normal Phase 1 step (P1.16).
+  [`crysview-structure-visualization.md`](../adrs/accepted/crysview-structure-visualization.md)
+  (accepted; ADR review cycle closed at the review-5 sentinel). This
+  plan originally owned the ADR during drafting; the ADR and index row
+  have since been promoted.
 - **Referenced accepted ADRs** (the design builds on these; none are
   amended):
   - [`display-ux.md`](../adrs/accepted/display-ux.md) — defines
@@ -60,8 +57,7 @@ exceptions to those instructions.
     `view` is a switchable-category selector (Family B), like `chart` /
     `table`.
   - [`enum-backed-closed-values.md`](../adrs/accepted/enum-backed-closed-values.md)
-    — every closed value set (`view.type`, `style.atom_shape`,
-    `style.radius_model`, `style.color_scheme`) is a `(str, Enum)`.
+    — every closed value set is a `(str, Enum)`.
   - [`factory-contracts.md`](../adrs/accepted/factory-contracts.md),
     [`factory-tag-naming.md`](../adrs/accepted/factory-tag-naming.md) —
     `@Factory.register` and tag-naming conventions for the new
@@ -416,9 +412,9 @@ P1.16):**
 
 - `docs/dev/adrs/index.md` (existing — add a **User-facing API** row for
   the crysview ADR).
-- `docs/dev/adrs/suggestions/crysview-structure-visualization.md`
-  (committed by `/draft-impl-1` Phase A; its `_review-*` / `_reply-*`
-  siblings removed there).
+- `docs/dev/adrs/accepted/crysview-structure-visualization.md` (promoted
+  after implementation; its `_review-*` / `_reply-*` siblings were
+  removed during the implementation workflow).
 
 **Tutorials and docs:**
 
@@ -428,7 +424,8 @@ P1.16):**
 - `docs/docs/tutorials/*.ipynb` (regenerated artefacts).
 - `docs/docs/user-guide/` and `docs/docs/api-reference/` (existing — add
   `project.display.structure()`, `project.rendering_structure`,
-  `project.style` reference + a short user-guide section).
+  `project.structure_view`, and `project.structure_style` references + a
+  short user-guide section).
 
 ## Commit discipline
 
diff --git a/docs/dev/plans/iucr-cif-tag-alignment.md b/docs/dev/plans/iucr-cif-tag-alignment.md
index d1169e3c3..3ac4e16a1 100644
--- a/docs/dev/plans/iucr-cif-tag-alignment.md
+++ b/docs/dev/plans/iucr-cif-tag-alignment.md
@@ -5,6 +5,13 @@ Implementation plan for the
 ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
 exceptions to those instructions.
 
+> **Status (closed).** Phase 1 and Phase 2 are complete; the ADR was
+> promoted to accepted during implementation. This file is retained as
+> the implementation and verification record. Early references below to
+> `project.report.show_report()` and related display helpers were
+> superseded by the later project-summary-rendering work; the current
+> report facade exposes save/render/data-context methods.
+
 ## ADR cross-reference
 
 - Primary ADR: `iucr-cif-tag-alignment.md` (accepted; this plan promoted
diff --git a/docs/dev/plans/project-summary-rendering.md b/docs/dev/plans/project-summary-rendering.md
index dcd812972..e1d2fccfc 100644
--- a/docs/dev/plans/project-summary-rendering.md
+++ b/docs/dev/plans/project-summary-rendering.md
@@ -5,6 +5,12 @@ Implementation plan for the
 ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
 exceptions to those instructions.
 
+> **Status (closed).** The report-rendering work has shipped and its ADR
+> remains accepted. The unchecked Phase 2 items later in this document
+> are retained as historical planning detail; the corresponding report,
+> category, display-handler, and units-vocabulary tests now exist in the
+> unit-test tree.
+
 > **Context for this plan.** The branch `project-summary-rendering`
 > already carries an end-to-end Phase 1 implementation of an earlier
 > version of the same ADR (PR-ready as of commit
diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index b4c2e1c39..65ae9b6c6 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -8,6 +8,12 @@ consolidation), but the scope has broadened: Part A introduces a
 project-wide selector-discovery convention, and Part B reorganises the
 structure-view settings on top of it.
 
+> **Status (closed).** Phase 1 and Phase 2 are complete on the
+> `crysview-structure-visualization` branch. The
+> `value-selector-discovery` and `crysview-structure-visualization` ADRs
+> have both been promoted to accepted. This file is retained as the
+> implementation and verification record.
+
 **Branch & PR (deliberate exception).** §Planning asks for a flat-slug
 `structure-view-settings` branch off `develop`. This plan deliberately
 deviates: the work continues on the in-flight
@@ -20,11 +26,10 @@ later split from the visualization PR, a dedicated
 
 ## ADR
 
-This plan now needs ADR work (it was previously "no ADR required"):
+This plan completed the ADR work that was added during planning:
 
-- **New ADR — `value-selector-discovery`** (draft via `/draft-adr`
-  before Phase 1, or accept alongside this plan). Recognises a
-  **fourth** selector shape beyond the three category-level families in
+- **Accepted ADR — `value-selector-discovery`**. Recognises a **fourth**
+  selector shape beyond the three category-level families in
   [`selector-families.md`](../adrs/accepted/selector-families.md):
   - **Category-level selectors** — the backend, switchable-category, and
     active-sibling families. Each _is_ a category and owns
@@ -37,7 +42,7 @@ This plan now needs ADR work (it was previously "no ADR required"):
     **same** `render_table` and `*`-marks-current convention. This is
     the new half.
 - **Update — crysview ADR**
-  ([`crysview-structure-visualization.md`](../adrs/suggestions/crysview-structure-visualization.md)):
+  ([`crysview-structure-visualization.md`](../adrs/accepted/crysview-structure-visualization.md)):
   the structure-view surface becomes three categories; `_style.*` →
   `_structure_style.*`; `show_labels`/`show_moments`/`range_*` move to
   `_structure_view.*`; `_rendering_structure.*` reduces to `type`;
@@ -338,11 +343,11 @@ separately): `data.calc_status` (`['incl', 'excl']`),
 
 ## Phase 2 — Verification
 
-This Phase 2 also discharges the crysview feature's never-written unit
-tests (the
+This Phase 2 also discharges the crysview feature's originally planned
+unit tests (the
 [`crysview-structure-visualization`](crysview-structure-visualization.md)
-plan's Phase 2 was never executed — `display/structure/` has no unit
-tests), written **once** against the final post-split API:
+plan's original Phase 2 checklist was superseded), written **once**
+against the final post-split API:
 
 - **This plan's surfaces:** `EnumDescriptor` + per-selector
   `show_supported()`; each migrated value selector; the new
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 5c20838ab..69d9783d4 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -212,7 +212,7 @@ project.structure_style.color_scheme.show_supported()
 project.structure_style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', or 'adp'
 project.structure_style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
 project.structure_style.atom_scale = 0.3  # overall ball size (square-root compressed)
-project.structure_style.adp_probability = 0.5  # ADP ellipsoid probability level (0–1)
+project.structure_style.adp_probability = 0.5  # ADP ellipsoid probability level (0, 1)
 ```
 
 Bonds are generated automatically between atoms whose separation falls

From 06af172148ecccdf2780e9681f3f686810305f26 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 19:43:38 +0200
Subject: [PATCH 112/160] Change default atom view to covalent

---
 .../crysview-structure-visualization.md       | 21 +++++++++----------
 .../user-guide/analysis-workflow/model.md     |  2 +-
 .../display/structure/enums.py                |  4 ++--
 .../display/structure/test_builder.py         |  4 ++--
 .../display/structure/test_enums.py           |  4 ++--
 .../structure_style/test_default.py           |  4 ++--
 .../structure_style/test_factory.py           |  2 +-
 7 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/docs/dev/adrs/accepted/crysview-structure-visualization.md b/docs/dev/adrs/accepted/crysview-structure-visualization.md
index 8fa04b273..d98478b2d 100644
--- a/docs/dev/adrs/accepted/crysview-structure-visualization.md
+++ b/docs/dev/adrs/accepted/crysview-structure-visualization.md
@@ -290,7 +290,7 @@ A scientist picks one model and one scheme instead of editing dozens of
 per-element rows, which keeps the view consistent and reproducible:
 
 ```python
-project.structure_style.atom_view = 'adp'      # vdw | covalent | ionic | adp
+project.structure_style.atom_view = 'covalent' # vdw | covalent | ionic | adp
 project.structure_style.color_scheme = 'jmol'  # jmol | vesta
 project.structure_style.atom_view.show_supported()
 project.structure_style.color_scheme.show_supported()
@@ -312,9 +312,9 @@ time:
   thermal-ellipsoid (ORTEP) depiction crystallographers use to inspect
   the displacement parameters a refinement adjusts.
 
-The default is `'adp'`, because this is a refinement tool and the
-thermal ellipsoids are usually the point; a structure with no ADP simply
-renders as covalent-radius spheres.
+The default is `'covalent'`, because it gives every structure a stable
+charge-free ball view. Users can switch to `'adp'` when they want to
+inspect displacement surfaces.
 
 > **Amendment — `atom_view` merge.** An earlier design split this into
 > two settings: `atom_shape` (`ball`/`ortep`) and `radius_model`
@@ -372,11 +372,10 @@ each selector lists its accepted values through descriptor-level
 is a plain category, not a switchable one: it has no factory-swapped
 `type`, only these validated value settings.
 
-The defaults are the **`adp`** atom view and the **Jmol/CPK** colour
-scheme, so the view looks right with no configuration. Covalent radii —
-the `adp` ball fallback and the `atom_view = 'covalent'` option — are
-preferred because they are backed by complete, well-documented
-per-element data and needs no oxidation state: today's atom-site model
+The defaults are the **`covalent`** atom view and the **Jmol/CPK**
+colour scheme, so the view looks right with no configuration. Covalent
+radii are preferred because they are backed by complete, well-documented
+per-element data and need no oxidation state: today's atom-site model
 carries only an element symbol — no charge, oxidation-state, or
 coordination field — so a model that depends on charge cannot be
 resolved per site yet.
@@ -509,7 +508,7 @@ project.rendering_structure.type = 'auto'           # default: 'threejs' in Jupy
 project.rendering_structure.show_supported()
 
 # How: standard styling models, not per-element values (visual only)
-project.structure_style.atom_view = 'adp'      # vdw | covalent | ionic | adp
+project.structure_style.atom_view = 'covalent' # vdw | covalent | ionic | adp
 project.structure_style.color_scheme = 'jmol'  # jmol | vesta
 project.structure_style.adp_probability = 0.5  # ADP probability level (0, 1)
 project.structure_style.atom_scale = 0.3       # overall atom scale (0, 1]
@@ -559,7 +558,7 @@ _structure_view.range_b_max    1
 _structure_view.range_c_min    0
 _structure_view.range_c_max    1
 
-_structure_style.atom_view        adp
+_structure_style.atom_view        covalent
 _structure_style.color_scheme     jmol
 _structure_style.adp_probability  0.5
 _structure_style.atom_scale       0.3
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 69d9783d4..3cbdb6026 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -209,7 +209,7 @@ project.structure_style.color_scheme.show_supported()
 # atom_view picks a radius-model ball ('vdw'/'covalent'/'ionic')
 # or 'adp' for displacement surfaces (spheres for isotropic sites,
 # ellipsoids for anisotropic ones — driven by each atom's adp_type).
-project.structure_style.atom_view = 'adp'  # 'vdw', 'covalent', 'ionic', or 'adp'
+project.structure_style.atom_view = 'covalent'  # default; use 'adp' for ellipsoids
 project.structure_style.color_scheme = 'jmol'  # 'jmol' or 'vesta'
 project.structure_style.atom_scale = 0.3  # overall ball size (square-root compressed)
 project.structure_style.adp_probability = 0.5  # ADP ellipsoid probability level (0, 1)
diff --git a/src/easydiffraction/display/structure/enums.py b/src/easydiffraction/display/structure/enums.py
index 2ea0480bb..f5f5d09bd 100644
--- a/src/easydiffraction/display/structure/enums.py
+++ b/src/easydiffraction/display/structure/enums.py
@@ -46,8 +46,8 @@ class AtomViewEnum(StrEnum):
 
     @classmethod
     def default(cls) -> AtomViewEnum:
-        """Select the default atom view (ADP displacement surfaces)."""
-        return cls.ADP
+        """Select the default atom view (covalent-radius balls)."""
+        return cls.COVALENT
 
     @property
     def is_adp(self) -> bool:
diff --git a/tests/unit/easydiffraction/display/structure/test_builder.py b/tests/unit/easydiffraction/display/structure/test_builder.py
index 5c6fb2ae2..d9880da60 100644
--- a/tests/unit/easydiffraction/display/structure/test_builder.py
+++ b/tests/unit/easydiffraction/display/structure/test_builder.py
@@ -640,8 +640,8 @@ def test_color_scheme_enum_backing(self):
 
 
 class TestStructureStyleInputs:
-    def test_default_atom_view_is_adp(self):
-        assert StructureStyle().atom_view.value == AtomViewEnum.ADP.value
+    def test_default_atom_view_is_covalent(self):
+        assert StructureStyle().atom_view.value == AtomViewEnum.COVALENT.value
 
     def test_default_color_scheme_is_jmol(self):
         assert StructureStyle().color_scheme.value == ColorSchemeEnum.JMOL.value
diff --git a/tests/unit/easydiffraction/display/structure/test_enums.py b/tests/unit/easydiffraction/display/structure/test_enums.py
index 9ca8def6d..508f2989e 100644
--- a/tests/unit/easydiffraction/display/structure/test_enums.py
+++ b/tests/unit/easydiffraction/display/structure/test_enums.py
@@ -95,8 +95,8 @@ def test_invalid_string(self):
         with pytest.raises(ValueError, match='is not a valid AtomViewEnum'):
             AtomViewEnum('atomic')
 
-    def test_default_is_adp(self):
-        assert AtomViewEnum.default() is AtomViewEnum.ADP
+    def test_default_is_covalent(self):
+        assert AtomViewEnum.default() is AtomViewEnum.COVALENT
 
     def test_is_adp_true_only_for_adp(self):
         assert AtomViewEnum.ADP.is_adp is True
diff --git a/tests/unit/easydiffraction/project/categories/structure_style/test_default.py b/tests/unit/easydiffraction/project/categories/structure_style/test_default.py
index a0e264a40..a2b7d8190 100644
--- a/tests/unit/easydiffraction/project/categories/structure_style/test_default.py
+++ b/tests/unit/easydiffraction/project/categories/structure_style/test_default.py
@@ -73,7 +73,7 @@ def test_default_values(self):
         from easydiffraction.project.categories.structure_style.default import StructureStyle
 
         style = StructureStyle()
-        assert style.atom_view.value == 'adp'
+        assert style.atom_view.value == 'covalent'
         assert style.color_scheme.value == 'jmol'
         assert style.adp_probability.value == 0.99
         assert style.atom_scale.value == 0.3
@@ -334,7 +334,7 @@ def test_as_cif_default_output(self):
 
         style = StructureStyle()
         cif = style.as_cif
-        assert '_structure_style.atom_view adp' in cif
+        assert '_structure_style.atom_view covalent' in cif
         assert '_structure_style.color_scheme jmol' in cif
         assert '_structure_style.adp_probability 0.99' in cif
         assert '_structure_style.atom_scale 0.3' in cif
diff --git a/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py b/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py
index 745a511ba..06b3195af 100644
--- a/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py
+++ b/tests/unit/easydiffraction/project/categories/structure_style/test_factory.py
@@ -133,7 +133,7 @@ def test_created_instance_identity():
 def test_created_instance_defaults():
     structure_style = _make_style()
 
-    assert structure_style.atom_view.value == 'adp'
+    assert structure_style.atom_view.value == 'covalent'
     assert structure_style.color_scheme.value == 'jmol'
     assert structure_style.adp_probability.value == 0.99
     assert structure_style.atom_scale.value == 0.3

From ee521a0d621914a57f4ed40f59713efe53e78e8b Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 20:24:35 +0200
Subject: [PATCH 113/160] Document clean report CIF metadata policy

---
 .../adrs/accepted/iucr-cif-tag-alignment.md   | 139 +++----
 .../project-facade-and-persistence.md         |  20 +-
 .../accepted/project-summary-rendering.md     | 376 +++++++-----------
 docs/dev/adrs/index.md                        |   4 +-
 4 files changed, 228 insertions(+), 311 deletions(-)

diff --git a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
index ddb3f05c6..b8fdeaee9 100644
--- a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
+++ b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
@@ -5,8 +5,8 @@
 
 Reframes the earlier "IUCr CIF Tag Alignment for Fit Outputs" suggestion
 (2026-05-24, PR #181) into a tiered policy. The default saved CIFs stay
-optimised for day-to-day UX; a separate IUCr export path produces
-journal-submission CIFs on demand. Amends parts of
+optimised for day-to-day UX; a separate IUCr export path produces clean
+report CIFs on demand. Amends parts of
 [`analysis-cif-fit-state.md`](analysis-cif-fit-state.md) and
 [`minimizer-input-output-split.md`](minimizer-input-output-split.md);
 runs alongside the
@@ -40,11 +40,11 @@ commonly produced by tooling that has not yet caught up with the current
 DDLm spec. The dictionaries are the source of truth.
 
 The submission-specific publication dictionary (`cif_publ.dic`) is not
-consulted directly — the publication-block items are all present in
-`cif_core.dic` under `_journal.*`, `_journal_coeditor.*`,
-`_journal_date.*`, `_publ_author.*`, `_publ_contact_author.*`,
-`_publ_body.*`, `_publ_manuscript.*`, `_audit.*`, and
-`_chemical_formula.*`.
+consulted directly. The v1 report CIF deliberately avoids empty journal
+and author template fields; the retained global metadata comes from
+`cif_core.dic` items such as `_audit.*`, `_computing.*`, and
+`_chemical_formula.*`. Deferred journal/publication tags are listed in
+[`project-summary-rendering.md`](project-summary-rendering.md) §5.1.
 
 ## Context
 
@@ -59,11 +59,12 @@ and item names:
   without a custom mapping layer.
 - **Day-to-day UX.** Users switch between Python and direct CIF editing
   in a CLI. Some IUCr-canonical structures are awkward for hand editing
-  — submission templates require multi-datablock layouts with
-  `data_global` publication metadata, embedded `_publ_*` placeholder
-  fields, and TOF calibration as a coefficient loop indexed by integer
-  `power`. Parametric profile shape (Caglioti, FCJ, TOF sigma/gamma) has
-  no IUCr counterpart at all.
+  — submission templates often include multi-datablock layouts with
+  `data_global` metadata and TOF calibration as a coefficient loop
+  indexed by integer `power`. The v1 report keeps the structural pieces
+  and omits empty `_publ_*` / `_journal_*` placeholders. Parametric
+  profile shape (Caglioti, FCJ, TOF sigma/gamma) has no IUCr counterpart
+  at all.
 
 A blanket "align with IUCr everywhere" policy pays a UX cost the project
 does not need to absorb for files that are not submission targets. A
@@ -86,8 +87,8 @@ In scope:
 
 - A tiered category-and-item-name policy for the default save, split by
   domain (structure / analysis / experiment).
-- A new IUCr export path that produces a single journal-submission CIF
-  on demand, separate from the default save.
+- A new IUCr export path that produces a single clean report CIF on
+  demand, separate from the default save.
 - ADP write-side single-tag emission and casing alignment in the
   structure tier.
 - Loop-tag style policy: dotted DDLm form universally on write, both
@@ -96,7 +97,7 @@ In scope:
   on `CifHandler`, category-level `IucrCategoryTransformer` for
   structural reshapings).
 - Multi-datablock layout in the IUCr export, including the `data_global`
-  publication-metadata block.
+  audit, software, and chemistry metadata block.
 
 Out of scope:
 
@@ -106,8 +107,8 @@ Out of scope:
   for Python-side decisions.
 - Adding new CIF categories the project does not currently track
   (`_chemical.*`, `_publ.*`, `_journal.*`) **for the default save**. The
-  IUCr export emits the publication-metadata categories per §2.3a with
-  `?` placeholders where the project has no source data.
+  IUCr export derives `_chemical_formula.*` for the report only and does
+  not emit `_publ_*` / `_journal_*` placeholders in v1.
 - imgCIF (`cif_img.dic`); no raw image persistence path exists.
 - Project-level singleton categories `_info.*`, `_rendering_plot.*`,
   `_rendering_table.*`, `_verbosity.*` — out of scope here; see
@@ -195,7 +196,7 @@ dotted DDLm tag emitted by the IUCr CIF report writer.
 | `_alias`, `_constraint`                                                                         | none                                                                        | Analysis — unchanged                        | `_easydiffraction_alias*`, `_easydiffraction_constraint*`.                                                                                                                                 |
 | `_joint_fit`, `_sequential_fit*`                                                                | none                                                                        | Analysis — unchanged                        | `_easydiffraction_joint_fit*`, `_easydiffraction_sequential_fit*`.                                                                                                                         |
 | reflection-set aggregates                                                                       | core (`_reflns.*`)                                                          | Analysis — new fields                       | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression` (e.g. `'I>3\s(I)'`).                                                                                           |
-| publication metadata                                                                            | core (`_journal.*`, `_publ_author.*`, `_publ_contact_author.*`, `_audit.*`) | (not emitted today)                         | Emitted in `data_global` block per §2.3a with `?` placeholders.                                                                                                                            |
+| report metadata                                                                                 | core (`_audit.*`, `_computing.*`, `_chemical_formula.*`) and project extension (`_easydiffraction_software.*`) | Analysis / derived report state             | Emitted in `data_global` block per §2.3a. Empty `_journal.*`, `_publ_*`, and `_pd_meas.info_author_*` placeholders are excluded by the clean-report policy in `project-summary-rendering.md` §5. |
 | analysis-stack identification                                                                   | core (`_computing.structure_refinement`)                                    | Analysis — `_software.*` persisted          | `_easydiffraction_software.{framework, calculator, minimizer}` triple + `_easydiffraction_software.fit_datetime` + `_computing.structure_refinement` derived from `analysis.software`.     |
 
 ## Decision
@@ -296,7 +297,7 @@ Specifically:
 - Parametric profile shape (`_peak.*` Caglioti / Lorentzian / FCJ / TOF
   coefficients) stays under `_peak.*`.
 
-### 2. Reports — IUCr submission CIF
+### 2. Reports — IUCr-aligned report CIF
 
 #### 2.1 API
 
@@ -360,7 +361,7 @@ quartz_sc/
                                           #   plus Bayesian / non-IUCr fields)
                                           # _easydiffraction_minimizer.* (settings)
   reports/
-    quartz_sc.cif                         # data_global    — _journal.*, _publ_*, _audit.*,
+    quartz_sc.cif                         # data_global    — _audit.*,
                                           #                  _easydiffraction_software.{framework,
                                           #                  calculator, minimizer},
                                           #                  _computing.structure_refinement,
@@ -386,7 +387,7 @@ mgo_rietveld/
   analysis/
     analysis.cif
   reports/
-    mgo_rietveld.cif                      # data_global               — publication metadata, software, _chemical_formula
+    mgo_rietveld.cif                      # data_global               — audit, software, _chemical_formula
                                           # data_mgo_rietveld_overall — _pd_proc_ls.prof_R_factor,
                                           #                              .prof_wR_factor,
                                           #                              .prof_wR_expected,
@@ -416,7 +417,7 @@ co2sio4/
   analysis/
     analysis.cif                          # _joint_fit weights
   reports/
-    co2sio4.cif                           # data_global          — publication metadata
+    co2sio4.cif                           # data_global          — audit, software, chemistry
                                           # data_co2sio4_overall  — combined refinement stats
                                           # data_co2sio4_phase_0  — Co2SiO4 structure
                                           # data_co2sio4_pwd_0    — NPD pattern,
@@ -440,7 +441,7 @@ co2sio4_t_series/
   analysis/
     analysis.cif                          # _sequential_fit configuration
   reports/
-    co2sio4_t_series.cif                  # data_global                  — publication metadata
+    co2sio4_t_series.cif                  # data_global                  — audit, software, chemistry
                                           # data_co2sio4_t_series_overall
                                           # data_co2sio4_t_series_phase_0
                                           # data_co2sio4_t_series_pwd_0  — TOF 5K,
@@ -453,15 +454,14 @@ co2sio4_t_series/
 
 #### 2.3 Multi-datablock layout inside the export file
 
-**Every export file starts with a `data_global` block carrying
-publication metadata** (§2.3a). Subsequent blocks depend on analysis
-topology. Block content uses dotted DDLm form throughout. The
+**Every export file starts with a `data_global` block carrying audit,
+software, and chemistry metadata** (§2.3a). Subsequent blocks depend on
+analysis topology. Block content uses dotted DDLm form throughout. The
 single-block-name rule is uniform across topologies; topology-specific
 GSAS-II-style suffix conventions seen in some example files (e.g.
 `data_<project>_publ`, `data_<project>_overall`) are folded into
-`data_global` for the publication header and `data_<project>_overall`
-for refinement metadata, leaving no ambiguity about where the
-journal-required publication items live.
+`data_global` for global metadata and `data_<project>_overall`
+for refinement metadata, leaving no ambiguity about block roles.
 
 - **Single-crystal, single structure (single experiment).**
   `data_global` + `data_<structure>` (or `data_I` if no name is set).
@@ -473,9 +473,9 @@ journal-required publication items live.
   `bp5014.cif`: `data_global + data_300K + data_55K + data_2point5K`.
 
 - **Powder Rietveld (single or multi-experiment, single or
-  multi-phase).** GSAS-II-style block split, with the publication block
-  renamed to `data_global` per the invariant above:
-  - `data_global` (publication metadata, per §2.3a),
+  multi-phase).** GSAS-II-style block split, with the global metadata
+  block named `data_global` per the invariant above:
+  - `data_global` (audit, software, and chemistry metadata per §2.3a),
   - `data_<project>_overall` (refinement-level metadata — Rietveld
     R-factors, profile/background function descriptors, parameter
     counts),
@@ -517,35 +517,23 @@ the project has source data, otherwise `?`.
 - `_easydiffraction_software.*` triple holding the same three roles in
   structured form, plus `_easydiffraction_software.fit_datetime` when a
   fit timestamp is available (see §2.3a-i below).
-- `_journal.*` placeholders, written as `?` when the project has no
-  source data: `_journal.name_full`, `_journal.year`, `_journal.volume`,
-  `_journal.issue`, `_journal.page_first`, `_journal.page_last`,
-  `_journal.paper_category`, `_journal.paper_DOI`,
-  `_journal.coden_ASTM`, `_journal.suppl_publ_number`.
-- `_journal_date.*` placeholders: `_journal_date.accepted`,
-  `_journal_date.from_coeditor`, `_journal_date.printers_final`, etc.
-- `_journal_coeditor.*` placeholders: `_journal_coeditor.code`,
-  `_journal_coeditor.name`, `_journal_coeditor.notes`.
-- `_publ_contact_author.*` placeholders: `_publ_contact_author.name`,
-  `_publ_contact_author.address`, `_publ_contact_author.email`,
-  `_publ_contact_author.phone`, `_publ_contact_author.id_ORCID`,
-  `_publ_contact_author.id_IUCr`.
-- `_publ_author.*` loop placeholders (`_publ_author.name`,
-  `_publ_author.address`, `_publ_author.footnote`,
-  `_publ_author.id_ORCID`, `_publ_author.id_IUCr`).
-- `_publ_body.*` for section content (`_publ_body.title`,
-  `_publ_body.contents`).
+- No `_journal.*`, `_journal_date.*`, `_journal_coeditor.*`,
+  `_publ_contact_author.*`, `_publ_author.*`, `_publ_body.*`, or
+  `_pd_meas.info_author_*` placeholders are emitted in v1. The clean
+  report policy and deferred tag list live in
+  [`project-summary-rendering.md`](project-summary-rendering.md) §5.
 - `_chemical_formula.*` chemistry summary derived from atom-site data
   where possible: `_chemical_formula.sum`, `_chemical_formula.moiety`,
   `_chemical_formula.weight`, `_chemical_formula.IUPAC` (uppercase IUPAC
   per dictionary).
 
-User-supplied publication metadata override (`publ_info.json` or
-similar) is deferred — see Deferred Work.
+User-supplied publication metadata (`publ_info.json`, `publ_info.toml`,
+or a Python `project.publication` owner) is deferred — see Deferred
+Work and the clean report policy in `project-summary-rendering.md` §5.
 
 #### 2.3a-i `_easydiffraction_software` framework
 
-The IUCr submission needs to identify the analysis stack. The project
+The IUCr-aligned report needs to identify the analysis stack. The project
 emits one structured category in `data_global` from `analysis.software`,
 carrying three role-keyed strings and an optional fit timestamp:
 
@@ -687,8 +675,9 @@ For each constant-wavelength (CWL) diffraction pattern:
 
 - `_pd_meas.*` measurement metadata (`_pd_meas.scan_method`,
   `_pd_meas.2theta_range_min/max/inc`, `_pd_meas.number_of_points`,
-  `_pd_meas.datetime_initiated`,
-  `_pd_meas.info_author_{name, email, phone}` placeholders).
+  `_pd_meas.datetime_initiated`). The
+  `_pd_meas.info_author_{name, email, phone}` placeholders are omitted
+  by the clean report policy.
 - `_diffrn.*` and `_diffrn_radiation_wavelength.*` (radiation type,
   probe, wavelength).
 - `_pd_proc.2theta_range_min/max/inc`, `_pd_proc.info_data_reduction`,
@@ -819,8 +808,9 @@ raising `EasyDiffractionWriterError`), value-type matching against
 loop columns, and well-formed DDLm dotted form. It never covered
 crystallographic sanity checks (bond lengths, void volumes, density
 plausibility, missed-symmetry detection, ADP positive-definiteness) or
-whether `?` placeholders in `_journal.*` / `_publ_*` had been filled —
-those remain a separate IUCr-server concern.
+whether future journal-submission metadata is complete — that remains a
+separate IUCr-server concern. The v1 clean report CIF does not emit the
+empty `_journal.*` / `_publ_*` placeholders.
 
 ### 3. Handler mechanism — `iucr_name` + `IucrCategoryTransformer`
 
@@ -984,17 +974,18 @@ Policy:
   recognisable to scientists familiar with `_refine_ls.*` /
   `_pd_proc_ls.*` from Rietveld publications; the IUCr export carries
   the matching dictionary-canonical category prefixes per topology.
-- IUCr submission becomes a single explicit report command, with no
-  manual editing required: `project.report.save_cif()` produces an
-  upload-ready file at `reports/<project>.cif` matching the
-  multi-datablock publication convention. Users who want CIF reports on
-  every project save can set `project.report.cif = True`.
-- Publication-metadata placeholders are emitted as `?` in `data_global`
-  so users know where to fill in journal-required info before
-  submission.
-- External IUCr tooling (publCIF, checkCIF, pdCIFplotter,
-  journal-submission pipelines) consumes the submission file cleanly;
-  the day-to-day saved files are not a tooling target.
+- The report CIF becomes a single explicit report command, with no
+  manual editing required for the refinement data:
+  `project.report.save_cif()` produces a clean file at
+  `reports/<project>.cif` matching the multi-datablock publication
+  convention for structural and fit content. Users who want CIF reports
+  on every project save can set `project.report.cif = True`.
+- Journal and author metadata placeholders are omitted from
+  `data_global`; a future submission-specific surface can add them when
+  a concrete journal workflow requires them.
+- External IUCr tooling (publCIF, checkCIF, pdCIFplotter) can consume
+  the report file cleanly; the day-to-day saved files are not a tooling
+  target.
 - `_easydiffraction_*` prefix appears only in the IUCr export, where the
   explicit namespacing aids journal reviewers. It does not bloat
   day-to-day CIFs.
@@ -1122,12 +1113,12 @@ it.
 
 ## Deferred Work
 
-- **Publication-metadata override hook.** A user-supplied
-  `reports/publ_info.json` (or `publ_info.toml`) read by the IUCr report
-  writer to replace the `?` placeholders in `data_global` (`_journal.*`,
-  `_publ_*`, `_publ_author.*` loop entries). Out of scope for the first
-  pass; revisit once the IUCr export is shipping and users have feedback
-  on workflow friction.
+- **Journal-submission metadata surface.** A future ADR may introduce a
+  user-supplied `reports/publ_info.json` / `publ_info.toml` file or a
+  Python `project.publication` owner for `_journal.*`, `_publ_*`, and
+  `_publ_author.*` entries. V1 deliberately omits those placeholders so
+  generated report CIFs stay clean; revisit only with concrete user or
+  journal-portal requirements.
 - **Crystallographic sanity validation.** The §2.5 validator covers spec
   compliance only. A future pass could integrate IUCr's web checkCIF
   (HTTP POST to the checkCIF endpoint) or bundle a local subset of its
diff --git a/docs/dev/adrs/accepted/project-facade-and-persistence.md b/docs/dev/adrs/accepted/project-facade-and-persistence.md
index 31ecec72a..7a3fcf66c 100644
--- a/docs/dev/adrs/accepted/project-facade-and-persistence.md
+++ b/docs/dev/adrs/accepted/project-facade-and-persistence.md
@@ -16,8 +16,8 @@ Persistence.
 
 `Project` is the top-level user facade. It owns project metadata,
 structures, experiments, rendering preferences, display helpers,
-analysis, report helpers, publication metadata, verbosity, and save/load
-behavior.
+analysis, report helpers, verbosity, and save/load behavior. Journal and
+publication metadata are deferred from the v1 facade.
 
 A later proposal considered renaming this facade to `Workspace` so that
 `project` could be reserved for the scientific project information
@@ -57,12 +57,14 @@ hybrid surface: its scalar output configuration persists to
 under `reports/`. The previous `project.summary` placeholder and its
 `summary.cif` output are not part of the persistence layout.
 
-Expose journal-submission metadata as `project.publication`. It is a
-top-level owner with CIF-aligned sibling categories for `_journal.*`,
+Do not expose journal-submission metadata as `project.publication` in
+v1. The clean report policy in
+[`project-summary-rendering.md`](project-summary-rendering.md) §5 keeps
+`project.cif` and generated report CIFs free of empty `_journal.*`,
 `_journal_date.*`, `_journal_coeditor.*`, `_publ_contact_author.*`,
-`_publ_body.*`, and the `_publ_author.*` loop. These singleton
-publication categories persist in `project.cif` and feed report exports;
-`reports/<project>.cif` remains export-only.
+`_publ_body.*`, `_publ_author.*`, and `_pd_meas.info_author_*` fields.
+Those tags are deferred for a future journal-submission metadata
+surface.
 
 Keep project information available as `project.info`. The Python name
 avoids a confusing `project.project` access path, while the persisted
@@ -91,9 +93,7 @@ it must not emit a `_project.path` CIF item.
 
 The project-level singleton categories currently persisted in
 `project.cif` are `_project.*`, `_rendering_plot.*`, `_report.*`,
-`_rendering_table.*`, `_verbosity.*`, `_journal.*`, `_journal_date.*`,
-`_journal_coeditor.*`, `_publ_contact_author.*`, `_publ_body.*`, and the
-`_publ_author.*` loop.
+`_rendering_table.*`, and `_verbosity.*`.
 
 ## Consequences
 
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index 260bf459d..d330f6432 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -18,7 +18,8 @@ Runs alongside, and **extends**, the accepted
 - A `project.save(report=True)` opt-in flag for the IUCr CIF.
 
 That ADR currently scopes `project.report` to **CIF only** — the
-multi-datablock IUCr submission CIF written to `reports/<project>.cif`.
+multi-datablock IUCr-aligned report CIF written to
+`reports/<project>.cif`.
 This ADR keeps the facade and adds a **`project.report` configuration
 category** with five scalar persisted fields (`cif`, `html`, `tex`,
 `pdf`, `html_offline`) on `project.cif`, plus ad-hoc per-format methods
@@ -50,18 +51,17 @@ Open Questions section is empty):
   `project.save()` (§1.4). HTML, TeX, and PDF outputs are not
   gemmi-validatable and get no pre-write validation; LaTeX errors
   surface at PDF-compile time via the TeX engine. A writer that emits
-  non-compliant CIF raises `EasyDiffractionWriterError` instead. This
-  ADR's deferred `check_completeness()` (publication-side completeness)
-  is a separate concern that stays in Deferred Work.
-- **Publication metadata source** — the alignment ADR's Deferred Work
-  proposes a user-supplied `reports/publ_info.{toml,json}` to replace
-  `?` placeholders. Both write paths read the same Python attribute,
-  **`project.publication`** — a new top-level on `Project`, sibling to
-  `project.info` and `project.analysis`. The schema is defined in §5 of
-  this ADR: six CIF-aligned sibling categories (`journal`,
-  `journal_date`, `journal_coeditor`, `contact_author`, `body`,
-  `authors`) with full IUCr-tag fidelity. The loader accepts TOML
-  (primary) and JSON (fallback); selection is by file extension.
+  non-compliant CIF raises `EasyDiffractionWriterError` instead.
+  Completeness checks for a future journal-submission metadata surface
+  stay in Deferred Work and are not part of the v1 clean report CIF.
+- **Clean report metadata** — the alignment ADR's Deferred Work
+  proposed user-supplied `reports/publ_info.{toml,json}` data to replace
+  `?` placeholders. This ADR rejects that v1 surface. There is no
+  `project.publication` owner in v1, `project.cif` does not persist
+  journal/publication metadata, and the report CIF does not emit empty
+  journal, author, publication-body, or powder-measurement author
+  placeholders. Section 5 records the deferred tags so they can be
+  reconsidered later without keeping empty fields in current reports.
 
 Also touches:
 
@@ -74,15 +74,14 @@ Also touches:
 - [`project-facade-and-persistence.md`](../accepted/project-facade-and-persistence.md)
   — two changes: `project.report` gains a persisted configuration
   category (`_report.*` in `project.cif`, see §1.3), turning the facade
-  into a hybrid of helper methods plus persisted config; and a new
-  top-level `project.publication` owner is added alongside the existing
-  `project.info`, `project.structures`, `project.experiments`,
-  `project.analysis`, `project.report` facade slots (see §5).
+  into a hybrid of helper methods plus persisted config; and the
+  previously proposed `project.publication` owner is rejected for v1 so
+  empty journal metadata stays out of `project.cif` (see §5).
 - [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
-  — owns the Python↔CIF correspondence rule for **two** new
-  project-level singleton surfaces: `project.report.* ↔ _report.*` (five
-  scalar items, §1.3) and `project.publication.*` sibling categories ↔
-  `_journal.*`, `_publ_author.*`, `_publ_contact_author.*`, etc. (§5).
+  — owns the Python↔CIF correspondence rule for the new
+  `project.report.* ↔ _report.*` project-level singleton surface (five
+  scalar items, §1.3). The rejected `project.publication.*` surface is
+  recorded in §5 for future reconsideration, not accepted for v1.
 
 ## Context
 
@@ -150,12 +149,11 @@ In scope:
   Persisted in `analysis/analysis.cif` (amends the IUCr ADR's "Analysis
   — unchanged" stance for these fields; see §4 and the ADRs-amended
   list).
-- Add a new top-level `project.publication` owner on `Project` (sibling
-  to `project.info`, `project.structures`, `project.experiments`,
-  `project.analysis`, `project.report`) carrying the `_publ_*` /
-  `_journal_*` publication metadata the IUCr writer otherwise emits as
-  `?` placeholders. See §5; amends `project-facade-and-persistence.md`
-  and complements `python-cif-category-correspondence.md`.
+- Reject the previously proposed top-level `project.publication` owner
+  for v1. Journal, author, publication-body, and powder-measurement
+  author tags are not represented in code, are not persisted in
+  `project.cif`, and are not emitted as empty fields in the report CIF.
+  See §5 for the deferred tag list and the retained report-CIF fields.
 - Ship exactly one LaTeX style (`iucrjournals`) — no style selector, no
   `ReportStyleEnum`, no `_report.style` field. Multi-style support
   (REVTeX, Elsevier, etc.) is deferred to a follow-up ADR; see "Deferred
@@ -166,7 +164,7 @@ Out of scope:
 - CIF tag-name decisions for any serialised field. Those are the
   alignment ADR's job; this ADR notes recommended mappings and
   cross-references.
-- The IUCr CIF submission export tag policy and multi-datablock layout.
+- The IUCr-aligned report CIF export tag policy and multi-datablock layout.
   Covered by the alignment ADR; the output file lives at
   `reports/<project>.cif` and is opt-in via `project.report.cif = True`.
 - Pre-existing project-level singleton categories (`_info.*`,
@@ -460,7 +458,7 @@ The split is summarised below.
 | `project.rendering_table`            | A       | `project.cif` (`_rendering_table.*`)     | `CategoryItem` (one field)                           |
 | `project.verbosity`                  | A       | `project.cif` (`_verbosity.*`)           | `CategoryItem` (one field)                           |
 | **`project.report`** (this ADR)      | **A**   | **`project.cif` (`_report.*`)**          | **`CategoryItem` (five fields) plus action methods** |
-| `project.publication` (this ADR, §5) | A       | `project.cif` (`_publ_*` / `_journal_*`) | `CategoryOwner` of six sibling categories            |
+| `project.publication` (rejected, §5) | n/a     | none                                     | no v1 Python surface                                 |
 | `project.analysis`                   | B       | `analysis/analysis.cif`                  | `CategoryOwner` (heavy datablock)                    |
 | `project.structures[name]`           | B       | `structures/<name>.cif`                  | `CategoryOwner` (heavy datablock)                    |
 | `project.experiments[name]`          | B       | `experiments/<name>.cif`                 | `CategoryOwner` (heavy datablock)                    |
@@ -542,11 +540,10 @@ overhead to a one-time ~200 ms session cost. The
 `EasyDiffractionWriterError` includes the full gemmi diagnostic so bug
 reports are actionable.
 
-A separate, _completeness_-oriented check
-(`project.report.check_completeness()`) — flagging unfilled `_publ_*` /
-`_journal_*` placeholders for journal submission, which is a
-publication-readiness question rather than a writer-correctness one — is
-a different concern and stays in Deferred Work.
+A separate, _completeness_-oriented check for a future
+journal-submission metadata surface is a different concern and stays in
+Deferred Work. The v1 report does not expose or fill `_publ_*` /
+`_journal_*` placeholders.
 
 #### 1.5 Descriptor display metadata — `DisplayHandler`
 
@@ -1063,7 +1060,7 @@ Single style (`iucrjournals`) — no multi-style infrastructure.
   # reports/ directory does not exist
 ```
 
-`project.report.cif = True` (journal-submission CIF only):
+`project.report.cif = True` (clean IUCr-aligned report CIF only):
 
 ```
 <project_root>/
@@ -1088,7 +1085,7 @@ inspection page):
     <project>.html                  # ~3 MB, Plotly inlined
 ```
 
-`project.report.cif/html/pdf = True` (typical pre-submission bundle):
+`project.report.cif/html/pdf = True` (typical review bundle):
 
 ```
 <project_root>/
@@ -1097,7 +1094,7 @@ inspection page):
   experiments/<...>.cif
   analysis/analysis.cif
   reports/
-    <project>.cif                   # journal-submission CIF
+    <project>.cif                   # clean IUCr-aligned report CIF
     <project>.html                  # interactive inspection page
     <project>.pdf                   # typeset PDF, iucrjournals class
     tex/                            # source for the PDF (kept editable)
@@ -1156,9 +1153,8 @@ when there is a concrete second style to ship.
 The generated document uses the project title directly in `\title{...}`
 and emits an empty `\author{}`. If `project.info.description` is
 non-empty, that text becomes the document abstract; if it is empty, the
-abstract environment is omitted. Publication metadata
-(`project.publication.*`) is not included in the human-readable HTML or
-TeX/PDF reports.
+abstract environment is omitted. Journal/publication metadata is not
+included in the human-readable HTML or TeX/PDF reports.
 
 #### 3.2.1 Source provenance and bundled files
 
@@ -1565,26 +1561,25 @@ public API surface treats missing provenance uniformly:
   end-to-end so users iterating on a configuration before fitting see
   the rest of the page.
 - **IUCr CIF export (`project.report.cif = True`).** The
-  `_easydiffraction_software.{framework, calculator, minimizer}` triple
-  emits `?` placeholders consistent with the IUCr ADR's unset-field
-  convention. The derived `_computing.structure_refinement` string falls
-  back to `"EasyDiffraction <version>"` (framework only). The
-  `_easydiffraction_software.fit_datetime` tag is omitted entirely (no
-  `?` — the absence is the signal).
+  `_computing.structure_refinement` string falls back to
+  `"EasyDiffraction <version>"` when calculator or minimizer provenance
+  is unavailable. `_easydiffraction_software.framework` is emitted from
+  the framework label; `_easydiffraction_software.calculator`,
+  `_easydiffraction_software.minimizer`, and
+  `_easydiffraction_software.fit_datetime` are emitted only when the
+  corresponding fit snapshot values exist.
 - **Internal validation (the §1.4 pre-write gemmi pass).** Does **not**
   detect missing provenance. The gemmi pass validates that emitted tags
   and types match the IUCr core / pdCIF dictionaries, and it explicitly
   skips the `_easydiffraction_*` extension namespace. So the
   fallback-filled `_computing.structure_refinement`
   (`"EasyDiffraction <version>"`) is not flagged as missing — it's a
-  valid string — and the `?` placeholders on
-  `_easydiffraction_software.{framework, calculator, minimizer}` are not
-  flagged either, because gemmi does not validate the extension
-  namespace. Detecting "publication-grade provenance is incomplete" is a
-  different concern from dictionary-spec compliance and falls to the
-  deferred `project.report.check_completeness()` listed in Deferred
-  Work. Users who must guarantee complete provenance before submission
-  should run that check (once it lands) or inspect the rendered report
+  valid string — and omitted optional `_easydiffraction_software.*`
+  fields are not flagged because gemmi does not validate the extension
+  namespace. Detecting complete provenance is a different concern from
+  dictionary-spec compliance and falls to a deferred completeness check.
+  Users who must guarantee complete provenance should run that check
+  (once it lands) or inspect the rendered report
   manually.
 - **Old projects.** Loading a project saved before this ADR produces an
   `analysis.software` with all fields unset and the timestamp `None`. No
@@ -1592,121 +1587,80 @@ public API surface treats missing provenance uniformly:
   the fit.
 
 This rule applies wholesale — no flag toggles it, no targeted exception
-is raised. Publication-grade users who need the provenance can re-run
-the fit; users producing draft / preview reports keep working without
+is raised. Users who need full provenance can re-run the fit; users
+producing draft / preview reports keep working without
 interruption.
 
-### 5. Publication-metadata category on `project`
-
-New top-level category on `Project`, sibling to `project.info` and
-`project.analysis`. Populated by the user (directly in Python, or loaded
-from a `publ_info.{toml,json}` file). Feeds the `_publ_*` / `_journal_*`
-/ `_publ_author.*` placeholders that the alignment ADR's `data_global`
-block currently emits as `?` (alignment ADR §2.3a).
-
-#### 5.1 Structure — CIF-aligned sibling categories
-
-`Publication` is a category-owner (like `Experiment`) hosting sibling
-sub-categories that map **1:1 to CIF category prefixes**. No artificial
-groupings; the CIF dictionaries already provide the natural shape:
-
-| Python attribute               | CIF category             | Audience                                                                                                                              |
-| ------------------------------ | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
-| `publication.journal`          | `_journal.*`             | User-set at submission (`name_full`, `paper_category`); editor-set post-acceptance (`year`, `volume`, `issue`, `page_*`, `paper_doi`) |
-| `publication.journal_date`     | `_journal_date.*`        | Editor (`accepted`, `from_coeditor`, `printers_final`)                                                                                |
-| `publication.journal_coeditor` | `_journal_coeditor.*`    | Editor (`code`, `name`, `notes`)                                                                                                      |
-| `publication.contact_author`   | `_publ_contact_author.*` | User (`name`, `address`, `email`, `phone`, `id_orcid`, `id_iucr`)                                                                     |
-| `publication.body`             | `_publ_body.*`           | User (`title`, `synopsis`, `abstract`, `keywords`)                                                                                    |
-| `publication.authors`          | `_publ_author.*` (loop)  | User (per author: `name`, `address`, `footnote`, `id_orcid`, `id_iucr`)                                                               |
-
-Access pattern:
-
-```python
-project.publication.journal.name_full       = "Acta Crystallographica E"
-project.publication.journal.paper_category  = "structure-report"
-project.publication.journal.paper_doi       = "10.1107/S2056989026..."   # post-acceptance
-project.publication.contact_author.name     = "Jane Doe"
-project.publication.contact_author.email    = "jane@example.com"
-project.publication.contact_author.id_orcid = "0000-0001-..."
-project.publication.body.title              = "Crystal structure of ..."
-project.publication.body.synopsis           = "Short summary..."
-project.publication.body.abstract           = "..."
-project.publication.body.keywords           = ["powder diffraction", "Rietveld", ...]
-project.publication.authors.add(name="Jane Doe",   id_orcid="0000-0001-...")
-project.publication.authors.add(name="John Smith", id_orcid="0000-0002-...")
-```
-
-Python attributes are lowercase snake_case (`id_orcid`); CIF tags retain
-dictionary casing (`_publ_contact_author.id_ORCID`). Loops use the
-project's existing `CategoryCollection` pattern (`add()`, indexed
-access, etc.).
-
-The editor-side categories (`journal_date`, `journal_coeditor`) exist so
-the schema can carry editor-supplied fields when a user manually copies
-them in (typically by editing `project.publication.*` in Python after a
-referee round) — not because users typically fill them at submission
-time. Defaults are `None`; the IUCr writer emits `?` for unset fields.
-Round-trip is on the **`project.cif`** axis only (`project.publication`
-reads and writes there per the project-facade-and-persistence contract);
-**the report CIF at `reports/<project>.cif` stays export-only** per the
-accepted IUCr ADR. A reader for `reports/<project>.cif` is explicitly
-out of scope.
-
-#### 5.2 Discrete `body` fields, not a markdown blob
-
-`_publ_body.*` in coreCIF supports nested section content via an
-`element` / `format` / `contents` trio. For the refinement-table
-appendix use case (user pastes content into a full manuscript later),
-discrete top-level slots are more discoverable than a generic markdown
-blob:
-
-- `publication.body.title` — manuscript title (single string)
-- `publication.body.synopsis` — short summary (IUCr Acta E requires
-  this)
-- `publication.body.abstract` — abstract text
-- `publication.body.keywords` — list of strings (loop on CIF side)
-
-A future v2 could add free-form section support
-(`publication.body.sections[]` with element/format/contents trios) when
-users produce full manuscripts from the library. Out of scope for v1.
-
-#### 5.3 Input mechanism — TOML primary, JSON fallback
-
-Two import paths, both writing into the same in-memory
-`project.publication` object:
-
-```python
-# Direct Python edit (preferred for notebook / interactive use):
-project.publication.contact_author.email = "jane@example.com"
-
-# File-based load (preferred for collaborative / batch workflows):
-project.publication.load("reports/publ_info.toml")    # TOML, by extension
-project.publication.load("reports/publ_info.json")    # JSON, by extension
-```
-
-TOML is the primary format:
-
-- **Comment support** — users can document why a field is set / unset.
-- **Multi-line strings** — abstracts, addresses, and synopses without
-  escaping.
-- **Familiar** — the project already uses `pyproject.toml` and
-  `pixi.toml`.
-- **Standard library** `tomllib` (Python 3.11+); no new dependency.
-
-JSON is supported as a fallback for programmatic generation (e.g. a user
-script that dumps publication data from a database; an external tool
-that produces JSON output). Standard library `json`.
-
-Format selection is by file extension. Unknown extensions raise
-`ValueError("Unsupported publication-info format: <ext>. " "Use .toml or .json.")`.
-No YAML support — adds a dependency for no gain.
-
-Reading from the report CIF (`reports/<project>.cif`) back into
-`project.publication` is **explicitly out of scope** here and remains
-the accepted IUCr ADR's "Export only — no round-trip" contract. Users
-who edit the report file by hand should also update
-`project.publication` (or its TOML/JSON source) so the next save
-reflects the edits; the library does not auto-import.
+### 5. Clean report-CIF metadata policy
+
+The v1 report CIF is a clean refinement report, not a journal-submission
+manuscript stub. It must not create a `project.publication` API surface,
+must not persist journal/publication metadata in `project.cif`, and must
+not emit report-CIF sections that only contain `?` placeholders.
+
+The report writer keeps only data-backed scientific content and
+generation/provenance metadata. Optional tags with no source value are
+omitted rather than written as empty fields. CIF unknown markers remain
+allowed only inside an otherwise useful emitted category or loop row
+where the dictionary shape requires a cell and dropping the row would
+lose real project data.
+
+#### 5.1 Deferred journal and author tags
+
+These tags are explicitly **not** part of the v1 code surface, default
+`project.cif`, or generated report CIF. They are recorded here for a
+future journal-submission ADR to reconsider against a concrete target
+journal or portal.
+
+- `_journal.name_full`, `_journal.year`, `_journal.volume`,
+  `_journal.issue`, `_journal.page_first`, `_journal.page_last`,
+  `_journal.paper_category`, `_journal.paper_DOI`,
+  `_journal.coden_ASTM`, `_journal.suppl_publ_number`.
+- `_journal_date.accepted`, `_journal_date.from_coeditor`,
+  `_journal_date.printers_final`.
+- `_journal_coeditor.code`, `_journal_coeditor.name`,
+  `_journal_coeditor.notes`.
+- `_publ_contact_author.name`, `_publ_contact_author.address`,
+  `_publ_contact_author.email`, `_publ_contact_author.phone`,
+  `_publ_contact_author.id_ORCID`, `_publ_contact_author.id_IUCr`.
+- `_publ_author.name`, `_publ_author.address`,
+  `_publ_author.footnote`, `_publ_author.id_ORCID`,
+  `_publ_author.id_IUCr`.
+- `_publ_body.title`, `_publ_body.synopsis`, `_publ_body.abstract`,
+  `_publ_body.keywords`, `_publ_body.contents`.
+- `_pd_meas.info_author_name`, `_pd_meas.info_author_email`,
+  `_pd_meas.info_author_phone`.
+
+The previously proposed `publ_info.{toml,json}` loader is deferred with
+these tags. It would be useful only when the library commits to a
+submission-oriented publication metadata surface; it is unnecessary for
+a clean report CIF.
+
+#### 5.2 Kept report-CIF fields and rationale
+
+The report CIF keeps the following tag families when the project has
+source data for them.
+
+| Tag family | Tags retained | Rationale |
+| --- | --- | --- |
+| Audit | `_audit.creation_method`, `_audit.creation_date` | Identifies the EasyDiffraction writer and report-generation time. These are generated by the library, not user-authored empty metadata. |
+| Software provenance | `_computing.structure_refinement`; `_easydiffraction_software.framework`, `_easydiffraction_software.calculator`, `_easydiffraction_software.minimizer`, `_easydiffraction_software.fit_datetime` | Records the analysis stack in a standard IUCr text field plus structured EasyDiffraction fields. `fit_datetime` is emitted only when a fit snapshot exists. |
+| Chemical formula | `_chemical_formula.sum`, `_chemical_formula.moiety`, `_chemical_formula.weight`, `_chemical_formula.IUPAC` | Summarises chemistry derived from structure atom sites. These fields describe the refined model, not journal administration. |
+| Unit cell | `_cell.length_a`, `_cell.length_b`, `_cell.length_c`, `_cell.angle_alpha`, `_cell.angle_beta`, `_cell.angle_gamma` | Core crystallographic model parameters needed to understand and reuse a structure block. |
+| Space group | `_space_group.name_H-M_alt`, `_space_group.IT_coordinate_system_code`, `_space_group.crystal_system`; `_space_group_symop.id`, `_space_group_symop.operation_xyz` | Gives symmetry in standard coreCIF form and includes explicit operations for downstream tools. |
+| Atom sites | `_atom_site.label`, `_atom_site.type_symbol`, `_atom_site.fract_x`, `_atom_site.fract_y`, `_atom_site.fract_z`, `_atom_site.occupancy`, `_atom_site.ADP_type`, `_atom_site.B_iso_or_equiv` or `_atom_site.U_iso_or_equiv`, `_atom_site.Wyckoff_symbol` | Carries the refined structural model. The B/U split follows the accepted ADP policy and dictionary names. |
+| Anisotropic ADPs | `_atom_site_aniso.label`, `_atom_site_aniso.B_11`, `_atom_site_aniso.B_22`, `_atom_site_aniso.B_33`, `_atom_site_aniso.B_12`, `_atom_site_aniso.B_13`, `_atom_site_aniso.B_23`, or the matching `U_*` items | Carries anisotropic displacement parameters when present, using one ADP family per emitted loop. |
+| Diffraction conditions | `_diffrn.ambient_temperature`, `_diffrn.ambient_pressure`, `_diffrn_radiation.probe`, `_diffrn_radiation_wavelength.id`, `_diffrn_radiation_wavelength.value`, `_diffrn_radiation_wavelength.wt` | Describes measurement conditions and wavelength/probe information needed to interpret the refinement. |
+| Single-crystal refinement | `_refine_ls.R_factor_all`, `_refine_ls.wR_factor_all`, `_refine_ls.R_factor_gt`, `_refine_ls.wR_factor_gt`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints`, `_refine_ls.extinction_method`, `_refine_ls.extinction_coef`, `_refine.special_details` | Reports standard single-crystal fit quality and extinction details produced by the refinement state. |
+| Reflection summary | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression` | Summarises the reflection set used for single-crystal quality metrics. |
+| Single-crystal reflections | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_refln.F_squared_meas_su`, `_refln.include_status` | Provides the measured/calculated reflection data needed to inspect the fit. |
+| Powder block cross-references | `_pd_block_id`, `_pd_block_diffractogram_id`, `_pd_phase_block.id`, `_pd_phase_block.scale` | Links overall, phase, and pattern blocks in multi-block powder reports. |
+| Powder measurement and profile | `_pd_meas.scan_method`, `_pd_meas.number_of_points`, `_pd_meas.2theta_scan` or `_pd_meas.time_of_flight`, `_pd_meas.intensity_total`, `_pd_calc.intensity_total`, `_pd_proc.intensity_bkg_calc`, `_pd_proc_ls.weight` | Carries the observed, calculated, background, and weight arrays for profile inspection. The author-info placeholders are excluded by §5.1. |
+| Powder processing | `_pd_proc.info_data_reduction`, `_pd_proc.info_datetime`, `_pd_proc.info_excluded_regions` | Documents processing state that affects the profile fit. Empty free-text fields are omitted until real source data exists. |
+| Powder refinement | `_pd_calc.method`, `_pd_proc_ls.prof_R_factor`, `_pd_proc_ls.prof_wR_factor`, `_pd_proc_ls.prof_wR_expected`, `_pd_proc_ls.profile_function`, `_pd_proc_ls.background_function`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints` | Reports Rietveld method, profile quality metrics, and model-size counts in standard pdCIF/coreCIF fields. |
+| Powder reflections | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_pd_refln.phase_id`, `_refln.d_spacing` | Keeps calculated powder reflection information tied to the contributing phase. |
+| TOF calibration | `_pd_calib_d_to_tof.id`, `_pd_calib_d_to_tof.power`, `_pd_calib_d_to_tof.coeff`, `_pd_calib_d_to_tof.coeff_su`, `_pd_calib_d_to_tof.diffractogram_id` | Required for time-of-flight powder reports when non-zero calibration coefficients are present. |
+| EasyDiffraction extensions | `_easydiffraction_experiment_type.sample_form`, `_easydiffraction_experiment_type.beam_mode`, `_easydiffraction_experiment_type.radiation_probe`, `_easydiffraction_experiment_type.scattering_type`, `_easydiffraction_calculator.type`, `_easydiffraction_peak.type`, `_easydiffraction_background.type`, `_easydiffraction_sc_crystal_block.id`, `_easydiffraction_sc_crystal_block.scale`, `_easydiffraction_diffrn.ambient_magnetic_field`, `_easydiffraction_diffrn.ambient_electric_field`, `_easydiffraction_extinction.type`, `_easydiffraction_extinction.model`, `_easydiffraction_extinction.mosaicity`, `_easydiffraction_extinction.radius` | Preserves EasyDiffraction-specific state that has no exact coreCIF/pdCIF equivalent but is needed to trace how the reported fit was configured. |
 
 ### 6. Shared `ReportDataContext` + Jinja templates
 
@@ -1793,14 +1747,6 @@ def data_context(self) -> dict:
             'constraints': ...,
         },
         'software': {...},  # from §4
-        'publication': {     # from project.publication (§5); unset fields → None
-            'journal':          {...},   # _journal.*
-            'journal_date':     {...},   # _journal_date.* (editor-side)
-            'journal_coeditor': {...},   # _journal_coeditor.* (editor-side)
-            'contact_author':   {...},   # _publ_contact_author.*
-            'body':             {...},   # _publ_body.{title, synopsis, abstract, keywords}
-            'authors':          [...],   # _publ_author.* loop
-        },
         'metadata': {
             'easydiffraction_version': ...,
             'generated_at': ...,
@@ -1992,25 +1938,15 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      existing `_audit.creation_date` keeps its
      `_iso_creation_datetime()` source (report-generation time) and is
      **not** overwritten — fit time and report time are distinct events.
-  5. **Publication metadata in the default save.** The alignment ADR's
-     Scope explicitly excluded "Adding new CIF categories the project
-     does not currently track (`_chemical.*`, `_publ.*`, `_journal.*`)
-     **for the default save**" (alignment ADR §Scope, lines 101-110).
-     This ADR adds `project.publication.*` (§5) and persists it to
-     `project.cif` — a different file from `reports/<project>.cif`, but
-     still a default-save change that the alignment ADR did not
-     anticipate. Specifically:
-     - `_publ_contact_author.*`, `_publ_author.*`, `_publ_body.*`,
-       `_journal.*`, `_journal_date.*`, `_journal_coeditor.*` are now in
-       scope for `project.cif`.
-     - The accepted IUCr export still reads these from
-       `project.publication.*` and emits them in `data_global` per
-       §2.3a; the `?` placeholder semantics for unset fields are
-       unchanged.
-     - The accepted "Export only — no round-trip" rule for
-       `reports/<project>.cif` is **unaffected** — `project.publication`
-       round-trips through `project.cif`, not through the report CIF
-       (see §5.1 / §5.3).
+  5. **Publication metadata excluded from the default save and report
+     CIF.** The alignment ADR's Scope explicitly excluded "Adding new
+     CIF categories the project does not currently track
+     (`_chemical.*`, `_publ.*`, `_journal.*`) **for the default save**"
+     (alignment ADR §Scope, lines 101-110). This ADR keeps that
+     exclusion for `_publ_*` and `_journal_*`: no `project.publication`
+     owner is added, no journal/publication metadata is persisted to
+     `project.cif`, and the report CIF omits the empty publication and
+     powder-measurement author placeholders listed in §5.1.
 
   All other IUCr-export decisions in the alignment ADR (multi-datablock
   layout, tag-name policy, gemmi as the validation engine) are
@@ -2023,7 +1959,7 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
 - [`analysis-cif-fit-state.md`](../accepted/analysis-cif-fit-state.md) —
   adds `analysis.software` to the persisted analysis state.
 - [`project-facade-and-persistence.md`](../accepted/project-facade-and-persistence.md)
-  — three changes:
+  — three points:
   1. **`project.report` gains a persisted configuration category.** The
      accepted ADR scoped `project.report` as a CIF-write helper (single
      output: `reports/<project>.cif`). This ADR extends it with a
@@ -2032,34 +1968,26 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      every save. The facade becomes a hybrid — helper methods
      (`save_*()`) **and** persisted configuration on the same Python
      object.
-  2. **New top-level `project.publication` facade slot (§5).** Sibling
-     to `project.info`, `project.structures`, `project.experiments`,
-     `project.analysis`, `project.report`. Persisted to `project.cif`
-     next to the other project-level singleton categories.
-  3. **Project-level singleton category enumeration extended.** The
-     accepted ADR enumerates `_info.*`, `_rendering_plot.*`,
+  2. **No top-level `project.publication` facade slot in v1 (§5).** The
+     previously considered journal/publication metadata surface is
+     deferred so `project.cif` stays free of empty manuscript and
+     journal-administration fields.
+  3. **Project-level singleton category enumeration extended only by
+     `_report.*`.** The accepted ADR enumerates `_info.*`,
+     `_rendering_plot.*`,
      `_rendering_table.*`, `_verbosity.*` as the project-level singleton
-     categories owned by `project.cif`. This ADR adds two more to that
-     enumeration: `_report.*` (this ADR §1.3) and `_publication.*`
-     family (this ADR §5; concrete sub-prefixes are `_publ_*` and
-     `_journal_*` per IUCr coreCIF).
+     categories owned by `project.cif`. This ADR adds `_report.*` (this
+     ADR §1.3) and explicitly does not add `_publ_*`, `_journal_*`, or
+     any `_publication.*` family.
 - [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
-  — owns the Python-to-CIF correspondence rule for two new project-level
-  singleton surfaces:
+  — owns the Python-to-CIF correspondence rule for one new project-level
+  singleton surface:
   - `project.report.*` ↔ `_report.*` — five scalar items (four format
     booleans plus `html_offline`) per §1.3.
-  - `project.publication.*` ↔ `_publ_*` / `_journal_*` sibling
-    categories per §5. Python attributes are lowercase snake_case
-    (`id_orcid`); CIF tags retain dictionary casing
-    (`_publ_contact_author.id_ORCID`).
-
-  Both follow the correspondence ADR's existing 1:1 mapping pattern. The
-  correspondence ADR's enumeration of "currently persisted Python
-  category surfaces" gains two rows for these additions.
 
-  No conflict with the correspondence ADR's project-level category list
-  because `_publ_*` / `_journal_*` are publication-domain, not
-  project-level singleton categories.
+  The rejected `project.publication.*` ↔ `_publ_*` / `_journal_*`
+  mapping is deferred in §5 and must not be added to the current
+  project-level category list.
 
 ## Open Questions
 
@@ -2160,12 +2088,10 @@ browser anyway. Deferred.
   matplotlib-rendered PDF figures for the LaTeX path while keeping
   pgfplots as the default. Tune when needed.
 - Tab/accordion navigation in HTML for projects with many experiments.
-- `project.report.check_completeness()` — complements the internal gemmi
-  pass from §1.4 (dictionary spec compliance, enforced before every CIF
-  write). The completeness check would flag whether the user has filled
-  in `_publ_*` / `_journal_*` placeholders for their target journal,
-  which dictionary validation cannot determine. Different concern,
-  different layer.
+- A future journal-submission completeness check — complements the
+  internal gemmi pass from §1.4 (dictionary spec compliance, enforced
+  before every CIF write). It would belong with a future
+  journal-metadata surface, not with the v1 clean report CIF.
 - A pinned-snapshot variant of `<project>.html` (timestamped, kept next
   to fit-run-specific artifacts) for users who want to track refinement
   history visually across saves.
@@ -2182,7 +2108,7 @@ browser anyway. Deferred.
 **Description:**
 
 Builds on the IUCr CIF alignment work by filling in the non-CIF half of
-the publication bundle. The `project.report` facade covers four output
+the report bundle. The `project.report` facade covers four output
 formats — CIF, HTML, TeX, PDF — chosen via a configuration category on
 the project (persisted in `project.cif`) and applied automatically on
 every save:
diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index f362f485f..3687d3cf2 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -38,7 +38,7 @@ folders.
 | Persistence          | Accepted   | Free-Flag CIF Encoding                    | Encodes fit free/fixed state through CIF uncertainty syntax instead of a separate free list.                          | [`free-flag-cif-encoding.md`](accepted/free-flag-cif-encoding.md)                            |
 | Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                       | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                    |
 | Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                    | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)            |
-| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds an IUCr submission report export.                             | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
+| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds a clean IUCr-aligned report export.                          | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
 | Persistence          | Suggestion | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then proposes scoped one-to-one mapping for project-level categories.     | [`python-cif-category-correspondence.md`](suggestions/python-cif-category-correspondence.md) |
 | Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
 | Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                              |
@@ -46,7 +46,7 @@ folders.
 | User-facing API      | Accepted   | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures.   | [`crysview-structure-visualization.md`](accepted/crysview-structure-visualization.md)        |
 | User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                          | [`display-ux.md`](accepted/display-ux.md)                                                    |
 | User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.       | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                    |
-| User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and publication metadata surfaces.                | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
+| User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and clean report-CIF metadata policy.             | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
 | User-facing API      | Accepted   | Selector Families                         | Distinguishes backend selectors, switchable-category selectors, and active-sibling selectors.                         | [`selector-families.md`](accepted/selector-families.md)                                      |
 | User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                         | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)      |
 | User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.     | [`switchable-category-api.md`](accepted/switchable-category-api.md)                          |

From 1f8448935abe5361e559212cd9b3da7cf132fcd4 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 20:46:17 +0200
Subject: [PATCH 114/160] Simplify CIF block naming in reports

---
 .../adrs/accepted/iucr-cif-tag-alignment.md   | 109 ++++++++++--------
 .../accepted/project-summary-rendering.md     |   2 +-
 2 files changed, 63 insertions(+), 48 deletions(-)

diff --git a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
index b8fdeaee9..8f07e18c9 100644
--- a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
+++ b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
@@ -388,20 +388,20 @@ mgo_rietveld/
     analysis.cif
   reports/
     mgo_rietveld.cif                      # data_global               — audit, software, _chemical_formula
-                                          # data_mgo_rietveld_overall — _pd_proc_ls.prof_R_factor,
-                                          #                              .prof_wR_factor,
-                                          #                              .prof_wR_expected,
-                                          #                              .profile_function,
-                                          #                              .background_function,
-                                          #                              _refine_ls.number_parameters,
-                                          #                              _pd_block_id cross-refs
-                                          # data_mgo_rietveld_phase_0 — MgO structure
-                                          # data_mgo_rietveld_pwd_0    — _pd_meas.* profile loop
-                                          #                              (_2theta_scan, intensity_total,
-                                          #                              _pd_calc.intensity_total,
-                                          #                              _pd_proc.intensity_bkg_calc,
-                                          #                              _pd_proc_ls.weight),
-                                          #                              _refln.* powder reflections loop
+                                          # data_overall — _pd_proc_ls.prof_R_factor,
+                                          #                .prof_wR_factor,
+                                          #                .prof_wR_expected,
+                                          #                .profile_function,
+                                          #                .background_function,
+                                          #                _refine_ls.number_parameters,
+                                          #                _pd_block_id cross-refs
+                                          # data_mgo     — MgO structure
+                                          # data_npd     — _pd_meas.* profile loop
+                                          #                (_2theta_scan, intensity_total,
+                                          #                _pd_calc.intensity_total,
+                                          #                _pd_proc.intensity_bkg_calc,
+                                          #                _pd_proc_ls.weight),
+                                          #                _refln.* powder reflections loop
 ```
 
 **Example C — Joint Rietveld, multi-experiment (neutron + X-ray).**
@@ -418,11 +418,11 @@ co2sio4/
     analysis.cif                          # _joint_fit weights
   reports/
     co2sio4.cif                           # data_global          — audit, software, chemistry
-                                          # data_co2sio4_overall  — combined refinement stats
-                                          # data_co2sio4_phase_0  — Co2SiO4 structure
-                                          # data_co2sio4_pwd_0    — NPD pattern,
+                                          # data_overall     — combined refinement stats
+                                          # data_co2sio4     — Co2SiO4 structure
+                                          # data_npd_300K    — NPD pattern,
                                           #                          _pd_block_diffractogram_id='npd_300K'
-                                          # data_co2sio4_pwd_1    — XRD pattern,
+                                          # data_xrd_300K    — XRD pattern,
                                           #                          _pd_block_diffractogram_id='xrd_300K'
 ```
 
@@ -442,14 +442,14 @@ co2sio4_t_series/
     analysis.cif                          # _sequential_fit configuration
   reports/
     co2sio4_t_series.cif                  # data_global                  — audit, software, chemistry
-                                          # data_co2sio4_t_series_overall
-                                          # data_co2sio4_t_series_phase_0
-                                          # data_co2sio4_t_series_pwd_0  — TOF 5K,
+                                          # data_overall
+                                          # data_co2sio4
+                                          # data_tof_5K   — TOF 5K,
                                           #                                 _pd_meas.time_of_flight,
                                           #                                 _pd_calib_d_to_tof loop
-                                          # data_co2sio4_t_series_pwd_1  — TOF 100K
-                                          # data_co2sio4_t_series_pwd_2  — TOF 165K
-                                          # data_co2sio4_t_series_pwd_3  — TOF 200K
+                                          # data_tof_100K — TOF 100K
+                                          # data_tof_165K — TOF 165K
+                                          # data_tof_200K — TOF 200K
 ```
 
 #### 2.3 Multi-datablock layout inside the export file
@@ -460,8 +460,8 @@ analysis topology. Block content uses dotted DDLm form throughout. The
 single-block-name rule is uniform across topologies; topology-specific
 GSAS-II-style suffix conventions seen in some example files (e.g.
 `data_<project>_publ`, `data_<project>_overall`) are folded into
-`data_global` for global metadata and `data_<project>_overall`
-for refinement metadata, leaving no ambiguity about block roles.
+`data_global` for global metadata and `data_overall` for refinement
+metadata, leaving no ambiguity about block roles.
 
 - **Single-crystal, single structure (single experiment).**
   `data_global` + `data_<structure>` (or `data_I` if no name is set).
@@ -476,30 +476,42 @@ for refinement metadata, leaving no ambiguity about block roles.
   multi-phase).** GSAS-II-style block split, with the global metadata
   block named `data_global` per the invariant above:
   - `data_global` (audit, software, and chemistry metadata per §2.3a),
-  - `data_<project>_overall` (refinement-level metadata — Rietveld
-    R-factors, profile/background function descriptors, parameter
-    counts),
-  - `data_<project>_phase_N` (one per phase — structural data per
+  - `data_overall` (refinement-level metadata — Rietveld R-factors,
+    profile/background function descriptors, parameter counts),
+  - `data_<structure-name>` (one per phase — structural data per
     `_pd_phase_block.id`),
-  - `data_<project>_pwd_N` (one per diffraction pattern — measurement
-    metadata, profile data loop, reflections loop).
+  - `data_<experiment-name>` (one per diffraction pattern —
+    measurement metadata, profile data loop, reflections loop).
 
   This deviates from the `data_<project>_publ` GSAS-II convention seen
   in `hb8206.cif`; the deviation buys a uniform rule across
   single-crystal and powder exports and matches the single-crystal
   corpus (`bal5004`, etc.) which uses `data_global` universally.
+  `data_overall` is deliberately unprefixed because the generated report
+  CIF is already scoped to one project. `global` means file/report
+  metadata; `overall` means combined refinement summary. Phase and
+  diffractogram blocks use the existing structure and experiment names
+  after CIF block-code normalization; if two normalized names collide,
+  append a short numeric suffix to preserve uniqueness.
 
 - **Multi-experiment joint Rietveld.** Same shape as the
-  single-experiment Rietveld block split above, with additional `_pwd_N`
-  blocks per pattern, all cross-referenced via
-  `_pd_block_diffractogram_id` and `_pd_block_id` pipe-delimited
-  identifiers (e.g. `2025-12-06T14:46|binimetinib_3|noname|PubInfo`,
-  format mirrored from `hb8206.cif`).
+  single-experiment Rietveld block split above, with one
+  `data_<experiment-name>` block per pattern, all cross-referenced via
+  `_pd_block_diffractogram_id` and `_pd_block_id`.
+
+  `_pd_block_id` identifies phase/model blocks; in this report that is
+  the `data_<structure-name>` block ID. `_pd_block_diffractogram_id`
+  identifies diffractogram/pattern blocks; in this report that is the
+  `data_<experiment-name>` block ID. For single references, emit the
+  scalar block ID directly (for example `_pd_block_id lbco`, not
+  `_pd_block_id |lbco|`). If multiple phases/patterns are needed, use a
+  proper loop or move toward the newer pdCIF replacement fields, not
+  encode lists in one scalar with pipes.
 
 - **Sequential fit.** One file per step is **not** the IUCr convention;
-  sequential refinements emit one `data_<project>_pwd_N` block per step
-  inside the same `reports/<project>.cif`. Natural sequential ordering
-  matches the multi-pattern Rietveld pattern above.
+  sequential refinements emit one `data_<experiment-name>` block per
+  step inside the same `reports/<project>.cif`. Natural sequential
+  ordering matches the multi-pattern Rietveld pattern above.
 
 #### 2.3a `data_global` block content
 
@@ -569,8 +581,8 @@ identification triple above.
 
 #### 2.3b Structure-block content (per-block)
 
-For each `data_<structure>` (single-crystal) or `data_<project>_phase_N`
-(powder Rietveld) block:
+For each `data_<structure>` (single-crystal) or
+`data_<structure-name>` (powder Rietveld phase) block:
 
 - `_chemical_formula.{moiety, sum, weight, IUPAC}` summary.
 - `_cell.*` (`length_a`, `angle_alpha`, `volume`,
@@ -652,7 +664,7 @@ For TOF experiments, the `_pd_meas.2theta_scan` column is replaced by
 `_pd_meas.time_of_flight`. Verified against `bal5001.cif` (content set;
 tag form follows `cif_pow.dic`).
 
-#### 2.3f `data_<project>_overall` block (Rietveld only)
+#### 2.3f `data_overall` block (Rietveld only)
 
 For powder Rietveld files, an `_overall` block carries refinement-level
 metadata that applies across all phases and patterns:
@@ -666,10 +678,13 @@ metadata that applies across all phases and patterns:
   is applied).
 - `_refine_ls.number_parameters`, `_refine_ls.number_restraints`,
   `_refine_ls.number_constraints`.
-- `_pd_block_id` pipe-delimited cross-reference values pointing to the
-  phase and pattern blocks.
+- `_pd_block_id` references to phase/model blocks and
+  `_pd_block_diffractogram_id` references to diffractogram/pattern
+  blocks. Single references are plain scalar IDs. Multiple
+  phases/patterns should use a proper loop or newer pdCIF replacement
+  fields, not pipe-delimited scalar lists.
 
-#### 2.3g `data_<project>_pwd_N` block (Rietveld only — constant wavelength)
+#### 2.3g `data_<experiment-name>` block (Rietveld only — constant wavelength)
 
 For each constant-wavelength (CWL) diffraction pattern:
 
@@ -686,7 +701,7 @@ For each constant-wavelength (CWL) diffraction pattern:
 - The `_pd_meas.*` profile-data loop (§2.3e).
 - The `_refln.*` reflections loop (§2.3d).
 
-#### 2.3h `data_<project>_pwd_N` block (Rietveld only — TOF)
+#### 2.3h `data_<experiment-name>` block (Rietveld only — TOF)
 
 For time-of-flight (TOF) diffraction patterns the block has the same
 shape as §2.3g, with three TOF-specific substitutions — **all defined in
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index d330f6432..c0a7dbc55 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -1654,7 +1654,7 @@ source data for them.
 | Single-crystal refinement | `_refine_ls.R_factor_all`, `_refine_ls.wR_factor_all`, `_refine_ls.R_factor_gt`, `_refine_ls.wR_factor_gt`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints`, `_refine_ls.extinction_method`, `_refine_ls.extinction_coef`, `_refine.special_details` | Reports standard single-crystal fit quality and extinction details produced by the refinement state. |
 | Reflection summary | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression` | Summarises the reflection set used for single-crystal quality metrics. |
 | Single-crystal reflections | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_refln.F_squared_meas_su`, `_refln.include_status` | Provides the measured/calculated reflection data needed to inspect the fit. |
-| Powder block cross-references | `_pd_block_id`, `_pd_block_diffractogram_id`, `_pd_phase_block.id`, `_pd_phase_block.scale` | Links overall, phase, and pattern blocks in multi-block powder reports. |
+| Powder block cross-references | `_pd_block_id`, `_pd_block_diffractogram_id`, `_pd_phase_block.id`, `_pd_phase_block.scale` | Links `data_overall`, phase/model blocks, and diffractogram/pattern blocks in multi-block powder reports. The block-name and scalar-reference policy is defined in the CIF-alignment ADR §2.3. |
 | Powder measurement and profile | `_pd_meas.scan_method`, `_pd_meas.number_of_points`, `_pd_meas.2theta_scan` or `_pd_meas.time_of_flight`, `_pd_meas.intensity_total`, `_pd_calc.intensity_total`, `_pd_proc.intensity_bkg_calc`, `_pd_proc_ls.weight` | Carries the observed, calculated, background, and weight arrays for profile inspection. The author-info placeholders are excluded by §5.1. |
 | Powder processing | `_pd_proc.info_data_reduction`, `_pd_proc.info_datetime`, `_pd_proc.info_excluded_regions` | Documents processing state that affects the profile fit. Empty free-text fields are omitted until real source data exists. |
 | Powder refinement | `_pd_calc.method`, `_pd_proc_ls.prof_R_factor`, `_pd_proc_ls.prof_wR_factor`, `_pd_proc_ls.prof_wR_expected`, `_pd_proc_ls.profile_function`, `_pd_proc_ls.background_function`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints` | Reports Rietveld method, profile quality metrics, and model-size counts in standard pdCIF/coreCIF fields. |

From 65eaaadde590a182248c1aeb146588adfd2b0ea5 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 21:02:26 +0200
Subject: [PATCH 115/160] Polish structure view dark mode and labels toggle

---
 .../display/structure/renderers/threejs.py    |  16 +-
 .../structure/templates/structure.html.j2     | 150 +++++++++++++-----
 src/easydiffraction/io/cif/iucr_writer.py     |   2 +-
 src/easydiffraction/project/display.py        |   3 +-
 .../structure/renderers/test_threejs.py       |  40 +++++
 5 files changed, 164 insertions(+), 47 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 4a8ceed06..53bd769d2 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -123,7 +123,7 @@ def _scene_payload(scene: StructureScene) -> dict:
         ],
         'cellEdges': edges,
         'axes': axes,
-        'labels': [{'anchor': label.anchor, 'text': label.text} for label in scene.labels],
+        'labels': _label_payload(scene),
         'legend': [{'symbol': entry.symbol, 'colour': entry.colour} for entry in scene.legend],
         'palettes': {
             scheme.value: {
@@ -134,6 +134,20 @@ def _scene_payload(scene: StructureScene) -> dict:
     }
 
 
+def _label_payload(scene: StructureScene) -> list[dict[str, object]]:
+    """Return explicit labels, or atom labels for runtime toggling."""
+    if scene.labels:
+        return [{'anchor': label.anchor, 'text': label.text} for label in scene.labels]
+    labels = [{'anchor': atom.centre, 'text': atom.label} for atom in scene.atoms]
+    labels.extend(
+        {'anchor': sphere.centre, 'text': sphere.label} for sphere in scene.occupancy_spheres
+    )
+    labels.extend(
+        {'anchor': ellipsoid.centre, 'text': ellipsoid.label} for ellipsoid in scene.ellipsoids
+    )
+    return labels
+
+
 def _rgb_css(rgb: tuple[int, int, int]) -> str:
     return f'rgb({rgb[0]}, {rgb[1]}, {rgb[2]})'
 
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 0f575425f..f3d5a57e6 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -1,4 +1,4 @@
-<div id="{{ container_id }}" class="crysview" style="position:relative;width:100%;height:480px;
+<div id="{{ container_id }}" class="crysview" style="position:relative;width:100%;height:512px;
      background:{{ background }};color:{{ foreground }};border:1px solid rgba(128,128,128,0.3);
      border-radius:0;box-sizing:border-box;overflow:hidden;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
   <div class="cv-canvas" style="position:absolute;inset:0;"></div>
@@ -10,9 +10,38 @@
 
 <style>
   #{{ container_id }} .cv-card {
-    position: absolute; z-index: 10; background: rgba(255, 255, 255, 0.94);
-    border: 1px solid #e2e2e2; border-radius: 0;
-    box-shadow: 0 1px 6px rgba(0, 0, 0, 0.12); font-size: 12px; color: #222;
+    position: absolute; z-index: 10; background: var(--cv-panel-bg);
+    border: 1px solid var(--cv-panel-border); border-radius: 0;
+    box-shadow: var(--cv-panel-shadow); font-size: 12px; color: var(--cv-panel-fg);
+  }
+  #{{ container_id }} {
+    --cv-control-h: 32px;
+    --cv-axis-letter-size: 18px;
+{% if theme == 'dark' %}
+    --cv-panel-bg: rgba(37, 37, 43, 0.95);
+    --cv-panel-border: #52545c;
+    --cv-panel-fg: {{ foreground }};
+    --cv-panel-shadow: 0 1px 8px rgba(0, 0, 0, 0.38);
+    --cv-control-bg: #2c2f37;
+    --cv-control-hover-bg: #373b45;
+    --cv-control-active-bg: #3d4657;
+    --cv-control-active-border: #63708a;
+    --cv-control-fg: {{ foreground }};
+    --cv-control-muted: #8d929e;
+    --cv-select-arrow: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%23ebebeb' stroke-width='1.3'/%3E%3C/svg%3E");
+{% else %}
+    --cv-panel-bg: rgba(255, 255, 255, 0.94);
+    --cv-panel-border: #e2e2e2;
+    --cv-panel-fg: #222;
+    --cv-panel-shadow: 0 1px 6px rgba(0, 0, 0, 0.12);
+    --cv-control-bg: #f5f5f6;
+    --cv-control-hover-bg: #e9eaef;
+    --cv-control-active-bg: #e7ecf5;
+    --cv-control-active-border: #c6d0e2;
+    --cv-control-fg: #2a3f5f;
+    --cv-control-muted: #b9bdc6;
+    --cv-select-arrow: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%232a3f5f' stroke-width='1.3'/%3E%3C/svg%3E");
+{% endif %}
   }
   #{{ container_id }} .cv-modebar {
     top: 10px; right: 10px; display: flex; align-items: center; gap: 16px;
@@ -21,22 +50,31 @@
   }
   #{{ container_id }} .mb-grp { display: flex; gap: 4px; }
   #{{ container_id }} .mb {
-    width: 32px; height: 30px; display: inline-flex; align-items: center;
+    width: 32px; height: var(--cv-control-h); display: inline-flex; align-items: center;
     justify-content: center; padding: 0; border: 1px solid #dcdcdc; border-radius: 0;
-    background: #f5f5f6; color: #2a3f5f; cursor: pointer;
+    border-color: var(--cv-panel-border); background: var(--cv-control-bg);
+    color: var(--cv-control-fg); cursor: pointer;
     transition: background 0.12s, color 0.12s, border-color 0.12s;
   }
-  #{{ container_id }} .mb:hover { background: #e9eaef; }
+  #{{ container_id }} .mb:hover { background: var(--cv-control-hover-bg); }
   #{{ container_id }} .mb svg { width: 17px; height: 17px; display: block; }
-  #{{ container_id }} .mb.lt { font: 700 15px/1 Georgia, 'Times New Roman', serif; }
-  #{{ container_id }} .mb.tog { color: #b9bdc6; }
-  #{{ container_id }} .mb.tog.on { color: #2a3f5f; background: #e7ecf5; border-color: #c6d0e2; }
+  #{{ container_id }} .cv-axis-letter {
+    font: 700 var(--cv-axis-letter-size)/1 system-ui, -apple-system, 'Segoe UI', sans-serif;
+  }
+  #{{ container_id }} .mb.lt { font: 700 var(--cv-axis-letter-size)/1 system-ui, -apple-system, 'Segoe UI', sans-serif; }
+  #{{ container_id }} .mb.tog { color: var(--cv-control-muted); }
+  #{{ container_id }} .mb.tog.on {
+    color: var(--cv-control-fg); background: var(--cv-control-active-bg);
+    border-color: var(--cv-control-active-border);
+  }
   #{{ container_id }} .mb-select {
-    height: 30px; box-sizing: border-box; border: 1px solid #dcdcdc; border-radius: 0;
-    color: #2a3f5f; font-size: 12px; padding: 0 22px 0 8px; cursor: pointer;
+    height: var(--cv-control-h); box-sizing: border-box;
+    border: 1px solid var(--cv-panel-border); border-radius: 0;
+    color: var(--cv-control-fg); font-size: 12px; line-height: var(--cv-control-h);
+    padding: 0 22px 0 8px; cursor: pointer;
     -webkit-appearance: none; -moz-appearance: none; appearance: none;
-    background-color: #f5f5f6;
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%232a3f5f' stroke-width='1.3'/%3E%3C/svg%3E");
+    background-color: var(--cv-control-bg);
+    background-image: var(--cv-select-arrow);
     background-repeat: no-repeat; background-position: right 7px center; background-size: 9px 9px;
   }
   #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; text-align: left; }
@@ -46,8 +84,9 @@
   }
   #{{ container_id }} .cv-hint {
     position: absolute; z-index: 10; bottom: 8px; left: 10px; font-size: 11px;
-    color: #555; background: rgba(255, 255, 255, 0.82); padding: 5px 9px; border-radius: 0;
-    line-height: 1.5; text-align: left;
+    color: var(--cv-panel-fg); background: var(--cv-panel-bg);
+    border: 1px solid var(--cv-panel-border); padding: 5px 9px; border-radius: 0;
+    line-height: 1.5; text-align: left; box-shadow: var(--cv-panel-shadow);
   }
   #{{ container_id }} .cv-tooltip {
     position: absolute; z-index: 30; pointer-events: none; display: none;
@@ -79,6 +118,7 @@ const ICONS = {
   axes: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M5 19V6M5 19h13M5 19l7-7"/><path d="M5 6 3.3 8.2M5 6l1.7 2.2M18 19l-2.2-1.4M18 19l-2.2 1.4"/></svg>',
   atoms: '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="9.5" cy="13.5" r="5"/><circle cx="16.5" cy="8" r="3.2"/></svg>',
   bonds: '<svg viewBox="0 0 24 24"><line x1="8" y1="16" x2="16" y2="8" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"/><circle cx="6.7" cy="17.3" r="3.1" fill="currentColor"/><circle cx="17.3" cy="6.7" r="3.1" fill="currentColor"/></svg>',
+  asymmetricUnit: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.65" stroke-linecap="round" stroke-linejoin="round"><path d="M5 8.3 12 4l7 4.3v7.4L12 20l-7-4.3Z"/><path d="M5 8.3 12 12.4l7-4.1M12 12.4V20"/><circle cx="9" cy="9.5" r="2.35" fill="currentColor" stroke="none"/></svg>',
   moments: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20V5"/><path d="M7 10l5-6 5 6"/></svg>',
   labels: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round" stroke-linecap="round"><rect x="3.5" y="5" width="17" height="14" rx="2"/><path d="M9 15.5 12 8.5l3 7M10.1 13.2h3.8"/></svg>',
   camera: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"><path d="M4 8h3l1.5-2h7L17 8h3a1 1 0 0 1 1 1v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V9a1 1 0 0 1 1-1Z"/><circle cx="12" cy="13" r="3.4"/></svg>',
@@ -225,6 +265,7 @@ for (const label of SCENE.labels) {
   div.className = 'cv-atom-label';
   div.textContent = label.text;
   const obj = new CSS2DObject(div);
+  obj.visible = groups.labels.visible;
   obj.position.copy(vec(label.anchor));
   groups.labels.add(obj);
 }
@@ -312,7 +353,7 @@ const perspective = new THREE.PerspectiveCamera(45, aspect, Math.max(distance *
 // Ortho frustum sized to the projected extent; reserve a top band for the
 // modebar/legend so the cell sits a little lower and clears them.
 const orthoHalfH = Math.max(halfH, halfW / aspect);
-const topBandPx = 50;
+const topBandPx = 84;
 // Reserve a band at the top for the modebar by growing the vertical extent and
 // shifting the centre up, keeping width/height === aspect so spheres stay round.
 // (Adding the band only to `top` skews the frustum and distorts the scene.)
@@ -361,9 +402,9 @@ if (SCENE.axes && SCENE.axes.arrows.length === 3) {
     group.position.copy(origin);
     groups.axes.add(group);
     const div = document.createElement('div');
+    div.className = 'cv-axis-letter';
     div.textContent = arrow.letter;
     div.style.color = rgbCss(arrow.colour);
-    div.style.fontWeight = 'bold';
     const tag = new CSS2DObject(div);
     tag.position.copy(origin).addScaledVector(dir, total + orthoHalfH * 0.05);
     groups.axes.add(tag);
@@ -389,6 +430,24 @@ const viewAlong = (axisVector, upVector) => {
   camera.position.copy(target.clone().add(axisVector.clone().normalize().multiplyScalar(distance)));
   controls.update();
 };
+const projectedOnViewPlane = (vector, normal) => (
+  vector.clone().addScaledVector(normal, -vector.dot(normal))
+);
+const viewAlongAxis = (axisIndex) => {
+  const viewAxis = cellBasis[axisIndex].clone().normalize();
+  const remaining = cellBasis
+    .map((axis, index) => ({ axis, index }))
+    .filter(({ index }) => index !== axisIndex)
+    .sort((left, right) => right.axis.length() - left.axis.length());
+  let horizontal = projectedOnViewPlane(remaining[0].axis.clone().normalize(), viewAxis);
+  if (horizontal.lengthSq() < 1e-8) {
+    horizontal = projectedOnViewPlane(remaining[1].axis.clone().normalize(), viewAxis);
+  }
+  horizontal.normalize();
+  const look = viewAxis.clone().negate();
+  const up = new THREE.Vector3().crossVectors(horizontal, look).normalize();
+  viewAlong(viewAxis, up);
+};
 
 const iconButton = (parent, html, title, cls) => {
   const el = document.createElement('button');
@@ -415,8 +474,7 @@ if (SCENE.axes) {
   SCENE.axes.arrows.forEach((arrow, i) => {
     const button = iconButton(cameraGroup, arrow.letter, `View along ${arrow.letter}`, 'lt');
     button.style.color = rgbCss(arrow.colour);
-    const upAxis = i === 2 ? cellBasis[1] : cellBasis[2];
-    button.addEventListener('click', () => viewAlong(cellBasis[i], upAxis));
+    button.addEventListener('click', () => viewAlongAxis(i));
   });
 }
 
@@ -428,19 +486,23 @@ homeButton.addEventListener('click', () => {
   controls.update();
 });
 
-const downloadButton = iconButton(cameraGroup, ICONS.camera, 'Download PNG');
-downloadButton.addEventListener('click', () => {
-  renderer.render(scene, camera);
-  const link = document.createElement('a');
-  link.download = 'structure.png';
-  link.href = renderer.domElement.toDataURL('image/png');
-  link.click();
-});
-
 const featureGroup = document.createElement('div');
 featureGroup.className = 'mb-grp';
 let hasFeatureToggle = false;
-for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
+// Asymmetric-unit toggle: hide symmetry-equivalent copies, keep the reference atoms.
+const hasNonAU = SCENE.atoms.some((a) => !a.asymmetric)
+  || SCENE.wedgeSpheres.some((s) => !s.asymmetric)
+  || SCENE.ellipsoids.some((e) => !e.asymmetric);
+const addAsymmetricUnitToggle = (parent) => {
+  let auOnly = false;
+  const auButton = iconButton(parent, ICONS.asymmetricUnit, 'Asymmetric unit only', 'tog');
+  auButton.addEventListener('click', () => {
+    auOnly = !auOnly;
+    groups.atoms.children.forEach((m) => { m.visible = !auOnly || m.userData.asymmetric; });
+    auButton.classList.toggle('on', auOnly);
+  });
+};
+for (const name of ['atoms', 'labels', 'bonds', 'cell', 'axes', 'moments']) {
   if (!groups[name] || groups[name].children.length === 0) continue;
   hasFeatureToggle = true;
   const visible = groups[name].visible;
@@ -453,20 +515,7 @@ for (const name of ['cell', 'axes', 'atoms', 'bonds', 'moments', 'labels']) {
     groups[name].traverse((o) => { if (o.isCSS2DObject) o.visible = next; });
     button.classList.toggle('on', next);
   });
-}
-// Asymmetric-unit toggle: hide symmetry-equivalent copies, keep the reference atoms.
-const hasNonAU = SCENE.atoms.some((a) => !a.asymmetric)
-  || SCENE.wedgeSpheres.some((s) => !s.asymmetric)
-  || SCENE.ellipsoids.some((e) => !e.asymmetric);
-if (hasNonAU && groups.atoms.children.length) {
-  hasFeatureToggle = true;
-  let auOnly = false;
-  const auButton = iconButton(featureGroup, 'AU', 'Asymmetric unit only', 'lt tog');
-  auButton.addEventListener('click', () => {
-    auOnly = !auOnly;
-    groups.atoms.children.forEach((m) => { m.visible = !auOnly || m.userData.asymmetric; });
-    auButton.classList.toggle('on', auOnly);
-  });
+  if (name === 'labels' && hasNonAU) addAsymmetricUnitToggle(featureGroup);
 }
 if (hasFeatureToggle) {
   modebar.appendChild(featureGroup);
@@ -527,6 +576,19 @@ if (schemeNames.length > 1 && SCENE.legend.length) {
   modebar.appendChild(schemeGroup);
 }
 
+const exportGroup = document.createElement('div');
+exportGroup.className = 'mb-grp';
+modebar.appendChild(exportGroup);
+
+const downloadButton = iconButton(exportGroup, ICONS.camera, 'Download PNG');
+downloadButton.addEventListener('click', () => {
+  renderer.render(scene, camera);
+  const link = document.createElement('a');
+  link.download = 'structure.png';
+  link.href = renderer.domElement.toDataURL('image/png');
+  link.click();
+});
+
 const raycaster = new THREE.Raycaster();
 const pointer = new THREE.Vector2();
 renderer.domElement.addEventListener('pointermove', (event) => {
diff --git a/src/easydiffraction/io/cif/iucr_writer.py b/src/easydiffraction/io/cif/iucr_writer.py
index 1ee4f4f97..5b55a2703 100644
--- a/src/easydiffraction/io/cif/iucr_writer.py
+++ b/src/easydiffraction/io/cif/iucr_writer.py
@@ -136,7 +136,7 @@ def _render_iucr_cif(project: object) -> str:
     blocks = [_write_global_block(project)]
     blocks.extend(_write_sc_blocks(project))
     blocks.extend(_write_rietveld_blocks(project))
-    return f'\n{_BLOCK_SEPARATOR}\n'.join(blocks) + '\n'
+    return f'\n\n{_BLOCK_SEPARATOR}\n'.join(blocks) + '\n'
 
 
 def _write_global_block(project: object) -> str:
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 6da991c40..238cb8e3e 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -531,7 +531,8 @@ def structure(
 
             pathlib.Path(path).write_text(output, encoding='utf-8')
             return
-        console.paragraph(f"Structure 🧩 '{struct_name}'")
+        atom_view = self._project.structure_style.atom_view.value
+        console.paragraph(f"Structure 🧩 '{struct_name}' (Atom view type: '{atom_view}')")
         self._emit_structure_output(output)
 
     def show_structure_options(self, struct_name: str) -> None:
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 9e237678a..018c98862 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -349,6 +349,44 @@ def test_labels_expose_anchor_and_text(self):
 
         assert payload['labels'] == [{'anchor': (0.1, 0.2, 0.3), 'text': 'Fe1'}]
 
+    def test_labels_fallback_to_atom_primitives(self):
+        scene = StructureScene(
+            cell_basis=_IDENTITY_BASIS,
+            atoms=(
+                AtomSphere(
+                    centre=(0.0, 0.0, 0.0),
+                    radius=0.5,
+                    colour=(255, 0, 0),
+                    label='Fe',
+                ),
+            ),
+            occupancy_spheres=(
+                OccupancyWedgeSphere(
+                    centre=(0.5, 0.5, 0.5),
+                    radius=0.4,
+                    wedges=(OccupancyWedge(fraction=1.0, colour=(0, 0, 255)),),
+                    label='La/Ba',
+                ),
+            ),
+            ellipsoids=(
+                AdpEllipsoid(
+                    centre=(0.25, 0.25, 0.25),
+                    semi_axes=(0.3, 0.2, 0.1),
+                    orientation=((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+                    colour=(0, 255, 0),
+                    label='O',
+                ),
+            ),
+        )
+
+        payload = MUT._scene_payload(scene)
+
+        assert payload['labels'] == [
+            {'anchor': (0.0, 0.0, 0.0), 'text': 'Fe'},
+            {'anchor': (0.5, 0.5, 0.5), 'text': 'La/Ba'},
+            {'anchor': (0.25, 0.25, 0.25), 'text': 'O'},
+        ]
+
     def test_legend_exposes_symbol_and_colour(self):
         payload = MUT._scene_payload(_rich_scene())
 
@@ -481,6 +519,8 @@ def test_dark_theme_marks_document_dark(self, patched_theme):
             dark=True,
         )
         assert 'dark' in html
+        assert '--cv-panel-bg: rgba(37, 37, 43, 0.95);' in html
+        assert "stroke='%23ebebeb'" in html
 
     def test_offline_embeds_inlined_module(self, patched_theme):
         html = ThreeJsStructureRenderer().render(

From 7109297867ca0a640aeb9cf8943060e46ea16094 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 21:29:28 +0200
Subject: [PATCH 116/160] Refine structure view controls and report axes

---
 .../experiment/categories/peak/base.py        | 21 ++---
 .../display/structure/renderers/raster.py     | 82 +++++++++++++------
 .../structure/templates/structure.html.j2     | 17 ++--
 .../experiment/item/test_base_coverage.py     |  7 +-
 .../structure/renderers/test_raster.py        | 53 ++++++++++++
 .../structure/renderers/test_threejs.py       | 12 +++
 6 files changed, 142 insertions(+), 50 deletions(-)

diff --git a/src/easydiffraction/datablocks/experiment/categories/peak/base.py b/src/easydiffraction/datablocks/experiment/categories/peak/base.py
index 4569b041e..9359ad0ac 100644
--- a/src/easydiffraction/datablocks/experiment/categories/peak/base.py
+++ b/src/easydiffraction/datablocks/experiment/categories/peak/base.py
@@ -75,21 +75,12 @@ def show_supported(self) -> None:
         context = self._parent._peak_profile_context() if self._parent is not None else {}
         rows = self._supported_types(filters)
         aliases = [PeakFactory._local_alias_for(tag, **context) for tag, _ in rows]
-        show_aliases = any(alias != tag for alias, (tag, _) in zip(aliases, rows, strict=True))
-
-        if show_aliases:
-            columns_headers = ['', 'Type', 'Alias', 'Description']
-            columns_alignment = ['left', 'left', 'left', 'left']
-            columns_data = [
-                ['*' if tag == self.type else '', tag, alias, description]
-                for alias, (tag, description) in zip(aliases, rows, strict=True)
-            ]
-        else:
-            columns_headers = ['', 'Type', 'Description']
-            columns_alignment = ['left', 'left', 'left']
-            columns_data = [
-                ['*' if tag == self.type else '', tag, description] for tag, description in rows
-            ]
+        columns_headers = ['', 'Type', 'Description']
+        columns_alignment = ['left', 'left', 'left']
+        columns_data = [
+            ['*' if tag == self.type else '', alias, description]
+            for alias, (tag, description) in zip(aliases, rows, strict=True)
+        ]
 
         console.paragraph('Peak types')
         render_table(
diff --git a/src/easydiffraction/display/structure/renderers/raster.py b/src/easydiffraction/display/structure/renderers/raster.py
index c30883edc..8e39490b6 100644
--- a/src/easydiffraction/display/structure/renderers/raster.py
+++ b/src/easydiffraction/display/structure/renderers/raster.py
@@ -63,9 +63,11 @@
 _AXIS_HEAD_LENGTH_FRAC = 0.043
 _AXIS_OVERHANG_FRAC = 0.045  # minimum overhang past the cell corner
 _AXIS_GAP_FRAC = 0.02  # clear gap between a corner atom and the head base
+_AXIS_LABEL_GAP_FRAC = 0.025  # label centre beyond the rendered arrow tip
 _AXIS_SEGMENTS = 32  # tessellation of the shaft cylinder and head cone
 _AXIS_RESERVE = 1.24  # extent multiplier reserving room for the arrows
 _AXIS_PERP_THRESHOLD = 0.9  # pick a fallback up-vector when nearly vertical
+_VERTICAL_SHIFT_FRAC = 0.025  # nudge structure down in report frame
 
 _EPS = 1e-9  # degenerate length / denominator guard
 _EPS_NORM = 1e-12  # surface-normal renormalisation guard
@@ -305,6 +307,33 @@ def _screen_fit(
     return scale, (lo + hi) / 2.0, extent
 
 
+def _axis_tip_vectors(
+    vectors: list[np.ndarray],
+    extent: float,
+    max_atom_r: float,
+) -> list[np.ndarray | None]:
+    """Return rendered axis-tip vectors from the triad origin."""
+    # Recover the longest cell edge from the builder's 0.3*max overhang.
+    max_axis = max((float(np.linalg.norm(v)) for v in vectors), default=1.0) / 1.3
+    head_len = _AXIS_HEAD_LENGTH_FRAC * extent
+    # Overhang clears the largest atom (so corner atoms never hide the
+    # head), plus the head length and a small gap.
+    overhang = max(
+        _AXIS_OVERHANG_FRAC * extent,
+        max_atom_r + head_len + _AXIS_GAP_FRAC * extent,
+    )
+    tips: list[np.ndarray | None] = []
+    for vector in vectors:
+        length = float(np.linalg.norm(vector))
+        if length < _EPS:
+            tips.append(None)
+            continue
+        axis = vector / length
+        axis_len = max(length - 0.3 * max_axis, 1e-3)
+        tips.append(axis * (axis_len + overhang))
+    return tips
+
+
 class RasterStructureRenderer:
     """Render a structure scene as a z-buffered PNG image."""
 
@@ -320,7 +349,7 @@ def render_png(self, scene: StructureScene, *, features: frozenset[str]) -> byte
             axis=(1, 3)
         )
         rgb = np.clip(downsampled * 255.0, 0, 255).astype(np.uint8)
-        return self._compose_png(rgb, scene, project, features)
+        return self._compose_png(rgb, scene, project, features, extent, pad)
 
     @staticmethod
     def _make_canvas(
@@ -341,7 +370,7 @@ def _make_canvas(
         def project(point: object) -> tuple[float, float, float]:
             rel = np.asarray(point, dtype=float) - target
             sx = (float(rel @ right) - centre2d[0]) * scale + size / 2.0
-            sy = size / 2.0 - (float(rel @ up) - centre2d[1]) * scale
+            sy = size / 2.0 - (float(rel @ up) - centre2d[1]) * scale + size * _VERTICAL_SHIFT_FRAC
             return sx, sy, float(rel @ view_dir)
 
         colour = np.ones((size, size, 3), dtype=np.float32)
@@ -386,6 +415,8 @@ def _compose_png(
         scene: StructureScene,
         project: Projector,
         features: frozenset[str],
+        extent: float,
+        max_atom_r: float,
     ) -> bytes:
         """Draw axis labels and the legend with Pillow, then encode."""
         from PIL import Image  # noqa: PLC0415
@@ -394,7 +425,9 @@ def _compose_png(
         image = Image.fromarray(rgb, mode='RGB')
         draw = ImageDraw.Draw(image)
         if 'axes' in features and scene.axes is not None:
-            RasterStructureRenderer._draw_axis_labels(draw, scene.axes, project)
+            RasterStructureRenderer._draw_axis_labels(
+                draw, scene.axes, project, extent, max_atom_r
+            )
         if scene.legend:
             RasterStructureRenderer._draw_legend(draw, scene.legend)
         buffer = io.BytesIO()
@@ -402,17 +435,26 @@ def _compose_png(
         return buffer.getvalue()
 
     @staticmethod
-    def _draw_axis_labels(draw: ImageDraw.ImageDraw, axes: AxisTriad, project: Projector) -> None:
+    def _draw_axis_labels(
+        draw: ImageDraw.ImageDraw,
+        axes: AxisTriad,
+        project: Projector,
+        extent: float,
+        max_atom_r: float,
+    ) -> None:
         """Place each axis letter just beyond its tip, always on top."""
         font = _font(int(_CANVAS * _LABEL_FRAC))
         inset = int(_CANVAS * 0.02)
         origin = np.asarray(axes.origin, dtype=float)
-        ox, oy, _od = project(axes.origin)
-        for arrow in axes.axes:
-            tip = origin + np.asarray(arrow.vector, dtype=float)
-            tx, ty, _td = project(tuple(tip))
-            lx = float(np.clip((ox + (tx - ox) * 1.08) / _SUPERSAMPLE, inset, _CANVAS - inset))
-            ly = float(np.clip((oy + (ty - oy) * 1.08) / _SUPERSAMPLE, inset, _CANVAS - inset))
+        vectors = [np.asarray(a.vector, dtype=float) for a in axes.axes]
+        tip_vectors = _axis_tip_vectors(vectors, extent, max_atom_r)
+        for arrow, tip_vector in zip(axes.axes, tip_vectors, strict=True):
+            if tip_vector is None:
+                continue
+            label = origin + tip_vector + _unit(tip_vector) * (_AXIS_LABEL_GAP_FRAC * extent)
+            lx, ly, _ld = project(tuple(label))
+            lx = float(np.clip(lx / _SUPERSAMPLE, inset, _CANVAS - inset))
+            ly = float(np.clip(ly / _SUPERSAMPLE, inset, _CANVAS - inset))
             draw.text((lx, ly), arrow.letter, font=font, fill=tuple(arrow.colour), anchor='mm')
 
     @staticmethod
@@ -680,22 +722,12 @@ def _axes(
         """Draw the a/b/c arrow triad beyond the cell corners."""
         origin = np.asarray(axes.origin, dtype=float)
         vectors = [np.asarray(a.vector, dtype=float) for a in axes.axes]
-        # Recover the longest cell edge (the builder adds a 0.3*max
-        # overhang).
-        max_axis = max((float(np.linalg.norm(v)) for v in vectors), default=1.0) / 1.3
-        head_len = _AXIS_HEAD_LENGTH_FRAC * extent
-        # Overhang clears the largest atom (so corner atoms never hide
-        # the head), plus the head length and a small gap.
-        overhang = max(
-            _AXIS_OVERHANG_FRAC * extent, max_atom_r + head_len + _AXIS_GAP_FRAC * extent
-        )
-        for arrow, vector in zip(axes.axes, vectors, strict=True):
-            length = float(np.linalg.norm(vector))
-            if length < _EPS:
+        for arrow, tip_vector in zip(
+            axes.axes, _axis_tip_vectors(vectors, extent, max_atom_r), strict=True
+        ):
+            if tip_vector is None:
                 continue
-            axis = vector / length
-            axis_len = max(length - 0.3 * max_axis, 1e-3)
-            self._arrow(canvas, basis, origin, axis * (axis_len + overhang), extent, arrow.colour)
+            self._arrow(canvas, basis, origin, tip_vector, extent, arrow.colour)
 
 
 def _shade_normals(normal: np.ndarray, base_rgb: np.ndarray) -> np.ndarray:
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index f3d5a57e6..df203b494 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -3,6 +3,7 @@
      border-radius:0;box-sizing:border-box;overflow:hidden;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
   <div class="cv-canvas" style="position:absolute;inset:0;"></div>
   <div class="cv-modebar cv-card"></div>
+  <div class="cv-download"></div>
   <div class="cv-legend cv-card"></div>
   <div class="cv-hint">drag = rotate<br>wheel = zoom<br>right-drag = pan</div>
   <div class="cv-tooltip"></div>
@@ -48,6 +49,9 @@
     padding: 0; flex-wrap: wrap; justify-content: flex-end; max-width: 80%;
     background: none; border: none; box-shadow: none;
   }
+  #{{ container_id }} .cv-download {
+    position: absolute; z-index: 10; right: 10px; bottom: 8px; display: flex;
+  }
   #{{ container_id }} .mb-grp { display: flex; gap: 4px; }
   #{{ container_id }} .mb {
     width: 32px; height: var(--cv-control-h); display: inline-flex; align-items: center;
@@ -116,9 +120,9 @@ const ICONS = {
   home: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 11 12 3l9 8"/><path d="M5 9.5V20h5v-6h4v6h5V9.5"/></svg>',
   cell: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round" stroke-linecap="round"><path d="M12 2.5 20 7v9l-8 4.5L4 16V7Z"/><path d="M4 7l8 4.5L20 7M12 11.5v9"/></svg>',
   axes: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M5 19V6M5 19h13M5 19l7-7"/><path d="M5 6 3.3 8.2M5 6l1.7 2.2M18 19l-2.2-1.4M18 19l-2.2 1.4"/></svg>',
-  atoms: '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="9.5" cy="13.5" r="5"/><circle cx="16.5" cy="8" r="3.2"/></svg>',
+  atoms: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><path d="M11.8 12.2 14 10M12.9 16.1l1.8.4"/><circle cx="9" cy="15" r="4.2" fill="currentColor" stroke="none"/><circle cx="16" cy="8" r="3" fill="currentColor" stroke="none"/><circle cx="17" cy="17" r="2.6" fill="currentColor" stroke="none"/></svg>',
   bonds: '<svg viewBox="0 0 24 24"><line x1="8" y1="16" x2="16" y2="8" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"/><circle cx="6.7" cy="17.3" r="3.1" fill="currentColor"/><circle cx="17.3" cy="6.7" r="3.1" fill="currentColor"/></svg>',
-  asymmetricUnit: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.65" stroke-linecap="round" stroke-linejoin="round"><path d="M5 8.3 12 4l7 4.3v7.4L12 20l-7-4.3Z"/><path d="M5 8.3 12 12.4l7-4.1M12 12.4V20"/><circle cx="9" cy="9.5" r="2.35" fill="currentColor" stroke="none"/></svg>',
+  asymmetricUnit: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><circle cx="9" cy="15" r="4.2" fill="currentColor" stroke="none"/><circle cx="16" cy="8" r="3" opacity=".48"/><circle cx="17" cy="17" r="2.6" opacity=".34"/><path d="M11.8 12.2 14 10M12.9 16.1l1.8.4" opacity=".34"/></svg>',
   moments: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20V5"/><path d="M7 10l5-6 5 6"/></svg>',
   labels: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round" stroke-linecap="round"><rect x="3.5" y="5" width="17" height="14" rx="2"/><path d="M9 15.5 12 8.5l3 7M10.1 13.2h3.8"/></svg>',
   camera: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"><path d="M4 8h3l1.5-2h7L17 8h3a1 1 0 0 1 1 1v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V9a1 1 0 0 1 1-1Z"/><circle cx="12" cy="13" r="3.4"/></svg>',
@@ -127,6 +131,7 @@ const ICONS = {
 const root = document.getElementById('{{ container_id }}');
 const host = root.querySelector('.cv-canvas');
 const modebar = root.querySelector('.cv-modebar');
+const downloadHost = root.querySelector('.cv-download');
 const legend = root.querySelector('.cv-legend');
 const tooltip = root.querySelector('.cv-tooltip');
 
@@ -515,7 +520,7 @@ for (const name of ['atoms', 'labels', 'bonds', 'cell', 'axes', 'moments']) {
     groups[name].traverse((o) => { if (o.isCSS2DObject) o.visible = next; });
     button.classList.toggle('on', next);
   });
-  if (name === 'labels' && hasNonAU) addAsymmetricUnitToggle(featureGroup);
+  if (name === 'atoms' && hasNonAU) addAsymmetricUnitToggle(featureGroup);
 }
 if (hasFeatureToggle) {
   modebar.appendChild(featureGroup);
@@ -576,11 +581,7 @@ if (schemeNames.length > 1 && SCENE.legend.length) {
   modebar.appendChild(schemeGroup);
 }
 
-const exportGroup = document.createElement('div');
-exportGroup.className = 'mb-grp';
-modebar.appendChild(exportGroup);
-
-const downloadButton = iconButton(exportGroup, ICONS.camera, 'Download PNG');
+const downloadButton = iconButton(downloadHost, ICONS.camera, 'Download PNG');
 downloadButton.addEventListener('click', () => {
   renderer.render(scene, camera);
   const link = document.createElement('a');
diff --git a/tests/unit/easydiffraction/datablocks/experiment/item/test_base_coverage.py b/tests/unit/easydiffraction/datablocks/experiment/item/test_base_coverage.py
index 92b399504..272781845 100644
--- a/tests/unit/easydiffraction/datablocks/experiment/item/test_base_coverage.py
+++ b/tests/unit/easydiffraction/datablocks/experiment/item/test_base_coverage.py
@@ -145,8 +145,11 @@ def test_show_peak_profile_types(self, capsys):
         out = capsys.readouterr().out
         assert len(out) > 0
 
-    def test_show_peak_profile_types_includes_current(self, capsys):
+    def test_show_peak_profile_types_uses_context_aliases(self, capsys):
         ex = ConcretePd(name='pd1', type=_mk_type_powder_cwl_bragg())
         ex.peak.show_supported()
         out = capsys.readouterr().out
-        assert str(ex.peak.type) in out
+        assert 'Alias' not in out
+        assert 'cwl-pseudo-voigt' not in out
+        assert 'pseudo-voigt' in out
+        assert 'pseudo-voigt + empirical asymmetry' in out
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
index fa5596b96..bfa426634 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_raster.py
@@ -10,6 +10,7 @@
 import pytest
 from PIL import Image
 
+from easydiffraction.display.structure.renderers import raster as MUT
 from easydiffraction.display.structure.renderers.raster import RasterStructureRenderer
 from easydiffraction.display.structure.scene import AdpEllipsoid
 from easydiffraction.display.structure.scene import AtomSphere
@@ -343,6 +344,58 @@ def test_no_legend_leaves_top_left_white(self):
 
 
 class TestViewBasis:
+    def test_projection_shifts_content_down_in_report_frame(self):
+        view_dir = np.array([0.0, 0.0, 1.0])
+        right = np.array([1.0, 0.0, 0.0])
+        up = np.array([0.0, 1.0, 0.0])
+
+        _canvas, project, _extent, _pad = RasterStructureRenderer._make_canvas(
+            _atom_scene(), view_dir, right, up
+        )
+
+        _x, y, _depth = project((0.0, 0.0, 0.0))
+        size = MUT._CANVAS * MUT._SUPERSAMPLE
+        assert y == pytest.approx(size * (0.5 + MUT._VERTICAL_SHIFT_FRAC))
+
+    def test_axis_labels_follow_rendered_arrow_tips(self):
+        class TextRecorder:
+            def __init__(self) -> None:
+                self.calls = []
+
+            def text(self, xy, text, font, fill, anchor) -> None:
+                del font, fill, anchor
+                self.calls.append((xy, text))
+
+        def project(point: tuple[float, float, float]) -> tuple[float, float, float]:
+            return (
+                (200.0 + point[0] * 100.0) * MUT._SUPERSAMPLE,
+                (200.0 - point[1] * 100.0) * MUT._SUPERSAMPLE,
+                point[2],
+            )
+
+        draw = TextRecorder()
+        axes = AxisTriad(
+            origin=(0.0, 0.0, 0.0),
+            axes=(
+                AxisArrow(vector=(6.5, 0.0, 0.0), colour=(255, 0, 0), letter='a'),
+                AxisArrow(vector=(0.0, 6.5, 0.0), colour=(0, 255, 0), letter='b'),
+                AxisArrow(vector=(0.0, 0.0, 6.5), colour=(0, 0, 255), letter='c'),
+            ),
+        )
+        extent = 10.0
+
+        RasterStructureRenderer._draw_axis_labels(draw, axes, project, extent, 0.0)
+
+        max_axis = 6.5 / 1.3
+        overhang = max(
+            MUT._AXIS_OVERHANG_FRAC * extent,
+            MUT._AXIS_HEAD_LENGTH_FRAC * extent + MUT._AXIS_GAP_FRAC * extent,
+        )
+        label_x = 200.0 + (6.5 - 0.3 * max_axis + overhang) * 100.0
+        label_x += MUT._AXIS_LABEL_GAP_FRAC * extent * 100.0
+        a_xy = next(xy for xy, text in draw.calls if text == 'a')
+        assert a_xy[0] == pytest.approx(label_x)
+
     def test_anisotropic_cell_renders(self):
         # An 8x5x3 cell drives the longest/middle/shortest axis ordering
         # in the default-view basis selection.
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 018c98862..dc731d3bf 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -585,6 +585,18 @@ def spy_dumps(obj, *args, **kwargs):
         )
         assert captured['features'] == ['atoms', 'bonds', 'cell']
 
+    def test_download_button_is_bottom_right_overlay(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+
+        assert '<div class="cv-download"></div>' in html
+        assert 'right: 10px; bottom: 8px;' in html
+        assert "iconButton(downloadHost, ICONS.camera, 'Download PNG')" in html
+
 
 # ------------------------------------------------------------------
 #  ThreeJsStructureRenderer.render — invalid inputs

From 38cda333fb64eac0743ba02a981ea6af51c551d2 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 21:36:46 +0200
Subject: [PATCH 117/160] Clean report CIF metadata and block references

---
 .../adrs/accepted/iucr-cif-tag-alignment.md   | 100 +--
 .../accepted/project-summary-rendering.md     | 133 ++--
 docs/dev/adrs/index.md                        |   2 +-
 docs/dev/package-structure/full.md            |  16 +-
 docs/dev/package-structure/short.md           |   6 +-
 src/easydiffraction/io/cif/iucr_writer.py     | 204 +-----
 .../categories/publication/__init__.py        |  15 -
 .../project/categories/publication/default.py | 657 ------------------
 .../project/categories/publication/factory.py |  17 -
 src/easydiffraction/project/project.py        |   9 -
 .../project/publication_loader.py             | 199 ------
 src/easydiffraction/report/data_context.py    |  77 +-
 .../io/cif/test_iucr_writer.py                |  35 +-
 .../categories/publication/test_default.py    |  20 -
 .../categories/publication/test_factory.py    |  25 -
 .../easydiffraction/project/test_project.py   |   1 +
 .../project/test_project_config.py            |   4 +
 .../project/test_publication_loader.py        |  57 --
 .../report/test_data_context.py               |   2 +-
 .../report/test_html_renderer.py              |   6 -
 .../report/test_tex_renderer.py               |  18 -
 21 files changed, 190 insertions(+), 1413 deletions(-)
 delete mode 100644 src/easydiffraction/project/categories/publication/__init__.py
 delete mode 100644 src/easydiffraction/project/categories/publication/default.py
 delete mode 100644 src/easydiffraction/project/categories/publication/factory.py
 delete mode 100644 src/easydiffraction/project/publication_loader.py
 delete mode 100644 tests/unit/easydiffraction/project/categories/publication/test_default.py
 delete mode 100644 tests/unit/easydiffraction/project/categories/publication/test_factory.py
 delete mode 100644 tests/unit/easydiffraction/project/test_publication_loader.py

diff --git a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
index 8f07e18c9..c925d63c2 100644
--- a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
+++ b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
@@ -160,44 +160,44 @@ Project CIF categories audited against `cif_core.dic` v3.4.0 and
 category changes in the default save; the "IUCr export" column shows the
 dotted DDLm tag emitted by the IUCr CIF report writer.
 
-| Category (current)                                                                              | IUCr dictionary                                                             | Default-save tier                           | IUCr export (dotted DDLm)                                                                                                                                                                  |
-| ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `_cell.*`                                                                                       | core                                                                        | Structure — unchanged                       | `_cell.length_a`, `_cell.angle_alpha`, etc.                                                                                                                                                |
-| `_atom_site.*` (most fields)                                                                    | core                                                                        | Structure — unchanged                       | `_atom_site.label`, `_atom_site.fract_x`, …                                                                                                                                                |
-| `_atom_site.adp_type`                                                                           | core (`_atom_site.ADP_type`)                                                | Structure — casing fix                      | `_atom_site.ADP_type` (uppercase ADP per dictionary).                                                                                                                                      |
-| `_atom_site.wyckoff_letter`                                                                     | core (`_atom_site.Wyckoff_symbol`)                                          | Structure — rename                          | `_atom_site.Wyckoff_symbol` (uppercase W, "symbol" not "letter").                                                                                                                          |
-| `_atom_site.B_iso_or_equiv` / `U_iso_or_equiv`                                                  | core                                                                        | Structure — single-tag emit                 | `_atom_site.B_iso_or_equiv` xor `_atom_site.U_iso_or_equiv` per row, based on `_atom_site.ADP_type`.                                                                                       |
-| `_atom_site_aniso.B_*` / `U_*`                                                                  | core                                                                        | Structure — single-tag emit                 | `_atom_site_aniso.B_*` xor `_atom_site_aniso.U_*` per row.                                                                                                                                 |
-| `_space_group.name_h_m`                                                                         | core (`_space_group.name_H-M_alt`)                                          | Structure — casing fix                      | `_space_group.name_H-M_alt`.                                                                                                                                                               |
-| `_space_group.it_coordinate_system_code`                                                        | core (`_space_group.IT_coordinate_system_code`)                             | Structure — casing fix                      | `_space_group.IT_coordinate_system_code`.                                                                                                                                                  |
-| symmetry operations                                                                             | core (`_space_group_symop.*`)                                               | (not emitted today)                         | `_space_group_symop.id` + `_space_group_symop.operation_xyz` loop alongside the H-M name.                                                                                                  |
-| `_diffrn.ambient_temperature`, `ambient_pressure`                                               | core                                                                        | Experiment — unchanged                      | `_diffrn.ambient_temperature`, `_diffrn.ambient_pressure`.                                                                                                                                 |
-| `_diffrn.ambient_magnetic_field`, `ambient_electric_field`                                      | none                                                                        | Experiment — unchanged                      | `_easydiffraction_diffrn.ambient_magnetic_field`, `…electric_field` (project extension).                                                                                                   |
-| `_refln.*`                                                                                      | core                                                                        | (no default save under refln)               | `_refln.*` reflections loop (column set differs by domain — see §2.3).                                                                                                                     |
-| `_pd_meas.*`, `_pd_proc.*`, `_pd_calc.*`, `_pd_data.*`                                          | pdCIF                                                                       | Experiment — unchanged                      | `_pd_meas.*`, `_pd_proc.*`, `_pd_calc.*` profile-data loop (see §2.3).                                                                                                                     |
-| `_pd_background.*`                                                                              | pdCIF                                                                       | Experiment — unchanged                      | `_pd_background.*`.                                                                                                                                                                        |
-| `_pd_phase_block.*`                                                                             | pdCIF                                                                       | Experiment — unchanged                      | `_pd_phase_block.*`.                                                                                                                                                                       |
-| `_sc_crystal_block.*`                                                                           | community (no IUCr counterpart)                                             | Experiment — unchanged                      | `_easydiffraction_sc_crystal_block.*` in IUCr export.                                                                                                                                      |
-| `_instr.wavelength`                                                                             | core (`_diffrn_radiation_wavelength.value`)                                 | Experiment — unchanged                      | `_diffrn_radiation_wavelength.{id, value, wt}` — single-row category for monochromatic; loop only for multi-λ.                                                                             |
-| `_instr.2theta_offset`                                                                          | pdCIF (`_pd_calib.2theta_offset`)                                           | Experiment — unchanged                      | `_pd_calib.2theta_offset`.                                                                                                                                                                 |
-| `_instr.2theta_bank`, `d_to_tof_*`                                                              | pdCIF (`_pd_calib_d_to_tof.*` loop)                                         | Experiment — unchanged                      | Four-row loop `_pd_calib_d_to_tof.{id, coeff, power, coeff_su, diffractogram_id}`.                                                                                                         |
-| `_peak.*` (parametric profile shape)                                                            | none (pdCIF has no shape parameters)                                        | Experiment — unchanged                      | `_easydiffraction_peak.*` + `_pd_proc_ls.profile_function` free-text descriptor.                                                                                                           |
-| `_extinction.*`                                                                                 | core (`_refine_ls.extinction_*` items)                                      | Experiment — unchanged                      | `_easydiffraction_extinction.*` + dual emit `_refine_ls.extinction_{method,coef,expression}`.                                                                                              |
-| `_excluded_region.*`                                                                            | pdCIF (`_pd_proc.info_excluded_regions` free-text)                          | Experiment — unchanged                      | `_easydiffraction_excluded_region.*` + `_pd_proc.info_excluded_regions` free-text rendering.                                                                                               |
-| `_expt_type.*`                                                                                  | none                                                                        | Experiment — unchanged                      | `_easydiffraction_experiment_type.*`.                                                                                                                                                      |
-| `_calculator.type`, `_minimizer.type`                                                           | none                                                                        | Analysis — unchanged                        | Selection fields remain settings only; identity is read from `analysis.software` for `_easydiffraction_software.{framework, calculator, minimizer}` and `_computing.structure_refinement`. |
-| `_software.*`                                                                                   | none                                                                        | Analysis — new provenance category          | Source for `_easydiffraction_software.{framework, calculator, minimizer}`, `_easydiffraction_software.fit_datetime`, and `_computing.structure_refinement` in `data_global`.               |
-| `_minimizer.*` settings (tolerances, max_iter, …)                                               | none                                                                        | Analysis — unchanged                        | `_easydiffraction_minimizer.*` (settings only, separate from the identification triple).                                                                                                   |
-| `_fitting_mode.type`, `_background.type`                                                        | none                                                                        | Analysis / Experiment — unchanged           | `_easydiffraction_fitting_mode.type`, `_easydiffraction_background.type` selectors.                                                                                                        |
-| `_fit_result.reduced_chi_square`, `n_data_points`, `n_parameters`                               | core (`_refine_ls.*`) and pdCIF (`_pd_proc_ls.*`)                           | Analysis — unchanged (topology-neutral)     | Shape-shifting per topology: see §1.2 and §3 transformers.                                                                                                                                 |
-| `_fit_result.*` (R-factors, counts, profile/background function)                                | core / pdCIF                                                                | Analysis — new fields under `_fit_result.*` | IUCr export remaps to per-topology `_refine_ls.*` / `_pd_proc_ls.*`; item names already match dictionary casing (§1.2).                                                                    |
-| `_fit_result.*` (Bayesian diagnostics, success, message, fitting_time, iterations, result_kind) | none                                                                        | Analysis — unchanged                        | `_easydiffraction_fit_result.*`.                                                                                                                                                           |
-| `_fit_parameter`, `_fit_parameter_correlation`                                                  | none / partial                                                              | Analysis — unchanged                        | `_easydiffraction_fit_parameter*` (no IUCr counterpart for per-parameter posterior).                                                                                                       |
-| `_alias`, `_constraint`                                                                         | none                                                                        | Analysis — unchanged                        | `_easydiffraction_alias*`, `_easydiffraction_constraint*`.                                                                                                                                 |
-| `_joint_fit`, `_sequential_fit*`                                                                | none                                                                        | Analysis — unchanged                        | `_easydiffraction_joint_fit*`, `_easydiffraction_sequential_fit*`.                                                                                                                         |
-| reflection-set aggregates                                                                       | core (`_reflns.*`)                                                          | Analysis — new fields                       | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression` (e.g. `'I>3\s(I)'`).                                                                                           |
+| Category (current)                                                                              | IUCr dictionary                                                                                                | Default-save tier                           | IUCr export (dotted DDLm)                                                                                                                                                                        |
+| ----------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `_cell.*`                                                                                       | core                                                                                                           | Structure — unchanged                       | `_cell.length_a`, `_cell.angle_alpha`, etc.                                                                                                                                                      |
+| `_atom_site.*` (most fields)                                                                    | core                                                                                                           | Structure — unchanged                       | `_atom_site.label`, `_atom_site.fract_x`, …                                                                                                                                                      |
+| `_atom_site.adp_type`                                                                           | core (`_atom_site.ADP_type`)                                                                                   | Structure — casing fix                      | `_atom_site.ADP_type` (uppercase ADP per dictionary).                                                                                                                                            |
+| `_atom_site.wyckoff_letter`                                                                     | core (`_atom_site.Wyckoff_symbol`)                                                                             | Structure — rename                          | `_atom_site.Wyckoff_symbol` (uppercase W, "symbol" not "letter").                                                                                                                                |
+| `_atom_site.B_iso_or_equiv` / `U_iso_or_equiv`                                                  | core                                                                                                           | Structure — single-tag emit                 | `_atom_site.B_iso_or_equiv` xor `_atom_site.U_iso_or_equiv` per row, based on `_atom_site.ADP_type`.                                                                                             |
+| `_atom_site_aniso.B_*` / `U_*`                                                                  | core                                                                                                           | Structure — single-tag emit                 | `_atom_site_aniso.B_*` xor `_atom_site_aniso.U_*` per row.                                                                                                                                       |
+| `_space_group.name_h_m`                                                                         | core (`_space_group.name_H-M_alt`)                                                                             | Structure — casing fix                      | `_space_group.name_H-M_alt`.                                                                                                                                                                     |
+| `_space_group.it_coordinate_system_code`                                                        | core (`_space_group.IT_coordinate_system_code`)                                                                | Structure — casing fix                      | `_space_group.IT_coordinate_system_code`.                                                                                                                                                        |
+| symmetry operations                                                                             | core (`_space_group_symop.*`)                                                                                  | (not emitted today)                         | `_space_group_symop.id` + `_space_group_symop.operation_xyz` loop alongside the H-M name.                                                                                                        |
+| `_diffrn.ambient_temperature`, `ambient_pressure`                                               | core                                                                                                           | Experiment — unchanged                      | `_diffrn.ambient_temperature`, `_diffrn.ambient_pressure`.                                                                                                                                       |
+| `_diffrn.ambient_magnetic_field`, `ambient_electric_field`                                      | none                                                                                                           | Experiment — unchanged                      | `_easydiffraction_diffrn.ambient_magnetic_field`, `…electric_field` (project extension).                                                                                                         |
+| `_refln.*`                                                                                      | core                                                                                                           | (no default save under refln)               | `_refln.*` reflections loop (column set differs by domain — see §2.3).                                                                                                                           |
+| `_pd_meas.*`, `_pd_proc.*`, `_pd_calc.*`, `_pd_data.*`                                          | pdCIF                                                                                                          | Experiment — unchanged                      | `_pd_meas.*`, `_pd_proc.*`, `_pd_calc.*` profile-data loop (see §2.3).                                                                                                                           |
+| `_pd_background.*`                                                                              | pdCIF                                                                                                          | Experiment — unchanged                      | `_pd_background.*`.                                                                                                                                                                              |
+| `_pd_phase_block.*`                                                                             | pdCIF                                                                                                          | Experiment — unchanged                      | `_pd_phase_block.*`.                                                                                                                                                                             |
+| `_sc_crystal_block.*`                                                                           | community (no IUCr counterpart)                                                                                | Experiment — unchanged                      | `_easydiffraction_sc_crystal_block.*` in IUCr export.                                                                                                                                            |
+| `_instr.wavelength`                                                                             | core (`_diffrn_radiation_wavelength.value`)                                                                    | Experiment — unchanged                      | `_diffrn_radiation_wavelength.{id, value, wt}` — single-row category for monochromatic; loop only for multi-λ.                                                                                   |
+| `_instr.2theta_offset`                                                                          | pdCIF (`_pd_calib.2theta_offset`)                                                                              | Experiment — unchanged                      | `_pd_calib.2theta_offset`.                                                                                                                                                                       |
+| `_instr.2theta_bank`, `d_to_tof_*`                                                              | pdCIF (`_pd_calib_d_to_tof.*` loop)                                                                            | Experiment — unchanged                      | Four-row loop `_pd_calib_d_to_tof.{id, coeff, power, coeff_su, diffractogram_id}`.                                                                                                               |
+| `_peak.*` (parametric profile shape)                                                            | none (pdCIF has no shape parameters)                                                                           | Experiment — unchanged                      | `_easydiffraction_peak.*` + `_pd_proc_ls.profile_function` free-text descriptor.                                                                                                                 |
+| `_extinction.*`                                                                                 | core (`_refine_ls.extinction_*` items)                                                                         | Experiment — unchanged                      | `_easydiffraction_extinction.*` + dual emit `_refine_ls.extinction_{method,coef,expression}`.                                                                                                    |
+| `_excluded_region.*`                                                                            | pdCIF (`_pd_proc.info_excluded_regions` free-text)                                                             | Experiment — unchanged                      | `_easydiffraction_excluded_region.*` + `_pd_proc.info_excluded_regions` free-text rendering.                                                                                                     |
+| `_expt_type.*`                                                                                  | none                                                                                                           | Experiment — unchanged                      | `_easydiffraction_experiment_type.*`.                                                                                                                                                            |
+| `_calculator.type`, `_minimizer.type`                                                           | none                                                                                                           | Analysis — unchanged                        | Selection fields remain settings only; identity is read from `analysis.software` for `_easydiffraction_software.{framework, calculator, minimizer}` and `_computing.structure_refinement`.       |
+| `_software.*`                                                                                   | none                                                                                                           | Analysis — new provenance category          | Source for `_easydiffraction_software.{framework, calculator, minimizer}`, `_easydiffraction_software.fit_datetime`, and `_computing.structure_refinement` in `data_global`.                     |
+| `_minimizer.*` settings (tolerances, max_iter, …)                                               | none                                                                                                           | Analysis — unchanged                        | `_easydiffraction_minimizer.*` (settings only, separate from the identification triple).                                                                                                         |
+| `_fitting_mode.type`, `_background.type`                                                        | none                                                                                                           | Analysis / Experiment — unchanged           | `_easydiffraction_fitting_mode.type`, `_easydiffraction_background.type` selectors.                                                                                                              |
+| `_fit_result.reduced_chi_square`, `n_data_points`, `n_parameters`                               | core (`_refine_ls.*`) and pdCIF (`_pd_proc_ls.*`)                                                              | Analysis — unchanged (topology-neutral)     | Shape-shifting per topology: see §1.2 and §3 transformers.                                                                                                                                       |
+| `_fit_result.*` (R-factors, counts, profile/background function)                                | core / pdCIF                                                                                                   | Analysis — new fields under `_fit_result.*` | IUCr export remaps to per-topology `_refine_ls.*` / `_pd_proc_ls.*`; item names already match dictionary casing (§1.2).                                                                          |
+| `_fit_result.*` (Bayesian diagnostics, success, message, fitting_time, iterations, result_kind) | none                                                                                                           | Analysis — unchanged                        | `_easydiffraction_fit_result.*`.                                                                                                                                                                 |
+| `_fit_parameter`, `_fit_parameter_correlation`                                                  | none / partial                                                                                                 | Analysis — unchanged                        | `_easydiffraction_fit_parameter*` (no IUCr counterpart for per-parameter posterior).                                                                                                             |
+| `_alias`, `_constraint`                                                                         | none                                                                                                           | Analysis — unchanged                        | `_easydiffraction_alias*`, `_easydiffraction_constraint*`.                                                                                                                                       |
+| `_joint_fit`, `_sequential_fit*`                                                                | none                                                                                                           | Analysis — unchanged                        | `_easydiffraction_joint_fit*`, `_easydiffraction_sequential_fit*`.                                                                                                                               |
+| reflection-set aggregates                                                                       | core (`_reflns.*`)                                                                                             | Analysis — new fields                       | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression` (e.g. `'I>3\s(I)'`).                                                                                                 |
 | report metadata                                                                                 | core (`_audit.*`, `_computing.*`, `_chemical_formula.*`) and project extension (`_easydiffraction_software.*`) | Analysis / derived report state             | Emitted in `data_global` block per §2.3a. Empty `_journal.*`, `_publ_*`, and `_pd_meas.info_author_*` placeholders are excluded by the clean-report policy in `project-summary-rendering.md` §5. |
-| analysis-stack identification                                                                   | core (`_computing.structure_refinement`)                                    | Analysis — `_software.*` persisted          | `_easydiffraction_software.{framework, calculator, minimizer}` triple + `_easydiffraction_software.fit_datetime` + `_computing.structure_refinement` derived from `analysis.software`.     |
+| analysis-stack identification                                                                   | core (`_computing.structure_refinement`)                                                                       | Analysis — `_software.*` persisted          | `_easydiffraction_software.{framework, calculator, minimizer}` triple + `_easydiffraction_software.fit_datetime` + `_computing.structure_refinement` derived from `analysis.software`.           |
 
 ## Decision
 
@@ -480,8 +480,8 @@ metadata, leaving no ambiguity about block roles.
     profile/background function descriptors, parameter counts),
   - `data_<structure-name>` (one per phase — structural data per
     `_pd_phase_block.id`),
-  - `data_<experiment-name>` (one per diffraction pattern —
-    measurement metadata, profile data loop, reflections loop).
+  - `data_<experiment-name>` (one per diffraction pattern — measurement
+    metadata, profile data loop, reflections loop).
 
   This deviates from the `data_<project>_publ` GSAS-II convention seen
   in `hb8206.cif`; the deviation buys a uniform rule across
@@ -504,9 +504,10 @@ metadata, leaving no ambiguity about block roles.
   identifies diffractogram/pattern blocks; in this report that is the
   `data_<experiment-name>` block ID. For single references, emit the
   scalar block ID directly (for example `_pd_block_id lbco`, not
-  `_pd_block_id |lbco|`). If multiple phases/patterns are needed, use a
-  proper loop or move toward the newer pdCIF replacement fields, not
-  encode lists in one scalar with pipes.
+  `_pd_block_id |lbco|`). User preference recorded for future
+  multi-block expansion: "If multiple phases/patterns are needed, I'd
+  rather use a proper loop or move toward the newer pdCIF replacement
+  fields, not encode lists in one scalar with pipes."
 
 - **Sequential fit.** One file per step is **not** the IUCr convention;
   sequential refinements emit one `data_<experiment-name>` block per
@@ -540,14 +541,15 @@ the project has source data, otherwise `?`.
   per dictionary).
 
 User-supplied publication metadata (`publ_info.json`, `publ_info.toml`,
-or a Python `project.publication` owner) is deferred — see Deferred
-Work and the clean report policy in `project-summary-rendering.md` §5.
+or a Python `project.publication` owner) is deferred — see Deferred Work
+and the clean report policy in `project-summary-rendering.md` §5.
 
 #### 2.3a-i `_easydiffraction_software` framework
 
-The IUCr-aligned report needs to identify the analysis stack. The project
-emits one structured category in `data_global` from `analysis.software`,
-carrying three role-keyed strings and an optional fit timestamp:
+The IUCr-aligned report needs to identify the analysis stack. The
+project emits one structured category in `data_global` from
+`analysis.software`, carrying three role-keyed strings and an optional
+fit timestamp:
 
 ```
 _easydiffraction_software.framework    'EasyDiffraction 0.17.0'
@@ -581,8 +583,8 @@ identification triple above.
 
 #### 2.3b Structure-block content (per-block)
 
-For each `data_<structure>` (single-crystal) or
-`data_<structure-name>` (powder Rietveld phase) block:
+For each `data_<structure>` (single-crystal) or `data_<structure-name>`
+(powder Rietveld phase) block:
 
 - `_chemical_formula.{moiety, sum, weight, IUPAC}` summary.
 - `_cell.*` (`length_a`, `angle_alpha`, `volume`,
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index c0a7dbc55..0107db2ad 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -19,20 +19,19 @@ Runs alongside, and **extends**, the accepted
 
 That ADR currently scopes `project.report` to **CIF only** — the
 multi-datablock IUCr-aligned report CIF written to
-`reports/<project>.cif`.
-This ADR keeps the facade and adds a **`project.report` configuration
-category** with five scalar persisted fields (`cif`, `html`, `tex`,
-`pdf`, `html_offline`) on `project.cif`, plus ad-hoc per-format methods
-(`save_html()`, `save_cif()`, `save_tex()`, `save_pdf()`). The
-Python-side API uses those same boolean descriptors directly, matching
-the persisted CIF shape. The LaTeX writer hardcodes `iucrjournals` as
-its document class — there is no style selector, no `_report.style`
-field, no `style=` arg on `save_tex()` / `save_pdf()`. The accepted IUCr
-`project.save(report=True)` flag is **removed**; reports come from the
-config category, not from boolean flags. All four format booleans
-default to `False` so `project.save()` writes nothing under `reports/`
-until the user configures otherwise, preserving the "no surprise files"
-property.
+`reports/<project>.cif`. This ADR keeps the facade and adds a
+**`project.report` configuration category** with five scalar persisted
+fields (`cif`, `html`, `tex`, `pdf`, `html_offline`) on `project.cif`,
+plus ad-hoc per-format methods (`save_html()`, `save_cif()`,
+`save_tex()`, `save_pdf()`). The Python-side API uses those same boolean
+descriptors directly, matching the persisted CIF shape. The LaTeX writer
+hardcodes `iucrjournals` as its document class — there is no style
+selector, no `_report.style` field, no `style=` arg on `save_tex()` /
+`save_pdf()`. The accepted IUCr `project.save(report=True)` flag is
+**removed**; reports come from the config category, not from boolean
+flags. All four format booleans default to `False` so `project.save()`
+writes nothing under `reports/` until the user configures otherwise,
+preserving the "no surprise files" property.
 
 Coordination points with the alignment ADR (no blocking conflicts; its
 Open Questions section is empty):
@@ -54,9 +53,9 @@ Open Questions section is empty):
   non-compliant CIF raises `EasyDiffractionWriterError` instead.
   Completeness checks for a future journal-submission metadata surface
   stay in Deferred Work and are not part of the v1 clean report CIF.
-- **Clean report metadata** — the alignment ADR's Deferred Work
-  proposed user-supplied `reports/publ_info.{toml,json}` data to replace
-  `?` placeholders. This ADR rejects that v1 surface. There is no
+- **Clean report metadata** — the alignment ADR's Deferred Work proposed
+  user-supplied `reports/publ_info.{toml,json}` data to replace `?`
+  placeholders. This ADR rejects that v1 surface. There is no
   `project.publication` owner in v1, `project.cif` does not persist
   journal/publication metadata, and the report CIF does not emit empty
   journal, author, publication-body, or powder-measurement author
@@ -164,8 +163,8 @@ Out of scope:
 - CIF tag-name decisions for any serialised field. Those are the
   alignment ADR's job; this ADR notes recommended mappings and
   cross-references.
-- The IUCr-aligned report CIF export tag policy and multi-datablock layout.
-  Covered by the alignment ADR; the output file lives at
+- The IUCr-aligned report CIF export tag policy and multi-datablock
+  layout. Covered by the alignment ADR; the output file lives at
   `reports/<project>.cif` and is opt-in via `project.report.cif = True`.
 - Pre-existing project-level singleton categories (`_info.*`,
   `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*`). Covered by
@@ -451,17 +450,17 @@ The project already has two distinct facade patterns for top-level
 config — not Pattern B — heavy datablock owner with its own CIF file.
 The split is summarised below.
 
-| Slot                                 | Pattern | CIF location                             | Python shape                                         |
-| ------------------------------------ | ------- | ---------------------------------------- | ---------------------------------------------------- |
-| `project.info`                       | A       | `project.cif` (`_info.*`)                | small `CategoryItem`                                 |
-| `project.rendering_plot`             | A       | `project.cif` (`_rendering_plot.*`)      | `CategoryItem` (one field)                           |
-| `project.rendering_table`            | A       | `project.cif` (`_rendering_table.*`)     | `CategoryItem` (one field)                           |
-| `project.verbosity`                  | A       | `project.cif` (`_verbosity.*`)           | `CategoryItem` (one field)                           |
-| **`project.report`** (this ADR)      | **A**   | **`project.cif` (`_report.*`)**          | **`CategoryItem` (five fields) plus action methods** |
-| `project.publication` (rejected, §5) | n/a     | none                                     | no v1 Python surface                                 |
-| `project.analysis`                   | B       | `analysis/analysis.cif`                  | `CategoryOwner` (heavy datablock)                    |
-| `project.structures[name]`           | B       | `structures/<name>.cif`                  | `CategoryOwner` (heavy datablock)                    |
-| `project.experiments[name]`          | B       | `experiments/<name>.cif`                 | `CategoryOwner` (heavy datablock)                    |
+| Slot                                 | Pattern | CIF location                         | Python shape                                         |
+| ------------------------------------ | ------- | ------------------------------------ | ---------------------------------------------------- |
+| `project.info`                       | A       | `project.cif` (`_info.*`)            | small `CategoryItem`                                 |
+| `project.rendering_plot`             | A       | `project.cif` (`_rendering_plot.*`)  | `CategoryItem` (one field)                           |
+| `project.rendering_table`            | A       | `project.cif` (`_rendering_table.*`) | `CategoryItem` (one field)                           |
+| `project.verbosity`                  | A       | `project.cif` (`_verbosity.*`)       | `CategoryItem` (one field)                           |
+| **`project.report`** (this ADR)      | **A**   | **`project.cif` (`_report.*`)**      | **`CategoryItem` (five fields) plus action methods** |
+| `project.publication` (rejected, §5) | n/a     | none                                 | no v1 Python surface                                 |
+| `project.analysis`                   | B       | `analysis/analysis.cif`              | `CategoryOwner` (heavy datablock)                    |
+| `project.structures[name]`           | B       | `structures/<name>.cif`              | `CategoryOwner` (heavy datablock)                    |
+| `project.experiments[name]`          | B       | `experiments/<name>.cif`             | `CategoryOwner` (heavy datablock)                    |
 
 Reasons `project.report` is Pattern A, not Pattern B:
 
@@ -1579,8 +1578,7 @@ public API surface treats missing provenance uniformly:
   namespace. Detecting complete provenance is a different concern from
   dictionary-spec compliance and falls to a deferred completeness check.
   Users who must guarantee complete provenance should run that check
-  (once it lands) or inspect the rendered report
-  manually.
+  (once it lands) or inspect the rendered report manually.
 - **Old projects.** Loading a project saved before this ADR produces an
   `analysis.software` with all fields unset and the timestamp `None`. No
   migration step is run; the user populates the snapshot by re-running
@@ -1588,8 +1586,7 @@ public API surface treats missing provenance uniformly:
 
 This rule applies wholesale — no flag toggles it, no targeted exception
 is raised. Users who need full provenance can re-run the fit; users
-producing draft / preview reports keep working without
-interruption.
+producing draft / preview reports keep working without interruption.
 
 ### 5. Clean report-CIF metadata policy
 
@@ -1623,9 +1620,8 @@ journal or portal.
 - `_publ_contact_author.name`, `_publ_contact_author.address`,
   `_publ_contact_author.email`, `_publ_contact_author.phone`,
   `_publ_contact_author.id_ORCID`, `_publ_contact_author.id_IUCr`.
-- `_publ_author.name`, `_publ_author.address`,
-  `_publ_author.footnote`, `_publ_author.id_ORCID`,
-  `_publ_author.id_IUCr`.
+- `_publ_author.name`, `_publ_author.address`, `_publ_author.footnote`,
+  `_publ_author.id_ORCID`, `_publ_author.id_IUCr`.
 - `_publ_body.title`, `_publ_body.synopsis`, `_publ_body.abstract`,
   `_publ_body.keywords`, `_publ_body.contents`.
 - `_pd_meas.info_author_name`, `_pd_meas.info_author_email`,
@@ -1641,26 +1637,26 @@ a clean report CIF.
 The report CIF keeps the following tag families when the project has
 source data for them.
 
-| Tag family | Tags retained | Rationale |
-| --- | --- | --- |
-| Audit | `_audit.creation_method`, `_audit.creation_date` | Identifies the EasyDiffraction writer and report-generation time. These are generated by the library, not user-authored empty metadata. |
-| Software provenance | `_computing.structure_refinement`; `_easydiffraction_software.framework`, `_easydiffraction_software.calculator`, `_easydiffraction_software.minimizer`, `_easydiffraction_software.fit_datetime` | Records the analysis stack in a standard IUCr text field plus structured EasyDiffraction fields. `fit_datetime` is emitted only when a fit snapshot exists. |
-| Chemical formula | `_chemical_formula.sum`, `_chemical_formula.moiety`, `_chemical_formula.weight`, `_chemical_formula.IUPAC` | Summarises chemistry derived from structure atom sites. These fields describe the refined model, not journal administration. |
-| Unit cell | `_cell.length_a`, `_cell.length_b`, `_cell.length_c`, `_cell.angle_alpha`, `_cell.angle_beta`, `_cell.angle_gamma` | Core crystallographic model parameters needed to understand and reuse a structure block. |
-| Space group | `_space_group.name_H-M_alt`, `_space_group.IT_coordinate_system_code`, `_space_group.crystal_system`; `_space_group_symop.id`, `_space_group_symop.operation_xyz` | Gives symmetry in standard coreCIF form and includes explicit operations for downstream tools. |
-| Atom sites | `_atom_site.label`, `_atom_site.type_symbol`, `_atom_site.fract_x`, `_atom_site.fract_y`, `_atom_site.fract_z`, `_atom_site.occupancy`, `_atom_site.ADP_type`, `_atom_site.B_iso_or_equiv` or `_atom_site.U_iso_or_equiv`, `_atom_site.Wyckoff_symbol` | Carries the refined structural model. The B/U split follows the accepted ADP policy and dictionary names. |
-| Anisotropic ADPs | `_atom_site_aniso.label`, `_atom_site_aniso.B_11`, `_atom_site_aniso.B_22`, `_atom_site_aniso.B_33`, `_atom_site_aniso.B_12`, `_atom_site_aniso.B_13`, `_atom_site_aniso.B_23`, or the matching `U_*` items | Carries anisotropic displacement parameters when present, using one ADP family per emitted loop. |
-| Diffraction conditions | `_diffrn.ambient_temperature`, `_diffrn.ambient_pressure`, `_diffrn_radiation.probe`, `_diffrn_radiation_wavelength.id`, `_diffrn_radiation_wavelength.value`, `_diffrn_radiation_wavelength.wt` | Describes measurement conditions and wavelength/probe information needed to interpret the refinement. |
-| Single-crystal refinement | `_refine_ls.R_factor_all`, `_refine_ls.wR_factor_all`, `_refine_ls.R_factor_gt`, `_refine_ls.wR_factor_gt`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints`, `_refine_ls.extinction_method`, `_refine_ls.extinction_coef`, `_refine.special_details` | Reports standard single-crystal fit quality and extinction details produced by the refinement state. |
-| Reflection summary | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression` | Summarises the reflection set used for single-crystal quality metrics. |
-| Single-crystal reflections | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_refln.F_squared_meas_su`, `_refln.include_status` | Provides the measured/calculated reflection data needed to inspect the fit. |
-| Powder block cross-references | `_pd_block_id`, `_pd_block_diffractogram_id`, `_pd_phase_block.id`, `_pd_phase_block.scale` | Links `data_overall`, phase/model blocks, and diffractogram/pattern blocks in multi-block powder reports. The block-name and scalar-reference policy is defined in the CIF-alignment ADR §2.3. |
-| Powder measurement and profile | `_pd_meas.scan_method`, `_pd_meas.number_of_points`, `_pd_meas.2theta_scan` or `_pd_meas.time_of_flight`, `_pd_meas.intensity_total`, `_pd_calc.intensity_total`, `_pd_proc.intensity_bkg_calc`, `_pd_proc_ls.weight` | Carries the observed, calculated, background, and weight arrays for profile inspection. The author-info placeholders are excluded by §5.1. |
-| Powder processing | `_pd_proc.info_data_reduction`, `_pd_proc.info_datetime`, `_pd_proc.info_excluded_regions` | Documents processing state that affects the profile fit. Empty free-text fields are omitted until real source data exists. |
-| Powder refinement | `_pd_calc.method`, `_pd_proc_ls.prof_R_factor`, `_pd_proc_ls.prof_wR_factor`, `_pd_proc_ls.prof_wR_expected`, `_pd_proc_ls.profile_function`, `_pd_proc_ls.background_function`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints` | Reports Rietveld method, profile quality metrics, and model-size counts in standard pdCIF/coreCIF fields. |
-| Powder reflections | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_pd_refln.phase_id`, `_refln.d_spacing` | Keeps calculated powder reflection information tied to the contributing phase. |
-| TOF calibration | `_pd_calib_d_to_tof.id`, `_pd_calib_d_to_tof.power`, `_pd_calib_d_to_tof.coeff`, `_pd_calib_d_to_tof.coeff_su`, `_pd_calib_d_to_tof.diffractogram_id` | Required for time-of-flight powder reports when non-zero calibration coefficients are present. |
-| EasyDiffraction extensions | `_easydiffraction_experiment_type.sample_form`, `_easydiffraction_experiment_type.beam_mode`, `_easydiffraction_experiment_type.radiation_probe`, `_easydiffraction_experiment_type.scattering_type`, `_easydiffraction_calculator.type`, `_easydiffraction_peak.type`, `_easydiffraction_background.type`, `_easydiffraction_sc_crystal_block.id`, `_easydiffraction_sc_crystal_block.scale`, `_easydiffraction_diffrn.ambient_magnetic_field`, `_easydiffraction_diffrn.ambient_electric_field`, `_easydiffraction_extinction.type`, `_easydiffraction_extinction.model`, `_easydiffraction_extinction.mosaicity`, `_easydiffraction_extinction.radius` | Preserves EasyDiffraction-specific state that has no exact coreCIF/pdCIF equivalent but is needed to trace how the reported fit was configured. |
+| Tag family                     | Tags retained                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Rationale                                                                                                                                                                                      |
+| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Audit                          | `_audit.creation_method`, `_audit.creation_date`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Identifies the EasyDiffraction writer and report-generation time. These are generated by the library, not user-authored empty metadata.                                                        |
+| Software provenance            | `_computing.structure_refinement`; `_easydiffraction_software.framework`, `_easydiffraction_software.calculator`, `_easydiffraction_software.minimizer`, `_easydiffraction_software.fit_datetime`                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Records the analysis stack in a standard IUCr text field plus structured EasyDiffraction fields. `fit_datetime` is emitted only when a fit snapshot exists.                                    |
+| Chemical formula               | `_chemical_formula.sum`, `_chemical_formula.moiety`, `_chemical_formula.weight`, `_chemical_formula.IUPAC`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Summarises chemistry derived from structure atom sites. These fields describe the refined model, not journal administration.                                                                   |
+| Unit cell                      | `_cell.length_a`, `_cell.length_b`, `_cell.length_c`, `_cell.angle_alpha`, `_cell.angle_beta`, `_cell.angle_gamma`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Core crystallographic model parameters needed to understand and reuse a structure block.                                                                                                       |
+| Space group                    | `_space_group.name_H-M_alt`, `_space_group.IT_coordinate_system_code`, `_space_group.crystal_system`; `_space_group_symop.id`, `_space_group_symop.operation_xyz`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Gives symmetry in standard coreCIF form and includes explicit operations for downstream tools.                                                                                                 |
+| Atom sites                     | `_atom_site.label`, `_atom_site.type_symbol`, `_atom_site.fract_x`, `_atom_site.fract_y`, `_atom_site.fract_z`, `_atom_site.occupancy`, `_atom_site.ADP_type`, `_atom_site.B_iso_or_equiv` or `_atom_site.U_iso_or_equiv`, `_atom_site.Wyckoff_symbol`                                                                                                                                                                                                                                                                                                                                                                                                    | Carries the refined structural model. The B/U split follows the accepted ADP policy and dictionary names.                                                                                      |
+| Anisotropic ADPs               | `_atom_site_aniso.label`, `_atom_site_aniso.B_11`, `_atom_site_aniso.B_22`, `_atom_site_aniso.B_33`, `_atom_site_aniso.B_12`, `_atom_site_aniso.B_13`, `_atom_site_aniso.B_23`, or the matching `U_*` items                                                                                                                                                                                                                                                                                                                                                                                                                                               | Carries anisotropic displacement parameters when present, using one ADP family per emitted loop.                                                                                               |
+| Diffraction conditions         | `_diffrn.ambient_temperature`, `_diffrn.ambient_pressure`, `_diffrn_radiation.probe`, `_diffrn_radiation_wavelength.id`, `_diffrn_radiation_wavelength.value`, `_diffrn_radiation_wavelength.wt`                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Describes measurement conditions and wavelength/probe information needed to interpret the refinement.                                                                                          |
+| Single-crystal refinement      | `_refine_ls.R_factor_all`, `_refine_ls.wR_factor_all`, `_refine_ls.R_factor_gt`, `_refine_ls.wR_factor_gt`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints`, `_refine_ls.extinction_method`, `_refine_ls.extinction_coef`, `_refine.special_details`                                                                                                                                                                                                                                                                                                                                                      | Reports standard single-crystal fit quality and extinction details produced by the refinement state.                                                                                           |
+| Reflection summary             | `_reflns.number_total`, `_reflns.number_gt`, `_reflns.threshold_expression`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Summarises the reflection set used for single-crystal quality metrics.                                                                                                                         |
+| Single-crystal reflections     | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_refln.F_squared_meas_su`, `_refln.include_status`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Provides the measured/calculated reflection data needed to inspect the fit.                                                                                                                    |
+| Powder block cross-references  | `_pd_block_id`, `_pd_block_diffractogram_id`, `_pd_phase_block.id`, `_pd_phase_block.scale`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Links `data_overall`, phase/model blocks, and diffractogram/pattern blocks in multi-block powder reports. The block-name and scalar-reference policy is defined in the CIF-alignment ADR §2.3. |
+| Powder measurement and profile | `_pd_meas.scan_method`, `_pd_meas.number_of_points`, `_pd_meas.2theta_scan` or `_pd_meas.time_of_flight`, `_pd_meas.intensity_total`, `_pd_calc.intensity_total`, `_pd_proc.intensity_bkg_calc`, `_pd_proc_ls.weight`                                                                                                                                                                                                                                                                                                                                                                                                                                     | Carries the observed, calculated, background, and weight arrays for profile inspection. The author-info placeholders are excluded by §5.1.                                                     |
+| Powder processing              | `_pd_proc.info_data_reduction`, `_pd_proc.info_datetime`, `_pd_proc.info_excluded_regions`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Documents processing state that affects the profile fit. Empty free-text fields are omitted until real source data exists.                                                                     |
+| Powder refinement              | `_pd_calc.method`, `_pd_proc_ls.prof_R_factor`, `_pd_proc_ls.prof_wR_factor`, `_pd_proc_ls.prof_wR_expected`, `_pd_proc_ls.profile_function`, `_pd_proc_ls.background_function`, `_refine_ls.number_parameters`, `_refine_ls.number_restraints`, `_refine_ls.number_constraints`                                                                                                                                                                                                                                                                                                                                                                          | Reports Rietveld method, profile quality metrics, and model-size counts in standard pdCIF/coreCIF fields.                                                                                      |
+| Powder reflections             | `_refln.index_h`, `_refln.index_k`, `_refln.index_l`, `_refln.F_squared_meas`, `_refln.F_squared_calc`, `_pd_refln.phase_id`, `_refln.d_spacing`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Keeps calculated powder reflection information tied to the contributing phase.                                                                                                                 |
+| TOF calibration                | `_pd_calib_d_to_tof.id`, `_pd_calib_d_to_tof.power`, `_pd_calib_d_to_tof.coeff`, `_pd_calib_d_to_tof.coeff_su`, `_pd_calib_d_to_tof.diffractogram_id`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Required for time-of-flight powder reports when non-zero calibration coefficients are present.                                                                                                 |
+| EasyDiffraction extensions     | `_easydiffraction_experiment_type.sample_form`, `_easydiffraction_experiment_type.beam_mode`, `_easydiffraction_experiment_type.radiation_probe`, `_easydiffraction_experiment_type.scattering_type`, `_easydiffraction_calculator.type`, `_easydiffraction_peak.type`, `_easydiffraction_background.type`, `_easydiffraction_sc_crystal_block.id`, `_easydiffraction_sc_crystal_block.scale`, `_easydiffraction_diffrn.ambient_magnetic_field`, `_easydiffraction_diffrn.ambient_electric_field`, `_easydiffraction_extinction.type`, `_easydiffraction_extinction.model`, `_easydiffraction_extinction.mosaicity`, `_easydiffraction_extinction.radius` | Preserves EasyDiffraction-specific state that has no exact coreCIF/pdCIF equivalent but is needed to trace how the reported fit was configured.                                                |
 
 ### 6. Shared `ReportDataContext` + Jinja templates
 
@@ -1940,13 +1936,13 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      **not** overwritten — fit time and report time are distinct events.
   5. **Publication metadata excluded from the default save and report
      CIF.** The alignment ADR's Scope explicitly excluded "Adding new
-     CIF categories the project does not currently track
-     (`_chemical.*`, `_publ.*`, `_journal.*`) **for the default save**"
-     (alignment ADR §Scope, lines 101-110). This ADR keeps that
-     exclusion for `_publ_*` and `_journal_*`: no `project.publication`
-     owner is added, no journal/publication metadata is persisted to
-     `project.cif`, and the report CIF omits the empty publication and
-     powder-measurement author placeholders listed in §5.1.
+     CIF categories the project does not currently track (`_chemical.*`,
+     `_publ.*`, `_journal.*`) **for the default save**" (alignment ADR
+     §Scope, lines 101-110). This ADR keeps that exclusion for `_publ_*`
+     and `_journal_*`: no `project.publication` owner is added, no
+     journal/publication metadata is persisted to `project.cif`, and the
+     report CIF omits the empty publication and powder-measurement
+     author placeholders listed in §5.1.
 
   All other IUCr-export decisions in the alignment ADR (multi-datablock
   layout, tag-name policy, gemmi as the validation engine) are
@@ -1974,11 +1970,10 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      journal-administration fields.
   3. **Project-level singleton category enumeration extended only by
      `_report.*`.** The accepted ADR enumerates `_info.*`,
-     `_rendering_plot.*`,
-     `_rendering_table.*`, `_verbosity.*` as the project-level singleton
-     categories owned by `project.cif`. This ADR adds `_report.*` (this
-     ADR §1.3) and explicitly does not add `_publ_*`, `_journal_*`, or
-     any `_publication.*` family.
+     `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*` as the
+     project-level singleton categories owned by `project.cif`. This ADR
+     adds `_report.*` (this ADR §1.3) and explicitly does not add
+     `_publ_*`, `_journal_*`, or any `_publication.*` family.
 - [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
   — owns the Python-to-CIF correspondence rule for one new project-level
   singleton surface:
diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index 3687d3cf2..ba7ff647f 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -38,7 +38,7 @@ folders.
 | Persistence          | Accepted   | Free-Flag CIF Encoding                    | Encodes fit free/fixed state through CIF uncertainty syntax instead of a separate free list.                          | [`free-flag-cif-encoding.md`](accepted/free-flag-cif-encoding.md)                            |
 | Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                       | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                    |
 | Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                    | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)            |
-| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds a clean IUCr-aligned report export.                          | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
+| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds a clean IUCr-aligned report export.                           | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
 | Persistence          | Suggestion | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then proposes scoped one-to-one mapping for project-level categories.     | [`python-cif-category-correspondence.md`](suggestions/python-cif-category-correspondence.md) |
 | Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
 | Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                              |
diff --git a/docs/dev/package-structure/full.md b/docs/dev/package-structure/full.md
index fdcf3c8d7..43b464be8 100644
--- a/docs/dev/package-structure/full.md
+++ b/docs/dev/package-structure/full.md
@@ -602,19 +602,6 @@
 │   │   │   └── 📄 factory.py
 │   │   │       └── 🏷️ class ProjectInfoFactory
 │   │   ├── 📁 publication
-│   │   │   ├── 📄 __init__.py
-│   │   │   ├── 📄 default.py
-│   │   │   │   ├── 🏷️ class PublicationItemBase
-│   │   │   │   ├── 🏷️ class PublicationJournal
-│   │   │   │   ├── 🏷️ class PublicationJournalDate
-│   │   │   │   ├── 🏷️ class PublicationJournalCoeditor
-│   │   │   │   ├── 🏷️ class PublicationContactAuthor
-│   │   │   │   ├── 🏷️ class PublicationBody
-│   │   │   │   ├── 🏷️ class PublicationAuthor
-│   │   │   │   ├── 🏷️ class PublicationAuthors
-│   │   │   │   └── 🏷️ class Publication
-│   │   │   └── 📄 factory.py
-│   │   │       └── 🏷️ class PublicationFactory
 │   │   ├── 📁 rendering
 │   │   ├── 📁 rendering_plot
 │   │   │   ├── 📄 __init__.py
@@ -670,8 +657,7 @@
 │   │   └── 🏷️ class Project
 │   ├── 📄 project_config.py
 │   │   └── 🏷️ class ProjectConfig
-│   ├── 📄 project_info.py
-│   └── 📄 publication_loader.py
+│   └── 📄 project_info.py
 ├── 📁 report
 │   ├── 📁 templates
 │   │   ├── 📁 html
diff --git a/docs/dev/package-structure/short.md b/docs/dev/package-structure/short.md
index d805b8011..e6ee7caa3 100644
--- a/docs/dev/package-structure/short.md
+++ b/docs/dev/package-structure/short.md
@@ -285,9 +285,6 @@
 │   │   │   ├── 📄 default.py
 │   │   │   └── 📄 factory.py
 │   │   ├── 📁 publication
-│   │   │   ├── 📄 __init__.py
-│   │   │   ├── 📄 default.py
-│   │   │   └── 📄 factory.py
 │   │   ├── 📁 rendering
 │   │   ├── 📁 rendering_plot
 │   │   │   ├── 📄 __init__.py
@@ -322,8 +319,7 @@
 │   ├── 📄 display.py
 │   ├── 📄 project.py
 │   ├── 📄 project_config.py
-│   ├── 📄 project_info.py
-│   └── 📄 publication_loader.py
+│   └── 📄 project_info.py
 ├── 📁 report
 │   ├── 📁 templates
 │   │   ├── 📁 html
diff --git a/src/easydiffraction/io/cif/iucr_writer.py b/src/easydiffraction/io/cif/iucr_writer.py
index 5b55a2703..e84b4d2e6 100644
--- a/src/easydiffraction/io/cif/iucr_writer.py
+++ b/src/easydiffraction/io/cif/iucr_writer.py
@@ -23,54 +23,6 @@
 _TEXT_WRAP_WIDTH = 80
 _ITEM_WIDTH = 38
 
-_JOURNAL_ITEMS = (
-    ('_journal.name_full', 'name_full'),
-    ('_journal.year', 'year'),
-    ('_journal.volume', 'volume'),
-    ('_journal.issue', 'issue'),
-    ('_journal.page_first', 'page_first'),
-    ('_journal.page_last', 'page_last'),
-    ('_journal.paper_category', 'paper_category'),
-    ('_journal.paper_DOI', 'paper_doi'),
-    ('_journal.coden_ASTM', 'coden_astm'),
-    ('_journal.suppl_publ_number', 'suppl_publ_number'),
-)
-
-_JOURNAL_DATE_ITEMS = (
-    ('_journal_date.accepted', 'accepted'),
-    ('_journal_date.from_coeditor', 'from_coeditor'),
-    ('_journal_date.printers_final', 'printers_final'),
-)
-
-_JOURNAL_COEDITOR_ITEMS = (
-    ('_journal_coeditor.code', 'code'),
-    ('_journal_coeditor.name', 'name'),
-    ('_journal_coeditor.notes', 'notes'),
-)
-
-_PUBL_CONTACT_AUTHOR_ITEMS = (
-    ('_publ_contact_author.name', 'name'),
-    ('_publ_contact_author.address', 'address'),
-    ('_publ_contact_author.email', 'email'),
-    ('_publ_contact_author.phone', 'phone'),
-    ('_publ_contact_author.id_ORCID', 'id_orcid'),
-    ('_publ_contact_author.id_IUCr', 'id_iucr'),
-)
-
-_PUBL_AUTHOR_ITEMS = (
-    ('_publ_author.name', 'name'),
-    ('_publ_author.address', 'address'),
-    ('_publ_author.footnote', 'footnote'),
-    ('_publ_author.id_ORCID', 'id_orcid'),
-    ('_publ_author.id_IUCr', 'id_iucr'),
-)
-_PUBL_AUTHOR_TAGS = tuple(tag for tag, _ in _PUBL_AUTHOR_ITEMS)
-
-_PUBL_BODY_ITEMS = (
-    ('_publ_body.title', 'title'),
-    ('_publ_body.contents', 'contents'),
-)
-
 _PACKAGE_BY_ENGINE = {
     'cryspy': 'cryspy',
     'crysfml': 'crysfml',
@@ -144,7 +96,6 @@ def _write_global_block(project: object) -> str:
     lines = ['data_global']
     _write_audit_section(lines)
     _write_computing_section(lines, project)
-    _write_publication_sections(lines, project)
     _write_formula_section(lines, project)
     return '\n'.join(lines)
 
@@ -176,45 +127,6 @@ def _write_computing_section(lines: list[str], project: object) -> None:
         _write_item(lines, '_easydiffraction_software.fit_datetime', fit_datetime)
 
 
-def _write_publication_sections(lines: list[str], project: object) -> None:
-    """
-    Append publication metadata from the project publication owner.
-    """
-    publication = getattr(project, 'publication', None)
-    _write_publication_item_section(
-        lines,
-        'Journal',
-        getattr(publication, 'journal', None),
-        _JOURNAL_ITEMS,
-    )
-    _write_publication_item_section(
-        lines,
-        'Journal dates',
-        getattr(publication, 'journal_date', None),
-        _JOURNAL_DATE_ITEMS,
-    )
-    _write_publication_item_section(
-        lines,
-        'Journal coeditor',
-        getattr(publication, 'journal_coeditor', None),
-        _JOURNAL_COEDITOR_ITEMS,
-    )
-    _write_publication_item_section(
-        lines,
-        'Publication contact author',
-        getattr(publication, 'contact_author', None),
-        _PUBL_CONTACT_AUTHOR_ITEMS,
-    )
-
-    _section(lines, 'Publication authors')
-    _write_loop(lines, _PUBL_AUTHOR_TAGS, _publication_author_rows(publication))
-
-    _write_publication_body_section(
-        lines,
-        getattr(publication, 'body', None),
-    )
-
-
 def _write_formula_section(lines: list[str], project: object) -> None:
     """Append chemical-formula summary metadata."""
     formula = _chemical_formula_values(project)
@@ -480,8 +392,9 @@ def _write_rietveld_blocks(project: object) -> list[str]:
     if not experiments:
         return []
 
-    phases = _powder_phases(project, experiments)
-    patterns = _powder_patterns(project, experiments)
+    used_block_names = {'global', 'overall'}
+    phases = _powder_phases(project, experiments, used_block_names)
+    patterns = _powder_patterns(experiments, used_block_names)
     return [
         _write_rietveld_overall_block(project, phases, patterns),
         *[_write_powder_phase_block(phase) for phase in phases],
@@ -495,20 +408,16 @@ def _write_rietveld_overall_block(
     patterns: list[_PowderPattern],
 ) -> str:
     """Render the powder Rietveld overall block."""
-    lines = [f'data_{_block_name(project.name)}_overall']
+    lines = ['data_overall']
     fit_result = _fit_result(project)
 
     _section(lines, 'Rietveld overall')
     _write_item(lines, '_pd_calc.method', 'Rietveld Refinement')
-    _write_item(
-        lines,
-        '_pd_block_id',
-        _pipe_ids([phase.block_name for phase in phases]),
-    )
-    _write_item(
+    _write_reference_values(lines, '_pd_block_id', [phase.block_name for phase in phases])
+    _write_reference_values(
         lines,
         '_pd_block_diffractogram_id',
-        _pipe_ids([pattern.block_name for pattern in patterns]),
+        [pattern.block_name for pattern in patterns],
     )
 
     _section(lines, 'Powder refinement')
@@ -587,7 +496,7 @@ def _write_powder_pattern_reference_section(
         phases,
     )
     _section(lines, 'Powder pattern')
-    _write_item(lines, '_pd_block_id', _pipe_ids(phase_ids))
+    _write_reference_values(lines, '_pd_block_id', phase_ids)
     _write_item(lines, '_pd_block_diffractogram_id', pattern.block_name)
 
 
@@ -601,9 +510,6 @@ def _write_powder_measurement_section(
     _section(lines, 'Powder measurement')
     _write_item(lines, '_pd_meas.scan_method', _attribute_value(expt_type, 'beam_mode'))
     _write_item(lines, '_pd_meas.number_of_points', len(data_items))
-    _write_item(lines, '_pd_meas.info_author_name', '?')
-    _write_item(lines, '_pd_meas.info_author_email', '?')
-    _write_item(lines, '_pd_meas.info_author_phone', '?')
 
 
 def _write_powder_proc_section(lines: list[str], experiment: object) -> None:
@@ -704,65 +610,6 @@ def _write_tof_calibration_loop(lines: list[str], experiment: object) -> None:
     _write_loop(lines, loop.tags, loop.rows)
 
 
-def _write_publication_item_section(
-    lines: list[str],
-    title: str,
-    category: object,
-    items: Iterable[tuple[str, str]],
-) -> None:
-    """Append one scalar publication metadata section."""
-    _section(lines, title)
-    for tag, attr_name in items:
-        _write_item(lines, tag, _attribute_value(category, attr_name))
-
-
-def _write_publication_body_section(lines: list[str], body: object) -> None:
-    """Append publication body metadata."""
-    _section(lines, 'Publication body')
-    for tag, attr_name in _PUBL_BODY_ITEMS:
-        _write_item(lines, tag, _publication_body_value(body, attr_name))
-
-
-def _publication_body_value(body: object, attr_name: str) -> object:
-    """Return one publication-body value."""
-    if attr_name != 'contents':
-        return _attribute_value(body, attr_name)
-
-    return _publication_body_contents(body)
-
-
-def _publication_body_contents(body: object) -> str | None:
-    """Return IUCr publication body contents from discrete fields."""
-    if body is None:
-        return None
-
-    sections = []
-    for attr_name in ('synopsis', 'abstract'):
-        value = _attribute_value(body, attr_name)
-        if value not in {None, ''}:
-            sections.append(str(value))
-
-    keywords = getattr(body, 'keywords', [])
-    if keywords:
-        sections.append(f'Keywords: {", ".join(keywords)}')
-
-    if not sections:
-        return None
-    return '\n\n'.join(sections)
-
-
-def _publication_author_rows(publication: object) -> list[tuple[object, ...]]:
-    """Return publication author rows or one empty placeholder row."""
-    authors = getattr(publication, 'authors', None)
-    rows = [
-        tuple(_attribute_value(author, attr_name) for _, attr_name in _PUBL_AUTHOR_ITEMS)
-        for author in _collection_values(authors)
-    ]
-    if rows:
-        return rows
-    return [tuple(None for _ in _PUBL_AUTHOR_ITEMS)]
-
-
 def _write_loop(
     lines: list[str],
     tags: Iterable[str],
@@ -1178,6 +1025,7 @@ def _powder_rietveld_experiments(project: object) -> list[object]:
 def _powder_phases(
     project: object,
     experiments: list[object],
+    used_block_names: set[str],
 ) -> list[_PowderPhase]:
     """Return unique powder phase blocks for the given experiments."""
     phases: list[_PowderPhase] = []
@@ -1188,10 +1036,9 @@ def _powder_phases(
             if structure_name in seen_structure_names:
                 continue
             seen_structure_names.add(structure_name)
-            block_name = f'{_block_name(project.name)}_phase_{len(phases) + 1}'
             phases.append(
                 _PowderPhase(
-                    block_name=block_name,
+                    block_name=_unique_block_name(structure_name, used_block_names),
                     structure=structure,
                     linked_phase=linked_phase,
                 )
@@ -1200,13 +1047,16 @@ def _powder_phases(
 
 
 def _powder_patterns(
-    project: object,
     experiments: list[object],
+    used_block_names: set[str],
 ) -> list[_PowderPattern]:
     """Return powder pattern blocks for the given experiments."""
     return [
         _PowderPattern(
-            block_name=f'{_block_name(project.name)}_pwd_{index}',
+            block_name=_unique_block_name(
+                getattr(experiment, 'name', None) or f'pattern_{index}',
+                used_block_names,
+            ),
             experiment=experiment,
         )
         for index, experiment in enumerate(experiments, start=1)
@@ -1244,11 +1094,27 @@ def _linked_powder_structures(
     raise ValueError(msg)
 
 
-def _pipe_ids(values: list[str]) -> str:
-    """Return pipe-delimited block identifiers."""
+def _write_reference_values(lines: list[str], tag: str, values: list[str]) -> None:
+    """Append scalar or loop block references."""
     if not values:
-        return '?'
-    return '|' + '|'.join(values) + '|'
+        _write_item(lines, tag, '?')
+        return
+    if len(values) == 1:
+        _write_item(lines, tag, values[0])
+        return
+    _write_loop(lines, (tag,), [(value,) for value in values])
+
+
+def _unique_block_name(value: object, used_block_names: set[str]) -> str:
+    """Return a CIF block name unique in the report."""
+    block_name = _block_name(value)
+    candidate = block_name
+    suffix = 2
+    while candidate in used_block_names:
+        candidate = f'{block_name}_{suffix}'
+        suffix += 1
+    used_block_names.add(candidate)
+    return candidate
 
 
 def _phase_block_names_for_experiment(
diff --git a/src/easydiffraction/project/categories/publication/__init__.py b/src/easydiffraction/project/categories/publication/__init__.py
deleted file mode 100644
index f1aa7a046..000000000
--- a/src/easydiffraction/project/categories/publication/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project publication metadata exports."""
-
-from __future__ import annotations
-
-from easydiffraction.project.categories.publication.default import Publication
-from easydiffraction.project.categories.publication.default import PublicationAuthor
-from easydiffraction.project.categories.publication.default import PublicationAuthors
-from easydiffraction.project.categories.publication.default import PublicationBody
-from easydiffraction.project.categories.publication.default import PublicationContactAuthor
-from easydiffraction.project.categories.publication.default import PublicationJournal
-from easydiffraction.project.categories.publication.default import PublicationJournalCoeditor
-from easydiffraction.project.categories.publication.default import PublicationJournalDate
-from easydiffraction.project.categories.publication.factory import PublicationFactory
diff --git a/src/easydiffraction/project/categories/publication/default.py b/src/easydiffraction/project/categories/publication/default.py
deleted file mode 100644
index e312e2a7d..000000000
--- a/src/easydiffraction/project/categories/publication/default.py
+++ /dev/null
@@ -1,657 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Project publication metadata categories."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from easydiffraction.core.category import CategoryCollection
-from easydiffraction.core.category import CategoryItem
-from easydiffraction.core.category_owner import CategoryOwner
-from easydiffraction.core.metadata import TypeInfo
-from easydiffraction.core.validation import AttributeSpec
-from easydiffraction.core.variable import StringDescriptor
-from easydiffraction.io.cif.handler import CifHandler
-from easydiffraction.project.categories.publication.factory import PublicationFactory
-from easydiffraction.project.publication_loader import load_publication
-
-if TYPE_CHECKING:
-    import pathlib
-
-
-class PublicationItemBase(CategoryItem):
-    """Base for optional publication metadata scalar categories."""
-
-    @staticmethod
-    def _optional_string(
-        *,
-        name: str,
-        cif_name: str,
-        description: str,
-    ) -> StringDescriptor:
-        """Create a nullable publication string descriptor."""
-        return StringDescriptor(
-            name=name,
-            description=description,
-            value_spec=AttributeSpec(default=None, allow_none=True),
-            cif_handler=CifHandler(names=[cif_name]),
-        )
-
-
-class PublicationJournal(PublicationItemBase):
-    """Journal metadata for publication reports."""
-
-    _category_code = 'journal'
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._name_full = self._optional_string(
-            name='name_full',
-            cif_name='_journal.name_full',
-            description='Full journal name.',
-        )
-        self._year = self._optional_string(
-            name='year',
-            cif_name='_journal.year',
-            description='Journal publication year.',
-        )
-        self._volume = self._optional_string(
-            name='volume',
-            cif_name='_journal.volume',
-            description='Journal volume.',
-        )
-        self._issue = self._optional_string(
-            name='issue',
-            cif_name='_journal.issue',
-            description='Journal issue.',
-        )
-        self._page_first = self._optional_string(
-            name='page_first',
-            cif_name='_journal.page_first',
-            description='First journal page.',
-        )
-        self._page_last = self._optional_string(
-            name='page_last',
-            cif_name='_journal.page_last',
-            description='Last journal page.',
-        )
-        self._paper_category = self._optional_string(
-            name='paper_category',
-            cif_name='_journal.paper_category',
-            description='Journal paper category.',
-        )
-        self._paper_doi = self._optional_string(
-            name='paper_doi',
-            cif_name='_journal.paper_DOI',
-            description='Journal paper DOI.',
-        )
-        self._coden_astm = self._optional_string(
-            name='coden_astm',
-            cif_name='_journal.coden_ASTM',
-            description='Journal CODEN ASTM identifier.',
-        )
-        self._suppl_publ_number = self._optional_string(
-            name='suppl_publ_number',
-            cif_name='_journal.suppl_publ_number',
-            description='Supplementary publication number.',
-        )
-
-    @property
-    def name_full(self) -> StringDescriptor:
-        """Full journal name."""
-        return self._name_full
-
-    @name_full.setter
-    def name_full(self, value: str | None) -> None:
-        self._name_full.value = value
-
-    @property
-    def year(self) -> StringDescriptor:
-        """Journal publication year."""
-        return self._year
-
-    @year.setter
-    def year(self, value: str | None) -> None:
-        self._year.value = value
-
-    @property
-    def volume(self) -> StringDescriptor:
-        """Journal volume."""
-        return self._volume
-
-    @volume.setter
-    def volume(self, value: str | None) -> None:
-        self._volume.value = value
-
-    @property
-    def issue(self) -> StringDescriptor:
-        """Journal issue."""
-        return self._issue
-
-    @issue.setter
-    def issue(self, value: str | None) -> None:
-        self._issue.value = value
-
-    @property
-    def page_first(self) -> StringDescriptor:
-        """First journal page."""
-        return self._page_first
-
-    @page_first.setter
-    def page_first(self, value: str | None) -> None:
-        self._page_first.value = value
-
-    @property
-    def page_last(self) -> StringDescriptor:
-        """Last journal page."""
-        return self._page_last
-
-    @page_last.setter
-    def page_last(self, value: str | None) -> None:
-        self._page_last.value = value
-
-    @property
-    def paper_category(self) -> StringDescriptor:
-        """Journal paper category."""
-        return self._paper_category
-
-    @paper_category.setter
-    def paper_category(self, value: str | None) -> None:
-        self._paper_category.value = value
-
-    @property
-    def paper_doi(self) -> StringDescriptor:
-        """Journal paper DOI."""
-        return self._paper_doi
-
-    @paper_doi.setter
-    def paper_doi(self, value: str | None) -> None:
-        self._paper_doi.value = value
-
-    @property
-    def coden_astm(self) -> StringDescriptor:
-        """Journal CODEN ASTM identifier."""
-        return self._coden_astm
-
-    @coden_astm.setter
-    def coden_astm(self, value: str | None) -> None:
-        self._coden_astm.value = value
-
-    @property
-    def suppl_publ_number(self) -> StringDescriptor:
-        """Supplementary publication number."""
-        return self._suppl_publ_number
-
-    @suppl_publ_number.setter
-    def suppl_publ_number(self, value: str | None) -> None:
-        self._suppl_publ_number.value = value
-
-
-class PublicationJournalDate(PublicationItemBase):
-    """Journal editorial date metadata."""
-
-    _category_code = 'journal_date'
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._accepted = self._optional_string(
-            name='accepted',
-            cif_name='_journal_date.accepted',
-            description='Accepted date.',
-        )
-        self._from_coeditor = self._optional_string(
-            name='from_coeditor',
-            cif_name='_journal_date.from_coeditor',
-            description='Date sent from coeditor.',
-        )
-        self._printers_final = self._optional_string(
-            name='printers_final',
-            cif_name='_journal_date.printers_final',
-            description='Final printer date.',
-        )
-
-    @property
-    def accepted(self) -> StringDescriptor:
-        """Accepted date."""
-        return self._accepted
-
-    @accepted.setter
-    def accepted(self, value: str | None) -> None:
-        self._accepted.value = value
-
-    @property
-    def from_coeditor(self) -> StringDescriptor:
-        """Date sent from coeditor."""
-        return self._from_coeditor
-
-    @from_coeditor.setter
-    def from_coeditor(self, value: str | None) -> None:
-        self._from_coeditor.value = value
-
-    @property
-    def printers_final(self) -> StringDescriptor:
-        """Final printer date."""
-        return self._printers_final
-
-    @printers_final.setter
-    def printers_final(self, value: str | None) -> None:
-        self._printers_final.value = value
-
-
-class PublicationJournalCoeditor(PublicationItemBase):
-    """Journal coeditor metadata."""
-
-    _category_code = 'journal_coeditor'
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._code = self._optional_string(
-            name='code',
-            cif_name='_journal_coeditor.code',
-            description='Journal coeditor code.',
-        )
-        self._name = self._optional_string(
-            name='name',
-            cif_name='_journal_coeditor.name',
-            description='Journal coeditor name.',
-        )
-        self._notes = self._optional_string(
-            name='notes',
-            cif_name='_journal_coeditor.notes',
-            description='Journal coeditor notes.',
-        )
-
-    @property
-    def code(self) -> StringDescriptor:
-        """Journal coeditor code."""
-        return self._code
-
-    @code.setter
-    def code(self, value: str | None) -> None:
-        self._code.value = value
-
-    @property
-    def name(self) -> StringDescriptor:
-        """Journal coeditor name."""
-        return self._name
-
-    @name.setter
-    def name(self, value: str | None) -> None:
-        self._name.value = value
-
-    @property
-    def notes(self) -> StringDescriptor:
-        """Journal coeditor notes."""
-        return self._notes
-
-    @notes.setter
-    def notes(self, value: str | None) -> None:
-        self._notes.value = value
-
-
-class PublicationContactAuthor(PublicationItemBase):
-    """Publication contact-author metadata."""
-
-    _category_code = 'publ_contact_author'
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._name = self._optional_string(
-            name='name',
-            cif_name='_publ_contact_author.name',
-            description='Contact author name.',
-        )
-        self._address = self._optional_string(
-            name='address',
-            cif_name='_publ_contact_author.address',
-            description='Contact author address.',
-        )
-        self._email = self._optional_string(
-            name='email',
-            cif_name='_publ_contact_author.email',
-            description='Contact author email.',
-        )
-        self._phone = self._optional_string(
-            name='phone',
-            cif_name='_publ_contact_author.phone',
-            description='Contact author phone.',
-        )
-        self._id_orcid = self._optional_string(
-            name='id_orcid',
-            cif_name='_publ_contact_author.id_ORCID',
-            description='Contact author ORCID identifier.',
-        )
-        self._id_iucr = self._optional_string(
-            name='id_iucr',
-            cif_name='_publ_contact_author.id_IUCr',
-            description='Contact author IUCr identifier.',
-        )
-
-    @property
-    def name(self) -> StringDescriptor:
-        """Contact author name."""
-        return self._name
-
-    @name.setter
-    def name(self, value: str | None) -> None:
-        self._name.value = value
-
-    @property
-    def address(self) -> StringDescriptor:
-        """Contact author address."""
-        return self._address
-
-    @address.setter
-    def address(self, value: str | None) -> None:
-        self._address.value = value
-
-    @property
-    def email(self) -> StringDescriptor:
-        """Contact author email."""
-        return self._email
-
-    @email.setter
-    def email(self, value: str | None) -> None:
-        self._email.value = value
-
-    @property
-    def phone(self) -> StringDescriptor:
-        """Contact author phone."""
-        return self._phone
-
-    @phone.setter
-    def phone(self, value: str | None) -> None:
-        self._phone.value = value
-
-    @property
-    def id_orcid(self) -> StringDescriptor:
-        """Contact author ORCID identifier."""
-        return self._id_orcid
-
-    @id_orcid.setter
-    def id_orcid(self, value: str | None) -> None:
-        self._id_orcid.value = value
-
-    @property
-    def id_iucr(self) -> StringDescriptor:
-        """Contact author IUCr identifier."""
-        return self._id_iucr
-
-    @id_iucr.setter
-    def id_iucr(self, value: str | None) -> None:
-        self._id_iucr.value = value
-
-
-class PublicationBody(PublicationItemBase):
-    """Publication body metadata."""
-
-    _category_code = 'publ_body'
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._title = self._optional_string(
-            name='title',
-            cif_name='_publ_body.title',
-            description='Publication title.',
-        )
-        self._synopsis = self._optional_string(
-            name='synopsis',
-            cif_name='_publ_body.synopsis',
-            description='Publication synopsis.',
-        )
-        self._abstract = self._optional_string(
-            name='abstract',
-            cif_name='_publ_body.abstract',
-            description='Publication abstract.',
-        )
-        self._keywords = self._optional_string(
-            name='keywords',
-            cif_name='_publ_body.keywords',
-            description='Publication keywords.',
-        )
-
-    @property
-    def title(self) -> StringDescriptor:
-        """Publication title."""
-        return self._title
-
-    @title.setter
-    def title(self, value: str | None) -> None:
-        self._title.value = value
-
-    @property
-    def synopsis(self) -> StringDescriptor:
-        """Publication synopsis."""
-        return self._synopsis
-
-    @synopsis.setter
-    def synopsis(self, value: str | None) -> None:
-        self._synopsis.value = value
-
-    @property
-    def abstract(self) -> StringDescriptor:
-        """Publication abstract."""
-        return self._abstract
-
-    @abstract.setter
-    def abstract(self, value: str | None) -> None:
-        self._abstract.value = value
-
-    @property
-    def keywords(self) -> list[str]:
-        """Publication keywords."""
-        value = self._keywords.value
-        if value in {None, ''}:
-            return []
-        return str(value).splitlines()
-
-    @keywords.setter
-    def keywords(self, value: list[str]) -> None:
-        self._keywords.value = '\n'.join(value)
-
-
-class PublicationAuthor(PublicationItemBase):
-    """Single publication author row."""
-
-    _category_code = 'publ_author'
-    _category_entry_name = 'name'
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._name = self._optional_string(
-            name='name',
-            cif_name='_publ_author.name',
-            description='Publication author name.',
-        )
-        self._address = self._optional_string(
-            name='address',
-            cif_name='_publ_author.address',
-            description='Publication author address.',
-        )
-        self._footnote = self._optional_string(
-            name='footnote',
-            cif_name='_publ_author.footnote',
-            description='Publication author footnote.',
-        )
-        self._id_orcid = self._optional_string(
-            name='id_orcid',
-            cif_name='_publ_author.id_ORCID',
-            description='Publication author ORCID identifier.',
-        )
-        self._id_iucr = self._optional_string(
-            name='id_iucr',
-            cif_name='_publ_author.id_IUCr',
-            description='Publication author IUCr identifier.',
-        )
-
-    @property
-    def name(self) -> StringDescriptor:
-        """Publication author name."""
-        return self._name
-
-    @name.setter
-    def name(self, value: str | None) -> None:
-        self._name.value = value
-
-    @property
-    def address(self) -> StringDescriptor:
-        """Publication author address."""
-        return self._address
-
-    @address.setter
-    def address(self, value: str | None) -> None:
-        self._address.value = value
-
-    @property
-    def footnote(self) -> StringDescriptor:
-        """Publication author footnote."""
-        return self._footnote
-
-    @footnote.setter
-    def footnote(self, value: str | None) -> None:
-        self._footnote.value = value
-
-    @property
-    def id_orcid(self) -> StringDescriptor:
-        """Publication author ORCID identifier."""
-        return self._id_orcid
-
-    @id_orcid.setter
-    def id_orcid(self, value: str | None) -> None:
-        self._id_orcid.value = value
-
-    @property
-    def id_iucr(self) -> StringDescriptor:
-        """Publication author IUCr identifier."""
-        return self._id_iucr
-
-    @id_iucr.setter
-    def id_iucr(self, value: str | None) -> None:
-        self._id_iucr.value = value
-
-
-class PublicationAuthors(CategoryCollection):
-    """Publication author rows."""
-
-    def __init__(self) -> None:
-        """Create an empty publication-author collection."""
-        super().__init__(item_type=PublicationAuthor)
-
-    def add(
-        self,
-        *,
-        name: str,
-        address: str | None = None,
-        footnote: str | None = None,
-        id_orcid: str | None = None,
-        id_iucr: str | None = None,
-    ) -> PublicationAuthor:
-        """
-        Add or replace one publication author row.
-
-        Parameters
-        ----------
-        name : str
-            Author name.
-        address : str | None, default=None
-            Author address.
-        footnote : str | None, default=None
-            Author footnote.
-        id_orcid : str | None, default=None
-            Author ORCID identifier.
-        id_iucr : str | None, default=None
-            Author IUCr identifier.
-
-        Returns
-        -------
-        PublicationAuthor
-            The inserted author row.
-        """
-        author = PublicationAuthor()
-        author.name = name
-        author.address = address
-        author.footnote = footnote
-        author.id_orcid = id_orcid
-        author.id_iucr = id_iucr
-        super().add(author)
-        return author
-
-
-@PublicationFactory.register
-class Publication(CategoryOwner):
-    """Project publication metadata facade."""
-
-    type_info = TypeInfo(
-        tag='default',
-        description='Project publication metadata',
-    )
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._journal = PublicationJournal()
-        self._journal_date = PublicationJournalDate()
-        self._journal_coeditor = PublicationJournalCoeditor()
-        self._contact_author = PublicationContactAuthor()
-        self._body = PublicationBody()
-        self._authors = PublicationAuthors()
-
-    @property
-    def journal(self) -> PublicationJournal:
-        """Journal metadata."""
-        return self._journal
-
-    @property
-    def journal_date(self) -> PublicationJournalDate:
-        """Journal editorial date metadata."""
-        return self._journal_date
-
-    @property
-    def journal_coeditor(self) -> PublicationJournalCoeditor:
-        """Journal coeditor metadata."""
-        return self._journal_coeditor
-
-    @property
-    def contact_author(self) -> PublicationContactAuthor:
-        """Publication contact-author metadata."""
-        return self._contact_author
-
-    @property
-    def body(self) -> PublicationBody:
-        """Publication body metadata."""
-        return self._body
-
-    @property
-    def authors(self) -> PublicationAuthors:
-        """Publication author rows."""
-        return self._authors
-
-    @property
-    def as_cif(self) -> str:
-        """Serialize publication metadata to CIF."""
-        from easydiffraction.io.cif.serialize import category_owner_to_cif  # noqa: PLC0415
-
-        return category_owner_to_cif(self)
-
-    def from_cif(self, block: object) -> None:
-        """
-        Populate publication metadata from a project CIF block.
-
-        Parameters
-        ----------
-        block : object
-            Parsed CIF block containing project-level publication tags.
-        """
-        for category in self.categories:
-            category.from_cif(block)
-
-    def load(self, path: str | pathlib.Path) -> None:
-        """
-        Load publication metadata from a TOML or JSON file.
-
-        Parameters
-        ----------
-        path : str | pathlib.Path
-            File path ending in ``.toml`` or ``.json``.
-        """
-        load_publication(self, path)
diff --git a/src/easydiffraction/project/categories/publication/factory.py b/src/easydiffraction/project/categories/publication/factory.py
deleted file mode 100644
index 0f2926339..000000000
--- a/src/easydiffraction/project/categories/publication/factory.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Factory for project publication metadata owners."""
-
-from __future__ import annotations
-
-from typing import ClassVar
-
-from easydiffraction.core.factory import FactoryBase
-
-
-class PublicationFactory(FactoryBase):
-    """Create project publication metadata owners."""
-
-    _default_rules: ClassVar[dict] = {
-        frozenset(): 'default',
-    }
diff --git a/src/easydiffraction/project/project.py b/src/easydiffraction/project/project.py
index 66b80e973..6cffbd76a 100644
--- a/src/easydiffraction/project/project.py
+++ b/src/easydiffraction/project/project.py
@@ -23,8 +23,6 @@
 from easydiffraction.io.cif.serialize import project_to_cif
 from easydiffraction.io.results_sidecar import read_analysis_results_sidecar
 from easydiffraction.io.results_sidecar import write_analysis_results_sidecar
-from easydiffraction.project.categories.publication import Publication
-from easydiffraction.project.categories.publication import PublicationFactory
 from easydiffraction.project.display import ProjectDisplay
 from easydiffraction.project.project_config import ProjectConfig
 from easydiffraction.utils.enums import VerbosityEnum
@@ -217,7 +215,6 @@ def __init__(
         object.__setattr__(self, '_structure_view', self._config.structure_view)
         object.__setattr__(self, '_structure_style', self._config.structure_style)
         object.__setattr__(self, '_report', self._config.report)
-        self._publication = PublicationFactory.create(PublicationFactory.default_tag())
         self._display = ProjectDisplay(self)
         self._analysis = Analysis(self)
         self._saved = False
@@ -236,7 +233,6 @@ def _attach_category_parents(self) -> None:
         self._structure_view._parent = self
         self._structure_style._parent = self
         self._report._parent = self
-        self._publication._parent = self
 
     @staticmethod
     def _supported_filters_for(category: object) -> dict[str, object]:
@@ -365,11 +361,6 @@ def report(self) -> Report:
         """Submission report builder bound to the project."""
         return self._report
 
-    @property
-    def publication(self) -> Publication:
-        """Publication metadata bound to the project."""
-        return self._publication
-
     @property
     def parameters(self) -> list:
         """Return parameters from all structures and experiments."""
diff --git a/src/easydiffraction/project/publication_loader.py b/src/easydiffraction/project/publication_loader.py
deleted file mode 100644
index 592b17411..000000000
--- a/src/easydiffraction/project/publication_loader.py
+++ /dev/null
@@ -1,199 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-"""Load publication metadata from TOML or JSON files."""
-
-from __future__ import annotations
-
-import json
-import pathlib
-import tomllib
-from collections.abc import Mapping
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from easydiffraction.project.categories.publication import Publication
-
-_FIELD_MAP = {
-    'journal_name_full': ('journal', 'name_full'),
-    'journal_year': ('journal', 'year'),
-    'journal_volume': ('journal', 'volume'),
-    'journal_issue': ('journal', 'issue'),
-    'journal_page_first': ('journal', 'page_first'),
-    'journal_page_last': ('journal', 'page_last'),
-    'journal_paper_category': ('journal', 'paper_category'),
-    'journal_paper_doi': ('journal', 'paper_doi'),
-    'journal_coden_astm': ('journal', 'coden_astm'),
-    'journal_suppl_publ_number': ('journal', 'suppl_publ_number'),
-    'journal_date_accepted': ('journal_date', 'accepted'),
-    'journal_date_from_coeditor': ('journal_date', 'from_coeditor'),
-    'journal_date_printers_final': ('journal_date', 'printers_final'),
-    'journal_coeditor_code': ('journal_coeditor', 'code'),
-    'journal_coeditor_name': ('journal_coeditor', 'name'),
-    'journal_coeditor_notes': ('journal_coeditor', 'notes'),
-    'contact_author_name': ('contact_author', 'name'),
-    'contact_author_address': ('contact_author', 'address'),
-    'contact_author_email': ('contact_author', 'email'),
-    'contact_author_phone': ('contact_author', 'phone'),
-    'contact_author_id_orcid': ('contact_author', 'id_orcid'),
-    'contact_author_id_iucr': ('contact_author', 'id_iucr'),
-    'body_title': ('body', 'title'),
-    'body_synopsis': ('body', 'synopsis'),
-    'body_abstract': ('body', 'abstract'),
-}
-
-_AUTHOR_FIELDS = {
-    'name',
-    'address',
-    'footnote',
-    'id_orcid',
-    'id_iucr',
-}
-
-
-def _read_publication_data(path: pathlib.Path) -> Mapping[str, object]:
-    """Read a publication metadata file by extension."""
-    ext = path.suffix.lower()
-    if ext == '.toml':
-        data = tomllib.loads(path.read_text(encoding='utf-8'))
-    elif ext == '.json':
-        data = json.loads(path.read_text(encoding='utf-8'))
-    else:
-        msg = f'Unsupported publication-info format: {ext}. Use .toml or .json.'
-        raise ValueError(msg)
-
-    if not isinstance(data, Mapping):
-        msg = 'Publication-info file must contain a top-level object.'
-        raise TypeError(msg)
-    return data
-
-
-def _optional_text(key: str, value: object) -> str | None:
-    """Validate an optional text field from the publication file."""
-    if value is None:
-        return None
-    if isinstance(value, str):
-        return value
-    if isinstance(value, (int, float)) and not isinstance(value, bool):
-        return str(value)
-    msg = f'Publication-info field {key!r} must be a string or null.'
-    raise ValueError(msg)
-
-
-def _required_text(key: str, value: object) -> str:
-    """Validate a required text field from the publication file."""
-    text = _optional_text(key, value)
-    if text is None or not text:
-        msg = f'Publication-info field {key!r} must be a non-empty string.'
-        raise ValueError(msg)
-    return text
-
-
-def _keywords(value: object) -> list[str]:
-    """Validate body keywords from the publication file."""
-    if value is None:
-        return []
-    if not isinstance(value, list):
-        msg = "Publication-info field 'body_keywords' must be a list of strings."
-        raise TypeError(msg)
-
-    keywords: list[str] = []
-    for idx, keyword in enumerate(value):
-        if not isinstance(keyword, str):
-            msg = f"Publication-info field 'body_keywords[{idx}]' must be a string."
-            raise TypeError(msg)
-        keywords.append(keyword)
-    return keywords
-
-
-def _author_rows(value: object) -> list[dict[str, str | None]]:
-    """Validate publication author rows from the publication file."""
-    if not isinstance(value, list):
-        msg = "Publication-info field 'authors' must be a list of objects."
-        raise TypeError(msg)
-
-    rows: list[dict[str, str | None]] = []
-    for idx, row in enumerate(value):
-        if not isinstance(row, Mapping):
-            msg = f"Publication-info field 'authors[{idx}]' must be an object."
-            raise TypeError(msg)
-
-        for key in row:
-            if key not in _AUTHOR_FIELDS:
-                msg = f'authors.{key}'
-                raise ValueError(msg)
-
-        rows.append({
-            'name': _required_text(f'authors[{idx}].name', row.get('name')),
-            'address': _optional_text(f'authors[{idx}].address', row.get('address')),
-            'footnote': _optional_text(f'authors[{idx}].footnote', row.get('footnote')),
-            'id_orcid': _optional_text(f'authors[{idx}].id_orcid', row.get('id_orcid')),
-            'id_iucr': _optional_text(f'authors[{idx}].id_iucr', row.get('id_iucr')),
-        })
-    return rows
-
-
-def _validate_publication_data(
-    data: Mapping[str, object],
-) -> tuple[
-    list[tuple[str, str, str | None]],
-    list[str] | None,
-    list[dict[str, str | None]] | None,
-]:
-    """Validate publication data and return normalized updates."""
-    updates: list[tuple[str, str, str | None]] = []
-    keywords: list[str] | None = None
-    authors: list[dict[str, str | None]] | None = None
-
-    for key, value in data.items():
-        if key in _FIELD_MAP:
-            category_name, attr_name = _FIELD_MAP[key]
-            updates.append((category_name, attr_name, _optional_text(key, value)))
-        elif key == 'body_keywords':
-            keywords = _keywords(value)
-        elif key == 'authors':
-            authors = _author_rows(value)
-        else:
-            raise ValueError(key)
-
-    return updates, keywords, authors
-
-
-def _apply_author_rows(
-    publication: Publication,
-    authors: list[dict[str, str | None]],
-) -> None:
-    """
-    Replace the publication author collection with normalized rows.
-    """
-    publication.authors._adopt_items([])
-    publication.authors._mark_parent_dirty()
-    for author in authors:
-        publication.authors.add(
-            name=author['name'],
-            address=author['address'],
-            footnote=author['footnote'],
-            id_orcid=author['id_orcid'],
-            id_iucr=author['id_iucr'],
-        )
-
-
-def load_publication(publication: Publication, path: str | pathlib.Path) -> None:
-    """
-    Load publication metadata into a Publication object.
-
-    Parameters
-    ----------
-    publication : Publication
-        Publication metadata facade to populate.
-    path : str | pathlib.Path
-        TOML or JSON file containing flat publication metadata keys.
-    """
-    data = _read_publication_data(pathlib.Path(path))
-    updates, keywords, authors = _validate_publication_data(data)
-
-    for category_name, attr_name, value in updates:
-        setattr(getattr(publication, category_name), attr_name, value)
-    if keywords is not None:
-        publication.body.keywords = keywords
-    if authors is not None:
-        _apply_author_rows(publication, authors)
diff --git a/src/easydiffraction/report/data_context.py b/src/easydiffraction/report/data_context.py
index 741c77a0e..ce6fe4ca9 100644
--- a/src/easydiffraction/report/data_context.py
+++ b/src/easydiffraction/report/data_context.py
@@ -57,48 +57,6 @@
     'ambient_temperature',
     'ambient_pressure',
 )
-_PUBLICATION_JOURNAL_FIELDS = (
-    'name_full',
-    'year',
-    'volume',
-    'issue',
-    'page_first',
-    'page_last',
-    'paper_category',
-    'paper_doi',
-    'coden_astm',
-    'suppl_publ_number',
-)
-_PUBLICATION_JOURNAL_DATE_FIELDS = (
-    'accepted',
-    'from_coeditor',
-    'printers_final',
-)
-_PUBLICATION_JOURNAL_COEDITOR_FIELDS = (
-    'code',
-    'name',
-    'notes',
-)
-_PUBLICATION_CONTACT_AUTHOR_FIELDS = (
-    'name',
-    'address',
-    'email',
-    'phone',
-    'id_orcid',
-    'id_iucr',
-)
-_PUBLICATION_BODY_FIELDS = (
-    'title',
-    'synopsis',
-    'abstract',
-)
-_PUBLICATION_AUTHOR_FIELDS = (
-    'name',
-    'address',
-    'footnote',
-    'id_orcid',
-    'id_iucr',
-)
 _REPORT_LOOP_DISPLAY_LIMIT = DEFAULT_LOOP_DISPLAY_LIMIT
 _FULL_WIDTH_TABLE_CHAR_LIMIT = 40
 _TRUNCATED_DATA_CATEGORY_CODES = frozenset({'pd_data', 'total_data'})
@@ -126,8 +84,7 @@ class ReportDataContext:
     Parameters
     ----------
     project : object
-        Project facade that owns structures, experiments, analysis, and
-        publication metadata.
+        Project facade that owns structures, experiments, and analysis.
     """
 
     def __init__(self, project: object) -> None:
@@ -151,7 +108,6 @@ def build(self) -> dict[str, object]:
             'structures': [self._structure_context(structure) for structure in structures],
             'experiments': [self._experiment_context(experiment) for experiment in experiments],
             'analysis': self._analysis_context(),
-            'publication': self._publication_context(),
             'metadata': {
                 'easydiffraction_version': package_version('easydiffraction'),
                 'generated_at': _format_generated_at(datetime.now(tz=UTC)),
@@ -312,37 +268,6 @@ def _software_context(self) -> dict[str, object]:
             'fit_datetime': _attr_value(software, 'timestamp'),
         }
 
-    def _publication_context(self) -> dict[str, object]:
-        """Return journal-publication metadata."""
-        publication = _safe_attr(self._project, 'publication')
-        body = _safe_attr(publication, 'body')
-        return {
-            'journal': _field_values(
-                _safe_attr(publication, 'journal'),
-                _PUBLICATION_JOURNAL_FIELDS,
-            ),
-            'journal_date': _field_values(
-                _safe_attr(publication, 'journal_date'),
-                _PUBLICATION_JOURNAL_DATE_FIELDS,
-            ),
-            'journal_coeditor': _field_values(
-                _safe_attr(publication, 'journal_coeditor'),
-                _PUBLICATION_JOURNAL_COEDITOR_FIELDS,
-            ),
-            'contact_author': _field_values(
-                _safe_attr(publication, 'contact_author'),
-                _PUBLICATION_CONTACT_AUTHOR_FIELDS,
-            ),
-            'body': {
-                **_field_values(body, _PUBLICATION_BODY_FIELDS),
-                'keywords': list(_safe_attr(body, 'keywords') or []),
-            },
-            'authors': [
-                _field_values(author, _PUBLICATION_AUTHOR_FIELDS)
-                for author in _collection_values(_safe_attr(publication, 'authors'))
-            ],
-        }
-
 
 def build_report_data_context(project: object) -> dict[str, object]:
     """
diff --git a/tests/unit/easydiffraction/io/cif/test_iucr_writer.py b/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
index 12217863d..5489f66d6 100644
--- a/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
+++ b/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
@@ -277,6 +277,8 @@ def test_write_iucr_cif_writes_global_block(tmp_path):
     assert '_computing.structure_refinement' in text
     assert '_easydiffraction_software.framework' in text
     assert '_easydiffraction_software.minimizer' in text
+    assert '_journal.' not in text
+    assert '_publ_' not in text
 
 
 def test_write_iucr_cif_emits_single_crystal_block(tmp_path):
@@ -312,15 +314,20 @@ def test_write_iucr_cif_emits_powder_cwl_blocks(tmp_path):
 
     text = write_iucr_cif(project).read_text(encoding='utf-8')
 
-    assert 'data_powder_overall' in text
-    assert 'data_powder_phase_1' in text
-    assert 'data_powder_pwd_1' in text
+    assert 'data_overall' in text
+    assert 'data_phase1' in text
+    assert 'data_cwl' in text
+    assert '_pd_block_id                           phase1' in text
+    assert '_pd_block_diffractogram_id             cwl' in text
+    assert '|phase1|' not in text
+    assert '|cwl|' not in text
     assert '_pd_meas.2theta_scan' in text
     assert '_pd_meas.time_of_flight' not in text
     assert '_pd_refln.phase_id' in text
     assert '_refln.phase_calc' not in text
     assert '_pd_proc.info_excluded_regions' in text
     assert '_easydiffraction_background.type' in text
+    assert '_pd_meas.info_author_' not in text
 
 
 def test_write_iucr_cif_emits_joint_tof_pattern_blocks(tmp_path):
@@ -338,14 +345,32 @@ def test_write_iucr_cif_emits_joint_tof_pattern_blocks(tmp_path):
 
     text = write_iucr_cif(project).read_text(encoding='utf-8')
 
-    assert 'data_joint_pwd_1' in text
-    assert 'data_joint_pwd_2' in text
+    assert 'data_tof1' in text
+    assert 'data_tof2' in text
+    assert '\n_pd_block_diffractogram_id\n  tof1\n  tof2\n' in text
     assert '_pd_meas.time_of_flight' in text
     assert '_pd_calib_d_to_tof.power' in text
     assert 'recip' in text
     assert '-1' in text
 
 
+def test_write_iucr_cif_keeps_powder_block_names_unique(tmp_path):
+    from easydiffraction.io.cif.iucr_writer import write_iucr_cif
+
+    project = _project(
+        'demo',
+        tmp_path,
+        _collection(_structure(name='overall')),
+        _collection(_powder_experiment('overall')),
+    )
+
+    text = write_iucr_cif(project).read_text(encoding='utf-8')
+
+    assert 'data_overall' in text
+    assert 'data_overall_2' in text
+    assert 'data_overall_3' in text
+
+
 def test_iucr_loop_rows_are_not_padded_to_tag_width():
     from easydiffraction.io.cif.iucr_writer import _write_loop
 
diff --git a/tests/unit/easydiffraction/project/categories/publication/test_default.py b/tests/unit/easydiffraction/project/categories/publication/test_default.py
deleted file mode 100644
index 4fe0b4462..000000000
--- a/tests/unit/easydiffraction/project/categories/publication/test_default.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-
-from __future__ import annotations
-
-
-def test_publication_instantiates_and_serializes_to_cif():
-    from easydiffraction.project.categories.publication.default import Publication
-
-    publication = Publication()
-    publication.body.title = 'Refinement report'
-    publication.authors.add(name='Ada Lovelace')
-
-    cif_text = publication.as_cif
-
-    assert not cif_text.startswith('data_')
-    assert '_publ_body.title' in cif_text
-    assert 'Refinement report' in cif_text
-    assert '_publ_author.name' in cif_text
-    assert 'Ada Lovelace' in cif_text
diff --git a/tests/unit/easydiffraction/project/categories/publication/test_factory.py b/tests/unit/easydiffraction/project/categories/publication/test_factory.py
deleted file mode 100644
index 872399697..000000000
--- a/tests/unit/easydiffraction/project/categories/publication/test_factory.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-
-from __future__ import annotations
-
-import pytest
-
-
-def test_publication_factory_default_and_create():
-    from easydiffraction.project.categories.publication.default import Publication
-    from easydiffraction.project.categories.publication.factory import PublicationFactory
-
-    assert PublicationFactory.default_tag() == 'default'
-    assert 'default' in PublicationFactory.supported_tags()
-
-    publication = PublicationFactory.create('default')
-
-    assert isinstance(publication, Publication)
-
-
-def test_publication_factory_rejects_unknown_tag():
-    from easydiffraction.project.categories.publication.factory import PublicationFactory
-
-    with pytest.raises(ValueError, match=r"Unsupported type: 'missing'"):
-        PublicationFactory.create('missing')
diff --git a/tests/unit/easydiffraction/project/test_project.py b/tests/unit/easydiffraction/project/test_project.py
index a57d0e46c..92b336483 100644
--- a/tests/unit/easydiffraction/project/test_project.py
+++ b/tests/unit/easydiffraction/project/test_project.py
@@ -80,6 +80,7 @@ def test_project_exposes_chart_table_and_display_facades():
     assert isinstance(project.display, ProjectDisplay)
     assert isinstance(project.report, Report)
     assert hasattr(project.report, 'save')
+    assert 'publication' not in Project._public_attrs()
 
 
 def test_apply_params_from_csv_resolves_relative_file_paths(tmp_path):
diff --git a/tests/unit/easydiffraction/project/test_project_config.py b/tests/unit/easydiffraction/project/test_project_config.py
index 0cc111398..6c9a4beeb 100644
--- a/tests/unit/easydiffraction/project/test_project_config.py
+++ b/tests/unit/easydiffraction/project/test_project_config.py
@@ -78,6 +78,8 @@ def test_project_config_as_cif_has_project_chart_and_table_sections_without_data
     assert '_rendering_plot.type auto' in cif_text
     assert '_rendering_table.type auto' in cif_text
     assert '_verbosity.fit full' in cif_text
+    assert '_journal.' not in cif_text
+    assert '_publ_' not in cif_text
 
 
 def test_project_save_and_load_use_auto_display_defaults_when_unset(tmp_path):
@@ -93,6 +95,8 @@ def test_project_save_and_load_use_auto_display_defaults_when_unset(tmp_path):
     assert '_report.cif false' in project_cif
     assert '_rendering_table.type auto' in project_cif
     assert '_verbosity.fit full' in project_cif
+    assert '_journal.' not in project_cif
+    assert '_publ_' not in project_cif
 
     loaded = Project.load(str(tmp_path / 'proj'))
 
diff --git a/tests/unit/easydiffraction/project/test_publication_loader.py b/tests/unit/easydiffraction/project/test_publication_loader.py
deleted file mode 100644
index 565c5afab..000000000
--- a/tests/unit/easydiffraction/project/test_publication_loader.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
-# SPDX-License-Identifier: BSD-3-Clause
-
-from __future__ import annotations
-
-import pytest
-
-
-def test_load_publication_reads_toml_metadata(tmp_path):
-    from easydiffraction.project.categories.publication.default import Publication
-    from easydiffraction.project.publication_loader import load_publication
-
-    path = tmp_path / 'publication.toml'
-    path.write_text(
-        """
-journal_name_full = "Journal of Testing"
-body_title = "Refinement report"
-body_keywords = ["diffraction", "neutron"]
-
-[[authors]]
-name = "Ada Lovelace"
-address = "London"
-""".lstrip(),
-        encoding='utf-8',
-    )
-    publication = Publication()
-
-    load_publication(publication, path)
-
-    assert publication.journal.name_full.value == 'Journal of Testing'
-    assert publication.body.title.value == 'Refinement report'
-    assert publication.body.keywords == ['diffraction', 'neutron']
-    assert len(publication.authors) == 1
-    assert publication.authors[0].name.value == 'Ada Lovelace'
-    assert publication.authors[0].address.value == 'London'
-
-
-def test_load_publication_rejects_unknown_extension(tmp_path):
-    from easydiffraction.project.categories.publication.default import Publication
-    from easydiffraction.project.publication_loader import load_publication
-
-    path = tmp_path / 'publication.txt'
-    path.write_text('body_title = "x"', encoding='utf-8')
-
-    with pytest.raises(ValueError, match='Unsupported publication-info format'):
-        load_publication(Publication(), path)
-
-
-def test_load_publication_rejects_invalid_author_shape(tmp_path):
-    from easydiffraction.project.categories.publication.default import Publication
-    from easydiffraction.project.publication_loader import load_publication
-
-    path = tmp_path / 'publication.json'
-    path.write_text('{"authors": [{"address": "missing name"}]}', encoding='utf-8')
-
-    with pytest.raises(ValueError, match=r'authors\[0\]\.name'):
-        load_publication(Publication(), path)
diff --git a/tests/unit/easydiffraction/report/test_data_context.py b/tests/unit/easydiffraction/report/test_data_context.py
index 8034e756f..ff34c0be8 100644
--- a/tests/unit/easydiffraction/report/test_data_context.py
+++ b/tests/unit/easydiffraction/report/test_data_context.py
@@ -141,7 +141,6 @@ def _project() -> SimpleNamespace:
             software=SimpleNamespace(),
             constraints=[],
         ),
-        publication=SimpleNamespace(),
     )
 
 
@@ -151,6 +150,7 @@ def test_report_data_context_builds_fit_data():
     context = build_report_data_context(_project())
 
     fit_data = context['experiments'][0]['fit_data']
+    assert 'publication' not in context
     assert fit_data['axes_labels'] == ['I²calc', 'I²meas']
     assert list(fit_data['series']['meas']['su']) == [0.5, 0.7]
     assert list(fit_data['series']['calc']['values']) == [10.0, 20.0]
diff --git a/tests/unit/easydiffraction/report/test_html_renderer.py b/tests/unit/easydiffraction/report/test_html_renderer.py
index d07d6bd40..7d65a1039 100644
--- a/tests/unit/easydiffraction/report/test_html_renderer.py
+++ b/tests/unit/easydiffraction/report/test_html_renderer.py
@@ -84,12 +84,6 @@ def _context() -> dict[str, object]:
             'n_phases': 1,
             'n_experiments': 0,
         },
-        'publication': {
-            'body': {'title': '', 'abstract': '', 'synopsis': '', 'keywords': ''},
-            'authors': [],
-            'journal': {'name_full': '', 'year': '', 'paper_doi': ''},
-            'contact_author': {'name': '', 'email': ''},
-        },
         'metadata': {
             'generated_at': '2026-05-26T00:00:00Z',
             'easydiffraction_version': '0.0',
diff --git a/tests/unit/easydiffraction/report/test_tex_renderer.py b/tests/unit/easydiffraction/report/test_tex_renderer.py
index f12b68f47..61efd39a7 100644
--- a/tests/unit/easydiffraction/report/test_tex_renderer.py
+++ b/tests/unit/easydiffraction/report/test_tex_renderer.py
@@ -16,24 +16,6 @@ def _minimal_context() -> dict[str, object]:
             'n_phases': 0,
             'n_experiments': 0,
         },
-        'publication': {
-            'body': {
-                'title': '',
-                'abstract': '',
-                'synopsis': '',
-                'keywords': '',
-            },
-            'authors': [],
-            'journal': {
-                'name_full': '',
-                'year': '',
-                'paper_doi': '',
-            },
-            'contact_author': {
-                'name': '',
-                'email': '',
-            },
-        },
         'metadata': {
             'generated_at': '2026-05-26T00:00:00Z',
             'easydiffraction_version': '0.0',

From e54709f1ef3f139b1a86878953150b45b7208b55 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 22:02:11 +0200
Subject: [PATCH 118/160] Keep report datablock names unique

---
 src/easydiffraction/io/cif/iucr_writer.py     | 24 ++++++++++-------
 .../io/cif/test_iucr_writer.py                | 26 +++++++++++++++++++
 2 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/src/easydiffraction/io/cif/iucr_writer.py b/src/easydiffraction/io/cif/iucr_writer.py
index e84b4d2e6..b0d5d9513 100644
--- a/src/easydiffraction/io/cif/iucr_writer.py
+++ b/src/easydiffraction/io/cif/iucr_writer.py
@@ -85,9 +85,10 @@ def iucr_report_path(
 
 def _render_iucr_cif(project: object) -> str:
     """Render all IUCr CIF blocks for *project*."""
+    used_block_names = {'global'}
     blocks = [_write_global_block(project)]
-    blocks.extend(_write_sc_blocks(project))
-    blocks.extend(_write_rietveld_blocks(project))
+    blocks.extend(_write_sc_blocks(project, used_block_names))
+    blocks.extend(_write_rietveld_blocks(project, used_block_names))
     return f'\n\n{_BLOCK_SEPARATOR}\n'.join(blocks) + '\n'
 
 
@@ -145,12 +146,16 @@ def _write_chemical_formula_section(
     _write_item(lines, '_chemical_formula.IUPAC', formula.iupac)
 
 
-def _write_sc_blocks(project: object) -> list[str]:
+def _write_sc_blocks(project: object, used_block_names: set[str]) -> list[str]:
     """Render single-crystal structure/experiment blocks."""
     blocks: list[str] = []
     for experiment in _single_crystal_experiments(project):
         structure = _linked_structure(project, experiment)
-        blocks.append(_write_sc_block(project, structure, experiment))
+        block_name = _unique_block_name(
+            getattr(structure, 'name', None) or 'I',
+            used_block_names,
+        )
+        blocks.append(_write_sc_block(project, structure, experiment, block_name))
     return blocks
 
 
@@ -158,9 +163,9 @@ def _write_sc_block(
     project: object,
     structure: object,
     experiment: object,
+    block_name: str,
 ) -> str:
     """Render one single-crystal data block."""
-    block_name = _block_name(getattr(structure, 'name', None) or 'I')
     lines = [f'data_{block_name}']
     _write_chemical_formula_section(lines, _structure_formula_values(structure))
     _write_cell_section(lines, structure)
@@ -386,17 +391,17 @@ def _write_sc_project_extensions(lines: list[str], experiment: object) -> None:
         _write_item(lines, tag, value)
 
 
-def _write_rietveld_blocks(project: object) -> list[str]:
+def _write_rietveld_blocks(project: object, used_block_names: set[str]) -> list[str]:
     """Render powder Rietveld overall, phase, and pattern blocks."""
     experiments = _powder_rietveld_experiments(project)
     if not experiments:
         return []
 
-    used_block_names = {'global', 'overall'}
+    overall_block_name = _unique_block_name('overall', used_block_names)
     phases = _powder_phases(project, experiments, used_block_names)
     patterns = _powder_patterns(experiments, used_block_names)
     return [
-        _write_rietveld_overall_block(project, phases, patterns),
+        _write_rietveld_overall_block(project, phases, patterns, overall_block_name),
         *[_write_powder_phase_block(phase) for phase in phases],
         *[_write_powder_pattern_block(project, pattern, phases) for pattern in patterns],
     ]
@@ -406,9 +411,10 @@ def _write_rietveld_overall_block(
     project: object,
     phases: list[_PowderPhase],
     patterns: list[_PowderPattern],
+    block_name: str,
 ) -> str:
     """Render the powder Rietveld overall block."""
-    lines = ['data_overall']
+    lines = [f'data_{block_name}']
     fit_result = _fit_result(project)
 
     _section(lines, 'Rietveld overall')
diff --git a/tests/unit/easydiffraction/io/cif/test_iucr_writer.py b/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
index 5489f66d6..5c0c67222 100644
--- a/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
+++ b/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
@@ -371,6 +371,32 @@ def test_write_iucr_cif_keeps_powder_block_names_unique(tmp_path):
     assert 'data_overall_3' in text
 
 
+def test_write_iucr_cif_keeps_mixed_topology_block_names_unique(tmp_path):
+    from easydiffraction.io.cif.iucr_writer import write_iucr_cif
+
+    project = _project(
+        'mixed',
+        tmp_path,
+        _collection(_structure(name='phase1')),
+        _collection(
+            _single_crystal_experiment('sc'),
+            _powder_experiment('cwl'),
+        ),
+    )
+
+    text = write_iucr_cif(project).read_text(encoding='utf-8')
+
+    block_names = [
+        line.removeprefix('data_')
+        for line in text.splitlines()
+        if line.startswith('data_')
+    ]
+    assert len(block_names) == len(set(block_names))
+    assert 'phase1' in block_names
+    assert 'phase1_2' in block_names
+    assert '_pd_block_id                           phase1_2' in text
+
+
 def test_iucr_loop_rows_are_not_padded_to_tag_width():
     from easydiffraction.io.cif.iucr_writer import _write_loop
 

From 32f751200d790fa0ecb6ef0f6c2747de15264de6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 22:07:52 +0200
Subject: [PATCH 119/160] Apply pixi run fix auto-fixes

---
 tests/unit/easydiffraction/io/cif/test_iucr_writer.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/tests/unit/easydiffraction/io/cif/test_iucr_writer.py b/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
index 5c0c67222..6ba55e93e 100644
--- a/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
+++ b/tests/unit/easydiffraction/io/cif/test_iucr_writer.py
@@ -387,9 +387,7 @@ def test_write_iucr_cif_keeps_mixed_topology_block_names_unique(tmp_path):
     text = write_iucr_cif(project).read_text(encoding='utf-8')
 
     block_names = [
-        line.removeprefix('data_')
-        for line in text.splitlines()
-        if line.startswith('data_')
+        line.removeprefix('data_') for line in text.splitlines() if line.startswith('data_')
     ]
     assert len(block_names) == len(set(block_names))
     assert 'phase1' in block_names

From b8b933f7688305c981ad567715e9e5192c5cde44 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 23:40:32 +0200
Subject: [PATCH 120/160] Add tutorial benchmarks

---
 ...darwin-arm64_py314_tutorial-benchmarks.csv | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 docs/dev/benchmarking/20260531-230149_darwin-arm64_py314_tutorial-benchmarks.csv

diff --git a/docs/dev/benchmarking/20260531-230149_darwin-arm64_py314_tutorial-benchmarks.csv b/docs/dev/benchmarking/20260531-230149_darwin-arm64_py314_tutorial-benchmarks.csv
new file mode 100644
index 000000000..cb80e3bb9
--- /dev/null
+++ b/docs/dev/benchmarking/20260531-230149_darwin-arm64_py314_tutorial-benchmarks.csv
@@ -0,0 +1,26 @@
+tutorial_name,elapsed_seconds,status
+ed-1.py,15.289,ok
+ed-2.py,20.224,ok
+ed-3.py,35.924,ok
+ed-4.py,4.900,ok
+ed-5.py,44.665,ok
+ed-6.py,72.056,ok
+ed-7.py,123.342,ok
+ed-8.py,122.295,ok
+ed-9.py,9.181,ok
+ed-10.py,39.141,ok
+ed-11.py,10.198,ok
+ed-12.py,8.380,ok
+ed-13.py,25.059,ok
+ed-14.py,19.839,ok
+ed-15.py,27.564,ok
+ed-16.py,63.262,ok
+ed-17.py,83.813,ok
+ed-18.py,7.138,ok
+ed-20.py,40.791,ok
+ed-21.py,78.117,ok
+ed-22.py,38.354,ok
+ed-23.py,23.290,ok
+ed-24.py,4.912,ok
+ed-25.py,27.338,ok
+ed-26.py,28.586,ok

From 52053fb08b025289f42efbbe17646aefd7213d61 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 23:49:02 +0200
Subject: [PATCH 121/160] Finalize Python-CIF category correspondence ADR

---
 .../python-cif-category-correspondence.md     | 222 ++++++++++--------
 ...hon-cif-category-correspondence_reply-1.md |  56 +++++
 ...on-cif-category-correspondence_review-1.md |  67 ++++++
 ...on-cif-category-correspondence_review-2.md |  12 +
 4 files changed, 264 insertions(+), 93 deletions(-)
 create mode 100644 docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
 create mode 100644 docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
 create mode 100644 docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md

diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
index 126483394..d31f8d0ff 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
@@ -16,17 +16,19 @@ saved in:
 project.cif
 ```
 
-Inside that file, generic category names such as `_info.*`,
-`_rendering_plot.*`, `_rendering_table.*`, and `_verbosity.*` are less
-ambiguous than they would be in a single monolithic CIF file. This opens
-the option of a strict one-to-one correspondence for project-owned
-singleton categories:
+Inside that file, project-owned category names such as
+`_rendering_plot.*`, `_report.*`, `_structure_view.*`,
+`_structure_style.*`, and `_verbosity.*` are less ambiguous than they
+would be in a single monolithic CIF file. This opens the option of a
+scoped one-to-one correspondence for EasyDiffraction-owned singleton
+configuration categories:
 
 ```text
-project.info.title        -> project.cif: _info.title
-project.rendering_plot.type        -> project.cif: _rendering_plot.type
-project.rendering_table.type        -> project.cif: _rendering_table.type
-project.verbosity.fit     -> project.cif: _verbosity.fit
+project.rendering_plot.type     -> project.cif: _rendering_plot.type
+project.report.cif              -> project.cif: _report.cif
+project.structure_view.range_a_min -> project.cif: _structure_view.range_a_min
+project.structure_style.atom_view  -> project.cif: _structure_style.atom_view
+project.verbosity.fit           -> project.cif: _verbosity.fit
 ```
 
 The design question is whether this rule should be applied only to
@@ -37,8 +39,16 @@ The accepted project-facade decision keeps `Project` as the public root
 and keeps `project.cif` as the singleton project configuration file. It
 also keeps `_project.*` as the semantic CIF category for scientific
 project information and rejects `_meta.*` for that purpose. This ADR
-therefore must not reintroduce the rejected `Workspace` rename,
-`workspace.cif`, or `_meta.project_*` tags as incidental cleanup.
+therefore does **not** reintroduce the rejected `Workspace` rename,
+`workspace.cif`, `_meta.project_*` tags, or a broad `_info.*` rewrite as
+incidental cleanup.
+
+The accepted project-summary-rendering ADR also rejected a v1
+`project.publication` owner. Journal, author, publication-body, and
+powder-measurement author metadata are not represented in code, are not
+persisted in `project.cif`, and are not emitted as empty report-CIF
+placeholders. This ADR records that as an intentional correspondence
+gap, not as a missing mapping.
 
 ## Scope Of Comparison
 
@@ -54,34 +64,43 @@ to objects reached from the current `Project` root, for example
 
 ## Current Persistence Layout
 
-| Current Python surface                                              | Current saved location   | Current CIF block form | Notes                                                                                 |
-| ------------------------------------------------------------------- | ------------------------ | ---------------------- | ------------------------------------------------------------------------------------- |
-| `project.info`, `project.rendering_plot`, `project.rendering_table` | `project.cif`            | bare categories        | Project-level singleton config.                                                       |
-| `project.report`                                                    | `project.cif`            | bare category          | Project-owned report-output config; report methods render artifacts under `reports/`. |
-| `project.publication`                                               | `project.cif`            | bare categories + loop | Journal-submission metadata under `_journal_*` / `_publ_*` categories.                |
-| `project.verbosity`                                                 | `project.cif`            | bare category          | Project-owned fit-output verbosity category backed by `VerbosityEnum`.                |
-| `project.structures[name]`                                          | `structures/<name>.cif`  | `data_<name>`          | Each structure is one CIF data block.                                                 |
-| `project.experiments[name]`                                         | `experiments/<name>.cif` | `data_<name>`          | Each experiment is one CIF data block.                                                |
-| `project.analysis`                                                  | `analysis/analysis.cif`  | bare categories        | Loader also accepts legacy root-level `analysis.cif`.                                 |
-| `project.summary`                                                   | `summary.cif`            | placeholder text       | Summary persistence exists as a file but `summary_to_cif()` is not implemented yet.   |
+| Current Python surface                                                                                                                                                  | Current saved location   | Current CIF block form | Notes                                                                                 |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ---------------------- | ------------------------------------------------------------------------------------- |
+| `project.info`, `project.rendering_plot`, `project.report`, `project.rendering_table`, `project.rendering_structure`, `project.structure_view`, `project.structure_style`, `project.verbosity` | `project.cif`            | bare categories        | Project-level singleton config.                                                       |
+| `project.structures[name]`                                                                                                                                              | `structures/<name>.cif`  | `data_<name>`          | Each structure is one CIF data block.                                                 |
+| `project.experiments[name]`                                                                                                                                             | `experiments/<name>.cif` | `data_<name>`          | Each experiment is one CIF data block.                                                |
+| `project.analysis`                                                                                                                                                      | `analysis/analysis.cif`  | bare categories        | Loader also accepts legacy root-level `analysis.cif`.                                 |
+| `project.report.save_*()` / `project.report.{cif,html,tex,pdf}`                                                                                                         | `reports/`              | multi-datablock CIF or rendered artifacts | Derived report outputs; generated only when configured or called explicitly. |
 
 ## Current Correspondence
 
 ### Project-Level Configuration
 
-| Current Python path            | Current CIF path         | Match? | Notes                                                                                              |
-| ------------------------------ | ------------------------ | ------ | -------------------------------------------------------------------------------------------------- |
-| `project.info.name`            | `_project.id`            | No     | Python uses user-facing `name`; CIF uses `id`; category is `info` in Python but `_project` in CIF. |
-| `project.info.title`           | `_project.title`         | Partly | Field name matches, category name does not.                                                        |
-| `project.info.description`     | `_project.description`   | Partly | Field name matches, category name does not.                                                        |
-| `project.info.created`         | `_project.created`       | Partly | Field name matches, category name does not.                                                        |
-| `project.info.last_modified`   | `_project.last_modified` | Partly | Field name matches, category name does not.                                                        |
-| `project.info.path`            | none                     | No     | Runtime storage path, not a CIF field.                                                             |
-| `project.rendering_plot.type`  | `_rendering_plot.type`   | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.report.*`             | `_report.*`              | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.publication.*`        | `_journal.*` / `_publ_*` | Partly | Python keeps one owner with sibling categories; CIF uses journal and publication dictionary names. |
-| `project.rendering_table.type` | `_rendering_table.type`  | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.verbosity.fit`        | `_verbosity.fit`         | Yes    | Direct category and field mapping for fitting process output verbosity.                            |
+| Current Python path                          | Current CIF path                | Match? | Notes                                                                                              |
+| -------------------------------------------- | ------------------------------- | ------ | -------------------------------------------------------------------------------------------------- |
+| `project.info.name`                          | `_project.id`                   | No     | Accepted exception: Python uses user-facing `name`; CIF uses semantic project `id`.                |
+| `project.info.title`                         | `_project.title`                | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
+| `project.info.description`                   | `_project.description`          | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
+| `project.info.created`                       | `_project.created`              | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
+| `project.info.last_modified`                 | `_project.last_modified`        | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
+| `project.info.path`                          | none                            | No     | Runtime storage path, not a CIF field.                                                             |
+| `project.rendering_plot.type`                | `_rendering_plot.type`          | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.report.cif`                         | `_report.cif`                   | Yes    | Direct project-owned report-output configuration mapping.                                          |
+| `project.report.html`                        | `_report.html`                  | Yes    | Direct project-owned report-output configuration mapping.                                          |
+| `project.report.tex`                         | `_report.tex`                   | Yes    | Direct project-owned report-output configuration mapping.                                          |
+| `project.report.pdf`                         | `_report.pdf`                   | Yes    | Direct project-owned report-output configuration mapping.                                          |
+| `project.report.html_offline`                | `_report.html_offline`          | Yes    | Direct project-owned report-output configuration mapping.                                          |
+| `project.rendering_table.type`               | `_rendering_table.type`         | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.rendering_structure.type`           | `_rendering_structure.type`     | Yes    | Direct category-owned selector mapping.                                                            |
+| `project.structure_view.show_labels`         | `_structure_view.show_labels`   | Yes    | Direct project-owned structure-view state mapping.                                                 |
+| `project.structure_view.show_moments`        | `_structure_view.show_moments`  | Yes    | Direct project-owned structure-view state mapping.                                                 |
+| `project.structure_view.range_{a,b,c}_{min,max}` | `_structure_view.range_{a,b,c}_{min,max}` | Yes | Six scalar bounds; direct project-owned structure-view state mapping.                              |
+| `project.structure_style.atom_view`          | `_structure_style.atom_view`    | Yes    | Direct project-owned structure-style value selector mapping.                                       |
+| `project.structure_style.color_scheme`       | `_structure_style.color_scheme` | Yes    | Direct project-owned structure-style value selector mapping.                                       |
+| `project.structure_style.adp_probability`    | `_structure_style.adp_probability` | Yes | Direct project-owned structure-style numeric setting.                                              |
+| `project.structure_style.atom_scale`         | `_structure_style.atom_scale`   | Yes    | Direct project-owned structure-style numeric setting.                                              |
+| `project.verbosity.fit`                      | `_verbosity.fit`                | Yes    | Direct category and field mapping for fitting process output verbosity.                            |
+| `project.verbosity = 'short'`                | `_verbosity.fit`                | Alias  | Convenience setter only; canonical persisted path remains `project.verbosity.fit`.                 |
 
 ### Analysis Configuration
 
@@ -89,8 +108,12 @@ to objects reached from the current `Project` root, for example
 | ------------------------------------------------- | ---------------------------------- | ------ | ------------------------------------------------------------------------------------------------ |
 | `analysis.minimizer.type`                         | `_minimizer.type`                  | Yes    | Direct category-owned selector mapping.                                                          |
 | `analysis.fitting_mode.type`                      | `_fitting_mode.type`               | Yes    | Direct category-owned active-sibling selector mapping.                                           |
+| `analysis.fit_result.*`                           | `_fit_result.*`                    | Yes    | Direct category mapping for scalar fit-result state; IUCr report export may use transformed tags. |
+| `analysis.fit_parameters[param].*`                 | `_fit_parameter.*`                 | Yes    | Direct loop mapping for persisted per-parameter fit state.                                       |
+| `analysis.fit_parameter_correlations[id].*`        | `_fit_parameter_correlation.*`     | Yes    | Direct loop mapping for deterministic and posterior correlation summaries.                       |
 | `analysis.joint_fit[experiment_id].experiment_id` | `_joint_fit.experiment_id`         | Yes    | Collection key is also stored as a field.                                                        |
 | `analysis.joint_fit[experiment_id].weight`        | `_joint_fit.weight`                | Yes    | Direct field mapping.                                                                            |
+| `analysis.software.*`                              | `_software.*`                      | Yes    | Direct analysis-tier software provenance mapping stamped at fit time.                            |
 | `analysis.sequential_fit.data_dir`                | `_sequential_fit.data_dir`         | Yes    | Direct category mapping.                                                                         |
 | `analysis.sequential_fit.file_pattern`            | `_sequential_fit.file_pattern`     | Yes    | Direct category mapping.                                                                         |
 | `analysis.sequential_fit.max_workers`             | `_sequential_fit.max_workers`      | Yes    | Direct category mapping.                                                                         |
@@ -102,7 +125,8 @@ to objects reached from the current `Project` root, for example
 | `analysis.sequential_fit_extract[id].required`    | `_sequential_fit_extract.required` | Yes    | Direct collection mapping.                                                                       |
 | `analysis.aliases[label].label`                   | `_alias.label`                     | Partly | Python collection is plural; CIF row category is singular.                                       |
 | `analysis.aliases[label].param_unique_name`       | `_alias.param_unique_name`         | Partly | Python collection is plural; CIF row category is singular.                                       |
-| `analysis.constraints[lhs_alias].expression`      | `_constraint.expression`           | Partly | Collection key is derived from the expression; there is no separate `_constraint.lhs_alias` tag. |
+| `analysis.constraints[id].id`                     | `_constraint.id`                   | Yes    | Direct explicit row-key mapping; older CIFs may backfill the id from the expression left-hand side. |
+| `analysis.constraints[id].expression`             | `_constraint.expression`           | Yes    | Direct row-field mapping; `lhs_alias` and `rhs_expr` are derived Python helpers.                  |
 
 ### Experiment Configuration
 
@@ -193,17 +217,17 @@ to objects reached from the current `Project` root, for example
 | `structure.cell.angle_alpha`                      | `_cell.angle_alpha`                                                                                                                                                 | Yes    | Direct category mapping.                                                          |
 | `structure.cell.angle_beta`                       | `_cell.angle_beta`                                                                                                                                                  | Yes    | Direct category mapping.                                                          |
 | `structure.cell.angle_gamma`                      | `_cell.angle_gamma`                                                                                                                                                 | Yes    | Direct category mapping.                                                          |
-| `structure.space_group.name_h_m`                  | `_space_group.name_H-M_alt`, `_space_group_name_H-M_alt`, `_symmetry.space_group_name_H-M`, or `_symmetry_space_group_name_H-M`                                     | Partly | CIF naming follows crystallographic conventions and supports legacy alternatives. |
-| `structure.space_group.it_coordinate_system_code` | `_space_group.IT_coordinate_system_code`, `_space_group_IT_coordinate_system_code`, `_symmetry.IT_coordinate_system_code`, or `_symmetry_IT_coordinate_system_code` | Partly | CIF naming follows crystallographic conventions and supports legacy alternatives. |
+| `structure.space_group.name_h_m`                  | `_space_group.name_H-M_alt`                                                                                                                                         | Partly | Default write uses dictionary-canonical casing; legacy `_space_group_name_H-M_alt` and `_symmetry*` alternatives are accepted on read. |
+| `structure.space_group.it_coordinate_system_code` | `_space_group.IT_coordinate_system_code`                                                                                                                            | Partly | Default write uses dictionary-canonical casing; legacy underscore-form and `_symmetry*` alternatives are accepted on read. |
 | `structure.atom_sites[label].label`               | `_atom_site.label`                                                                                                                                                  | Yes    | Direct row-field mapping.                                                         |
 | `structure.atom_sites[label].type_symbol`         | `_atom_site.type_symbol`                                                                                                                                            | Yes    | Direct row-field mapping.                                                         |
 | `structure.atom_sites[label].fract_x`             | `_atom_site.fract_x`                                                                                                                                                | Yes    | Direct row-field mapping.                                                         |
 | `structure.atom_sites[label].fract_y`             | `_atom_site.fract_y`                                                                                                                                                | Yes    | Direct row-field mapping.                                                         |
 | `structure.atom_sites[label].fract_z`             | `_atom_site.fract_z`                                                                                                                                                | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].wyckoff_letter`      | `_atom_site.Wyckoff_letter` or `_atom_site.Wyckoff_symbol`                                                                                                          | Partly | CIF uses capitalized/legacy Wyckoff tags.                                         |
+| `structure.atom_sites[label].wyckoff_letter`      | `_atom_site.Wyckoff_symbol`                                                                                                                                         | Partly | Default write uses dictionary-canonical tag; legacy `_atom_site.Wyckoff_letter` is accepted on read. |
 | `structure.atom_sites[label].occupancy`           | `_atom_site.occupancy`                                                                                                                                              | Yes    | Direct row-field mapping.                                                         |
 | `structure.atom_sites[label].adp_iso`             | `_atom_site.B_iso_or_equiv` or `_atom_site.U_iso_or_equiv`                                                                                                          | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_sites[label].adp_type`            | `_atom_site.adp_type`                                                                                                                                               | Yes    | Direct row-field mapping.                                                         |
+| `structure.atom_sites[label].adp_type`            | `_atom_site.ADP_type`                                                                                                                                               | Partly | Default write uses dictionary-canonical capitalization; legacy `_atom_site.adp_type` is accepted on read. |
 | `structure.atom_site_aniso[label].label`          | `_atom_site_aniso.label`                                                                                                                                            | Yes    | Direct row-field mapping.                                                         |
 | `structure.atom_site_aniso[label].adp_11`         | `_atom_site_aniso.B_11` or `_atom_site_aniso.U_11`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
 | `structure.atom_site_aniso[label].adp_22`         | `_atom_site_aniso.B_22` or `_atom_site_aniso.U_22`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
@@ -212,58 +236,58 @@ to objects reached from the current `Project` root, for example
 | `structure.atom_site_aniso[label].adp_13`         | `_atom_site_aniso.B_13` or `_atom_site_aniso.U_13`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
 | `structure.atom_site_aniso[label].adp_23`         | `_atom_site_aniso.B_23` or `_atom_site_aniso.U_23`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
 
-### Not Yet Mapped
+### Not Represented In V1
 
-| Current Python path | Current CIF status    | Notes                                        |
-| ------------------- | --------------------- | -------------------------------------------- |
-| `project.summary`   | placeholder text only | `summary_to_cif()` currently returns a stub. |
+| Candidate surface | Current CIF status | Notes |
+| ----------------- | ------------------ | ----- |
+| `project.summary` | removed | Replaced by `project.report`; no `summary.cif` placeholder is written. |
+| `project.publication` | none | Rejected for v1 by the accepted project-summary-rendering ADR. |
+| journal/publication tags | not emitted | `_journal.*`, `_journal_date.*`, `_journal_coeditor.*`, `_publ_contact_author.*`, `_publ_author.*`, `_publ_body.*`, and `_pd_meas.info_author_*` placeholders are deferred and intentionally omitted while empty. |
 
-## Decision To Discuss
+## Decision
 
-Adopt a scoped one-to-one rule for project-level configuration:
+Adopt a scoped one-to-one rule for EasyDiffraction-owned project-level
+singleton configuration:
 
 ```text
 project.<category>.<field> -> project.cif: _<category>.<field>
 ```
 
-This ADR does not propose renaming the public root object. The current
-root object is already `Project`; the proposal is about category and tag
-correspondence inside project-owned singleton configuration.
+The rule applies to:
+
+- `project.rendering_plot.type -> _rendering_plot.type`
+- `project.report.{cif,html,tex,pdf,html_offline} -> _report.*`
+- `project.rendering_table.type -> _rendering_table.type`
+- `project.rendering_structure.type -> _rendering_structure.type`
+- `project.structure_view.* -> _structure_view.*`
+- `project.structure_style.* -> _structure_style.*`
+- `project.verbosity.fit -> _verbosity.fit`
 
-The accepted baseline is:
+Keep `project.info` as the accepted exception:
 
 ```text
-project.info.<field> -> project.cif: _project.<field>
+project.info.name -> _project.id
+project.info.title -> _project.title
+project.info.description -> _project.description
+project.info.created -> _project.created
+project.info.last_modified -> _project.last_modified
 ```
 
-Future one-to-one correspondence work may still discuss whether the
-public identity field should be `name` or `id`, and whether verbosity
-should gain additional coverage-specific fields.
-
-Possible strict-correspondence target if a future ADR explicitly changes
-the accepted `_project.*` baseline:
+The exception is deliberate. `_project.*` is the semantic CIF category
+for scientific project identity in this project file, and `name` remains
+the user-facing Python property. This ADR does not rename `name` to
+`id`, does not rename `_project.*` to `_info.*`, and does not add an
+`_info.*` compatibility layer.
 
-| Python path                    | Target CIF path         | Current state                                    |
-| ------------------------------ | ----------------------- | ------------------------------------------------ |
-| `project.info.name`            | `_info.name`            | Currently `_project.id`.                         |
-| `project.info.title`           | `_info.title`           | Currently `_project.title`.                      |
-| `project.info.description`     | `_info.description`     | Currently `_project.description`.                |
-| `project.info.created`         | `_info.created`         | Currently `_project.created`.                    |
-| `project.info.last_modified`   | `_info.last_modified`   | Currently `_project.last_modified`.              |
-| `project.rendering_plot.type`  | `_rendering_plot.type`  | Already matches.                                 |
-| `project.rendering_table.type` | `_rendering_table.type` | Already matches.                                 |
-| `project.verbosity.fit`        | `_verbosity.fit`        | Implemented direct fit-output verbosity mapping. |
+Do not force strict one-to-one correspondence globally. Analysis,
+experiment, structure, measured-data, calculated-data, and report-export
+categories may keep CIF-domain names where those names are clearer,
+dictionary-aligned, or intentionally different from Python convenience
+names.
 
-Alternative target if the project identity field should be called `id`
-rather than `name`:
-
-```text
-project.info.id -> _info.id
-```
-
-Do not force strict one-to-one correspondence globally where CIF-domain
-names are clearer or where the Python API intentionally abstracts over
-CIF details.
+Do not add a v1 `project.publication` owner or empty publication tags to
+make the correspondence table appear complete. Publication metadata is a
+future feature with its own sourcing and completeness questions.
 
 ## Rationale
 
@@ -273,12 +297,13 @@ Project-level configuration categories are not external crystallographic
 CIF categories. They are EasyDiffraction project-file categories, so the
 repository can optimize them for API/persistence symmetry.
 
-### `project.cif` Scopes Generic Categories
+### `project.cif` Scopes Project-Owned Categories
 
-`_info.title` is generic in isolation, but inside `project.cif` it reads
-as project information. This is similar to `_verbosity.fit`: the file
-scope tells the reader this is project-level verbosity, and the field
-name identifies the fitting-process coverage.
+`_report.cif`, `_structure_view.show_labels`, and `_verbosity.fit` are
+generic in isolation, but inside `project.cif` they read as
+project-level report, structure-view, and verbosity configuration. The
+file scope supplies the project root; the category and field names
+identify the specific setting.
 
 ### The Current `Project` Root Already Matches User Language
 
@@ -295,6 +320,14 @@ say that directly, while `_meta.project_id` and `_meta.project_title`
 make the CIF less domain-oriented and repeat the concept in every item
 name.
 
+### `project.info` Is A Deliberate Exception
+
+`project.info` is the user-facing Python grouping, but `_project.*` is
+the accepted CIF grouping for project identity. Preserving this
+exception avoids a beta-period churn-only rename from `name` to `id` in
+Python and avoids a persistence migration from `_project.*` to
+`_info.*` without a scientific benefit.
+
 ### Scientific CIF/Domain Categories Should Stay Domain-Oriented
 
 For structures, experiments, measured data, and calculated results, many
@@ -313,6 +346,13 @@ switchable-category, backend, and active-sibling selector families.
 These should remain exceptions unless a separate ADR changes the
 underlying API pattern.
 
+### Convenience Aliases Do Not Define Persistence
+
+`project.verbosity = 'short'` remains acceptable as a user-facing
+shortcut because it writes the canonical `project.verbosity.fit` value.
+The persistence contract is still the category/field path, not every
+convenience setter that happens to reach it.
+
 ## Consequences
 
 ### Positive
@@ -321,13 +361,16 @@ underlying API pattern.
 - Users can predict project-level CIF tags from Python paths.
 - The decision can focus on project-owned singleton config without
   forcing scientific CIF categories to mirror Python convenience names.
+- The clean-report decision remains intact: empty journal/publication
+  placeholders stay out of both `project.cif` and generated report CIFs.
 
 ### Trade-Offs
 
-- `_info.*` is less self-describing if copied out of `project.cif`.
-- Existing `_project.*` project files would need migration or a
-  deliberate compatibility decision.
-- Persisted verbosity is now a category object. The initial field is
+- `project.info` does not follow the strict category-name rule; this
+  exception must be explained alongside the other project config.
+- Future publication metadata needs a separate ADR rather than a quiet
+  extension of this correspondence table.
+- Persisted verbosity remains a category object. The initial field is
   `project.verbosity.fit`, leaving room for future coverage-specific
   verbosity fields.
 - Chart and table renderers are separate selector categories
@@ -336,11 +379,4 @@ underlying API pattern.
 
 ## Open Questions
 
-- Should the project identity remain `project.info.name`, or should it
-  become `project.info.id` to mirror the saved identifier field?
-- Should `project.rendering_plot.type` and
-  `project.rendering_table.type` remain separate, or should the public
-  API and CIF collapse to one renderer field?
-- Should `project.verbosity = 'short'` remain as a convenience alias for
-  `project.verbosity.fit = 'short'`, or should strict correspondence
-  remove the alias?
+None for this ADR.
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
new file mode 100644
index 000000000..3a5515100
--- /dev/null
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
@@ -0,0 +1,56 @@
+# Reply 1: Python and CIF Category Correspondence
+
+## P1 - Resolve the `_project.*` versus `_info.*` decision
+
+Verdict: agree.
+
+Action taken: the ADR now explicitly keeps `_project.*` as the accepted
+`project.info` exception and limits the strict
+`project.<category>.<field> -> _<category>.<field>` rule to the other
+EasyDiffraction-owned project-level singleton configuration categories.
+It also states that this ADR does not rename `project.info.name` to
+`id`, does not migrate `_project.*` to `_info.*`, and does not add an
+`_info.*` compatibility layer.
+
+Pointer: `## Decision`, `### project.info Is A Deliberate Exception`,
+and `## Consequences`.
+
+## P1 - Update the project persistence inventory
+
+Verdict: agree.
+
+Action taken: the current persistence layout now removes the obsolete
+`project.publication`, `project.summary`, and `summary.cif` entries;
+adds `project.report`, `project.rendering_structure`,
+`project.structure_view`, and `project.structure_style`; and records
+`project.publication` plus journal/publication tags as intentionally not
+represented in v1.
+
+Pointer: `## Current Persistence Layout`, `### Project-Level
+Configuration`, and `### Not Represented In V1`.
+
+## P2 - Refresh the constraint correspondence rows
+
+Verdict: agree.
+
+Action taken: the analysis table now describes the explicit row-key
+model:
+`analysis.constraints[id].id -> _constraint.id` and
+`analysis.constraints[id].expression -> _constraint.expression`. The row
+notes that older CIFs may backfill ids from the expression left-hand
+side, and that `lhs_alias` / `rhs_expr` are derived Python helpers.
+
+Pointer: `### Analysis Configuration`.
+
+## P2 - Reconcile structure rows with the IUCr alignment decision
+
+Verdict: agree.
+
+Action taken: the structure table now distinguishes canonical write tags
+from read aliases for the affected rows. The default-save rows now use
+`_space_group.name_H-M_alt`,
+`_space_group.IT_coordinate_system_code`,
+`_atom_site.Wyckoff_symbol`, and `_atom_site.ADP_type`, with legacy
+alternatives described as read-side aliases.
+
+Pointer: `### Structure Configuration`.
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
new file mode 100644
index 000000000..04874e2d6
--- /dev/null
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
@@ -0,0 +1,67 @@
+# Review 1: Python and CIF Category Correspondence
+
+## Findings
+
+### P1 - Resolve the `_project.*` versus `_info.*` decision
+
+The decision text says to adopt the strict project-level mapping
+`project.<category>.<field> -> _<category>.<field>` at
+`python-cif-category-correspondence.md:223`, but the next paragraph keeps
+the accepted baseline `project.info.<field> -> _project.<field>` at
+`python-cif-category-correspondence.md:233`. The consequences then still
+discuss `_info.*` migration risk at
+`python-cif-category-correspondence.md:327`. As written, an implementer
+cannot tell whether accepting this ADR should keep `_project.*` or
+supersede it with `_info.*`. Please choose one explicit decision:
+either keep `_project.*` and define strict correspondence as applying
+only to the other project-owned singleton categories, or explicitly
+propose a superseding `_project.*` -> `_info.*` migration with the
+compatibility policy.
+
+### P1 - Update the project persistence inventory
+
+The "Current Persistence Layout" table still lists
+`project.publication` and `project.summary` / `summary.cif` at
+`python-cif-category-correspondence.md:61` and
+`python-cif-category-correspondence.md:66`, and the "Not Yet Mapped"
+section repeats `project.summary` at
+`python-cif-category-correspondence.md:215`. Those are rejected by the
+accepted project-facade/report decisions: report metadata now goes
+through `project.report`, `summary.cif` is not part of the save layout,
+and `project.publication` is deferred from v1. The same inventory also
+omits current persisted project-level structure rendering categories
+such as `project.rendering_structure`, `project.structure_view`, and
+`project.structure_style`. Please refresh the table before this ADR is
+accepted so it does not reintroduce removed surfaces or omit active
+project configuration categories.
+
+### P2 - Refresh the constraint correspondence rows
+
+The analysis table says `analysis.constraints[lhs_alias].expression`
+maps to `_constraint.expression` and notes that the key is derived from
+the expression at `python-cif-category-correspondence.md:105`. That was
+superseded by the accepted loop-key ADR: constraints now have an
+explicit serialized `_constraint.id` key, while `lhs_alias` and
+`rhs_expr` are derived helpers from the expression. Please update this
+section to describe `analysis.constraints[id].id -> _constraint.id` and
+`analysis.constraints[id].expression -> _constraint.expression`, so
+future correspondence work does not preserve the old implicit-key model.
+
+### P2 - Reconcile structure rows with the IUCr alignment decision
+
+The structure table still treats `_atom_site.adp_type` as the direct
+current mapping at `python-cif-category-correspondence.md:206` and lists
+legacy/capitalization alternatives for Wyckoff and space-group tags at
+`python-cif-category-correspondence.md:196` and
+`python-cif-category-correspondence.md:203`. The accepted IUCr alignment
+ADR made the default-save structure tier dictionary-aligned, including
+canonical `_atom_site.ADP_type`, `_atom_site.Wyckoff_symbol`,
+`_space_group.name_H-M_alt`, and
+`_space_group.IT_coordinate_system_code` on write, with legacy aliases
+accepted on read. Please update the current-correspondence rows so this
+ADR remains the Python-side companion to the accepted CIF-side policy.
+
+## Checks
+
+Static ADR review only. Per `/review-adr`, I did not edit the ADR under
+review, run tests, run formatters, run build commands, or invoke `pixi`.
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md
new file mode 100644
index 000000000..813104913
--- /dev/null
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md
@@ -0,0 +1,12 @@
+# Review 2: Python and CIF Category Correspondence
+
+**No findings. Ready to commit.**
+
+Reply 1 addresses the previous findings by making `_project.*` an
+explicit `project.info` exception, refreshing the project persistence
+inventory, updating the constraint key correspondence, and aligning the
+structure rows with the accepted IUCr tag policy.
+
+Per `/review-adr`, this was a static ADR review only. I did not edit the
+ADR under review, run tests, run formatters, run build commands, or
+invoke `pixi`.

From 73cf65fc72dbd9f2caf3bcc38fd61ced4861b542 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Sun, 31 May 2026 23:59:05 +0200
Subject: [PATCH 122/160] Refresh user guide docs for current API

---
 docs/docs/index.md                            |   9 +-
 docs/docs/quick-reference/index.md            |  57 ++---
 .../user-guide/analysis-workflow/analysis.md  | 199 ++++++++++++------
 .../analysis-workflow/experiment.md           |  45 ++--
 .../user-guide/analysis-workflow/index.md     |   4 +-
 .../user-guide/analysis-workflow/model.md     |  40 ++--
 .../user-guide/analysis-workflow/project.md   |  58 ++---
 docs/docs/user-guide/concept.md               |  19 +-
 docs/docs/user-guide/data-format.md           |  16 +-
 docs/docs/user-guide/first-steps.md           |  38 ++--
 docs/docs/user-guide/index.md                 |  22 +-
 docs/docs/user-guide/parameters.md            |  36 ++--
 docs/docs/user-guide/parameters/expt_type.md  |  35 +--
 docs/docs/user-guide/parameters/instrument.md |  98 +++------
 docs/docs/user-guide/parameters/peak.md       |  71 +++++--
 15 files changed, 421 insertions(+), 326 deletions(-)

diff --git a/docs/docs/index.md b/docs/docs/index.md
index cc8b5cb0b..f3f434005 100644
--- a/docs/docs/index.md
+++ b/docs/docs/index.md
@@ -16,9 +16,12 @@ Here is a brief overview of the main documentation sections:
 - [:material-school: Tutorials](tutorials/index.md) – Offers practical,
   step-by-step examples demonstrating common workflows and data analysis
   tasks.
-- [:material-code-braces-box: API Reference](api-reference/index.md) –
-  An auto-generated reference detailing the available functions and
-  modules in EasyDiffraction.
 - [:material-console: Command-Line Interface](cli/index.md) – Describes
   how to use EasyDiffraction from the terminal for batch fitting and
   other tasks.
+- [:material-code-braces-box: API Reference](api-reference/index.md) –
+  An auto-generated reference detailing the available functions and
+  modules in EasyDiffraction.
+- [:material-clipboard-text-outline: Quick Reference](quick-reference/index.md)
+  – Collects the most common commands for project setup, fitting,
+  display, reports, and command-line use.
diff --git a/docs/docs/quick-reference/index.md b/docs/docs/quick-reference/index.md
index de3bb8c81..6fee6b1f5 100644
--- a/docs/docs/quick-reference/index.md
+++ b/docs/docs/quick-reference/index.md
@@ -180,37 +180,42 @@ List supported type choices. The current selection is marked in the
 output:
 
 ```python
-experiment.show_peak_profile_types()
-experiment.show_background_types()
-experiment.calculation.show_calculator_types()
+experiment.peak.show_supported()
+experiment.background.show_supported()
+experiment.calculator.show_supported()
 
-project.analysis.show_fitting_mode_types()
-project.analysis.fitting.show_minimizer_types()
+project.analysis.fitting_mode.show_supported()
+project.analysis.minimizer.show_supported()
 
-project.rendering.show_chart_engines()
-project.rendering.show_table_engines()
-project.rendering.show_config()
+project.rendering_plot.show_supported()
+project.rendering_table.show_supported()
+project.rendering_structure.show_supported()
+project.structure_style.atom_view.show_supported()
+project.structure_style.color_scheme.show_supported()
 ```
 
-Change the active type by assigning the corresponding `*_type` property:
+Change the active type by assigning the category's `type` selector or
+the value selector property:
 
 ```python
-experiment.peak_profile_type = 'pseudo-voigt'
-experiment.background_type = 'line-segment'
-experiment.calculation.calculator_type = 'cryspy'
+experiment.peak.type = 'pseudo-voigt'
+experiment.background.type = 'line-segment'
+experiment.calculator.type = 'cryspy'
 
-project.analysis.fitting_mode_type = 'single'
-project.analysis.fitting.minimizer_type = 'lmfit'
+project.analysis.fitting_mode.type = 'single'
+project.analysis.minimizer.type = 'lmfit'
 
-project.rendering.chart_engine = 'plotly'
-project.rendering.table_engine = 'rich'
+project.rendering_plot.type = 'plotly'
+project.rendering_table.type = 'rich'
+project.rendering_structure.type = 'threejs'
+project.structure_style.atom_view = 'covalent'
 ```
 
 For single-crystal experiments, extinction uses the same pattern:
 
 ```python
-experiment.show_extinction_types()
-experiment.extinction_type = 'becker-coppens'
+experiment.extinction.show_supported()
+experiment.extinction.type = 'becker-coppens'
 ```
 
 ## Find Commands with Help
@@ -291,14 +296,14 @@ experiment.linked_phases['lbco'].scale.free = True
 Choose calculators and minimizers:
 
 ```python
-experiment.calculation.show_calculator_types()
-experiment.calculation.calculator_type = 'cryspy'
+experiment.calculator.show_supported()
+experiment.calculator.type = 'cryspy'
 
-project.analysis.show_fitting_mode_types()
-project.analysis.fitting_mode_type = 'single'
+project.analysis.fitting_mode.show_supported()
+project.analysis.fitting_mode.type = 'single'
 
-project.analysis.fitting.show_minimizer_types()
-project.analysis.fitting.minimizer_type = 'lmfit'
+project.analysis.minimizer.show_supported()
+project.analysis.minimizer.type = 'lmfit'
 ```
 
 Run a fit and inspect the result:
@@ -324,7 +329,7 @@ project.analysis.sequential_fit_extract.create(
   required=True,
 )
 
-project.analysis.fitting_mode_type = 'sequential'
+project.analysis.fitting_mode.type = 'sequential'
 project.analysis.sequential_fit.data_dir = scan_data_dir
 project.analysis.sequential_fit.max_workers = 'auto'
 
@@ -345,7 +350,7 @@ and `apply_params_from_csv()` rather than `display.fit.results()`.
 After a Bayesian fit, inspect posterior displays:
 
 ```python
-project.display.posterior.distribution(param)
+project.display.posterior.distribution(structure.cell.length_a)
 project.display.posterior.distribution()
 project.display.posterior.pairs()
 project.display.posterior.predictive(expt_name='hrpt')
diff --git a/docs/docs/user-guide/analysis-workflow/analysis.md b/docs/docs/user-guide/analysis-workflow/analysis.md
index 08de5c80d..4fce53ef9 100644
--- a/docs/docs/user-guide/analysis-workflow/analysis.md
+++ b/docs/docs/user-guide/analysis-workflow/analysis.md
@@ -63,21 +63,21 @@ The calculator is automatically selected based on the experiment type
 To show the supported calculation engines for a specific experiment:
 
 ```python
-project.experiments['hrpt'].calculation.show_calculator_types()
+project.experiments['hrpt'].calculator.show_supported()
 ```
 
-The example of the output is:
+Example output:
 
-Supported calculator types
+Calculator types
 
-| Calculator | Description                                      |
-| ---------- | ------------------------------------------------ |
-| cryspy     | CrysPy library for crystallographic calculations |
+|   | Type   | Description                                      |
+| - | ------ | ------------------------------------------------ |
+| * | cryspy | CrysPy library for crystallographic calculations |
 
 To explicitly select a calculation engine for an experiment:
 
 ```python
-project.experiments['hrpt'].calculation.calculator_type = 'cryspy'
+project.experiments['hrpt'].calculator.type = 'cryspy'
 ```
 
 ## Minimization / Optimization
@@ -88,10 +88,10 @@ experimental data. This process is illustrated in the following diagram:
 
 ```mermaid
 flowchart LR
-    a(Propose<br/>model)
-    b(Set/change<br/>model<br/>parameter<br/>values)
-    c(Calculate<br/>model<br/>data)
-    d(Compare<br/>model data to<br/>experimental<br/>data)
+    a(Propose<br/>structure)
+    b(Set/change<br/>structure and<br/>experiment<br/>parameters)
+    c(Calculate<br/>pattern)
+    d(Compare<br/>calculated data to<br/>experimental<br/>data)
     e(Stop<br/>iteration)
     a --> b
     b --> c
@@ -122,6 +122,14 @@ in the search space, bumps provides Bayesian uncertainty analysis which
 explores all viable minima and finds confidence intervals on the
 parameters based on uncertainty in the measured values.
 
+### emcee Minimizer
+
+[emcee](https://emcee.readthedocs.io/) is an affine-invariant ensemble
+sampler for Bayesian posterior exploration. It is useful after a stable
+least-squares model has been prepared and the goal is to inspect
+credible intervals, correlations, and posterior-predictive uncertainty
+rather than only one best-fit point.
+
 ### DFO-LS Minimizer
 
 [DFO-LS](https://github.com/numericalalgorithmsgroup/dfols)
@@ -134,24 +142,30 @@ derivatives of the objective.
 To show the supported minimizers:
 
 ```python
-project.analysis.fitting.show_minimizer_types()
+project.analysis.minimizer.show_supported()
 ```
 
-The example of the output is:
-
-Supported minimizers
+Example output:
 
-| Minimizer             | Description                                                              |
-| --------------------- | ------------------------------------------------------------------------ |
-| lmfit                 | LMFIT library using the default Levenberg-Marquardt least squares method |
-| lmfit (leastsq)       | LMFIT library with Levenberg-Marquardt least squares method              |
-| lmfit (least_squares) | LMFIT library with SciPy's trust region reflective algorithm             |
-| dfols                 | DFO-LS library for derivative-free least-squares optimization            |
+Minimizer types
+
+|   | Type                  | Description                                                   |
+| - | --------------------- | ------------------------------------------------------------- |
+|   | lmfit                 | LMFIT library using the default Levenberg-Marquardt method    |
+| * | lmfit (leastsq)       | LMFIT library with Levenberg-Marquardt least squares method   |
+|   | lmfit (least_squares) | LMFIT library with SciPy's trust region reflective algorithm  |
+|   | dfols                 | DFO-LS library for derivative-free least-squares optimization |
+|   | bumps                 | BUMPS library using the default Levenberg-Marquardt method    |
+|   | bumps (lm)            | BUMPS library with Levenberg-Marquardt method                 |
+|   | bumps (dream)         | BUMPS library with DREAM Bayesian sampling                    |
+|   | bumps (amoeba)        | BUMPS library with Nelder-Mead simplex method                 |
+|   | bumps (de)            | BUMPS library with differential evolution method              |
+|   | emcee                 | emcee affine-invariant ensemble Bayesian sampling             |
 
 To select the desired minimizer, e.g., 'lmfit':
 
 ```python
-project.analysis.fitting.minimizer_type = 'lmfit'
+project.analysis.minimizer.type = 'lmfit'
 ```
 
 ### Fit Mode
@@ -163,29 +177,31 @@ across all experiments.
 
 The supported fit modes are:
 
-| Mode   | Description                                                         |
-| ------ | ------------------------------------------------------------------- |
-| single | Independent fitting of each experiment; no shared parameters        |
-| joint  | Simultaneous fitting of all experiments; some parameters are shared |
+| Mode       | Description                                                         |
+| ---------- | ------------------------------------------------------------------- |
+| single     | Independent fitting of each experiment; no shared parameters        |
+| joint      | Simultaneous fitting of all experiments; some parameters are shared |
+| sequential | Repeated single fits over a scan directory                          |
 
 You can set the fit mode on the analysis owner:
 
 ```python
-project.analysis.fitting_mode_type = 'joint'
+project.analysis.fitting_mode.type = 'joint'
 ```
 
 To check the current fit mode:
 
 ```python
-print(project.analysis.fitting_mode_type)
+print(project.analysis.fitting_mode.type)
 ```
 
 ### Perform Fit
 
 Refining the structure and experiment parameters against measured data
 is usually divided into several steps, where each step involves adding
-or removing parameters to be refined, calculating the model data, and
-comparing it to the experimental data as shown in the diagram above.
+or removing parameters to be refined, calculating the diffraction
+pattern, and comparing it to the experimental data as shown in the
+diagram above.
 
 To select the parameters to be refined, you can set the attribute `free`
 of the parameters to `True`. This indicates that the parameter is free
@@ -218,29 +234,30 @@ experimental data.
 An example of the output after performing the fit is:
 
 ```console
-Using experiment 🔬 'hrpt' for 'single' fitting
-🚀 Starting fitting process with 'lmfit (leastsq)'...
-📈 Goodness-of-fit (reduced χ²) change:
-╒═════════════════╤═════════════════╤═════════════════╕
-│    iteration    │        χ²       │ improvement [%] │
-╞═════════════════╪═════════════════╪═════════════════╡
-│        1        │      164.59     │                 │
-│        12       │      33.43      │     79.7% ↓     │
-│        21       │      13.22      │     60.4% ↓     │
-│        30       │       5.78      │     56.3% ↓     │
-│        39       │       3.15      │     45.6% ↓     │
-│        77       │       3.14      │                 │
-╘═════════════════╧═════════════════╧═════════════════╛
-🏆 Best goodness-of-fit (reduced χ²) is 3.14 at iteration 73
+🚀 Starting fit process with 'lmfit (leastsq)'...
+📈 Goodness-of-fit progress:
+╒═══════════╤══════════╤═══════╤═════════════════╕
+│ iteration │ time (s) │  χ²   │ change / status │
+╞═══════════╪══════════╪═══════╪═════════════════╡
+│     1     │   0.10   │ 164.6 │ initial         │
+│    12     │   0.24   │ 33.4  │ 79.7 % ↓        │
+│    21     │   0.38   │ 13.2  │ 60.4 % ↓        │
+│    30     │   0.52   │  5.8  │ 56.3 % ↓        │
+│    77     │   0.77   │  3.1  │ converged       │
+╘═══════════╧══════════╧═══════╧═════════════════╛
+🏆 Best goodness-of-fit (reduced χ²) is 3.14 at iteration 77
 ✅ Fitting complete.
-Fit results
-✅ Success: True
-⏱️ Fitting time: 0.77 seconds
-📏 Goodness-of-fit (reduced χ²): 3.14
-📏 R-factor (Rf): 8.42%
-📏 R-factor squared (Rf²): 11.79%
-📏 Weighted R-factor (wR): 11.62%
-📈 Fitted parameters:
+📋 Least-squares fit results:
+╒═════════════════════════════════╤════════════════╕
+│ 🧪 Minimizer                    │ lmfit (leastsq)│
+│ ✅ Overall status               │ success        │
+│ ⏱️ Fitting time (seconds)       │ 0.77           │
+│ 🔁 Iterations                   │ 77             │
+│ 📏 Goodness-of-fit (reduced χ²) │ 3.14           │
+│ 📏 R-factor (Rf, %)             │ 8.42           │
+│ 📏 Weighted R-factor (wR, %)    │ 11.62          │
+╘═════════════════════════════════╧════════════════╛
+📈 Refined parameters:
 ```
 
 Now, you can inspect the fitted parameters to see how they have changed
@@ -254,17 +271,56 @@ To plot the measured and calculated data after the fit, you can use the
 project.display.pattern(expt_name='hrpt')
 ```
 
+## Bayesian Analysis
+
+Bayesian minimizers sample a posterior distribution rather than only
+optimizing to a single minimum. They are useful after a conventional
+least-squares fit has produced a stable model and you want credible
+intervals, parameter correlations, and posterior-predictive uncertainty.
+
+Two minimizer types currently use Bayesian sampling:
+
+- `bumps (dream)` uses the DREAM sampler through Bumps.
+- `emcee` uses the affine-invariant ensemble sampler and can resume from
+  a saved project.
+
+Select a Bayesian minimizer through the same category-owned selector:
+
+```python
+project.analysis.minimizer.type = 'emcee'
+project.save_as(dir_path='lbco_hrpt')  # required before an emcee fit
+project.analysis.fit()
+```
+
+For a saved `emcee` project, resume the chain with extra steps:
+
+```python
+project.analysis.fit(resume=True, extra_steps=500)
+```
+
+After a Bayesian fit, inspect posterior summaries and plots:
+
+```python
+project.display.posterior.distribution()
+project.display.posterior.pairs()
+project.display.posterior.predictive(expt_name='hrpt')
+```
+
+When posterior or posterior-predictive arrays are persisted, they are
+stored in `analysis/results.h5`. Scalar summaries remain in
+`analysis/analysis.cif`.
+
 ## Constraints
 
-In EasyDiffraction, you can define **constraints** on the model
-parameters to ensure that they remain within a specific range or follow
-a certain relationship during the refinement process.
+In EasyDiffraction, you can define **constraints** on the structure or
+experiment parameters to ensure that they remain within a specific range
+or follow a certain relationship during the refinement process.
 
 ### Setting Aliases
 
 Before setting constraints, you need to set aliases for the parameters
-you want to constrain. This can be done using the `add` method of the
-`aliases` object. Aliases are used to reference parameters in a more
+you want to constrain. This can be done using the `create` method of
+the `aliases` object. Aliases are used to reference parameters in a more
 readable way, making it easier to manage constraints.
 
 An example of setting aliases for parameters in a structure:
@@ -273,21 +329,21 @@ An example of setting aliases for parameters in a structure:
 # Set aliases for the atomic displacement parameters
 project.analysis.aliases.create(
     label='biso_La',
-    param_uid=project.structures['lbco'].atom_sites['La'].adp_iso.uid,
+    param=project.structures['lbco'].atom_sites['La'].adp_iso,
 )
 project.analysis.aliases.create(
     label='biso_Ba',
-    param_uid=project.structures['lbco'].atom_sites['Ba'].adp_iso.uid,
+    param=project.structures['lbco'].atom_sites['Ba'].adp_iso,
 )
 
 # Set aliases for the occupancies of the atom sites
 project.analysis.aliases.create(
     label='occ_La',
-    param_uid=project.structures['lbco'].atom_sites['La'].occupancy.uid,
+    param=project.structures['lbco'].atom_sites['La'].occupancy,
 )
 project.analysis.aliases.create(
     label='occ_Ba',
-    param_uid=project.structures['lbco'].atom_sites['Ba'].occupancy.uid,
+    param=project.structures['lbco'].atom_sites['Ba'].occupancy,
 )
 ```
 
@@ -326,10 +382,12 @@ The example of the output is:
 
 User defined constraints
 
-| expression          |
-| ------------------- |
-| biso_Ba = biso_La   |
-| occ_Ba = 1 - occ_La |
+| id      | expression          |
+| ------- | ------------------- |
+| biso_Ba | biso_Ba = biso_La   |
+| occ_Ba  | occ_Ba = 1 - occ_La |
+
+Constraints enabled: True
 
 ## Analysis as CIF
 
@@ -344,21 +402,22 @@ Example output:
 
 ```
 ╒════════════════════════════════════════════════╕
-│ _fitting.minimizer_type      "lmfit (leastsq)" │
-│ _fitting.mode_type           single            │
+│ _fitting_mode.type           single            │
+│ _minimizer.type              "lmfit (leastsq)" │
 │                                                │
 │ loop_                                          │
 │ _alias.label                                   │
-│ _alias.param_uid                               │
+│ _alias.param_unique_name                       │
 │ biso_La  lbco.atom_site.La.B_iso_or_equiv      │
 │ biso_Ba  lbco.atom_site.Ba.B_iso_or_equiv      │
 │ occ_La   lbco.atom_site.La.occupancy           │
 │ occ_Ba   lbco.atom_site.Ba.occupancy           │
 │                                                │
 │ loop_                                          │
+│ _constraint.id                                 │
 │ _constraint.expression                         │
-│ "biso_Ba = biso_La"                            │
-│ "occ_Ba = 1 - occ_La"                         │
+│ biso_Ba  "biso_Ba = biso_La"                   │
+│ occ_Ba   "occ_Ba = 1 - occ_La"                 │
 ╘════════════════════════════════════════════════╛
 ```
 
diff --git a/docs/docs/user-guide/analysis-workflow/experiment.md b/docs/docs/user-guide/analysis-workflow/experiment.md
index c121d6a9c..043d4c58e 100644
--- a/docs/docs/user-guide/analysis-workflow/experiment.md
+++ b/docs/docs/user-guide/analysis-workflow/experiment.md
@@ -74,7 +74,7 @@ data_<span class="red"><b>hrpt</b></span>
 you can access it in the code as follows:
 
 ```python
-# Access the experient by its name
+# Access the experiment by its name
 project.experiments['hrpt']
 ```
 
@@ -203,7 +203,7 @@ project.experiments['hrpt'].excluded_regions.create(start=160, end=180)
 
 ```python
 # Select the desired peak profile type
-project.experiments['hrpt'].peak_profile_type = 'pseudo-voigt'
+project.experiments['hrpt'].peak.type = 'pseudo-voigt'
 
 # Modify default peak profile parameters
 project.experiments['hrpt'].peak.broad_gauss_u = 0.1
@@ -217,7 +217,7 @@ project.experiments['hrpt'].peak.broad_lorentz_y = 0.1
 
 ```python
 # Select the desired background type
-project.experiments['hrpt'].background_type = 'line-segment'
+project.experiments['hrpt'].background.type = 'line-segment'
 
 # Add background points
 project.experiments['hrpt'].background.create(x=10, y=170)
@@ -489,19 +489,19 @@ data_<span class="red"><b>wish</b></span>
 
 <span class="blue"><b>_diffrn_radiation</b>.probe</span> neutron
 
-<span class="blue"><b>_pd_instr</b>.2theta_bank</span> 152.827
+<span class="blue"><b>_instr</b>.2theta_bank</span> 152.827
 
-<span class="blue"><b>_pd_instr</b>.dtt1</span> 20773.1(3)
-<span class="blue"><b>_pd_instr</b>.dtt2</span>    -1.08308
-<span class="blue"><b>_pd_instr</b>.zero</span>   -13.7(5)
+<span class="blue"><b>_instr</b>.d_to_tof_linear</span> 20773.1(3)
+<span class="blue"><b>_instr</b>.d_to_tof_quad</span>    -1.08308
+<span class="blue"><b>_instr</b>.d_to_tof_offset</span>   -13.7(5)
 
-<span class="blue"><b>_pd_instr</b>.alpha0</span> -0.009(1)
-<span class="blue"><b>_pd_instr</b>.alpha1</span>  0.109(2)
-<span class="blue"><b>_pd_instr</b>.beta0</span>   0.00670(3)
-<span class="blue"><b>_pd_instr</b>.beta1</span>   0.0100(3)
-<span class="blue"><b>_pd_instr</b>.sigma0</span>  0
-<span class="blue"><b>_pd_instr</b>.sigma1</span>  0
-<span class="blue"><b>_pd_instr</b>.sigma2</span> 15.7(8)
+<span class="blue"><b>_peak</b>.rise_alpha_0</span> -0.009(1)
+<span class="blue"><b>_peak</b>.rise_alpha_1</span>  0.109(2)
+<span class="blue"><b>_peak</b>.decay_beta_0</span>  0.00670(3)
+<span class="blue"><b>_peak</b>.decay_beta_1</span>  0.0100(3)
+<span class="blue"><b>_peak</b>.gauss_sigma_0</span> 0
+<span class="blue"><b>_peak</b>.gauss_sigma_1</span> 0
+<span class="blue"><b>_peak</b>.gauss_sigma_2</span> 15.7(8)
 
 loop_
 <span class="green"><b>_pd_phase_block</b>.id</span>
@@ -558,21 +558,8 @@ This example represents a single-crystal neutron diffraction experiment:
 <pre>
 data_<span class="red"><b>heidi</b></span>
 
-<span class="blue"><b>_diffrn_radiation</b>.probe</span>                 neutron
-<span class="blue"><b>_diffrn_radiation_wavelength</b>.wavelength</span> 0.793
-
-<span class="blue"><b>_pd_calib</b>.2theta_offset</span> 0.6225(4)
-
-<span class="blue"><b>_pd_instr</b>.resolution_u</span>  0.0834
-<span class="blue"><b>_pd_instr</b>.resolution_v</span> -0.1168
-<span class="blue"><b>_pd_instr</b>.resolution_w</span>  0.123
-<span class="blue"><b>_pd_instr</b>.resolution_x</span>  0
-<span class="blue"><b>_pd_instr</b>.resolution_y</span>  0.0797
-
-<span class="blue"><b>_pd_instr</b>.reflex_asymmetry_p1</span> 0
-<span class="blue"><b>_pd_instr</b>.reflex_asymmetry_p2</span> 0
-<span class="blue"><b>_pd_instr</b>.reflex_asymmetry_p3</span> 0
-<span class="blue"><b>_pd_instr</b>.reflex_asymmetry_p4</span> 0
+<span class="blue"><b>_diffrn_radiation</b>.probe</span> neutron
+<span class="blue"><b>_instr</b>.wavelength</span>       0.793
 
 loop_
 <span class="green"><b>_exptl_crystal</b>.id</span>
diff --git a/docs/docs/user-guide/analysis-workflow/index.md b/docs/docs/user-guide/analysis-workflow/index.md
index 79b80497b..aa23ca8f7 100644
--- a/docs/docs/user-guide/analysis-workflow/index.md
+++ b/docs/docs/user-guide/analysis-workflow/index.md
@@ -6,7 +6,7 @@ structured workflow divided into **five key steps**:
 ```mermaid
 flowchart LR
     a(Project)
-    b(Model)
+    b(Structure)
     c(Experiment)
     d(Analysis)
     e(Report)
@@ -20,7 +20,7 @@ flowchart LR
   a container for structure and experiment parameters, measured and
   calculated data, analysis settings and results.
 - [:material-puzzle: Structure](model.md) – Load an existing
-  **crystallographic model** in CIF format or define a new one from
+  **crystallographic structure** in CIF format or define a new one from
   scratch.
 - [:material-microscope: Experiment](experiment.md) – Import
   **experimental diffraction data** and configure **instrumental** and
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index 3cbdb6026..a8670f017 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -11,30 +11,30 @@ parameters.
 
 EasyDiffraction allows you to:
 
-- **Load an existing model** from a file (**CIF** format).
+- **Load an existing structure** from a file (**CIF** format).
 - **Manually define** a new structure by specifying crystallographic
   parameters.
 
 Below, you will find instructions on how to define and manage
-crystallographic models in EasyDiffraction. It is assumed that you have
+crystallographic structures in EasyDiffraction. It is assumed that you have
 already created a `project` object, as described in the
 [Project](project.md) section.
 
-## Adding a Model from CIF
+## Adding a Structure from CIF
 
 This is the most straightforward way to define a structure in
 EasyDiffraction. If you have a crystallographic information file (CIF)
 for your structure, you can add it to your project using the
 `add_from_cif_path` method of the `project.structures` collection. In
-this case, the name of the model will be taken from CIF.
+this case, the structure name will be taken from CIF.
 
 ```python
 # Load a phase from a CIF file
 project.structures.add_from_cif_path('data/lbco.cif')
 ```
 
-Accessing the model after loading it will be done through the
-`structures` collection of the `project` instance. The name of the model
+Accessing the structure after loading it will be done through the
+`structures` collection of the `project` instance. The structure name
 will be the same as the data block id in the CIF file. For example, if
 the CIF file contains a data block with the id `lbco`,
 
@@ -58,12 +58,12 @@ you can access it in the code as follows:
 project.structures['lbco']
 ```
 
-## Defining a Model Manually
+## Defining a Structure Manually
 
-If you do not have a CIF file or prefer to define the model manually,
+If you do not have a CIF file or prefer to define the structure manually,
 you can use the `create` method of the `structures` object of the
 `project` instance. In this case, you will need to specify the name of
-the model, which will be used to reference it later.
+the structure, which will be used to reference it later.
 
 ```python
 # Add a structure with default parameters
@@ -71,10 +71,10 @@ the model, which will be used to reference it later.
 project.structures.create(name='nacl')
 ```
 
-The `add` method creates a new structure with default parameters. You
+The `create` method creates a new structure with default parameters. You
 can then modify its parameters to match your specific crystallographic
 structure. All parameters are grouped into the following categories,
-which makes it easier to manage the model:
+which makes it easier to manage the structure:
 
 1. **Space Group Category**: Defines the symmetry of the crystal
    structure.
@@ -121,7 +121,7 @@ project.structures['nacl'].atom_sites.create(
 )
 ```
 
-## Listing Defined Models
+## Listing Defined Structures
 
 To check which structures have been added to the `project`, use:
 
@@ -137,7 +137,7 @@ Defined structures 🧩
 ['lbco', 'nacl']
 ```
 
-## Viewing a Model as CIF
+## Viewing a Structure as CIF
 
 To inspect a structure in CIF format, use:
 
@@ -172,7 +172,7 @@ Structure 🧩 'lbco' as cif
 │ _atom_site.label                          │
 │ _atom_site.occupancy                      │
 │ _atom_site.type_symbol                    │
-│ _atom_site.Wyckoff_letter                 │
+│ _atom_site.Wyckoff_symbol                 │
 │ Biso 0.5 0.0 0.0 0.0 La 0.5 La a          │
 │ Biso 0.5 0.0 0.0 0.0 Ba 0.5 Ba a          │
 │ Biso 0.5 0.5 0.5 0.5 Co 1.0 Co b          │
@@ -180,7 +180,7 @@ Structure 🧩 'lbco' as cif
 ╘═══════════════════════════════════════════╛
 ```
 
-## Viewing a Model in 3D
+## Viewing a Structure in 3D
 
 EasyDiffraction can render a defined structure as an interactive 3D
 view. The renderer engine is chosen through
@@ -247,14 +247,14 @@ interactive Three.js view in the HTML report and a static,
 depth-rendered image in the TeX/PDF report (see the [Report](report.md)
 section).
 
-## Saving a Model
+## Saving a Structure
 
 Saving the project, as described in the [Project](project.md) section,
-will also save the model. Each model is saved as a separate CIF file in
+will also save the structure. Each structure is saved as a separate CIF file in
 the `structures` subdirectory of the project directory. The project file
 contains references to these files.
 
-Below is an example of the saved CIF file for the `lbco` model:
+Below is an example of the saved CIF file for the `lbco` structure:
 
 <!-- prettier-ignore-start -->
 
@@ -278,9 +278,9 @@ loop_
 <span class="green"><b>_atom_site</b>.fract_x</span>
 <span class="green"><b>_atom_site</b>.fract_y</span>
 <span class="green"><b>_atom_site</b>.fract_z</span>
-<span class="green"><b>_atom_site</b>.Wyckoff_letter</span>
+<span class="green"><b>_atom_site</b>.Wyckoff_symbol</span>
 <span class="green"><b>_atom_site</b>.occupancy</span>
-<span class="green"><b>_atom_site</b>.adp_type</span>
+<span class="green"><b>_atom_site</b>.ADP_type</span>
 <span class="green"><b>_atom_site</b>.B_iso_or_equiv</span>
 La La   0   0   0     a   0.5  Biso 0.4958
 Ba Ba   0   0   0     a   0.5  Biso 0.4943
diff --git a/docs/docs/user-guide/analysis-workflow/project.md b/docs/docs/user-guide/analysis-workflow/project.md
index 45f227d41..e9f133d3e 100644
--- a/docs/docs/user-guide/analysis-workflow/project.md
+++ b/docs/docs/user-guide/analysis-workflow/project.md
@@ -75,20 +75,20 @@ The example below illustrates a typical **project structure** for a
 
 <div class="cif">
 <pre>
-📁 <span class="red"><b>La0.5Ba0.5CoO3</b></span>     - Project directory.
-├── 📄 <span class="orange"><b>project.cif</b></span>    - Main project description file.
-├── 📁 structures  - Folder with structures (crystallographic structures).
-│   ├── 📄 <span class="orange"><b>lbco.cif</b></span>   - File with La0.5Ba0.5CoO3 structure parameters.
+📁 <span class="red"><b>La0.5Ba0.5CoO3</b></span>     - project root
+├── 📄 <span class="orange"><b>project.cif</b></span>    - project configuration
+├── 📁 structures  - structures
+│   ├── 📄 <span class="orange"><b>lbco.cif</b></span>   - LBCO
 │   └── ...
-├── 📁 experiments    - Folder with experiment settings and measured data.
-│   ├── 📄 <span class="orange"><b>hrpt.cif</b></span>   - Instrumental parameters, calculator selection and measured data from HRPT@PSI.
+├── 📁 experiments - experiments
+│   ├── 📄 <span class="orange"><b>hrpt.cif</b></span>   - HRPT pattern
 │   └── ...
-├── 📁 analysis       - Analysis settings and optional persisted Bayesian arrays.
-│   ├── 📄 <span class="orange"><b>analysis.cif</b></span> - Settings for data analysis (minimizer, fit mode, constraints, persisted fit state).
-│   └── 📄 <span class="orange"><b>results.h5</b></span>   - Optional Bayesian sidecar with posterior and predictive arrays.
-└── 📁 reports      - Optional reports written from project.report config.
-    ├── 📄 <span class="orange"><b>La0.5Ba0.5CoO3.cif</b></span>  - IUCr submission report.
-    └── 📄 <span class="orange"><b>La0.5Ba0.5CoO3.html</b></span> - HTML report.
+├── 📁 analysis    - analysis
+│   ├── 📄 <span class="orange"><b>analysis.cif</b></span> - fit state
+│   └── 📄 <span class="orange"><b>results.h5</b></span>   - Bayesian arrays
+└── 📁 reports     - reports
+    ├── 📄 <span class="orange"><b>La0.5Ba0.5CoO3.cif</b></span>  - IUCr
+    └── 📄 <span class="orange"><b>La0.5Ba0.5CoO3.html</b></span> - HTML
 </pre>
 </div>
 
@@ -96,8 +96,8 @@ The example below illustrates a typical **project structure** for a
 
 ## Project Files
 
-Below is a complete project example stored in the `La0.5Ba0.5CoO3`
-directory, showing the contents of all files in the project.
+Below is a representative project example stored in the `La0.5Ba0.5CoO3`
+directory, showing the main files created by a typical workflow.
 
 !!! warning "Important"
 
@@ -123,8 +123,17 @@ This file stores project-level metadata and display configuration.
 <span class="blue"><b>_project</b>.created</span>     "18 May 2026 10:15:00"
 <span class="blue"><b>_project</b>.last_modified</span> "18 May 2026 10:20:00"
 
-<span class="blue"><b>_rendering</b>.chart_engine</span> auto
-<span class="blue"><b>_rendering</b>.table_engine</span> auto
+<span class="blue"><b>_rendering_plot</b>.type</span>      auto
+<span class="blue"><b>_report</b>.cif</span>               false
+<span class="blue"><b>_report</b>.html</span>              true
+<span class="blue"><b>_report</b>.tex</span>               false
+<span class="blue"><b>_report</b>.pdf</span>               false
+<span class="blue"><b>_report</b>.html_offline</span>      false
+<span class="blue"><b>_rendering_table</b>.type</span>     auto
+<span class="blue"><b>_rendering_structure</b>.type</span> auto
+<span class="blue"><b>_structure_view</b>.show_labels</span> false
+<span class="blue"><b>_structure_style</b>.atom_view</span> covalent
+<span class="blue"><b>_structure_style</b>.color_scheme</span> jmol
 <span class="blue"><b>_verbosity</b>.fit</span>         full
 </pre>
 </div>
@@ -159,9 +168,9 @@ loop_
 <span class="green"><b>_atom_site</b>.fract_x</span>
 <span class="green"><b>_atom_site</b>.fract_y</span>
 <span class="green"><b>_atom_site</b>.fract_z</span>
-<span class="green"><b>_atom_site</b>.Wyckoff_letter</span>
+<span class="green"><b>_atom_site</b>.Wyckoff_symbol</span>
 <span class="green"><b>_atom_site</b>.occupancy</span>
-<span class="green"><b>_atom_site</b>.adp_type</span>
+<span class="green"><b>_atom_site</b>.ADP_type</span>
 <span class="green"><b>_atom_site</b>.B_iso_or_equiv</span>
 La La   0   0   0     a   0.5  Biso 0.4958
 Ba Ba   0   0   0     a   0.5  Biso 0.4943
@@ -189,7 +198,7 @@ data_<span class="red"><b>hrpt</b></span>
 <span class="blue"><b>_expt_type</b>.sample_form</span>      powder
 <span class="blue"><b>_expt_type</b>.scattering_type</span>  bragg
 
-<span class="blue"><b>_calculation</b>.calculator_type</span> cryspy
+<span class="blue"><b>_calculator</b>.type</span> cryspy
 
 <span class="blue"><b>_instr</b>.wavelength</span>    1.494
 <span class="blue"><b>_instr</b>.2theta_offset</span> 0.6225(4)
@@ -252,21 +261,22 @@ of **calculation** and **fitting** engines, as well as user defined
 
 <div class="cif">
 <pre>
-<span class="blue"><b>_fitting</b>.mode_type</span>              single
-<span class="blue"><b>_fitting</b>.minimizer_type</span>         lmfit
+<span class="blue"><b>_fitting_mode</b>.type</span>              single
+<span class="blue"><b>_minimizer</b>.type</span>                 lmfit
 
 loop_
 <span class="green"><b>_alias</b>.label</span>
-<span class="green"><b>_alias</b>.param_uid</span>
+<span class="green"><b>_alias</b>.param_unique_name</span>
 biso_La  lbco.atom_site.La.B_iso_or_equiv
 biso_Ba  lbco.atom_site.Ba.B_iso_or_equiv
 occ_La   lbco.atom_site.La.occupancy
 occ_Ba   lbco.atom_site.Ba.occupancy
 
 loop_
+<span class="green"><b>_constraint</b>.id</span>
 <span class="green"><b>_constraint</b>.expression</span>
-"biso_Ba = biso_La"
-"occ_Ba = 1 - occ_La"
+biso_Ba  "biso_Ba = biso_La"
+occ_Ba   "occ_Ba = 1 - occ_La"
 </pre>
 </div>
 
diff --git a/docs/docs/user-guide/concept.md b/docs/docs/user-guide/concept.md
index 29768ebab..dbdee2f2c 100644
--- a/docs/docs/user-guide/concept.md
+++ b/docs/docs/user-guide/concept.md
@@ -6,7 +6,7 @@ main steps:
 
 ```mermaid
 flowchart LR
-    a(Data Aquisition)
+    a(Data Acquisition)
     b(Data Reduction)
     c(Data Analysis)
     a --> b
@@ -85,6 +85,23 @@ sample by minimizing the difference (or **residual**) between the
 experimental and calculated data — and this is exactly where
 EasyDiffraction comes into play.
 
+## Least-Squares and Bayesian Analysis
+
+Most refinements use least-squares minimization: EasyDiffraction varies
+the selected free parameters and reports the best-fit values, standard
+uncertainties, R-factors, and goodness-of-fit metrics. This is the usual
+workflow for routine model refinement and is available through
+minimizers such as `lmfit`, `dfols`, and several `bumps` optimizers.
+
+Bayesian analysis answers a different question. Instead of reporting
+only one best-fit point and a covariance estimate, a Bayesian sampler
+explores the posterior distribution of the free parameters. This gives
+credible intervals, correlations, posterior-predictive patterns, and
+diagnostics such as r-hat and effective sample size. EasyDiffraction
+currently exposes Bayesian workflows through `bumps (dream)` and
+`emcee`; their posterior and predictive arrays are stored in
+`analysis/results.h5` when available.
+
 <!-- prettier-ignore-start -->
 ![](../assets/images/user-guide/data-analysis_refinement.png){ width="450", loading=lazy }
 /// caption
diff --git a/docs/docs/user-guide/data-format.md b/docs/docs/user-guide/data-format.md
index da7c92b16..d81346f1c 100644
--- a/docs/docs/user-guide/data-format.md
+++ b/docs/docs/user-guide/data-format.md
@@ -19,10 +19,11 @@ crystallography. The **pdCIF** dictionary covers parameters specific to
 powder diffraction, **magCIF** is used for magnetic structure analysis.
 
 As most parameters needed for diffraction data analysis are already
-covered by IUCr dictionaries, EasyDiffraction uses the strict **CIF
-format** and follows these dictionaries as closely as possible — for
-both input and output — throughout the workflow described in the
-[Analysis Workflow](analysis-workflow/index.md) section.
+covered by IUCr dictionaries, EasyDiffraction uses **CIF** as its
+project persistence format and follows these dictionaries where they fit
+the day-to-day project files. Some EasyDiffraction-owned settings, such
+as minimizer choices and report configuration, use project-specific CIF
+categories.
 
 The key advantage of CIF is the standardized naming of parameters and
 categories, which promotes interoperability and familiarity among
@@ -91,9 +92,9 @@ loop_
 <span class="green"><b>_atom_site</b>.fract_x</span>
 <span class="green"><b>_atom_site</b>.fract_y</span>
 <span class="green"><b>_atom_site</b>.fract_z</span>
-<span class="green"><b>_atom_site</b>.Wyckoff_letter</span>
+<span class="green"><b>_atom_site</b>.Wyckoff_symbol</span>
 <span class="green"><b>_atom_site</b>.occupancy</span>
-<span class="green"><b>_atom_site</b>.adp_type</span>
+<span class="green"><b>_atom_site</b>.ADP_type</span>
 <span class="green"><b>_atom_site</b>.B_iso_or_equiv</span>
 La La   0   0   0     a   0.5  Biso 0.4958
 Ba Ba   0   0   0     a   0.5  Biso 0.4958
@@ -211,7 +212,8 @@ in the following blocks:
 - **structure**: defines the structure
 - **experiment**: contains the experiment setup and measured data
 - **analysis**: stores fitting and analysis parameters
-- **summary**: captures analysis results
+- **reports**: stores generated HTML, CIF, TeX, and PDF reports when
+  enabled through `project.report`
 
 Example CIF files for each block are provided in the
 [Analysis Workflow](analysis-workflow/index.md) and
diff --git a/docs/docs/user-guide/first-steps.md b/docs/docs/user-guide/first-steps.md
index a41bcee68..81e901c70 100644
--- a/docs/docs/user-guide/first-steps.md
+++ b/docs/docs/user-guide/first-steps.md
@@ -95,11 +95,11 @@ different categories.
 ### Supported calculators
 
 The calculator is automatically selected based on the experiment type.
-You can use the experiment `calculation` category to see which
-calculation engines are compatible:
+Use the experiment `calculator` category to see which calculation
+engines are compatible:
 
 ```python
-project.experiments['hrpt'].calculation.show_calculator_types()
+project.experiments['hrpt'].calculator.show_supported()
 ```
 
 This will display a list of supported calculators along with their
@@ -113,11 +113,11 @@ An example of the output for a Bragg diffraction experiment:
 
 ### Supported minimizers
 
-You can also check the available minimizers using the
-`show_minimizer_types()` method:
+You can also check the available minimizers from the active minimizer
+category:
 
 ```python
-project.analysis.fitting.show_minimizer_types()
+project.analysis.minimizer.show_supported()
 ```
 
 ### Available parameters
@@ -142,24 +142,24 @@ with parameters in their projects.
 An example of the output for the `project.display.parameters.access()`
 method is:
 
-|     | Code variable                                       | Unique ID for CIF          |
-| --- | --------------------------------------------------- | -------------------------- |
-| 1   | project.structures['lbco'].atom_site['La'].adp_type | lbco.atom_site.La.ADP_type |
-| 2   | project.structures['lbco'].atom_site['La'].adp_iso  | lbco.atom_site.La.adp_iso  |
-| 3   | project.structures['lbco'].atom_site['La'].fract_x  | lbco.atom_site.La.fract_x  |
-| 4   | project.structures['lbco'].atom_site['La'].fract_y  | lbco.atom_site.La.fract_y  |
-| ... | ...                                                 | ...                        |
-| 59  | project.experiments['hrpt'].peak.broad_gauss_u      | hrpt.peak.broad_gauss_u    |
-| 60  | project.experiments['hrpt'].peak.broad_gauss_v      | hrpt.peak.broad_gauss_v    |
-| 61  | project.experiments['hrpt'].peak.broad_gauss_w      | hrpt.peak.broad_gauss_w    |
+|     | Code variable                                        | Unique ID for CIF          |
+| --- | ---------------------------------------------------- | -------------------------- |
+| 1   | project.structures['lbco'].atom_sites['La'].adp_type | lbco.atom_site.La.ADP_type |
+| 2   | project.structures['lbco'].atom_sites['La'].adp_iso  | lbco.atom_site.La.adp_iso  |
+| 3   | project.structures['lbco'].atom_sites['La'].fract_x  | lbco.atom_site.La.fract_x  |
+| 4   | project.structures['lbco'].atom_sites['La'].fract_y  | lbco.atom_site.La.fract_y  |
+| ... | ...                                                  | ...                        |
+| 59  | project.experiments['hrpt'].peak.broad_gauss_u       | hrpt.peak.broad_gauss_u    |
+| 60  | project.experiments['hrpt'].peak.broad_gauss_v       | hrpt.peak.broad_gauss_v    |
+| 61  | project.experiments['hrpt'].peak.broad_gauss_w       | hrpt.peak.broad_gauss_w    |
 
 ### Supported plotters
 
-To see the available plotters, you can use the `display` category on the
-`Project` instance:
+To see the available plotters, use the project rendering categories:
 
 ```python
-project.rendering.show_chart_engines()
+project.rendering_plot.show_supported()
+project.rendering_table.show_supported()
 ```
 
 An example of the output is:
diff --git a/docs/docs/user-guide/index.md b/docs/docs/user-guide/index.md
index 72978518b..012a8e3f3 100644
--- a/docs/docs/user-guide/index.md
+++ b/docs/docs/user-guide/index.md
@@ -10,15 +10,15 @@ effectively.
 
 Here is a brief overview of the User Guide sections:
 
-- [Glossary](#) – Defines common terms and labels used throughout the
-  documentation.
-- [Concept](#) – Introduces the overall idea behind data analysis in
+- [Glossary](glossary.md) – Defines common terms and labels used
+  throughout the documentation.
+- [Concept](concept.md) – Introduces the overall idea behind data analysis in
   EasyDiffraction.
-- [Data Format](#) – Explains the data structures and file formats used
-  by EasyDiffraction.
-- [Parameters](#) – Describes how parameters are structured, named, and
-  accessed within the EasyDiffraction.
-- [First Steps](#) – Shows how to begin using EasyDiffraction in Python
-  or Jupyter notebooks.
-- [Analysis Workflow](#) – Breaks down the data analysis pipeline into
-  practical, sequential steps.
+- [Data Format](data-format.md) – Explains the data structures and file
+  formats used by EasyDiffraction.
+- [Parameters](parameters.md) – Describes how parameters are structured,
+  named, and accessed within EasyDiffraction.
+- [First Steps](first-steps.md) – Shows how to begin using
+  EasyDiffraction in Python or Jupyter notebooks.
+- [Analysis Workflow](analysis-workflow/index.md) – Breaks down the data
+  analysis pipeline into practical, sequential steps.
diff --git a/docs/docs/user-guide/parameters.md b/docs/docs/user-guide/parameters.md
index 4b4da1016..b97ff9e08 100644
--- a/docs/docs/user-guide/parameters.md
+++ b/docs/docs/user-guide/parameters.md
@@ -91,8 +91,8 @@ EasyDiffraction.
 
     | Category                                            | Parameter                                                    | How to access in the code          |
     |-----------------------------------------------------|--------------------------------------------------------------|------------------------------------|
-    | :material-space-station: [space_group][space_group] | :material-tag: [name_hm][space_group]                        | space_group.name_hm                |
-    |                                                     | :material-numeric: [system_code][space_group]                | space_group.system_code            |
+    | :material-space-station: [space_group][space_group] | :material-tag: [name_h_m][space_group]                       | space_group.name_h_m               |
+    |                                                     | :material-numeric: [it_coordinate_system_code][space_group]  | space_group.it_coordinate_system_code |
     | :material-cube-outline: [cell][cell]                | :material-ruler: [length_a][cell]                            | cell.length_a                      |
     |                                                     | :material-ruler: [length_b][cell]                            | cell.length_b                      |
     |                                                     | :material-ruler: [length_c][cell]                            | cell.length_c                      |
@@ -114,8 +114,8 @@ EasyDiffraction.
 
     | Category                                            | Parameter                                                    | CIF name for serialization              | CIF dictionary            |
     |-----------------------------------------------------|--------------------------------------------------------------|-----------------------------------------|---------------------------|
-    | :material-space-station: [space_group][space_group] | :material-tag: [name_hm][space_group]                        | \_space_group.name_H-M_alt              | [coreCIF][1]{:.label-cif} |
-    |                                                     | :material-numeric: [system_code][space_group]                | \_space_group.IT_coordinate_system_code | [coreCIF][1]{:.label-cif} |
+    | :material-space-station: [space_group][space_group] | :material-tag: [name_h_m][space_group]                       | \_space_group.name_H-M_alt              | [coreCIF][1]{:.label-cif} |
+    |                                                     | :material-numeric: [it_coordinate_system_code][space_group]  | \_space_group.IT_coordinate_system_code | [coreCIF][1]{:.label-cif} |
     | :material-cube-outline: [cell][cell]                | :material-ruler: [length_a][cell]                            | \_cell.length_a                         | [coreCIF][1]{:.label-cif} |
     |                                                     | :material-ruler: [length_b][cell]                            | \_cell.length_b                         | [coreCIF][1]{:.label-cif} |
     |                                                     | :material-ruler: [length_c][cell]                            | \_cell.length_c                         | [coreCIF][1]{:.label-cif} |
@@ -205,8 +205,8 @@ EasyDiffraction.
 
     | Category                                       | Parameter                                                  | CIF name for serialization         | CIF dictionary                       |
     |------------------------------------------------|------------------------------------------------------------|------------------------------------|--------------------------------------|
-    | :material-microscope: [instrument][instrument] | :material-wrench: [setup_wavelength][instrument]           | \_instrument.setup_wavelength      | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-tune: [calib_twotheta_offset][instrument]        | \_instrument.calib_twotheta_offset | [easydiffractionCIF][0]{:.label-cif} |
+    | :material-microscope: [instrument][instrument] | :material-wrench: [setup_wavelength][instrument]           | \_instr.wavelength                | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-tune: [calib_twotheta_offset][instrument]        | \_instr.2theta_offset             | [easydiffractionCIF][0]{:.label-cif} |
     | :material-shape: [peak][peak]                  | :material-arrow-expand-horizontal: [broad_gauss_u][peak]   | \_peak.broad_gauss_u               | [easydiffractionCIF][0]{:.label-cif} |
     |                                                | :material-arrow-expand-horizontal: [broad_gauss_v][peak]   | \_peak.broad_gauss_v               | [easydiffractionCIF][0]{:.label-cif} |
     |                                                | :material-arrow-expand-horizontal: [broad_gauss_w][peak]   | \_peak.broad_gauss_w               | [easydiffractionCIF][0]{:.label-cif} |
@@ -236,18 +236,18 @@ EasyDiffraction.
 
     | Category                                       | Parameter                                                      | CIF name for serialization         | CIF dictionary                       |
     |------------------------------------------------|----------------------------------------------------------------|------------------------------------|--------------------------------------|
-    | :material-microscope: [instrument][instrument] | :material-wrench: [setup_twotheta_bank][instrument]            | \_instrument.setup_twotheta_bank   | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-tune: [calib_d_to_tof_recip][instrument]             | \_instrument.calib_d_to_tof_recip  | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-tune: [calib_d_to_tof_offset][instrument]            | \_instrument.calib_d_to_tof_offset | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-tune: [calib_d_to_tof_linear][instrument]            | \_instrument.calib_d_to_tof_linear | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-tune: [calib_d_to_tof_quad][instrument]              | \_instrument.calib_d_to_tof_quad   | [easydiffractionCIF][0]{:.label-cif} |
-    | :material-shape: [peak][peak]                  | :material-arrow-expand-horizontal: [broad_gauss_sigma_0][peak] | \_peak.broad_gauss_sigma_0         | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-arrow-expand-horizontal: [broad_gauss_sigma_1][peak] | \_peak.broad_gauss_sigma_1         | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-arrow-expand-horizontal: [broad_gauss_sigma_2][peak] | \_peak.broad_gauss_sigma_2         | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-arrow-expand-horizontal: [exp_decay_beta_0][peak]    | \_peak.exp_decay_beta_0            | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-arrow-expand-horizontal: [exp_decay_beta_1][peak]    | \_peak.exp_decay_beta_1            | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-scale-unbalanced: [exp_rise_alpha_0][peak]           | \_peak.exp_rise_alpha_0            | [easydiffractionCIF][0]{:.label-cif} |
-    |                                                | :material-scale-unbalanced: [exp_rise_alpha_1][peak]           | \_peak.exp_rise_alpha_1            | [easydiffractionCIF][0]{:.label-cif} |
+    | :material-microscope: [instrument][instrument] | :material-wrench: [setup_twotheta_bank][instrument]            | \_instr.2theta_bank                | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-tune: [calib_d_to_tof_recip][instrument]             | \_instr.d_to_tof_recip             | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-tune: [calib_d_to_tof_offset][instrument]            | \_instr.d_to_tof_offset            | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-tune: [calib_d_to_tof_linear][instrument]            | \_instr.d_to_tof_linear            | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-tune: [calib_d_to_tof_quad][instrument]              | \_instr.d_to_tof_quad              | [easydiffractionCIF][0]{:.label-cif} |
+    | :material-shape: [peak][peak]                  | :material-arrow-expand-horizontal: [broad_gauss_sigma_0][peak] | \_peak.gauss_sigma_0               | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-arrow-expand-horizontal: [broad_gauss_sigma_1][peak] | \_peak.gauss_sigma_1               | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-arrow-expand-horizontal: [broad_gauss_sigma_2][peak] | \_peak.gauss_sigma_2               | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-arrow-expand-horizontal: [exp_decay_beta_0][peak]    | \_peak.decay_beta_0                | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-arrow-expand-horizontal: [exp_decay_beta_1][peak]    | \_peak.decay_beta_1                | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-scale-unbalanced: [exp_rise_alpha_0][peak]           | \_peak.rise_alpha_0                | [easydiffractionCIF][0]{:.label-cif} |
+    |                                                | :material-scale-unbalanced: [exp_rise_alpha_1][peak]           | \_peak.rise_alpha_1                | [easydiffractionCIF][0]{:.label-cif} |
 
 ### Total scattering
 
diff --git a/docs/docs/user-guide/parameters/expt_type.md b/docs/docs/user-guide/parameters/expt_type.md
index 806df516f..c6d3605e9 100644
--- a/docs/docs/user-guide/parameters/expt_type.md
+++ b/docs/docs/user-guide/parameters/expt_type.md
@@ -1,27 +1,30 @@
-[coreCIF][1]{:.label-cif}
+[customCIF][0]{:.label-cif}
 
-# \_cell
+# \_expt_type
 
-Data items in this category record details about the crystallographic
-cell parameters and their measurement. Please see the
-[IUCr page](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/CCELL.html)
-for further details.
+This EasyDiffraction category records the experiment type. The type
+selects compatible experiment categories, calculators, peak profiles,
+and data handling.
 
-## \_cell.angle
+## \_expt_type.beam_mode
 
-The angles between the bounding cell axes in degrees.
+Beam mode used by the experiment. Supported values include
+`constant wavelength` and `time-of-flight`.
 
-- [\_cell.angle_alpha](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.angle_alpha.html)
-- [\_cell.angle_beta](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.angle_beta.html)
-- [\_cell.angle_gamma](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.angle_gamma.html)
+## \_expt_type.radiation_probe
 
-## \_cell.length
+Radiation probe used by the experiment. Supported values include
+`neutron` and `x-ray`.
 
-The lengths of each cell axis in angstroms.
+## \_expt_type.sample_form
 
-- [\_cell.length_a](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.length_a.html)
-- [\_cell.length_b](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.length_b.html)
-- [\_cell.length_c](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.length_c.html)
+Sample form used by the experiment. Supported values include `powder`
+and `single crystal`.
+
+## \_expt_type.scattering_type
+
+Scattering type used by the experiment. Supported values include `bragg`
+and `total`.
 
 <!-- prettier-ignore-start -->
 [0]: #
diff --git a/docs/docs/user-guide/parameters/instrument.md b/docs/docs/user-guide/parameters/instrument.md
index fbeca6c95..fdbfcdacd 100644
--- a/docs/docs/user-guide/parameters/instrument.md
+++ b/docs/docs/user-guide/parameters/instrument.md
@@ -1,84 +1,54 @@
 [customCIF][0]{:.label-cif}
 
-# \_pd_instr
+# \_instr
 
-This section contains information relevant to the instrument used for
-the diffraction measurement, similar to this
-[IUCr section](https://www.iucr.org/resources/cif/dictionaries/browse/cif_pd).
+This category stores instrument setup and calibration parameters used by
+EasyDiffraction experiments. Constant-wavelength and time-of-flight
+experiments use different subsets of the category.
 
-## [\_pd_instr.resolution](#)
+## \_instr.wavelength
 
-In general, the profile of a Bragg reflection centred at the peak
-position can be approximated by mathematical convolution of
-contributions from the instrument, called the instrumental resolution
-function, and from the microstructure of the sample. Because many
-contributions to powder diffraction peaks have a nearly Gaussian or
-Lorentzian shape, the pseudo-Voigt function, is widely used to describe
-peak profiles in powder diffraction.
+Incident neutron or X-ray wavelength for constant-wavelength
+experiments. In Python this is accessed as:
 
-Half-width parameters (normally characterising the instrumental
-resolution function) as implemented in [CrysPy](https://cryspy.fr):
+```python
+experiment.instrument.setup_wavelength
+```
 
-- \_pd_instr.resolution_u
-- \_pd_instr.resolution_v
-- \_pd_instr.resolution_w
+## \_instr.2theta_offset
 
-Lorentzian isotropic microstrain parameter as implemented in
-[CrysPy](https://cryspy.fr):
+Two-theta zero offset for constant-wavelength powder experiments. In
+Python this is accessed as:
 
-- \_pd_instr.resolution_x
+```python
+experiment.instrument.calib_twotheta_offset
+```
 
-Lorentzian isotropic particle size parameteras implemented in
-[CrysPy](https://cryspy.fr):
+## \_instr.2theta_bank
 
-- \_pd_instr.resolution_y
+Detector-bank two-theta angle for time-of-flight powder experiments. In
+Python this is accessed as:
 
-## [\_pd_instr.reflex_asymmetry](#)
+```python
+experiment.instrument.setup_twotheta_bank
+```
 
-Peak profile asymmetry parameters as implemented in
-[CrysPy](https://cryspy.fr).
+## \_instr.d_to_tof
 
-- \_pd_instr.reflex_asymmetry_p1
-- \_pd_instr.reflex_asymmetry_p2
-- \_pd_instr.reflex_asymmetry_p3
-- \_pd_instr.reflex_asymmetry_p4
+Time-of-flight calibration terms converting d-spacing to time of flight.
+In Python these are accessed as:
 
-## [\_pd_instr.2theta_bank](#)
+- `experiment.instrument.calib_d_to_tof_recip`
+- `experiment.instrument.calib_d_to_tof_offset`
+- `experiment.instrument.calib_d_to_tof_linear`
+- `experiment.instrument.calib_d_to_tof_quad`
 
-Time-of-flight parameters as implemented in [CrysPy](https://cryspy.fr).
+They serialize to the following CIF tags:
 
-## [\_pd_instr.dtt](#)
-
-Time-of-flight parameters as implemented in [CrysPy](https://cryspy.fr).
-
-- \_pd_instr.dtt1
-- \_pd_instr.dtt2
-
-## [\_pd_instr.zero](#)
-
-Time-of-flight parameters as implemented in [CrysPy](https://cryspy.fr).
-
-## [\_pd_instr.alpha](#)
-
-Time-of-flight parameters as implemented in [CrysPy](https://cryspy.fr).
-
-- \_pd_instr.alpha0
-- \_pd_instr.alpha1
-
-## [\_pd_instr.beta](#)
-
-Time-of-flight parameters as implemented in [CrysPy](https://cryspy.fr).
-
-- \_pd_instr.beta0
-- \_pd_instr.beta1
-
-## [\_pd_instr.sigma](#)
-
-Time-of-flight parameters as implemented in [CrysPy](https://cryspy.fr).
-
-- \_pd_instr.sigma0
-- \_pd_instr.sigma1
-- \_pd_instr.sigma2
+- `_instr.d_to_tof_recip`
+- `_instr.d_to_tof_offset`
+- `_instr.d_to_tof_linear`
+- `_instr.d_to_tof_quad`
 
 <!-- prettier-ignore-start -->
 [0]: #
diff --git a/docs/docs/user-guide/parameters/peak.md b/docs/docs/user-guide/parameters/peak.md
index 806df516f..e7b94565f 100644
--- a/docs/docs/user-guide/parameters/peak.md
+++ b/docs/docs/user-guide/parameters/peak.md
@@ -1,27 +1,66 @@
-[coreCIF][1]{:.label-cif}
+[customCIF][0]{:.label-cif}
 
-# \_cell
+# \_peak
 
-Data items in this category record details about the crystallographic
-cell parameters and their measurement. Please see the
-[IUCr page](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/CCELL.html)
-for further details.
+This category stores peak-profile parameters used by powder diffraction
+and total-scattering calculations. The active peak-profile category is
+selected from the experiment:
 
-## \_cell.angle
+```python
+experiment.peak.type = 'pseudo-voigt'
+```
 
-The angles between the bounding cell axes in degrees.
+## Constant-wavelength powder profiles
 
-- [\_cell.angle_alpha](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.angle_alpha.html)
-- [\_cell.angle_beta](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.angle_beta.html)
-- [\_cell.angle_gamma](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.angle_gamma.html)
+The constant-wavelength pseudo-Voigt profile uses Gaussian and
+Lorentzian broadening parameters:
 
-## \_cell.length
+- `_peak.broad_gauss_u`
+- `_peak.broad_gauss_v`
+- `_peak.broad_gauss_w`
+- `_peak.broad_lorentz_x`
+- `_peak.broad_lorentz_y`
 
-The lengths of each cell axis in angstroms.
+When empirical asymmetry is enabled, the profile also uses:
 
-- [\_cell.length_a](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.length_a.html)
-- [\_cell.length_b](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.length_b.html)
-- [\_cell.length_c](https://www.iucr.org/__data/iucr/cifdic_html/3/CORE_DIC/Icell.length_c.html)
+- `_peak.asym_p1`
+- `_peak.asym_p2`
+- `_peak.asym_p3`
+- `_peak.asym_p4`
+
+## Time-of-flight powder profiles
+
+The time-of-flight pseudo-Voigt profiles use instrument-dependent
+Gaussian broadening, back-to-back exponential rise and decay terms, and
+optionally Lorentzian broadening or double-exponential asymmetry terms:
+
+- `_peak.gauss_sigma_0`
+- `_peak.gauss_sigma_1`
+- `_peak.gauss_sigma_2`
+- `_peak.rise_alpha_0`
+- `_peak.rise_alpha_1`
+- `_peak.decay_beta_0`
+- `_peak.decay_beta_1`
+- `_peak.lorentz_gamma_0`
+- `_peak.lorentz_gamma_1`
+- `_peak.lorentz_gamma_2`
+- `_peak.dexp_rise_alpha_1`
+- `_peak.dexp_rise_alpha_2`
+- `_peak.dexp_decay_beta_00`
+- `_peak.dexp_decay_beta_01`
+- `_peak.dexp_decay_beta_10`
+
+## Total-scattering profiles
+
+Total-scattering peak parameters describe Q-space cutoff, broadening,
+sharpening, and damping:
+
+- `_peak.cutoff_q`
+- `_peak.broad_q`
+- `_peak.sharp_delta_1`
+- `_peak.sharp_delta_2`
+- `_peak.damp_q`
+- `_peak.damp_particle_diameter`
 
 <!-- prettier-ignore-start -->
 [0]: #

From 437a06160c097b2e9256a2e77cdcb06584d13f20 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:16:01 +0200
Subject: [PATCH 123/160] Add documentation CI ADR suggestion

---
 docs/dev/adrs/index.md                        |   1 +
 .../suggestions/documentation-ci-build.md     | 189 ++++++++++++++++++
 2 files changed, 190 insertions(+)
 create mode 100644 docs/dev/adrs/suggestions/documentation-ci-build.md

diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index ba7ff647f..43e50a6da 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -32,6 +32,7 @@ folders.
 | Documentation        | Accepted   | Development Documentation Structure       | Defines the `docs/dev` layout for ADRs, issues, plans, package structure, and roadmap.                                | [`development-docs-structure.md`](accepted/development-docs-structure.md)                    |
 | Documentation        | Accepted   | Help Method Discoverability               | Requires primary public objects and facades to expose consistent `help()` output.                                     | [`help-discoverability.md`](accepted/help-discoverability.md)                                |
 | Documentation        | Accepted   | Notebook Generation Source of Truth       | Treats tutorial `.py` files as editable sources and notebooks as generated artifacts.                                 | [`notebook-generation.md`](accepted/notebook-generation.md)                                  |
+| Documentation        | Suggestion | Documentation CI and Build Verification   | Proposes strict MkDocs builds, API-derived docs, snippet smoke tests, link checks, and prose/spelling checks.         | [`documentation-ci-build.md`](suggestions/documentation-ci-build.md)                         |
 | Experiment model     | Accepted   | Immutable Experiment Type                 | Makes experiment type axes creation-time state rather than mutable runtime state.                                     | [`immutable-experiment-type.md`](accepted/immutable-experiment-type.md)                      |
 | Factories            | Accepted   | Factory Contracts and Metadata            | Standardizes factory construction, metadata, compatibility, and registration behavior.                                | [`factory-contracts.md`](accepted/factory-contracts.md)                                      |
 | Naming               | Accepted   | Factory Tag Naming                        | Defines canonical factory tag style and standard abbreviations.                                                       | [`factory-tag-naming.md`](accepted/factory-tag-naming.md)                                    |
diff --git a/docs/dev/adrs/suggestions/documentation-ci-build.md b/docs/dev/adrs/suggestions/documentation-ci-build.md
new file mode 100644
index 000000000..f3a858832
--- /dev/null
+++ b/docs/dev/adrs/suggestions/documentation-ci-build.md
@@ -0,0 +1,189 @@
+# ADR: Documentation CI and Build Verification
+
+**Status:** Proposed  
+**Date:** 2026-05-31
+
+## Group
+
+Documentation.
+
+## Context
+
+User-facing documentation can drift from the Python API, persisted CIF
+tags, tutorial outputs, and MkDocs navigation. Recent examples included
+stale selector methods, an outdated minimizer list, missing Quick
+Reference navigation, and code snippets that no longer matched current
+category-owned selectors.
+
+The documentation build should catch more of this drift before review.
+The checks should remain understandable to scientific contributors and
+should distinguish source documentation from generated notebooks.
+
+## Decision
+
+Add documentation verification in layers, starting with checks that are
+cheap, deterministic, and useful in local development.
+
+### 1. Build the MkDocs site in strict mode
+
+Run the docs build in CI with:
+
+```shell
+mkdocs build --strict
+```
+
+or the equivalent `pixi` task once one is added. This should catch
+missing navigation entries, broken internal references reported by
+MkDocs, and warnings that should fail documentation CI.
+
+### 2. Keep API reference generation source-driven
+
+Continue using source-driven API documentation. If the current API
+reference generation is not already based on `mkdocstrings`, adopt or
+standardize on `mkdocstrings[python]` so public signatures and docstring
+content are pulled from the installed package rather than copied into
+manual Markdown.
+
+### 3. Add snippet smoke tests for user-facing examples
+
+Add a small documentation smoke-test script that extracts or imports
+selected Python snippets from:
+
+- `docs/docs/quick-reference/index.md`
+- `docs/docs/user-guide/first-steps.md`
+- `docs/docs/user-guide/analysis-workflow/*.md`
+
+The smoke tests should focus on API shape, not full calculations. They
+should instantiate small projects, check public method names, and avoid
+network, notebooks, and real calculator backends unless explicitly
+covered by slower script or integration tests.
+
+### 4. Check generated tutorial freshness separately
+
+Tutorial notebooks remain generated artifacts. CI should verify that
+`pixi run notebook-prepare` leaves generated `.ipynb` files unchanged,
+or expose an explicit `notebook-prepare-check` task if the project wants
+a faster no-write mode.
+
+### 5. Check links with a dedicated link checker
+
+Use `lychee` or an equivalent link checker for Markdown and generated
+HTML links. Configure it with an allowlist for intentionally unstable or
+rate-limited external domains, and cache results where practical.
+
+### 6. Add prose and spelling checks incrementally
+
+Use `codespell` first for low-noise spelling checks. Consider `Vale`
+after the project has a small EasyDiffraction style vocabulary and an
+allowlist for crystallographic terms, package names, and CIF tags.
+
+## Options Considered
+
+### MkDocs strict build
+
+Pros:
+
+- aligns with the existing MkDocs build path
+- catches navigation and internal-reference problems early
+- low conceptual overhead for contributors
+
+Cons:
+
+- does not execute Python snippets
+- external URLs require a separate checker
+
+### mkdocstrings for API pages
+
+Pros:
+
+- keeps API reference tied to source signatures and docstrings
+- supports Python docstring styles already used by the project
+- reduces manual API copy/paste drift
+
+Cons:
+
+- requires a docs dependency if not already present
+- only helps reference pages, not narrative examples
+
+### Documentation snippet smoke tests
+
+Pros:
+
+- directly catches renamed methods and stale public API examples
+- can stay fast if limited to no-backend API construction
+- complements unit tests because it validates documented workflows
+
+Cons:
+
+- snippet extraction needs conventions or explicit markers
+- examples involving downloaded data or calculators need fixtures or
+  slower test tiers
+
+### lychee link checking
+
+Pros:
+
+- checks Markdown, HTML, and external URLs
+- has a GitHub Action and CLI workflow
+- can run on a schedule for external-link rot
+
+Cons:
+
+- external sites can be flaky or rate-limited
+- needs ignore rules for intentionally unreachable example URLs
+
+### Vale prose linting
+
+Pros:
+
+- catches grammar/style issues beyond spelling
+- supports project-specific style rules
+- can make docs more consistent for non-programmer users
+
+Cons:
+
+- needs careful configuration to avoid noisy scientific false positives
+- style-rule debates can slow feature reviews if introduced too broadly
+
+### codespell spelling checks
+
+Pros:
+
+- fast, simple, and available through pre-commit and CI
+- catches common typos in docs and code comments
+- lower adoption cost than full prose linting
+
+Cons:
+
+- needs ignore words for crystallography, CIF tags, names, and package
+  identifiers
+- does not catch grammar or stale API examples
+
+## Consequences
+
+### Positive
+
+- Documentation drift becomes visible before merge.
+- User-facing examples are more likely to match the current API.
+- Generated notebooks remain controlled by their existing
+  source-of-truth workflow.
+- Link and prose quality can improve without blocking on a full
+  documentation-system redesign.
+
+### Trade-offs
+
+- CI gains more jobs or longer docs jobs.
+- New tools require dependency and configuration maintenance.
+- External link checking can produce intermittent failures unless
+  scheduled, cached, or configured with retries and an allowlist.
+
+## Deferred Work
+
+- Decide whether link checking runs on every pull request, nightly, or
+  both.
+- Decide whether snippet smoke tests extract fenced code blocks
+  automatically or rely on explicitly named snippets.
+- Decide whether docs CI should build only source Markdown or also build
+  rendered notebooks.
+- Add the chosen checks to `pixi.toml`, CI configuration, and developer
+  documentation after this ADR is accepted.

From cff815e152914b20beee2f57004c4e2f912bb558 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:16:25 +0200
Subject: [PATCH 124/160] Contain structure view overlays in docs

---
 docs/docs/assets/javascripts/extra.js         | 85 +++++++++++++++++--
 docs/docs/assets/stylesheets/extra.css        | 65 ++++++++++++++
 .../display/structure/renderers/threejs.py    |  6 ++
 .../structure/templates/structure.html.j2     | 85 ++++++++++++++-----
 .../structure/renderers/test_threejs.py       | 46 ++++++++++
 5 files changed, 258 insertions(+), 29 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index 9596ee07e..ee0de007b 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -1,13 +1,10 @@
 ;(function () {
   'use strict'
 
-  // Variables
   const header = document.getElementsByTagName('header')[0]
 
-  console.log(window.pageYOffset)
-
-  // Hide-show header shadow
   function toggleHeaderShadow() {
+    if (!header) return
     if (window.pageYOffset <= 0) {
       header.classList.remove('md-header--shadow')
     } else {
@@ -15,13 +12,83 @@
     }
   }
 
-  // Onload
-  window.onload = function () {
-    toggleHeaderShadow()
+  function themeName() {
+    return document.documentElement.getAttribute('data-md-color-scheme') === 'slate'
+      ? 'dark'
+      : 'light'
+  }
+
+  function themeColors() {
+    if (themeName() === 'dark') {
+      return {
+        background: '#262626',
+        foreground: '#a3a3a3',
+        grid: 'rgba(163, 163, 163, 0.22)',
+      }
+    }
+    return {
+      background: '#fafafa',
+      foreground: '#525252',
+      grid: 'rgba(82, 82, 82, 0.18)',
+    }
+  }
+
+  function syncPlotlyTheme() {
+    if (!window.Plotly) return
+    const colors = themeColors()
+    document.querySelectorAll('.plotly-graph-div').forEach((plot) => {
+      if (!plot.layout) return
+      const update = {
+        paper_bgcolor: colors.background,
+        plot_bgcolor: colors.background,
+        'font.color': colors.foreground,
+        'legend.font.color': colors.foreground,
+      }
+      Object.keys(plot.layout).forEach((key) => {
+        if (/^[xy]axis[0-9]*$/.test(key)) {
+          update[`${key}.color`] = colors.foreground
+          update[`${key}.gridcolor`] = colors.grid
+          update[`${key}.linecolor`] = colors.grid
+          update[`${key}.zerolinecolor`] = colors.grid
+        }
+      })
+      try {
+        window.Plotly.relayout(plot, update)
+      } catch (_error) {
+        // Keep one stale chart from blocking the rest of the page theme update.
+      }
+    })
   }
 
-  // Onscroll
-  window.onscroll = function () {
+  function syncCrysviewTheme() {
+    const next = themeName()
+    document.querySelectorAll('.crysview').forEach((viewer) => {
+      viewer.classList.toggle('cv-host-theme-dark', next === 'dark')
+      viewer.classList.toggle('cv-host-theme-light', next !== 'dark')
+      if (typeof viewer.__crysviewApplyTheme === 'function') {
+        viewer.__crysviewApplyTheme(next)
+      }
+    })
+  }
+
+  function syncThemeAwareOutputs() {
+    syncPlotlyTheme()
+    syncCrysviewTheme()
+  }
+
+  window.addEventListener('load', function () {
     toggleHeaderShadow()
+    syncThemeAwareOutputs()
+  })
+
+  window.addEventListener('scroll', function () {
+    toggleHeaderShadow()
+  })
+
+  if (window.MutationObserver) {
+    new MutationObserver(syncThemeAwareOutputs).observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ['data-md-color-scheme'],
+    })
   }
 })()
diff --git a/docs/docs/assets/stylesheets/extra.css b/docs/docs/assets/stylesheets/extra.css
index a625be804..72a97a602 100644
--- a/docs/docs/assets/stylesheets/extra.css
+++ b/docs/docs/assets/stylesheets/extra.css
@@ -257,6 +257,71 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
   padding-left: 0.85em !important;
 }
 
+/* Keep inline Three.js structure outputs inside the notebook stacking context.
+   Generated notebook HTML contains internal z-index values, so isolate the
+   viewer to stop its controls from painting over the sticky MkDocs header. */
+.md-typeset .crysview {
+  isolation: isolate;
+  z-index: 0;
+}
+
+.md-typeset .crysview .cv-card,
+.md-typeset .crysview .cv-download,
+.md-typeset .crysview .cv-hint {
+  z-index: 2 !important;
+}
+
+.md-typeset .crysview .cv-tooltip {
+  z-index: 4 !important;
+}
+
+.md-typeset .crysview .mb-select {
+  height: calc(var(--cv-control-h, 32px) + 2px) !important;
+  min-height: calc(var(--cv-control-h, 32px) + 2px) !important;
+  margin: -1px 0 !important;
+}
+
+.md-typeset .crysview.cv-host-theme-dark {
+  --cv-scene-bg: #111217 !important;
+  --cv-scene-fg: #e6e8ee !important;
+  --cv-panel-bg: rgba(37, 37, 43, 0.95) !important;
+  --cv-panel-border: #52545c !important;
+  --cv-panel-fg: var(--cv-scene-fg) !important;
+  --cv-control-bg: #2c2f37 !important;
+  --cv-control-hover-bg: #373b45 !important;
+  --cv-control-active-bg: #3d4657 !important;
+  --cv-control-active-border: #63708a !important;
+  --cv-control-fg: var(--cv-scene-fg) !important;
+  --cv-control-muted: #8d929e !important;
+  background: var(--cv-scene-bg) !important;
+  color: var(--cv-scene-fg) !important;
+}
+
+.md-typeset .crysview.cv-host-theme-light {
+  --cv-scene-bg: #fff !important;
+  --cv-scene-fg: #222 !important;
+  --cv-panel-bg: rgba(255, 255, 255, 0.94) !important;
+  --cv-panel-border: #e2e2e2 !important;
+  --cv-panel-fg: #222 !important;
+  --cv-control-bg: #f5f5f6 !important;
+  --cv-control-hover-bg: #e9eaef !important;
+  --cv-control-active-bg: #e7ecf5 !important;
+  --cv-control-active-border: #c6d0e2 !important;
+  --cv-control-fg: #2a3f5f !important;
+  --cv-control-muted: #b9bdc6 !important;
+  background: var(--cv-scene-bg) !important;
+  color: var(--cv-scene-fg) !important;
+}
+
+.md-typeset .crysview.cv-host-theme-dark .cv-atom-label,
+.md-typeset .crysview.cv-host-theme-light .cv-atom-label {
+  color: var(--cv-scene-fg) !important;
+  text-shadow:
+    0 0 3px var(--cv-scene-bg),
+    0 0 3px var(--cv-scene-bg),
+    0 0 3px var(--cv-scene-bg) !important;
+}
+
 /* Extra styling the panda dataframes, on top of the style included in the code */
 table.dataframe {
   float: left;
diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index 53bd769d2..ab318c602 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -199,6 +199,8 @@ def render(
         if dark is None:
             dark = is_dark()
         colours = theme_colors(dark=dark)
+        light_colours = theme_colors(dark=False)
+        dark_colours = theme_colors(dark=True)
         payload = json.dumps(_scene_payload(scene)).replace('</', '<\\/')
         import_map = json.dumps({'imports': _import_map(offline=offline)}).replace('</', '<\\/')
         template = _environment().get_template(self.TEMPLATE_NAME)
@@ -209,5 +211,9 @@ def render(
             features_json=json.dumps(sorted(features)),
             background=_rgb_css(colours['background']),
             foreground=_rgb_css(colours['foreground']),
+            light_background=_rgb_css(light_colours['background']),
+            light_foreground=_rgb_css(light_colours['foreground']),
+            dark_background=_rgb_css(dark_colours['background']),
+            dark_foreground=_rgb_css(dark_colours['foreground']),
             theme='dark' if dark else 'light',
         )
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index df203b494..357ca54ce 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -1,6 +1,7 @@
-<div id="{{ container_id }}" class="crysview" style="position:relative;width:100%;height:512px;
-     background:{{ background }};color:{{ foreground }};border:1px solid rgba(128,128,128,0.3);
-     border-radius:0;box-sizing:border-box;overflow:hidden;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
+<div id="{{ container_id }}" class="crysview cv-theme-{{ theme }}" style="position:relative;width:100%;height:512px;
+     background:var(--cv-scene-bg);color:var(--cv-scene-fg);border:1px solid rgba(128,128,128,0.3);
+     border-radius:0;box-sizing:border-box;overflow:hidden;isolation:isolate;z-index:0;
+     font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
   <div class="cv-canvas" style="position:absolute;inset:0;"></div>
   <div class="cv-modebar cv-card"></div>
   <div class="cv-download"></div>
@@ -11,26 +12,32 @@
 
 <style>
   #{{ container_id }} .cv-card {
-    position: absolute; z-index: 10; background: var(--cv-panel-bg);
+    position: absolute; z-index: 2; background: var(--cv-panel-bg);
     border: 1px solid var(--cv-panel-border); border-radius: 0;
     box-shadow: var(--cv-panel-shadow); font-size: 12px; color: var(--cv-panel-fg);
   }
   #{{ container_id }} {
     --cv-control-h: 32px;
     --cv-axis-letter-size: 18px;
-{% if theme == 'dark' %}
+  }
+  #{{ container_id }}.cv-theme-dark {
+    --cv-scene-bg: {{ dark_background }};
+    --cv-scene-fg: {{ dark_foreground }};
     --cv-panel-bg: rgba(37, 37, 43, 0.95);
     --cv-panel-border: #52545c;
-    --cv-panel-fg: {{ foreground }};
+    --cv-panel-fg: var(--cv-scene-fg);
     --cv-panel-shadow: 0 1px 8px rgba(0, 0, 0, 0.38);
     --cv-control-bg: #2c2f37;
     --cv-control-hover-bg: #373b45;
     --cv-control-active-bg: #3d4657;
     --cv-control-active-border: #63708a;
-    --cv-control-fg: {{ foreground }};
+    --cv-control-fg: var(--cv-scene-fg);
     --cv-control-muted: #8d929e;
     --cv-select-arrow: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%23ebebeb' stroke-width='1.3'/%3E%3C/svg%3E");
-{% else %}
+  }
+  #{{ container_id }}.cv-theme-light {
+    --cv-scene-bg: {{ light_background }};
+    --cv-scene-fg: {{ light_foreground }};
     --cv-panel-bg: rgba(255, 255, 255, 0.94);
     --cv-panel-border: #e2e2e2;
     --cv-panel-fg: #222;
@@ -42,7 +49,6 @@
     --cv-control-fg: #2a3f5f;
     --cv-control-muted: #b9bdc6;
     --cv-select-arrow: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%232a3f5f' stroke-width='1.3'/%3E%3C/svg%3E");
-{% endif %}
   }
   #{{ container_id }} .cv-modebar {
     top: 10px; right: 10px; display: flex; align-items: center; gap: 16px;
@@ -50,7 +56,7 @@
     background: none; border: none; box-shadow: none;
   }
   #{{ container_id }} .cv-download {
-    position: absolute; z-index: 10; right: 10px; bottom: 8px; display: flex;
+    position: absolute; z-index: 2; right: 10px; bottom: 8px; display: flex;
   }
   #{{ container_id }} .mb-grp { display: flex; gap: 4px; }
   #{{ container_id }} .mb {
@@ -72,9 +78,10 @@
     border-color: var(--cv-control-active-border);
   }
   #{{ container_id }} .mb-select {
-    height: var(--cv-control-h); box-sizing: border-box;
+    height: calc(var(--cv-control-h) + 2px); min-height: calc(var(--cv-control-h) + 2px);
+    box-sizing: border-box; margin: -1px 0;
     border: 1px solid var(--cv-panel-border); border-radius: 0;
-    color: var(--cv-control-fg); font-size: 12px; line-height: var(--cv-control-h);
+    color: var(--cv-control-fg); font-size: 12px; line-height: calc(var(--cv-control-h) - 2px);
     padding: 0 22px 0 8px; cursor: pointer;
     -webkit-appearance: none; -moz-appearance: none; appearance: none;
     background-color: var(--cv-control-bg);
@@ -87,19 +94,19 @@
     margin-right: 7px; vertical-align: middle; border: 1px solid rgba(0, 0, 0, 0.18);
   }
   #{{ container_id }} .cv-hint {
-    position: absolute; z-index: 10; bottom: 8px; left: 10px; font-size: 11px;
+    position: absolute; z-index: 2; bottom: 8px; left: 10px; font-size: 11px;
     color: var(--cv-panel-fg); background: var(--cv-panel-bg);
     border: 1px solid var(--cv-panel-border); padding: 5px 9px; border-radius: 0;
     line-height: 1.5; text-align: left; box-shadow: var(--cv-panel-shadow);
   }
   #{{ container_id }} .cv-tooltip {
-    position: absolute; z-index: 30; pointer-events: none; display: none;
+    position: absolute; z-index: 4; pointer-events: none; display: none;
     background: rgba(33, 42, 62, 0.92); color: #fff; padding: 3px 8px;
     border-radius: 0; font-size: 12px; white-space: nowrap;
   }
   #{{ container_id }} .cv-atom-label {
-    font-size: 11px; font-weight: 600; color: {{ foreground }};
-    text-shadow: 0 0 3px {{ background }}, 0 0 3px {{ background }}, 0 0 3px {{ background }};
+    font-size: 11px; font-weight: 600; color: var(--cv-scene-fg);
+    text-shadow: 0 0 3px var(--cv-scene-bg), 0 0 3px var(--cv-scene-bg), 0 0 3px var(--cv-scene-bg);
     pointer-events: none; white-space: nowrap;
   }
 </style>
@@ -112,7 +119,7 @@ import { CSS2DRenderer, CSS2DObject } from 'three/addons/renderers/CSS2DRenderer
 
 const SCENE = {{ scene_json }};
 const FEATURES = {{ features_json }};
-const FG = '{{ foreground }}';
+const INITIAL_THEME = '{{ theme }}';
 
 const ICONS = {
   perspective: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><rect x="3.5" y="4.5" width="17" height="15" rx="1.5"/><path d="M9 4.5 11 19.5M15 4.5 13 19.5"/></svg>',
@@ -141,6 +148,7 @@ const tooltip = root.querySelector('.cv-tooltip');
 const col = (rgb) => new THREE.Color().setRGB(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255, THREE.SRGBColorSpace);
 const vec = (xyz) => new THREE.Vector3(xyz[0], xyz[1], xyz[2]);
 const rgbCss = (rgb) => `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
+const cssVar = (name, fallback) => getComputedStyle(root).getPropertyValue(name).trim() || fallback;
 const elementOf = (label) => (label.match(/[A-Z][a-z]?/) || [label])[0];
 const PALETTES = SCENE.palettes || {};
 
@@ -255,7 +263,9 @@ for (const b of SCENE.bonds) {
   addHalfBond(mid, end, b.endColour, b.endElement);
 }
 
-const cellMaterial = new THREE.LineBasicMaterial({ color: new THREE.Color(FG) });
+const cellMaterial = new THREE.LineBasicMaterial({
+  color: new THREE.Color(cssVar('--cv-scene-fg', '{{ foreground }}')),
+});
 for (const edge of SCENE.cellEdges) {
   const geo = new THREE.BufferGeometry().setFromPoints([vec(edge.start), vec(edge.end)]);
   groups.cell.add(new THREE.Line(geo, cellMaterial));
@@ -350,11 +360,12 @@ const halfW = Math.max((maxU - minU) / 2 + fitPad, 0.5) * margin;
 const halfH = Math.max((maxV - minV) / 2 + fitPad, 0.5) * margin;
 const radius = Math.max(halfW, halfH);
 const far = radius * 100;
-const tanV = Math.tan((45 * Math.PI) / 360);
+const PERSPECTIVE_FOV_DEG = 30;
+const tanV = Math.tan((PERSPECTIVE_FOV_DEG * Math.PI) / 360);
 const distance = Math.max(halfH / tanV, halfW / (tanV * aspect)) * 1.05;
 const home = target.clone().add(viewDir.clone().multiplyScalar(distance));
 
-const perspective = new THREE.PerspectiveCamera(45, aspect, Math.max(distance * 0.01, 0.01), far);
+const perspective = new THREE.PerspectiveCamera(PERSPECTIVE_FOV_DEG, aspect, Math.max(distance * 0.01, 0.01), far);
 // Ortho frustum sized to the projected extent; reserve a top band for the
 // modebar/legend so the cell sits a little lower and clears them.
 const orthoHalfH = Math.max(halfH, halfW / aspect);
@@ -630,6 +641,40 @@ const resize = () => {
 };
 if (window.ResizeObserver) new ResizeObserver(resize).observe(host);
 
+const hostTheme = () => {
+  const scheme = document.documentElement && document.documentElement.getAttribute('data-md-color-scheme');
+  if (scheme === 'slate') return 'dark';
+  if (scheme === 'default') return 'light';
+  const jpLight = (document.body && document.body.getAttribute('data-jp-theme-light'))
+    || (document.documentElement && document.documentElement.getAttribute('data-jp-theme-light'));
+  if (jpLight === 'true') return 'light';
+  if (jpLight === 'false') return 'dark';
+  return INITIAL_THEME;
+};
+
+const applyTheme = (name) => {
+  const themeName = name === 'dark' ? 'dark' : 'light';
+  root.classList.toggle('cv-theme-dark', themeName === 'dark');
+  root.classList.toggle('cv-theme-light', themeName !== 'dark');
+  cellMaterial.color.setStyle(cssVar('--cv-scene-fg', '{{ foreground }}'));
+};
+
+root.__crysviewApplyTheme = applyTheme;
+applyTheme(hostTheme());
+if (window.MutationObserver) {
+  const themeObserver = new MutationObserver(() => applyTheme(hostTheme()));
+  themeObserver.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ['data-md-color-scheme', 'data-jp-theme-light', 'data-jp-theme-name'],
+  });
+  if (document.body) {
+    themeObserver.observe(document.body, {
+      attributes: true,
+      attributeFilter: ['data-jp-theme-light', 'data-jp-theme-name'],
+    });
+  }
+}
+
 // Camera-relative light directions (right, up, toward-camera), matching the
 // raster figure's _LIGHT / _FILL so both engines shade atoms identically.
 const KEY_LOCAL = [0.3, 0.45, 0.85];
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index dc731d3bf..aeefda7eb 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -597,6 +597,52 @@ def test_download_button_is_bottom_right_overlay(self, patched_theme):
         assert 'right: 10px; bottom: 8px;' in html
         assert "iconButton(downloadHost, ICONS.camera, 'Download PNG')" in html
 
+    def test_viewer_is_isolated_from_page_header_stacking(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+
+        assert 'overflow:hidden;isolation:isolate;z-index:0;' in html
+        assert 'position: absolute; z-index: 2; background: var(--cv-panel-bg);' in html
+
+    def test_perspective_projection_uses_reduced_field_of_view(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+
+        assert 'const PERSPECTIVE_FOV_DEG = 30;' in html
+        assert 'new THREE.PerspectiveCamera(PERSPECTIVE_FOV_DEG,' in html
+
+    def test_colour_scheme_select_matches_button_height(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _rich_scene(),
+            features=frozenset({'atoms'}),
+            offline=True,
+            dark=False,
+        )
+
+        assert 'height: calc(var(--cv-control-h) + 2px);' in html
+        assert 'min-height: calc(var(--cv-control-h) + 2px);' in html
+        assert '--cv-axis-letter-size: 18px;\n  }\n  #' in html
+
+    def test_exposes_host_theme_sync_hook(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+
+        assert 'root.__crysviewApplyTheme = applyTheme;' in html
+        assert "data-md-color-scheme" in html
+        assert "data-jp-theme-light" in html
+
 
 # ------------------------------------------------------------------
 #  ThreeJsStructureRenderer.render — invalid inputs

From 52904d15a4885b6b953224a438118f673c05ce4f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:20:03 +0200
Subject: [PATCH 125/160] Format refreshed user guide docs

---
 .../user-guide/analysis-workflow/analysis.md  | 34 +++++++++----------
 .../user-guide/analysis-workflow/model.md     | 18 +++++-----
 docs/docs/user-guide/index.md                 |  4 +--
 3 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/docs/docs/user-guide/analysis-workflow/analysis.md b/docs/docs/user-guide/analysis-workflow/analysis.md
index 4fce53ef9..c7035a985 100644
--- a/docs/docs/user-guide/analysis-workflow/analysis.md
+++ b/docs/docs/user-guide/analysis-workflow/analysis.md
@@ -70,9 +70,9 @@ Example output:
 
 Calculator types
 
-|   | Type   | Description                                      |
-| - | ------ | ------------------------------------------------ |
-| * | cryspy | CrysPy library for crystallographic calculations |
+|     | Type   | Description                                      |
+| --- | ------ | ------------------------------------------------ |
+| \*  | cryspy | CrysPy library for crystallographic calculations |
 
 To explicitly select a calculation engine for an experiment:
 
@@ -149,18 +149,18 @@ Example output:
 
 Minimizer types
 
-|   | Type                  | Description                                                   |
-| - | --------------------- | ------------------------------------------------------------- |
-|   | lmfit                 | LMFIT library using the default Levenberg-Marquardt method    |
-| * | lmfit (leastsq)       | LMFIT library with Levenberg-Marquardt least squares method   |
-|   | lmfit (least_squares) | LMFIT library with SciPy's trust region reflective algorithm  |
-|   | dfols                 | DFO-LS library for derivative-free least-squares optimization |
-|   | bumps                 | BUMPS library using the default Levenberg-Marquardt method    |
-|   | bumps (lm)            | BUMPS library with Levenberg-Marquardt method                 |
-|   | bumps (dream)         | BUMPS library with DREAM Bayesian sampling                    |
-|   | bumps (amoeba)        | BUMPS library with Nelder-Mead simplex method                 |
-|   | bumps (de)            | BUMPS library with differential evolution method              |
-|   | emcee                 | emcee affine-invariant ensemble Bayesian sampling             |
+|     | Type                  | Description                                                   |
+| --- | --------------------- | ------------------------------------------------------------- |
+|     | lmfit                 | LMFIT library using the default Levenberg-Marquardt method    |
+| \*  | lmfit (leastsq)       | LMFIT library with Levenberg-Marquardt least squares method   |
+|     | lmfit (least_squares) | LMFIT library with SciPy's trust region reflective algorithm  |
+|     | dfols                 | DFO-LS library for derivative-free least-squares optimization |
+|     | bumps                 | BUMPS library using the default Levenberg-Marquardt method    |
+|     | bumps (lm)            | BUMPS library with Levenberg-Marquardt method                 |
+|     | bumps (dream)         | BUMPS library with DREAM Bayesian sampling                    |
+|     | bumps (amoeba)        | BUMPS library with Nelder-Mead simplex method                 |
+|     | bumps (de)            | BUMPS library with differential evolution method              |
+|     | emcee                 | emcee affine-invariant ensemble Bayesian sampling             |
 
 To select the desired minimizer, e.g., 'lmfit':
 
@@ -319,8 +319,8 @@ or follow a certain relationship during the refinement process.
 ### Setting Aliases
 
 Before setting constraints, you need to set aliases for the parameters
-you want to constrain. This can be done using the `create` method of
-the `aliases` object. Aliases are used to reference parameters in a more
+you want to constrain. This can be done using the `create` method of the
+`aliases` object. Aliases are used to reference parameters in a more
 readable way, making it easier to manage constraints.
 
 An example of setting aliases for parameters in a structure:
diff --git a/docs/docs/user-guide/analysis-workflow/model.md b/docs/docs/user-guide/analysis-workflow/model.md
index a8670f017..3f0783a28 100644
--- a/docs/docs/user-guide/analysis-workflow/model.md
+++ b/docs/docs/user-guide/analysis-workflow/model.md
@@ -16,8 +16,8 @@ EasyDiffraction allows you to:
   parameters.
 
 Below, you will find instructions on how to define and manage
-crystallographic structures in EasyDiffraction. It is assumed that you have
-already created a `project` object, as described in the
+crystallographic structures in EasyDiffraction. It is assumed that you
+have already created a `project` object, as described in the
 [Project](project.md) section.
 
 ## Adding a Structure from CIF
@@ -60,10 +60,10 @@ project.structures['lbco']
 
 ## Defining a Structure Manually
 
-If you do not have a CIF file or prefer to define the structure manually,
-you can use the `create` method of the `structures` object of the
-`project` instance. In this case, you will need to specify the name of
-the structure, which will be used to reference it later.
+If you do not have a CIF file or prefer to define the structure
+manually, you can use the `create` method of the `structures` object of
+the `project` instance. In this case, you will need to specify the name
+of the structure, which will be used to reference it later.
 
 ```python
 # Add a structure with default parameters
@@ -250,9 +250,9 @@ section).
 ## Saving a Structure
 
 Saving the project, as described in the [Project](project.md) section,
-will also save the structure. Each structure is saved as a separate CIF file in
-the `structures` subdirectory of the project directory. The project file
-contains references to these files.
+will also save the structure. Each structure is saved as a separate CIF
+file in the `structures` subdirectory of the project directory. The
+project file contains references to these files.
 
 Below is an example of the saved CIF file for the `lbco` structure:
 
diff --git a/docs/docs/user-guide/index.md b/docs/docs/user-guide/index.md
index 012a8e3f3..546e69316 100644
--- a/docs/docs/user-guide/index.md
+++ b/docs/docs/user-guide/index.md
@@ -12,8 +12,8 @@ Here is a brief overview of the User Guide sections:
 
 - [Glossary](glossary.md) – Defines common terms and labels used
   throughout the documentation.
-- [Concept](concept.md) – Introduces the overall idea behind data analysis in
-  EasyDiffraction.
+- [Concept](concept.md) – Introduces the overall idea behind data
+  analysis in EasyDiffraction.
 - [Data Format](data-format.md) – Explains the data structures and file
   formats used by EasyDiffraction.
 - [Parameters](parameters.md) – Describes how parameters are structured,

From 1b8ffc19c47b6ca26f721e8d5f2d8eb4443d1cbe Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:24:52 +0200
Subject: [PATCH 126/160] Render pretty units in fit parameter tables

---
 .../analysis/fit_helpers/bayesian.py          |  3 +-
 .../analysis/fit_helpers/reporting.py         | 12 +++-
 .../fitting/test_bayesian_helper_support.py   | 59 ++++++++++++++++---
 .../analysis/fit_helpers/test_bayesian.py     | 47 ++++++++++++---
 .../analysis/fit_helpers/test_reporting.py    |  8 ++-
 5 files changed, 109 insertions(+), 20 deletions(-)

diff --git a/src/easydiffraction/analysis/fit_helpers/bayesian.py b/src/easydiffraction/analysis/fit_helpers/bayesian.py
index bc50ba7a7..665bf6cce 100644
--- a/src/easydiffraction/analysis/fit_helpers/bayesian.py
+++ b/src/easydiffraction/analysis/fit_helpers/bayesian.py
@@ -16,6 +16,7 @@
 from easydiffraction.analysis.fit_helpers.metrics import calculate_weighted_r_factor
 from easydiffraction.analysis.fit_helpers.reporting import FitResults
 from easydiffraction.analysis.fit_helpers.reporting import _build_parameter_row
+from easydiffraction.analysis.fit_helpers.reporting import _display_units
 from easydiffraction.analysis.fit_helpers.reporting import _overall_status_row_label
 from easydiffraction.core.posterior import PosteriorParameterSummary
 from easydiffraction.utils.logging import console
@@ -714,7 +715,7 @@ def _build_posterior_summary_row(
     category = getattr(identity, 'category_code', 'N/A')
     entry = getattr(identity, 'category_entry_name', '') or ''
     parameter_name = getattr(parameter, 'name', summary.display_name)
-    units = getattr(parameter, 'units', 'N/A')
+    units = _display_units(parameter)
 
     return [
         datablock,
diff --git a/src/easydiffraction/analysis/fit_helpers/reporting.py b/src/easydiffraction/analysis/fit_helpers/reporting.py
index 40f898d86..687060f94 100644
--- a/src/easydiffraction/analysis/fit_helpers/reporting.py
+++ b/src/easydiffraction/analysis/fit_helpers/reporting.py
@@ -252,7 +252,7 @@ def _build_parameter_row(param: object) -> list[str]:
     uncertainty = f'{param.uncertainty:.4f}' if param.uncertainty is not None else 'N/A'
     if _is_uncertainty_large(param):
         uncertainty = f'[red]{uncertainty}[/red]'
-    units = getattr(param, 'units', 'N/A')
+    units = _display_units(param)
     relative_change = _compute_relative_change(param)
     return [
         param._identity.datablock_entry_name,
@@ -267,6 +267,16 @@ def _build_parameter_row(param: object) -> list[str]:
     ]
 
 
+def _display_units(param: object) -> str:
+    """Return user-facing units for a fitted parameter."""
+    if hasattr(param, 'resolve_display_units'):
+        return param.resolve_display_units('gui')
+    units = getattr(param, 'units', 'N/A')
+    if units == 'none':
+        return ''
+    return units
+
+
 def _compute_relative_change(param: object) -> str:
     """
     Compute percentage change between start and fitted values.
diff --git a/tests/integration/fitting/test_bayesian_helper_support.py b/tests/integration/fitting/test_bayesian_helper_support.py
index c8028d3b7..8aac2e2ef 100644
--- a/tests/integration/fitting/test_bayesian_helper_support.py
+++ b/tests/integration/fitting/test_bayesian_helper_support.py
@@ -23,7 +23,15 @@ def __init__(self) -> None:
 
 
 class Param:
-    def __init__(self, unique_name: str, start: float, value: float, uncertainty: float) -> None:
+    def __init__(
+        self,
+        unique_name: str,
+        start: float,
+        value: float,
+        uncertainty: float,
+        *,
+        display_units: str | None = None,
+    ) -> None:
         self._identity = Identity()
         self._fit_start_value = start
         self.unique_name = unique_name
@@ -31,6 +39,11 @@ def __init__(self, unique_name: str, start: float, value: float, uncertainty: fl
         self.value = value
         self.uncertainty = uncertainty
         self.units = 'arb'
+        self._display_units = display_units
+
+    def resolve_display_units(self, context: str) -> str:
+        assert context == 'gui'
+        return self._display_units or self.units
 
 
 def test_posterior_samples_flatten():
@@ -353,7 +366,13 @@ def test_build_posterior_summary_row_restores_identifier_columns():
     from easydiffraction.analysis.fit_helpers.bayesian import PosteriorParameterSummary
     from easydiffraction.analysis.fit_helpers.bayesian import _build_posterior_summary_row
 
-    parameter = Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)
+    parameter = Param(
+        unique_name='a',
+        start=1.0,
+        value=1.2,
+        uncertainty=0.05,
+        display_units='Ų',
+    )
     summary = PosteriorParameterSummary(
         unique_name='a',
         display_name='a',
@@ -373,7 +392,7 @@ def test_build_posterior_summary_row_restores_identifier_columns():
         'cat',
         'entry',
         'a',
-        'arb',
+        'Ų',
         '1.1500',
         '[1.0000, 1.3000]',
         '[red]1.107[/red]',
@@ -394,7 +413,13 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
     monkeypatch.setattr(bayesian, 'render_table', fake_render_table)
 
     bayesian._render_committed_parameter_table([
-        Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)
+        Param(
+            unique_name='a',
+            start=1.0,
+            value=1.2,
+            uncertainty=0.05,
+            display_units='Ų',
+        )
     ])
 
     assert captured['columns_headers'] == [
@@ -425,7 +450,7 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
             'cat',
             'entry',
             'a',
-            'arb',
+            'Ų',
             '1.0000',
             '1.2000',
             '0.0500',
@@ -448,7 +473,15 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
     monkeypatch.setattr(bayesian, 'render_table', fake_render_table)
 
     bayesian._render_posterior_summary_table(
-        parameters=[Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)],
+        parameters=[
+            Param(
+                unique_name='a',
+                start=1.0,
+                value=1.2,
+                uncertainty=0.05,
+                display_units='Ų',
+            )
+        ],
         posterior_parameter_summaries=[
             PosteriorParameterSummary(
                 unique_name='a',
@@ -492,7 +525,7 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
             'cat',
             'entry',
             'a',
-            'arb',
+            'Ų',
             '1.1500',
             '[1.0000, 1.3000]',
             '[red]1.107[/red]',
@@ -612,7 +645,15 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
 
     reporting.FitResults(
         success=True,
-        parameters=[Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)],
+        parameters=[
+            Param(
+                unique_name='a',
+                start=1.0,
+                value=1.2,
+                uncertainty=0.05,
+                display_units='Ų',
+            )
+        ],
     ).display_results()
 
     assert captured['columns_headers'] == [
@@ -643,7 +684,7 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
             'cat',
             'entry',
             'a',
-            'arb',
+            'Ų',
             '1.0000',
             '1.2000',
             '0.0500',
diff --git a/tests/unit/easydiffraction/analysis/fit_helpers/test_bayesian.py b/tests/unit/easydiffraction/analysis/fit_helpers/test_bayesian.py
index da29f65ba..556d931ce 100644
--- a/tests/unit/easydiffraction/analysis/fit_helpers/test_bayesian.py
+++ b/tests/unit/easydiffraction/analysis/fit_helpers/test_bayesian.py
@@ -15,7 +15,15 @@ def __init__(self) -> None:
 
 
 class Param:
-    def __init__(self, unique_name: str, start: float, value: float, uncertainty: float) -> None:
+    def __init__(
+        self,
+        unique_name: str,
+        start: float,
+        value: float,
+        uncertainty: float,
+        *,
+        display_units: str | None = None,
+    ) -> None:
         self._identity = Identity()
         self._fit_start_value = start
         self.unique_name = unique_name
@@ -23,6 +31,11 @@ def __init__(self, unique_name: str, start: float, value: float, uncertainty: fl
         self.value = value
         self.uncertainty = uncertainty
         self.units = 'arb'
+        self._display_units = display_units
+
+    def resolve_display_units(self, context: str) -> str:
+        assert context == 'gui'
+        return self._display_units or self.units
 
 
 def test_module_import():
@@ -221,7 +234,13 @@ def test_build_posterior_summary_row_restores_identifier_columns():
     from easydiffraction.analysis.fit_helpers.bayesian import PosteriorParameterSummary
     from easydiffraction.analysis.fit_helpers.bayesian import _build_posterior_summary_row
 
-    parameter = Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)
+    parameter = Param(
+        unique_name='a',
+        start=1.0,
+        value=1.2,
+        uncertainty=0.05,
+        display_units='Ų',
+    )
     summary = PosteriorParameterSummary(
         unique_name='a',
         display_name='a',
@@ -241,7 +260,7 @@ def test_build_posterior_summary_row_restores_identifier_columns():
         'cat',
         'entry',
         'a',
-        'arb',
+        'Ų',
         '1.1500',
         '[1.0000, 1.3000]',
         '[red]1.107[/red]',
@@ -262,7 +281,13 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
     monkeypatch.setattr(bayesian, 'render_table', fake_render_table)
 
     bayesian._render_committed_parameter_table([
-        Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)
+        Param(
+            unique_name='a',
+            start=1.0,
+            value=1.2,
+            uncertainty=0.05,
+            display_units='Ų',
+        )
     ])
 
     assert captured['columns_headers'] == [
@@ -293,7 +318,7 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
             'cat',
             'entry',
             'a',
-            'arb',
+            'Ų',
             '1.0000',
             '1.2000',
             '0.0500',
@@ -316,7 +341,15 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
     monkeypatch.setattr(bayesian, 'render_table', fake_render_table)
 
     bayesian._render_posterior_summary_table(
-        parameters=[Param(unique_name='a', start=1.0, value=1.2, uncertainty=0.05)],
+        parameters=[
+            Param(
+                unique_name='a',
+                start=1.0,
+                value=1.2,
+                uncertainty=0.05,
+                display_units='Ų',
+            )
+        ],
         posterior_parameter_summaries=[
             PosteriorParameterSummary(
                 unique_name='a',
@@ -360,7 +393,7 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
             'cat',
             'entry',
             'a',
-            'arb',
+            'Ų',
             '1.1500',
             '[1.0000, 1.3000]',
             '[red]1.107[/red]',
diff --git a/tests/unit/easydiffraction/analysis/fit_helpers/test_reporting.py b/tests/unit/easydiffraction/analysis/fit_helpers/test_reporting.py
index d5a241d17..bba7ee45b 100644
--- a/tests/unit/easydiffraction/analysis/fit_helpers/test_reporting.py
+++ b/tests/unit/easydiffraction/analysis/fit_helpers/test_reporting.py
@@ -84,7 +84,11 @@ def __init__(self):
             self.value = 1.2
             self.uncertainty = 0.05
             self.name = 'a'
-            self.units = 'arb'
+            self.units = 'angstrom_squared'
+
+        def resolve_display_units(self, context):
+            assert context == 'gui'
+            return 'Ų'
 
     from easydiffraction.analysis.fit_helpers import reporting
 
@@ -127,7 +131,7 @@ def fake_render_table(*, columns_headers, columns_alignment, columns_data):
             'cat',
             'entry',
             'a',
-            'arb',
+            'Ų',
             '1.0000',
             '1.2000',
             '0.0500',

From eada32fb039fb65a5329cf7c75787cbba42c88ba Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:39:44 +0200
Subject: [PATCH 127/160] Sync Plotly and structure themes in docs

---
 docs/docs/assets/javascripts/extra.js         |  88 ++++++++---
 .../display/plotters/plotly.py                | 143 +++++++++++++++++-
 .../structure/templates/structure.html.j2     |   5 +-
 .../display/plotters/test_plotly.py           |  11 +-
 .../structure/renderers/test_threejs.py       |   1 +
 5 files changed, 221 insertions(+), 27 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index ee0de007b..8521f65ea 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -13,47 +13,83 @@
   }
 
   function themeName() {
-    return document.documentElement.getAttribute('data-md-color-scheme') === 'slate'
-      ? 'dark'
-      : 'light'
+    const materialScheme =
+      document.body?.getAttribute('data-md-color-scheme') ||
+      document.documentElement.getAttribute('data-md-color-scheme')
+    if (materialScheme === 'slate') return 'dark'
+    if (materialScheme === 'default') return 'light'
+
+    const jupyterThemeLight =
+      document.body?.getAttribute('data-jp-theme-light') ||
+      document.documentElement.getAttribute('data-jp-theme-light')
+    if (jupyterThemeLight === 'false') return 'dark'
+    if (jupyterThemeLight === 'true') return 'light'
+
+    return 'light'
   }
 
   function themeColors() {
     if (themeName() === 'dark') {
       return {
-        background: '#262626',
-        foreground: '#a3a3a3',
-        grid: 'rgba(163, 163, 163, 0.22)',
+        background: '#111217',
+        foreground: '#e6e8ee',
+        grid: 'rgba(110, 145, 190, 0.35)',
+        legend: 'rgba(0, 0, 0, 0.5)',
       }
     }
     return {
-      background: '#fafafa',
-      foreground: '#525252',
-      grid: 'rgba(82, 82, 82, 0.18)',
+      background: '#ffffff',
+      foreground: '#222222',
+      grid: 'rgba(120, 140, 160, 0.28)',
+      legend: 'rgba(255, 255, 255, 0.5)',
     }
   }
 
+  function plotlyAxisNames(plot) {
+    const names = new Set(['xaxis', 'yaxis'])
+    ;[plot.layout, plot._fullLayout].forEach((layout) => {
+      if (!layout) return
+      Object.keys(layout).forEach((key) => {
+        if (/^[xyz]axis[0-9]*$/.test(key)) {
+          names.add(key)
+        }
+      })
+    })
+    return names
+  }
+
   function syncPlotlyTheme() {
     if (!window.Plotly) return
     const colors = themeColors()
     document.querySelectorAll('.plotly-graph-div').forEach((plot) => {
-      if (!plot.layout) return
+      if (!plot.layout && !plot._fullLayout) return
       const update = {
         paper_bgcolor: colors.background,
         plot_bgcolor: colors.background,
         'font.color': colors.foreground,
+        'title.font.color': colors.foreground,
+        'legend.bgcolor': colors.legend,
         'legend.font.color': colors.foreground,
+        'hoverlabel.bgcolor': colors.background,
+        'hoverlabel.font.color': colors.foreground,
       }
-      Object.keys(plot.layout).forEach((key) => {
-        if (/^[xy]axis[0-9]*$/.test(key)) {
-          update[`${key}.color`] = colors.foreground
-          update[`${key}.gridcolor`] = colors.grid
-          update[`${key}.linecolor`] = colors.grid
-          update[`${key}.zerolinecolor`] = colors.grid
-        }
+      plotlyAxisNames(plot).forEach((key) => {
+        update[`${key}.color`] = colors.foreground
+        update[`${key}.gridcolor`] = colors.grid
+        update[`${key}.linecolor`] = colors.grid
+        update[`${key}.zerolinecolor`] = colors.grid
+        update[`${key}.title.font.color`] = colors.foreground
+        update[`${key}.tickfont.color`] = colors.foreground
       })
       try {
-        window.Plotly.relayout(plot, update)
+        const result = window.Plotly.relayout(plot, update)
+        if (result && typeof result.then === 'function') {
+          result.then(function () {
+            window.Plotly.redraw(plot)
+          })
+        } else {
+          window.Plotly.redraw(plot)
+        }
       } catch (_error) {
         // Keep one stale chart from blocking the rest of the page theme update.
       }
@@ -86,9 +122,21 @@
   })
 
   if (window.MutationObserver) {
-    new MutationObserver(syncThemeAwareOutputs).observe(document.documentElement, {
+    const themeObserver = new MutationObserver(syncThemeAwareOutputs)
+    const attributeFilter = [
+      'data-md-color-scheme',
+      'data-jp-theme-light',
+      'data-jp-theme-name',
+    ]
+    themeObserver.observe(document.documentElement, {
       attributes: true,
-      attributeFilter: ['data-md-color-scheme'],
+      attributeFilter,
     })
+    if (document.body) {
+      themeObserver.observe(document.body, {
+        attributes: true,
+        attributeFilter,
+      })
+    }
   }
 })()
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 153f3d2fd..2e271eb06 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -948,16 +948,153 @@ def _modebar_legend_toggle_post_script() -> str:
 }
 syncLegendVisibility();
 window.requestAnimationFrame(installLegendToggleButton);
+"""
+
+    @staticmethod
+    def _theme_sync_post_script() -> str:
+        """
+        Return client-side code for host dark/light theme changes.
+        """
+        return r"""
+const graphDiv = document.getElementById('{plot_id}');
+if (!graphDiv || !window.Plotly) {
+    return;
+}
+
+const hostTheme = function () {
+    const materialScheme = (
+        (document.body && document.body.getAttribute('data-md-color-scheme'))
+        || (document.documentElement && document.documentElement.getAttribute('data-md-color-scheme'))
+    );
+    if (materialScheme === 'slate') {
+        return 'dark';
+    }
+    if (materialScheme === 'default') {
+        return 'light';
+    }
+
+    const jupyterThemeLight = (
+        (document.body && document.body.getAttribute('data-jp-theme-light'))
+        || (document.documentElement && document.documentElement.getAttribute('data-jp-theme-light'))
+    );
+    if (jupyterThemeLight === 'false') {
+        return 'dark';
+    }
+    if (jupyterThemeLight === 'true') {
+        return 'light';
+    }
+    return 'light';
+};
+
+const themeColors = function (theme) {
+    if (theme === 'dark') {
+        return {
+            background: '#111217',
+            foreground: '#e6e8ee',
+            grid: 'rgba(110, 145, 190, 0.35)',
+            legend: 'rgba(0, 0, 0, 0.5)',
+        };
+    }
+    return {
+        background: '#ffffff',
+        foreground: '#222222',
+        grid: 'rgba(120, 140, 160, 0.28)',
+        legend: 'rgba(255, 255, 255, 0.5)',
+    };
+};
+
+const axisNames = function () {
+    const names = new Set(['xaxis', 'yaxis']);
+    [graphDiv.layout, graphDiv._fullLayout].forEach(function (layout) {
+        if (!layout) {
+            return;
+        }
+        Object.keys(layout).forEach(function (key) {
+            if (/^[xyz]axis[0-9]*$/.test(key)) {
+                names.add(key);
+            }
+        });
+    });
+    return names;
+};
+
+const applyTheme = function () {
+    const theme = hostTheme();
+    if (graphDiv.dataset.edPlotlyTheme === theme) {
+        return;
+    }
+    graphDiv.dataset.edPlotlyTheme = theme;
+
+    const colors = themeColors(theme);
+    const update = {
+        paper_bgcolor: colors.background,
+        plot_bgcolor: colors.background,
+        'font.color': colors.foreground,
+        'title.font.color': colors.foreground,
+        'legend.bgcolor': colors.legend,
+        'legend.font.color': colors.foreground,
+        'hoverlabel.bgcolor': colors.background,
+        'hoverlabel.font.color': colors.foreground,
+    };
+
+    axisNames().forEach(function (axisName) {
+        update[axisName + '.color'] = colors.foreground;
+        update[axisName + '.gridcolor'] = colors.grid;
+        update[axisName + '.linecolor'] = colors.grid;
+        update[axisName + '.zerolinecolor'] = colors.grid;
+        update[axisName + '.title.font.color'] = colors.foreground;
+        update[axisName + '.tickfont.color'] = colors.foreground;
+    });
+
+    try {
+        const result = window.Plotly.relayout(graphDiv, update);
+        if (result && typeof result.then === 'function') {
+            result.then(function () {
+                window.Plotly.redraw(graphDiv);
+            });
+        } else {
+            window.Plotly.redraw(graphDiv);
+        }
+    } catch (_error) {
+        // Keep theme switching from breaking interaction with the figure.
+    }
+};
+
+if (graphDiv.on) {
+    graphDiv.on('plotly_afterplot', applyTheme);
+}
+
+if (window.MutationObserver) {
+    const themeObserver = new MutationObserver(function () {
+        graphDiv.dataset.edPlotlyTheme = '';
+        applyTheme();
+    });
+    const attributeFilter = [
+        'data-md-color-scheme',
+        'data-jp-theme-light',
+        'data-jp-theme-name',
+    ];
+    themeObserver.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: attributeFilter,
+    });
+    if (document.body) {
+        themeObserver.observe(document.body, {
+            attributes: true,
+            attributeFilter: attributeFilter,
+        });
+    }
+}
+
+applyTheme();
 """
 
     @classmethod
     def _html_post_script(cls, fig: object) -> str | None:
         """Return concatenated HTML post scripts for a Plotly figure."""
-        scripts: list[str] = []
+        scripts: list[str] = [cls._theme_sync_post_script()]
         if cls._has_visible_legend(fig):
             scripts.append(cls._modebar_legend_toggle_post_script())
-        if not scripts:
-            return None
         return '\n'.join(cls._scoped_html_post_script(script) for script in scripts)
 
     @staticmethod
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 357ca54ce..c0f74bad0 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -642,7 +642,8 @@ const resize = () => {
 if (window.ResizeObserver) new ResizeObserver(resize).observe(host);
 
 const hostTheme = () => {
-  const scheme = document.documentElement && document.documentElement.getAttribute('data-md-color-scheme');
+  const scheme = (document.body && document.body.getAttribute('data-md-color-scheme'))
+    || (document.documentElement && document.documentElement.getAttribute('data-md-color-scheme'));
   if (scheme === 'slate') return 'dark';
   if (scheme === 'default') return 'light';
   const jpLight = (document.body && document.body.getAttribute('data-jp-theme-light'))
@@ -670,7 +671,7 @@ if (window.MutationObserver) {
   if (document.body) {
     themeObserver.observe(document.body, {
       attributes: true,
-      attributeFilter: ['data-jp-theme-light', 'data-jp-theme-name'],
+      attributeFilter: ['data-md-color-scheme', 'data-jp-theme-light', 'data-jp-theme-name'],
     });
   }
 }
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 26d3446f3..3c7fc6047 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -166,6 +166,10 @@ def __init__(self, html):
     assert captured.get('show_called') is not True
     assert captured['config']['displayModeBar'] is True
     assert captured['config']['displaylogo'] is False
+    assert 'data-jp-theme-light' in captured['post_script']
+    assert 'data-md-color-scheme' in captured['post_script']
+    assert 'graphDiv.dataset.edPlotlyTheme' in captured['post_script']
+    assert 'window.Plotly.relayout(graphDiv, update)' in captured['post_script']
     assert 'data-legend-toggle="true"' in captured['post_script']
     assert 'Toggle legend' in captured['post_script']
     assert 'graphDiv.dataset.legendVisible' in captured['post_script']
@@ -229,7 +233,9 @@ def __init__(self, html):
     plotter._show_figure(DummyFig())
 
     assert captured.get('show_called') is not True
-    assert captured['post_script'] is None
+    assert captured['post_script'] is not None
+    assert 'data-jp-theme-light' in captured['post_script']
+    assert 'data-legend-toggle="true"' not in captured['post_script']
     assert captured['displayed_html'] == '<div>plot</div>'
 
 
@@ -278,7 +284,8 @@ def __init__(self, html):
     plotter._show_figure(DummyFig())
 
     assert captured.get('show_called') is not True
-    assert captured['post_script'] is None
+    assert captured['post_script'] is not None
+    assert 'data-jp-theme-light' in captured['post_script']
     assert 'aspect-ratio: 1 / 1;' in captured['displayed_html']
     assert 'ed-fixed-aspect-plotly-wrapper' in captured['displayed_html']
     assert '<div>plot</div>' in captured['displayed_html']
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index aeefda7eb..4d1298eb3 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -642,6 +642,7 @@ def test_exposes_host_theme_sync_hook(self, patched_theme):
         assert 'root.__crysviewApplyTheme = applyTheme;' in html
         assert "data-md-color-scheme" in html
         assert "data-jp-theme-light" in html
+        assert "document.body.getAttribute('data-md-color-scheme')" in html
 
 
 # ------------------------------------------------------------------

From cf0a5eddf0347e6cd31dbdc378c5deecae8486eb Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:46:38 +0200
Subject: [PATCH 128/160] Remove redundant line in tutorial docs

---
 docs/docs/tutorials/ed-5.py | 2 --
 docs/docs/tutorials/ed-6.py | 2 --
 docs/docs/tutorials/ed-8.py | 2 --
 3 files changed, 6 deletions(-)

diff --git a/docs/docs/tutorials/ed-5.py b/docs/docs/tutorials/ed-5.py
index 046db1f37..0a657ee02 100644
--- a/docs/docs/tutorials/ed-5.py
+++ b/docs/docs/tutorials/ed-5.py
@@ -300,7 +300,5 @@
 # %% [markdown]
 # ## Report
 #
-# This final section shows how to review the results of the analysis.
-#
 # The HTML report is written automatically when the project is saved;
 # enable `project.report.pdf` as well for a PDF version.
diff --git a/docs/docs/tutorials/ed-6.py b/docs/docs/tutorials/ed-6.py
index bea61203e..898b488da 100644
--- a/docs/docs/tutorials/ed-6.py
+++ b/docs/docs/tutorials/ed-6.py
@@ -347,7 +347,5 @@
 # %% [markdown]
 # ## Report
 #
-# This final section shows how to review the results of the analysis.
-#
 # The HTML report is written automatically when the project is saved;
 # enable `project.report.pdf` as well for a PDF version.
diff --git a/docs/docs/tutorials/ed-8.py b/docs/docs/tutorials/ed-8.py
index 790c09d51..0988ffd71 100644
--- a/docs/docs/tutorials/ed-8.py
+++ b/docs/docs/tutorials/ed-8.py
@@ -364,7 +364,5 @@
 # %% [markdown]
 # ## Report
 #
-# This final section shows how to review the results of the analysis.
-#
 # The HTML report is written automatically when the project is saved;
 # enable `project.report.pdf` as well for a PDF version.

From 46abd0516410f6ee8bba97de376ceda6c30ad435 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:48:24 +0200
Subject: [PATCH 129/160] Normalize structure toolbar select sizing

---
 docs/docs/assets/stylesheets/extra.css                   | 9 +++++++++
 .../display/structure/templates/structure.html.j2        | 5 +++--
 .../display/structure/renderers/test_threejs.py          | 4 ++++
 3 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/docs/docs/assets/stylesheets/extra.css b/docs/docs/assets/stylesheets/extra.css
index 72a97a602..ae7d13f9b 100644
--- a/docs/docs/assets/stylesheets/extra.css
+++ b/docs/docs/assets/stylesheets/extra.css
@@ -278,7 +278,16 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
 .md-typeset .crysview .mb-select {
   height: calc(var(--cv-control-h, 32px) + 2px) !important;
   min-height: calc(var(--cv-control-h, 32px) + 2px) !important;
+  max-height: calc(var(--cv-control-h, 32px) + 2px) !important;
+  box-sizing: border-box !important;
+  display: inline-flex !important;
+  align-items: center !important;
   margin: -1px 0 !important;
+  vertical-align: top !important;
+  font-family: inherit !important;
+  font-size: 12px !important;
+  line-height: calc(var(--cv-control-h, 32px) - 2px) !important;
+  padding: 0 22px 0 8px !important;
 }
 
 .md-typeset .crysview.cv-host-theme-dark {
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index c0f74bad0..06544102c 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -79,9 +79,10 @@
   }
   #{{ container_id }} .mb-select {
     height: calc(var(--cv-control-h) + 2px); min-height: calc(var(--cv-control-h) + 2px);
-    box-sizing: border-box; margin: -1px 0;
+    max-height: calc(var(--cv-control-h) + 2px); box-sizing: border-box;
+    display: inline-flex; align-items: center; margin: -1px 0; vertical-align: top;
     border: 1px solid var(--cv-panel-border); border-radius: 0;
-    color: var(--cv-control-fg); font-size: 12px; line-height: calc(var(--cv-control-h) - 2px);
+    color: var(--cv-control-fg); font-family: inherit; font-size: 12px; line-height: calc(var(--cv-control-h) - 2px);
     padding: 0 22px 0 8px; cursor: pointer;
     -webkit-appearance: none; -moz-appearance: none; appearance: none;
     background-color: var(--cv-control-bg);
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 4d1298eb3..5b42ccd34 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -629,6 +629,10 @@ def test_colour_scheme_select_matches_button_height(self, patched_theme):
 
         assert 'height: calc(var(--cv-control-h) + 2px);' in html
         assert 'min-height: calc(var(--cv-control-h) + 2px);' in html
+        assert 'max-height: calc(var(--cv-control-h) + 2px);' in html
+        assert 'display: inline-flex; align-items: center;' in html
+        assert 'vertical-align: top;' in html
+        assert 'font-family: inherit;' in html
         assert '--cv-axis-letter-size: 18px;\n  }\n  #' in html
 
     def test_exposes_host_theme_sync_hook(self, patched_theme):

From 6eaea1e0bff1ce6b007d8dc2b9ee4d6ed3e96e06 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 00:52:14 +0200
Subject: [PATCH 130/160] Use unified dark plot background

---
 docs/docs/assets/javascripts/extra.js                           | 2 +-
 docs/docs/assets/stylesheets/extra.css                          | 2 +-
 src/easydiffraction/display/plotters/plotly.py                  | 2 +-
 src/easydiffraction/display/structure/assets/colors.py          | 2 +-
 tests/unit/easydiffraction/display/plotters/test_plotly.py      | 1 +
 .../easydiffraction/display/structure/assets/test_colors.py     | 2 +-
 .../easydiffraction/display/structure/renderers/test_threejs.py | 2 +-
 7 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index 8521f65ea..a46e935b9 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -31,7 +31,7 @@
   function themeColors() {
     if (themeName() === 'dark') {
       return {
-        background: '#111217',
+        background: '#212121',
         foreground: '#e6e8ee',
         grid: 'rgba(110, 145, 190, 0.35)',
         legend: 'rgba(0, 0, 0, 0.5)',
diff --git a/docs/docs/assets/stylesheets/extra.css b/docs/docs/assets/stylesheets/extra.css
index ae7d13f9b..0a2bf6378 100644
--- a/docs/docs/assets/stylesheets/extra.css
+++ b/docs/docs/assets/stylesheets/extra.css
@@ -291,7 +291,7 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
 }
 
 .md-typeset .crysview.cv-host-theme-dark {
-  --cv-scene-bg: #111217 !important;
+  --cv-scene-bg: #212121 !important;
   --cv-scene-fg: #e6e8ee !important;
   --cv-panel-bg: rgba(37, 37, 43, 0.95) !important;
   --cv-panel-border: #52545c !important;
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 2e271eb06..dbae129ca 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -989,7 +989,7 @@ def _theme_sync_post_script() -> str:
 const themeColors = function (theme) {
     if (theme === 'dark') {
         return {
-            background: '#111217',
+            background: '#212121',
             foreground: '#e6e8ee',
             grid: 'rgba(110, 145, 190, 0.35)',
             legend: 'rgba(0, 0, 0, 0.5)',
diff --git a/src/easydiffraction/display/structure/assets/colors.py b/src/easydiffraction/display/structure/assets/colors.py
index 8d15ced82..37913ed2d 100644
--- a/src/easydiffraction/display/structure/assets/colors.py
+++ b/src/easydiffraction/display/structure/assets/colors.py
@@ -21,7 +21,7 @@
 
 # Canvas + annotation colours selected by the detected light/dark theme.
 LIGHT_THEME: dict[str, Rgb] = {'background': (255, 255, 255), 'foreground': (33, 33, 33)}
-DARK_THEME: dict[str, Rgb] = {'background': (20, 20, 24), 'foreground': (235, 235, 235)}
+DARK_THEME: dict[str, Rgb] = {'background': (33, 33, 33), 'foreground': (235, 235, 235)}
 
 
 def color_for(element: str, scheme: str) -> Rgb:
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 3c7fc6047..006aebc9f 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -169,6 +169,7 @@ def __init__(self, html):
     assert 'data-jp-theme-light' in captured['post_script']
     assert 'data-md-color-scheme' in captured['post_script']
     assert 'graphDiv.dataset.edPlotlyTheme' in captured['post_script']
+    assert "background: '#212121'" in captured['post_script']
     assert 'window.Plotly.relayout(graphDiv, update)' in captured['post_script']
     assert 'data-legend-toggle="true"' in captured['post_script']
     assert 'Toggle legend' in captured['post_script']
diff --git a/tests/unit/easydiffraction/display/structure/assets/test_colors.py b/tests/unit/easydiffraction/display/structure/assets/test_colors.py
index 31813c33d..2d723716b 100644
--- a/tests/unit/easydiffraction/display/structure/assets/test_colors.py
+++ b/tests/unit/easydiffraction/display/structure/assets/test_colors.py
@@ -89,7 +89,7 @@ def test_light_theme_values(self):
         assert LIGHT_THEME['foreground'] == (33, 33, 33)
 
     def test_dark_theme_values(self):
-        assert DARK_THEME['background'] == (20, 20, 24)
+        assert DARK_THEME['background'] == (33, 33, 33)
         assert DARK_THEME['foreground'] == (235, 235, 235)
 
     def test_theme_values_all_rgb(self):
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 5b42ccd34..3613dac18 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -715,6 +715,6 @@ def test_dark_theme_embeds_real_canvas_colours(self):
             offline=True,
             dark=True,
         )
-        assert 'rgb(20, 20, 24)' in html  # DARK_THEME background
+        assert 'rgb(33, 33, 33)' in html  # DARK_THEME background
         assert 'rgb(235, 235, 235)' in html  # DARK_THEME foreground
         assert 'dark' in html

From 521b9a36bcee72ed99cca7cad69503238572d902 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 01:03:04 +0200
Subject: [PATCH 131/160] Use transparent plot backgrounds

---
 docs/docs/assets/javascripts/extra.js         |  8 ++++---
 docs/docs/assets/stylesheets/extra.css        | 16 +++++++------
 .../display/plotters/plotly.py                | 23 ++++++++++++++++---
 .../display/structure/assets/colors.py        |  6 ++---
 .../structure/templates/structure.html.j2     |  8 ++++---
 .../display/plotters/test_plotly.py           |  5 +++-
 .../structure/renderers/test_threejs.py       | 16 +++++++------
 7 files changed, 55 insertions(+), 27 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index a46e935b9..87db3038c 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -31,16 +31,18 @@
   function themeColors() {
     if (themeName() === 'dark') {
       return {
-        background: '#212121',
+        background: 'rgba(0, 0, 0, 0)',
         foreground: '#e6e8ee',
         grid: 'rgba(110, 145, 190, 0.35)',
+        hoverBackground: '#212121',
         legend: 'rgba(0, 0, 0, 0.5)',
       }
     }
     return {
-      background: '#ffffff',
+      background: 'rgba(0, 0, 0, 0)',
       foreground: '#222222',
       grid: 'rgba(120, 140, 160, 0.28)',
+      hoverBackground: '#ffffff',
       legend: 'rgba(255, 255, 255, 0.5)',
     }
   }
@@ -70,7 +72,7 @@
         'title.font.color': colors.foreground,
         'legend.bgcolor': colors.legend,
         'legend.font.color': colors.foreground,
-        'hoverlabel.bgcolor': colors.background,
+        'hoverlabel.bgcolor': colors.hoverBackground,
         'hoverlabel.font.color': colors.foreground,
       }
       plotlyAxisNames(plot).forEach((key) => {
diff --git a/docs/docs/assets/stylesheets/extra.css b/docs/docs/assets/stylesheets/extra.css
index 0a2bf6378..70aeda52f 100644
--- a/docs/docs/assets/stylesheets/extra.css
+++ b/docs/docs/assets/stylesheets/extra.css
@@ -291,8 +291,9 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
 }
 
 .md-typeset .crysview.cv-host-theme-dark {
-  --cv-scene-bg: #212121 !important;
+  --cv-scene-bg: transparent !important;
   --cv-scene-fg: #e6e8ee !important;
+  --cv-label-shadow-bg: #212121 !important;
   --cv-panel-bg: rgba(37, 37, 43, 0.95) !important;
   --cv-panel-border: #52545c !important;
   --cv-panel-fg: var(--cv-scene-fg) !important;
@@ -302,13 +303,14 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
   --cv-control-active-border: #63708a !important;
   --cv-control-fg: var(--cv-scene-fg) !important;
   --cv-control-muted: #8d929e !important;
-  background: var(--cv-scene-bg) !important;
+  background: transparent !important;
   color: var(--cv-scene-fg) !important;
 }
 
 .md-typeset .crysview.cv-host-theme-light {
-  --cv-scene-bg: #fff !important;
+  --cv-scene-bg: transparent !important;
   --cv-scene-fg: #222 !important;
+  --cv-label-shadow-bg: #fff !important;
   --cv-panel-bg: rgba(255, 255, 255, 0.94) !important;
   --cv-panel-border: #e2e2e2 !important;
   --cv-panel-fg: #222 !important;
@@ -318,7 +320,7 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
   --cv-control-active-border: #c6d0e2 !important;
   --cv-control-fg: #2a3f5f !important;
   --cv-control-muted: #b9bdc6 !important;
-  background: var(--cv-scene-bg) !important;
+  background: transparent !important;
   color: var(--cv-scene-fg) !important;
 }
 
@@ -326,9 +328,9 @@ Adjust the margins and paddings to fit the defaults in MkDocs Material and do no
 .md-typeset .crysview.cv-host-theme-light .cv-atom-label {
   color: var(--cv-scene-fg) !important;
   text-shadow:
-    0 0 3px var(--cv-scene-bg),
-    0 0 3px var(--cv-scene-bg),
-    0 0 3px var(--cv-scene-bg) !important;
+    0 0 3px var(--cv-label-shadow-bg),
+    0 0 3px var(--cv-label-shadow-bg),
+    0 0 3px var(--cv-label-shadow-bg) !important;
 }
 
 /* Extra styling the panda dataframes, on top of the style included in the code */
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index dbae129ca..9e82a2c5c 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -95,6 +95,7 @@
 PREDICTIVE_DRAW_ARRAY_NDIM = 2
 FIXED_ASPECT_WRAPPER_META_KEY = 'fixed_aspect_wrapper'
 FIXED_ASPECT_WRAPPER_CLASS_NAME = 'ed-fixed-aspect-plotly-wrapper'
+TRANSPARENT_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0)'
 
 
 def single_crystal_axis_range(
@@ -989,16 +990,18 @@ def _theme_sync_post_script() -> str:
 const themeColors = function (theme) {
     if (theme === 'dark') {
         return {
-            background: '#212121',
+            background: 'rgba(0, 0, 0, 0)',
             foreground: '#e6e8ee',
             grid: 'rgba(110, 145, 190, 0.35)',
+            hoverBackground: '#212121',
             legend: 'rgba(0, 0, 0, 0.5)',
         };
     }
     return {
-        background: '#ffffff',
+        background: 'rgba(0, 0, 0, 0)',
         foreground: '#222222',
         grid: 'rgba(120, 140, 160, 0.28)',
+        hoverBackground: '#ffffff',
         legend: 'rgba(255, 255, 255, 0.5)',
     };
 };
@@ -1033,7 +1036,7 @@ def _theme_sync_post_script() -> str:
         'title.font.color': colors.foreground,
         'legend.bgcolor': colors.legend,
         'legend.font.color': colors.foreground,
-        'hoverlabel.bgcolor': colors.background,
+        'hoverlabel.bgcolor': colors.hoverBackground,
         'hoverlabel.font.color': colors.foreground,
     };
 
@@ -1244,6 +1247,7 @@ def _show_figure(
             A :class:`plotly.graph_objects.Figure` to display.
         """
         config = self._get_config()
+        self._apply_transparent_background(fig)
 
         if in_pycharm() or display is None or HTML is None:
             fig.show(config=config)
@@ -1299,6 +1303,7 @@ def serialize_html(
             legend_bgcolor = cls._legend_background_color_for_template(force_template)
             if legend_bgcolor is not None:
                 fig.update_layout(legend={'bgcolor': legend_bgcolor})
+        cls._apply_transparent_background(fig)
         html_fig = pio.to_html(
             fig,
             include_plotlyjs=include_plotlyjs,
@@ -1308,6 +1313,16 @@ def serialize_html(
         )
         return cls._wrap_html_figure(fig, html_fig)
 
+    @staticmethod
+    def _apply_transparent_background(fig: object) -> None:
+        """Make Plotly paper and plot areas inherit their parent."""
+        update_layout = getattr(fig, 'update_layout', None)
+        if callable(update_layout):
+            update_layout(
+                paper_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
+                plot_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
+            )
+
     @classmethod
     def _get_layout(
         cls,
@@ -1380,6 +1395,8 @@ def _get_layout(
                 'text': title,
                 'font': {'size': TITLE_FONT_SIZE},
             },
+            paper_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
+            plot_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
             legend={
                 'bgcolor': cls._legend_background_color(),
                 'xanchor': 'right',
diff --git a/src/easydiffraction/display/structure/assets/colors.py b/src/easydiffraction/display/structure/assets/colors.py
index 37913ed2d..5474c43aa 100644
--- a/src/easydiffraction/display/structure/assets/colors.py
+++ b/src/easydiffraction/display/structure/assets/colors.py
@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
 # SPDX-License-Identifier: BSD-3-Clause
 """
-Per-element colours, axis colours, and theme-dependent canvas colours.
+Per-element colours, axis colours, and theme-dependent contrast colours.
 """
 
 from __future__ import annotations
@@ -19,7 +19,7 @@
 # Neutral wedge colour for the vacant fraction of a mixed site.
 VACANCY_COLOR: Rgb = (210, 210, 210)
 
-# Canvas + annotation colours selected by the detected light/dark theme.
+# Parent-independent annotation contrast colours for light/dark themes.
 LIGHT_THEME: dict[str, Rgb] = {'background': (255, 255, 255), 'foreground': (33, 33, 33)}
 DARK_THEME: dict[str, Rgb] = {'background': (33, 33, 33), 'foreground': (235, 235, 235)}
 
@@ -54,7 +54,7 @@ def color_for(element: str, scheme: str) -> Rgb:
 
 def theme_colors(*, dark: bool) -> dict[str, Rgb]:
     """
-    Return canvas/annotation colours for the detected theme.
+    Return annotation contrast colours for the detected theme.
 
     Parameters
     ----------
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 06544102c..76d6ca42d 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -21,8 +21,9 @@
     --cv-axis-letter-size: 18px;
   }
   #{{ container_id }}.cv-theme-dark {
-    --cv-scene-bg: {{ dark_background }};
+    --cv-scene-bg: transparent;
     --cv-scene-fg: {{ dark_foreground }};
+    --cv-label-shadow-bg: {{ dark_background }};
     --cv-panel-bg: rgba(37, 37, 43, 0.95);
     --cv-panel-border: #52545c;
     --cv-panel-fg: var(--cv-scene-fg);
@@ -36,8 +37,9 @@
     --cv-select-arrow: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'%3E%3Cpath d='M2 4l3 3 3-3' fill='none' stroke='%23ebebeb' stroke-width='1.3'/%3E%3C/svg%3E");
   }
   #{{ container_id }}.cv-theme-light {
-    --cv-scene-bg: {{ light_background }};
+    --cv-scene-bg: transparent;
     --cv-scene-fg: {{ light_foreground }};
+    --cv-label-shadow-bg: {{ light_background }};
     --cv-panel-bg: rgba(255, 255, 255, 0.94);
     --cv-panel-border: #e2e2e2;
     --cv-panel-fg: #222;
@@ -107,7 +109,7 @@
   }
   #{{ container_id }} .cv-atom-label {
     font-size: 11px; font-weight: 600; color: var(--cv-scene-fg);
-    text-shadow: 0 0 3px var(--cv-scene-bg), 0 0 3px var(--cv-scene-bg), 0 0 3px var(--cv-scene-bg);
+    text-shadow: 0 0 3px var(--cv-label-shadow-bg), 0 0 3px var(--cv-label-shadow-bg), 0 0 3px var(--cv-label-shadow-bg);
     pointer-events: none; white-space: nowrap;
   }
 </style>
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 006aebc9f..59d87a794 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -21,6 +21,8 @@ def test_get_layout_sets_title_and_axis_title_font_sizes():
     assert layout.title.font.size == pp.TITLE_FONT_SIZE
     assert layout.xaxis.title.font.size == pp.AXIS_TITLE_FONT_SIZE
     assert layout.yaxis.title.font.size == pp.AXIS_TITLE_FONT_SIZE
+    assert layout.paper_bgcolor == pp.TRANSPARENT_BACKGROUND_COLOR
+    assert layout.plot_bgcolor == pp.TRANSPARENT_BACKGROUND_COLOR
 
 
 def test_get_trace_and_plot(monkeypatch):
@@ -169,7 +171,8 @@ def __init__(self, html):
     assert 'data-jp-theme-light' in captured['post_script']
     assert 'data-md-color-scheme' in captured['post_script']
     assert 'graphDiv.dataset.edPlotlyTheme' in captured['post_script']
-    assert "background: '#212121'" in captured['post_script']
+    assert "background: 'rgba(0, 0, 0, 0)'" in captured['post_script']
+    assert "hoverBackground: '#212121'" in captured['post_script']
     assert 'window.Plotly.relayout(graphDiv, update)' in captured['post_script']
     assert 'data-legend-toggle="true"' in captured['post_script']
     assert 'Toggle legend' in captured['post_script']
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 3613dac18..62743b202 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -676,8 +676,8 @@ class TestRenderUnpatchedIntegration:
 
     These tests deliberately omit the ``patched_theme`` fixture so the
     production ``theme_colors(dark=dark)`` call runs for real, proving the
-    keyword-only signature is invoked correctly and its light/dark canvas
-    colours reach the document.
+    keyword-only signature is invoked correctly and its light/dark
+    contrast colours reach the document.
     """
 
     def test_render_returns_html_document(self):
@@ -694,20 +694,21 @@ def test_render_returns_html_document(self):
         assert '>' in html
         assert 'crysview-' in html
 
-    def test_light_theme_embeds_real_canvas_colours(self):
+    def test_light_theme_embeds_transparent_canvas_and_contrast_colours(self):
         # ``theme_colors(dark=False)`` returns LIGHT_THEME; its background
-        # and foreground must be wired into the document.
+        # and foreground must be wired into the document for labels.
         html = ThreeJsStructureRenderer().render(
             _identity_scene(),
             features=frozenset(),
             offline=True,
             dark=False,
         )
-        assert 'rgb(255, 255, 255)' in html  # LIGHT_THEME background
+        assert '--cv-scene-bg: transparent;' in html
+        assert '--cv-label-shadow-bg: rgb(255, 255, 255);' in html
         assert 'rgb(33, 33, 33)' in html  # LIGHT_THEME foreground
         assert 'light' in html
 
-    def test_dark_theme_embeds_real_canvas_colours(self):
+    def test_dark_theme_embeds_transparent_canvas_and_contrast_colours(self):
         # ``theme_colors(dark=True)`` returns DARK_THEME instead.
         html = ThreeJsStructureRenderer().render(
             _identity_scene(),
@@ -715,6 +716,7 @@ def test_dark_theme_embeds_real_canvas_colours(self):
             offline=True,
             dark=True,
         )
-        assert 'rgb(33, 33, 33)' in html  # DARK_THEME background
+        assert '--cv-scene-bg: transparent;' in html
+        assert '--cv-label-shadow-bg: rgb(33, 33, 33);' in html
         assert 'rgb(235, 235, 235)' in html  # DARK_THEME foreground
         assert 'dark' in html

From 92d5b12ab57e943235bcbc5b4e150e4912749274 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 09:33:00 +0200
Subject: [PATCH 132/160] Clarify structure-view settings ADR coverage

---
 .../adrs/accepted/crysview-structure-visualization.md    | 6 ++++++
 docs/dev/adrs/accepted/value-selector-discovery.md       | 9 +++++++++
 docs/dev/plans/structure-view-settings.md                | 9 +++++++--
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/docs/dev/adrs/accepted/crysview-structure-visualization.md b/docs/dev/adrs/accepted/crysview-structure-visualization.md
index d98478b2d..cd25c4554 100644
--- a/docs/dev/adrs/accepted/crysview-structure-visualization.md
+++ b/docs/dev/adrs/accepted/crysview-structure-visualization.md
@@ -6,6 +6,12 @@ Accepted.
 
 **Date:** 2026-05-31
 
+**Implementation note:** The later
+[`structure-view-settings`](../../plans/structure-view-settings.md) plan
+split structure-view configuration into `rendering_structure`,
+`structure_view`, and `structure_style`. This ADR reflects that final
+surface; no separate `structure-view-settings` ADR exists.
+
 ## Context
 
 EasyDiffraction refines crystal structures but offers no interactive 3D
diff --git a/docs/dev/adrs/accepted/value-selector-discovery.md b/docs/dev/adrs/accepted/value-selector-discovery.md
index c7bbc7831..8a24d8d2d 100644
--- a/docs/dev/adrs/accepted/value-selector-discovery.md
+++ b/docs/dev/adrs/accepted/value-selector-discovery.md
@@ -12,6 +12,15 @@ Accepted.
 
 User-facing API.
 
+## Implementation Note
+
+This ADR was implemented through the
+[`structure-view-settings`](../../plans/structure-view-settings.md)
+plan. That plan also amended
+[`crysview-structure-visualization.md`](crysview-structure-visualization.md)
+for the structure-view settings split; no separate
+`structure-view-settings` ADR exists.
+
 ## Context
 
 EasyDiffraction is used by scientists who explore the API in notebooks,
diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
index 65ae9b6c6..e5dde4cd7 100644
--- a/docs/dev/plans/structure-view-settings.md
+++ b/docs/dev/plans/structure-view-settings.md
@@ -12,7 +12,8 @@ structure-view settings on top of it.
 > `crysview-structure-visualization` branch. The
 > `value-selector-discovery` and `crysview-structure-visualization` ADRs
 > have both been promoted to accepted. This file is retained as the
-> implementation and verification record.
+> implementation and verification record; no same-slug
+> `structure-view-settings` ADR is needed.
 
 **Branch & PR (deliberate exception).** §Planning asks for a flat-slug
 `structure-view-settings` branch off `develop`. This plan deliberately
@@ -26,7 +27,11 @@ later split from the visualization PR, a dedicated
 
 ## ADR
 
-This plan completed the ADR work that was added during planning:
+This plan completed the ADR work that was added during planning. Its two
+architectural decisions intentionally live in existing accepted ADRs:
+there is no separate `structure-view-settings` ADR because the selector
+convention is project-wide and the settings split is part of the
+crysview public surface.
 
 - **Accepted ADR — `value-selector-discovery`**. Recognises a **fourth**
   selector shape beyond the three category-level families in

From dd794fbad636b8637610a5b6a9180edda9638f16 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 09:38:12 +0200
Subject: [PATCH 133/160] Centralize display theme styling

---
 docs/docs/assets/javascripts/extra.js         |  72 ++++--
 .../display/plotters/plotly.py                | 220 ++++++++++++++----
 src/easydiffraction/display/tablers/base.py   |   6 +-
 src/easydiffraction/display/tablers/pandas.py | 107 ++++++++-
 src/easydiffraction/display/theme.py          | 108 +++++++++
 src/easydiffraction/report/style.py           |  17 +-
 .../display/plotters/test_plotly.py           |  54 ++++-
 .../structure/renderers/test_threejs.py       |   4 +-
 .../display/tablers/test_base.py              |   3 +-
 .../display/tablers/test_pandas.py            |  11 +-
 .../easydiffraction/display/test_theme.py     |  26 +++
 .../unit/easydiffraction/report/test_style.py |   3 +-
 12 files changed, 546 insertions(+), 85 deletions(-)
 create mode 100644 src/easydiffraction/display/theme.py
 create mode 100644 tests/unit/easydiffraction/display/test_theme.py

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index 87db3038c..2246901d0 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -31,19 +31,21 @@
   function themeColors() {
     if (themeName() === 'dark') {
       return {
-        background: 'rgba(0, 0, 0, 0)',
-        foreground: '#e6e8ee',
-        grid: 'rgba(110, 145, 190, 0.35)',
-        hoverBackground: '#212121',
-        legend: 'rgba(0, 0, 0, 0.5)',
+        background: '#111', // DARK_BACKGROUND_COLOR
+        foreground: '#e6e8ee', // DARK_FOREGROUND_COLOR
+        axisFrame: '#333', // DARK_AXIS_FRAME_COLOR
+        innerTickGrid: '#1e1e1e', // DARK_INNER_TICK_GRID_COLOR
+        hoverBackground: '#212121', // DARK_HOVER_BACKGROUND_COLOR
+        legend: 'rgba(0, 0, 0, 0.5)', // DARK_LEGEND_BACKGROUND_COLOR
       }
     }
     return {
-      background: 'rgba(0, 0, 0, 0)',
-      foreground: '#222222',
-      grid: 'rgba(120, 140, 160, 0.28)',
-      hoverBackground: '#ffffff',
-      legend: 'rgba(255, 255, 255, 0.5)',
+      background: '#fff', // LIGHT_BACKGROUND_COLOR
+      foreground: '#222222', // LIGHT_FOREGROUND_COLOR
+      axisFrame: '#e2e2e2', // LIGHT_AXIS_FRAME_COLOR
+      innerTickGrid: '#f2f2f2', // LIGHT_INNER_TICK_GRID_COLOR
+      hoverBackground: '#ffffff', // LIGHT_HOVER_BACKGROUND_COLOR
+      legend: 'rgba(255, 255, 255, 0.5)', // LIGHT_LEGEND_BACKGROUND_COLOR
     }
   }
 
@@ -60,11 +62,46 @@
     return names
   }
 
+  function installPlotlyModebarThemeStyle() {
+    const styleId = 'ed-plotly-modebar-theme-style'
+    if (document.getElementById(styleId)) return
+
+    const style = document.createElement('style')
+    style.id = styleId
+    style.textContent = [
+      '.plotly-graph-div.ed-plotly-themed-modebar .modebar-btn path {',
+      '  fill: var(--ed-plotly-modebar-icon-color) !important;',
+      '  opacity: var(--ed-plotly-modebar-icon-opacity) !important;',
+      '}',
+      '.plotly-graph-div.ed-plotly-themed-modebar .modebar-btn:hover path,',
+      '.plotly-graph-div.ed-plotly-themed-modebar .modebar-btn.active path {',
+      '  fill: var(--ed-plotly-modebar-icon-color) !important;',
+      '  opacity: var(--ed-plotly-modebar-icon-hover-opacity) !important;',
+      '}',
+    ].join('\n')
+    document.head.appendChild(style)
+  }
+
+  function syncPlotlyModebarTheme(plot, colors) {
+    installPlotlyModebarThemeStyle()
+    plot.classList.add('ed-plotly-themed-modebar')
+    plot.style.setProperty('--ed-plotly-modebar-icon-color', colors.foreground)
+    plot.style.setProperty(
+      '--ed-plotly-modebar-icon-opacity',
+      themeName() === 'dark' ? '0.62' : '0.42',
+    )
+    plot.style.setProperty(
+      '--ed-plotly-modebar-icon-hover-opacity',
+      themeName() === 'dark' ? '0.95' : '0.85',
+    )
+  }
+
   function syncPlotlyTheme() {
     if (!window.Plotly) return
     const colors = themeColors()
     document.querySelectorAll('.plotly-graph-div').forEach((plot) => {
       if (!plot.layout && !plot._fullLayout) return
+      syncPlotlyModebarTheme(plot, colors)
       const update = {
         paper_bgcolor: colors.background,
         plot_bgcolor: colors.background,
@@ -77,9 +114,9 @@
       }
       plotlyAxisNames(plot).forEach((key) => {
         update[`${key}.color`] = colors.foreground
-        update[`${key}.gridcolor`] = colors.grid
-        update[`${key}.linecolor`] = colors.grid
-        update[`${key}.zerolinecolor`] = colors.grid
+        update[`${key}.gridcolor`] = colors.innerTickGrid
+        update[`${key}.linecolor`] = colors.axisFrame
+        update[`${key}.zerolinecolor`] = colors.innerTickGrid
         update[`${key}.title.font.color`] = colors.foreground
         update[`${key}.tickfont.color`] = colors.foreground
       })
@@ -98,6 +135,14 @@
     })
   }
 
+  function syncPandasTableTheme() {
+    const colors = themeColors()
+    document.querySelectorAll('.ed-themed-table').forEach((table) => {
+      // TABLE_AXIS_FRAME_CSS_VAR
+      table.style.setProperty('--ed-axis-frame-color', colors.axisFrame)
+    })
+  }
+
   function syncCrysviewTheme() {
     const next = themeName()
     document.querySelectorAll('.crysview').forEach((viewer) => {
@@ -111,6 +156,7 @@
 
   function syncThemeAwareOutputs() {
     syncPlotlyTheme()
+    syncPandasTableTheme()
     syncCrysviewTheme()
   }
 
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 9e82a2c5c..7055651bc 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -30,6 +30,21 @@
 from easydiffraction.display.plotters.base import BraggTickSet
 from easydiffraction.display.plotters.base import PlotterBase
 from easydiffraction.display.plotters.base import PowderMeasVsCalcSpec
+from easydiffraction.display.theme import DARK_AXIS_FRAME_COLOR
+from easydiffraction.display.theme import DARK_BACKGROUND_COLOR
+from easydiffraction.display.theme import DARK_FOREGROUND_COLOR
+from easydiffraction.display.theme import DARK_HOVER_BACKGROUND_COLOR
+from easydiffraction.display.theme import DARK_INNER_TICK_GRID_COLOR
+from easydiffraction.display.theme import DARK_LEGEND_BACKGROUND_COLOR
+from easydiffraction.display.theme import LIGHT_AXIS_FRAME_COLOR
+from easydiffraction.display.theme import LIGHT_BACKGROUND_COLOR
+from easydiffraction.display.theme import LIGHT_FOREGROUND_COLOR
+from easydiffraction.display.theme import LIGHT_HOVER_BACKGROUND_COLOR
+from easydiffraction.display.theme import LIGHT_INNER_TICK_GRID_COLOR
+from easydiffraction.display.theme import LIGHT_LEGEND_BACKGROUND_COLOR
+from easydiffraction.display.theme import DisplayThemeColors
+from easydiffraction.display.theme import display_theme_colors
+from easydiffraction.display.theme import display_theme_colors_for_template
 from easydiffraction.utils._vendored.theme_detect import is_dark
 from easydiffraction.utils.environment import in_jupyter
 from easydiffraction.utils.environment import in_pycharm
@@ -51,10 +66,6 @@
 SINGLE_CRYSTAL_MARKER_LINE_WIDTH = 0.5
 MEASURED_ERROR_BAR_THICKNESS = 0.5
 MEASURED_ERROR_BAR_WIDTH = 2
-LIGHT_AXIS_FRAME_COLOR = 'rgba(120, 140, 160, 0.28)'
-DARK_AXIS_FRAME_COLOR = 'rgba(110, 145, 190, 0.35)'
-LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
-DARK_LEGEND_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0.5)'
 # Single source for the y=x reference-line colour, shared with the
 # report axis gray (report.style.REPORT_AXIS_RGB) and imported by
 # report.fit_plot so the diagonal looks identical in the Plotly and
@@ -87,6 +98,8 @@
 COMPOSITE_MARGIN_BOTTOM = 45
 TITLE_FONT_SIZE = 14
 AXIS_TITLE_FONT_SIZE = 12
+X_AXIS_TICK_LABEL_STANDOFF = 5
+Y_AXIS_TICK_LABEL_STANDOFF = 6
 PREDICTIVE_BAND_COLOR = 'rgba(214, 39, 40, 0.14)'
 PREDICTIVE_BAND_EDGE_COLOR = 'rgba(214, 39, 40, 0.45)'
 PREDICTIVE_DRAW_COLOR = 'rgba(140, 140, 140, 0.18)'
@@ -95,7 +108,6 @@
 PREDICTIVE_DRAW_ARRAY_NDIM = 2
 FIXED_ASPECT_WRAPPER_META_KEY = 'fixed_aspect_wrapper'
 FIXED_ASPECT_WRAPPER_CLASS_NAME = 'ed-fixed-aspect-plotly-wrapper'
-TRANSPARENT_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0)'
 
 
 def single_crystal_axis_range(
@@ -278,37 +290,52 @@ def _correlation_grid_color(cls) -> str:
         str
             RGBA color string tuned for the active theme.
         """
-        if cls._is_dark_mode():
-            return DARK_AXIS_FRAME_COLOR
-        return LIGHT_AXIS_FRAME_COLOR
+        return cls._theme_colors().axis_frame
 
     @classmethod
     def _axis_frame_color(cls) -> str:
         """Return the shared axis-frame color for Plotly figures."""
         return cls._correlation_grid_color()
 
+    @classmethod
+    def _theme_colors(cls) -> DisplayThemeColors:
+        """Return display theme colors for the active theme."""
+        return display_theme_colors(is_dark_theme=cls._is_dark_mode())
+
+    @classmethod
+    def _background_color(cls) -> str:
+        """Return the plot background color for the active theme."""
+        return cls._theme_colors().background
+
+    @classmethod
+    def _inner_tick_grid_color(cls) -> str:
+        """Return the inner tick-grid color for the active theme."""
+        return cls._theme_colors().inner_tick_grid
+
     @classmethod
     def _legend_background_color(cls) -> str:
         """Return a half-transparent legend background color."""
-        if cls._is_dark_mode():
-            return DARK_LEGEND_BACKGROUND_COLOR
-        return LIGHT_LEGEND_BACKGROUND_COLOR
+        return cls._theme_colors().legend_background
+
+    @staticmethod
+    def _background_color_for_template(template: str) -> str | None:
+        theme_colors = display_theme_colors_for_template(template)
+        return theme_colors.background if theme_colors is not None else None
 
     @staticmethod
     def _axis_frame_color_for_template(template: str) -> str | None:
-        if template == 'plotly_white':
-            return LIGHT_AXIS_FRAME_COLOR
-        if template == 'plotly_dark':
-            return DARK_AXIS_FRAME_COLOR
-        return None
+        theme_colors = display_theme_colors_for_template(template)
+        return theme_colors.axis_frame if theme_colors is not None else None
+
+    @staticmethod
+    def _inner_tick_grid_color_for_template(template: str) -> str | None:
+        theme_colors = display_theme_colors_for_template(template)
+        return theme_colors.inner_tick_grid if theme_colors is not None else None
 
     @staticmethod
     def _legend_background_color_for_template(template: str) -> str | None:
-        if template == 'plotly_white':
-            return LIGHT_LEGEND_BACKGROUND_COLOR
-        if template == 'plotly_dark':
-            return DARK_LEGEND_BACKGROUND_COLOR
-        return None
+        theme_colors = display_theme_colors_for_template(template)
+        return theme_colors.legend_background if theme_colors is not None else None
 
     def plot_correlation_heatmap(
         self,
@@ -421,6 +448,7 @@ def plot_correlation_heatmap(
             tickmode='array',
             tickvals=x_centers.tolist(),
             ticktext=corr_df.columns.tolist(),
+            ticklabelstandoff=X_AXIS_TICK_LABEL_STANDOFF,
             range=[0.0, float(num_cols)],
             showgrid=False,
             showline=False,
@@ -434,7 +462,7 @@ def plot_correlation_heatmap(
             tickmode='array',
             tickvals=y_centers.tolist(),
             ticktext=corr_df.index.tolist(),
-            ticklabelstandoff=8,
+            ticklabelstandoff=Y_AXIS_TICK_LABEL_STANDOFF,
             range=[float(num_rows), 0.0],
             showgrid=False,
             showline=False,
@@ -956,7 +984,7 @@ def _theme_sync_post_script() -> str:
         """
         Return client-side code for host dark/light theme changes.
         """
-        return r"""
+        script = r"""
 const graphDiv = document.getElementById('{plot_id}');
 if (!graphDiv || !window.Plotly) {
     return;
@@ -965,7 +993,10 @@ def _theme_sync_post_script() -> str:
 const hostTheme = function () {
     const materialScheme = (
         (document.body && document.body.getAttribute('data-md-color-scheme'))
-        || (document.documentElement && document.documentElement.getAttribute('data-md-color-scheme'))
+        || (
+            document.documentElement
+            && document.documentElement.getAttribute('data-md-color-scheme')
+        )
     );
     if (materialScheme === 'slate') {
         return 'dark';
@@ -976,7 +1007,10 @@ def _theme_sync_post_script() -> str:
 
     const jupyterThemeLight = (
         (document.body && document.body.getAttribute('data-jp-theme-light'))
-        || (document.documentElement && document.documentElement.getAttribute('data-jp-theme-light'))
+        || (
+            document.documentElement
+            && document.documentElement.getAttribute('data-jp-theme-light')
+        )
     );
     if (jupyterThemeLight === 'false') {
         return 'dark';
@@ -990,19 +1024,21 @@ def _theme_sync_post_script() -> str:
 const themeColors = function (theme) {
     if (theme === 'dark') {
         return {
-            background: 'rgba(0, 0, 0, 0)',
-            foreground: '#e6e8ee',
-            grid: 'rgba(110, 145, 190, 0.35)',
-            hoverBackground: '#212121',
-            legend: 'rgba(0, 0, 0, 0.5)',
+            background: '__DARK_BACKGROUND_COLOR__',
+            foreground: '__DARK_FOREGROUND_COLOR__',
+            axisFrame: '__DARK_AXIS_FRAME_COLOR__',
+            innerTickGrid: '__DARK_INNER_TICK_GRID_COLOR__',
+            hoverBackground: '__DARK_HOVER_BACKGROUND_COLOR__',
+            legend: '__DARK_LEGEND_BACKGROUND_COLOR__',
         };
     }
     return {
-        background: 'rgba(0, 0, 0, 0)',
-        foreground: '#222222',
-        grid: 'rgba(120, 140, 160, 0.28)',
-        hoverBackground: '#ffffff',
-        legend: 'rgba(255, 255, 255, 0.5)',
+        background: '__LIGHT_BACKGROUND_COLOR__',
+        foreground: '__LIGHT_FOREGROUND_COLOR__',
+        axisFrame: '__LIGHT_AXIS_FRAME_COLOR__',
+        innerTickGrid: '__LIGHT_INNER_TICK_GRID_COLOR__',
+        hoverBackground: '__LIGHT_HOVER_BACKGROUND_COLOR__',
+        legend: '__LIGHT_LEGEND_BACKGROUND_COLOR__',
     };
 };
 
@@ -1021,14 +1057,52 @@ def _theme_sync_post_script() -> str:
     return names;
 };
 
+const installModebarThemeStyle = function () {
+    const styleId = 'ed-plotly-modebar-theme-style';
+    if (document.getElementById(styleId)) {
+        return;
+    }
+
+    const style = document.createElement('style');
+    style.id = styleId;
+    style.textContent = [
+        '.plotly-graph-div.ed-plotly-themed-modebar .modebar-btn path {',
+        '    fill: var(--ed-plotly-modebar-icon-color) !important;',
+        '    opacity: var(--ed-plotly-modebar-icon-opacity) !important;',
+        '}',
+        '.plotly-graph-div.ed-plotly-themed-modebar .modebar-btn:hover path,',
+        '.plotly-graph-div.ed-plotly-themed-modebar .modebar-btn.active path {',
+        '    fill: var(--ed-plotly-modebar-icon-color) !important;',
+        '    opacity: var(--ed-plotly-modebar-icon-hover-opacity) !important;',
+        '}',
+    ].join('\n');
+    document.head.appendChild(style);
+};
+
+const applyModebarTheme = function (theme, colors) {
+    installModebarThemeStyle();
+    graphDiv.classList.add('ed-plotly-themed-modebar');
+    graphDiv.style.setProperty('--ed-plotly-modebar-icon-color', colors.foreground);
+    graphDiv.style.setProperty(
+        '--ed-plotly-modebar-icon-opacity',
+        theme === 'dark' ? '0.62' : '0.42',
+    );
+    graphDiv.style.setProperty(
+        '--ed-plotly-modebar-icon-hover-opacity',
+        theme === 'dark' ? '0.95' : '0.85',
+    );
+};
+
 const applyTheme = function () {
     const theme = hostTheme();
+    const colors = themeColors(theme);
+    applyModebarTheme(theme, colors);
+
     if (graphDiv.dataset.edPlotlyTheme === theme) {
         return;
     }
     graphDiv.dataset.edPlotlyTheme = theme;
 
-    const colors = themeColors(theme);
     const update = {
         paper_bgcolor: colors.background,
         plot_bgcolor: colors.background,
@@ -1042,9 +1116,9 @@ def _theme_sync_post_script() -> str:
 
     axisNames().forEach(function (axisName) {
         update[axisName + '.color'] = colors.foreground;
-        update[axisName + '.gridcolor'] = colors.grid;
-        update[axisName + '.linecolor'] = colors.grid;
-        update[axisName + '.zerolinecolor'] = colors.grid;
+        update[axisName + '.gridcolor'] = colors.innerTickGrid;
+        update[axisName + '.linecolor'] = colors.axisFrame;
+        update[axisName + '.zerolinecolor'] = colors.innerTickGrid;
         update[axisName + '.title.font.color'] = colors.foreground;
         update[axisName + '.tickfont.color'] = colors.foreground;
     });
@@ -1091,6 +1165,21 @@ def _theme_sync_post_script() -> str:
 
 applyTheme();
 """
+        return (
+            script
+            .replace('__DARK_BACKGROUND_COLOR__', DARK_BACKGROUND_COLOR)
+            .replace('__DARK_FOREGROUND_COLOR__', DARK_FOREGROUND_COLOR)
+            .replace('__DARK_AXIS_FRAME_COLOR__', DARK_AXIS_FRAME_COLOR)
+            .replace('__DARK_INNER_TICK_GRID_COLOR__', DARK_INNER_TICK_GRID_COLOR)
+            .replace('__DARK_HOVER_BACKGROUND_COLOR__', DARK_HOVER_BACKGROUND_COLOR)
+            .replace('__DARK_LEGEND_BACKGROUND_COLOR__', DARK_LEGEND_BACKGROUND_COLOR)
+            .replace('__LIGHT_BACKGROUND_COLOR__', LIGHT_BACKGROUND_COLOR)
+            .replace('__LIGHT_FOREGROUND_COLOR__', LIGHT_FOREGROUND_COLOR)
+            .replace('__LIGHT_AXIS_FRAME_COLOR__', LIGHT_AXIS_FRAME_COLOR)
+            .replace('__LIGHT_INNER_TICK_GRID_COLOR__', LIGHT_INNER_TICK_GRID_COLOR)
+            .replace('__LIGHT_HOVER_BACKGROUND_COLOR__', LIGHT_HOVER_BACKGROUND_COLOR)
+            .replace('__LIGHT_LEGEND_BACKGROUND_COLOR__', LIGHT_LEGEND_BACKGROUND_COLOR)
+        )
 
     @classmethod
     def _html_post_script(cls, fig: object) -> str | None:
@@ -1247,7 +1336,7 @@ def _show_figure(
             A :class:`plotly.graph_objects.Figure` to display.
         """
         config = self._get_config()
-        self._apply_transparent_background(fig)
+        self._apply_background_color(fig)
 
         if in_pycharm() or display is None or HTML is None:
             fig.show(config=config)
@@ -1289,21 +1378,34 @@ def serialize_html(
         str
             Inline HTML containing the figure and helper scripts.
         """
+        background_color = None
         if force_template is not None:
             fig.update_layout(template=force_template)
+            background_color = cls._background_color_for_template(force_template)
             resolved_axis_color = axis_frame_color
             if resolved_axis_color is None:
                 resolved_axis_color = cls._axis_frame_color_for_template(force_template)
             if resolved_axis_color is not None:
                 fig.update_xaxes(linecolor=resolved_axis_color)
                 fig.update_yaxes(linecolor=resolved_axis_color)
-            if grid_color is not None:
-                fig.update_xaxes(gridcolor=grid_color)
-                fig.update_yaxes(gridcolor=grid_color)
+            resolved_grid_color = grid_color
+            if resolved_grid_color is None:
+                resolved_grid_color = cls._inner_tick_grid_color_for_template(
+                    force_template,
+                )
+            if resolved_grid_color is not None:
+                fig.update_xaxes(
+                    gridcolor=resolved_grid_color,
+                    zerolinecolor=resolved_grid_color,
+                )
+                fig.update_yaxes(
+                    gridcolor=resolved_grid_color,
+                    zerolinecolor=resolved_grid_color,
+                )
             legend_bgcolor = cls._legend_background_color_for_template(force_template)
             if legend_bgcolor is not None:
                 fig.update_layout(legend={'bgcolor': legend_bgcolor})
-        cls._apply_transparent_background(fig)
+        cls._apply_background_color(fig, background_color=background_color)
         html_fig = pio.to_html(
             fig,
             include_plotlyjs=include_plotlyjs,
@@ -1313,14 +1415,22 @@ def serialize_html(
         )
         return cls._wrap_html_figure(fig, html_fig)
 
-    @staticmethod
-    def _apply_transparent_background(fig: object) -> None:
-        """Make Plotly paper and plot areas inherit their parent."""
+    @classmethod
+    def _apply_background_color(
+        cls,
+        fig: object,
+        *,
+        background_color: str | None = None,
+    ) -> None:
+        """Apply the theme background to Plotly paper and plot areas."""
         update_layout = getattr(fig, 'update_layout', None)
         if callable(update_layout):
+            resolved_background = background_color
+            if resolved_background is None:
+                resolved_background = cls._background_color()
             update_layout(
-                paper_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
-                plot_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
+                paper_bgcolor=resolved_background,
+                plot_bgcolor=resolved_background,
             )
 
     @classmethod
@@ -1362,8 +1472,11 @@ def _get_layout(
             },
             'showline': True,
             'linecolor': cls._axis_frame_color(),
+            'gridcolor': cls._inner_tick_grid_color(),
             'mirror': True,
+            'ticklabelstandoff': X_AXIS_TICK_LABEL_STANDOFF,
             'zeroline': False,
+            'zerolinecolor': cls._inner_tick_grid_color(),
         }
         yaxis = {
             'title': {
@@ -1372,8 +1485,11 @@ def _get_layout(
             },
             'showline': True,
             'linecolor': cls._axis_frame_color(),
+            'gridcolor': cls._inner_tick_grid_color(),
             'mirror': True,
+            'ticklabelstandoff': Y_AXIS_TICK_LABEL_STANDOFF,
             'zeroline': False,
+            'zerolinecolor': cls._inner_tick_grid_color(),
         }
         if axis_range is not None:
             for axis in (xaxis, yaxis):
@@ -1395,8 +1511,8 @@ def _get_layout(
                 'text': title,
                 'font': {'size': TITLE_FONT_SIZE},
             },
-            paper_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
-            plot_bgcolor=TRANSPARENT_BACKGROUND_COLOR,
+            paper_bgcolor=cls._background_color(),
+            plot_bgcolor=cls._background_color(),
             legend={
                 'bgcolor': cls._legend_background_color(),
                 'xanchor': 'right',
@@ -2072,6 +2188,7 @@ def _configure_shared_composite_axes(
                 'mirror': True,
                 'zeroline': False,
                 'tickformat': ',.6~g',
+                'ticklabelstandoff': X_AXIS_TICK_LABEL_STANDOFF,
                 'separatethousands': True,
             }
             if x_min is not None and x_max is not None:
@@ -2083,6 +2200,7 @@ def _configure_shared_composite_axes(
                 mirror=True,
                 zeroline=False,
                 tickformat=',.6~g',
+                ticklabelstandoff=Y_AXIS_TICK_LABEL_STANDOFF,
                 separatethousands=True,
                 row=row_idx,
                 col=1,
diff --git a/src/easydiffraction/display/tablers/base.py b/src/easydiffraction/display/tablers/base.py
index 0bc2bddfb..5de381f86 100644
--- a/src/easydiffraction/display/tablers/base.py
+++ b/src/easydiffraction/display/tablers/base.py
@@ -15,6 +15,8 @@
 from IPython import get_ipython
 from rich.color import Color
 
+from easydiffraction.display.theme import DARK_AXIS_FRAME_COLOR
+from easydiffraction.display.theme import LIGHT_AXIS_FRAME_COLOR
 from easydiffraction.utils._vendored.theme_detect import is_dark
 
 
@@ -96,7 +98,9 @@ def _rich_border_color(self) -> str:
 
     @property
     def _pandas_border_color(self) -> str:
-        return self._rich_to_hex(self._rich_border_color)
+        if self._is_dark_theme():
+            return DARK_AXIS_FRAME_COLOR
+        return LIGHT_AXIS_FRAME_COLOR
 
     @abstractmethod
     def build_renderable(
diff --git a/src/easydiffraction/display/tablers/pandas.py b/src/easydiffraction/display/tablers/pandas.py
index 823c2cb09..f5cfaa1f9 100644
--- a/src/easydiffraction/display/tablers/pandas.py
+++ b/src/easydiffraction/display/tablers/pandas.py
@@ -14,15 +14,27 @@
 import re
 
 from easydiffraction.display.tablers.base import TableBackendBase
+from easydiffraction.display.theme import DARK_AXIS_FRAME_COLOR
+from easydiffraction.display.theme import LIGHT_AXIS_FRAME_COLOR
+from easydiffraction.display.theme import TABLE_AXIS_FRAME_CSS_VAR
 from easydiffraction.utils.environment import can_use_ipython_display
 from easydiffraction.utils.logging import log
 
 _RICH_COLOR_RE = re.compile(r'\[(\w+)\](.*?)\[/\1\]')
+PANDAS_TABLE_THEME_CLASS = 'ed-themed-table'
+PANDAS_AXIS_FRAME_COLOR = f'var({TABLE_AXIS_FRAME_CSS_VAR}, {LIGHT_AXIS_FRAME_COLOR})'
 
 
 class PandasTableBackend(TableBackendBase):
     """Render tables using the pandas Styler in Jupyter environments."""
 
+    def _table_attributes(self) -> str:
+        """Return HTML table attributes for themed pandas tables."""
+        return (
+            f'class="dataframe {PANDAS_TABLE_THEME_CLASS}" '
+            f'style="{TABLE_AXIS_FRAME_CSS_VAR}: {self._pandas_border_color};"'
+        )
+
     @staticmethod
     def _build_base_styles(color: str) -> list[dict]:
         """
@@ -172,7 +184,7 @@ def _apply_styling(self, df: object, alignments: object, color: str) -> object:
         styler = df.style.format(precision=self.FLOAT_PRECISION)
         if color_styles is not None:
             styler = styler.apply(lambda _: color_styles, axis=None)
-        styler = styler.set_table_attributes('class="dataframe"')  # For mkdocs-jupyter
+        styler = styler.set_table_attributes(self._table_attributes())
         styler = styler.set_table_styles(table_styles + header_alignment_styles)
 
         for column, align in zip(df.columns, alignments, strict=False):
@@ -182,8 +194,7 @@ def _apply_styling(self, df: object, alignments: object, color: str) -> object:
             )
         return styler
 
-    @staticmethod
-    def _update_display(styler: object, display_handle: object) -> None:
+    def _update_display(self, styler: object, display_handle: object) -> None:
         """
         Single, consistent update path for Jupyter.
 
@@ -203,7 +214,7 @@ def _update_display(styler: object, display_handle: object) -> None:
             # IPython DisplayHandle path
             if can_use_ipython_display(display_handle) and HTML is not None:
                 try:
-                    html = styler.to_html()
+                    html = self._themed_html(styler)
                     display_handle.update(HTML(html))
                 except (TypeError, ValueError, AttributeError, RuntimeError, OSError) as err:
                     log.debug(f'Pandas DisplayHandle update failed: {err!r}')
@@ -215,7 +226,10 @@ def _update_display(styler: object, display_handle: object) -> None:
                 pass
 
         # Normal display
-        display(styler)
+        if HTML is not None:
+            display(HTML(self._themed_html(styler)))
+        else:
+            display(styler)
 
     def render(
         self,
@@ -266,7 +280,7 @@ def build_renderable(
             HTML string representation of the styled table.
         """
         styler = self._build_styler(alignments, df)
-        return styler.to_html()
+        return self._themed_html(styler)
 
     def _build_styler(
         self,
@@ -274,5 +288,84 @@ def _build_styler(
         df: object,
     ) -> object:
         """Return a configured pandas Styler for the provided table."""
-        color = self._pandas_border_color
+        color = PANDAS_AXIS_FRAME_COLOR
         return self._apply_styling(df, alignments, color)
+
+    @classmethod
+    def _themed_html(cls, styler: object) -> str:
+        """Return styled table HTML plus the theme-sync script."""
+        return styler.to_html() + cls._theme_sync_post_script()
+
+    @staticmethod
+    def _theme_sync_post_script() -> str:
+        """Return client-side code for host table theme changes."""
+        return f"""
+<script>
+(function () {{
+  const tableSelector = '.{PANDAS_TABLE_THEME_CLASS}';
+  const axisFrameProperty = '{TABLE_AXIS_FRAME_CSS_VAR}';
+
+  const hostTheme = function () {{
+    const materialScheme = (
+      document.body?.getAttribute('data-md-color-scheme')
+      || document.documentElement.getAttribute('data-md-color-scheme')
+    );
+    if (materialScheme === 'slate') {{
+      return 'dark';
+    }}
+    if (materialScheme === 'default') {{
+      return 'light';
+    }}
+
+    const jupyterThemeLight = (
+      document.body?.getAttribute('data-jp-theme-light')
+      || document.documentElement.getAttribute('data-jp-theme-light')
+    );
+    if (jupyterThemeLight === 'false') {{
+      return 'dark';
+    }}
+    if (jupyterThemeLight === 'true') {{
+      return 'light';
+    }}
+    return 'light';
+  }};
+
+  const axisFrameColor = function () {{
+    if (hostTheme() === 'dark') {{
+      return '{DARK_AXIS_FRAME_COLOR}';
+    }}
+    return '{LIGHT_AXIS_FRAME_COLOR}';
+  }};
+
+  const applyTheme = function () {{
+    const color = axisFrameColor();
+    document.querySelectorAll(tableSelector).forEach(function (table) {{
+      table.style.setProperty(axisFrameProperty, color);
+    }});
+  }};
+
+  applyTheme();
+
+  if (window.__edPandasTableThemeObserverInstalled || !window.MutationObserver) {{
+    return;
+  }}
+  window.__edPandasTableThemeObserverInstalled = true;
+  const themeObserver = new MutationObserver(applyTheme);
+  const attributeFilter = [
+    'data-md-color-scheme',
+    'data-jp-theme-light',
+    'data-jp-theme-name',
+  ];
+  themeObserver.observe(document.documentElement, {{
+    attributes: true,
+    attributeFilter: attributeFilter,
+  }});
+  if (document.body) {{
+    themeObserver.observe(document.body, {{
+      attributes: true,
+      attributeFilter: attributeFilter,
+    }});
+  }}
+}}());
+</script>
+"""
diff --git a/src/easydiffraction/display/theme.py b/src/easydiffraction/display/theme.py
new file mode 100644
index 000000000..6ed326e6c
--- /dev/null
+++ b/src/easydiffraction/display/theme.py
@@ -0,0 +1,108 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+"""Shared display theme colors for plots and notebook tables."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+LIGHT_BACKGROUND_COLOR = '#fff'
+DARK_BACKGROUND_COLOR = '#111'
+LIGHT_FOREGROUND_COLOR = '#222222'
+DARK_FOREGROUND_COLOR = '#e6e8ee'
+LIGHT_AXIS_FRAME_COLOR = '#e2e2e2'
+DARK_AXIS_FRAME_COLOR = '#333'
+LIGHT_INNER_TICK_GRID_COLOR = '#f2f2f2'
+DARK_INNER_TICK_GRID_COLOR = '#1e1e1e'
+LIGHT_HOVER_BACKGROUND_COLOR = '#ffffff'
+DARK_HOVER_BACKGROUND_COLOR = '#212121'
+LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
+DARK_LEGEND_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0.5)'
+TABLE_AXIS_FRAME_CSS_VAR = '--ed-axis-frame-color'
+
+
+@dataclass(frozen=True)
+class DisplayThemeColors:
+    """
+    Theme colors shared by interactive display outputs.
+
+    Attributes
+    ----------
+    background : str
+        Plot or output background color.
+    foreground : str
+        Primary text color.
+    axis_frame : str
+        Axis rectangle and table border color.
+    inner_tick_grid : str
+        Inner Plotly tick-grid color.
+    hover_background : str
+        Plotly hover label background color.
+    legend_background : str
+        Plotly legend background color.
+    """
+
+    background: str
+    foreground: str
+    axis_frame: str
+    inner_tick_grid: str
+    hover_background: str
+    legend_background: str
+
+
+LIGHT_THEME_COLORS = DisplayThemeColors(
+    background=LIGHT_BACKGROUND_COLOR,
+    foreground=LIGHT_FOREGROUND_COLOR,
+    axis_frame=LIGHT_AXIS_FRAME_COLOR,
+    inner_tick_grid=LIGHT_INNER_TICK_GRID_COLOR,
+    hover_background=LIGHT_HOVER_BACKGROUND_COLOR,
+    legend_background=LIGHT_LEGEND_BACKGROUND_COLOR,
+)
+DARK_THEME_COLORS = DisplayThemeColors(
+    background=DARK_BACKGROUND_COLOR,
+    foreground=DARK_FOREGROUND_COLOR,
+    axis_frame=DARK_AXIS_FRAME_COLOR,
+    inner_tick_grid=DARK_INNER_TICK_GRID_COLOR,
+    hover_background=DARK_HOVER_BACKGROUND_COLOR,
+    legend_background=DARK_LEGEND_BACKGROUND_COLOR,
+)
+
+
+def display_theme_colors(*, is_dark_theme: bool) -> DisplayThemeColors:
+    """
+    Return the display colors for the requested theme.
+
+    Parameters
+    ----------
+    is_dark_theme : bool
+        Whether to return the dark theme colors.
+
+    Returns
+    -------
+    DisplayThemeColors
+        Shared colors for the requested theme.
+    """
+    if is_dark_theme:
+        return DARK_THEME_COLORS
+    return LIGHT_THEME_COLORS
+
+
+def display_theme_colors_for_template(template: str) -> DisplayThemeColors | None:
+    """
+    Return display colors for a Plotly template name.
+
+    Parameters
+    ----------
+    template : str
+        Plotly template name.
+
+    Returns
+    -------
+    DisplayThemeColors | None
+        Theme colors for known Plotly templates, otherwise ``None``.
+    """
+    if template == 'plotly_white':
+        return LIGHT_THEME_COLORS
+    if template == 'plotly_dark':
+        return DARK_THEME_COLORS
+    return None
diff --git a/src/easydiffraction/report/style.py b/src/easydiffraction/report/style.py
index f88b27c6a..ab1ddae01 100644
--- a/src/easydiffraction/report/style.py
+++ b/src/easydiffraction/report/style.py
@@ -4,8 +4,10 @@
 
 from __future__ import annotations
 
+from easydiffraction.display.theme import LIGHT_AXIS_FRAME_COLOR
+
 REPORT_AXIS_RGB = (190, 199, 208)
-REPORT_TABLE_INNER_RGB = (217, 223, 228)
+REPORT_TABLE_INNER_HEX = LIGHT_AXIS_FRAME_COLOR
 REPORT_CHART_GRID_RGB = (235, 240, 248)
 REPORT_ROW_RGB = (235, 240, 248)
 REPORT_LINK_RGB = (36, 90, 155)  # mirrors --link (#245a9b) in html/style.css
@@ -20,8 +22,8 @@ def report_style_context() -> dict[str, object]:
     return {
         'axis_hex': _rgb_hex(REPORT_AXIS_RGB),
         'axis_rgb': _rgb_channels(REPORT_AXIS_RGB),
-        'grid_hex': _rgb_hex(REPORT_TABLE_INNER_RGB),
-        'grid_rgb': _rgb_channels(REPORT_TABLE_INNER_RGB),
+        'grid_hex': REPORT_TABLE_INNER_HEX,
+        'grid_rgb': _hex_channels(REPORT_TABLE_INNER_HEX),
         'chart_grid_hex': _rgb_hex(REPORT_CHART_GRID_RGB),
         'chart_grid_rgb': _rgb_channels(REPORT_CHART_GRID_RGB),
         'row_hex': _rgb_hex(REPORT_ROW_RGB),
@@ -43,3 +45,12 @@ def _rgb_hex(rgb: tuple[int, int, int]) -> str:
 def _rgb_channels(rgb: tuple[int, int, int]) -> str:
     """Return comma-separated channels for TeX RGB definitions."""
     return ','.join(str(channel) for channel in rgb)
+
+
+def _hex_channels(color: str) -> str:
+    """Return comma-separated RGB channels for a CSS hex color."""
+    return _rgb_channels((
+        int(color[1:3], 16),
+        int(color[3:5], 16),
+        int(color[5:7], 16),
+    ))
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 59d87a794..c25b86522 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -13,16 +13,44 @@ def test_module_import():
     assert expected_module_name == actual_module_name
 
 
-def test_get_layout_sets_title_and_axis_title_font_sizes():
+@pytest.mark.parametrize(
+    'is_dark_mode',
+    [False, True],
+)
+def test_get_layout_sets_title_axis_and_theme_colors(
+    monkeypatch,
+    is_dark_mode,
+):
     import easydiffraction.display.plotters.plotly as pp
 
+    if is_dark_mode:
+        background_color = pp.DARK_BACKGROUND_COLOR
+        axis_color = pp.DARK_AXIS_FRAME_COLOR
+        grid_color = pp.DARK_INNER_TICK_GRID_COLOR
+    else:
+        background_color = pp.LIGHT_BACKGROUND_COLOR
+        axis_color = pp.LIGHT_AXIS_FRAME_COLOR
+        grid_color = pp.LIGHT_INNER_TICK_GRID_COLOR
+
+    monkeypatch.setattr(
+        pp.PlotlyPlotter,
+        '_is_dark_mode',
+        classmethod(lambda cls: is_dark_mode),
+    )
+
     layout = pp.PlotlyPlotter._get_layout('Title', ['x axis', 'y axis'])
 
     assert layout.title.font.size == pp.TITLE_FONT_SIZE
     assert layout.xaxis.title.font.size == pp.AXIS_TITLE_FONT_SIZE
     assert layout.yaxis.title.font.size == pp.AXIS_TITLE_FONT_SIZE
-    assert layout.paper_bgcolor == pp.TRANSPARENT_BACKGROUND_COLOR
-    assert layout.plot_bgcolor == pp.TRANSPARENT_BACKGROUND_COLOR
+    assert layout.paper_bgcolor == background_color
+    assert layout.plot_bgcolor == background_color
+    assert layout.xaxis.linecolor == axis_color
+    assert layout.yaxis.linecolor == axis_color
+    assert layout.xaxis.gridcolor == grid_color
+    assert layout.yaxis.gridcolor == grid_color
+    assert layout.xaxis.ticklabelstandoff == pp.X_AXIS_TICK_LABEL_STANDOFF
+    assert layout.yaxis.ticklabelstandoff == pp.Y_AXIS_TICK_LABEL_STANDOFF
 
 
 def test_get_trace_and_plot(monkeypatch):
@@ -171,8 +199,18 @@ def __init__(self, html):
     assert 'data-jp-theme-light' in captured['post_script']
     assert 'data-md-color-scheme' in captured['post_script']
     assert 'graphDiv.dataset.edPlotlyTheme' in captured['post_script']
-    assert "background: 'rgba(0, 0, 0, 0)'" in captured['post_script']
-    assert "hoverBackground: '#212121'" in captured['post_script']
+    assert f"background: '{pp.DARK_BACKGROUND_COLOR}'" in captured['post_script']
+    assert f"background: '{pp.LIGHT_BACKGROUND_COLOR}'" in captured['post_script']
+    assert f"axisFrame: '{pp.DARK_AXIS_FRAME_COLOR}'" in captured['post_script']
+    assert f"axisFrame: '{pp.LIGHT_AXIS_FRAME_COLOR}'" in captured['post_script']
+    assert f"innerTickGrid: '{pp.DARK_INNER_TICK_GRID_COLOR}'" in captured['post_script']
+    assert f"innerTickGrid: '{pp.LIGHT_INNER_TICK_GRID_COLOR}'" in captured['post_script']
+    assert f"hoverBackground: '{pp.DARK_HOVER_BACKGROUND_COLOR}'" in captured['post_script']
+    assert f"legend: '{pp.DARK_LEGEND_BACKGROUND_COLOR}'" in captured['post_script']
+    assert 'ed-plotly-modebar-theme-style' in captured['post_script']
+    assert 'ed-plotly-themed-modebar' in captured['post_script']
+    assert '--ed-plotly-modebar-icon-color' in captured['post_script']
+    assert '--ed-plotly-modebar-icon-hover-opacity' in captured['post_script']
     assert 'window.Plotly.relayout(graphDiv, update)' in captured['post_script']
     assert 'data-legend-toggle="true"' in captured['post_script']
     assert 'Toggle legend' in captured['post_script']
@@ -509,6 +547,12 @@ def fake_show_figure(self, fig):
     assert fig.layout.xaxis.matches == 'x'
     assert fig.layout.xaxis2.matches == 'x'
     assert fig.layout.xaxis3.matches == 'x'
+    assert fig.layout.xaxis.ticklabelstandoff == pp.X_AXIS_TICK_LABEL_STANDOFF
+    assert fig.layout.xaxis2.ticklabelstandoff == pp.X_AXIS_TICK_LABEL_STANDOFF
+    assert fig.layout.xaxis3.ticklabelstandoff == pp.X_AXIS_TICK_LABEL_STANDOFF
+    assert fig.layout.yaxis.ticklabelstandoff == pp.Y_AXIS_TICK_LABEL_STANDOFF
+    assert fig.layout.yaxis2.ticklabelstandoff == pp.Y_AXIS_TICK_LABEL_STANDOFF
+    assert fig.layout.yaxis3.ticklabelstandoff == pp.Y_AXIS_TICK_LABEL_STANDOFF
     assert fig.layout.yaxis3.scaleanchor == 'y'
     assert fig.layout.yaxis3.scaleratio == pytest.approx(1.0)
 
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 62743b202..6e0b91897 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -644,8 +644,8 @@ def test_exposes_host_theme_sync_hook(self, patched_theme):
         )
 
         assert 'root.__crysviewApplyTheme = applyTheme;' in html
-        assert "data-md-color-scheme" in html
-        assert "data-jp-theme-light" in html
+        assert 'data-md-color-scheme' in html
+        assert 'data-jp-theme-light' in html
         assert "document.body.getAttribute('data-md-color-scheme')" in html
 
 
diff --git a/tests/unit/easydiffraction/display/tablers/test_base.py b/tests/unit/easydiffraction/display/tablers/test_base.py
index 8dd7d1e92..2402a6bb9 100644
--- a/tests/unit/easydiffraction/display/tablers/test_base.py
+++ b/tests/unit/easydiffraction/display/tablers/test_base.py
@@ -48,8 +48,9 @@ def test_rich_border_color_property(self):
         assert isinstance(color, str)
 
     def test_pandas_border_color_property(self):
+        from easydiffraction.display.theme import DARK_AXIS_FRAME_COLOR
         from easydiffraction.display.tablers.rich import RichTableBackend
 
         backend = RichTableBackend()
         color = backend._pandas_border_color
-        assert color.startswith('#')
+        assert color == DARK_AXIS_FRAME_COLOR
diff --git a/tests/unit/easydiffraction/display/tablers/test_pandas.py b/tests/unit/easydiffraction/display/tablers/test_pandas.py
index e4a77c5b6..f8b5d93fe 100644
--- a/tests/unit/easydiffraction/display/tablers/test_pandas.py
+++ b/tests/unit/easydiffraction/display/tablers/test_pandas.py
@@ -8,14 +8,18 @@
 
 class TestPandasTableBackend:
     def test_build_base_styles(self):
+        from easydiffraction.display.tablers.pandas import PANDAS_AXIS_FRAME_COLOR
         from easydiffraction.display.tablers.pandas import PandasTableBackend
 
         backend = PandasTableBackend()
-        styles = backend._build_base_styles('#aabbcc')
+        styles = backend._build_base_styles(PANDAS_AXIS_FRAME_COLOR)
         assert isinstance(styles, list)
         assert len(styles) > 0
         selectors = [s['selector'] for s in styles]
         assert 'thead' in selectors
+        assert any(
+            PANDAS_AXIS_FRAME_COLOR in value for style in styles for _, value in style['props']
+        )
 
     def test_build_header_alignment_styles(self):
         from easydiffraction.display.tablers.pandas import PandasTableBackend
@@ -35,7 +39,9 @@ def test_apply_styling_returns_styler(self):
         assert hasattr(styler, 'to_html')
 
     def test_build_renderable_returns_html(self):
+        from easydiffraction.display.tablers.pandas import PANDAS_TABLE_THEME_CLASS
         from easydiffraction.display.tablers.pandas import PandasTableBackend
+        from easydiffraction.display.theme import TABLE_AXIS_FRAME_CSS_VAR
 
         pytest.importorskip('jinja2')
         backend = PandasTableBackend()
@@ -45,3 +51,6 @@ def test_build_renderable_returns_html(self):
 
         assert isinstance(html, str)
         assert '<table' in html
+        assert PANDAS_TABLE_THEME_CLASS in html
+        assert TABLE_AXIS_FRAME_CSS_VAR in html
+        assert 'window.__edPandasTableThemeObserverInstalled' in html
diff --git a/tests/unit/easydiffraction/display/test_theme.py b/tests/unit/easydiffraction/display/test_theme.py
new file mode 100644
index 000000000..e1ce1b99e
--- /dev/null
+++ b/tests/unit/easydiffraction/display/test_theme.py
@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2026 EasyScience contributors <https://github.com/easyscience>
+# SPDX-License-Identifier: BSD-3-Clause
+
+from __future__ import annotations
+
+
+def test_display_theme_colors_returns_light_and_dark_constants():
+    import easydiffraction.display.theme as theme
+
+    light = theme.display_theme_colors(is_dark_theme=False)
+    dark = theme.display_theme_colors(is_dark_theme=True)
+
+    assert light.background == theme.LIGHT_BACKGROUND_COLOR
+    assert light.axis_frame == theme.LIGHT_AXIS_FRAME_COLOR
+    assert light.inner_tick_grid == theme.LIGHT_INNER_TICK_GRID_COLOR
+    assert dark.background == theme.DARK_BACKGROUND_COLOR
+    assert dark.axis_frame == theme.DARK_AXIS_FRAME_COLOR
+    assert dark.inner_tick_grid == theme.DARK_INNER_TICK_GRID_COLOR
+
+
+def test_display_theme_colors_for_template_maps_plotly_templates():
+    import easydiffraction.display.theme as theme
+
+    assert theme.display_theme_colors_for_template('plotly_white') is theme.LIGHT_THEME_COLORS
+    assert theme.display_theme_colors_for_template('plotly_dark') is theme.DARK_THEME_COLORS
+    assert theme.display_theme_colors_for_template('custom') is None
diff --git a/tests/unit/easydiffraction/report/test_style.py b/tests/unit/easydiffraction/report/test_style.py
index bd4f07ea2..8a2266bef 100644
--- a/tests/unit/easydiffraction/report/test_style.py
+++ b/tests/unit/easydiffraction/report/test_style.py
@@ -11,7 +11,8 @@ def test_report_style_context_exposes_hex_and_rgb_values():
 
     assert context['axis_hex'] == '#bec7d0'
     assert context['axis_rgb'] == '190,199,208'
-    assert context['grid_hex'] == '#d9dfe4'
+    assert context['grid_hex'] == '#e2e2e2'
+    assert context['grid_rgb'] == '226,226,226'
     assert context['chart_grid_rgb'] == '235,240,248'
     assert context['subtitle'] == 'EasyDiffraction Report'
     assert 'PT Sans' in context['html_font_family']

From ea888b52647b1005386bf01ea33692103f4baaca Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 09:45:25 +0200
Subject: [PATCH 134/160] Add DisplayThemeColors class

---
 .../python-cif-category-correspondence.md     | 174 +++++++++---------
 ...hon-cif-category-correspondence_reply-1.md |  10 +-
 ...on-cif-category-correspondence_review-1.md |  22 +--
 docs/dev/package-structure/full.md            |   2 +
 docs/dev/package-structure/short.md           |   1 +
 5 files changed, 105 insertions(+), 104 deletions(-)

diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
index d31f8d0ff..1099435fe 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
@@ -64,69 +64,69 @@ to objects reached from the current `Project` root, for example
 
 ## Current Persistence Layout
 
-| Current Python surface                                                                                                                                                  | Current saved location   | Current CIF block form | Notes                                                                                 |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ---------------------- | ------------------------------------------------------------------------------------- |
-| `project.info`, `project.rendering_plot`, `project.report`, `project.rendering_table`, `project.rendering_structure`, `project.structure_view`, `project.structure_style`, `project.verbosity` | `project.cif`            | bare categories        | Project-level singleton config.                                                       |
-| `project.structures[name]`                                                                                                                                              | `structures/<name>.cif`  | `data_<name>`          | Each structure is one CIF data block.                                                 |
-| `project.experiments[name]`                                                                                                                                             | `experiments/<name>.cif` | `data_<name>`          | Each experiment is one CIF data block.                                                |
-| `project.analysis`                                                                                                                                                      | `analysis/analysis.cif`  | bare categories        | Loader also accepts legacy root-level `analysis.cif`.                                 |
-| `project.report.save_*()` / `project.report.{cif,html,tex,pdf}`                                                                                                         | `reports/`              | multi-datablock CIF or rendered artifacts | Derived report outputs; generated only when configured or called explicitly. |
+| Current Python surface                                                                                                                                                                         | Current saved location   | Current CIF block form                    | Notes                                                                        |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ----------------------------------------- | ---------------------------------------------------------------------------- |
+| `project.info`, `project.rendering_plot`, `project.report`, `project.rendering_table`, `project.rendering_structure`, `project.structure_view`, `project.structure_style`, `project.verbosity` | `project.cif`            | bare categories                           | Project-level singleton config.                                              |
+| `project.structures[name]`                                                                                                                                                                     | `structures/<name>.cif`  | `data_<name>`                             | Each structure is one CIF data block.                                        |
+| `project.experiments[name]`                                                                                                                                                                    | `experiments/<name>.cif` | `data_<name>`                             | Each experiment is one CIF data block.                                       |
+| `project.analysis`                                                                                                                                                                             | `analysis/analysis.cif`  | bare categories                           | Loader also accepts legacy root-level `analysis.cif`.                        |
+| `project.report.save_*()` / `project.report.{cif,html,tex,pdf}`                                                                                                                                | `reports/`               | multi-datablock CIF or rendered artifacts | Derived report outputs; generated only when configured or called explicitly. |
 
 ## Current Correspondence
 
 ### Project-Level Configuration
 
-| Current Python path                          | Current CIF path                | Match? | Notes                                                                                              |
-| -------------------------------------------- | ------------------------------- | ------ | -------------------------------------------------------------------------------------------------- |
-| `project.info.name`                          | `_project.id`                   | No     | Accepted exception: Python uses user-facing `name`; CIF uses semantic project `id`.                |
-| `project.info.title`                         | `_project.title`                | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
-| `project.info.description`                   | `_project.description`          | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
-| `project.info.created`                       | `_project.created`              | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
-| `project.info.last_modified`                 | `_project.last_modified`        | Partly | Accepted exception: field name matches, category name is semantic `_project`.                      |
-| `project.info.path`                          | none                            | No     | Runtime storage path, not a CIF field.                                                             |
-| `project.rendering_plot.type`                | `_rendering_plot.type`          | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.report.cif`                         | `_report.cif`                   | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.report.html`                        | `_report.html`                  | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.report.tex`                         | `_report.tex`                   | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.report.pdf`                         | `_report.pdf`                   | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.report.html_offline`                | `_report.html_offline`          | Yes    | Direct project-owned report-output configuration mapping.                                          |
-| `project.rendering_table.type`               | `_rendering_table.type`         | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.rendering_structure.type`           | `_rendering_structure.type`     | Yes    | Direct category-owned selector mapping.                                                            |
-| `project.structure_view.show_labels`         | `_structure_view.show_labels`   | Yes    | Direct project-owned structure-view state mapping.                                                 |
-| `project.structure_view.show_moments`        | `_structure_view.show_moments`  | Yes    | Direct project-owned structure-view state mapping.                                                 |
-| `project.structure_view.range_{a,b,c}_{min,max}` | `_structure_view.range_{a,b,c}_{min,max}` | Yes | Six scalar bounds; direct project-owned structure-view state mapping.                              |
-| `project.structure_style.atom_view`          | `_structure_style.atom_view`    | Yes    | Direct project-owned structure-style value selector mapping.                                       |
-| `project.structure_style.color_scheme`       | `_structure_style.color_scheme` | Yes    | Direct project-owned structure-style value selector mapping.                                       |
-| `project.structure_style.adp_probability`    | `_structure_style.adp_probability` | Yes | Direct project-owned structure-style numeric setting.                                              |
-| `project.structure_style.atom_scale`         | `_structure_style.atom_scale`   | Yes    | Direct project-owned structure-style numeric setting.                                              |
-| `project.verbosity.fit`                      | `_verbosity.fit`                | Yes    | Direct category and field mapping for fitting process output verbosity.                            |
-| `project.verbosity = 'short'`                | `_verbosity.fit`                | Alias  | Convenience setter only; canonical persisted path remains `project.verbosity.fit`.                 |
+| Current Python path                              | Current CIF path                          | Match? | Notes                                                                               |
+| ------------------------------------------------ | ----------------------------------------- | ------ | ----------------------------------------------------------------------------------- |
+| `project.info.name`                              | `_project.id`                             | No     | Accepted exception: Python uses user-facing `name`; CIF uses semantic project `id`. |
+| `project.info.title`                             | `_project.title`                          | Partly | Accepted exception: field name matches, category name is semantic `_project`.       |
+| `project.info.description`                       | `_project.description`                    | Partly | Accepted exception: field name matches, category name is semantic `_project`.       |
+| `project.info.created`                           | `_project.created`                        | Partly | Accepted exception: field name matches, category name is semantic `_project`.       |
+| `project.info.last_modified`                     | `_project.last_modified`                  | Partly | Accepted exception: field name matches, category name is semantic `_project`.       |
+| `project.info.path`                              | none                                      | No     | Runtime storage path, not a CIF field.                                              |
+| `project.rendering_plot.type`                    | `_rendering_plot.type`                    | Yes    | Direct category-owned selector mapping.                                             |
+| `project.report.cif`                             | `_report.cif`                             | Yes    | Direct project-owned report-output configuration mapping.                           |
+| `project.report.html`                            | `_report.html`                            | Yes    | Direct project-owned report-output configuration mapping.                           |
+| `project.report.tex`                             | `_report.tex`                             | Yes    | Direct project-owned report-output configuration mapping.                           |
+| `project.report.pdf`                             | `_report.pdf`                             | Yes    | Direct project-owned report-output configuration mapping.                           |
+| `project.report.html_offline`                    | `_report.html_offline`                    | Yes    | Direct project-owned report-output configuration mapping.                           |
+| `project.rendering_table.type`                   | `_rendering_table.type`                   | Yes    | Direct category-owned selector mapping.                                             |
+| `project.rendering_structure.type`               | `_rendering_structure.type`               | Yes    | Direct category-owned selector mapping.                                             |
+| `project.structure_view.show_labels`             | `_structure_view.show_labels`             | Yes    | Direct project-owned structure-view state mapping.                                  |
+| `project.structure_view.show_moments`            | `_structure_view.show_moments`            | Yes    | Direct project-owned structure-view state mapping.                                  |
+| `project.structure_view.range_{a,b,c}_{min,max}` | `_structure_view.range_{a,b,c}_{min,max}` | Yes    | Six scalar bounds; direct project-owned structure-view state mapping.               |
+| `project.structure_style.atom_view`              | `_structure_style.atom_view`              | Yes    | Direct project-owned structure-style value selector mapping.                        |
+| `project.structure_style.color_scheme`           | `_structure_style.color_scheme`           | Yes    | Direct project-owned structure-style value selector mapping.                        |
+| `project.structure_style.adp_probability`        | `_structure_style.adp_probability`        | Yes    | Direct project-owned structure-style numeric setting.                               |
+| `project.structure_style.atom_scale`             | `_structure_style.atom_scale`             | Yes    | Direct project-owned structure-style numeric setting.                               |
+| `project.verbosity.fit`                          | `_verbosity.fit`                          | Yes    | Direct category and field mapping for fitting process output verbosity.             |
+| `project.verbosity = 'short'`                    | `_verbosity.fit`                          | Alias  | Convenience setter only; canonical persisted path remains `project.verbosity.fit`.  |
 
 ### Analysis Configuration
 
-| Current Python path                               | Current CIF path                   | Match? | Notes                                                                                            |
-| ------------------------------------------------- | ---------------------------------- | ------ | ------------------------------------------------------------------------------------------------ |
-| `analysis.minimizer.type`                         | `_minimizer.type`                  | Yes    | Direct category-owned selector mapping.                                                          |
-| `analysis.fitting_mode.type`                      | `_fitting_mode.type`               | Yes    | Direct category-owned active-sibling selector mapping.                                           |
-| `analysis.fit_result.*`                           | `_fit_result.*`                    | Yes    | Direct category mapping for scalar fit-result state; IUCr report export may use transformed tags. |
-| `analysis.fit_parameters[param].*`                 | `_fit_parameter.*`                 | Yes    | Direct loop mapping for persisted per-parameter fit state.                                       |
-| `analysis.fit_parameter_correlations[id].*`        | `_fit_parameter_correlation.*`     | Yes    | Direct loop mapping for deterministic and posterior correlation summaries.                       |
-| `analysis.joint_fit[experiment_id].experiment_id` | `_joint_fit.experiment_id`         | Yes    | Collection key is also stored as a field.                                                        |
-| `analysis.joint_fit[experiment_id].weight`        | `_joint_fit.weight`                | Yes    | Direct field mapping.                                                                            |
-| `analysis.software.*`                              | `_software.*`                      | Yes    | Direct analysis-tier software provenance mapping stamped at fit time.                            |
-| `analysis.sequential_fit.data_dir`                | `_sequential_fit.data_dir`         | Yes    | Direct category mapping.                                                                         |
-| `analysis.sequential_fit.file_pattern`            | `_sequential_fit.file_pattern`     | Yes    | Direct category mapping.                                                                         |
-| `analysis.sequential_fit.max_workers`             | `_sequential_fit.max_workers`      | Yes    | Direct category mapping.                                                                         |
-| `analysis.sequential_fit.chunk_size`              | `_sequential_fit.chunk_size`       | Yes    | Direct category mapping.                                                                         |
-| `analysis.sequential_fit.reverse`                 | `_sequential_fit.reverse`          | Yes    | Direct category mapping.                                                                         |
-| `analysis.sequential_fit_extract[id].id`          | `_sequential_fit_extract.id`       | Yes    | Direct collection mapping.                                                                       |
-| `analysis.sequential_fit_extract[id].target`      | `_sequential_fit_extract.target`   | Yes    | Direct collection mapping.                                                                       |
-| `analysis.sequential_fit_extract[id].pattern`     | `_sequential_fit_extract.pattern`  | Yes    | Direct collection mapping.                                                                       |
-| `analysis.sequential_fit_extract[id].required`    | `_sequential_fit_extract.required` | Yes    | Direct collection mapping.                                                                       |
-| `analysis.aliases[label].label`                   | `_alias.label`                     | Partly | Python collection is plural; CIF row category is singular.                                       |
-| `analysis.aliases[label].param_unique_name`       | `_alias.param_unique_name`         | Partly | Python collection is plural; CIF row category is singular.                                       |
+| Current Python path                               | Current CIF path                   | Match? | Notes                                                                                               |
+| ------------------------------------------------- | ---------------------------------- | ------ | --------------------------------------------------------------------------------------------------- |
+| `analysis.minimizer.type`                         | `_minimizer.type`                  | Yes    | Direct category-owned selector mapping.                                                             |
+| `analysis.fitting_mode.type`                      | `_fitting_mode.type`               | Yes    | Direct category-owned active-sibling selector mapping.                                              |
+| `analysis.fit_result.*`                           | `_fit_result.*`                    | Yes    | Direct category mapping for scalar fit-result state; IUCr report export may use transformed tags.   |
+| `analysis.fit_parameters[param].*`                | `_fit_parameter.*`                 | Yes    | Direct loop mapping for persisted per-parameter fit state.                                          |
+| `analysis.fit_parameter_correlations[id].*`       | `_fit_parameter_correlation.*`     | Yes    | Direct loop mapping for deterministic and posterior correlation summaries.                          |
+| `analysis.joint_fit[experiment_id].experiment_id` | `_joint_fit.experiment_id`         | Yes    | Collection key is also stored as a field.                                                           |
+| `analysis.joint_fit[experiment_id].weight`        | `_joint_fit.weight`                | Yes    | Direct field mapping.                                                                               |
+| `analysis.software.*`                             | `_software.*`                      | Yes    | Direct analysis-tier software provenance mapping stamped at fit time.                               |
+| `analysis.sequential_fit.data_dir`                | `_sequential_fit.data_dir`         | Yes    | Direct category mapping.                                                                            |
+| `analysis.sequential_fit.file_pattern`            | `_sequential_fit.file_pattern`     | Yes    | Direct category mapping.                                                                            |
+| `analysis.sequential_fit.max_workers`             | `_sequential_fit.max_workers`      | Yes    | Direct category mapping.                                                                            |
+| `analysis.sequential_fit.chunk_size`              | `_sequential_fit.chunk_size`       | Yes    | Direct category mapping.                                                                            |
+| `analysis.sequential_fit.reverse`                 | `_sequential_fit.reverse`          | Yes    | Direct category mapping.                                                                            |
+| `analysis.sequential_fit_extract[id].id`          | `_sequential_fit_extract.id`       | Yes    | Direct collection mapping.                                                                          |
+| `analysis.sequential_fit_extract[id].target`      | `_sequential_fit_extract.target`   | Yes    | Direct collection mapping.                                                                          |
+| `analysis.sequential_fit_extract[id].pattern`     | `_sequential_fit_extract.pattern`  | Yes    | Direct collection mapping.                                                                          |
+| `analysis.sequential_fit_extract[id].required`    | `_sequential_fit_extract.required` | Yes    | Direct collection mapping.                                                                          |
+| `analysis.aliases[label].label`                   | `_alias.label`                     | Partly | Python collection is plural; CIF row category is singular.                                          |
+| `analysis.aliases[label].param_unique_name`       | `_alias.param_unique_name`         | Partly | Python collection is plural; CIF row category is singular.                                          |
 | `analysis.constraints[id].id`                     | `_constraint.id`                   | Yes    | Direct explicit row-key mapping; older CIFs may backfill the id from the expression left-hand side. |
-| `analysis.constraints[id].expression`             | `_constraint.expression`           | Yes    | Direct row-field mapping; `lhs_alias` and `rhs_expr` are derived Python helpers.                  |
+| `analysis.constraints[id].expression`             | `_constraint.expression`           | Yes    | Direct row-field mapping; `lhs_alias` and `rhs_expr` are derived Python helpers.                    |
 
 ### Experiment Configuration
 
@@ -209,40 +209,40 @@ to objects reached from the current `Project` root, for example
 
 ### Structure Configuration
 
-| Current Python path                               | Current CIF path                                                                                                                                                    | Match? | Notes                                                                             |
-| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | --------------------------------------------------------------------------------- |
-| `structure.cell.length_a`                         | `_cell.length_a`                                                                                                                                                    | Yes    | Direct category mapping.                                                          |
-| `structure.cell.length_b`                         | `_cell.length_b`                                                                                                                                                    | Yes    | Direct category mapping.                                                          |
-| `structure.cell.length_c`                         | `_cell.length_c`                                                                                                                                                    | Yes    | Direct category mapping.                                                          |
-| `structure.cell.angle_alpha`                      | `_cell.angle_alpha`                                                                                                                                                 | Yes    | Direct category mapping.                                                          |
-| `structure.cell.angle_beta`                       | `_cell.angle_beta`                                                                                                                                                  | Yes    | Direct category mapping.                                                          |
-| `structure.cell.angle_gamma`                      | `_cell.angle_gamma`                                                                                                                                                 | Yes    | Direct category mapping.                                                          |
-| `structure.space_group.name_h_m`                  | `_space_group.name_H-M_alt`                                                                                                                                         | Partly | Default write uses dictionary-canonical casing; legacy `_space_group_name_H-M_alt` and `_symmetry*` alternatives are accepted on read. |
-| `structure.space_group.it_coordinate_system_code` | `_space_group.IT_coordinate_system_code`                                                                                                                            | Partly | Default write uses dictionary-canonical casing; legacy underscore-form and `_symmetry*` alternatives are accepted on read. |
-| `structure.atom_sites[label].label`               | `_atom_site.label`                                                                                                                                                  | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].type_symbol`         | `_atom_site.type_symbol`                                                                                                                                            | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].fract_x`             | `_atom_site.fract_x`                                                                                                                                                | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].fract_y`             | `_atom_site.fract_y`                                                                                                                                                | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].fract_z`             | `_atom_site.fract_z`                                                                                                                                                | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].wyckoff_letter`      | `_atom_site.Wyckoff_symbol`                                                                                                                                         | Partly | Default write uses dictionary-canonical tag; legacy `_atom_site.Wyckoff_letter` is accepted on read. |
-| `structure.atom_sites[label].occupancy`           | `_atom_site.occupancy`                                                                                                                                              | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_sites[label].adp_iso`             | `_atom_site.B_iso_or_equiv` or `_atom_site.U_iso_or_equiv`                                                                                                          | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_sites[label].adp_type`            | `_atom_site.ADP_type`                                                                                                                                               | Partly | Default write uses dictionary-canonical capitalization; legacy `_atom_site.adp_type` is accepted on read. |
-| `structure.atom_site_aniso[label].label`          | `_atom_site_aniso.label`                                                                                                                                            | Yes    | Direct row-field mapping.                                                         |
-| `structure.atom_site_aniso[label].adp_11`         | `_atom_site_aniso.B_11` or `_atom_site_aniso.U_11`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_site_aniso[label].adp_22`         | `_atom_site_aniso.B_22` or `_atom_site_aniso.U_22`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_site_aniso[label].adp_33`         | `_atom_site_aniso.B_33` or `_atom_site_aniso.U_33`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_site_aniso[label].adp_12`         | `_atom_site_aniso.B_12` or `_atom_site_aniso.U_12`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_site_aniso[label].adp_13`         | `_atom_site_aniso.B_13` or `_atom_site_aniso.U_13`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
-| `structure.atom_site_aniso[label].adp_23`         | `_atom_site_aniso.B_23` or `_atom_site_aniso.U_23`                                                                                                                  | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                    |
+| Current Python path                               | Current CIF path                                           | Match? | Notes                                                                                                                                  |
+| ------------------------------------------------- | ---------------------------------------------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `structure.cell.length_a`                         | `_cell.length_a`                                           | Yes    | Direct category mapping.                                                                                                               |
+| `structure.cell.length_b`                         | `_cell.length_b`                                           | Yes    | Direct category mapping.                                                                                                               |
+| `structure.cell.length_c`                         | `_cell.length_c`                                           | Yes    | Direct category mapping.                                                                                                               |
+| `structure.cell.angle_alpha`                      | `_cell.angle_alpha`                                        | Yes    | Direct category mapping.                                                                                                               |
+| `structure.cell.angle_beta`                       | `_cell.angle_beta`                                         | Yes    | Direct category mapping.                                                                                                               |
+| `structure.cell.angle_gamma`                      | `_cell.angle_gamma`                                        | Yes    | Direct category mapping.                                                                                                               |
+| `structure.space_group.name_h_m`                  | `_space_group.name_H-M_alt`                                | Partly | Default write uses dictionary-canonical casing; legacy `_space_group_name_H-M_alt` and `_symmetry*` alternatives are accepted on read. |
+| `structure.space_group.it_coordinate_system_code` | `_space_group.IT_coordinate_system_code`                   | Partly | Default write uses dictionary-canonical casing; legacy underscore-form and `_symmetry*` alternatives are accepted on read.             |
+| `structure.atom_sites[label].label`               | `_atom_site.label`                                         | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_sites[label].type_symbol`         | `_atom_site.type_symbol`                                   | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_sites[label].fract_x`             | `_atom_site.fract_x`                                       | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_sites[label].fract_y`             | `_atom_site.fract_y`                                       | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_sites[label].fract_z`             | `_atom_site.fract_z`                                       | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_sites[label].wyckoff_letter`      | `_atom_site.Wyckoff_symbol`                                | Partly | Default write uses dictionary-canonical tag; legacy `_atom_site.Wyckoff_letter` is accepted on read.                                   |
+| `structure.atom_sites[label].occupancy`           | `_atom_site.occupancy`                                     | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_sites[label].adp_iso`             | `_atom_site.B_iso_or_equiv` or `_atom_site.U_iso_or_equiv` | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
+| `structure.atom_sites[label].adp_type`            | `_atom_site.ADP_type`                                      | Partly | Default write uses dictionary-canonical capitalization; legacy `_atom_site.adp_type` is accepted on read.                              |
+| `structure.atom_site_aniso[label].label`          | `_atom_site_aniso.label`                                   | Yes    | Direct row-field mapping.                                                                                                              |
+| `structure.atom_site_aniso[label].adp_11`         | `_atom_site_aniso.B_11` or `_atom_site_aniso.U_11`         | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
+| `structure.atom_site_aniso[label].adp_22`         | `_atom_site_aniso.B_22` or `_atom_site_aniso.U_22`         | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
+| `structure.atom_site_aniso[label].adp_33`         | `_atom_site_aniso.B_33` or `_atom_site_aniso.U_33`         | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
+| `structure.atom_site_aniso[label].adp_12`         | `_atom_site_aniso.B_12` or `_atom_site_aniso.U_12`         | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
+| `structure.atom_site_aniso[label].adp_13`         | `_atom_site_aniso.B_13` or `_atom_site_aniso.U_13`         | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
+| `structure.atom_site_aniso[label].adp_23`         | `_atom_site_aniso.B_23` or `_atom_site_aniso.U_23`         | No     | Python uses type-neutral ADP name; CIF uses B/U-specific tags.                                                                         |
 
 ### Not Represented In V1
 
-| Candidate surface | Current CIF status | Notes |
-| ----------------- | ------------------ | ----- |
-| `project.summary` | removed | Replaced by `project.report`; no `summary.cif` placeholder is written. |
-| `project.publication` | none | Rejected for v1 by the accepted project-summary-rendering ADR. |
-| journal/publication tags | not emitted | `_journal.*`, `_journal_date.*`, `_journal_coeditor.*`, `_publ_contact_author.*`, `_publ_author.*`, `_publ_body.*`, and `_pd_meas.info_author_*` placeholders are deferred and intentionally omitted while empty. |
+| Candidate surface        | Current CIF status | Notes                                                                                                                                                                                                             |
+| ------------------------ | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `project.summary`        | removed            | Replaced by `project.report`; no `summary.cif` placeholder is written.                                                                                                                                            |
+| `project.publication`    | none               | Rejected for v1 by the accepted project-summary-rendering ADR.                                                                                                                                                    |
+| journal/publication tags | not emitted        | `_journal.*`, `_journal_date.*`, `_journal_coeditor.*`, `_publ_contact_author.*`, `_publ_author.*`, `_publ_body.*`, and `_pd_meas.info_author_*` placeholders are deferred and intentionally omitted while empty. |
 
 ## Decision
 
@@ -325,8 +325,8 @@ name.
 `project.info` is the user-facing Python grouping, but `_project.*` is
 the accepted CIF grouping for project identity. Preserving this
 exception avoids a beta-period churn-only rename from `name` to `id` in
-Python and avoids a persistence migration from `_project.*` to
-`_info.*` without a scientific benefit.
+Python and avoids a persistence migration from `_project.*` to `_info.*`
+without a scientific benefit.
 
 ### Scientific CIF/Domain Categories Should Stay Domain-Oriented
 
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
index 3a5515100..cd7a64e52 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
@@ -26,16 +26,15 @@ adds `project.report`, `project.rendering_structure`,
 `project.publication` plus journal/publication tags as intentionally not
 represented in v1.
 
-Pointer: `## Current Persistence Layout`, `### Project-Level
-Configuration`, and `### Not Represented In V1`.
+Pointer: `## Current Persistence Layout`,
+`### Project-Level Configuration`, and `### Not Represented In V1`.
 
 ## P2 - Refresh the constraint correspondence rows
 
 Verdict: agree.
 
 Action taken: the analysis table now describes the explicit row-key
-model:
-`analysis.constraints[id].id -> _constraint.id` and
+model: `analysis.constraints[id].id -> _constraint.id` and
 `analysis.constraints[id].expression -> _constraint.expression`. The row
 notes that older CIFs may backfill ids from the expression left-hand
 side, and that `lhs_alias` / `rhs_expr` are derived Python helpers.
@@ -48,8 +47,7 @@ Verdict: agree.
 
 Action taken: the structure table now distinguishes canonical write tags
 from read aliases for the affected rows. The default-save rows now use
-`_space_group.name_H-M_alt`,
-`_space_group.IT_coordinate_system_code`,
+`_space_group.name_H-M_alt`, `_space_group.IT_coordinate_system_code`,
 `_atom_site.Wyckoff_symbol`, and `_atom_site.ADP_type`, with legacy
 alternatives described as read-side aliases.
 
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
index 04874e2d6..8f5f0f870 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
@@ -6,22 +6,22 @@
 
 The decision text says to adopt the strict project-level mapping
 `project.<category>.<field> -> _<category>.<field>` at
-`python-cif-category-correspondence.md:223`, but the next paragraph keeps
-the accepted baseline `project.info.<field> -> _project.<field>` at
-`python-cif-category-correspondence.md:233`. The consequences then still
-discuss `_info.*` migration risk at
+`python-cif-category-correspondence.md:223`, but the next paragraph
+keeps the accepted baseline `project.info.<field> -> _project.<field>`
+at `python-cif-category-correspondence.md:233`. The consequences then
+still discuss `_info.*` migration risk at
 `python-cif-category-correspondence.md:327`. As written, an implementer
 cannot tell whether accepting this ADR should keep `_project.*` or
-supersede it with `_info.*`. Please choose one explicit decision:
-either keep `_project.*` and define strict correspondence as applying
-only to the other project-owned singleton categories, or explicitly
-propose a superseding `_project.*` -> `_info.*` migration with the
-compatibility policy.
+supersede it with `_info.*`. Please choose one explicit decision: either
+keep `_project.*` and define strict correspondence as applying only to
+the other project-owned singleton categories, or explicitly propose a
+superseding `_project.*` -> `_info.*` migration with the compatibility
+policy.
 
 ### P1 - Update the project persistence inventory
 
-The "Current Persistence Layout" table still lists
-`project.publication` and `project.summary` / `summary.cif` at
+The "Current Persistence Layout" table still lists `project.publication`
+and `project.summary` / `summary.cif` at
 `python-cif-category-correspondence.md:61` and
 `python-cif-category-correspondence.md:66`, and the "Not Yet Mapped"
 section repeats `project.summary` at
diff --git a/docs/dev/package-structure/full.md b/docs/dev/package-structure/full.md
index 43b464be8..1b3e42e91 100644
--- a/docs/dev/package-structure/full.md
+++ b/docs/dev/package-structure/full.md
@@ -568,6 +568,8 @@
 │   │   ├── 🏷️ class TableEngineEnum
 │   │   ├── 🏷️ class TableRenderer
 │   │   └── 🏷️ class TableRendererFactory
+│   ├── 📄 theme.py
+│   │   └── 🏷️ class DisplayThemeColors
 │   └── 📄 utils.py
 │       └── 🏷️ class JupyterScrollManager
 ├── 📁 io
diff --git a/docs/dev/package-structure/short.md b/docs/dev/package-structure/short.md
index e6ee7caa3..23c0e68b8 100644
--- a/docs/dev/package-structure/short.md
+++ b/docs/dev/package-structure/short.md
@@ -266,6 +266,7 @@
 │   ├── 📄 plotting.py
 │   ├── 📄 progress.py
 │   ├── 📄 tables.py
+│   ├── 📄 theme.py
 │   └── 📄 utils.py
 ├── 📁 io
 │   ├── 📁 cif

From a9720a1395dad76a371a9fe6aa79e504d7b10c31 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 09:49:50 +0200
Subject: [PATCH 135/160] Clean up Python-CIF ADR review artifacts

---
 .../python-cif-category-correspondence.md     |  8 +++
 ...hon-cif-category-correspondence_reply-1.md | 54 ---------------
 ...on-cif-category-correspondence_review-1.md | 67 -------------------
 ...on-cif-category-correspondence_review-2.md | 12 ----
 4 files changed, 8 insertions(+), 133 deletions(-)
 delete mode 100644 docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
 delete mode 100644 docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
 delete mode 100644 docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md

diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
index 1099435fe..7d3803a2a 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
+++ b/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
@@ -3,6 +3,14 @@
 **Status:** Proposed  
 **Date:** 2026-05-17
 
+## Status Note
+
+The ADR review cycle closed at
+`python-cif-category-correspondence_review-2.md` with the final-review
+sentinel. The suggestion is ready for a same-slug draft plan; review
+and reply artifacts from the ADR cycle have been removed from the
+active tree.
+
 ## Context
 
 EasyDiffraction exposes a Python object graph and persists state in CIF
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
deleted file mode 100644
index cd7a64e52..000000000
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence_reply-1.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# Reply 1: Python and CIF Category Correspondence
-
-## P1 - Resolve the `_project.*` versus `_info.*` decision
-
-Verdict: agree.
-
-Action taken: the ADR now explicitly keeps `_project.*` as the accepted
-`project.info` exception and limits the strict
-`project.<category>.<field> -> _<category>.<field>` rule to the other
-EasyDiffraction-owned project-level singleton configuration categories.
-It also states that this ADR does not rename `project.info.name` to
-`id`, does not migrate `_project.*` to `_info.*`, and does not add an
-`_info.*` compatibility layer.
-
-Pointer: `## Decision`, `### project.info Is A Deliberate Exception`,
-and `## Consequences`.
-
-## P1 - Update the project persistence inventory
-
-Verdict: agree.
-
-Action taken: the current persistence layout now removes the obsolete
-`project.publication`, `project.summary`, and `summary.cif` entries;
-adds `project.report`, `project.rendering_structure`,
-`project.structure_view`, and `project.structure_style`; and records
-`project.publication` plus journal/publication tags as intentionally not
-represented in v1.
-
-Pointer: `## Current Persistence Layout`,
-`### Project-Level Configuration`, and `### Not Represented In V1`.
-
-## P2 - Refresh the constraint correspondence rows
-
-Verdict: agree.
-
-Action taken: the analysis table now describes the explicit row-key
-model: `analysis.constraints[id].id -> _constraint.id` and
-`analysis.constraints[id].expression -> _constraint.expression`. The row
-notes that older CIFs may backfill ids from the expression left-hand
-side, and that `lhs_alias` / `rhs_expr` are derived Python helpers.
-
-Pointer: `### Analysis Configuration`.
-
-## P2 - Reconcile structure rows with the IUCr alignment decision
-
-Verdict: agree.
-
-Action taken: the structure table now distinguishes canonical write tags
-from read aliases for the affected rows. The default-save rows now use
-`_space_group.name_H-M_alt`, `_space_group.IT_coordinate_system_code`,
-`_atom_site.Wyckoff_symbol`, and `_atom_site.ADP_type`, with legacy
-alternatives described as read-side aliases.
-
-Pointer: `### Structure Configuration`.
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
deleted file mode 100644
index 8f5f0f870..000000000
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-1.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# Review 1: Python and CIF Category Correspondence
-
-## Findings
-
-### P1 - Resolve the `_project.*` versus `_info.*` decision
-
-The decision text says to adopt the strict project-level mapping
-`project.<category>.<field> -> _<category>.<field>` at
-`python-cif-category-correspondence.md:223`, but the next paragraph
-keeps the accepted baseline `project.info.<field> -> _project.<field>`
-at `python-cif-category-correspondence.md:233`. The consequences then
-still discuss `_info.*` migration risk at
-`python-cif-category-correspondence.md:327`. As written, an implementer
-cannot tell whether accepting this ADR should keep `_project.*` or
-supersede it with `_info.*`. Please choose one explicit decision: either
-keep `_project.*` and define strict correspondence as applying only to
-the other project-owned singleton categories, or explicitly propose a
-superseding `_project.*` -> `_info.*` migration with the compatibility
-policy.
-
-### P1 - Update the project persistence inventory
-
-The "Current Persistence Layout" table still lists `project.publication`
-and `project.summary` / `summary.cif` at
-`python-cif-category-correspondence.md:61` and
-`python-cif-category-correspondence.md:66`, and the "Not Yet Mapped"
-section repeats `project.summary` at
-`python-cif-category-correspondence.md:215`. Those are rejected by the
-accepted project-facade/report decisions: report metadata now goes
-through `project.report`, `summary.cif` is not part of the save layout,
-and `project.publication` is deferred from v1. The same inventory also
-omits current persisted project-level structure rendering categories
-such as `project.rendering_structure`, `project.structure_view`, and
-`project.structure_style`. Please refresh the table before this ADR is
-accepted so it does not reintroduce removed surfaces or omit active
-project configuration categories.
-
-### P2 - Refresh the constraint correspondence rows
-
-The analysis table says `analysis.constraints[lhs_alias].expression`
-maps to `_constraint.expression` and notes that the key is derived from
-the expression at `python-cif-category-correspondence.md:105`. That was
-superseded by the accepted loop-key ADR: constraints now have an
-explicit serialized `_constraint.id` key, while `lhs_alias` and
-`rhs_expr` are derived helpers from the expression. Please update this
-section to describe `analysis.constraints[id].id -> _constraint.id` and
-`analysis.constraints[id].expression -> _constraint.expression`, so
-future correspondence work does not preserve the old implicit-key model.
-
-### P2 - Reconcile structure rows with the IUCr alignment decision
-
-The structure table still treats `_atom_site.adp_type` as the direct
-current mapping at `python-cif-category-correspondence.md:206` and lists
-legacy/capitalization alternatives for Wyckoff and space-group tags at
-`python-cif-category-correspondence.md:196` and
-`python-cif-category-correspondence.md:203`. The accepted IUCr alignment
-ADR made the default-save structure tier dictionary-aligned, including
-canonical `_atom_site.ADP_type`, `_atom_site.Wyckoff_symbol`,
-`_space_group.name_H-M_alt`, and
-`_space_group.IT_coordinate_system_code` on write, with legacy aliases
-accepted on read. Please update the current-correspondence rows so this
-ADR remains the Python-side companion to the accepted CIF-side policy.
-
-## Checks
-
-Static ADR review only. Per `/review-adr`, I did not edit the ADR under
-review, run tests, run formatters, run build commands, or invoke `pixi`.
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md b/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md
deleted file mode 100644
index 813104913..000000000
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence_review-2.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Review 2: Python and CIF Category Correspondence
-
-**No findings. Ready to commit.**
-
-Reply 1 addresses the previous findings by making `_project.*` an
-explicit `project.info` exception, refreshing the project persistence
-inventory, updating the constraint key correspondence, and aligning the
-structure rows with the accepted IUCr tag policy.
-
-Per `/review-adr`, this was a static ADR review only. I did not edit the
-ADR under review, run tests, run formatters, run build commands, or
-invoke `pixi`.

From 2de28dc2e2f5b18209d8714edebb67ac68908ee4 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 09:55:14 +0200
Subject: [PATCH 136/160] Reset zoom on view reset

---
 .../structure/templates/structure.html.j2        |  4 ++++
 .../display/structure/renderers/test_threejs.py  | 16 ++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 76d6ca42d..5353bd0c3 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -499,6 +499,10 @@ if (SCENE.axes) {
 
 const homeButton = iconButton(cameraGroup, ICONS.home, 'Reset view');
 homeButton.addEventListener('click', () => {
+  perspective.zoom = 1;
+  perspective.updateProjectionMatrix();
+  ortho.zoom = 1;
+  ortho.updateProjectionMatrix();
   camera.up.copy(viewUp);
   camera.position.copy(home);
   controls.target.copy(target);
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 6e0b91897..25d3fa6ef 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -619,6 +619,22 @@ def test_perspective_projection_uses_reduced_field_of_view(self, patched_theme):
         assert 'const PERSPECTIVE_FOV_DEG = 30;' in html
         assert 'new THREE.PerspectiveCamera(PERSPECTIVE_FOV_DEG,' in html
 
+    def test_reset_view_resets_orthographic_zoom(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+
+        assert "iconButton(cameraGroup, ICONS.home, 'Reset view');" in html
+        assert 'perspective.zoom = 1;' in html
+        assert 'perspective.updateProjectionMatrix();' in html
+        assert 'ortho.zoom = 1;' in html
+        assert 'ortho.updateProjectionMatrix();' in html
+        assert 'camera.position.copy(home);' in html
+        assert 'controls.target.copy(target);' in html
+
     def test_colour_scheme_select_matches_button_height(self, patched_theme):
         html = ThreeJsStructureRenderer().render(
             _rich_scene(),

From 4996044208b65e3ea96c45db30db0183479d4c98 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 10:17:11 +0200
Subject: [PATCH 137/160] Remove implemented plan records

---
 .../crysview-structure-visualization.md       |    5 +-
 .../adrs/accepted/value-selector-discovery.md |   12 +-
 docs/dev/issues/closed.md                     |   12 +-
 .../plans/crysview-structure-visualization.md | 1191 ---------------
 docs/dev/plans/iucr-cif-tag-alignment.md      |  640 --------
 docs/dev/plans/project-summary-rendering.md   | 1352 -----------------
 docs/dev/plans/structure-view-settings.md     |  396 -----
 7 files changed, 12 insertions(+), 3596 deletions(-)
 delete mode 100644 docs/dev/plans/crysview-structure-visualization.md
 delete mode 100644 docs/dev/plans/iucr-cif-tag-alignment.md
 delete mode 100644 docs/dev/plans/project-summary-rendering.md
 delete mode 100644 docs/dev/plans/structure-view-settings.md

diff --git a/docs/dev/adrs/accepted/crysview-structure-visualization.md b/docs/dev/adrs/accepted/crysview-structure-visualization.md
index cd25c4554..c6dd4c154 100644
--- a/docs/dev/adrs/accepted/crysview-structure-visualization.md
+++ b/docs/dev/adrs/accepted/crysview-structure-visualization.md
@@ -6,9 +6,8 @@ Accepted.
 
 **Date:** 2026-05-31
 
-**Implementation note:** The later
-[`structure-view-settings`](../../plans/structure-view-settings.md) plan
-split structure-view configuration into `rendering_structure`,
+**Implementation note:** A later implementation pass split
+structure-view configuration into `rendering_structure`,
 `structure_view`, and `structure_style`. This ADR reflects that final
 surface; no separate `structure-view-settings` ADR exists.
 
diff --git a/docs/dev/adrs/accepted/value-selector-discovery.md b/docs/dev/adrs/accepted/value-selector-discovery.md
index 8a24d8d2d..93f982e52 100644
--- a/docs/dev/adrs/accepted/value-selector-discovery.md
+++ b/docs/dev/adrs/accepted/value-selector-discovery.md
@@ -14,9 +14,8 @@ User-facing API.
 
 ## Implementation Note
 
-This ADR was implemented through the
-[`structure-view-settings`](../../plans/structure-view-settings.md)
-plan. That plan also amended
+This ADR was accepted as part of the structure-view settings cleanup,
+which also amended
 [`crysview-structure-visualization.md`](crysview-structure-visualization.md)
 for the structure-view settings split; no separate
 `structure-view-settings` ADR exists.
@@ -180,11 +179,8 @@ a discovery surface symmetric with the three category-level families.
   selectors only (the audit pins the exact set; the dynamic/external
   validators above are excluded and keep their current behavior).
   Affected enums gain `.default()`/`.description` where missing. The
-  phased rollout — and the matching narrowing of which
-  `atom_sites`/`space_group` fields are touched — is tracked by the
-  [`structure-view-settings`](../../plans/structure-view-settings.md)
-  implementation plan, which also reorganizes the structure-view
-  categories that motivated this ADR.
+  phased rollout also reorganized the structure-view categories that
+  motivated this ADR.
 
 ## Alternatives Considered
 
diff --git a/docs/dev/issues/closed.md b/docs/dev/issues/closed.md
index 4186146ed..cad61c363 100644
--- a/docs/dev/issues/closed.md
+++ b/docs/dev/issues/closed.md
@@ -6,16 +6,16 @@ Issues that have been fully resolved. Kept for historical reference.
 
 ## 103. Make `_sync_engine_from_minimizer_category` Skip-Keys Declarative
 
-Closed by [`emcee-minimizer.md`](../plans/emcee-minimizer.md). Minimizer
-categories now declare `_engine_sync_skip_keys`, and analysis sync
-filters against that set instead of hardcoding skipped keys.
+Closed by the emcee minimizer implementation. Minimizer categories now
+declare `_engine_sync_skip_keys`, and analysis sync filters against that
+set instead of hardcoding skipped keys.
 
 ---
 
 ## 101. Remove Dead Branch in `_fit_state_categories`
 
-Closed by [`emcee-minimizer.md`](../plans/emcee-minimizer.md). The
-deterministic branch that returned the same category list as the
+Closed by the emcee minimizer implementation. The deterministic branch
+that returned the same category list as the
 fallthrough path was removed while preserving unsupported `result_kind`
 warning behavior.
 
@@ -23,7 +23,7 @@ warning behavior.
 
 ## 100. Collapse Duplicate Predictive-Cache-Key Helpers
 
-Closed by [`emcee-minimizer.md`](../plans/emcee-minimizer.md).
+Closed by the emcee minimizer implementation.
 `posterior_predictive_cache_key()` in `analysis.fit_helpers.bayesian` is
 now the single helper used by analysis, plotting, and project display
 code.
diff --git a/docs/dev/plans/crysview-structure-visualization.md b/docs/dev/plans/crysview-structure-visualization.md
deleted file mode 100644
index 37f823392..000000000
--- a/docs/dev/plans/crysview-structure-visualization.md
+++ /dev/null
@@ -1,1191 +0,0 @@
-# Plan: crysview Structure Visualization
-
-Implementation plan for the
-[`crysview-structure-visualization`](../adrs/accepted/crysview-structure-visualization.md)
-ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
-exceptions to those instructions.
-
-> **Status (closed).** The feature has shipped on this branch and the
-> ADR has been promoted to accepted. The original Phase 2 checklist
-> below is retained as historical planning detail; active verification
-> was completed once against the final API through the
-> [`structure-view-settings`](structure-view-settings.md) plan. Some
-> prose below predates two later changes: the
-> `atom_shape`/`radius_model` → `atom_view` merge (commit `f31996da7`)
-> and the `structure-view-settings` split of `style` /
-> `rendering_structure` into `rendering_structure` (engine) +
-> `structure_view` + `structure_style`. See the accepted crysview ADR
-> and the `structure-view-settings` plan for the current design.
-
-> **Context for this plan.** This started as a **greenfield feature**:
-> there was no prior crysview implementation on the branch. The ADR
-> review cycle closed at the review-5 sentinel ("No findings. Ready to
-> commit."), so the design below is settled; this plan only makes it
-> concrete. It is a **single comprehensive plan** covering both shipping
-> engines (ASCII + Three.js), the original `view` and `style` categories
-> later split by `structure-view-settings`, the
-> `project.display.structure()` surface, CIF persistence, Three.js
-> bundling, the HTML-report structure figure, and tutorials — one
-> branch, one PR — matching the slug invoked and the project precedent
-> ([`project-summary-rendering`](project-summary-rendering.md) was one
-> large plan). The Phase 1 steps are ordered foundation-first (scene
-> model → builder → ASCII end-to-end → Three.js), so an early increment
-> is already terminal-viewable before the JavaScript work begins.
-
-## ADR cross-reference
-
-- **Primary (owned) ADR:**
-  [`crysview-structure-visualization.md`](../adrs/accepted/crysview-structure-visualization.md)
-  (accepted; ADR review cycle closed at the review-5 sentinel). This
-  plan originally owned the ADR during drafting; the ADR and index row
-  have since been promoted.
-- **Referenced accepted ADRs** (the design builds on these; none are
-  amended):
-  - [`display-ux.md`](../adrs/accepted/display-ux.md) — defines
-    `project.display` and the `pattern()` / `show_pattern_options()`
-    surface this plan parallels with `structure()` /
-    `show_structure_options()`.
-  - [`switchable-category-owned-selectors.md`](../adrs/accepted/switchable-category-owned-selectors.md)
-    and
-    [`switchable-category-api.md`](../adrs/accepted/switchable-category-api.md)
-    — the contract the new switchable `view` category follows
-    (`project.rendering_structure` read-only attribute;
-    `project.rendering_structure.type` writable selector;
-    `project.rendering_structure.show_supported()`; private
-    `_swap_rendering_structure` hook, Family B engine rebind).
-  - [`selector-families.md`](../adrs/accepted/selector-families.md) —
-    `view` is a switchable-category selector (Family B), like `chart` /
-    `table`.
-  - [`enum-backed-closed-values.md`](../adrs/accepted/enum-backed-closed-values.md)
-    — every closed value set is a `(str, Enum)`.
-  - [`factory-contracts.md`](../adrs/accepted/factory-contracts.md),
-    [`factory-tag-naming.md`](../adrs/accepted/factory-tag-naming.md) —
-    `@Factory.register` and tag-naming conventions for the new
-    renderer/category factories.
-  - [`category-owner-sections.md`](../adrs/accepted/category-owner-sections.md),
-    [`project-facade-and-persistence.md`](../adrs/accepted/project-facade-and-persistence.md)
-    — how owner-level categories persist to `project.cif`.
-- No **new** ADR is required. The owned suggestion ADR is the
-  authoritative reference.
-
-## Branch and PR
-
-- **Recommended branch:** `crysview-structure-visualization` (flat slug,
-  off `develop`, per AGENTS.md §Planning). **Do not create or switch
-  branches** while running the shortcut — stay on the current branch;
-  the branch note is for when the work is eventually pushed.
-- **PR target:** `develop`.
-- Do not push the branch until both Phase 1 and Phase 2 review cycles
-  close.
-
-## Decisions already made
-
-Settled by the accepted ADR (not re-litigated here), plus three
-plan-level structural choices confirmed with the author at plan start.
-
-### From the ADR
-
-- **Renderer-neutral scene + thin renderers** (§1, §2): all
-  crystallographic computation (symmetry expansion,
-  fractional→Cartesian, ADP eigendecomposition, radius/colour lookup,
-  bond detection, occupancy splitting) happens in a scene **builder**,
-  upstream of any renderer. Renderers consume a flat set of typed
-  Cartesian primitives carrying no rendering-library types.
-- **Two shipping engines** (§2): `ascii` (terminal/headless) and
-  `threejs` (notebook + standalone HTML), shipping together exactly as
-  the `asciichartpy` and `plotly` chart engines do. Qt Quick 3D is
-  deferred.
-- **Switchable `rendering_structure` selector** (§2):
-  `project.rendering_structure.type` (`'auto'` default, resolving to
-  `'threejs'` in Jupyter / `'ascii'` in a terminal), CIF
-  `_rendering_structure.type`, following the category-owned selector
-  contract with a private `_swap_rendering_structure` Family B rebind.
-  No `rendering_structure_type` setter, no
-  `show_supported_rendering_structure_types()`.
-- **`structure()` entry point** (§3):
-  `project.display.structure(struct_name=...)` parallel to
-  `pattern(expt_name=...)`, with `include=` reusing the pattern
-  vocabulary (`auto`, `atoms`, `bonds`, `cell`, `axes`, `moments`,
-  `labels`); a companion `show_structure_options(struct_name=...)`
-  mirrors `show_pattern_options()`. Notebook embeds an interactive view
-  (IPython HTML repr); a standalone HTML file can be written to a path.
-- **Per-axis fractional range** (§3): six scalar bounds
-  `project.rendering_structure.range_{a,b,c}_{min,max}` (defaults 0 and
-  1 = full cell, **borders included**), mirroring the six scalar cell
-  parameters; non-integer allowed, validated min < max per axis,
-  persisted; a per-call `range=` tuple on `structure()` overrides for
-  one call.
-- **Scene-atom identity rule** (§3): two generated atoms are the same
-  scene atom iff same atom-site row **and** fractional coordinates
-  coincide within `1e-4` (fractional units); keep one, drop the rest.
-  Border copies at 0 and 1 are distinct positions and both survive.
-- **Occupancy grouping** (§3): distinct atom-site rows resolving to the
-  same position (within `1e-4`) group into one occupancy-wedge sphere,
-  each wedge proportional to occupancy. Sum < 1 → vacancy wedge; sum ≥ 1
-  → normalize to sum, no vacancy wedge. The builder invents no
-  occupancies.
-- **ASCII is the reduced-fidelity sibling** (§3, §7): always renders the
-  single default cell, no bonds/labels/ellipsoids/moments; announces
-  every 3D-only feature (including a wider `range`) through
-  `show_structure_options()` and at draw time, exactly as the ascii
-  chart engine announces Plotly-only features.
-- **Styling = atom-shape mode + standard models** (§6, visual only):
-  `atom_shape` (`ball` | `ortep`, default `ortep`), `radius_model`
-  (`vdw` | `covalent` | `ionic` | `atomic`, default `covalent`),
-  `color_scheme` (`jmol` | `vesta` | …, default `jmol`),
-  `adp_probability` (fraction in open interval (0,1), default `0.5`,
-  ortep-only). All enum-backed and CIF-persisted to the project CIF;
-  `project.style.show_supported()` lists accepted values. Bond cutoffs
-  are **not** here — they are a per-structure property (see below).
-- **Bundled element database** (§6): one package asset (not
-  CIF-serialized) carrying, per element, the `vdw` / `covalent` /
-  `ionic` (representative Shannon) / `atomic` radii and the `jmol` /
-  `vesta` colour palettes, each with documented provenance. `covalent`
-  is the default model because it needs no charge and is fully
-  populated. An element missing an entry for the selected model falls
-  back to its covalent radius; `show_structure_options()` reports the
-  substitution rather than failing.
-- **Bond cutoffs are per-structure, not styling** (§6, §8): bond
-  generation uses the standard cif_core `_geom` cutoffs
-  (`_geom.min_bond_distance_cutoff`, `_geom.bond_distance_incr`) plus a
-  per-type bonding radius (`_atom_type.radius_bond`, covalent by
-  default), on the structure and persisted in the structure CIF —
-  independent of the display `radius_model`. Version 1 draws bonds on
-  the fly; the full computed `_geom_bond` / `_geom_angle` tables are
-  deferred.
-- **Dark/light theme is auto-detected** (§6): the view reuses the
-  project's `is_dark()` detection (mirroring the Plotly engine's
-  `plotly_dark`/`plotly_white` switch) to theme the canvas +
-  annotations; element colours still come from the chosen scheme. Not
-  persisted.
-- **Pinned, bundled Three.js** (§5): `three@0.160.0` + `OrbitControls` +
-  `CSS2DRenderer` ship as **vendored static assets**, embedded inline
-  for the notebook and standalone HTML (autonomous, no network), and
-  embedded vs linked in the HTML report under the report's existing
-  `html_offline` flag — the same switch that already governs
-  Plotly/MathJax.
-- **Visibility precedence** (§8): explicit `include=(...)` tuple wins
-  outright (ignores persisted `_rendering_structure.show_*`);
-  `include='auto'` resolves each feature from data-availability →
-  persisted flag (only `show_labels` off, `show_moments` on-where-data)
-  → built-in default; unsupported options are skipped and announced,
-  never errored; live modebar toggles are runtime-only and never rewrite
-  persisted state.
-- **Moments stay gated** (§3, Deferred Work): the scene model carries a
-  moment-arrow primitive, but the builder never emits it because the
-  structure model has no moment fields today; `show_moments` is inert
-  and `show_structure_options()` reports `moments` unavailable.
-
-### Plan-level structural choices (confirmed at plan start)
-
-- **Single comprehensive plan / one PR** (vs. a foundation-first split):
-  ASCII and Three.js land together on one branch. The step order is
-  still foundation-first so the ASCII path is end-to-end before any JS
-  work.
-- **Dedicated cohesive subpackage** (ADR §4): the viewer subsystem lives
-  under `src/easydiffraction/display/structure/` with a `renderers/`
-  subpackage, keeping the renderer-neutral scene model + renderers
-  together as a future extraction unit (`crysview`). The **scene model**
-  (`scene.py`) imports nothing from easydiffraction domain code; the
-  **builder** (`builder.py`) is the easydiffraction-specific adapter.
-  The name `display/structure/` is **fixed by ADR §4** and used verbatim
-  by every Phase 1 step and Phase 2 test path below — it is **not** an
-  open question. It does not collide with `datablocks/structure/`: the
-  two live under different parents (`easydiffraction.display.structure`
-  vs `easydiffraction.datablocks.structure.categories`), so there is no
-  import ambiguity, and the rename candidate is dropped.
-- **Crystallographic math centralized**: the new orthogonalization
-  (fractional→Cartesian) and ADP-tensor eigendecomposition helpers are
-  added to `src/easydiffraction/crystallography/crystallography.py`
-  (where symmetry-operation parsing and ADP-constraint math already
-  live), and the existing symmetry-op generator
-  (`_get_general_position_ops`) is reused (promoted to a public entry
-  point if needed). The display builder stays a thin adapter.
-
-## Open questions — all resolved for autonomous implementation
-
-These were open during drafting and are now **resolved** (clarified with
-the author), so `/draft-impl-1` can run Phase 1 with **no
-stop-and-ask**. Each item records the final decision; the data sources
-below were verified reachable (HTTP 200).
-
-- **Exact CIF tag spelling for `style`, `view`, and `geom`** (ADR Open
-  Question 1) — **Resolved (final).** Project CIF: `_style.atom_shape`,
-  `_style.radius_model`, `_style.color_scheme`,
-  `_style.adp_probability`, and `_rendering_structure.type`,
-  `_rendering_structure.show_labels`,
-  `_rendering_structure.show_moments`, plus the per-axis range as six
-  scalar tags `_rendering_structure.range_a_min` /
-  `_rendering_structure.range_a_max` /
-  `_rendering_structure.range_b_min` /
-  `_rendering_structure.range_b_max` /
-  `_rendering_structure.range_c_min` /
-  `_rendering_structure.range_c_max` (one number each, defaults 0 and
-  1), mirroring the cell parameters. Structure CIF (per-structure): the
-  **standard cif_core** bond cutoffs `_geom.min_bond_distance_cutoff`
-  (default `0.0`) and `_geom.bond_distance_incr` (default `0.25`), plus
-  the per-type bonding radius `_atom_type.radius_bond` when present
-  (P1.11). `_rendering_structure.type` follows the Display-UX ADR
-  (`_rendering_plot.type` / `_rendering_table.type`); `_style.*` and
-  `_rendering_structure.*` are project-internal app/settings tags; the
-  bond cutoffs use the standard `_geom.*` category `cif_core.dic`
-  defines (`_geom.min_bond_distance_cutoff` dic 13084,
-  `_geom.bond_distance_incr` dic 13044), while the computed
-  `_geom_bond.*` / `_geom_angle.*` loops are a separate, deferred
-  concern. No further confirmation needed during implementation.
-- **ASCII rendering details** (ADR Open Question 2) — **Resolved (final
-  for v1).** A **4-bucket** radius glyph ramp `· • ● ⬤`, and the **8/16
-  colour ANSI** mapping the existing ascii chart legend already uses
-  (`display/plotters/ascii.py`), reused verbatim. Implementers may
-  fine-tune glyph/colour choices against a terminal, but the ramp size
-  and the ANSI palette are fixed — no design decision remains.
-- **Range boundary completion** (ADR Open Question 3) — **Resolved
-  (final for v1).** The scene contains only atoms whose fractional
-  coordinates fall inside the range (borders included); bonds are drawn
-  **only between atoms already in the scene**, so no partner atoms
-  outside the range are generated and no edge-coordination completion is
-  attempted in v1. (Boundary completion can be revisited in a later
-  version.)
-- **Three.js asset acquisition** — **Resolved (URLs verified, HTTP
-  200).** Fetch and vendor these exact pinned files in P1.13 (network
-  needed for that step only), recording the URLs + version (MIT) in the
-  vendored `LICENSES.md`:
-  - `https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js`
-  - `https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/controls/OrbitControls.js`
-  - `https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/renderers/CSS2DRenderer.js`
-    These are **static JS assets, not a Python dependency**, so no
-    `pyproject.toml` change is required (and none is pre-approved).
-- **Plain-category base for `style`.** Resolved: model `Style` on
-  `project/categories/verbosity/` (and `info` / `publication` /
-  `report`), which are the existing plain (non-switchable) categories
-  with the `default.py` + `factory.py` shape — `Verbosity(CategoryItem)`
-  registers via `@VerbosityFactory.register`, derives from
-  `CategoryItem` only (no `SwitchableCategoryBase`), and uses
-  enum-backed `StringDescriptor`s with a `MembershipValidator` and a
-  getter/setter property per setting. `project/categories/rendering/`
-  has no `default.py` / `factory.py`, so it is **not** a usable template
-  and is dropped as a model.
-- **Element data provenance** — **Resolved.** Covalent + vdW radii and
-  Jmol colours from EasyDiffractionBeta `Tables.py` (BSD-3-Clause).
-  Ionic (Shannon) from pymatgen `Shannon_Radii.csv`, atomic from
-  pymatgen `radii.csv`, VESTA colours from pymatgen
-  `ElementColorSchemes.yaml` (all MIT, verified reachable). Shannon
-  representative selection and full URLs are pinned in P1.4. Each
-  value's source is recorded in `LICENSES.md`.
-
-## Concrete files likely to change
-
-**New viewer subsystem (`display/structure/`):**
-
-- `src/easydiffraction/display/structure/__init__.py` (new — package
-  docstring; no `__all__`, explicit imports per AGENTS.md).
-- `src/easydiffraction/display/structure/enums.py` (new —
-  `ViewerEngineEnum`, `AtomShapeEnum`, `RadiusModelEnum`,
-  `ColorSchemeEnum`, each `(str, Enum)` with a `default()` classmethod,
-  modelled on `src/easydiffraction/display/plotting.py:50`
-  `PlotterEngineEnum`).
-- `src/easydiffraction/display/structure/scene.py` (new — frozen
-  dataclasses for the renderer-neutral primitives + `StructureScene`
-  container; **no easydiffraction-domain imports**).
-- `src/easydiffraction/display/structure/builder.py` (new —
-  `build_scene(...)`, the easydiffraction adapter reading structure
-  categories and calling the crystallography helpers).
-- `src/easydiffraction/display/structure/assets/elements.py` (new — the
-  extended per-element database: `vdw`/`covalent`/`ionic`/`atomic`
-  radii + `jmol`/`vesta` palettes, seeded from EasyDiffractionBeta
-  `Tables.py`).
-- `src/easydiffraction/display/structure/assets/radii.py` (new —
-  `radius_for(element, model)` lookup over the database, covalent
-  fallback).
-- `src/easydiffraction/display/structure/assets/colors.py` (new —
-  `color_for(element, scheme)` + a/b/c axis colours + theme-dependent
-  canvas/annotation colours).
-- `src/easydiffraction/display/structure/assets/LICENSES.md` (new —
-  per-source provenance/licence for the vendored element data).
-- `src/easydiffraction/display/structure/viewing.py` (new —
-  `Viewer(RendererBase)` facade + `ViewerFactory(RendererFactoryBase)`,
-  modelled on `src/easydiffraction/display/plotting.py` `PlotterFactory`
-  and `src/easydiffraction/display/tables.py` `TableRendererFactory`).
-- `src/easydiffraction/display/structure/renderers/__init__.py` (new).
-- `src/easydiffraction/display/structure/renderers/base.py` (new —
-  `StructureRendererBase(ABC)`).
-- `src/easydiffraction/display/structure/renderers/ascii.py` (new —
-  `AsciiStructureRenderer`, `@ViewerFactory.register`).
-- `src/easydiffraction/display/structure/renderers/threejs.py` (new —
-  `ThreeJsStructureRenderer`, `@ViewerFactory.register`).
-- `src/easydiffraction/display/structure/renderers/vendor/threejs/` (new
-  — vendored `three.module.js`, `OrbitControls.js`, `CSS2DRenderer.js` +
-  `LICENSES.md`).
-- `src/easydiffraction/display/structure/templates/structure.html.j2`
-  (new — the Three.js HTML/JS shell; mirrors
-  `report/templates/html/report.html.j2`'s offline/online asset switch).
-
-**Core validation (exclusive-bound support for `adp_probability`):**
-
-- `src/easydiffraction/core/validation.py` (existing — extend
-  `RangeValidator` (`core/validation.py:169`) with optional exclusive
-  `gt` / `lt` bounds so a value can be validated in the **open**
-  interval `(0, 1)`; the current `ge` / `le` inclusive bounds stay
-  unchanged and default to ±∞, so every existing caller is unaffected).
-  Needed because the only numeric validator today is inclusive-only and
-  cannot reject `0.0` / `1.0` for `adp_probability` (ADR §6).
-
-**New project categories:**
-
-- `src/easydiffraction/project/categories/rendering_structure/__init__.py`,
-  `default.py`, `factory.py` (new —
-  `View(CategoryItem, SwitchableCategoryBase)`,
-  `RenderingStructureFactory(FactoryBase)`, modelled on
-  `src/easydiffraction/project/categories/rendering_plot/`).
-- `src/easydiffraction/project/categories/style/__init__.py`,
-  `default.py`, `factory.py` (new — `Style` plain category +
-  `StyleFactory`, modelled on the existing plain category under
-  `src/easydiffraction/project/categories/verbosity/`).
-
-**New per-structure datablock category (bond cutoffs):**
-
-- `src/easydiffraction/datablocks/structure/categories/geom/__init__.py`,
-  `default.py`, `factory.py` (new — `Geom` single-record `CategoryItem`
-  with `min_bond_distance_cutoff` / `bond_distance_incr`, modelled on
-  the structure `cell` / `space_group` categories; standard CIF
-  `_geom.*` in the structure datablock).
-- `src/easydiffraction/datablocks/structure/item/base.py` (existing —
-  add the `geom` category to `Structure`, mirroring how `cell` /
-  `atom_sites` are owned).
-
-**Crystallography helpers:**
-
-- `src/easydiffraction/crystallography/crystallography.py` (existing —
-  add public `orthogonalization_matrix(a,b,c,alpha,beta,gamma)`,
-  `fractional_to_cartesian(...)`, `adp_principal_axes(tensor)`
-  (eigendecomposition → semi-axis lengths + orientation); reuse /
-  promote `_get_general_position_ops` for symmetry expansion).
-- `src/easydiffraction/crystallography/__init__.py` (existing — export
-  any newly public helpers per the explicit-`__init__` rule).
-
-**Project wiring + persistence:**
-
-- `src/easydiffraction/project/project.py` (existing — add `view` /
-  `style` read-only properties and the private
-  `_swap_rendering_structure` hook, mirroring `_swap_rendering_plot` at
-  `project.py:238`).
-- `src/easydiffraction/project/project_config.py` (existing — import +
-  instantiate `RenderingStructureFactory` / `StyleFactory` defaults,
-  mirroring the chart/table wiring at `project_config.py:36`).
-- The CIF read-side hook that restores chart/table (in
-  `project_config.py` / the project-config CIF deserializer) — extend to
-  restore `_rendering_structure.*` / `_style.*` (mirrors the chart
-  `from_cif` at `project/categories/rendering_plot/default.py:94`).
-
-**Display facade:**
-
-- `src/easydiffraction/project/display.py` (existing — add
-  `structure(struct_name=..., include='auto', range=None, path=None)`
-  and `show_structure_options(struct_name=...)` to the class that backs
-  `project.display` and already owns `pattern()` /
-  `show_pattern_options()`; add the structure `include`-option
-  descriptions alongside `_PATTERN_OPTION_DESCRIPTIONS`).
-
-**HTML report integration:**
-
-- `src/easydiffraction/report/html_renderer.py` (existing — embed the
-  structure figure honoring `html_offline`, mirroring the Plotly/MathJax
-  offline path at `html_renderer.py:170` and the MathJax copy at
-  `_copy_mathjax`).
-- `src/easydiffraction/report/templates/html/report.html.j2` (existing —
-  optional structure-figure block under the same `html_offline` switch).
-
-**Packaging + lint/coverage excludes (vendored assets):**
-
-- `pyproject.toml` (existing — add the new vendored Three.js path to the
-  `[tool.ruff]`, `[tool.coverage.run]`, `[tool.interrogate]`, pydoclint,
-  and format-docstring `exclude` lists, mirroring the existing
-  `report/templates/html/vendor` entries; confirm hatchling's wheel
-  packaging ships the new `display/structure/renderers/vendor/` and
-  `display/structure/templates/` subtrees, adding a `force-include` rule
-  only if the defaults miss them).
-- `THIRD_PARTY_LICENSES.md` (existing at repo root — add the Three.js
-  entry and the element-data provenance entry).
-
-**ADR index + ADR promotion (handled by `/draft-impl-1` Phase A /
-P1.16):**
-
-- `docs/dev/adrs/index.md` (existing — add a **User-facing API** row for
-  the crysview ADR).
-- `docs/dev/adrs/accepted/crysview-structure-visualization.md` (promoted
-  after implementation; its `_review-*` / `_reply-*` siblings were
-  removed during the implementation workflow).
-
-**Tutorials and docs:**
-
-- `docs/docs/tutorials/*.py` (existing — add a structure-view example to
-  a representative tutorial; regenerate notebooks via
-  `pixi run notebook-prepare`).
-- `docs/docs/tutorials/*.ipynb` (regenerated artefacts).
-- `docs/docs/user-guide/` and `docs/docs/api-reference/` (existing — add
-  `project.display.structure()`, `project.rendering_structure`,
-  `project.structure_view`, and `project.structure_style` references + a
-  short user-guide section).
-
-## Commit discipline
-
-When an AI agent follows this plan, **every completed Phase 1
-implementation step must be staged with explicit paths and committed
-locally before moving to the next implementation step or the Phase 1
-review gate.** Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
-**Commits**. Keep commits atomic, single-purpose, and aligned with the
-plan steps. Stage only the files a step enumerates; do not include
-generated artifacts (project directories, data CIFs, benchmark CSVs,
-built wheels) unless a step explicitly produces them — see **Workflow**
-in [`AGENTS.md`](../../../AGENTS.md) for the generated-artifact
-exceptions.
-
-## Implementation steps (Phase 1)
-
-Ordered foundation-first: the scene model, builder, and ASCII engine
-reach end-to-end (P1.1–P1.12) before any Three.js work (P1.13–P1.15).
-
-- [x] **P1.1 — Add viewer + styling enums**
-  - Files: new `src/easydiffraction/display/structure/__init__.py`,
-    `src/easydiffraction/display/structure/enums.py`.
-  - Define four `(str, Enum)` classes per the Enum-Backed Closed Values
-    ADR, each with a `default()` classmethod (model on
-    `PlotterEngineEnum` at `display/plotting.py:50`):
-    - `ViewerEngineEnum`: `ASCII = 'ascii'`, `THREEJS = 'threejs'`, with
-      an **environment-aware `default()`** (`threejs` in Jupyter,
-      `ascii` in a terminal), matching `PlotterEngineEnum` /
-      `TableEngineEnum`. The `view` category adds an `'auto'` selector
-      sentinel resolved through `default()`, so
-      `project.rendering_structure.type` defaults to `auto` and the ADR
-      §8 persisted example is `_rendering_structure.type auto`; see P1.9
-      and the headless note there.
-    - `AtomShapeEnum`: `BALL = 'ball'`, `ORTEP = 'ortep'` (default
-      `ORTEP`).
-    - `RadiusModelEnum`: `VDW = 'vdw'`, `COVALENT = 'covalent'`,
-      `IONIC = 'ionic'`, `ATOMIC = 'atomic'` (default `COVALENT` — the
-      charge-free model with complete per-element data).
-    - `ColorSchemeEnum`: `JMOL = 'jmol'`, `VESTA = 'vesta'` (default
-      `JMOL`).
-  - `__init__.py`: package docstring only; explicit imports added as
-    later steps land modules (no `__all__`).
-  - Commit: `Add crysview viewer and styling enums`.
-
-- [x] **P1.2 — Add the renderer-neutral scene model**
-  - Files: new `src/easydiffraction/display/structure/scene.py`.
-  - `@dataclass(frozen=True, slots=True)` primitives in Cartesian space,
-    carrying only stdlib / numpy / RGB-tuple types — **no
-    easydiffraction-domain imports** (extraction constraint, ADR §4):
-    - `AtomSphere` (centre, radius, colour, label).
-    - `OccupancyWedgeSphere` (centre, radius, ordered
-      `(fraction, colour)` wedges incl. an optional vacancy wedge,
-      label).
-    - `AdpEllipsoid` (centre, semi-axis lengths, orientation
-      matrix/quaternion, colour, label).
-    - `Bond` (two endpoints, two colours split at midpoint).
-    - `MomentArrow` (origin, vector, colour) — **defined but never
-      emitted in version 1** (gated, ADR §1 + Deferred Work). It still
-      carries a numpy-style docstring like every other primitive (so
-      `interrogate` passes) and is exercised by a direct construction
-      test in Phase 2 (so it is not a coverage gap despite the builder
-      never emitting it).
-    - `CellEdges` (the 12 edges, as Cartesian segment endpoints).
-    - `AxisTriad` (a/b/c arrow vectors + per-axis colours + letters).
-    - `TextLabel` (anchor, text).
-    - `StructureScene` — the flat container holding lists of the above
-      plus the cell basis used for projection.
-  - Numpy-style docstrings ≤72-char summaries on every public class.
-  - Commit: `Add renderer-neutral structure scene model`.
-
-- [x] **P1.3 — Add crystallographic geometry helpers**
-  - Files: existing
-    `src/easydiffraction/crystallography/crystallography.py`,
-    `src/easydiffraction/crystallography/__init__.py`.
-  - Add public helpers (centralized math decision):
-    - `orthogonalization_matrix(a, b, c, alpha, beta, gamma) -> np.ndarray`
-      — the 3×3 fractional→Cartesian matrix from cell parameters
-      (standard crystallographic convention; document the chosen axis
-      setting).
-    - `fractional_to_cartesian(frac, matrix) -> np.ndarray`.
-    - `adp_principal_axes(tensor) -> tuple[np.ndarray, np.ndarray]` —
-      eigendecomposition (`numpy.linalg.eigh`) of a symmetric 3×3 ADP
-      tensor returning semi-axis lengths + orientation; document the
-      U-vs-B and Cartesian-vs-crystal convention used.
-    - A public symmetry-expansion entry point reusing the existing
-      `_get_general_position_ops` / `_parse_rotation_matrix`
-      (`crystallography.py:399`, `:350`) — either promote
-      `_get_general_position_ops` to public or add a thin public wrapper
-      that yields `(rotation, translation)` ops for a space group.
-  - Export any newly public helpers from `crystallography/__init__.py`.
-  - Commit: `Add orthogonalization and ADP eigendecomposition helpers`.
-
-- [x] **P1.4 — Build the extended element database (radii + colours)**
-  - Files: new
-    `src/easydiffraction/display/structure/assets/__init__.py`,
-    `assets/elements.py` (or a vendored data file + loader),
-    `assets/radii.py`, `assets/colors.py`, `assets/LICENSES.md`.
-  - Build **one extended per-element database** as a package asset (not
-    CIF-serialized), complete for the elements EasyDiffraction handles,
-    carrying for each element the four radii (`vdw`, `covalent`, `ionic`
-    representative Shannon at a documented default oxidation
-    state/coordination, `atomic`) and the `jmol`/CPK and `vesta` colour
-    palettes, every value tagged with its provenance.
-  - **Seed from our own prior data, then extend from verified sources.**
-    EasyDiffractionBeta's `easyDiffractionApp/Logic/Tables.py`
-    `PERIODIC_TABLE` (BSD-3-Clause, our project) provides the Jmol/CPK
-    `color` and the `covalent` and `vdW` radii per element — reuse
-    verbatim with provenance. Fetch the remaining values from
-    **pymatgen** (MIT; each URL verified reachable, HTTP 200),
-    **extracting the data values, not adding a runtime dependency**. Raw
-    URLs under
-    `https://raw.githubusercontent.com/materialsproject/pymatgen/master/`:
-    - **Ionic (Shannon)** radii →
-      `dev_scripts/periodic_table_resources/Shannon_Radii.csv` (columns
-      `Element, Charge, Coordination, Spin State, Crystal Radius, Ionic Radius`;
-      original: R. D. Shannon, Acta Cryst. (1976) A32, 751).
-    - **Atomic** radii →
-      `dev_scripts/periodic_table_resources/radii.csv` (`Atomic radius`
-      column; `Van der waals radius` there is a cross-check of the
-      seed).
-    - **VESTA** (and Jmol cross-check) colours →
-      `src/pymatgen/vis/ElementColorSchemes.yaml` (`Jmol:` / `VESTA:`
-      RGB maps; VESTA original: Momma & Izumi, J. Appl. Cryst. 2011).
-      Cite each pymatgen file URL **and** the primary scientific
-      reference in `LICENSES.md`. **Network access is needed for this
-      step** to fetch these.
-  - **Shannon representative-radius policy (deterministic,
-    reproducible).** The atom-site model carries only an element symbol,
-    so pick exactly one Shannon row per element by a fixed rule:
-    **charge** = walk the element's oxidation states from pymatgen
-    `dev_scripts/periodic_table_resources/oxidation_states.yaml` (same
-    repo/raw-URL base, verified reachable HTTP 200) in listed order,
-    keeping those that have a Shannon entry, then any remaining Shannon
-    charges (lowest `|charge|` first) — this keeps anions such as O²⁻ /
-    F⁻, not just cations; **coordination** = `VI` (else the lowest
-    coordination present); **spin** = high-spin where a spin state is
-    listed; take the `Ionic Radius` column, skipping non-physical
-    (non-positive) entries such as the H⁺ value. The first charge that
-    yields a positive radius wins; if none does, fall back to the
-    covalent radius (the `substituted` flag). Record the chosen
-    `(charge, coordination)` per element in `LICENSES.md`. Ionic is not
-    the default model, so this only applies when the user selects
-    `radius_model = 'ionic'`. (Result: 93/118 elements carry a Shannon
-    radius; the rest fall back to covalent.)
-  - `radii.py`: `radius_for(element, model) -> tuple[float, bool]`
-    lookup returning the radius and a `substituted` flag; a miss for the
-    selected model (e.g. an element with no ionic entry) falls back to
-    **covalent** (the default model, always populated), surfaced by
-    `show_structure_options()` per ADR §6.
-  - `colors.py`: `color_for(element, scheme) -> RGB` for `jmol` /
-    `vesta`, plus the a/b/c axis colours the scene gives every engine,
-    plus the theme-dependent canvas/annotation colours the renderers
-    read from `is_dark()` (P1.14).
-  - `assets/LICENSES.md`: per-source provenance + licence (Tables.py
-    seed; Shannon ionic; atomic; VESTA), no hand-guessed values.
-  - Commit: `Add extended element database for radii and colours`.
-
-- [x] **P1.5 — Add the scene builder**
-  - Files: new `src/easydiffraction/display/structure/builder.py`.
-  - `build_scene(structure, *, style, view_range, features) -> StructureScene`,
-    the easydiffraction adapter. **`features` is the already-resolved
-    concrete set of primitives to emit (e.g.
-    `frozenset({'atoms', 'bonds', 'cell', 'axes'})`), never the raw
-    `'auto'` request** — the builder only decides which primitive lists
-    to populate and **never re-implements ADR §8 precedence** (that is
-    the facade's job, P1.12):
-    - Read cell (`cell.length_a…angle_gamma`), atom sites (`atom_sites`:
-      label, `type_symbol`, `fract_x/y/z`, `occupancy`, `adp_iso`,
-      `adp_type`), anisotropic ADP (`atom_site_aniso.adp_11…adp_23`),
-      and the space group (`space_group.name_h_m`,
-      `it_coordinate_system_code`).
-    - **Symmetry expansion** over `view_range` using the P1.3 ops; keep
-      every generated copy whose fractional coords fall in the per-axis
-      range, **borders included**.
-    - **Scene-atom identity dedup**: same atom-site row + coords within
-      `1e-4` → keep one (ADR §3).
-    - **Occupancy grouping**: distinct rows at the same position (within
-      `1e-4`) → one `OccupancyWedgeSphere` with proportional wedges; sum
-      < 1 → vacancy wedge; sum ≥ 1 → normalize (ADR §3).
-    - **fractional→Cartesian** via P1.3.
-    - **Atom shape** (style.atom*shape): `ortep` → `AdpEllipsoid` from
-      `adp_principal_axes` scaled to `adp_probability` (anisotropic) or
-      a radius-model sphere (isotropic / no ADP); `ball` → radius-model
-      sphere always. The display radius model sets sphere \_size* only —
-      it does **not** drive bond detection (bonds use the `_geom`
-      cutoffs below).
-    - **Bonds**: between in-scene atoms whose separation `d` satisfies
-      the standard cif_core `_geom` auto-bonding rule (P1.11) —
-      `geom.min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + geom.bond_distance_incr`,
-      where `r_bond` is `_atom_type.radius_bond` when the structure
-      carries it, else the element's covalent radius from the bundled DB
-      (P1.4). Matches are then pruned to the first coordination shell
-      (kept only within `1.3×` the nearer atom's nearest-neighbour
-      distance, `COORDINATION_SHELL_FACTOR`) so large ionic-cation
-      covalent radii do not over-bond — a heuristic stop-gap, see open
-      issue #108. Split-coloured at midpoint; only atoms already in the
-      scene (no out-of-range partners, see Open Questions). The builder
-      reads the cutoffs from `structure.geom`, like cell/atom data —
-      they are not styling and are independent of the display
-      `radius_model`.
-    - **Cell edges + axis triad + labels** always built; **moments never
-      emitted** (gated).
-  - **Single source of truth for visibility.** The builder receives the
-    facade-resolved `features` set and populates exactly those primitive
-    lists — it does not see `'auto'`, persisted `show_*` flags, or the
-    `include=` request, so ADR §8 precedence lives only in the facade
-    (P1.12).
-  - **Data-availability probe (same module).** Add
-    `structure_feature_availability(structure, *, style) -> FeatureAvailability`
-    — a lightweight read of the structure (no full scene build)
-    reporting, per feature, whether the data exists (e.g. `moments`
-    always absent in version 1; `bonds`/`axes`/`cell` always available;
-    `labels` always available) **plus** the ionic→covalent radius
-    substitutions the chosen `radius_model` would trigger. The builder
-    is the only place that reads the structure, so this probe is the one
-    source both the facade's `'auto'` resolution **and**
-    `show_structure_options()` (P1.12) call; neither re-reads the
-    structure for availability.
-  - Commit: `Add structure scene builder`.
-
-- [x] **P1.6 — Add base + ASCII structure renderer**
-  - Files: new
-    `src/easydiffraction/display/structure/renderers/__init__.py`,
-    `renderers/base.py`, `renderers/ascii.py`.
-  - `StructureRendererBase(ABC)`: abstract `render(scene, *, features)`
-    contract (the content-resolved feature set from the facade, per
-    P1.12) and a `supported_features()` capability hook with two
-    distinct readers: (a) the **renderer** uses it to filter the passed
-    `features` set and announce + skip what it cannot draw (the
-    render-time owner, per P1.12); (b) the **facade** queries it **only
-    to preview** availability through `show_structure_options()` — the
-    facade never intersects or drops features itself.
-  - **Registration import point (AGENTS.md §Architecture).**
-    `renderers/__init__.py` explicitly imports the concrete renderer
-    class — `AsciiStructureRenderer` now, `ThreeJsStructureRenderer` in
-    P1.14 — so the package `__init__.py` is the single import point per
-    the convention, **not** an import side-effect in `viewing.py`. At
-    this step `ViewerFactory` does not exist yet (it lands in P1.7), so
-    `AsciiStructureRenderer` carries **no** decorator and importing the
-    package registers nothing yet. P1.7 attaches
-    `@ViewerFactory.register` once the factory exists, and that is when
-    importing the package triggers registration.
-  - `AsciiStructureRenderer` (ADR §7), the reduced-fidelity sibling:
-    - Project the scene's Cartesian atom centres + cell edges onto a
-      plane (longest in-plane axis horizontal, shortest vertical, middle
-      axis = viewing direction).
-    - Draw the cell as a schematic parallelogram using the asciichartpy
-      glyph set (`│ ╭ ╮ ╯ ╰ ─`); add a **row-major gap-free line
-      helper** generalizing the existing asciichartpy connector used by
-      `display/plotters/ascii.py` (column-major) so near-vertical
-      slanted edges rasterize.
-    - Atoms as colour-by-element Unicode circles on a radius-bucketed
-      glyph ramp; axis arrows tinted with the a/b/c scheme colours
-      (nearest terminal colour, reset after); a colour-tinted legend.
-    - Always one default cell; **announce** any 3D-only request (bonds,
-      labels, ellipsoids, moments, multi-cell/margin `range`) and skip
-      it, mirroring the ascii chart engine.
-  - Renderer is developed against a hand-built `StructureScene`, so it
-    is testable before the facade exists.
-  - Commit: `Add ASCII structure renderer`.
-
-- [x] **P1.7 — Add the Viewer facade + factory; register ASCII**
-  - Files: new `src/easydiffraction/display/structure/viewing.py`;
-    update `display/structure/renderers/ascii.py` with
-    `@ViewerFactory.register`; update `display/structure/__init__.py`.
-  - `ViewerFactory(RendererFactoryBase)` + `Viewer(RendererBase)`
-    modelled on `PlotterFactory` / `Plotter`
-    (`display/plotting.py:5980`) and `TableRendererFactory` /
-    `TableRenderer` (`display/tables.py:142`): a `_registry()` of
-    `{engine: {'description', 'class'}}`, `descriptions()`, and the
-    active-engine binding the `_swap_rendering_structure` hook rebinds.
-    Add the `@ViewerFactory.register` decorator to
-    `AsciiStructureRenderer` in this step (the factory now exists).
-  - **Registration wiring (AGENTS.md §Architecture).**
-    `display/structure/__init__.py` explicitly imports the `renderers`
-    package (which imports the concrete renderer classes, P1.6) **and**
-    `Viewer` / `ViewerFactory` from `viewing.py`, so importing the
-    `display.structure` package triggers every
-    `@ViewerFactory.register`. `viewing.py` itself does **not** import
-    the renderer modules (that would create an import cycle, since the
-    renderers import `ViewerFactory` for the decorator) — the package
-    `__init__.py` is the single import point, exactly as the
-    registration convention requires.
-  - Commit: `Add Viewer facade and factory with ASCII engine`.
-
-- [x] **P1.8 — Add the plain `style` category**
-  - Files: existing `src/easydiffraction/core/validation.py`; new
-    `src/easydiffraction/project/categories/style/__init__.py`,
-    `default.py`, `factory.py`.
-  - **First, enable open-interval validation.** Extend `RangeValidator`
-    (`core/validation.py:169`) with optional exclusive `gt` / `lt`
-    bounds alongside the existing inclusive `ge` / `le` (all four
-    default to ±∞, so existing callers are unchanged): a value passes
-    when `ge <= value <= le` **and** `gt < value < lt`. Update the
-    docstring and `Diagnostics.range_mismatch` reporting to name
-    whichever bound was violated. This is bundled into P1.8's single
-    commit because it is the enabling prerequisite for
-    `adp_probability`; the validator change ships with the only caller
-    that needs it. (Its dedicated unit test is a Phase 2 item.)
-  - `Style` plain category (model on `project/categories/verbosity/`,
-    the plain-category-with-factory shape — `Verbosity(CategoryItem)` +
-    `@VerbosityFactory.register`, no `SwitchableCategoryBase`,
-    enum-backed `StringDescriptor`s with a `MembershipValidator` and a
-    getter/setter per setting) with descriptors validated on assignment:
-    `atom_shape` (`AtomShapeEnum`), `radius_model` (`RadiusModelEnum`),
-    `color_scheme` (`ColorSchemeEnum`), and `adp_probability` (float
-    validated in the **open** interval `(0, 1)` via the extended
-    `RangeValidator` with `gt=0.0, lt=1.0`). Bond cutoffs are **not**
-    here — they are a per-structure property (P1.11). CIF tags
-    `_style.*` (see Open Questions). `show_supported()` lists accepted
-    values for every styling setting (ADR §6). No factory-swapped
-    `type`.
-  - Register `Style` in `project/categories/style/__init__.py`.
-  - Commit: `Add style category for structure view styling`.
-
-- [x] **P1.9 — Add the switchable `view` category**
-  - Files: new
-    `src/easydiffraction/project/categories/rendering_structure/__init__.py`,
-    `default.py`, `factory.py`.
-  - `View(CategoryItem, SwitchableCategoryBase)` modelled on `Chart`
-    (`project/categories/rendering_plot/default.py`):
-    `_category_code='view'`, `_owner_attr_name='view'`,
-    `_swap_method_name='_swap_rendering_structure'`; a `type`
-    `StringDescriptor` with CIF `_rendering_structure.type` validated
-    against `['auto', *ViewerEngineEnum]` +
-    `ViewerFactory.descriptions()` and **defaulting to `'auto'`**
-    (resolved to a concrete engine through `ViewerEngineEnum.default()`,
-    exactly as `Chart` resolves its `'auto'`), matching P1.1; `from_cif`
-    calling `self._parent._swap_rendering_structure`. Plus persisted
-    view-state descriptors: `show_labels` (`BoolDescriptor`, default
-    off), `show_moments` (`BoolDescriptor`, default on-where-data), and
-    the per-axis range as **six scalar `NumericDescriptor`s**
-    `range_a_min` / `range_a_max` / `range_b_min` / `range_b_max` /
-    `range_c_min` / `range_c_max` (CIF
-    `_rendering_structure.range_a_min` … , defaults 0 and 1, each axis
-    validated `min < max` in the setter), mirroring the six scalar cell
-    parameters; `structure()`'s `range=` tuple arg overrides them per
-    call. `show_supported()` lists engines.
-  - **Headless implication of the `auto` default.** In Jupyter (and
-    under nbmake `script-tests`, which run a Jupyter kernel) `auto`
-    resolves to `threejs`, so `project.display.structure(...)`
-    returns/writes an HTML string and needs **no browser** — it runs
-    unattended out of the box. In a bare terminal `auto` resolves to the
-    `ascii` engine the ADR §2 names; `threejs` can still be forced via
-    `project.rendering_structure.type = 'threejs'`. The P1.16 tutorial
-    and the Phase 2 script-test coverage item therefore exercise
-    **both** paths: the `threejs` HTML emission and an explicit
-    `view.type = 'ascii'` terminal render (see the Phase 2 "Integration
-    / script-test coverage" item).
-  - Register `View` in
-    `project/categories/rendering_structure/__init__.py`.
-  - Commit: `Add switchable view category for renderer selection`.
-
-- [x] **P1.10 — Wire `project.rendering_structure` / `project.style` +
-      CIF persistence**
-  - Files: existing `src/easydiffraction/project/project.py`,
-    `src/easydiffraction/project/project_config.py` (+ the
-    project-config CIF deserializer hook).
-  - Add read-only `rendering_structure` / `style` properties on
-    `Project` (mirror `rendering_plot` / `rendering_table` at
-    `project.py:315`) and the private `_swap_rendering_structure` hook
-    (mirror `_swap_rendering_plot` at `project.py:238`) that rebinds the
-    active `Viewer` engine.
-  - Instantiate `RenderingStructureFactory` / `StyleFactory` defaults in
-    `project_config.py` (mirror `project_config.py:36`) and extend the
-    CIF read side to restore `_rendering_structure.*` / `_style.*`
-    (mirror the chart `from_cif`).
-  - Round-trip check is deferred to the Phase 2 tests; this step only
-    wires the surfaces.
-  - Commit:
-    `Wire project.rendering_structure and project.style with CIF persistence`.
-
-- [x] **P1.11 — Add the per-structure `geom` bond-cutoff category**
-  - Files: new
-    `src/easydiffraction/datablocks/structure/categories/geom/__init__.py`,
-    `default.py`, `factory.py`; existing
-    `src/easydiffraction/datablocks/structure/item/base.py` (add the
-    category to `Structure`).
-  - `Geom` per-structure category — a **single-record `CategoryItem`**
-    (model on `cell` / `space_group`, not the `atom_sites` loop) holding
-    the standard cif_core bond-generation cutoffs:
-    - `min_bond_distance_cutoff` (float Å, default `0.0`) — CIF
-      `_geom.min_bond_distance_cutoff`.
-    - `bond_distance_incr` (float Å, default `0.25`, documented and
-      tunable) — CIF `_geom.bond_distance_incr`. A bond forms between
-      two in-scene atoms when
-      `min_bond_distance_cutoff ≤ d ≤ r_bond(A) + r_bond(B) + bond_distance_incr`,
-      where `r_bond` is `_atom_type.radius_bond` when the structure
-      carries it, else the element's covalent radius from the bundled DB
-      (P1.4); version 1 has no `_atom_type` category, so covalent is
-      used. Both tags are the **standard** `cif_core.dic` definitions
-      (`_geom.min_bond_distance_cutoff`, `_geom.bond_distance_incr`) and
-      always serialize in the **structure datablock**.
-  - Add `geom` to `Structure` (the `CategoryOwner` auto-discovers any
-    `CategoryItem` attribute) and register the concrete class in
-    `datablocks/structure/categories/geom/__init__.py`.
-  - This is the per-structure home the builder reads bond cutoffs from
-    (P1.5), so multi-phase projects can carry different cutoffs per
-    phase; the computed `_geom_bond` / `_geom_angle` loops and the
-    angle/contact cutoffs are deferred (ADR Deferred Work).
-  - Commit: `Add per-structure geom bond-cutoff category`.
-
-- [x] **P1.12 — Add `display.structure()` + `show_structure_options()`**
-  - Files: existing `src/easydiffraction/project/display.py`.
-  - Add to the class backing `project.display` (owner of `pattern()` /
-    `show_pattern_options()`):
-    - `structure(struct_name, include='auto', range=None, path=None)`:
-      resolve the structure by name; **resolve the concrete `features`
-      set here** (see precedence below) by calling P1.5's
-      `structure_feature_availability(structure, style=project.style)`;
-      build the scene via
-      `build_scene(structure, style=project.style, view_range=<resolved range>, features=<resolved set>)`
-      (per-call `range` overrides the persisted view range for that
-      call); render with the active `project.rendering_structure`
-      engine. **Signature mirrors `pattern()`**:
-      `structure(...) -> None`, displaying directly as a side effect
-      (notebook: `IPython.display` of the engine's HTML; terminal: print
-      the ASCII view); when `path` is given, also write a standalone,
-      self-contained HTML file (Three.js embedded). (`pattern()` is
-      `-> None` and displays directly — verified in `display.py` — so no
-      open signature decision remains.)
-    - `show_structure_options(struct_name)`: mirror
-      `show_pattern_options()` — list each `include=` option with engine
-      - data support and the reason when unavailable, reading the
-        **same** `structure_feature_availability(...)` probe (P1.5) plus
-        the active engine's `supported_features()` (P1.6), so it never
-        re-reads the structure: ascii's 3D-only skips; `moments` until
-        moment fields exist; ionic→covalent radius substitutions from
-        P1.4.
-    - **Content precedence — resolved only here (ADR §8).** The facade
-      is the single resolver of **which features the data and flags
-      select**; it does **not** filter by what the engine can draw. It
-      resolves content in a fixed order:
-      1. explicit `include=(...)` tuple → that set wins outright,
-         ignoring persisted `show_*`;
-      2. `include='auto'` → per feature, data-availability (from the
-         probe) → persisted `show_*` flag where one exists → built-in
-         default;
-      3. live modebar toggles are runtime-only and never rewrite the
-         resolved/persisted state.
-    - **Supported-feature filtering + announce/skip — the renderer's
-      job, not the facade's.** The content-resolved set is passed to
-      `build_scene(..., features=...)` and on to the active renderer;
-      the **renderer** is the authority on what it can draw, so it draws
-      the features `supported_features()` allows and **announces +
-      skips** any it cannot (ascii's 3D-only
-      bonds/labels/ellipsoids/moments/wider `range`), never erroring
-      (P1.6). The facade never drops features and never announces at
-      render time — it only queries `supported_features()` to
-      **preview** the same information through
-      `show_structure_options()`, so an unsupported feature is announced
-      exactly once.
-    - Add structure `include`-option descriptions next to
-      `_PATTERN_OPTION_DESCRIPTIONS`.
-  - End-to-end ASCII path works after this step
-    (`project.rendering_structure.type='ascii'`).
-  - Commit:
-    `Add structure() and show_structure_options() display surface`.
-
-- [x] **P1.13 — Vendor pinned Three.js assets + lint/coverage excludes**
-  - Files: new
-    `src/easydiffraction/display/structure/renderers/vendor/threejs/three.module.js`,
-    `OrbitControls.js`, `CSS2DRenderer.js`, and a sibling `LICENSES.md`;
-    existing `pyproject.toml`, `THIRD_PARTY_LICENSES.md`.
-  - Fetch `three@0.160.0` + the two addons from the upstream the
-    prototype pins; record exact source URLs + version + licence (MIT)
-    in the vendored `LICENSES.md`. **Network access is needed for this
-    step only.**
-  - Add the vendored path to the `exclude` lists for ruff, coverage,
-    interrogate, pydoclint, and format-docstring in `pyproject.toml`
-    (mirror the existing `report/templates/html/vendor` entries). Add
-    the Three.js row to `THIRD_PARTY_LICENSES.md`.
-  - If hatchling's defaults don't ship the new `vendor/` (and the P1.14
-    `templates/`) subtree, add a `force-include` rule under
-    `[tool.hatch.build.targets.wheel]`. The actual `pixi run dist-build`
-    wheel check is a Phase 2 step.
-  - Commit: `Vendor pinned Three.js assets`.
-
-- [x] **P1.14 — Add the Three.js structure renderer**
-  - Files: new
-    `src/easydiffraction/display/structure/renderers/threejs.py`; new
-    `src/easydiffraction/display/structure/templates/structure.html.j2`;
-    update `display/structure/renderers/__init__.py` to add the explicit
-    `ThreeJsStructureRenderer` import (so its `@ViewerFactory.register`
-    fires on package import, per the registration convention — not via a
-    `viewing.py` side-effect).
-  - `ThreeJsStructureRenderer` (`@ViewerFactory.register`):
-    - Serialize the `StructureScene` to JSON (primitive arrays).
-    - Render the HTML/JS shell from `structure.html.j2`: pinned Three.js
-      - `OrbitControls` + `CSS2DRenderer`, the Plotly-style modebar
-        (perspective/parallel toggle, view-along a/b/c, home/reset,
-        per-feature visibility toggles for
-        cell/axes/atoms/bonds/moments/ labels), shrink-wrapped legend,
-        hover tooltips, persistent labels, orbit/zoom/pan; **parallel
-        projection default**; initial visibility from the resolved
-        `include` (P1.12).
-    - **Offline-autonomous by default** for notebook + standalone HTML
-      (assets embedded inline, no network — what a CDN-blocked context
-      needs); expose an `offline`/embed switch so the HTML-report path
-      (P1.15) can link vs embed.
-    - **Dark/light theme.** Detect the host theme via the project's
-      `is_dark()` (`utils/_vendored` — the same call the Plotly plotter
-      uses to pick `plotly_dark`/`plotly_white`) and set the scene
-      background and the label/axis/edge colours from the
-      theme-dependent colours in `assets/colors.py` (P1.4); element
-      colours still come from the selected scheme. Auto-detected, not
-      persisted.
-    - Provide the IPython HTML representation the facade returns and the
-      standalone-HTML write path.
-  - Commit: `Add Three.js structure renderer`.
-
-- [x] **P1.15 — Embed the structure figure in the HTML report**
-  - Files: existing `src/easydiffraction/report/html_renderer.py`,
-    `src/easydiffraction/report/templates/html/report.html.j2`.
-  - Render a structure figure into the HTML report honoring the report's
-    existing `html_offline` flag — embed the Three.js assets when
-    offline, link them otherwise — so a structure figure behaves like
-    the existing Plotly figures (ADR §5). Reuse the offline-copy pattern
-    at `html_renderer.py` `_copy_mathjax` / the `include_plotlyjs`
-    switch at `html_renderer.py:170`.
-  - Commit: `Embed structure figure in HTML report under html_offline`.
-
-- [x] **P1.16 — Promote ADR index row, tutorials, and docs**
-  - Files: existing [`docs/dev/adrs/index.md`](../adrs/index.md);
-    `docs/docs/tutorials/*.py` (+ regenerated `*.ipynb`);
-    `docs/docs/user-guide/`, `docs/docs/api-reference/`.
-  - Add the **User-facing API** index row for the crysview ADR (the ADR
-    file itself is committed/promoted by `/draft-impl-1` Phase A).
-  - Add a structure-view example to a representative tutorial
-    (`project.rendering_structure.type`, `project.style.*`,
-    `structure.geom.min_bond_distance_cutoff` /
-    `structure.geom.bond_distance_incr`,
-    `project.display.structure(...)`, `show_structure_options(...)`);
-    regenerate notebooks via `pixi run notebook-prepare` and stage the
-    `.py` + regenerated `.ipynb` together.
-  - Add `project.display.structure()` / `project.rendering_structure` /
-    `project.style` and the per-structure `structure.geom` bond cutoffs
-    to the API reference and a short user-guide section.
-  - Commit: `Document structure view in tutorials and reference`.
-
-- [x] **P1.17 — Reach Phase 1 review gate**
-  - No-code step. Mark every `[ ]` above as `[x]`; commit the plan-file
-    update alone.
-  - Commit: `Reach Phase 1 review gate`.
-
-## Test plan (Phase 2)
-
-Per AGENTS.md §Testing, every new module/class ships with tests; unit
-tests mirror the source tree (`src/easydiffraction/<pkg>/<mod>.py` →
-`tests/unit/easydiffraction/<pkg>/test_<mod>.py`) — verify with
-`pixi run test-structure-check`. No network, no sleeping, no real
-calculation engines, no test-ordering dependence. Vendored Three.js +
-element-data assets are excluded from test-structure mirroring and
-coverage (configured in P1.13).
-
-- [ ] **`tests/unit/easydiffraction/display/structure/test_enums.py`**
-      (new) — each enum's members, values, and `default()`. P1.1.
-- [ ] **`tests/unit/easydiffraction/display/structure/test_scene.py`**
-      (new) — primitives are frozen/slotted; `StructureScene` holds the
-      primitive lists; the module imports **nothing** from
-      `easydiffraction` domain packages (assert via an import-graph
-      check). Includes a **direct `MomentArrow` construction test**
-      (build it, assert its fields) so the gated, never-emitted
-      primitive is covered. P1.2.
-- [ ] **`tests/unit/easydiffraction/crystallography/test_crystallography.py`**
-      (extend) — `orthogonalization_matrix` for orthorhombic (diagonal)
-      and a known monoclinic/triclinic cell (compare to a hand-computed
-      matrix and check `|det| = unit-cell volume`);
-      `fractional_to_cartesian` round-trips a known site;
-      `adp_principal_axes` diagonalizes a known tensor to expected
-      semi-axes/orientation and recovers an isotropic tensor as equal
-      axes; the public symmetry-expansion wrapper returns the right
-      operation count for a known space group. P1.3.
-- [ ] **`tests/unit/easydiffraction/display/structure/assets/test_radii.py`**
-      and **`test_colors.py`** (new) — a known element resolves to the
-      documented radius for each of the four models; a miss for the
-      selected model falls back to covalent with the `substituted` flag
-      set; the database is complete for the seeded covalent/vdW/Jmol
-      values from `Tables.py`; `jmol` and `vesta` palettes return RGB
-      for known elements; the a/b/c axis colours and the dark/light
-      canvas colours are returned. P1.4.
-- [ ] **`tests/unit/easydiffraction/display/structure/test_builder.py`**
-      (new) — against small hand-built structures (no real engine):
-  - Special-position overlap collapses to one scene atom; a corner site
-    with the default `[0,1]³` range appears at all eight corners (border
-    inclusion + identity rule). P1.5.
-  - Two rows at one position → one occupancy-wedge sphere; sum < 1 adds
-    a vacancy wedge; sum ≥ 1 normalizes with no vacancy wedge. P1.5.
-  - `ortep` anisotropic atom → `AdpEllipsoid` scaled to
-    `adp_probability`; isotropic/no-ADP → sphere; `ball` → sphere
-    always. P1.5.
-  - Bonds appear only between in-scene atoms satisfying the `_geom`
-    auto-bonding rule
-    `min_bond_distance_cutoff ≤ d ≤ r_bond(A)+r_bond(B)+ bond_distance_incr`
-    (`r_bond` = covalent radius in v1); varying `bond_distance_incr`
-    adds/drops bonds; nothing below `min_bond_distance_cutoff`; no
-    out-of-range partner atoms are generated. P1.5.
-  - Moments are never emitted. P1.5.
-  - The builder emits exactly the primitive lists named in the passed
-    `features` set and reads neither `'auto'` nor persisted `show_*`
-    flags (precedence is the facade's job);
-    `structure_feature_availability(...)` reports `moments` unavailable
-    and flags ionic→covalent substitutions without building a scene.
-    P1.5.
-- [ ] **`tests/unit/easydiffraction/display/structure/renderers/test_ascii.py`**
-      (new) — orthorhombic cell renders a rectangular parallelogram;
-      monoclinic renders the slanted staircase; atoms map to the
-      bucketed glyph ramp; a 3D-only `include` (bonds/labels/moments)
-      and a wider `range` are announced and skipped; legend lists
-      elements. P1.6.
-- [ ] **`tests/unit/easydiffraction/display/structure/test_viewing.py`**
-      (new) — `ViewerFactory` registers `ascii` (and `threejs` after
-      P1.14); `descriptions()` lists them; the facade rebinds the active
-      engine. P1.7, P1.14.
-- [ ] **`tests/unit/easydiffraction/core/test_validation.py`** (extend)
-      — the extended `RangeValidator` with exclusive `gt` / `lt` bounds
-      rejects the endpoints (`gt=0.0` rejects `0.0`, `lt=1.0` rejects
-      `1.0`) and accepts an interior value; a validator with only `ge` /
-      `le` still behaves exactly as before (no regression for existing
-      callers). P1.8.
-- [ ] **`tests/unit/easydiffraction/project/categories/style/test_style.py`**
-      (new — single parent-level test if the package is only
-      `default.py`/`factory.py`) — enum assignment validates (bad value
-      raises `typeguard.TypeCheckError` / `ValueError`);
-      `adp_probability` accepts an interior value (e.g. `0.5`) and
-      **rejects both endpoints `0.0` and `1.0`** (open interval, via the
-      extended `RangeValidator`); `show_supported()` lists every
-      setting's accepted values; `_style.*` CIF round-trips. P1.8.
-- [ ] **`tests/unit/easydiffraction/project/categories/rendering_structure/test_rendering_structure.py`**
-      (new) — `type` validates against `['auto', *ViewerEngineEnum]` and
-      defaults to `'auto'`; setting `type` calls
-      `_swap_rendering_structure`; a `range_a_max` below `range_a_min`
-      is rejected (per-axis `min < max`); `_rendering_structure.type` /
-      `_rendering_structure.show_*` / `_rendering_structure.range_a_min`
-      … `_rendering_structure.range_c_max` CIF round-trip;
-      `show_supported()` lists engines. P1.9.
-- [ ] **`tests/unit/easydiffraction/project/test_project.py`** (extend)
-      — `project.rendering_structure` / `project.style` are read-only
-      attributes; switching `project.rendering_structure.type` rebinds
-      the active engine; a saved + reloaded project restores
-      `_rendering_structure.*` / `_style.*` identically. P1.10.
-- [ ] **`tests/unit/easydiffraction/datablocks/structure/categories/geom/test_geom.py`**
-      (new — single parent-level test if the package is only
-      `default.py`/`factory.py`) — defaults are
-      `min_bond_distance_cutoff = 0.0` and `bond_distance_incr = 0.25`;
-      both `_geom.min_bond_distance_cutoff` and
-      `_geom.bond_distance_incr` round-trip in the **structure**
-      datablock; a multi-phase project keeps independent cutoffs per
-      structure. P1.11.
-- [ ] **`tests/unit/easydiffraction/project/test_display.py`** (extend)
-      — `structure()` returns the expected representation per engine;
-      per-call `range=` overrides the persisted range for that call
-      only; `include='auto'` resolves per ADR §8 (data → persisted →
-      default); an explicit tuple ignores persisted `show_*`;
-      unsupported options are skipped, never raised;
-      `show_structure_options()` reports support + reasons (ascii
-      3D-only, moments gated, ionic→covalent substitution). P1.12.
-- [ ] **`tests/unit/easydiffraction/display/structure/renderers/test_threejs.py`**
-      (new) — the renderer emits an HTML string containing the scene
-      JSON and the modebar controls; the emitted
-      `<script     type="importmap">` parses to JSON with a top-level
-      **`imports`** key mapping `three` (regression guard: a bare
-      specifier map with no `imports` wrapper silently fails to resolve
-      and renders blank); **offline** mode embeds the Three.js asset
-      text inline (no CDN URL), online mode links it; the standalone
-      write path produces a self-contained file; the resolved dark/light
-      theme drives the canvas/annotation colours (assert the dark vs
-      light background differs when `is_dark()` is monkeypatched), while
-      element colours stay scheme-driven. Assert on emitted markup, not
-      a live browser. P1.14.
-- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
-      (extend) — `html_offline=True` embeds the Three.js assets next to
-      / inside the report; `html_offline=False` links them; the
-      structure figure block appears when a structure is present. P1.15.
-- [ ] **Wheel-packaging verification** — `pixi run dist-build` then
-      `unzip -l dist/*.whl | grep -E 'three.module.js|OrbitControls|CSS2DRenderer|structure.html.j2'`
-      confirms the vendored Three.js + HTML template ship in the wheel.
-      `dist/*.whl` is a verification artefact — do not stage it. P1.13.
-- [ ] **Integration / script-test coverage** — confirm
-      `pixi run script-tests` exercises the tutorial that calls
-      `project.display.structure(...)` along **both** engine paths: the
-      **`auto` default** (which resolves to `threejs` under nbmake's
-      Jupyter kernel) HTML emission (no browser, runs headless in CI)
-      and an explicit `project.rendering_structure.type = 'ascii'`
-      terminal render. Extend a tutorial if not. P1.16.
-
-Use `pixi run test-structure-check` to confirm the unit-test layout
-mirrors the source tree per AGENTS.md §Testing.
-
-## Verification commands (Phase 2)
-
-Per AGENTS.md §Workflow, save any required check output with the
-zsh-safe pattern. Variable names per task (never assign to `status` in
-zsh — it is readonly):
-
-```sh
-pixi run fix > /tmp/easydiffraction-fix.log 2>&1; fix_exit_code=$?; tail -n 200 /tmp/easydiffraction-fix.log; exit $fix_exit_code
-pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
-pixi run test-structure-check > /tmp/easydiffraction-test-structure-check.log 2>&1; test_structure_check_exit_code=$?; tail -n 200 /tmp/easydiffraction-test-structure-check.log; exit $test_structure_check_exit_code
-pixi run unit-tests > /tmp/easydiffraction-unit-tests.log 2>&1; unit_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-unit-tests.log; exit $unit_tests_exit_code
-pixi run integration-tests > /tmp/easydiffraction-integration-tests.log 2>&1; integration_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-integration-tests.log; exit $integration_tests_exit_code
-pixi run script-tests > /tmp/easydiffraction-script-tests.log 2>&1; script_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-script-tests.log; exit $script_tests_exit_code
-```
-
-Run in order; each must complete clean before the next. Per AGENTS.md
-§Workflow: `pixi run fix` regenerates
-`docs/dev/package-structure/full.md` and `short.md` automatically —
-never edit those by hand. The vendored Three.js assets, the HTML
-template, and the element-data assets are intentional sources (included
-in commits); the built wheel under `dist/`, benchmark CSVs under
-`docs/dev/benchmarking/`, and any tutorial project output under
-`tmp/tutorials/` are verification artefacts — do not stage them. Lint
-complexity thresholds are guardrails: if the scene builder or a renderer
-trips `max-branches` / `max-statements`, refactor (extract helpers,
-parameter objects) rather than raising thresholds or adding `# noqa`.
-
-## Suggested Pull Request
-
-**Title:** `[display] Interactive 3D structure view (crysview)`
-
-**Description:**
-
-Adds an interactive 3D view of the crystal structure a refinement is
-adjusting — the atoms, the unit cell, the bonds, and the thermal (ADP)
-ellipsoids — alongside the existing 1D pattern view.
-
-- **`project.display.structure('lbco')`.** A new display method,
-  parallel to `project.display.pattern(...)`, draws one structure. In a
-  Jupyter notebook it renders an interactive Three.js scene (rotate,
-  zoom, pan, view down a/b/c, toggle features, switch
-  perspective/parallel projection); in a terminal it prints a schematic,
-  colour-coded ASCII view.
-  `project.display.show_structure_options('lbco')` lists what each
-  engine and the current structure can show, with reasons when something
-  is unavailable.
-- **Choose the engine and the styling, once.**
-  `project.rendering_structure.type` selects `threejs` or `ascii`;
-  `project.style` picks the depiction (`ortep` thermal ellipsoids — the
-  default — or `ball`-and-stick), a standard radius model (covalent by
-  default, or vdw/ionic/atomic), and a colour scheme (Jmol/CPK, VESTA)
-  and ADP probability level — standard models drawn from a built-in
-  element database, not dozens of per-element rows. The view also
-  follows your notebook's dark or light theme automatically. It all
-  persists to `project.cif`, so a reopened project looks the same.
-- **Tune which bonds are drawn, per structure.** `structure.geom` sets
-  the standard bond cut-offs (a minimum distance and a tolerance added
-  to the atoms' bonding radii) for each structure, saved in that
-  structure's own file, so different phases can use different cut-offs.
-- **See a single cell, a margin, or several cells.**
-  `project.rendering_structure` sets a per-axis fractional range
-  (default: the full cell with border atoms drawn); widen it for a
-  margin or multiple cells.
-- **Works offline.** The notebook and standalone-HTML views embed a
-  pinned Three.js so they render with no network, and a structure figure
-  can be embedded in the HTML report under the existing
-  `html_offline = True` switch — just like the Plotly figures.
-
-Full bond/angle geometry tables (`_geom_bond` / `_geom_angle`),
-magnetic-moment arrows, the Qt Quick 3D GUI renderer, and extraction of
-a standalone `crysview` package are intentionally deferred (see the
-ADR's Deferred Work).
-
-**Scope label:** `[display]`.
diff --git a/docs/dev/plans/iucr-cif-tag-alignment.md b/docs/dev/plans/iucr-cif-tag-alignment.md
deleted file mode 100644
index 3ac4e16a1..000000000
--- a/docs/dev/plans/iucr-cif-tag-alignment.md
+++ /dev/null
@@ -1,640 +0,0 @@
-# Plan: IUCr CIF Tag Alignment
-
-Implementation plan for the
-[`iucr-cif-tag-alignment`](../adrs/accepted/iucr-cif-tag-alignment.md)
-ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
-exceptions to those instructions.
-
-> **Status (closed).** Phase 1 and Phase 2 are complete; the ADR was
-> promoted to accepted during implementation. This file is retained as
-> the implementation and verification record. Early references below to
-> `project.report.show_report()` and related display helpers were
-> superseded by the later project-summary-rendering work; the current
-> report facade exposes save/render/data-context methods.
-
-## ADR cross-reference
-
-- Primary ADR: `iucr-cif-tag-alignment.md` (accepted; this plan promoted
-  it from `suggestions/` during Phase 1).
-- Amends (per the ADR's "ADRs amended by this ADR" section):
-  - [`analysis-cif-fit-state.md`](../adrs/accepted/analysis-cif-fit-state.md)
-    — new `_fit_result.*` fields; topology-neutral default save.
-  - [`minimizer-input-output-split.md`](../adrs/accepted/minimizer-input-output-split.md)
-    — new `_fit_result.*` examples.
-  - [`project-facade-and-persistence.md`](../adrs/accepted/project-facade-and-persistence.md)
-    — `project.summary` removed and replaced by `project.report`;
-    `summary.cif` no longer written.
-  - [`help-discoverability.md`](../adrs/accepted/help-discoverability.md)
-    — `project.summary.help()` → `project.report.help()`.
-
-## Branch and PR
-
-- Branch: `iucr-cif-tag-alignment` (already checked out, matches the
-  slug).
-- PR target: `develop`.
-- Do not push the branch until both Phase 1 and Phase 2 review cycles
-  close.
-
-## Decisions already made (in the ADR)
-
-These are settled by the accepted ADR — the plan does not re-litigate
-them, only implements them:
-
-- **Three-tier default save:** structure-tier IUCr alignment with casing
-  fixes; analysis-tier topology-neutral `_fit_result.*` with
-  dictionary-canonical _item_ names (uppercase R / wR / DOI);
-  experiment-tier unchanged. Per-topology category split (`_refine_ls.*`
-  / `_pd_proc_ls.*` / `_reflns.*`) happens only in the IUCr export.
-- **Reports system:** new `project.report` facade slot replaces the
-  unimplemented `project.summary` placeholder; single
-  `reports/<project>.cif` file with multi-datablock layout always
-  starting with `data_global`. `project.save(report=True)` and
-  `project.report.save()` produce the file; `project.report.check()`
-  validates via gemmi against `cif_core.dic` / `cif_pow.dic`.
-- **Handler mechanism:** per-field `iucr_name` (optional, falls back to
-  `names[0]`) plus category-level `IucrCategoryTransformer` subclasses
-  for wavelength, TOF calibration, excluded regions, symmetry
-  operations, and extinction reshaping.
-- **ADP single-tag emission:** emit `B_*` xor `U_*` per row based on
-  `_atom_site.ADP_type`; both forms still accepted on read.
-- **Loop-tag style:** dotted DDLm everywhere on write; both forms on
-  read.
-- **`_easydiffraction_software`** umbrella category with three free-text
-  fields (`framework`, `calculator`, `minimizer`), plus a derived
-  `_computing.structure_refinement` string in the IUCr export.
-- **gemmi** is already a project dependency (`pyproject.toml:39`); no
-  new dependencies needed.
-
-## Open questions to resolve during implementation
-
-- **Pixi env:** confirm `gemmi.cif.read_doc` and the dictionary
-  validation path are available in the project's pinned gemmi version
-  before P1.16 (validator implementation). If the pinned version is too
-  old, bump the constraint in `pyproject.toml` (counts as a plan-named
-  dependency change — pre-approved per AGENTS.md §Architecture because
-  the package is already named).
-- **Tutorial scope:** identify every tutorial source under
-  `docs/docs/tutorials/*.py` that references `project.summary` and
-  update them in P1.17. If a tutorial currently uses
-  `project.summary.help()` as a discoverability example, it becomes
-  `project.report.help()`; if a tutorial expects `summary.cif`, swap to
-  `project.save(report=True)` and reference `reports/<project>.cif`.
-- **Extinction transformer detail:** the `(type, model)` →
-  `_refine_ls.extinction_method` descriptive string in §3 of the ADR
-  uses a Becker-Coppens taxonomy table; the implementation needs the
-  project's existing extinction-model selector enums to map cleanly.
-  Verify enum values during P1.14.
-
-## Concrete files likely to change
-
-Foundation:
-
-- `src/easydiffraction/io/cif/handler.py` — `CifHandler` gains
-  `iucr_name` parameter.
-
-Structure tier (casing):
-
-- `src/easydiffraction/datablocks/structure/categories/atom_sites/default.py`
-- `src/easydiffraction/datablocks/structure/categories/space_group/default.py`
-
-ADP write-side:
-
-- `src/easydiffraction/io/cif/serialize.py` (atom_site / atom_site_aniso
-  write path)
-
-Analysis tier (new `_fit_result.*` fields):
-
-- `src/easydiffraction/analysis/categories/fit_result/lsq.py`
-- `src/easydiffraction/analysis/categories/fit_result/base.py`
-- `src/easydiffraction/analysis/fit/` (residual / aggregate computation
-  site; exact module determined during P1.4)
-
-Project-extension `iucr_name` settings (P1.7):
-
-- The descriptor files enumerated in P1.7 (one `cif_handler` call per
-  descriptor across the analysis / experiment categories — no new
-  modules, no new packages). The software triple itself is built inline
-  by the IUCr writer (P1.11) and does **not** introduce a new category
-  class or default-save persistence.
-
-Facade rename `project.summary` → `project.report` (P1.8):
-
-- `src/easydiffraction/project/project.py` (replace the `summary`
-  property and `summary.cif` write with the new `report` facade; drop
-  the `as_cif()` caller; add the `report: bool = False` keyword to
-  `Project.save()`).
-- `src/easydiffraction/summary/` → migrated to
-  `src/easydiffraction/report/` (either rename the package and class, or
-  add a fresh `report/` package whose `Report` delegates to the migrated
-  display methods — implementer's choice). Every live display method
-  (`show_report`, `show_project_info`, `show_crystallographic_data`,
-  `show_experimental_data`, `show_fitting_details`) is preserved
-  verbatim; only the placeholder `as_cif()` is dropped.
-- `src/easydiffraction/report/__init__.py`, `report.py` — destination of
-  the migration.
-
-IUCr writer:
-
-- `src/easydiffraction/io/cif/iucr_writer.py` (new)
-- `src/easydiffraction/io/cif/iucr_transformers.py` (new — holds
-  `IucrCategoryTransformer` subclasses)
-
-Validation:
-
-- `src/easydiffraction/report/check.py` (new — wraps `gemmi`)
-
-Amended ADRs:
-
-- `docs/dev/adrs/accepted/analysis-cif-fit-state.md`
-- `docs/dev/adrs/accepted/minimizer-input-output-split.md`
-- `docs/dev/adrs/accepted/project-facade-and-persistence.md`
-- `docs/dev/adrs/accepted/help-discoverability.md`
-
-ADR promotion:
-
-- `docs/dev/adrs/suggestions/iucr-cif-tag-alignment.md` → moved to
-  `docs/dev/adrs/accepted/iucr-cif-tag-alignment.md` with status flipped
-  to Accepted.
-- `docs/dev/adrs/index.md` (index row updated).
-
-Tutorials / CLI:
-
-- `docs/docs/tutorials/*.py` (regenerate notebooks after edits via
-  `pixi run notebook-prepare`).
-- `src/easydiffraction/cli/` (any command that surfaces
-  `project.summary`).
-
-## Commit discipline
-
-When an AI agent follows this plan, **every completed Phase 1
-implementation step must be staged with explicit paths and committed
-locally before moving to the next implementation step or the Phase 1
-review gate.** Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
-**Commits**. Keep commits atomic, single-purpose, and aligned with the
-plan steps. Do not include generated artifacts (data CIFs, project
-directories, benchmark CSVs) unless the step explicitly produces them —
-see **Workflow** in [`AGENTS.md`](../../../AGENTS.md) for the
-generated-artifact exceptions.
-
-## Implementation steps (Phase 1)
-
-- [x] **P1.1 — Extend `CifHandler` with `iucr_name`**
-  - File: `src/easydiffraction/io/cif/handler.py`.
-  - Add an optional keyword `iucr_name: str | None = None` to
-    `CifHandler.__init__`.
-  - Add a public property / method returning the IUCr-side tag:
-    `iucr_name` when set, else `names[0]`.
-  - No call sites change in this step — the default fallback leaves
-    every existing handler emitting its current name.
-  - Commit: `Add iucr_name to CifHandler`.
-
-- [x] **P1.2 — Structure-tier casing fixes**
-  - Files:
-    `src/easydiffraction/datablocks/structure/categories/atom_sites/default.py`,
-    `src/easydiffraction/datablocks/structure/categories/space_group/default.py`.
-  - Rename canonical CIF tags to dictionary-canonical casing
-    (`_atom_site.ADP_type`, `_atom_site.Wyckoff_symbol`,
-    `_space_group.name_H-M_alt`,
-    `_space_group.IT_coordinate_system_code`). Python attribute names
-    stay lowercase.
-  - Keep the old (lowercase / `wyckoff_letter`) forms in each
-    `CifHandler.names` list as read-only aliases so loading legacy files
-    still works.
-  - Commit: `Adopt IUCr casing for atom_site and space_group CIF tags`.
-
-- [x] **P1.3 — ADP single-tag emission per row**
-  - File: `src/easydiffraction/io/cif/serialize.py` (and any helper
-    called by it).
-  - When emitting `_atom_site_aniso.*` and `_atom_site.B_iso_or_equiv` /
-    `_atom_site.U_iso_or_equiv`, choose `B_*` or `U_*` per row based on
-    `_atom_site.ADP_type`; omit the other family for that row.
-  - Read side unchanged (both families still accepted).
-  - Commit: `Emit one ADP family per atom_site row on save`.
-
-- [x] **P1.4 — Analysis tier: new `_fit_result.*` fields**
-  - Files: `src/easydiffraction/analysis/categories/fit_result/lsq.py`,
-    `src/easydiffraction/analysis/categories/fit_result/base.py`, plus
-    the fit-computation site (search for where `n_data_points`,
-    `reduced_chi_square` are currently populated).
-  - Declare new descriptors under `_fit_result.*` with
-    dictionary-canonical _item_ names (uppercase R / wR):
-    `R_factor_all`, `wR_factor_all`, `R_factor_gt`, `wR_factor_gt`,
-    `prof_R_factor`, `prof_wR_factor`, `prof_wR_expected`,
-    `number_restraints`, `number_constraints`, `shift_over_su_max`,
-    `shift_over_su_mean`, `profile_function`, `background_function`,
-    `threshold_expression`, `number_reflns_total`, `number_reflns_gt`.
-  - Wire computation: R-factors from residuals; restraint / constraint
-    counts from the analysis model; profile / background descriptors
-    from the active peak / background categories; reflns aggregates from
-    refln data.
-  - Fields not meaningful for a given fit (e.g. `prof_R_factor` for SC)
-    stay unset / `None`.
-  - Commit:
-    `Add IUCr-canonical fit_result fields to LeastSquaresFitResult`.
-
-- [x] **P1.5 — Amend `analysis-cif-fit-state.md`**
-  - File: `docs/dev/adrs/accepted/analysis-cif-fit-state.md`.
-  - Document the new `_fit_result.*` fields, the topology-neutral
-    default-save policy, and the per-topology IUCr-export remapping
-    deferred to §3 of the iucr-cif-tag-alignment ADR.
-  - Commit:
-    `Amend analysis-cif-fit-state ADR for new fit_result fields`.
-
-- [x] **P1.6 — Amend `minimizer-input-output-split.md`**
-  - File: `docs/dev/adrs/accepted/minimizer-input-output-split.md`.
-  - Update the `_fit_result.*` examples in §3 to reflect the new field
-    set from P1.4.
-  - Commit: `Amend minimizer-input-output-split ADR examples`.
-
-- [x] **P1.7 — Set `iucr_name` on project-extension descriptors**
-  - No new category. The ADR's `_easydiffraction_software` triple is a
-    **report-only projection**: it is derived inline by the IUCr writer
-    in P1.11 from existing state (`easydiffraction` package version,
-    `project.analysis.calculator.type`,
-    `project.analysis.minimizer.type`, and per-backend version
-    metadata). It is **not** persisted to `analysis/analysis.cif` and no
-    new category class is added.
-  - This step's actual work is the `_easydiffraction_*` prefix rename
-    for existing project-extension descriptors at IUCr export time. For
-    each project-extension category, set the matching descriptor's
-    `cif_handler` `iucr_name` to the prefixed form so the IUCr writer
-    emits `_easydiffraction_<category>.<field>` while the default save
-    keeps the bare-category form (`_minimizer.*`, `_calculator.*`,
-    etc.).
-  - Touched descriptors:
-    - `_minimizer.*` → `iucr_name='_easydiffraction_minimizer.*'`
-      (settings only — type, tolerance, max_iter, …).
-    - `_calculator.*` → `iucr_name='_easydiffraction_calculator.*'`.
-    - `_fitting_mode.*` → `iucr_name='_easydiffraction_fitting_mode.*'`.
-    - `_alias.*` → `iucr_name='_easydiffraction_alias.*'`.
-    - `_constraint.*` → `iucr_name='_easydiffraction_constraint.*'`.
-    - `_joint_fit.*` → `iucr_name='_easydiffraction_joint_fit.*'`.
-    - `_sequential_fit.*`, `_sequential_fit_extract.*` →
-      `iucr_name='_easydiffraction_sequential_fit*.*'`.
-    - `_expt_type.*` → `iucr_name='_easydiffraction_experiment_type.*'`.
-    - `_excluded_region.*` →
-      `iucr_name='_easydiffraction_excluded_region.*'`.
-    - `_peak.*` → `iucr_name='_easydiffraction_peak.*'`.
-    - `_extinction.*` (project-side selectors and parameters) →
-      `iucr_name='_easydiffraction_extinction.*'` (the transformer in
-      P1.14 also dual-emits the coreCIF `_refine_ls.extinction_*`
-      triple).
-    - `_background.type` →
-      `iucr_name='_easydiffraction_background.type'`.
-    - `_sc_crystal_block.*` →
-      `iucr_name='_easydiffraction_sc_crystal_block.*'`.
-    - Bayesian-only `_fit_result.*` fields →
-      `iucr_name='_easydiffraction_fit_result.*'` (project extensions
-      per ADR §3.3).
-  - The non-IUCr-counterpart `_diffrn.ambient_magnetic_field` and
-    `_diffrn.ambient_electric_field` descriptors get
-    `iucr_name='_easydiffraction_diffrn.ambient_magnetic_field'` /
-    `…electric_field`.
-  - Default-save behaviour is unchanged for every touched descriptor —
-    only the IUCr-export emission picks up the new prefix.
-  - Commit: `Set iucr_name on project-extension descriptors`.
-
-- [x] **P1.8 — Rename `project.summary` → `project.report`, preserve
-      display methods**
-  - Files: `src/easydiffraction/project/project.py`,
-    `src/easydiffraction/summary/` (renamed / migrated),
-    `src/easydiffraction/report/` (new).
-  - **Preserve every live `Summary` method.** The existing `Summary`
-    class (at `src/easydiffraction/summary/summary.py`) has live
-    user-facing display methods that tutorials call: `show_report()`,
-    `show_project_info()`, `show_crystallographic_data()`,
-    `show_experimental_data()`, `show_fitting_details()`. These are not
-    placeholders and must not be removed. Move them verbatim onto the
-    new `Report` class (rename of the class only, with no behavioural
-    change), so `project.report.show_report()` and friends remain
-    available with the same signatures and output.
-  - **Drop only the placeholder CIF method.** The `as_cif()` method on
-    `Summary` returns a stub string and is the only placeholder being
-    removed. Its caller — the `summary.cif` write at `Project.save()`
-    (currently at `src/easydiffraction/project/project.py:464`-ish) — is
-    removed in the same commit. The real CIF emission for journal
-    submission lives in `Report.save()` (writes `reports/<project>.cif`,
-    real implementation lands in P1.15) — the two are independent:
-    dropping `as_cif()` does not break any user-visible behaviour
-    because nothing meaningful was being written.
-  - Migration mechanics:
-    - Either rename the package directory
-      (`src/easydiffraction/summary/` → `src/easydiffraction/report/`)
-      and class (`Summary` → `Report`) in one move, **or** add a new
-      `src/easydiffraction/report/report.py` whose `Report` class
-      inherits / delegates to the migrated display methods. Pick the
-      approach that produces the smallest diff at review time; both keep
-      the display behaviour intact.
-    - Update `__init__.py` re-exports accordingly.
-  - `Project` gains a `report` property returning the `Report` instance;
-    the old `summary` property is removed. The `summary.cif` write call
-    in `Project.save()` is removed.
-  - `Project.save()` gains a `report: bool = False` keyword (no
-    behaviour yet beyond passing through to `Report.save()` when truthy;
-    the real `Report.save()` lands in P1.15).
-  - Tutorial / CLI call sites that invoke
-    `project.summary.show_report()` are updated in **P1.17**.
-  - Commit: `Replace project.summary with project.report facade`.
-
-- [x] **P1.9 — Amend `project-facade-and-persistence.md`**
-  - File: `docs/dev/adrs/accepted/project-facade-and-persistence.md`.
-  - Document the `project.report` facade slot, removal of
-    `project.summary`, removal of `summary.cif` from default saves, and
-    the new `reports/<project>.cif` output path.
-  - Commit:
-    `Amend project-facade-and-persistence ADR for project.report`.
-
-- [x] **P1.10 — Amend `help-discoverability.md`**
-  - File: `docs/dev/adrs/accepted/help-discoverability.md`.
-  - Replace `project.summary.help()` with `project.report.help()` in the
-    help-surface enumeration.
-  - Commit: `Amend help-discoverability ADR for project.report`.
-
-- [x] **P1.11 — IUCr writer foundation + `data_global` content**
-  - New file: `src/easydiffraction/io/cif/iucr_writer.py`.
-  - Implement the multi-datablock orchestrator skeleton: a
-    `write_iucr_cif(project, path)` entry point that opens
-    `reports/<project>.cif`, emits `data_global` first, then delegates
-    topology-specific blocks to subordinate writers (added in P1.12 /
-    P1.13).
-  - Emit `data_global` content per §2.3a of the ADR:
-    `_audit.creation_method` / `_audit.creation_date`,
-    `_computing.structure_refinement` (derived from the
-    `_easydiffraction_software` triple),
-    `_easydiffraction_software.{framework, calculator, minimizer}`,
-    `_journal.*` and `_publ_*` placeholders (written as `?`),
-    `_chemical_formula.*` derived from atom sites where possible.
-  - Apply the §2.4 formatting rules: blank line between categories,
-    `# ---- <section> ----` headers, 80-char wrap on long strings,
-    dotted DDLm form throughout, project extensions grouped at the end
-    of each block.
-  - Wire `Report.save()` (stubbed in P1.8) to call `write_iucr_cif`.
-  - Commit: `Add IUCr CIF writer with data_global block`.
-
-- [x] **P1.12 — Single-crystal block layout**
-  - Same file as P1.11; add `_write_sc_block` helper.
-  - Per-structure block emission per §2.3b: `_chemical_formula.*`,
-    `_cell.*`, `_space_group.*` + `_space_group_symop.*` loop,
-    `_diffrn.*`, `_diffrn_radiation_wavelength.*` (scalar / single-row
-    category for monochromatic per the wavelength transformer),
-    `_atom_site.*` + `_atom_site_aniso.*` loops with ADP single-tag
-    emission, `_refine_ls.*`, `_reflns.*`, the `_refln.*` loop per §2.3c
-    (`index_h/k/l`, `F_squared_meas`, `F_squared_calc`,
-    `F_squared_meas_su`, `include_status`).
-  - For SC the project-extension `_easydiffraction_extinction.*` block +
-    the dual `_refine_ls.extinction_*` triple are emitted via the
-    transformer (added in P1.14).
-  - Commit: `Emit single-crystal blocks in IUCr CIF writer`.
-
-- [x] **P1.13 — Powder Rietveld block layout (CWL + TOF)**
-  - Same writer file; add `_write_rietveld_blocks` helper.
-  - Emit `data_<project>_overall`, `data_<project>_phase_N` (one per
-    phase), `data_<project>_pwd_N` (one per pattern) per §2.3f / §2.3g /
-    §2.3h.
-  - Profile-data loop columns: CWL form uses `_pd_meas.2theta_scan`; TOF
-    form uses `_pd_meas.time_of_flight`. Other columns:
-    `_pd_meas.intensity_total`, `_pd_calc.intensity_total`,
-    `_pd_proc.intensity_bkg_calc`, `_pd_proc_ls.weight`.
-  - Powder reflections loop per §2.3d:
-    `_refln.{index_h/k/l, F_squared_meas, F_squared_calc, d_spacing}`
-    plus `_pd_refln.phase_id` for the powder phase identifier.
-  - Cross-block reference markers (`_pd_block_id`,
-    `_pd_block_diffractogram_id`) emitted with pipe-delimited
-    identifiers matching the §2.3 examples.
-  - Joint Rietveld and sequential fits emit one `_pwd_N` per pattern /
-    step inside the same file.
-  - Commit: `Emit powder Rietveld blocks in IUCr CIF writer`.
-
-- [x] **P1.14 — `IucrCategoryTransformer` subclasses**
-  - New file: `src/easydiffraction/io/cif/iucr_transformers.py`.
-  - Implement and register five transformers per §3 of the ADR:
-    - **Wavelength** — monochromatic scalar / single-row category;
-      multi-row loop when applicable.
-    - **TOF calibration** — four-row
-      `_pd_calib_d_to_tof.{id, coeff, power, coeff_su, diffractogram_id}`
-      loop with EasyDiffraction attribute names as `id` codes (`offset`,
-      `linear`, `quad`, `recip`) and powers 0, 1, 2, −1 respectively per
-      the §2.3h cif_pow.dic equation.
-    - **Excluded regions** — free-text rendering as
-      `_pd_proc.info_excluded_regions`.
-    - **Symmetry operations** — `_space_group_symop.*` loop derived from
-      the active space group.
-    - **Extinction** — dual emit `_easydiffraction_extinction.*` + the
-      coreCIF `_refine_ls.extinction_{method,coef,expression}` triple,
-      with the descriptive string built from the project's
-      `(type, model)` selectors per the ADR §3 mapping table.
-  - Wire transformers into the writer from P1.12 / P1.13 (the writer
-    asks each per-block category for its IUCr representation, which is
-    either a direct `iucr_name` rename or a transformer call).
-  - Commit: `Add IUCr category transformers for restructured emissions`.
-
-- [x] **P1.15 — Wire `Project.save(report=True)` end-to-end**
-  - File: `src/easydiffraction/project/project.py`,
-    `src/easydiffraction/report/report.py`.
-  - `Project.save(report=False)` continues to write the regular project
-    files. `Project.save(report=True)` additionally writes
-    `reports/<project>.cif`.
-  - `Project.save(report=True, check=False)` is the default for the
-    report path; `check=True` is wired in P1.16.
-  - Make the `reports/` directory if absent; overwrite an existing
-    report file (no round-trip).
-  - Commit: `Wire report=True kwarg on Project.save`.
-
-- [x] **P1.16 — Submission-side validation via gemmi**
-  - New file: `src/easydiffraction/report/check.py`.
-  - Implement `Report.check()` using `gemmi.cif.read_doc` against the
-    shipped (or downloaded) `cif_core.dic` and `cif_pow.dic`. Skip
-    `_easydiffraction_*` from unknown-tag warnings.
-  - Wire `Project.save(report=True, check=True)` to run validation after
-    the write and surface any errors / warnings to the user.
-  - Verify gemmi version supports the validation calls in the project's
-    pinned env; if not, bump the constraint in `pyproject.toml` /
-    `pixi.toml` / `pixi.lock` (pre-approved per AGENTS.md §Architecture
-    because gemmi is already a named dependency).
-  - Commit: `Add Report.check() validation via gemmi`.
-
-- [x] **P1.17 — Update tutorials / CLI / docs references**
-  - Source files in `docs/docs/tutorials/*.py` and CLI commands in
-    `src/easydiffraction/cli/`.
-  - Replace every `project.summary.*` call site with the matching
-    `project.report.*` call:
-    - `project.summary.show_report()` → `project.report.show_report()`
-      (currently used by `docs/docs/tutorials/ed-3.py`,
-      `docs/docs/tutorials/ed-5.py`, `docs/docs/tutorials/ed-6.py`,
-      `docs/docs/tutorials/ed-8.py` — confirm the full list via
-      `git grep -n 'project\.summary'` at the start of the step and
-      update every match).
-    - Other `project.summary.*` accessors (`show_project_info`,
-      `show_crystallographic_data`, `show_experimental_data`,
-      `show_fitting_details`) — replace each call with the
-      `project.report.*` equivalent.
-    - `project.summary.help()` in any tutorial or doc page becomes
-      `project.report.help()`.
-  - Demonstrate `project.save(report=True)` in at least one tutorial
-    that finishes a fit; reference `reports/<project>.cif` in the prose.
-  - Regenerate notebooks with `pixi run notebook-prepare` (per AGENTS.md
-    §Tutorials).
-  - Commit: `Update tutorials and CLI for project.report rename`.
-
-- [x] **P1.18 — Promote ADR to `accepted/`**
-  - Move `docs/dev/adrs/suggestions/iucr-cif-tag-alignment.md` to
-    `docs/dev/adrs/accepted/iucr-cif-tag-alignment.md`.
-  - Flip the front-matter `**Status:**` line from `Proposed` to
-    `Accepted`. Update the date to today (Phase 1 acceptance date).
-  - Update `docs/dev/adrs/index.md`: the row's status column changes
-    from `Suggestion` to `Accepted`, and the link target changes from
-    `suggestions/` to `accepted/`.
-  - Commit: `Promote iucr-cif-tag-alignment ADR to accepted`.
-
-- [x] **P1.19 — Reach Phase 1 review gate**
-  - No-code step. Mark every `[ ]` above as `[x]`; commit the plan-file
-    update alone.
-  - Commit: `Reach Phase 1 review gate`.
-
-## Test plan (Phase 2)
-
-Per AGENTS.md §Testing, every new module, class, and bug fix ships with
-tests; unit tests mirror the source tree. Before running the
-verification commands below, add or update:
-
-- [x] **`tests/unit/easydiffraction/io/cif/test_handler.py`** —
-      `CifHandler.iucr_name` resolver: explicit value used when set,
-      fallback to `names[0]` when unset. P1.1 surface.
-- [x] **`tests/unit/easydiffraction/io/cif/test_iucr_writer.py`** —
-      fixture-driven golden tests for each topology covered in §2.3 /
-      §2.2 worked examples: single-crystal (Example A), single-
-      experiment Rietveld CWL (Example B), joint Rietveld multi-
-      experiment (Example C), sequential TOF Rietveld (Example D). Each
-      golden compares the emitted file against a checked-in reference
-      and asserts: block names, block order, `data_global` content,
-      profile-data / reflections loop columns, project-extension
-      `_easydiffraction_*` grouping at end of block, 80-char wrap.
-      P1.11–P1.13 surface.
-- [x] **`tests/unit/easydiffraction/io/cif/test_iucr_transformers.py`**
-      — per-transformer unit tests: wavelength scalar vs loop based on
-      multiplicity; TOF calibration loop with
-      `id = offset / linear / quad / recip` and powers 0, 1, 2, −1;
-      range-form excluded regions rendered to
-      `_pd_proc.info_excluded_regions`; `_space_group_symop.*` loop
-      derived from the active space group; extinction `(type, model)` →
-      `_refine_ls.extinction_method` descriptive string and
-      `_refine_ls.extinction_coef` value per the ADR §3 mapping table
-      (Becker-Coppens type 1 / type 2 / mixed, Zachariasen). P1.14
-      surface.
-- [x] **`tests/unit/easydiffraction/io/cif/test_serialize.py`** — update
-      to cover ADP single-tag emission: rows with `ADP_type='Biso'` /
-      `'Bani'` emit only the `B_*` family; rows with `ADP_type='Uiso'` /
-      `'Uani'` emit only the `U_*` family. P1.3 surface.
-- [x] **`tests/unit/easydiffraction/datablocks/structure/categories/atom_sites/test_default.py`**
-      — update for the casing fixes from P1.2: `_atom_site.ADP_type`
-      (uppercase ADP), `_atom_site.Wyckoff_symbol` (uppercase W,
-      "symbol"); legacy lowercase forms still loadable on read.
-- [x] **`tests/unit/easydiffraction/datablocks/structure/categories/space_group/test_default.py`**
-      — update for `_space_group.name_H-M_alt` and
-      `_space_group.IT_coordinate_system_code` casing fixes (P1.2).
-- [x] **`tests/unit/easydiffraction/analysis/categories/fit_result/test_lsq.py`**
-      — update for the new `_fit_result.*` fields from P1.4: each new
-      descriptor (`R_factor_all`, `wR_factor_all`, `R_factor_gt`,
-      `wR_factor_gt`, `prof_R_factor`, `prof_wR_factor`,
-      `prof_wR_expected`, `number_restraints`, `number_constraints`,
-      `shift_over_su_max`, `shift_over_su_mean`, `profile_function`,
-      `background_function`, `threshold_expression`,
-      `number_reflns_total`, `number_reflns_gt`) is read / written
-      round-trip; fields unset for inapplicable experiment families
-      remain `None`.
-- [x] **`tests/unit/easydiffraction/report/test_report.py`** — new
-      `Report` class: `save()` writes `reports/<project>.cif`; preserved
-      display methods (`show_report`, `show_project_info`,
-      `show_crystallographic_data`, `show_experimental_data`,
-      `show_fitting_details`) keep their existing behaviour (port the
-      relevant assertions from the current
-      `tests/unit/easydiffraction/summary/`-equivalent tests if any
-      exist; otherwise add coverage). P1.8 surface.
-- [x] **`tests/unit/easydiffraction/report/test_check.py`** —
-      `Report.check()` validates the generated CIF against
-      `cif_core.dic` / `cif_pow.dic` via gemmi; surfaces unknown- tag
-      warnings for non-extension categories; ignores the
-      `_easydiffraction_*` namespace per the configured skip list. P1.16
-      surface.
-- [x] **`tests/unit/easydiffraction/project/test_project.py`** — update
-      / extend: `Project.save()` no longer writes `summary.cif`;
-      `Project.save(report=True)` writes `reports/<project>.cif`;
-      `Project.save(report=True, check=True)` runs validation; the
-      `project.report` facade exposes `save`, `check`, and the preserved
-      display methods. P1.8, P1.15, P1.16 surface.
-- [x] **`tests/unit/easydiffraction/analysis/test_analysis.py`** —
-      update for the project-extension `iucr_name` settings on
-      `_minimizer.*`, `_calculator.*`, `_fitting_mode.*` (P1.7):
-      default-save CIF tags unchanged; IUCr-export `iucr_name` resolves
-      to `_easydiffraction_*` prefix.
-- [x] **Script / tutorial coverage.** Verify `pixi run script-tests`
-      exercises at least one tutorial that calls
-      `project.save(report=True)` and the resulting
-      `reports/<project>.cif` is non-empty and gemmi-valid. If no
-      tutorial exercises this, extend the relevant tutorial source per
-      P1.17 and regenerate the notebook.
-
-Use `pixi run test-structure-check` to confirm the unit-test layout
-mirrors the source tree per AGENTS.md §Testing.
-
-## Verification commands (Phase 2)
-
-Per AGENTS.md §Workflow, save any required check output with the
-zsh-safe pattern. Variable names per-task:
-
-```sh
-pixi run fix > /tmp/easydiffraction-fix.log 2>&1; fix_exit_code=$?; tail -n 200 /tmp/easydiffraction-fix.log; exit $fix_exit_code
-pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
-pixi run unit-tests > /tmp/easydiffraction-unit-tests.log 2>&1; unit_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-unit-tests.log; exit $unit_tests_exit_code
-pixi run integration-tests > /tmp/easydiffraction-integration-tests.log 2>&1; integration_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-integration-tests.log; exit $integration_tests_exit_code
-pixi run script-tests > /tmp/easydiffraction-script-tests.log 2>&1; script_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-script-tests.log; exit $script_tests_exit_code
-```
-
-Run in order; each must complete clean before the next. The
-`pixi run script-tests` pass may surface tutorial path collisions or
-stale tutorials — apply the tutorial-source fix from AGENTS.md §Workflow
-("If `pixi run script-tests` fails because two tutorials write to the
-same project directory…") rather than deleting project output. Benchmark
-CSVs under `docs/dev/benchmarking/` produced by `pixi run script-tests`
-are untracked verification artifacts; do not stage them.
-
-## Suggested Pull Request
-
-**Title:**
-`[scope] Align CIF tags with IUCr dictionaries and add journal-submission export`
-
-**Description:**
-
-EasyDiffraction now writes day-to-day project CIFs in a form that
-matches the IUCr core and powder dictionaries where it makes sense,
-while keeping the experiment-side names friendly for users who edit CIFs
-by hand. Structure CIFs adopt the dictionary casing
-(`_atom_site.ADP_type`, `_atom_site.Wyckoff_symbol`,
-`_space_group.name_H-M_alt`, `_space_group.IT_coordinate_system_code`),
-and atomic displacement parameters are written using a single family per
-row (`B_*` or `U_*`) based on `_atom_site.ADP_type`. Analysis CIFs gain
-a richer set of fit-output statistics — the standard Rietveld R-factor
-family, restraint and constraint counts, shift / σ diagnostics, profile
-and background function descriptors — all under the existing
-topology-neutral `_fit_result.*` category, with item names matching IUCr
-casing so they are immediately recognisable to anyone familiar with
-`_refine_ls.*` / `_pd_proc_ls.*` from publications.
-
-A new `project.report` facade replaces the previously empty
-`project.summary` placeholder. Calling `project.save(report=True)` (or
-`project.report.save()`) generates a single journal-submission CIF at
-`reports/<project>.cif` — one multi- datablock file ready to upload to
-IUCr journals, with the publication-metadata `data_global` block holding
-`?` placeholders the user fills in before submission. The new
-`project.report.check()` runs the generated file through `gemmi` against
-the IUCr dictionaries to surface any tag, category, or type issues
-before the upload.
-
-The PR also amends four accepted ADRs (`analysis-cif-fit-state`,
-`minimizer-input-output-split`, `project-facade-and-persistence`,
-`help-discoverability`) to reflect the new facade and field set, and
-promotes the `iucr-cif-tag-alignment` ADR to `accepted/`.
-
-**Scope label:** `[analysis]` or `[io]` — pick whichever the maintainers
-prefer for the IUCr-export work; the field renames in `analysis.cif`
-lean `[analysis]`, the new writer leans `[io]`.
diff --git a/docs/dev/plans/project-summary-rendering.md b/docs/dev/plans/project-summary-rendering.md
deleted file mode 100644
index e1d2fccfc..000000000
--- a/docs/dev/plans/project-summary-rendering.md
+++ /dev/null
@@ -1,1352 +0,0 @@
-# Plan: Project Summary Rendering — migration to single-style + pgfplots + DisplayHandler
-
-Implementation plan for the
-[`project-summary-rendering`](../adrs/accepted/project-summary-rendering.md)
-ADR. Follows [`AGENTS.md`](../../../AGENTS.md) — no deliberate
-exceptions to those instructions.
-
-> **Status (closed).** The report-rendering work has shipped and its ADR
-> remains accepted. The unchecked Phase 2 items later in this document
-> are retained as historical planning detail; the corresponding report,
-> category, display-handler, and units-vocabulary tests now exist in the
-> unit-test tree.
-
-> **Context for this plan.** The branch `project-summary-rendering`
-> already carries an end-to-end Phase 1 implementation of an earlier
-> version of the same ADR (PR-ready as of commit
-> `f354fa435 Reach Phase 1 review gate`). That earlier implementation
-> supported two LaTeX styles (`iucr` + `revtex`), used `kaleido` + a
-> Chrome bootstrap to render fit-quality figures, and had no
-> `DisplayHandler` for descriptor display metadata. The ADR has since
-> been substantially rewritten (single `iucrjournals` style only;
-> `pgfplots` with external CSV in place of `kaleido`; new
-> `DisplayHandler` value object; new ASCII units vocabulary aligned to
-> CIF DDLm `_units.code`; MathJax bundled under `html_offline=True`;
-> descriptor-driven `fit_data.x` payload in `ReportDataContext`).
->
-> This plan is the **migration delta**: the diff between the committed
-> implementation and the rewritten ADR. It does **not** re-derive the
-> surfaces already shipped (config category, per-format methods,
-> `analysis.software`, `project.publication`, and CLI report saving via
-> `fit`); those stay as-is except for the later approved removal of the
-> standalone `save` / `save-report` commands. Every step below either
-> deletes or replaces something the previous implementation introduced,
-> or adds a new surface the rewritten ADR requires.
-
-## ADR cross-reference
-
-- **Primary ADR:**
-  [`project-summary-rendering.md`](../adrs/accepted/project-summary-rendering.md)
-  (Accepted; ADR review cycle closed at review 5 sentinel).
-- The ADR's "ADRs amended by this ADR" section is unchanged by this
-  migration — the amendments to
-  [`iucr-cif-tag-alignment`](../adrs/accepted/iucr-cif-tag-alignment.md),
-  [`analysis-cif-fit-state`](../adrs/accepted/analysis-cif-fit-state.md),
-  [`project-facade-and-persistence`](../adrs/accepted/project-facade-and-persistence.md),
-  and the suggested
-  [`python-cif-category-correspondence`](../adrs/suggestions/python-cif-category-correspondence.md)
-  were applied in the earlier P1 walk and remain valid.
-- No new ADR is required for this migration. The rewritten ADR is the
-  authoritative reference.
-
-## Branch and PR
-
-- **Branch:** `project-summary-rendering` (already checked out; carries
-  the earlier implementation commits).
-- **PR target:** `develop`.
-- Do not push the branch until both Phase 1 and Phase 2 review cycles
-  close.
-
-## Decisions already made (in the ADR)
-
-These are settled by the accepted, rewritten ADR — this plan does not
-re-litigate them:
-
-- **Five-field config, no `style`** (§1.1, §1.3): the `Report`
-  `CategoryItem` carries exactly five persisted descriptors — `cif`,
-  `html`, `tex`, `pdf`, `html_offline` — written as `_report.*` in
-  `project.cif`. No `style` field, no `ReportStyleEnum`, no `--style`
-  CLI flag. Multi-style support is deferred to a follow-up ADR (see ADR
-  "Deferred Work").
-- **Single LaTeX style — `iucrjournals` hardcoded** (§3.2): the LaTeX
-  renderer emits one document class (`iucrjournals`). The vendored TeX
-  bundle drops from 12 files (previous design) to 2: `iucrjournals.cls`
-  and `harvard.sty`, both CC0 1.0 from the IUCr upstream.
-- **No `kaleido`, no `chromium`** (§3.3): each fit-quality figure is a
-  **standalone `pgfplots` `.tex` document**
-  (`reports/tex/data/fit_<expt_id>.tex`, reading its sibling
-  `fit_<expt_id>.csv`), compiled independently to `fit_<expt_id>.pdf`
-  and pulled into the main report via `\includegraphics` — no inline
-  pgfplots in `<project>.tex`, and per-figure compiles isolate the TeX
-  memory pool. The fit-quality figure uses the Plotly geometry, colors,
-  legend structure, grid colors, and line widths where `pgfplots` can
-  support them without exceeding TeX memory. The PDF figure deliberately
-  does **not** include the background curve or measured error bars, and
-  it keeps every measured point with the small pgfplots marker size from
-  the accepted design. The TeX engine (Tectonic / TeX Live / MiKTeX)
-  supplies `pgfplots` + `standalone` + TikZ deps from CTAN or its
-  default sets.
-- **`DisplayHandler` value object** (§1.5): new
-  `@dataclass(frozen=True, slots=True)` at
-  `src/easydiffraction/core/display_handler.py` carrying four optional
-  fields — `display_name`, `display_units`, `latex_name`, `latex_units`.
-  Renderers consult it via a per-context fallback chain (LaTeX context →
-  `latex_*` fields, HTML context → `display_*` fields, GUI/terminal →
-  `display_*` fields), each falling back to the descriptor's plain
-  `name` / `units`. **Table-rendering paths MUST read through the
-  resolution chain, not the raw `descriptor.units` field**, because
-  `units=` now holds ASCII CIF DDLm codes.
-- **Units vocabulary aligned to `_units.code`** (§1.5): every `units=`
-  string on a descriptor is the ASCII value the CIF DDLm dictionary
-  defines verbatim (`angstroms`, `angstrom_squared`, `degrees`,
-  `kelvins`, `kilopascals`, `microseconds`, `dalton`, `megagray`,
-  `reciprocal_angstroms`, `reciprocal_angstrom_squared`, `none`). The
-  single project-internal code in scope is `degrees_squared` (no
-  `_units.code` round-trip). A new `units_vocabulary.py` module
-  enumerates every valid code for a declaration-time validator. The
-  Unicode-symbol form (`Ų`, `°`, `Å`) moves into `display_units`; the
-  LaTeX form (`\AA$^2$`, `$\deg$`, `\AA`) into `latex_units`.
-- **MathJax bundling under `html_offline`** (§2): `html_offline=True`
-  inline-bundles **both** Plotly (~3 MB, `include_plotlyjs=True`) and
-  the vendored MathJax `tex-mml-chtml.js` (~1.5 MB, Apache-2.0). When
-  `html_offline=False`, both load from CDN. No new Python dependency;
-  MathJax is a static JS asset under
-  `src/easydiffraction/report/templates/html/vendor/` packaged by
-  hatchling.
-- **Descriptor-driven `fit_data` shape** (§6): `data_context()`'s
-  `experiments[i].fit_data` payload carries an `x` sub-dict (values +
-  descriptor `name`, `units`, `display_name`, `latex_name`,
-  `display_units`, `latex_units` resolved at builder time) and a
-  `series` sub-dict (`meas`, `calc`, `diff`, optional `bkg`, each with
-  `values`, optional `su`, `label`). One descriptor path, two renderers
-  (Plotly for HTML, pgfplots CSV for TeX), all experiment types — Bragg
-  powder `two_theta`, TOF `time_of_flight`, total-scattering `r`, future
-  `q`, …
-- **CIF persistence unchanged in shape** (§1.3): the existing
-  `category_owner_to_cif` walker continues to emit `_report.*`; the
-  read-side hook in `project_config_from_cif` continues to restore the
-  five fields. Removing `_report.style` from the write surface is the
-  only persistence change required.
-
-## Open questions to resolve during implementation
-
-- **`DisplayHandler` attachment point.** The ADR says the handler
-  attaches to the descriptor as an optional slot. Confirm during P1
-  whether the right surface is the base `Descriptor` class (every
-  descriptor type inherits the slot) or the more specific `Parameter` /
-  `StringDescriptor` subclasses. Default assumption: base `Descriptor` —
-  uniform across all descriptor kinds.
-- **MathJax bundle version.** Pick a specific MathJax 3.x release for
-  `tex-mml-chtml.js` and pin its source URL in `LICENSES.md` for
-  traceability. Assume the latest 3.x release tagged on jsdelivr at
-  vendoring time.
-- **`reports/tex/data/fit_<expt_id>.csv` schema.** The CSV emitter
-  writes one row per data point with columns `x`, `meas`, optional
-  `meas_su`, `calc`, `diff`. Background is not emitted to the pgfplots
-  CSV because the PDF figure does not plot it. Confirm `figure.tex.j2`'s
-  column references match this schema exactly during P1.
-- **Style-bundle cleanup vs. wheel size.** The 10 REVTeX files dropped
-  from the bundle reduce the wheel by ~350 KB. The Phase 2 verification
-  step covers the actual `pixi run dist-build` check
-  (`iucrjournals.cls` + `harvard.sty` still ship; MathJax vendored
-  bundle included); Phase 1 only edits
-  `[tool.hatch.build.targets.wheel]` packaging rules if hatchling's
-  defaults don't pick the files up.
-- **Tutorial coverage.** The two tutorial files already modified in the
-  worktree (`ed-3.py`, `ed-14.py`) reference the old `style=` API; they
-  need re-editing or reverting in P1.17 once the new surface is in
-  place.
-
-## Concrete files likely to change
-
-**Surface shrink — drop `style` everywhere:**
-
-- `src/easydiffraction/report/enums.py` (existing — delete
-  `ReportStyleEnum`; keep only `ReportFormatEnum`).
-- `src/easydiffraction/report/__init__.py` (existing — remove
-  `ReportStyleEnum` re-export).
-- `src/easydiffraction/project/categories/report/default.py` (existing —
-  delete the `style` `StringDescriptor`; drop the `style=` parameter
-  from `save_tex()`, `save_pdf()`, any `Report.save()` dispatch; update
-  docstrings).
-- `src/easydiffraction/__main__.py` (existing — remove standalone
-  report-export CLI options; report saving is driven by persisted
-  `_report.*` flags during `fit`).
-- `src/easydiffraction/report/tex_renderer.py` (existing — remove style
-  dispatch; emit a single template).
-- `src/easydiffraction/io/cif/serialize.py` (existing — no code change
-  expected; the walker emits whatever descriptors are declared, so
-  removing the `style` descriptor drops the `_report.style` row
-  automatically).
-
-**Style-bundle shrink (12 → 2):**
-
-- `src/easydiffraction/report/templates/tex/styles/` — delete:
-  `revtex4-2.cls`, `ltxgrid.sty`, `ltxutil.sty`, `ltxfront.sty`,
-  `ltxdocext.sty`, `revsymb4-2.sty`, `aps4-2.rtx`, `aps10pt4-2.rtx`,
-  `aps11pt4-2.rtx`, `aps12pt4-2.rtx`. Keep: `iucrjournals.cls`,
-  `harvard.sty`.
-- `src/easydiffraction/report/templates/tex/styles/LICENSES.md`
-  (existing — rewrite to cover only the two CC0 1.0 files; remove the
-  LPPL 1.3c REVTeX section).
-- `THIRD_PARTY_LICENSES.md` (existing at repo root — shrink index to one
-  entry).
-- `src/easydiffraction/report/templates/tex/iucr.tex.j2` (existing —
-  rename to a single canonical template name, e.g. `report.tex.j2`).
-- `src/easydiffraction/report/templates/tex/revtex.tex.j2` (existing —
-  delete).
-
-**Drop `kaleido`:**
-
-- `pyproject.toml` (existing — remove `kaleido` from the runtime
-  dependency list).
-- `pixi.lock` (regenerated).
-- `src/easydiffraction/report/tex_renderer.py` (existing — remove
-  kaleido-based PDF figure emission and `figures/` output; replace with
-  pgfplots CSV emission).
-- `docs/docs/user-guide/analysis-workflow/report.md` (existing — drop
-  the kaleido bootstrap section).
-
-**Add `DisplayHandler`:**
-
-- `src/easydiffraction/core/display_handler.py` (new — frozen dataclass
-  with four `str | None` fields).
-- `src/easydiffraction/core/__init__.py` (existing — export
-  `DisplayHandler` alongside `CifHandler` etc., per AGENTS.md
-  `__init__.py` rule).
-- `src/easydiffraction/core/descriptor.py` (or `parameter.py` /
-  `base_descriptor.py` — whichever owns the descriptor base) (existing —
-  add an optional `display_handler: DisplayHandler | None = None` slot;
-  define resolution helpers `resolve_display_name(context)` /
-  `resolve_display_units(context)` per the ADR's per-context fallback
-  chain).
-
-**Units vocabulary sweep:**
-
-- `src/easydiffraction/core/units_vocabulary.py` (new — enumerate every
-  valid `units=` code; raise `ValueError` with the offending code on
-  validation failure; called from the descriptor base class at
-  construction time).
-- Every descriptor declaration in `src/easydiffraction/` that currently
-  passes a Unicode units string (`'Ų'`, `'°'`, `'Å'`, …) — rewrite to
-  use the ASCII DDLm code and attach a `DisplayHandler` with the Unicode
-  / LaTeX forms. Concrete file list resolved during P1.7's sweep; expect
-  ≥20 sites across `datablocks/structure/`, `datablocks/experiment/`,
-  `analysis/categories/`.
-
-**Table-rendering migration:**
-
-- `src/easydiffraction/project/categories/report/default.py` (existing —
-  every `show_*()` method that builds a unit column reads through
-  `resolve_display_units(...)` instead of `descriptor.units` directly).
-- `src/easydiffraction/report/html_renderer.py` (existing — same
-  migration for Jinja context inputs).
-- `src/easydiffraction/report/tex_renderer.py` (existing — same
-  migration for the TeX context).
-- `src/easydiffraction/report/data_context.py` (existing — every label /
-  unit string baked into the context is resolved per-context here so
-  renderers don't re-derive).
-
-**MathJax bundling:**
-
-- `src/easydiffraction/report/templates/html/vendor/mathjax-tex-mml-chtml.js`
-  (new — vendored static asset, Apache-2.0).
-- `src/easydiffraction/report/templates/html/vendor/LICENSES.md` (new —
-  Apache-2.0 text + upstream URL + version).
-- `THIRD_PARTY_LICENSES.md` (existing at repo root — extend index with
-  MathJax entry alongside the IUCr TeX bundle).
-- `src/easydiffraction/report/templates/html/report.html.j2` (existing —
-  switch the MathJax `<script>` tag between the relative vendored path
-  and the CDN URL per `html_offline`).
-- `src/easydiffraction/report/html_renderer.py` (existing — when
-  `html_offline=True`, copy the vendored MathJax file next to the
-  emitted `<project>.html` so the relative `<script src="vendor/...">`
-  resolves; otherwise emit the CDN URL).
-- `pyproject.toml` (existing — confirm
-  `[tool.hatch.build.targets.wheel.shared-data]` (or the package-data
-  equivalent already in place) ships the new `vendor/` subtree).
-
-**`fit_data` shape + pgfplots CSV emitter:**
-
-- `src/easydiffraction/report/data_context.py` (existing — replace the
-  previous `figures.fit_per_experiment` payload with the
-  descriptor-driven `experiments[i].fit_data` dict per ADR §6).
-- `src/easydiffraction/report/tex_renderer.py` (existing — add
-  `_write_fit_csv(expt_id, fit_data, out_dir)` writing
-  `reports/tex/data/fit_<expt_id>.csv`, and render a standalone
-  `data/fit_<expt_id>.tex` per experiment from the new `figure.tex.j2`;
-  see §3.3 and P1.16).
-- `src/easydiffraction/report/templates/tex/figure.tex.j2` (new —
-  `\documentclass{standalone}` pgfplots figure: Plotly-derived geometry,
-  colors, line widths, legend structure, Bragg row, residual panel,
-  light inner grids, no outside tick marks. Measured points are all
-  plotted; background and measured error bars are intentionally omitted
-  from the PDF figure. No band. `\pgfplotsset{set layers}` +
-  `mark layer=like plot` mandatory; see P1.16 and P1.23).
-- `src/easydiffraction/report/templates/tex/report.tex.j2` (renamed from
-  `iucr.tex.j2`) — the **main** document: tables +
-  `\includegraphics{data/fit_<expt>.pdf}` per experiment. No inline
-  pgfplots. Single template, no style branching.
-- `src/easydiffraction/report/pdf_compiler.py` (existing — compile each
-  `data/fit_<expt>.tex` first, then the main `<project>.tex`, **each
-  using the same discovered-engine fallback** `_ENGINE_ORDER` =
-  `tectonic` → `latexmk` → `pdflatex` (not tectonic only); per-figure
-  separate documents provide the memory isolation; see P1.16).
-- `src/easydiffraction/report/html_renderer.py` (existing — the Plotly
-  builder now consumes `fit_data` directly rather than expecting
-  pre-rendered HTML; serializes through the shared `PlotlyPlotter`
-  helper that applies `_get_config()` **and** the legend-toggle
-  `post_script` + `_wrap_html_figure` wrapper, with a **report-only**
-  `force_template='plotly_white'` override (notebook stays
-  theme-adaptive); see ADR §2 and P1.18).
-- `src/easydiffraction/report/templates/html/report.html.j2` (existing —
-  feed the dict to the Plotly builder at render time).
-
-**Tutorials and docs:**
-
-- `docs/docs/tutorials/ed-3.py`, `docs/docs/tutorials/ed-14.py`
-  (existing — already dirty in the worktree from the earlier walk; align
-  with the new no-`style` surface, then regenerate notebooks via
-  `pixi run notebook-prepare`).
-- `docs/docs/tutorials/*.ipynb` (regenerated artefacts matched to the
-  edited `.py` sources).
-- `docs/docs/user-guide/analysis-workflow/report.md` (existing — remove
-  `style=` mentions and the kaleido bootstrap section; add the
-  MathJax-offline note).
-- `docs/docs/api-reference/report.md` (existing — update the `Report`
-  class surface: five fields, no `ReportStyleEnum`, no `--style`).
-
-## Commit discipline
-
-When an AI agent follows this plan, **every completed Phase 1
-implementation step must be staged with explicit paths and committed
-locally before moving to the next implementation step or the Phase 1
-review gate.** Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
-**Commits**. Keep commits atomic, single-purpose, and aligned with the
-plan steps. Do not include generated artifacts (data CIFs, project
-directories, benchmark CSVs) unless the step explicitly produces them —
-see **Workflow** in [`AGENTS.md`](../../../AGENTS.md) for the
-generated-artifact exceptions.
-
-## Implementation steps (Phase 1)
-
-- [x] **P1.1 — Remove `ReportStyleEnum` and `style` field**
-  - Files: `src/easydiffraction/report/enums.py`,
-    `src/easydiffraction/report/__init__.py`,
-    `src/easydiffraction/project/categories/report/default.py`.
-  - Delete `ReportStyleEnum` and its re-export.
-  - Delete the `style` `StringDescriptor` from `Report` (the four-field
-    config + `html_offline` remains).
-  - Update docstrings to reference the five-field surface; drop any
-    "style selector" prose.
-  - Commit: `Drop ReportStyleEnum and _report.style field`.
-
-- [x] **P1.2 — Drop `style=` from `save_tex` / `save_pdf` / CLI**
-  - Files: `src/easydiffraction/project/categories/report/default.py`,
-    `src/easydiffraction/__main__.py`,
-    `src/easydiffraction/report/tex_renderer.py`,
-    `src/easydiffraction/report/pdf_compiler.py`.
-  - Drop the `style='iucr'` kwarg from `save_tex()` and `save_pdf()`
-    signatures and from any internal dispatcher / `Report.save()` call
-    site.
-  - Keep CLI report saving tied to the persisted `_report.*` flags used
-    during `fit`; do not add one-off report-export flags.
-  - The TeX renderer's template selection collapses to a single template
-    (renamed below); remove the `ReportStyleEnum`-driven dispatch.
-  - Commit: `Drop style= parameter from save_tex/save_pdf and CLI`.
-
-- [x] **P1.3 — Reduce vendored TeX bundle (12 → 2 files)**
-  - Files: delete
-    `src/easydiffraction/report/templates/tex/styles/revtex4-2.cls`,
-    `ltxgrid.sty`, `ltxutil.sty`, `ltxfront.sty`, `ltxdocext.sty`,
-    `revsymb4-2.sty`, `aps4-2.rtx`, `aps10pt4-2.rtx`, `aps11pt4-2.rtx`,
-    `aps12pt4-2.rtx` (10 files). Keep `iucrjournals.cls` and
-    `harvard.sty`.
-  - Rewrite
-    `src/easydiffraction/report/templates/tex/styles/LICENSES.md` to
-    cover only the two CC0 1.0 files (per-file attribution, upstream
-    URL, version). Remove the LPPL 1.3c REVTeX section.
-  - Update `THIRD_PARTY_LICENSES.md` at the repo root: shrink the index
-    to one entry pointing at the in-package `LICENSES.md`.
-  - Commit: `Drop REVTeX style files from vendored TeX bundle`.
-
-- [x] **P1.4 — Rename TeX template to a single canonical name**
-  - Files: rename `src/easydiffraction/report/templates/tex/iucr.tex.j2`
-    → `report.tex.j2`. Delete
-    `src/easydiffraction/report/templates/tex/revtex.tex.j2`.
-  - Update `src/easydiffraction/report/tex_renderer.py` to load the
-    renamed template by its single path.
-  - Commit: `Rename TeX template to single canonical report.tex.j2`.
-
-- [x] **P1.5 — Drop `kaleido` runtime dependency**
-  - Files: `pyproject.toml`, `pixi.lock` (regenerated);
-    `src/easydiffraction/report/tex_renderer.py`;
-    `docs/docs/user-guide/analysis-workflow/report.md`.
-  - Remove `kaleido` from the runtime dependency list in
-    `pyproject.toml`. Regenerate `pixi.lock`.
-  - Strip the kaleido-based PDF figure emission code from the TeX
-    renderer (the `figures/` directory creation,
-    `fig.write_image(..., engine='kaleido')` calls, and the bootstrap
-    warning text).
-  - Remove the "Kaleido browser bootstrap" subsection from the
-    user-guide report doc.
-  - Per AGENTS.md §Architecture, removing a dependency the ADR named is
-    pre-approved by the rewritten ADR text (which explicitly says
-    kaleido is gone).
-  - Commit: `Drop kaleido runtime dependency`.
-
-- [x] **P1.6 — Add `DisplayHandler` dataclass**
-  - Files: new `src/easydiffraction/core/display_handler.py`; existing
-    `src/easydiffraction/core/__init__.py`.
-  - Define `DisplayHandler` exactly per ADR §1.5:
-    `@dataclass(frozen=True, slots=True)` with four fields —
-    `display_name: str | None = None`,
-    `display_units: str | None = None`, `latex_name: str | None = None`,
-    `latex_units: str | None = None`. Numpy-style docstring summary ≤72
-    chars.
-  - Export from `src/easydiffraction/core/__init__.py` so
-    `from easydiffraction.core import DisplayHandler` works.
-  - Commit: `Add DisplayHandler value object for descriptors`.
-
-- [x] **P1.7 — Wire `display_handler` slot + resolution helpers on
-      `Descriptor`**
-  - Files: existing `src/easydiffraction/core/descriptor.py` (or
-    `parameter.py` / `base_descriptor.py`, whichever owns the base —
-    confirm at step start with `git grep -n "class Descriptor"`).
-  - Add an optional `display_handler: DisplayHandler | None = None` slot
-    on the base class (`__init__` kwarg + storage).
-  - Add two resolution helpers on the base class:
-    - `resolve_display_name(context: str) -> str` — `context` is one of
-      `'latex'`, `'html'`, `'gui'`; returns
-      `handler.latex_name or self.name` for `'latex'`,
-      `handler.display_name or self.name` otherwise.
-    - `resolve_display_units(context: str) -> str` — same shape; falls
-      back to `self.units`.
-  - Both helpers fall through cleanly when `display_handler is None`, so
-    descriptors without an attached handler keep working unchanged.
-  - Commit:
-    `Wire display_handler slot and resolution helpers on Descriptor`.
-
-- [x] **P1.8 — Inventory every `units=` string and build the vocabulary
-      table**
-  - Files: new
-    `docs/dev/plans/project-summary-rendering_units-inventory.md`
-    (working scratch — **not committed**); read-only sweep of
-    `src/easydiffraction/`.
-  - Run `git grep -nE "units='[^']*'" src/easydiffraction/` and record
-    every distinct unit literal. For each, look up the matching
-    `_units.code` in
-    [`cif_core.dic`](../../../tmp/iucr-dicts/cif_core.dic) and
-    [`cif_pow.dic`](../../../tmp/iucr-dicts/cif_pow.dic) via
-    `grep -nE "_units.code" tmp/iucr-dicts/*.dic` and pick the
-    dictionary's spelling verbatim when one exists. Symbols the
-    dictionaries don't define become project-internal codes following
-    the dictionary's naming pattern (e.g. `arcminutes`, `teslas`,
-    `volts_per_metre`).
-  - The **verified inventory** as of this plan (19 distinct literals;
-    revise during the step if `src/` has shifted):
-
-    | Symbol   | Code                                        | Source                    |
-    | -------- | ------------------------------------------- | ------------------------- |
-    | `''`     | `none`                                      | cif_core.dic              |
-    | `K`      | `kelvins`                                   | cif_core.dic              |
-    | `T`      | `teslas`                                    | project-internal          |
-    | `V/m`    | `volts_per_metre`                           | project-internal          |
-    | `arcmin` | `arcminutes`                                | project-internal          |
-    | `deg`    | `degrees`                                   | cif_core.dic              |
-    | `deg²`   | `degrees_squared`                           | project-internal          |
-    | `kPa`    | `kilopascals`                               | cif_core.dic              |
-    | `Å`      | `angstroms`                                 | cif_core.dic              |
-    | `Ų`     | `angstrom_squared`                          | cif_core.dic              |
-    | `Å⁻¹`    | `reciprocal_angstroms`                      | cif_core.dic              |
-    | `Å⁻²`    | `reciprocal_angstrom_squared`               | cif_core.dic              |
-    | `μm`     | `micrometres`                               | project-internal          |
-    | `μs`     | `microseconds`                              | cif_core.dic, cif_pow.dic |
-    | `μs/Å`   | `microseconds_per_angstrom`                 | cif_pow.dic               |
-    | `μs/Ų`  | `microseconds_per_angstrom_squared`         | cif_pow.dic               |
-    | `μs²`    | `microseconds_squared`                      | project-internal          |
-    | `μs²/Ų` | `microseconds_squared_per_angstrom_squared` | project-internal          |
-    | `μs·Å`   | `microsecond_angstroms`                     | project-internal          |
-
-  - The seven project-internal codes follow the dictionary
-    plural/singular pattern (each modelled on its closest dictionary
-    sibling) and have no `_units.code` round-trip.
-  - Commit: none. P1.8 produces no code — it sets up the table that P1.9
-    and P1.10 consume. The inventory file is `.gitignore`-style scratch
-    under `docs/dev/plans/` named with the `_units-inventory.md` suffix
-    so it's clearly disposable; leave it untracked or delete after
-    P1.10.
-
-- [x] **P1.9 — Add `units_vocabulary.py` validator covering every
-      inventoried code**
-  - Files: new `src/easydiffraction/core/units_vocabulary.py`; existing
-    `src/easydiffraction/core/__init__.py`.
-  - Module exports `VALID_UNITS_CODES: frozenset[str]` containing
-    **every** code from the P1.8 inventory — dictionary codes
-    (`angstroms`, `angstrom_squared`, `degrees`, `kelvins`,
-    `kilopascals`, `microseconds`, `microseconds_per_angstrom`,
-    `microseconds_per_angstrom_squared`, `reciprocal_angstroms`,
-    `reciprocal_angstrom_squared`, `none`) **plus** every
-    project-internal code (`arcminutes`, `teslas`, `volts_per_metre`,
-    `micrometres`, `degrees_squared`, `microseconds_squared`,
-    `microseconds_squared_per_angstrom_squared`,
-    `microsecond_angstroms`).
-  - Module exports `validate_units_code(code: str) -> None` raising
-    `ValueError(f"Unknown units code: {code!r}. Valid: {sorted(VALID_UNITS_CODES)}")`
-    on membership miss.
-  - Call `validate_units_code(units)` from the base descriptor's
-    `__init__` only when `units` is a non-empty string. Empty strings
-    get normalised to `'none'` (the dimensionless ASCII code) at the
-    same site so legacy `units=''` declarations keep working until P1.10
-    rewrites them.
-  - The vocabulary is the single source of truth — adding a new unit
-    anywhere in `src/` later requires extending `VALID_UNITS_CODES`
-    first, otherwise the descriptor raises at import time. The P1.9 test
-    below asserts this round-trip with a parametrised case per code.
-  - Commit: `Add units vocabulary validator at descriptor construction`.
-
-- [x] **P1.10 — Sweep `units=` strings across `src/` + attach
-      `DisplayHandler`**
-  - Files: every descriptor declaration in `src/easydiffraction/` from
-    the P1.8 inventory. The sites are concentrated under
-    `src/easydiffraction/datablocks/experiment/categories/` (data,
-    diffrn, extinction, instrument, peak, refln) and
-    `src/easydiffraction/datablocks/structure/categories/`
-    (atom_site_aniso, atom_sites, cell).
-  - For each call site, apply the inventory mapping from P1.8:
-    - Rewrite the unit literal to the ASCII code.
-    - Attach a
-      `DisplayHandler(display_units=<symbol>, latex_units=<latex>)` with
-      the matching Unicode and LaTeX forms (e.g.
-      `display_units='Ų', latex_units=r'\AA$^2$'`;
-      `display_units='μs/Å', latex_units=r'$\mu\mathrm{s}/\mathrm{\AA}$'`).
-      For descriptors whose `name` would benefit from a typeset form
-      (Greek letters, subscripts, `Uiso`), also set `display_name` /
-      `latex_name`.
-    - The empty-string case (`units=''`) becomes `units='none'` plus no
-      `display_units` on the handler so terminal output stays bare.
-  - The construction-time validator from P1.9 catches any miss
-    automatically — if a code is missed, descriptor instantiation raises
-    at import time and `pytest --collect-only` fails fast.
-  - Commit:
-    `Migrate descriptor units to ASCII codes with DisplayHandler`.
-
-- [x] **P1.11 — Migrate table-rendering paths to read via
-      `DisplayHandler`**
-  - Files: existing
-    `src/easydiffraction/project/categories/report/default.py`,
-    `src/easydiffraction/report/data_context.py`,
-    `src/easydiffraction/report/html_renderer.py`,
-    `src/easydiffraction/report/tex_renderer.py`.
-  - Every `show_*()` method on `Report` building a unit column reads
-    `descriptor.resolve_display_units('gui')` (or `'html'` for Jupyter
-    contexts) instead of `descriptor.units` directly.
-  - `data_context()` bakes resolved labels and units into the dict
-    per-renderer-context once at builder time so Jinja templates consume
-    strings, not raw descriptors.
-  - HTML and TeX renderers read the pre-resolved strings from the
-    context.
-  - Commit:
-    `Read display labels through DisplayHandler resolution chain`.
-
-- [x] **P1.12 — Vendor MathJax `tex-mml-chtml.js`**
-  - Files: new
-    `src/easydiffraction/report/templates/html/vendor/mathjax-tex-mml-chtml.js`
-    (Apache-2.0, ~1.5 MB minified, MathJax 3.x); new
-    `src/easydiffraction/report/templates/html/vendor/LICENSES.md` (full
-    Apache-2.0 text + upstream URL + version); update
-    `THIRD_PARTY_LICENSES.md` at the repo root.
-  - The vendor URL is jsdelivr's
-    `https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js` at
-    vendoring time; record the exact pinned version string in
-    `vendor/LICENSES.md` for traceability.
-  - If hatchling's default behaviour does not pick the new `vendor/`
-    subtree up under `[tool.hatch.build.targets.wheel]`, extend the
-    packaging config with a
-    `force-include = { "src/easydiffraction/report/templates/html/vendor" = "easydiffraction/report/templates/html/vendor" }`
-    rule in the same commit. The actual `pixi run dist-build` +
-    `unzip -l dist/*.whl` verification is a Phase 2 step (see the test
-    plan below) per AGENTS.md §Workflow's two-phase split.
-  - Commit: `Vendor MathJax tex-mml-chtml bundle`.
-
-- [x] **P1.13 — Wire MathJax loader through `html_offline`**
-  - Files: existing
-    `src/easydiffraction/report/templates/html/report.html.j2`; existing
-    `src/easydiffraction/report/html_renderer.py`.
-  - Template emits one of two `<script>` tags driven by a boolean
-    context variable `html_offline`:
-    - `True`: `<script src="vendor/mathjax-tex-mml-chtml.js"></script>`.
-    - `False`:
-      `<script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>`.
-  - When `html_offline=True`, the renderer copies the vendored file next
-    to the emitted `<project>.html` so the relative
-    `<script src="vendor/...">` resolves on-disk (use `shutil.copy2`).
-    The CDN branch needs no file copy.
-  - This is the **same switch** that already governs the
-    `fig.to_html(include_plotlyjs=<cdn|True>)` call; the two assets are
-    tied to one config field per ADR §2.
-  - Commit: `Inline MathJax when html_offline=True`.
-
-- [x] **P1.14 — Add `x_descriptor` + `fit_data_arrays()` on
-      `ExperimentBase` and data categories**
-  - Files: existing
-    `src/easydiffraction/datablocks/experiment/item/base.py` (the
-    experiment base — see
-    `src/easydiffraction/datablocks/experiment/item/base.py:618` for the
-    existing `data` property the new API forwards through);
-    `src/easydiffraction/datablocks/experiment/categories/data/bragg_pd.py`,
-    `src/easydiffraction/datablocks/experiment/categories/data/total_pd.py`.
-  - The current report builder reaches the x array via
-    `_line_fit_x_values()` plus an ad-hoc string label (see
-    `src/easydiffraction/report/data_context.py:433` and
-    `src/easydiffraction/report/data_context.py:470`). Replace that
-    ad-hoc path with a **two-layer API**: descriptor metadata lives on
-    the data category; `ExperimentBase` exposes flat forwarding
-    properties so the renderer reads `e.x_descriptor` and
-    `e.fit_data_arrays()` directly.
-  - **Layer A — data-category bindings** (`x_descriptor` returns the
-    existing descriptor object that owns the x axis; `fit_data_arrays()`
-    returns a dict of numpy arrays):
-    - `BraggPdData` (Bragg powder, both beam modes):
-      - `x_descriptor` returns the `two_theta` descriptor for CWL
-        (`bragg_pd.py:210`) or the `time_of_flight` descriptor for TOF
-        (`bragg_pd.py:220`). The CWL-vs-TOF branch keys on the
-        experiment's `beam_mode`. The descriptor objects live on the
-        data-point class, but the collection-level `x_descriptor`
-        returns the same descriptor object — the values come from the
-        existing collection-level x-array properties already in place at
-        `bragg_pd.py:607` and `bragg_pd.py:688`.
-    - `TotalPdData` (total-scattering powder):
-      - `x_descriptor` returns the `r` descriptor (`total_pd.py:55`).
-      - x-array lives at `total_pd.py:366`.
-    - `BraggScData` (Bragg single-crystal):
-      - `x_descriptor` returns **`None`** — no 1-D x axis, no fit chart
-        in scope. (A 2-D figure path is deferred per ADR §8.)
-      - `fit_data_arrays()` returns an empty dict `{}` for the same
-        reason.
-    - All three categories' `fit_data_arrays()` return the dict
-      `{'x': np.ndarray, 'meas': np.ndarray, 'meas_su': np.ndarray | None, 'calc': np.ndarray, 'diff': np.ndarray, 'bkg': np.ndarray | None}`
-      — x values folded into the same dict so the renderer has one
-      source of truth for "all arrays this experiment's fit chart
-      needs". Consolidates the existing scattered accessors
-      (`measured.intensity`, `calculated.intensity`, inline-difference
-      computation in the data-context builder) into one boundary.
-  - **Layer B — experiment-class flat surface, split per family** (so
-    single-crystal experiments — which do not initialise `self._data`
-    per
-    `src/easydiffraction/datablocks/experiment/item/base.py:426,446,504`
-    — never reach a `self.data.*` dereference):
-    - `PdExperimentBase.x_descriptor` — property forwarding to
-      `self.data.x_descriptor`. `self._data` is set by
-      `PdExperimentBase` (see
-      `src/easydiffraction/datablocks/experiment/item/base.py:519,534`),
-      so the forward succeeds for every concrete powder experiment.
-    - `PdExperimentBase.fit_data_arrays()` — method forwarding to
-      `self.data.fit_data_arrays()`.
-    - `ScExperimentBase.x_descriptor` — property returning `None`
-      directly. No `self.data` reach- through; single-crystal
-      experiments have no 1-D x axis and so no fit chart, full stop.
-    - `ScExperimentBase.fit_data_arrays()` — method returning `{}`
-      directly.
-    - Renderers call `e.x_descriptor` and `e.fit_data_arrays()` on the
-      experiment regardless of family and branch on
-      `if e.x_descriptor is None: skip` — the value carries the "no x
-      axis" signal, and no `AttributeError` is ever raised.
-    - `ExperimentBase` itself stays abstract for these two surfaces — it
-      does **not** declare a default implementation that would mask the
-      per-family split. Concrete families inherit from
-      `PdExperimentBase` / `ScExperimentBase` and pick up the matching
-      version.
-  - The `is None` / `{}` semantics replace the previous `hasattr` +
-    `NotImplementedError` combination, which would have propagated the
-    exception out of `hasattr` rather than registering as absence.
-  - Commit: `Add x_descriptor and fit_data_arrays on ExperimentBase`.
-
-- [x] **P1.15 — Replace `fit_data` shape in `data_context()`**
-  - Files: existing `src/easydiffraction/report/data_context.py`.
-  - Replace the previous `figures.fit_per_experiment`
-    `expt_id -> plotly_html_div` payload with the descriptor-driven
-    shape per ADR §6, consuming the flat API from P1.14:
-
-    ```python
-    'experiments': [
-        _build_experiment_payload(e)
-        for e in self.project.experiments.values()
-    ]
-
-    # In a module-level helper:
-    def _build_experiment_payload(e):
-        base = {'id': e.id, ...}  # other experiment fields
-        if e.x_descriptor is None:
-            base['fit_data'] = None
-            return base
-        arrays = e.fit_data_arrays()
-        base['fit_data'] = {
-            'x': {
-                'values':        arrays['x'],
-                'name':          e.x_descriptor.name,
-                'units':         e.x_descriptor.units,
-                'display_name':  e.x_descriptor.resolve_display_name('html'),
-                'latex_name':    e.x_descriptor.resolve_display_name('latex'),
-                'display_units': e.x_descriptor.resolve_display_units('html'),
-                'latex_units':   e.x_descriptor.resolve_display_units('latex'),
-            },
-            'series': {
-                'meas': {'values': arrays['meas'],    'su': arrays['meas_su'], 'label': 'Measured'},
-                'calc': {'values': arrays['calc'],                              'label': 'Calculated'},
-                'diff': {'values': arrays['diff'],                              'label': 'Difference'},
-                'bkg':  {'values': arrays['bkg'],                               'label': 'Background'},
-            },
-        }
-        return base
-    ```
-
-    Single-crystal experiments contribute `fit_data: None`; renderers
-    skip the fit-quality block when the value is `None`. The
-    `fit_data_arrays()` call happens once per experiment, so the four
-    `arrays[...]` reads share a single dict.
-
-  - The previous pre-rendered HTML payload is **removed entirely** —
-    neither renderer reads it. The Plotly figure is built at HTML render
-    time from `fit_data`; the LaTeX renderer reads the same `fit_data`
-    for the CSV emitter in P1.16.
-  - Commit: `Replace fit_data payload with descriptor-driven shape`.
-
-- [x] **P1.16 — Standalone per-figure pgfplots `.tex` → PDF, included by
-      the report** (See ADR §3.3 — "standalone pgfplots figures, built
-      independently, included as PDF" — for the full decision this step
-      implements.)
-  - Files: existing `src/easydiffraction/report/tex_renderer.py`,
-    `src/easydiffraction/report/pdf_compiler.py`; renamed
-    `src/easydiffraction/report/templates/tex/report.tex.j2` (from
-    P1.4); new `src/easydiffraction/report/templates/tex/figure.tex.j2`
-    (standalone figure document).
-  - Add `_write_fit_csv(expt_id, fit_data, out_dir)` writing
-    `<out_dir>/data/fit_<expt_id>.csv` with columns
-    `x, meas, calc, diff` (+ `meas_su` when present). Write all rows; do
-    not downsample the pgfplots data. Background is omitted from this
-    CSV because the PDF figure does not plot it. Python stdlib `csv`, no
-    new dependency.
-  - Add `figure.tex.j2`: a `\documentclass{standalone}` pgfplots
-    document, one per experiment, rendered to `data/fit_<expt_id>.tex`.
-    Mandatory preamble: `\pgfplotsset{set layers}` **and** axis option
-    `mark layer=like plot` (both required — `mark layer` is inert
-    without `set layers`; together they let the calculated line draw
-    over the measured markers).
-  - **Intensity panel: two plotted data series.**
-    - Measured — connecting line + markers for **all** points: `mark=*`,
-      small `mark size=0.75pt`, Plotly- derived line width,
-      `line join=bevel`, and marker outline width `0pt`.
-    - Calculated — red line, declared after measured so it draws above
-      the measured data.
-    - **No measured–calculated band, no background curve, and no
-      measured error bars in the PDF.** Residual and Bragg peaks stay in
-      their own panels, but appear in the main legend like Plotly.
-  - Bragg tick row + residual panel as before (residual in its own
-    panel; difference is not overlaid on intensity).
-  - `report.tex.j2` (main document) includes each figure as a pre-built
-    PDF: `\includegraphics[width=\linewidth]{data/fit_<expt_id>.pdf}` —
-    **no inline pgfplots in the main report**.
-  - `Report.save_tex()` writes, per experiment, the CSV + the standalone
-    `fit_<expt_id>.tex`, and writes the main `<project>.tex`.
-    `pdf_compiler.py` is extended so `save_pdf()` compiles **each figure
-    `.tex` first, then the main `<project>.tex`** (which
-    `\includegraphics` the figure PDFs) — an N+1-document build. Each
-    compile (figure and main) uses the **same discovered-engine fallback
-    the compiler already implements** (`tectonic` → `latexmk` →
-    `pdflatex`, `_ENGINE_ORDER` in `pdf_compiler.py`) — not `tectonic`
-    only — so TeX Live / MiKTeX users keep PDF output. Compiling each
-    figure as its own document is what isolates the memory pool; the
-    engine choice is unchanged. When only `tex` is configured (no
-    `pdf`), the figure `.tex` + CSV are written but not compiled.
-  - **Data resolution — concrete contract.** Plot every row from
-    `fit_data` in the pgfplots CSV. Do not downsample PDF plots or use a
-    sampled marker/error-bar overlay.
-  - Commit: `Emit standalone pgfplots figures included as PDF`.
-
-- [x] **P1.17 — HTML Plotly builder consumes `fit_data` directly**
-  - Files: existing `src/easydiffraction/report/html_renderer.py`;
-    existing `src/easydiffraction/report/templates/html/report.html.j2`;
-    existing `src/easydiffraction/display/plotters/plotly.py` (if
-    separate — confirm with `git grep -n "class.*Plotly" src/`).
-  - The HTML renderer feeds each experiment's `fit_data` dict to the
-    Plotly builder at render time, then embeds the resulting figure via
-    `fig.to_html(include_plotlyjs=<cdn|True>)`. The template no longer
-    expects pre-rendered HTML in the context.
-  - Axis labels and series labels come from the same `fit_data` payload
-    the TeX renderer uses — one source of truth.
-  - Commit: `Build Plotly fit figures from fit_data context`.
-
-- [x] **P1.18 — HTML serialization parity: forced light theme + notebook
-      modebar (ADR §2)**
-  - Files: `src/easydiffraction/report/html_renderer.py`;
-    `src/easydiffraction/display/plotters/plotly.py` (extract a shared
-    serialization helper — see below).
-  - **Problem this fixes.** The current report HTML path serializes with
-    only `full_html=False` + `include_plotlyjs=...`
-    (`html_renderer.py:283`); it does **not** pass the notebook
-    `config`, does **not** pass the notebook `post_script`, and does
-    **not** force the figure template after `PlotlyPlotter()` has set
-    the global default from the ambient theme (`html_renderer.py:221`).
-    So the report can inherit a dark theme and shows Plotly's default
-    modebar. ADR §2 requires the report to match the notebook.
-  - **Forced light theme — report only.** For the report, set each
-    figure's `template` to `plotly_white` **on the figure object** (e.g.
-    `fig.update_layout(template='plotly_white')`) right before
-    serialization — not via the global `pio.templates.default`, which
-    `PlotlyPlotter.__init__` already set from the ambient theme. This
-    makes the report independent of notebook/system dark mode. **The
-    notebook path must NOT be forced** — it stays theme-adaptive per
-    `_default_template_name` (ADR §1 / §2). So forcing `plotly_white` is
-    a report-only override, not part of the shared mechanics.
-  - **Notebook modebar — reuse the notebook serialization mechanics (two
-    pieces).** The curated buttons come from
-    `PlotlyPlotter._get_config()` (`plotly.py:567` —
-    `displaylogo=False`, `modeBarButtonsToRemove`), **but the custom
-    legend-toggle button is NOT in `_get_config()`** — it is installed
-    via `post_script` plus the `_wrap_html_figure` wrapper in
-    `_show_figure` (`plotly.py:954`). To match the notebook, the report
-    must pass **both** `config=_get_config()` and the same
-    `post_script`, and apply the same wrapper.
-  - **Implementation: one shared low-level helper + a report-only
-    template override.** Extract the notebook's
-    `pio.to_html(..., config=_get_config(), post_script=...)`
-    - `_wrap_html_figure` sequence into a single classmethod on
-      `PlotlyPlotter` that takes the template as a parameter — e.g.
-      `serialize_html(fig, *, offline, force_template: str | None = None)`:
-      it applies `_get_config()`, the legend-toggle `post_script`, and
-      the wrapper, and when `force_template` is given does
-      `fig.update_layout(template=force_template)` first. The
-      **notebook** path (`_show_figure`) calls it with
-      `force_template=None` (keeps its theme-adaptive template); the
-      **report** renderer calls it with `force_template='plotly_white'`.
-      One source of truth for the modebar/post-script/wrapper; the
-      light-theme override lives only at the report call site.
-  - Commit: `Serialize report Plotly figures via shared notebook path`.
-
-- [x] **P1.19 — Clean up stale `figures/` references in code and docs**
-  - Files: `src/easydiffraction/project/categories/report/default.py`,
-    `src/easydiffraction/report/tex_renderer.py`,
-    `src/easydiffraction/report/pdf_compiler.py`,
-    `docs/docs/user-guide/analysis-workflow/report.md`,
-    `docs/docs/api-reference/report.md`.
-  - Update install-hint warning text (engine-missing branch) from
-    "`.tex`, `figures/`, and `styles/` are still written" to "`.tex`,
-    `data/`, and `styles/` are still written" — matches the new on-disk
-    layout.
-  - Update docstrings and user-guide prose anywhere the old `figures/`
-    directory was named.
-  - A final `git grep -n figures/` across `src/` and `docs/` should
-    return only legitimate hits (e.g. inline comments describing the
-    rendered output's typesetting, not filesystem paths).
-  - Commit: `Replace stale figures/ references with data/`.
-
-- [x] **P1.20 — Update tutorials and user-guide for the new surface**
-  - Files: `docs/docs/tutorials/ed-3.py`,
-    `docs/docs/tutorials/ed-14.py`, any other tutorial `.py` referencing
-    `style=` or `--style` (grep at step start); regenerated
-    `docs/docs/tutorials/*.ipynb` artefacts;
-    `docs/docs/user-guide/analysis-workflow/report.md`;
-    `docs/docs/api-reference/report.md`.
-  - Drop every `style='iucr'` / `style='revtex'` / `--style iucr`
-    reference from tutorial sources. The new examples show
-    `project.report.formats = ['html', 'tex']` + `project.save()` and
-    the matching one-off `project.report.save_pdf()`.
-  - Add a short user-guide note covering the `html_offline=True`
-    two-asset bundle (Plotly + MathJax, ~4.5 MB total).
-  - Regenerate notebooks via `pixi run notebook-prepare` and stage the
-    regenerated `.ipynb` files alongside the `.py` edits.
-  - Commit: `Update tutorials and docs for single-style report surface`.
-
-- [x] **P1.21 — Visual parity check — PDF figure vs Plotly figure**
-  - Files: `src/easydiffraction/report/templates/tex/figure.tex.j2`
-    (geometry fixes); read-only reference to the Plotly builder in
-    `src/easydiffraction/display/plotters/plotly.py`.
-  - The pgfplots PDF figure and the Plotly HTML figure must share the
-    **same geometry** even though fonts and exact line rendering differ.
-    This is a build-and-eyeball check on a real project (the `lbco_hrpt`
-    tutorial), **not** an automated pixel test — fonts differ, so pixel
-    diffing would false-fail. It is a Phase 1 step because it drives
-    geometry corrections to `figure.tex.j2`; it produces template
-    commits, not test files.
-  - Procedure (per representative experiment):
-    1. **Build the PDF figure.** Compile the standalone
-       `reports/tex/data/fit_<expt>.tex` to `fit_<expt>.pdf` (and/or the
-       full `reports/<project>.pdf`).
-    2. **Rasterize to PNG.** Any available rasteriser —
-       `pdftoppm -png -r 150 fit_<expt>.pdf out`,
-       `magick -density 150 fit_<expt>.pdf out.png`, or macOS
-       `sips -s format png fit_<expt>.pdf --out out.png`.
-    3. **Capture the Plotly reference.** Generate
-       `reports/<project>.html` (or the notebook figure) for the same
-       experiment and capture its chart as an image — open the HTML in a
-       browser and screenshot, or use a browser-automation tool.
-       Plotly→static image has **no** headless path here (`kaleido` was
-       dropped), so the reference comes from the rendered HTML /
-       notebook, not a Python export.
-    4. **Compare geometry side by side.** The two images must match on:
-       - overall figure aspect ratio / box dimensions;
-       - number of stacked panels and their **relative heights**
-         (intensity : Bragg : residual);
-       - **vertical spacing between panels** (no oversized or uneven
-         gaps);
-       - which panels carry x-axis ticks/labels (**only the bottom
-         panel**) and which carry a y-axis title (**each panel its own,
-         once** — no missing titles, no stray/overlapping titles across
-         panels);
-       - x-range (`xmin`/`xmax`) and per-panel y-range;
-       - legend position. Fonts, line antialiasing, and marker rendering
-         may differ — out of scope.
-  - **Known defects to fix in `figure.tex.j2`:** uneven/wrong
-    inter-panel spacing (`vertical sep` / per-panel `height`), and
-    spurious or overlapping y-axis titles on the short Bragg / residual
-    panels (tune each panel's `ylabel`, `ylabel style`, `yticklabel`
-    placement so labels don't collide — the demo symptom where "Bragg",
-    "lbco", and "Residual" overprinted). Re-run steps 1–4 until the
-    geometry matches the Plotly figure.
-  - Follow-up adjustment: derive pgfplots panel heights and vertical
-    spacing from the Plotly row-height constants. Use `scale only axis`
-    so the axes rectangles preserve Plotly's main/Bragg/residual ratios,
-    with total axis height matching the current Plotly chart aspect
-    ratio (about 70% of the axis width for the representative 856x600
-    HTML chart).
-  - Commit one geometry fix per logical change, e.g.
-    `Match pgfplots figure geometry to Plotly layout`.
-
-- [x] **P1.22 — Reach Phase 1 review gate**
-  - No-code step. Mark every `[ ]` above as `[x]`; commit the plan-file
-    update alone.
-  - Commit: `Reach Phase 1 review gate`.
-
-- [x] **P1.23 — Align report plot styling with Plotly output**
-  - Files: `src/easydiffraction/display/plotters/plotly.py`,
-    `src/easydiffraction/report/fit_plot.py`,
-    `src/easydiffraction/report/tex_renderer.py`,
-    `src/easydiffraction/report/templates/tex/figure.tex.j2`.
-  - HTML reports force report-only light styling after applying
-    `plotly_white`: legend background `rgba(255, 255, 255, 0.5)` and
-    light axis-frame colors are applied even when the figure object was
-    built under a dark notebook/system theme. Notebook rendering stays
-    theme-adaptive.
-  - The measured powder trace exposes reusable style constants: marker
-    size 6 px, marker outline 0 px, line width 2 px, error-bar thickness
-    2 px, and error-bar cap width 4 px for Plotly/HTML. The PDF
-    deliberately keeps the smaller accepted pgfplots measured marker
-    size (`0.75pt`) and does not draw measured error bars.
-  - PDF figures use Plotly-like inner grids: vertical grid lines on
-    major x ticks in all panels, horizontal grid lines in the intensity
-    and residual panels, no outside tick marks, and light Plotly-derived
-    axis/grid colors.
-  - PDF legends include measured, calculated, residual, and Bragg-peak
-    entries. Residual and Bragg peaks remain in their own panels even
-    though their legend entries live with the main legend, matching
-    Plotly where practical.
-  - Compile and visually inspect the standalone `fit_<expt_id>.pdf` plus
-    the full report PDF on the representative `lbco_hrpt` project. The
-    standalone figure should match the Plotly chart's 70%
-    height-to-width ratio and keep the same main/Bragg/residual panel
-    ratios and vertical spacing.
-  - Commit: `Align report plot styling with Plotly output`.
-
-- [x] **P1.24 — Disable draft line numbers and align numeric tables**
-  - Files: `src/easydiffraction/report/templates/tex/report.tex.j2`.
-  - Disable the `iucrjournals.cls` draft line numbering in generated
-    reports by emitting `\nolinenumbers` at the start of the document.
-    The vendored class still loads `lineno`, but reports should not show
-    line numbers by default.
-  - Add `siunitx` to the report template and use `S` columns for numeric
-    report tables: refinement, unit-cell numeric rows, atom-site
-    fractional coordinates / occupancies / isotropic ADPs, anisotropic
-    ADPs, and experiment temperature / pressure. Non-numeric rows in
-    mixed key-value tables are wrapped in `\multicolumn` cells so
-    `siunitx` does not parse text as a number.
-  - Parenthesized uncertainty notation such as `0.584(20)` is left
-    unwrapped in `S` cells; `siunitx` parses it as numeric uncertainty
-    notation and aligns on the decimal marker.
-  - Commit: `Align numeric report table columns`.
-
-- [x] **P1.25 — Restore accepted pgfplots line widths**
-  - Files: `src/easydiffraction/report/fit_plot.py`.
-  - Keep Plotly/HTML line-width settings unchanged, but use the earlier
-    accepted pgfplots widths for PDF figures: measured line `0.5pt`,
-    calculated line `0.75pt`, and residual line `0.5pt`.
-  - Commit: `Restore pgfplots report line widths`.
-
-- [x] **P1.26 — Render category-driven reports with aligned tables (ADR
-      §2)**
-  - Files: `docs/dev/adrs/accepted/project-summary-rendering.md`,
-    `src/easydiffraction/datablocks/experiment/categories/background/base.py`,
-    `src/easydiffraction/datablocks/experiment/categories/background/line_segment.py`,
-    `src/easydiffraction/datablocks/experiment/categories/calculator/default.py`,
-    `src/easydiffraction/datablocks/experiment/categories/data/bragg_pd.py`,
-    `src/easydiffraction/datablocks/experiment/categories/diffrn/default.py`,
-    `src/easydiffraction/datablocks/experiment/categories/experiment_type/default.py`,
-    `src/easydiffraction/datablocks/experiment/categories/instrument/cwl.py`,
-    `src/easydiffraction/datablocks/experiment/categories/instrument/tof.py`,
-    `src/easydiffraction/datablocks/experiment/categories/linked_crystal/default.py`,
-    `src/easydiffraction/datablocks/experiment/categories/linked_phases/default.py`,
-    `src/easydiffraction/datablocks/experiment/categories/peak/base.py`,
-    `src/easydiffraction/datablocks/experiment/categories/peak/cwl_mixins.py`,
-    `src/easydiffraction/datablocks/experiment/categories/refln/bragg_pd.py`,
-    `src/easydiffraction/datablocks/structure/categories/atom_sites/default.py`,
-    `src/easydiffraction/datablocks/structure/categories/cell/default.py`,
-    `src/easydiffraction/datablocks/structure/categories/space_group/default.py`,
-    `src/easydiffraction/display/plotters/base.py`,
-    `src/easydiffraction/report/data_context.py`,
-    `src/easydiffraction/report/templates/html/report.html.j2`,
-    `src/easydiffraction/report/templates/html/style.css`,
-    `src/easydiffraction/report/templates/tex/figure.tex.j2`,
-    `src/easydiffraction/report/templates/tex/report.tex.j2`,
-    `src/easydiffraction/report/tex_renderer.py`.
-  - **Category-driven report content.** Replace the last hand-written
-    structure and experiment summary tables with `ReportDataContext`
-    category traversal: every public structure category and every public
-    experiment category gets its own sub-subsection, item categories
-    render as two-column key-value tables, and collection loops render
-    as one-to-one loop tables. Experiment data categories (`pd_data`,
-    `total_data`, `refln`) stay out of the tabular report because they
-    are already represented by plots or are too large for summary
-    tables. The fit-quality chart remains the first experiment
-    sub-subsection.
-  - **Shared readable labels and units.** Add the missing
-    `DisplayHandler` names and units used by report tables so HTML and
-    TeX resolve the same domain labels (`H-M symbol`,
-    `$2\theta$ offset`, `Wavelength`, `Scale`, `$U_{\mathrm{iso}}$`,
-    etc.) rather than raw CIF field names where a better report label
-    exists. Normalise report angle units to `deg` and avoid
-    degree-symbol / `degree_squared` labels.
-  - **Normal-weight headings and headers.** Make HTML and TeX document
-    titles, section headings, subheadings, and table headers normal
-    weight. Table hierarchy comes from spacing, sizing, and rules
-    instead of bold headers.
-  - **Decimal-point-aligned numeric columns.** Keep TeX numeric columns
-    on `siunitx` `S` columns and add HTML-side numeric metadata (`left`,
-    decimal marker, `right`, and per-column widths) so `report.html.j2`
-    emits `number-left`, `number-dot`, and `number-right` spans with
-    tabular digits. This aligns values such as `0.584(20)` and
-    `3.89086937` on the decimal marker without changing the displayed
-    text.
-  - **Matching table layout.** HTML tables shrink to their content width
-    instead of filling the report page. HTML and TeX both use only top,
-    middle, and bottom rules with very light alternating body-row
-    backgrounds starting at the first body row.
-  - **Automatic HTML section numbering.** Add CSS counters so HTML
-    sections mirror the PDF numbering (`1`, `1.1`, `1.1.1`) while
-    keeping the document title and Abstract unnumbered.
-  - **PDF plot legend polish.** Explicitly set the measured marker fill
-    and draw color in the pgfplots legend so the legend marker matches
-    the plotted measured points.
-  - Commit: `Render category-driven reports with aligned tables`.
-
-- [x] **P1.27 — Harmonize report tables, colors, title, and fonts (ADR
-      §2)**
-  - Files: `docs/dev/adrs/accepted/project-summary-rendering.md`,
-    `docs/dev/plans/project-summary-rendering.md`,
-    `src/easydiffraction/display/plotters/plotly.py`,
-    `src/easydiffraction/report/data_context.py`,
-    `src/easydiffraction/report/fit_plot.py`,
-    `src/easydiffraction/report/html_renderer.py`,
-    `src/easydiffraction/report/style.py`,
-    `src/easydiffraction/report/templates/html/report.html.j2`,
-    `src/easydiffraction/report/templates/html/style.css`,
-    `src/easydiffraction/report/templates/tex/figure.tex.j2`,
-    `src/easydiffraction/report/templates/tex/report.tex.j2`,
-    `src/easydiffraction/report/tex_renderer.py`.
-  - Add report styling constants for the axis-frame color, table-inner
-    color, chart-grid color, row-fill color, subtitle, HTML font stack,
-    and TeX font choices. Feed those constants into HTML CSS, Plotly
-    report figure serialization, pgfplots figures, and TeX table styles.
-  - Render HTML and TeX tables with an outer frame and, for header
-    tables, one header rule. The outer frame and header rule use the
-    darker shared axis-frame color; filled rows use the shared row-fill
-    color. Tables do not draw separators between columns or between body
-    rows.
-  - Keep the HTML and TeX row striping consistent: the first body row is
-    filled for both header and key-value tables. Remove the extra TeX
-    spacing around the line below header rows by using framed tables
-    plus a single colored header rule instead of booktabs rules.
-  - Force key-value tables to occupy half of the text line. Classify
-    loop tables from their rendered content: compact loops occupy half
-    of the text line, and wider loops occupy the full text line. Add
-    `report_style` to the saved TeX report context so project saves can
-    render the configured font and color settings.
-  - Tighten HTML table line height to match the denser PDF table rhythm.
-  - Add terminal dots to generated section numbers in both HTML and TeX
-    (`1.`, `1.1.`, `1.1.1.`).
-  - Render the report title and project description left-aligned. Show
-    the project description as an unnumbered `Description` section, and
-    show `EasyDiffraction report` as a smaller subtitle under the main
-    title.
-  - Configure free report fonts centrally: HTML uses a non-embedded
-    local font stack headed by Nunito; TeX uses `fontspec` with Nunito
-    and Fira Math when available, otherwise leaving the engine's bundled
-    Latin Modern defaults in place so the generated PDF embeds the fonts
-    it actually uses.
-  - Commit: `Harmonize report table and title styling`.
-
-## Test plan (Phase 2)
-
-Per AGENTS.md §Testing, every new module, class, and bug fix ships with
-tests; unit tests mirror the source tree. Before running the
-verification commands below, add or update:
-
-- [ ] **`tests/unit/easydiffraction/report/test_enums.py`** (extend) —
-      `ReportStyleEnum` removed (calling `ReportStyleEnum('iucr')`
-      raises `AttributeError`); `ReportFormatEnum` membership unchanged.
-      P1.1 surface.
-- [ ] **`tests/unit/easydiffraction/project/categories/report/test_default.py`**
-      (extend) — no `style` descriptor field; `report.save_tex()` and
-      `report.save_pdf()` accept no `style=` kwarg (calling raises
-      `TypeError`); the five remaining descriptors round-trip through
-      `project.cif`. P1.1, P1.2 surface.
-- [ ] **`tests/unit/easydiffraction/test___main__.py`** (extend) —
-      standalone `save` and `save-report` commands are unknown; project-
-      first argument normalization does not treat them as saved-project
-      actions. P1.2 surface.
-- [ ] **`tests/unit/easydiffraction/core/test_display_handler.py`**
-      (new) — `DisplayHandler` is frozen, slotted; all four fields
-      default to `None`; constructor accepts kwargs; unspecified fields
-      stay `None`. P1.6 surface.
-- [ ] **`tests/unit/easydiffraction/core/test_descriptor_display.py`**
-      (new) — `Descriptor` with no `display_handler` returns `name` /
-      `units` from every `resolve_*` call; with a handler attached,
-      returns the right field per context (`'latex'` / `'html'` /
-      `'gui'`); missing handler fields fall back to plain `name` /
-      `units`. P1.7 surface.
-- [ ] **`tests/unit/easydiffraction/core/test_units_vocabulary.py`**
-      (new) — `VALID_UNITS_CODES` contains **every** code from the P1.8
-      inventory (11 dictionary codes + 8 project-internal codes —
-      exhaustive enumeration in the test body so the next contributor
-      adding a unit has a matching test row);
-      `validate_units_code('angstroms')` is a no-op;
-      `validate_units_code('Å')` raises `ValueError` citing the
-      offending code; the empty-string → `'none'` normalisation is
-      exercised. P1.9 surface.
-- [ ] **Descriptor-instantiation smoke** — every descriptor declared
-      under `src/easydiffraction/` constructs without raising at import
-      time. Run via `pytest --collect-only` (a collection failure on a
-      missing code is the desired signal) or a dedicated test importing
-      every category package. P1.10 surface — catches any missed
-      inventory entry from P1.8.
-- [ ] **`tests/unit/easydiffraction/project/categories/report/test_default.py`**
-      (further extend) — every `show_*()` method renders unit columns
-      using `display_units` rather than the raw `units=` ASCII code (a
-      snapshot containing `Ų` rather than `angstrom_squared`). P1.11
-      surface.
-- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
-      (extend) — `html_offline=False` emits the CDN MathJax script tag;
-      `html_offline=True` emits the relative vendored path and copies
-      `mathjax-tex-mml-chtml.js` next to the output `.html`. P1.12,
-      P1.13 surface.
-- [ ] **`tests/unit/easydiffraction/datablocks/experiment/categories/data/test_bragg_pd.py`**
-      and **`test_total_pd.py`** (extend) — data-category `x_descriptor`
-      resolves to the right descriptor per beam mode (CWL → `two_theta`,
-      TOF → `time_of_flight`, total → `r`). `fit_data_arrays()` returns
-      the documented dict shape including the `'x'` numpy array.
-      Single-crystal experiments have no data category in the current
-      tree (`src/easydiffraction/datablocks/experiment/categories/data/`
-      contains only `bragg_pd.py`, `total_pd.py`, `factory.py`,
-      `__init__.py`) — their `None` / `{}` semantics are covered in the
-      `ExperimentBase` bullet below, not here. P1.14 layer A.
-- [ ] **`tests/unit/easydiffraction/datablocks/experiment/item/test_base.py`**
-      (extend) — Layer B split is asserted against **real concrete
-      experiments**, not a mocked base:
-  - Construct concrete `CwlPdExperiment` / `TofPdExperiment` (or
-    whichever non-abstract powder classes the tree exposes) —
-    `x_descriptor` forwards to the data category and returns the
-    matching descriptor; `fit_data_arrays()` returns the populated dict.
-  - Construct concrete `CwlScExperiment` / `TofScExperiment` —
-    `x_descriptor is None` and `fit_data_arrays() == {}`. Asserting on
-    the concrete class catches the `self._data`-not-set pitfall flagged
-    in the review: a regression that naively moved the forwarding to
-    `ExperimentBase` would raise `AttributeError` on these instances,
-    not return `None`.
-  - No `AttributeError`, `NotImplementedError`, or any other exception
-    escapes either property under any of the four experiments above.
-    P1.14 layer B.
-- [ ] **`tests/unit/easydiffraction/report/test_data_context.py`**
-      (extend) — each experiment's `fit_data` carries the new `x`
-      sub-dict (six string keys + `values`) and `series` sub-dict
-      (`meas`, `calc`, `diff`, optional `bkg`); pre-rendered HTML keys
-      are absent; single-crystal experiments emit `fit_data: None`.
-      P1.15 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_tex_renderer.py`**
-      (extend) — `_write_fit_csv` writes the right schema
-      (`x, meas, calc, diff` + optional `meas_su`) with every row from
-      `fit_data`; each standalone `data/fit_<expt>.tex` contains
-      measured line+markers for all points, calculated line, residual
-      and Bragg legend entries, light inner grid settings, and no
-      band/fill-between, no background plot, no error-bar overlay, and
-      no sampled marker path; the preamble contains both
-      `\pgfplotsset{set layers}` and `mark layer=like plot`; the main
-      `report.tex` uses `\includegraphics{data/fit_<expt>.pdf}` and
-      contains **no** inline `\begin{axis}`. P1.16 + P1.23 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
-      (further extend) — Plotly figures appear in the rendered HTML and
-      are built from the `fit_data` payload rather than read from a
-      context key; the resulting HTML body contains a
-      `<div class="plotly-graph-div">` per experiment. P1.17 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
-      (further extend) — **HTML serialization parity, with the
-      report-only light override.** With `pio.templates.default` set to
-      `plotly_dark` (simulating notebook/system dark mode):
-  - **Report** serialization (`force_template='plotly_white'`) carries
-    `plotly_white`, not `plotly_dark`.
-  - **Notebook** serialization (`force_template=None`) keeps the
-    theme-adaptive template (here `plotly_dark`) — i.e. the shared
-    helper does **not** force light for the notebook path. This guards
-    the regression where forcing light leaks into the interactive path.
-  - Both paths emit a `config` matching `PlotlyPlotter._get_config()`
-    (`displaylogo:false`, the curated `modeBarButtonsToRemove` set)
-    **and** the legend- toggle behaviour from the shared `post_script` /
-    `_wrap_html_figure`, since both call the single serialization
-    helper. P1.18 surface.
-  - The report path also forces light legend background and light
-    axis-frame colors after applying `plotly_white`, preventing
-    dark-theme colors from leaking into report HTML. P1.23 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_pdf_compiler.py`**
-      (extend) — **N+1 build + engine fallback.** Each figure
-      `data/fit_<expt>.tex` is compiled **before** the main
-      `<project>.tex` (assert call ordering); figure and main compiles
-      use the **same discovered engine** (`_ENGINE_ORDER` fallback
-      `tectonic` → `latexmk` → `pdflatex`), not tectonic only; the
-      no-engine branch writes the `.tex` + CSV bundle and returns with
-      the install hint **without raising**; an engine non-zero exit
-      raises a clear error. P1.16 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
-      (further extend) — **HTML category tables and CSS polish
-      (P1.26).** Rendered fixtures include category-driven structure and
-      experiment tables, with experiment data categories skipped and the
-      fit-quality chart first in the experiment block. Numeric cells
-      render split into `<span class="number">` with `number-left`,
-      `number-dot`, and `number-right` children while preserving the
-      original `aria-label`; non-numeric cells stay plain. The emitted
-      CSS sets `h1`–`h4` and `th` to `font-weight: 400`, fits tables to
-      content width, stripes the first body row, and defines
-      section-numbering counters on `h2`/`h3`/`h4`; the title (`h1`) and
-      Abstract carry no counter. P1.26 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_tex_renderer.py`**
-      (further extend) — **TeX category tables and styling (P1.26).**
-      The main report renders structure and experiment categories as
-      separate sub-subsections, skips experiment data categories, uses
-      normal-weight titles/headings/table headers, applies the first-row
-      table striping commands, keeps numeric columns on `S` alignment,
-      emits readable labels/units, and sets the measured pgfplots legend
-      marker color explicitly. P1.26 surface.
-- [ ] **`tests/unit/easydiffraction/report/test_html_renderer.py`**
-      (further extend) — **shared report styling (P1.27).** Assert that
-      the HTML report injects shared axis/grid/row color CSS variables,
-      uses dotted section-number counters, renders a left-aligned
-      subtitle and unnumbered `Description` section, emits framed tables
-      without column or body-row separators, sets compact table
-      line-height, and applies content-driven half/full table width
-      classes.
-- [ ] **`tests/unit/easydiffraction/report/test_tex_renderer.py`**
-      (further extend) — **shared report styling (P1.27).** Assert that
-      the TeX report defines the shared axis/grid/row colors, uses
-      framed half-width and full-width tables without inner column
-      separators, emits a colored header rule instead of booktabs or
-      body-row rules, adds terminal dots to section numbers, renders the
-      custom left-aligned title/subtitle and `Description` section,
-      includes the configured font setup, and passes `report_style`
-      through saved TeX report rendering.
-- [ ] **Wheel-packaging verification** — run `pixi run dist-build` and
-      then
-      `unzip -l dist/*.whl | grep -E 'mathjax|iucrjournals.cls|harvard.sty'`
-      to confirm the wheel ships the two remaining TeX style files plus
-      the MathJax bundle. The 10 deleted REVTeX files must be absent
-      from the wheel. `dist/*.whl` is a verification artefact — do not
-      stage it. P1.3 + P1.11
-  - P1.12 surface.
-- [ ] **No-kaleido smoke** — after the dependency removal, importing
-      `easydiffraction.report` does not require `kaleido`;
-      `pixi run unit-tests` passes without the package present. P1.5
-      surface — covered automatically by the broader test sweep but call
-      it out.
-- [ ] **Integration / script-test coverage** — verify
-      `pixi run script-tests` exercises at least one tutorial that emits
-      `reports/<project>.html` with MathJax loaded and one tutorial that
-      emits the pgfplots `.tex` + `data/*.csv` bundle. Extend a tutorial
-      if not.
-
-Use `pixi run test-structure-check` to confirm the unit-test layout
-mirrors the source tree per AGENTS.md §Testing.
-
-## Verification commands (Phase 2)
-
-Per AGENTS.md §Workflow, save any required check output with the
-zsh-safe pattern. Variable names per-task:
-
-```sh
-pixi run fix > /tmp/easydiffraction-fix.log 2>&1; fix_exit_code=$?; tail -n 200 /tmp/easydiffraction-fix.log; exit $fix_exit_code
-pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
-pixi run test-structure-check > /tmp/easydiffraction-test-structure-check.log 2>&1; test_structure_check_exit_code=$?; tail -n 200 /tmp/easydiffraction-test-structure-check.log; exit $test_structure_check_exit_code
-pixi run unit-tests > /tmp/easydiffraction-unit-tests.log 2>&1; unit_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-unit-tests.log; exit $unit_tests_exit_code
-pixi run integration-tests > /tmp/easydiffraction-integration-tests.log 2>&1; integration_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-integration-tests.log; exit $integration_tests_exit_code
-pixi run script-tests > /tmp/easydiffraction-script-tests.log 2>&1; script_tests_exit_code=$?; tail -n 200 /tmp/easydiffraction-script-tests.log; exit $script_tests_exit_code
-```
-
-Run in order; each must complete clean before the next. Per AGENTS.md
-§Workflow: `pixi run fix` regenerates
-`docs/dev/package-structure/full.md` and `short.md` automatically. The
-new vendored MathJax bundle and the two remaining TeX style files are
-intentional sources — included in commits. The 10 deleted REVTeX files
-are removed from the worktree via `git rm` so the deletion appears in
-the diff. Benchmark CSVs under `docs/dev/benchmarking/` produced by
-`pixi run script-tests` are untracked verification artifacts; do not
-stage them.
-
-Docstring convention for propagated exceptions: document exceptions in a
-`Raises` section where the function body raises them directly. For
-public wrappers that call lower-level helpers which may raise, keep the
-wrapper lint-clean under pydoclint's direct-raise rule and mention the
-propagation in prose only when it materially helps users.
-
-## Suggested Pull Request
-
-**Title:**
-`[report] Single iucrjournals style + pgfplots + DisplayHandler`
-
-**Description:**
-
-Aligns the `project.report` rendering surface with the rewritten
-`project-summary-rendering` ADR. The visible changes for users:
-
-- **One LaTeX style — `iucrjournals`.** The `style=` argument is gone,
-  and CLI report generation now follows the report flags persisted in
-  `project.cif` during `fit`. Multi-style support (REVTeX, Elsevier, …)
-  is deferred to a follow-up ADR. The vendored TeX bundle shrinks from
-  12 files to 2 (`iucrjournals.cls` + `harvard.sty`, both CC0 1.0).
-- **No `kaleido`, no Chrome bootstrap.** Each fit-quality figure in the
-  PDF / TeX bundle is a standalone `pgfplots` document under
-  `reports/tex/data/`, compiled to PDF and included in the report —
-  vector throughout, no inline pgfplots in the main document. The TeX
-  engine (Tectonic / TeX Live / MiKTeX) handles the plotting; users no
-  longer need a system browser to generate a PDF report.
-- **Fit plots look consistent across HTML and PDF.** Report HTML always
-  uses the light Plotly report theme, while the PDF figure uses
-  Plotly-derived colors, line widths, marker sizes, grids, panel
-  proportions, and legend entries.
-- **Offline HTML is now actually offline.** When
-  `project.report.html_offline = True`, both Plotly and MathJax are
-  inline-bundled — the resulting `.html` opens with no network. The
-  vendored MathJax `tex-mml-chtml.js` (~1.5 MB, Apache-2.0) ships with
-  the wheel.
-- **Pretty units in tables, ASCII codes on the wire.** Descriptor
-  `units=` strings now follow the CIF DDLm `_units.code` vocabulary
-  verbatim (`angstrom_squared`, `degrees`, `kelvins`, `kilopascals`, …).
-  A new `DisplayHandler` value object carries the Unicode and LaTeX
-  label / unit forms (`Ų`, `°`, `$U_{\mathrm{iso}}$`) so every renderer
-  — terminal `show_*`, Jupyter HTML, PDF — shows the right form for its
-  context.
-
-Internally, the change pivots fit-data flow through a single
-descriptor-driven `fit_data` payload in `ReportDataContext`: one source
-of truth, two renderers (Plotly for HTML, pgfplots CSV for TeX), every
-experiment type (Bragg powder, TOF, total-scattering, future Q-space)
-without further ADR changes.
-
-**Scope label:** `[report]`. Builds on PR #184 (IUCr CIF alignment) and
-the earlier commits on this branch (`project.report` config category,
-`analysis.software`, `project.publication`, and CLI report saving via
-`fit`).
diff --git a/docs/dev/plans/structure-view-settings.md b/docs/dev/plans/structure-view-settings.md
deleted file mode 100644
index e5dde4cd7..000000000
--- a/docs/dev/plans/structure-view-settings.md
+++ /dev/null
@@ -1,396 +0,0 @@
-# Plan: Uniform value-selector discovery + structure-view settings split
-
-Follows [`AGENTS.md`](../../../AGENTS.md). It applies the standard
-two-phase workflow, with one deliberate exception — the implementation
-branch (see **Branch & PR** below). The slug `structure-view-settings`
-is retained for continuity (it began as the `project.style`
-consolidation), but the scope has broadened: Part A introduces a
-project-wide selector-discovery convention, and Part B reorganises the
-structure-view settings on top of it.
-
-> **Status (closed).** Phase 1 and Phase 2 are complete on the
-> `crysview-structure-visualization` branch. The
-> `value-selector-discovery` and `crysview-structure-visualization` ADRs
-> have both been promoted to accepted. This file is retained as the
-> implementation and verification record; no same-slug
-> `structure-view-settings` ADR is needed.
-
-**Branch & PR (deliberate exception).** §Planning asks for a flat-slug
-`structure-view-settings` branch off `develop`. This plan deliberately
-deviates: the work continues on the in-flight
-`crysview-structure-visualization` branch because it builds directly on
-the structure-view rendering commits already there (not yet on
-`develop`) and ships as part of the same crysview feature delivery. The
-PR still targets `develop`, not `master`. If the convention work is
-later split from the visualization PR, a dedicated
-`structure-view-settings` branch off `develop` is the fallback.
-
-## ADR
-
-This plan completed the ADR work that was added during planning. Its two
-architectural decisions intentionally live in existing accepted ADRs:
-there is no separate `structure-view-settings` ADR because the selector
-convention is project-wide and the settings split is part of the
-crysview public surface.
-
-- **Accepted ADR — `value-selector-discovery`**. Recognises a **fourth**
-  selector shape beyond the three category-level families in
-  [`selector-families.md`](../adrs/accepted/selector-families.md):
-  - **Category-level selectors** — the backend, switchable-category, and
-    active-sibling families. Each _is_ a category and owns
-    `<category>.type` + category-level `<category>.show_supported()` per
-    [`switchable-category-owned-selectors.md`](../adrs/accepted/switchable-category-owned-selectors.md).
-    **Unchanged by this plan.**
-  - **Value selectors** — enumerated descriptor _fields_ over a
-    project-owned static `(str, Enum)` (no class swap, no `_swap_<name>`
-    hook). They gain a descriptor-level `show_supported()` reusing the
-    **same** `render_table` and `*`-marks-current convention. This is
-    the new half.
-- **Update — crysview ADR**
-  ([`crysview-structure-visualization.md`](../adrs/accepted/crysview-structure-visualization.md)):
-  the structure-view surface becomes three categories; `_style.*` →
-  `_structure_style.*`; `show_labels`/`show_moments`/`range_*` move to
-  `_structure_view.*`; `_rendering_structure.*` reduces to `type`;
-  `atom_view`/`color_scheme` become value selectors with
-  `show_supported()`.
-
-## Motivation
-
-Two long-standing inconsistencies, fixed together because Part B depends
-on Part A:
-
-1. **Selector discovery is half-built.** Switchable categories expose
-   `show_supported()` (e.g. `rendering_plot.show_supported()`), but the
-   project-owned enum-backed _value_ selectors
-   (`experiment.experiment_type` axes, `verbosity`, the structure
-   `atom_view`/`color_scheme`, …) have **no** uniform way to list their
-   accepted values. Scientists must read source or trigger a validation
-   error to learn the options. (Fields with dynamic or external
-   membership — `atom_sites.type_symbol`, `space_group.name_h_m`, … —
-   are _not_ value selectors and are out of scope; see the ADR.)
-2. **Structure-view settings are split awkwardly.**
-   `project.rendering_structure` carries engine + content + region;
-   `project.style` (generic `_style.*`) carries appearance — but
-   `rendering_plot`/`rendering_table` are pure engine selectors. The
-   structure view should match that layering and isolate the appearance
-   settings that will keep growing (bonds, polyhedra, lighting, moment
-   scale).
-
-## Decisions
-
-- **`EnumDescriptor` (Part A).** A new `core/variable.py` descriptor
-  bound to a `(str, Enum)`. It derives `allowed` (the
-  `MembershipValidator`) and the default (`Enum.default()`) from the
-  enum, stores the enum class, and exposes `show_supported()` rendering
-  `render_table(['', 'Value', 'Description'])` with `*` on the current
-  value and descriptions from `Enum.description`. Replaces the manual
-  `StringDescriptor(... MembershipValidator(allowed=[m.value for m in E]))`
-  pattern for value selectors.
-- **Enums gain `.default()` and `.description` (Part A).** Every enum
-  behind a value selector must expose both; add them where missing.
-  Wording is concise, scientist-facing.
-- **Scope is project-owned static enum sets only.** A field migrates to
-  `EnumDescriptor` only when its allowed set is a project-owned, static
-  `(str, Enum)` closed set (`atom_view`, `color_scheme`, the
-  `experiment_type` axes, `verbosity`). Two buckets are out of scope and
-  unchanged: (a) category-level `.type` selectors — the backend,
-  switchable-category, and active-sibling families — keep their
-  category-level `show_supported()` per the selector-families and
-  switchable ADRs; (b) **dynamic / external / context-dependent**
-  membership validators — `atom_sites.type_symbol`,
-  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
-  `space_group.it_coordinate_system_code` — keep their current
-  `MembershipValidator` (a dynamic-choice discovery surface is deferred
-  per the ADR). The P1.2 audit sorts every field into one of these three
-  buckets.
-- **Numerics stay plain.** `adp_probability`, `atom_scale`, the
-  `range_*` scalars, and similar bounded numbers remain
-  `NumericDescriptor`s; their limits live in the docstring + validation
-  error, not in a `show_supported()` table (nothing to enumerate). This
-  resolves the earlier "list all vs enumerated only" question: selectors
-  list, scalars document.
-- **Three flat sibling categories (Part B).**
-  - `rendering_structure` — engine only: `type` (+ the live `viewer`
-    facade), `show_supported()` already lists engines. CIF:
-    `_rendering_structure.type`.
-  - `structure_view` — durable content/region: `show_labels`,
-    `show_moments`, and six flat `range_{a,b,c}_{min,max}` scalars. CIF:
-    `_structure_view.*`.
-  - `structure_style` — durable appearance: `atom_view`, `color_scheme`
-    (`EnumDescriptor`s), `adp_probability`, `atom_scale`. CIF:
-    `_structure_style.*`.
-- **Range stays six flat scalars.** API is `range_a_min … range_c_max`
-  (six setters), 1:1 with the six CIF tags, mirroring the six `_cell.*`
-  parameters. Keep the internal `view_range()` helper that assembles the
-  `((a_min,a_max),(b_min,b_max),(c_min,c_max))` tuple, and the per-call
-  `range=` override on `display.structure()` (per the crysview ADR). No
-  tuple-valued public setter.
-- **Per-descriptor discovery only.** `show_supported()` lives on the
-  value selector itself
-  (`structure_style.color_scheme.show_supported()`), never on the bundle
-  category. Switchable categories keep their category-level
-  `show_supported()` because the category _is_ a single selector; a
-  multi-setting bundle has no single "supported values", so a method
-  there would be ambiguous and redundant. An `experiment_type` overview
-  (its four axes shown together) may be added later as a clearly-named
-  convenience — deferred, not part of this change.
-- **No nesting, no deeper tree.** `color_scheme.show_supported()` is a
-  method on the descriptor the getter already returns — not a
-  sub-category. The category tree depth is unchanged.
-- **CIF renames (beta → no shim).** `_style.*` is dropped;
-  `_structure_view.*` and `_structure_style.*` are added;
-  `_rendering_structure.*` reduces to `type`. No backward-compatible
-  reader.
-- **Defaults preserved.** Keep current defaults during the move
-  (`adp_probability`, `atom_scale`, the show flags, range bounds, every
-  migrated selector's default).
-
-## Open questions
-
-None outstanding:
-
-- **Naming — resolved.** `structure_view` / `structure_style` (CIF
-  `_structure_view.*` / `_structure_style.*`), confirmed.
-- **Discovery surface — resolved.** Per-descriptor `show_supported()`
-  only; no category-level method on the non-switchable bundle categories
-  (see Decisions).
-- **Selector classification** is handled by the P1.2 audit (three
-  buckets: value selector / category-level selector / dynamic-external)
-  and recorded in this plan during implementation.
-
-## Concrete files likely to change
-
-**Part A — convention + project-wide migration**
-
-- `src/easydiffraction/core/variable.py` — add `EnumDescriptor`; reuse
-  `render_table` from `utils/utils.py`.
-- `src/easydiffraction/core/validation.py` — only if a small helper
-  eases deriving `allowed` from an enum.
-- Value-selector enums (add `.default()`/`.description` where missing):
-  `display/structure/enums.py` (`AtomViewEnum`, `ColorSchemeEnum`),
-  `datablocks/experiment/categories/experiment_type/*` (sample_form,
-  beam_mode, radiation_probe, scattering_type),
-  `project/categories/verbosity/*`, and any others the audit confirms as
-  project-owned closed sets. **Excluded** (dynamic or external
-  membership, unchanged): `atom_sites.type_symbol`,
-  `atom_sites.wyckoff_letter`, `space_group.name_h_m`,
-  `space_group.it_coordinate_system_code`.
-- The category files that declare those value selectors → switch the
-  field declarations to `EnumDescriptor` (one commit per area; see Phase
-  1).
-
-**Part B — structure-view three-way split**
-
-- `src/easydiffraction/project/categories/rendering_structure/default.py`
-  — remove `show_labels`/`show_moments`/`range_*`; keep `type` +
-  `viewer`.
-- `src/easydiffraction/project/categories/structure_view/` — **new**
-  package (`__init__.py`, `default.py`, `factory.py`): the moved
-  content/region settings
-  - `view_range()`.
-- `src/easydiffraction/project/categories/structure_style/` —
-  **renamed** from `style/`: `atom_view`/`color_scheme` as
-  `EnumDescriptor`, `adp_probability`/ `atom_scale` as
-  `NumericDescriptor`; CIF `_structure_style.*`.
-- `src/easydiffraction/project/categories/style/` — **removed**.
-- `src/easydiffraction/project/project.py`,
-  `src/easydiffraction/project/project_config.py` — add
-  `project.structure_view` / `project.structure_style`; drop
-  `project.style`.
-- `src/easydiffraction/io/cif/serialize.py` — swap the `style` block for
-  the `structure_view` + `structure_style` blocks; trim
-  `rendering_structure`.
-- `src/easydiffraction/display/structure/builder.py`,
-  `src/easydiffraction/project/display.py`,
-  `src/easydiffraction/report/html_renderer.py`,
-  `src/easydiffraction/report/tex_renderer.py` — repoint `style=` to
-  `project.structure_style` and read the view window/flags from
-  `project.structure_view`.
-
-**Docs / tutorials / tests**
-
-- `docs/docs/user-guide/analysis-workflow/model.md` (the
-  `project.style.*` examples); the crysview ADR; the new
-  `value-selector-discovery` ADR.
-- `docs/docs/tutorials/ed-3.py`, `ed-14.py`, `ed-17.py` (any
-  `project.style.*`), then `pixi run notebook-prepare`.
-- Tests mirroring every changed module: `EnumDescriptor` +
-  `show_supported`, each migrated category, new
-  `structure_view`/`structure_style`, removed `style`; repoint
-  `tests/.../project/test_project_config.py`, `test_project_load.py`,
-  `display/plotters/test_plotly.py`. Verify the mirror with
-  `pixi run test-structure-check`.
-
-## Implementation steps (Phase 1)
-
-Each step is one atomic commit (stage explicit paths; commit before the
-next) per §Commits. When an AI agent follows this plan, every completed
-Phase 1 step is staged and committed locally before moving on.
-
-**Part A — value-selector discovery convention**
-
-- [x] **P1.1 — Add `EnumDescriptor`.** Implement in `core/variable.py`
-      with the `show_supported()` table (reuse `render_table`). Commit:
-      `Add EnumDescriptor with show_supported listing`.
-- [x] **P1.2 — Classify selectors.** Audit every `MembershipValidator`
-      usage; record a three-bucket table in this plan (value selector /
-      category-level selector / dynamic-external), doc-only. See
-      _Selector classification_ below. Commit:
-      `Classify enumerated selectors for discovery`.
-- [x] **P1.3 — Enum metadata.** Add `.default()`/`.description()` to the
-      in-scope value-selector enums that lack them (no field migration
-      yet). Commit:
-      `Add default and description to value-selector enums`. _(Only
-      `VerbosityEnum`, `FitResultKindEnum`, `FitCorrelationSourceEnum`
-      lacked `description()`; the rest already had both.)_
-- [x] **P1.4 — Migrate experiment_type axes.** `sample_form`,
-      `beam_mode`, `radiation_probe`, `scattering_type` →
-      `EnumDescriptor`. Commit:
-      `Use EnumDescriptor for experiment_type axes`.
-- [x] **P1.5 — Migrate `atom_sites.adp_type`.** The P1.2 audit confirms
-      `adp_type` (`AdpTypeEnum`) is the one in-scope structure-data
-      value selector → `EnumDescriptor` (preserve its dual CIF names
-      `_atom_site.ADP_type` / `_atom_site.adp_type` and the category's
-      `adp_type` setter). The dynamic/external validators
-      (`atom_sites.type_symbol`, `atom_sites.wyckoff_letter`,
-      `space_group.name_h_m`, `space_group.it_coordinate_system_code`)
-      are **out of scope** and keep their current `MembershipValidator`.
-      Commit: `Use EnumDescriptor for atom_sites adp_type`.
-- [x] **P1.6 — Migrate remaining value selectors.** Per the P1.2 audit:
-      `verbosity.fit` (`VerbosityEnum`), `fit_result.result_kind`
-      (`FitResultKindEnum`), `fit_parameter_correlations.source_kind`
-      (`FitCorrelationSourceEnum`), and `extinction.model`
-      (`ExtinctionModelEnum`) → `EnumDescriptor`, one commit per area.
-      Commit (per area): `Use EnumDescriptor for <area> selector`.
-
-**Part B — structure-view three-way split.** Ordered additive-first: the
-new categories and their consumers land before the old surfaces are
-removed, so **every commit imports and renders** — no intermediate
-revision loses a live API. A short bridge period where old and new
-surfaces coexist is intentional.
-
-- [x] **P1.7 — Add `structure_view` (additive).** New category +
-      `project.structure_view` + a new `_structure_view.*` CIF block
-      carrying `show_labels`, `show_moments`, six `range_*` scalars, and
-      `view_range()`. `rendering_structure` keeps its copies for now.
-      Commit: `Add structure_view content/region category`.
-- [x] **P1.8 — Add `structure_style` (additive).** New category +
-      `project.structure_style` + a new `_structure_style.*` CIF block;
-      `atom_view`/`color_scheme` as `EnumDescriptor`,
-      `adp_probability`/`atom_scale` as `NumericDescriptor`. The old
-      `style` category / `project.style` stay for now. Commit:
-      `Add structure_style appearance category`.
-- [x] **P1.9 — Repoint consumers to the new categories.** Builder,
-      display facade, and report renderers read appearance from
-      `project.structure_style` and the window/flags from
-      `project.structure_view` (`builder.py`, `display.py`,
-      `html_renderer.py`, `tex_renderer.py`). After this commit nothing
-      reads `project.style` or `rendering_structure.view_range()`, but
-      both still exist — so the revision builds and renders. Commit:
-      `Read structure view and style from new categories`.
-- [x] **P1.10 — Remove the old surfaces.** Now that no consumer uses
-      them: remove `show_labels`/`show_moments`/`range_*`/`view_range()`
-      from `rendering_structure` (leaving engine `type` + `viewer`);
-      remove the `style` package, `project.style`, and the bespoke
-      `Style.show_supported()`; drop the `_style.*` block and the moved
-      `_rendering_structure.*` tags from CIF serialise. Commit:
-      `Remove the old style and rendering_structure surfaces`.
-- [x] **P1.11 — Docs, ADRs, tutorials.** `model.md` (commit
-      `e24a42571`), crysview ADR §8 surface note + final CIF tags
-      (commit `44abff413`), `value-selector-discovery` ADR already
-      current. Tutorials `ed-3/14/17.py` migrated to
-      `project.structure_style.*` (per-descriptor `show_supported()`)
-      and notebooks regenerated via `pixi run notebook-prepare`,
-      committed in `6fb2df3c7` (user approved committing their
-      playground edits alongside).
-- [x] **P1.12 — Phase 1 review gate.** No-code step: mark complete and
-      commit the checklist update alone. (Reopened once by
-      `_impl-review-1` [P1]; re-gated after the tutorial migration
-      landed in `6fb2df3c7`.) Commit: `Reach Phase 1 review gate`.
-
-### Selector classification (P1.2 audit)
-
-Every `MembershipValidator` site, sorted into the three buckets from the
-`value-selector-discovery` ADR, plus a fourth not-yet-enum-backed group.
-
-**Migrate to `EnumDescriptor` (project-owned static `(str, Enum)`):**
-
-| Field                                    | Enum                       | Step | Note                            |
-| ---------------------------------------- | -------------------------- | ---- | ------------------------------- |
-| `experiment_type.sample_form`            | `SampleFormEnum`           | P1.4 | has `display_handler`           |
-| `experiment_type.beam_mode`              | `BeamModeEnum`             | P1.4 | has `display_handler`           |
-| `experiment_type.radiation_probe`        | `RadiationProbeEnum`       | P1.4 | has `display_handler`           |
-| `experiment_type.scattering_type`        | `ScatteringTypeEnum`       | P1.4 | has `display_handler`           |
-| `atom_sites.adp_type`                    | `AdpTypeEnum`              | P1.5 | dual CIF names; category setter |
-| `verbosity.fit`                          | `VerbosityEnum`            | P1.6 |                                 |
-| `fit_result.result_kind`                 | `FitResultKindEnum`        | P1.6 |                                 |
-| `fit_parameter_correlations.source_kind` | `FitCorrelationSourceEnum` | P1.6 |                                 |
-| `extinction.model`                       | `ExtinctionModelEnum`      | P1.6 |                                 |
-| `style.atom_view`                        | `AtomViewEnum`             | P1.8 | already has metadata            |
-| `style.color_scheme`                     | `ColorSchemeEnum`          | P1.8 | already has metadata            |
-
-**Category-level `.type` selectors — unchanged** (backend /
-switchable-category / active-sibling families): `rendering_plot`,
-`rendering_table`, `rendering_structure`, `minimizer`, `background`,
-`peak`, `calculator`, `extinction`, `fitting_mode`.
-
-**Dynamic / external / context-dependent — unchanged:**
-`atom_sites.type_symbol` (isotope database), `atom_sites.wyckoff_letter`
-(space-group dependent), `space_group.name_h_m` /
-`space_group.it_coordinate_system_code` (callable, H-M-derived),
-minimizer `initialization_method` (per-class enum **subset**, not the
-full set).
-
-**Bucket 4 — closed but not `(str, Enum)`, out of scope** (candidates
-for a future enum-ification per `enum-backed-closed-values`, tracked
-separately): `data.calc_status` (`['incl', 'excl']`),
-`emcee.proposal_moves` (raw tuple).
-
-## Phase 2 — Verification
-
-This Phase 2 also discharges the crysview feature's originally planned
-unit tests (the
-[`crysview-structure-visualization`](crysview-structure-visualization.md)
-plan's original Phase 2 checklist was superseded), written **once**
-against the final post-split API:
-
-- **This plan's surfaces:** `EnumDescriptor` + per-selector
-  `show_supported()`; each migrated value selector; the new
-  `structure_view` / `structure_style` categories; removal of `style`;
-  the slimmed `rendering_structure`.
-- **Crysview surfaces still untested:** `display/structure/` —
-  `test_enums.py`, `test_scene.py`, `test_builder.py`,
-  `renderers/test_ascii.py`, `renderers/test_raster.py`,
-  `renderers/test_threejs.py`, `test_viewing.py`; the crystallography
-  geometry helpers; the element-radii asset;
-  `report/test_html_renderer.py` (structure figure); and the structure
-  surfaces of `project/test_display.py`.
-
-Mirror the source tree per §Testing (verify with
-`pixi run test-structure-check`), then run, capturing logs with the
-zsh-safe pattern:
-
-```sh
-pixi run fix
-pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
-pixi run test-structure-check
-pixi run unit-tests > /tmp/easydiffraction-unit.log 2>&1; unit_tests_exit_code=$?; tail -n 100 /tmp/easydiffraction-unit.log; exit $unit_tests_exit_code
-pixi run integration-tests > /tmp/easydiffraction-integration.log 2>&1; integration_tests_exit_code=$?; tail -n 100 /tmp/easydiffraction-integration.log; exit $integration_tests_exit_code
-pixi run script-tests > /tmp/easydiffraction-script.log 2>&1; script_tests_exit_code=$?; tail -n 100 /tmp/easydiffraction-script.log; exit $script_tests_exit_code
-```
-
-## Suggested Pull Request
-
-**Title:** Make every option list discoverable, and tidy structure-view
-settings
-
-**Description:** Any setting that takes one of a fixed list of values —
-the experiment type, atom depiction, colour scheme, verbosity, and more
-— can now show its options the same way, with the active one marked, via
-`show_supported()`. Separately, the structure-view settings are
-reorganised to match the rest of the project:
-`project.rendering_structure` now just selects the engine,
-`project.structure_view` holds what and where to draw, and
-`project.structure_style` holds how it looks. Structure-view settings
-saved by older versions (the `_style.*` block) need re-applying (beta:
-no automatic migration).

From d6c6408cba3d24f72be5d3562098c2b2907dbff3 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 10:26:11 +0200
Subject: [PATCH 138/160] Add responsive resizing for Plotly plots

---
 docs/docs/tutorials/ed-13.ipynb               |  2 +-
 docs/docs/tutorials/ed-5.ipynb                |  2 -
 docs/docs/tutorials/ed-6.ipynb                |  2 -
 docs/docs/tutorials/ed-8.ipynb                |  2 -
 .../display/plotters/plotly.py                | 56 ++++++++++++++++++-
 .../display/plotters/test_plotly.py           |  5 ++
 6 files changed, 61 insertions(+), 8 deletions(-)

diff --git a/docs/docs/tutorials/ed-13.ipynb b/docs/docs/tutorials/ed-13.ipynb
index bd3e2ba96..db36a147e 100644
--- a/docs/docs/tutorials/ed-13.ipynb
+++ b/docs/docs/tutorials/ed-13.ipynb
@@ -2690,7 +2690,7 @@
  ],
  "metadata": {
   "jupytext": {
-   "cell_metadata_filter": "title,tags,-all",
+   "cell_metadata_filter": "tags,title,-all",
    "main_language": "python",
    "notebook_metadata_filter": "-all"
   }
diff --git a/docs/docs/tutorials/ed-5.ipynb b/docs/docs/tutorials/ed-5.ipynb
index c60cf0cd0..930d73d9a 100644
--- a/docs/docs/tutorials/ed-5.ipynb
+++ b/docs/docs/tutorials/ed-5.ipynb
@@ -658,8 +658,6 @@
    "source": [
     "## Report\n",
     "\n",
-    "This final section shows how to review the results of the analysis.\n",
-    "\n",
     "The HTML report is written automatically when the project is saved;\n",
     "enable `project.report.pdf` as well for a PDF version."
    ]
diff --git a/docs/docs/tutorials/ed-6.ipynb b/docs/docs/tutorials/ed-6.ipynb
index a83b47313..62780be9b 100644
--- a/docs/docs/tutorials/ed-6.ipynb
+++ b/docs/docs/tutorials/ed-6.ipynb
@@ -832,8 +832,6 @@
    "source": [
     "## Report\n",
     "\n",
-    "This final section shows how to review the results of the analysis.\n",
-    "\n",
     "The HTML report is written automatically when the project is saved;\n",
     "enable `project.report.pdf` as well for a PDF version."
    ]
diff --git a/docs/docs/tutorials/ed-8.ipynb b/docs/docs/tutorials/ed-8.ipynb
index b27530631..f61c4ea9a 100644
--- a/docs/docs/tutorials/ed-8.ipynb
+++ b/docs/docs/tutorials/ed-8.ipynb
@@ -716,8 +716,6 @@
    "source": [
     "## Report\n",
     "\n",
-    "This final section shows how to review the results of the analysis.\n",
-    "\n",
     "The HTML report is written automatically when the project is saved;\n",
     "enable `project.report.pdf` as well for a PDF version."
    ]
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 7055651bc..5aeccf554 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -760,6 +760,7 @@ def _get_config() -> dict:
         return {
             'displayModeBar': True,
             'displaylogo': False,
+            'responsive': True,
             'modeBarButtonsToRemove': [
                 'select2d',
                 'lasso2d',
@@ -1181,10 +1182,63 @@ def _theme_sync_post_script() -> str:
             .replace('__LIGHT_LEGEND_BACKGROUND_COLOR__', LIGHT_LEGEND_BACKGROUND_COLOR)
         )
 
+    @staticmethod
+    def _resize_sync_post_script() -> str:
+        """
+        Return client-side code to resize hidden-tab Plotly outputs.
+        """
+        return r"""
+const graphDiv = document.getElementById('{plot_id}');
+if (!graphDiv || !window.Plotly || !window.Plotly.Plots) {
+    return;
+}
+
+let pendingResize = false;
+const resizePlot = function () {
+    if (pendingResize) {
+        return;
+    }
+    pendingResize = true;
+    window.requestAnimationFrame(function () {
+        pendingResize = false;
+        if (!graphDiv.isConnected || graphDiv.offsetParent === null) {
+            return;
+        }
+        window.Plotly.Plots.resize(graphDiv);
+    });
+};
+
+const scheduleResize = function () {
+    resizePlot();
+    window.setTimeout(resizePlot, 50);
+    window.setTimeout(resizePlot, 250);
+};
+
+if (window.ResizeObserver) {
+    const resizeObserver = new ResizeObserver(scheduleResize);
+    resizeObserver.observe(graphDiv);
+    if (graphDiv.parentElement) {
+        resizeObserver.observe(graphDiv.parentElement);
+    }
+}
+
+document.addEventListener('visibilitychange', function () {
+    if (!document.hidden) {
+        scheduleResize();
+    }
+});
+window.addEventListener('focus', scheduleResize);
+window.addEventListener('pageshow', scheduleResize);
+scheduleResize();
+"""
+
     @classmethod
     def _html_post_script(cls, fig: object) -> str | None:
         """Return concatenated HTML post scripts for a Plotly figure."""
-        scripts: list[str] = [cls._theme_sync_post_script()]
+        scripts: list[str] = [
+            cls._theme_sync_post_script(),
+            cls._resize_sync_post_script(),
+        ]
         if cls._has_visible_legend(fig):
             scripts.append(cls._modebar_legend_toggle_post_script())
         return '\n'.join(cls._scoped_html_post_script(script) for script in scripts)
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index c25b86522..0c549b6f0 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -196,6 +196,7 @@ def __init__(self, html):
     assert captured.get('show_called') is not True
     assert captured['config']['displayModeBar'] is True
     assert captured['config']['displaylogo'] is False
+    assert captured['config']['responsive'] is True
     assert 'data-jp-theme-light' in captured['post_script']
     assert 'data-md-color-scheme' in captured['post_script']
     assert 'graphDiv.dataset.edPlotlyTheme' in captured['post_script']
@@ -212,6 +213,10 @@ def __init__(self, html):
     assert '--ed-plotly-modebar-icon-color' in captured['post_script']
     assert '--ed-plotly-modebar-icon-hover-opacity' in captured['post_script']
     assert 'window.Plotly.relayout(graphDiv, update)' in captured['post_script']
+    assert 'window.Plotly.Plots.resize(graphDiv)' in captured['post_script']
+    assert "document.addEventListener('visibilitychange'" in captured['post_script']
+    assert "window.addEventListener('focus', scheduleResize);" in captured['post_script']
+    assert 'new ResizeObserver(scheduleResize)' in captured['post_script']
     assert 'data-legend-toggle="true"' in captured['post_script']
     assert 'Toggle legend' in captured['post_script']
     assert 'graphDiv.dataset.legendVisible' in captured['post_script']

From 89cb84c07dcd08b07a985f4e34da8bf5a9058663 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 10:26:38 +0200
Subject: [PATCH 139/160] Remove unused reason column and standardize titles

---
 src/easydiffraction/display/plotters/ascii.py | 28 +++++++++++-------
 src/easydiffraction/display/plotting.py       |  6 ++--
 src/easydiffraction/project/display.py        | 19 ++----------
 src/easydiffraction/report/html_renderer.py   | 23 ++++-----------
 src/easydiffraction/utils/logging.py          |  4 ++-
 .../display/plotters/test_ascii.py            | 17 +++++++++++
 .../easydiffraction/display/test_plotting.py  | 14 ++++++++-
 .../easydiffraction/project/test_display.py   | 29 +++++++++++++++++++
 .../report/test_html_renderer.py              |  1 +
 9 files changed, 92 insertions(+), 49 deletions(-)

diff --git a/src/easydiffraction/display/plotters/ascii.py b/src/easydiffraction/display/plotters/ascii.py
index 625b2e2fd..f3ee3533a 100644
--- a/src/easydiffraction/display/plotters/ascii.py
+++ b/src/easydiffraction/display/plotters/ascii.py
@@ -14,11 +14,13 @@
 
 import asciichartpy
 import numpy as np
+from rich.text import Text
 
 from easydiffraction.display.plotters.base import DEFAULT_HEIGHT
 from easydiffraction.display.plotters.base import SERIES_CONFIG
 from easydiffraction.display.plotters.base import PlotterBase
 from easydiffraction.display.plotters.base import PowderMeasVsCalcSpec
+from easydiffraction.utils.logging import CONSOLE_PARAGRAPH_STYLE
 from easydiffraction.utils.logging import console
 
 DEFAULT_COLORS = {
@@ -33,6 +35,7 @@
 ASCII_CHART_FALLBACK_POINT_COUNT = 80
 ASCII_CHART_MIN_POINT_COUNT = 2
 ASCII_CHART_CROP_TRIGGER_MULTIPLIER = 2
+SINGLE_CRYSTAL_SCATTER_SYMBOL = '●'
 
 
 class AsciiPlotter(PlotterBase):
@@ -130,6 +133,17 @@ def _get_legend_item(label: str) -> str:
         name = SERIES_CONFIG[label]['name']
         return f'{color_start}{line}{color_end} {name}'
 
+    @staticmethod
+    def _single_crystal_grid_line(row: list[str]) -> Text:
+        """Return one scatter grid line with styled data markers."""
+        line = Text('  │')
+        for cell in row:
+            if cell == SINGLE_CRYSTAL_SCATTER_SYMBOL:
+                line.append(cell, style=CONSOLE_PARAGRAPH_STYLE)
+            else:
+                line.append(cell)
+        return line
+
     def plot_powder(
         self,
         x: object,
@@ -286,13 +300,7 @@ def plot_single_crystal(
             col = int((xv - vmin) / (vmax - vmin) * (width - 1))
             row = height - 1 - int((yv - vmin) / (vmax - vmin) * (height - 1))
             if 0 <= row < height and 0 <= col < width:
-                grid[row][col] = '●'
-
-        # Build chart string with axes
-        chart_lines = []
-        for row in grid:
-            label = '│'
-            chart_lines.append(label + ''.join(row))
+                grid[row][col] = SINGLE_CRYSTAL_SCATTER_SYMBOL
 
         # X-axis
         x_axis = '└' + '─' * width
@@ -300,9 +308,9 @@ def plot_single_crystal(
         # Print output
         console.paragraph(f'{title}')
         console.print(f'{axes_labels[1]}')
-        for line in chart_lines:
-            print(f'  {line}')
-        print(f'  {x_axis}')
+        for row in grid:
+            console.print(self._single_crystal_grid_line(row))
+        console.print(f'  {x_axis}')
         console.print(f'{" " * (width - 3)}{axes_labels[0]}')
 
     def plot_scatter(
diff --git a/src/easydiffraction/display/plotting.py b/src/easydiffraction/display/plotting.py
index 65c4d7bb7..f52cc3177 100644
--- a/src/easydiffraction/display/plotting.py
+++ b/src/easydiffraction/display/plotting.py
@@ -5258,7 +5258,7 @@ def _plot_meas_data(
             y_series=[y_meas],
             labels=['meas'],
             axes_labels=ctx['axes_labels'],
-            title=f"Measured data for experiment 🔬 '{expt_name}'",
+            title=f"Diffraction pattern for experiment 🔬 '{expt_name}'",
             height=self.height,
             excluded_ranges=excluded_ranges,
         )
@@ -5320,7 +5320,7 @@ def _plot_calc_data(
             y_series=[y_calc],
             labels=['calc'],
             axes_labels=ctx['axes_labels'],
-            title=f"Calculated data for experiment 🔬 '{expt_name}'",
+            title=f"Diffraction pattern for experiment 🔬 '{expt_name}'",
             height=self.height,
             excluded_ranges=excluded_ranges,
         )
@@ -5418,7 +5418,7 @@ def _plot_meas_vs_calc_data(
             log.error(f'No calculated data available for experiment {expt_name}')
             return
 
-        title = f"Measured vs Calculated data for experiment 🔬 '{expt_name}'"
+        title = f"Diffraction pattern for experiment 🔬 '{expt_name}'"
 
         # Single crystal scatter plot (I²calc vs I²meas)
         if x_axis in {XAxisType.INTENSITY_CALC, 'intensity_calc'}:
diff --git a/src/easydiffraction/project/display.py b/src/easydiffraction/project/display.py
index 238cb8e3e..3c07970fb 100644
--- a/src/easydiffraction/project/display.py
+++ b/src/easydiffraction/project/display.py
@@ -537,7 +537,7 @@ def structure(
 
     def show_structure_options(self, struct_name: str) -> None:
         """
-        Show available ``structure(include=...)`` options with reasons.
+        Show available ``structure(include=...)`` options.
         """
         from easydiffraction.display.structure.builder import (  # noqa: PLC0415
             structure_feature_availability,
@@ -555,17 +555,15 @@ def show_structure_options(self, struct_name: str) -> None:
         for option in ('atoms', 'bonds', 'cell', 'axes', 'moments', 'labels'):
             in_data = option in availability.available
             in_engine = option in supported
-            reason = self._structure_option_reason(option, in_data=in_data, in_engine=in_engine)
             rows.append([
                 option,
                 _STRUCTURE_OPTION_DESCRIPTIONS[option],
                 'yes' if (in_data and in_engine) else 'no',
                 'yes' if (option in auto and in_engine) else 'no',
-                reason or '-',
             ])
         render_table(
-            columns_headers=['Option', 'Description', 'Available', 'Auto', 'Reason'],
-            columns_alignment=['left', 'left', 'center', 'center', 'left'],
+            columns_headers=['Option', 'Description', 'Available', 'Auto'],
+            columns_alignment=['left', 'left', 'center', 'center'],
             columns_data=rows,
         )
         if availability.radius_substitutions:
@@ -608,17 +606,6 @@ def _normalize_structure_include(include: str | tuple[str, ...]) -> tuple[str, .
             raise ValueError(msg)
         return normalized
 
-    @staticmethod
-    def _structure_option_reason(option: str, *, in_data: bool, in_engine: bool) -> str:
-        """Explain why a structure option is unavailable, if it is."""
-        if not in_engine:
-            return 'Shown only by the 3D engines.'
-        if not in_data:
-            if option == 'moments':
-                return 'No moment data in version 1.'
-            return 'No data for this structure.'
-        return ''
-
     def _emit_structure_output(self, output: str) -> None:
         """Display ASCII text in the console or HTML in a notebook."""
         from easydiffraction.display.structure.enums import ViewerEngineEnum  # noqa: PLC0415
diff --git a/src/easydiffraction/report/html_renderer.py b/src/easydiffraction/report/html_renderer.py
index 0d59909cf..b7080b49c 100644
--- a/src/easydiffraction/report/html_renderer.py
+++ b/src/easydiffraction/report/html_renderer.py
@@ -182,7 +182,7 @@ def _fit_figure_html_context(
         if fit_data is None:
             continue
         experiment_id = str(experiment.get('id') or 'experiment')
-        figure = _fit_data_figure(experiment_id, fit_data, experiment)
+        figure = _fit_data_figure(experiment_id, fit_data)
         rendered[experiment_id] = _figure_html(
             figure,
             include_plotlyjs=include_plotlyjs,
@@ -232,7 +232,6 @@ def _structure_figure_html_context(
 def _fit_data_figure(
     experiment_id: str,
     fit_data: dict[str, object],
-    experiment: dict[str, object],
 ) -> object:
     """Build a Plotly fit figure from one fit-data payload."""
     x_data = fit_data['x']
@@ -274,7 +273,7 @@ def _fit_data_figure(
             y_resid=np.asarray(y_diff, dtype=float),
             bragg_tick_sets=tuple(fit_data.get('bragg_tick_sets') or ()),
             axes_labels=list(fit_data.get('axes_labels') or [_axis_title(x_data), 'Intensity']),
-            title=_fit_figure_title(experiment_id, experiment),
+            title=_fit_figure_title(experiment_id),
             residual_height_fraction=DEFAULT_RESID_HEIGHT,
             bragg_peaks_height_fraction=DEFAULT_BRAGG_ROW,
             y_bkg=np.asarray(y_bkg, dtype=float) if y_bkg is not None else None,
@@ -303,25 +302,13 @@ def _single_crystal_fit_data_figure(
         y_meas=y_meas_array,
         y_meas_su=y_meas_su_array,
         axes_labels=list(fit_data.get('axes_labels') or ['I²calc', 'I²meas']),
-        title=f"Measured vs Calculated data for experiment 🔬 '{experiment_id}'",
+        title=_fit_figure_title(experiment_id),
     )
 
 
-def _fit_figure_title(experiment_id: str, experiment: dict[str, object]) -> str:
+def _fit_figure_title(experiment_id: str) -> str:
     """Return a report title matching the direct plotting API."""
-    experiment_type = experiment.get('type')
-    if _is_powder_bragg_context(experiment_type):
-        return f"Measured vs Calculated data for experiment 🔬 '{experiment_id}'"
-    return f'Measured vs calculated: {experiment_id}'
-
-
-def _is_powder_bragg_context(experiment_type: object) -> bool:
-    if not isinstance(experiment_type, dict):
-        return False
-    return (
-        experiment_type.get('sample_form') == 'powder'
-        and experiment_type.get('scattering_type') == 'bragg'
-    )
+    return f"Diffraction pattern for experiment 🔬 '{experiment_id}'"
 
 
 def _figure_html(
diff --git a/src/easydiffraction/utils/logging.py b/src/easydiffraction/utils/logging.py
index a185205fb..1f6e4ddb8 100644
--- a/src/easydiffraction/utils/logging.py
+++ b/src/easydiffraction/utils/logging.py
@@ -41,6 +41,8 @@
 from easydiffraction.utils.environment import in_pytest
 from easydiffraction.utils.environment import in_warp
 
+CONSOLE_PARAGRAPH_STYLE = 'bold deep_sky_blue3'
+
 # ======================================================================
 # HANDLERS
 # ======================================================================
@@ -721,7 +723,7 @@ def paragraph(cls, title: str) -> None:
             if part.startswith("'") and part.endswith("'"):
                 text.append(part)
             else:
-                text.append(part, style='bold deep_sky_blue3')
+                text.append(part, style=CONSOLE_PARAGRAPH_STYLE)
         formatted = f'{text.markup}'
         if not in_jupyter():
             formatted = f'\n{formatted}'
diff --git a/tests/unit/easydiffraction/display/plotters/test_ascii.py b/tests/unit/easydiffraction/display/plotters/test_ascii.py
index 809cbc772..16dea0113 100644
--- a/tests/unit/easydiffraction/display/plotters/test_ascii.py
+++ b/tests/unit/easydiffraction/display/plotters/test_ascii.py
@@ -98,6 +98,23 @@ def test_ascii_plotter_plot_single_crystal(capsys):
     assert '·' in out
 
 
+def test_ascii_plotter_single_crystal_marker_uses_paragraph_style():
+    from easydiffraction.display.plotters.ascii import AsciiPlotter
+    from easydiffraction.display.plotters.ascii import SINGLE_CRYSTAL_SCATTER_SYMBOL
+    from easydiffraction.utils.logging import CONSOLE_PARAGRAPH_STYLE
+
+    line = AsciiPlotter._single_crystal_grid_line([
+        ' ',
+        SINGLE_CRYSTAL_SCATTER_SYMBOL,
+        '·',
+    ])
+
+    marker_start = line.plain.index(SINGLE_CRYSTAL_SCATTER_SYMBOL)
+    assert line.spans[0].start == marker_start
+    assert line.spans[0].end == marker_start + 1
+    assert line.spans[0].style == CONSOLE_PARAGRAPH_STYLE
+
+
 def test_ascii_plotter_plot_powder_meas_vs_calc_announces_plotly_only_bragg_row(capsys):
     from easydiffraction.display.plotters.ascii import AsciiPlotter
     from easydiffraction.display.plotters.base import BraggTickSet
diff --git a/tests/unit/easydiffraction/display/test_plotting.py b/tests/unit/easydiffraction/display/test_plotting.py
index de9b86845..ea7da0c4e 100644
--- a/tests/unit/easydiffraction/display/test_plotting.py
+++ b/tests/unit/easydiffraction/display/test_plotting.py
@@ -276,6 +276,7 @@ class Ptn:
         def __init__(self):
             self.two_theta = np.array([0.0, 1.0])
             self.intensity_meas = np.array([1.0, 2.0])
+            self.intensity_calc = np.array([1.0, 2.0])
             self.d_spacing = self.two_theta
 
     class ExptType:
@@ -294,7 +295,18 @@ def __init__(self):
         _MeasVsCalcPlotOptions(),
     )
     assert called['labels'] == ('meas',)
-    assert 'Measured data' in called['title']
+    assert called['title'] == "Diffraction pattern for experiment 🔬 'E'"
+    assert called['excluded_ranges'] == ()
+
+    p._plot_calc_data(
+        object(),
+        Ptn(),
+        'E',
+        ExptType(),
+        _MeasVsCalcPlotOptions(),
+    )
+    assert called['labels'] == ('calc',)
+    assert called['title'] == "Diffraction pattern for experiment 🔬 'E'"
     assert called['excluded_ranges'] == ()
 
 
diff --git a/tests/unit/easydiffraction/project/test_display.py b/tests/unit/easydiffraction/project/test_display.py
index 2dd0d27fa..45d30efee 100644
--- a/tests/unit/easydiffraction/project/test_display.py
+++ b/tests/unit/easydiffraction/project/test_display.py
@@ -746,3 +746,32 @@ def fake_structure_feature_availability(structure_arg, *, style):
     display.show_structure_options('lbco')
 
     assert calls == ['update', 'availability']
+
+
+def test_show_structure_options_omits_reason_column(monkeypatch):
+    structure = Structure(name='lbco')
+    project = _make_structure_display_project(structure)
+    display = ProjectDisplay(project)
+    captured: dict[str, object] = {}
+
+    def fake_structure_feature_availability(structure_arg, *, style):
+        assert structure_arg is structure
+        assert style is project.structure_style
+        return FeatureAvailability(frozenset({'cell', 'axes'}), ())
+
+    def fake_render_table(*, columns_headers, columns_alignment, columns_data):
+        captured['columns_headers'] = columns_headers
+        captured['columns_alignment'] = columns_alignment
+        captured['columns_data'] = columns_data
+
+    monkeypatch.setattr(
+        'easydiffraction.display.structure.builder.structure_feature_availability',
+        fake_structure_feature_availability,
+    )
+    monkeypatch.setattr('easydiffraction.project.display.render_table', fake_render_table)
+
+    display.show_structure_options('lbco')
+
+    assert captured['columns_headers'] == ['Option', 'Description', 'Available', 'Auto']
+    assert captured['columns_alignment'] == ['left', 'left', 'center', 'center']
+    assert all(len(row) == 4 for row in captured['columns_data'])
diff --git a/tests/unit/easydiffraction/report/test_html_renderer.py b/tests/unit/easydiffraction/report/test_html_renderer.py
index 7d65a1039..4a965055a 100644
--- a/tests/unit/easydiffraction/report/test_html_renderer.py
+++ b/tests/unit/easydiffraction/report/test_html_renderer.py
@@ -349,6 +349,7 @@ def test_render_html_report_uses_plotly_fit_style_order():
 
     html = render_html_report(context)
 
+    assert 'Diffraction pattern for experiment' in html
     measured = html.index('"name":"Measured (Imeas)"')
     background = html.index('"name":"Background (Ibkg)"')
     calculated = html.index('"name":"Total calculated (Icalc)"')

From 53cf2a51b5faccb909fd78b0da4aab51279dc5af Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 10:36:21 +0200
Subject: [PATCH 140/160] Add Python-CIF correspondence implementation plan

---
 .../python-cif-category-correspondence.md     | 106 ++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 docs/dev/plans/python-cif-category-correspondence.md

diff --git a/docs/dev/plans/python-cif-category-correspondence.md b/docs/dev/plans/python-cif-category-correspondence.md
new file mode 100644
index 000000000..88786b43d
--- /dev/null
+++ b/docs/dev/plans/python-cif-category-correspondence.md
@@ -0,0 +1,106 @@
+# Plan: Python and CIF Category Correspondence
+
+Follows [`AGENTS.md`](../../../AGENTS.md). No deliberate exceptions.
+
+> **Status:** Ready for Phase 1 implementation. The ADR review cycle
+> closed at `python-cif-category-correspondence_review-2.md` with the
+> final-review sentinel. The review/reply artifacts have already been
+> removed from the active tree.
+
+## ADR
+
+- Primary ADR:
+  [`python-cif-category-correspondence.md`](../adrs/suggestions/python-cif-category-correspondence.md)
+  (Proposed; review cycle closed, ready to promote).
+- Referenced accepted ADRs:
+  - [`project-facade-and-persistence.md`](../adrs/accepted/project-facade-and-persistence.md)
+  - [`project-summary-rendering.md`](../adrs/accepted/project-summary-rendering.md)
+  - [`iucr-cif-tag-alignment.md`](../adrs/accepted/iucr-cif-tag-alignment.md)
+  - [`loop-category-key-identity.md`](../adrs/accepted/loop-category-key-identity.md)
+  - [`switchable-category-owned-selectors.md`](../adrs/accepted/switchable-category-owned-selectors.md)
+
+## Branch and PR
+
+- Branch: current branch, `crysview-structure-visualization`.
+- PR target: `develop`.
+- Do not push the branch unless asked.
+
+## Decisions
+
+- Promote the reviewed ADR from `suggestions/` to `accepted/`.
+- Keep the ADR as a documentation-only decision record. It records the
+  current correspondence policy and does not require source-code
+  behavior changes.
+- Update ADR index and cross-references so accepted ADRs no longer point
+  to the old suggestion path.
+- Preserve the clean-report policy: no v1 `project.publication` owner
+  and no empty journal/publication placeholders.
+
+## Open Questions
+
+None.
+
+## Concrete Files Likely To Change
+
+- `docs/dev/adrs/suggestions/python-cif-category-correspondence.md`
+  (moved to `accepted/`).
+- `docs/dev/adrs/accepted/python-cif-category-correspondence.md`
+  (status and accepted-location link fixes after the move).
+- `docs/dev/adrs/index.md`.
+- Accepted ADRs that link to the suggestion path:
+  - `docs/dev/adrs/accepted/iucr-cif-tag-alignment.md`
+  - `docs/dev/adrs/accepted/project-summary-rendering.md`
+  - `docs/dev/adrs/accepted/switchable-category-owned-selectors.md`
+
+## Commit Discipline
+
+When an AI agent follows this plan, every completed Phase 1
+implementation step must be staged with explicit paths and committed
+locally before moving to the next implementation step or the Phase 1
+review gate. Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
+**Commits**.
+
+## Implementation Steps (Phase 1)
+
+- [ ] **P1.1 - Promote the ADR to accepted**
+  - Move
+    `docs/dev/adrs/suggestions/python-cif-category-correspondence.md` to
+    `docs/dev/adrs/accepted/python-cif-category-correspondence.md`.
+  - Change ADR status from `Proposed` to `Accepted`.
+  - Remove the suggestion-only status note.
+  - Update `docs/dev/adrs/index.md` to mark the ADR as accepted and
+    point to the accepted path.
+  - Update accepted ADR cross-references that still point to
+    `../suggestions/python-cif-category-correspondence.md`.
+  - Commit: `Promote Python-CIF correspondence ADR`
+
+- [ ] **P1.2 - Phase 1 review gate**
+  - Mark this checklist item complete after P1.1 is committed.
+  - Commit: `Reach Python-CIF correspondence Phase 1 review gate`
+
+## Verification Commands (Phase 2)
+
+Run the standard Phase 2 sequence:
+
+```shell
+pixi run fix
+pixi run check
+pixi run unit-tests
+pixi run integration-tests
+pixi run script-tests
+```
+
+Use the zsh-safe log-capture pattern from `AGENTS.md` if a command's
+output needs to be preserved for analysis, for example:
+
+```shell
+pixi run check > /tmp/easydiffraction-check.log 2>&1; check_exit_code=$?; tail -n 200 /tmp/easydiffraction-check.log; exit $check_exit_code
+```
+
+## Suggested Pull Request
+
+Title: Accept Python and CIF category correspondence
+
+Description: Records the current Python-to-CIF naming policy so project
+configuration remains predictable while scientific CIF categories keep
+their domain-specific names.

From 58d13bda1452f366849a1ce8bfa3bb1c28b4b0ce Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 10:37:54 +0200
Subject: [PATCH 141/160] Promote Python-CIF correspondence ADR

---
 docs/dev/adrs/accepted/iucr-cif-tag-alignment.md    |  6 +++---
 docs/dev/adrs/accepted/project-summary-rendering.md |  6 +++---
 .../python-cif-category-correspondence.md           | 10 +---------
 .../accepted/switchable-category-owned-selectors.md |  6 +++---
 docs/dev/adrs/index.md                              |  2 +-
 .../dev/plans/python-cif-category-correspondence.md | 13 +++++--------
 6 files changed, 16 insertions(+), 27 deletions(-)
 rename docs/dev/adrs/{suggestions => accepted}/python-cif-category-correspondence.md (99%)

diff --git a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
index c925d63c2..d36193346 100644
--- a/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
+++ b/docs/dev/adrs/accepted/iucr-cif-tag-alignment.md
@@ -10,7 +10,7 @@ report CIFs on demand. Amends parts of
 [`analysis-cif-fit-state.md`](analysis-cif-fit-state.md) and
 [`minimizer-input-output-split.md`](minimizer-input-output-split.md);
 runs alongside the
-[`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+[`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
 suggestion (Python-side correspondence).
 
 Grounded in:
@@ -75,7 +75,7 @@ Two earlier ADRs already touch this surface:
 
 - [`loop-category-key-identity.md`](loop-category-key-identity.md) pins
   loop-key naming on COMCIFS conventions.
-- [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+- [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
   catalogues Python-vs-CIF category mismatches and chooses which side
   should bend.
 
@@ -103,7 +103,7 @@ Out of scope:
 
 - Python attribute renames. This ADR changes CIF emission only.
   Cross-reference
-  [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+  [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
   for Python-side decisions.
 - Adding new CIF categories the project does not currently track
   (`_chemical.*`, `_publ.*`, `_journal.*`) **for the default save**. The
diff --git a/docs/dev/adrs/accepted/project-summary-rendering.md b/docs/dev/adrs/accepted/project-summary-rendering.md
index 0107db2ad..85e9e72b0 100644
--- a/docs/dev/adrs/accepted/project-summary-rendering.md
+++ b/docs/dev/adrs/accepted/project-summary-rendering.md
@@ -76,7 +76,7 @@ Also touches:
   into a hybrid of helper methods plus persisted config; and the
   previously proposed `project.publication` owner is rejected for v1 so
   empty journal metadata stays out of `project.cif` (see §5).
-- [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+- [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
   — owns the Python↔CIF correspondence rule for the new
   `project.report.* ↔ _report.*` project-level singleton surface (five
   scalar items, §1.3). The rejected `project.publication.*` surface is
@@ -169,7 +169,7 @@ Out of scope:
 - Pre-existing project-level singleton categories (`_info.*`,
   `_rendering_plot.*`, `_rendering_table.*`, `_verbosity.*`). Covered by
   the in-flight
-  [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md).
+  [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md).
   This ADR **does** add one new project-level singleton category,
   `_report.*`, alongside them (see §1.3 and the ADRs-amended list); that
   surface is not delegated to the correspondence ADR.
@@ -1974,7 +1974,7 @@ every renderer (HTML, PDF, terminal, GUI) simultaneously.
      project-level singleton categories owned by `project.cif`. This ADR
      adds `_report.*` (this ADR §1.3) and explicitly does not add
      `_publ_*`, `_journal_*`, or any `_publication.*` family.
-- [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+- [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
   — owns the Python-to-CIF correspondence rule for one new project-level
   singleton surface:
   - `project.report.*` ↔ `_report.*` — five scalar items (four format
diff --git a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md b/docs/dev/adrs/accepted/python-cif-category-correspondence.md
similarity index 99%
rename from docs/dev/adrs/suggestions/python-cif-category-correspondence.md
rename to docs/dev/adrs/accepted/python-cif-category-correspondence.md
index 7d3803a2a..a9963270e 100644
--- a/docs/dev/adrs/suggestions/python-cif-category-correspondence.md
+++ b/docs/dev/adrs/accepted/python-cif-category-correspondence.md
@@ -1,16 +1,8 @@
 # ADR: Python and CIF Category Correspondence
 
-**Status:** Proposed  
+**Status:** Accepted  
 **Date:** 2026-05-17
 
-## Status Note
-
-The ADR review cycle closed at
-`python-cif-category-correspondence_review-2.md` with the final-review
-sentinel. The suggestion is ready for a same-slug draft plan; review
-and reply artifacts from the ADR cycle have been removed from the
-active tree.
-
 ## Context
 
 EasyDiffraction exposes a Python object graph and persists state in CIF
diff --git a/docs/dev/adrs/accepted/switchable-category-owned-selectors.md b/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
index fec95ffb4..2d3ca926a 100644
--- a/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
+++ b/docs/dev/adrs/accepted/switchable-category-owned-selectors.md
@@ -52,7 +52,7 @@ Three problems have accumulated since that ADR landed:
    swapped category writes; `_calculation.calculator_type` lives inside
    its category block but the descriptor name awkwardly repeats the noun
    ("calculator") instead of using a uniform `.type` selector.
-   [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+   [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
    notes the inconsistency under §"Owner-level switchable selectors" and
    tags it for a future ADR.
 
@@ -663,7 +663,7 @@ binding — this is a Family-B engine-swap mechanism; only the user-facing
 surface and the CIF block name change.
 
 Affected ADRs: this rename adds a small amendment to
-[`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+[`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
 (category and CIF tag both move from `calculation` to `calculator`) and
 to [`selector-families.md`](selector-families.md) (the example row for
 Family B).
@@ -821,7 +821,7 @@ member and exposes `category.type` plus `category.show_supported()`.
   Replace the `analysis.fitting_mode_type` description with
   `analysis.fitting_mode.type` and document the new `FittingMode`
   category (§8b).
-- [`python-cif-category-correspondence.md`](../suggestions/python-cif-category-correspondence.md)
+- [`python-cif-category-correspondence.md`](python-cif-category-correspondence.md)
   — the §"Owner-level switchable selectors" table becomes obsolete;
   remove the "deliberate abstraction" exception. Update every entry to
   the `_<cat>.type` form.
diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index 43e50a6da..3a2540546 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -40,7 +40,7 @@ folders.
 | Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                       | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                    |
 | Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                    | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)            |
 | Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds a clean IUCr-aligned report export.                           | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
-| Persistence          | Suggestion | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then proposes scoped one-to-one mapping for project-level categories.     | [`python-cif-category-correspondence.md`](suggestions/python-cif-category-correspondence.md) |
+| Persistence          | Accepted   | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then records scoped one-to-one mapping for project-level categories.      | [`python-cif-category-correspondence.md`](accepted/python-cif-category-correspondence.md)    |
 | Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
 | Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                              |
 | Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                         | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                  |
diff --git a/docs/dev/plans/python-cif-category-correspondence.md b/docs/dev/plans/python-cif-category-correspondence.md
index 88786b43d..f53780677 100644
--- a/docs/dev/plans/python-cif-category-correspondence.md
+++ b/docs/dev/plans/python-cif-category-correspondence.md
@@ -10,8 +10,8 @@ Follows [`AGENTS.md`](../../../AGENTS.md). No deliberate exceptions.
 ## ADR
 
 - Primary ADR:
-  [`python-cif-category-correspondence.md`](../adrs/suggestions/python-cif-category-correspondence.md)
-  (Proposed; review cycle closed, ready to promote).
+  [`python-cif-category-correspondence.md`](../adrs/accepted/python-cif-category-correspondence.md)
+  (Accepted).
 - Referenced accepted ADRs:
   - [`project-facade-and-persistence.md`](../adrs/accepted/project-facade-and-persistence.md)
   - [`project-summary-rendering.md`](../adrs/accepted/project-summary-rendering.md)
@@ -42,8 +42,6 @@ None.
 
 ## Concrete Files Likely To Change
 
-- `docs/dev/adrs/suggestions/python-cif-category-correspondence.md`
-  (moved to `accepted/`).
 - `docs/dev/adrs/accepted/python-cif-category-correspondence.md`
   (status and accepted-location link fixes after the move).
 - `docs/dev/adrs/index.md`.
@@ -62,10 +60,9 @@ review gate. Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
 
 ## Implementation Steps (Phase 1)
 
-- [ ] **P1.1 - Promote the ADR to accepted**
-  - Move
-    `docs/dev/adrs/suggestions/python-cif-category-correspondence.md` to
-    `docs/dev/adrs/accepted/python-cif-category-correspondence.md`.
+- [x] **P1.1 - Promote the ADR to accepted**
+  - Move the ADR from `docs/dev/adrs/suggestions/` to
+    `docs/dev/adrs/accepted/`.
   - Change ADR status from `Proposed` to `Accepted`.
   - Remove the suggestion-only status note.
   - Update `docs/dev/adrs/index.md` to mark the ADR as accepted and

From d06051fb1e873c11b91ecd076b738fd1d07be3ef Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 10:38:08 +0200
Subject: [PATCH 142/160] Reach Python-CIF correspondence Phase 1 review gate

---
 docs/dev/plans/python-cif-category-correspondence.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/docs/dev/plans/python-cif-category-correspondence.md b/docs/dev/plans/python-cif-category-correspondence.md
index f53780677..a7a8df8a6 100644
--- a/docs/dev/plans/python-cif-category-correspondence.md
+++ b/docs/dev/plans/python-cif-category-correspondence.md
@@ -2,10 +2,11 @@
 
 Follows [`AGENTS.md`](../../../AGENTS.md). No deliberate exceptions.
 
-> **Status:** Ready for Phase 1 implementation. The ADR review cycle
-> closed at `python-cif-category-correspondence_review-2.md` with the
-> final-review sentinel. The review/reply artifacts have already been
-> removed from the active tree.
+> **Status:** Phase 1 implementation complete; awaiting implementation
+> review. The ADR review cycle closed at
+> `python-cif-category-correspondence_review-2.md` with the final-review
+> sentinel. The review/reply artifacts have already been removed from
+> the active tree.
 
 ## ADR
 
@@ -71,7 +72,7 @@ review gate. Follow the rules in [`AGENTS.md`](../../../AGENTS.md) →
     `../suggestions/python-cif-category-correspondence.md`.
   - Commit: `Promote Python-CIF correspondence ADR`
 
-- [ ] **P1.2 - Phase 1 review gate**
+- [x] **P1.2 - Phase 1 review gate**
   - Mark this checklist item complete after P1.1 is committed.
   - Commit: `Reach Python-CIF correspondence Phase 1 review gate`
 

From f0e83f001f5ba40d92e82388f073d4f3214ea423 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 11:43:32 +0200
Subject: [PATCH 143/160] Make Plotly backgrounds transparent

---
 docs/docs/assets/javascripts/extra.js | 4 ++--
 src/easydiffraction/display/theme.py  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index 2246901d0..a693b43f0 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -31,7 +31,7 @@
   function themeColors() {
     if (themeName() === 'dark') {
       return {
-        background: '#111', // DARK_BACKGROUND_COLOR
+        background: 'rgba(0, 0, 0, 0)', // DARK_BACKGROUND_COLOR
         foreground: '#e6e8ee', // DARK_FOREGROUND_COLOR
         axisFrame: '#333', // DARK_AXIS_FRAME_COLOR
         innerTickGrid: '#1e1e1e', // DARK_INNER_TICK_GRID_COLOR
@@ -40,7 +40,7 @@
       }
     }
     return {
-      background: '#fff', // LIGHT_BACKGROUND_COLOR
+      background: 'rgba(0, 0, 0, 0)', // LIGHT_BACKGROUND_COLOR
       foreground: '#222222', // LIGHT_FOREGROUND_COLOR
       axisFrame: '#e2e2e2', // LIGHT_AXIS_FRAME_COLOR
       innerTickGrid: '#f2f2f2', // LIGHT_INNER_TICK_GRID_COLOR
diff --git a/src/easydiffraction/display/theme.py b/src/easydiffraction/display/theme.py
index 6ed326e6c..cbbad474c 100644
--- a/src/easydiffraction/display/theme.py
+++ b/src/easydiffraction/display/theme.py
@@ -6,8 +6,8 @@
 
 from dataclasses import dataclass
 
-LIGHT_BACKGROUND_COLOR = '#fff'
-DARK_BACKGROUND_COLOR = '#111'
+LIGHT_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0)'
+DARK_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0)'
 LIGHT_FOREGROUND_COLOR = '#222222'
 DARK_FOREGROUND_COLOR = '#e6e8ee'
 LIGHT_AXIS_FRAME_COLOR = '#e2e2e2'

From 8648442dd1811e86842da6b712b0d4efc6a11f8f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 11:51:19 +0200
Subject: [PATCH 144/160] Apply pixi run fix auto-fixes

---
 docs/dev/adrs/index.md                        | 80 +++++++++----------
 docs/dev/issues/closed.md                     |  5 +-
 .../python-cif-category-correspondence.md     |  4 +-
 3 files changed, 44 insertions(+), 45 deletions(-)

diff --git a/docs/dev/adrs/index.md b/docs/dev/adrs/index.md
index 3a2540546..9a04a6a6c 100644
--- a/docs/dev/adrs/index.md
+++ b/docs/dev/adrs/index.md
@@ -13,43 +13,43 @@ folders.
 
 ## ADR Index
 
-| Group                | Status     | Title                                     | Short description                                                                                                     | Link                                                                                         |
-| -------------------- | ---------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
-| Analysis and fitting | Accepted   | Fit Mode Categories and Fit Execution API | Splits fitting configuration from execution and defines active sibling fit-mode categories.                           | [`fit-mode-categories.md`](accepted/fit-mode-categories.md)                                  |
-| Analysis and fitting | Accepted   | Runtime Fit Results                       | Keeps full fit outputs runtime-only in the current design unless a narrower persistence ADR is accepted.              | [`runtime-fit-results.md`](accepted/runtime-fit-results.md)                                  |
-| Analysis and fitting | Accepted   | Analysis CIF Fit State                    | Defines the persisted fit-state projection in `analysis/analysis.cif` and `analysis/results.h5`.                      | [`analysis-cif-fit-state.md`](accepted/analysis-cif-fit-state.md)                            |
-| Analysis and fitting | Accepted   | Parameter Correlation Persistence         | Persists deterministic and posterior correlation summaries in `_fit_parameter_correlation`                            | [`parameter-correlation-persistence.md`](accepted/parameter-correlation-persistence.md)      |
-| Analysis and fitting | Suggestion | Fit Output Files and Data Exports         | Narrows remaining archive/export questions after adopting `results.csv` and `results.h5`.                             | [`fit-output-files-and-data-exports.md`](suggestions/fit-output-files-and-data-exports.md)   |
-| Analysis and fitting | Accepted   | Minimizer Category Consolidation          | Collapses the seven Bayesian categories into one owner-level switchable `minimizer` category with HDF5 sidecar.       | [`minimizer-category-consolidation.md`](accepted/minimizer-category-consolidation.md)        |
-| Analysis and fitting | Accepted   | Minimizer Input/Output Split              | Keeps `analysis.minimizer` input-only and moves scalar fit outputs to paired `analysis.fit_result` classes.           | [`minimizer-input-output-split.md`](accepted/minimizer-input-output-split.md)                |
-| Analysis and fitting | Superseded | Parameter-Level Posterior Projection      | Superseded by minimizer-category consolidation; kept as historical context for `parameter.posterior`.                 | [`parameter-posterior-summary.md`](suggestions/parameter-posterior-summary.md)               |
-| Analysis and fitting | Accepted   | Undo Fit                                  | Builds rollback semantics and CLI behavior on already-persisted pre-fit scalar snapshots.                             | [`undo-fit.md`](accepted/undo-fit.md)                                                        |
-| Core model           | Accepted   | Category Owners and Real Datablocks       | Introduces `CategoryOwner` so singleton sections do not pretend to be real CIF datablocks.                            | [`category-owner-sections.md`](accepted/category-owner-sections.md)                          |
-| Core model           | Accepted   | Enum-Backed Closed Value Sets             | Requires finite option sets to use `(str, Enum)` classes for validation and dispatch.                                 | [`enum-backed-closed-values.md`](accepted/enum-backed-closed-values.md)                      |
-| Core model           | Accepted   | Guarded Public Properties                 | Uses property setters as the public writability contract for guarded objects.                                         | [`guarded-public-properties.md`](accepted/guarded-public-properties.md)                      |
-| Core model           | Accepted   | Two-Level Category Parameter Access       | Keeps parameter access to `datablock.category.parameter` or `datablock.collection[id].parameter`.                     | [`category-parameter-access.md`](accepted/category-parameter-access.md)                      |
-| Documentation        | Accepted   | Descriptor Property Docstring Template    | Makes descriptor metadata the source of truth for public property docstrings and annotations.                         | [`property-docstring-template.md`](accepted/property-docstring-template.md)                  |
-| Documentation        | Accepted   | Development Documentation Structure       | Defines the `docs/dev` layout for ADRs, issues, plans, package structure, and roadmap.                                | [`development-docs-structure.md`](accepted/development-docs-structure.md)                    |
-| Documentation        | Accepted   | Help Method Discoverability               | Requires primary public objects and facades to expose consistent `help()` output.                                     | [`help-discoverability.md`](accepted/help-discoverability.md)                                |
-| Documentation        | Accepted   | Notebook Generation Source of Truth       | Treats tutorial `.py` files as editable sources and notebooks as generated artifacts.                                 | [`notebook-generation.md`](accepted/notebook-generation.md)                                  |
-| Documentation        | Suggestion | Documentation CI and Build Verification   | Proposes strict MkDocs builds, API-derived docs, snippet smoke tests, link checks, and prose/spelling checks.         | [`documentation-ci-build.md`](suggestions/documentation-ci-build.md)                         |
-| Experiment model     | Accepted   | Immutable Experiment Type                 | Makes experiment type axes creation-time state rather than mutable runtime state.                                     | [`immutable-experiment-type.md`](accepted/immutable-experiment-type.md)                      |
-| Factories            | Accepted   | Factory Contracts and Metadata            | Standardizes factory construction, metadata, compatibility, and registration behavior.                                | [`factory-contracts.md`](accepted/factory-contracts.md)                                      |
-| Naming               | Accepted   | Factory Tag Naming                        | Defines canonical factory tag style and standard abbreviations.                                                       | [`factory-tag-naming.md`](accepted/factory-tag-naming.md)                                    |
-| Persistence          | Accepted   | Free-Flag CIF Encoding                    | Encodes fit free/fixed state through CIF uncertainty syntax instead of a separate free list.                          | [`free-flag-cif-encoding.md`](accepted/free-flag-cif-encoding.md)                            |
-| Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                       | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                    |
-| Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                    | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)            |
-| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds a clean IUCr-aligned report export.                           | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                            |
-| Persistence          | Accepted   | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then records scoped one-to-one mapping for project-level categories.      | [`python-cif-category-correspondence.md`](accepted/python-cif-category-correspondence.md)    |
-| Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                    |
-| Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                              |
-| Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                         | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                  |
-| User-facing API      | Accepted   | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures.   | [`crysview-structure-visualization.md`](accepted/crysview-structure-visualization.md)        |
-| User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                          | [`display-ux.md`](accepted/display-ux.md)                                                    |
-| User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.       | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                    |
-| User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and clean report-CIF metadata policy.             | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                      |
-| User-facing API      | Accepted   | Selector Families                         | Distinguishes backend selectors, switchable-category selectors, and active-sibling selectors.                         | [`selector-families.md`](accepted/selector-families.md)                                      |
-| User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                         | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)      |
-| User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.     | [`switchable-category-api.md`](accepted/switchable-category-api.md)                          |
-| User-facing API      | Accepted   | Switchable Category Owned Selectors       | Moves the writable `type` selector and `show_supported()` onto the category itself; collapses the CIF duplication.    | [`switchable-category-owned-selectors.md`](accepted/switchable-category-owned-selectors.md)  |
-| User-facing API      | Accepted   | Value-Selector Discovery                  | Gives enumerated value fields a per-descriptor `show_supported()`, beside the three category-level selector families. | [`value-selector-discovery.md`](accepted/value-selector-discovery.md)                        |
+| Group                | Status     | Title                                     | Short description                                                                                                     | Link                                                                                        |
+| -------------------- | ---------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Analysis and fitting | Accepted   | Fit Mode Categories and Fit Execution API | Splits fitting configuration from execution and defines active sibling fit-mode categories.                           | [`fit-mode-categories.md`](accepted/fit-mode-categories.md)                                 |
+| Analysis and fitting | Accepted   | Runtime Fit Results                       | Keeps full fit outputs runtime-only in the current design unless a narrower persistence ADR is accepted.              | [`runtime-fit-results.md`](accepted/runtime-fit-results.md)                                 |
+| Analysis and fitting | Accepted   | Analysis CIF Fit State                    | Defines the persisted fit-state projection in `analysis/analysis.cif` and `analysis/results.h5`.                      | [`analysis-cif-fit-state.md`](accepted/analysis-cif-fit-state.md)                           |
+| Analysis and fitting | Accepted   | Parameter Correlation Persistence         | Persists deterministic and posterior correlation summaries in `_fit_parameter_correlation`                            | [`parameter-correlation-persistence.md`](accepted/parameter-correlation-persistence.md)     |
+| Analysis and fitting | Suggestion | Fit Output Files and Data Exports         | Narrows remaining archive/export questions after adopting `results.csv` and `results.h5`.                             | [`fit-output-files-and-data-exports.md`](suggestions/fit-output-files-and-data-exports.md)  |
+| Analysis and fitting | Accepted   | Minimizer Category Consolidation          | Collapses the seven Bayesian categories into one owner-level switchable `minimizer` category with HDF5 sidecar.       | [`minimizer-category-consolidation.md`](accepted/minimizer-category-consolidation.md)       |
+| Analysis and fitting | Accepted   | Minimizer Input/Output Split              | Keeps `analysis.minimizer` input-only and moves scalar fit outputs to paired `analysis.fit_result` classes.           | [`minimizer-input-output-split.md`](accepted/minimizer-input-output-split.md)               |
+| Analysis and fitting | Superseded | Parameter-Level Posterior Projection      | Superseded by minimizer-category consolidation; kept as historical context for `parameter.posterior`.                 | [`parameter-posterior-summary.md`](suggestions/parameter-posterior-summary.md)              |
+| Analysis and fitting | Accepted   | Undo Fit                                  | Builds rollback semantics and CLI behavior on already-persisted pre-fit scalar snapshots.                             | [`undo-fit.md`](accepted/undo-fit.md)                                                       |
+| Core model           | Accepted   | Category Owners and Real Datablocks       | Introduces `CategoryOwner` so singleton sections do not pretend to be real CIF datablocks.                            | [`category-owner-sections.md`](accepted/category-owner-sections.md)                         |
+| Core model           | Accepted   | Enum-Backed Closed Value Sets             | Requires finite option sets to use `(str, Enum)` classes for validation and dispatch.                                 | [`enum-backed-closed-values.md`](accepted/enum-backed-closed-values.md)                     |
+| Core model           | Accepted   | Guarded Public Properties                 | Uses property setters as the public writability contract for guarded objects.                                         | [`guarded-public-properties.md`](accepted/guarded-public-properties.md)                     |
+| Core model           | Accepted   | Two-Level Category Parameter Access       | Keeps parameter access to `datablock.category.parameter` or `datablock.collection[id].parameter`.                     | [`category-parameter-access.md`](accepted/category-parameter-access.md)                     |
+| Documentation        | Accepted   | Descriptor Property Docstring Template    | Makes descriptor metadata the source of truth for public property docstrings and annotations.                         | [`property-docstring-template.md`](accepted/property-docstring-template.md)                 |
+| Documentation        | Accepted   | Development Documentation Structure       | Defines the `docs/dev` layout for ADRs, issues, plans, package structure, and roadmap.                                | [`development-docs-structure.md`](accepted/development-docs-structure.md)                   |
+| Documentation        | Accepted   | Help Method Discoverability               | Requires primary public objects and facades to expose consistent `help()` output.                                     | [`help-discoverability.md`](accepted/help-discoverability.md)                               |
+| Documentation        | Accepted   | Notebook Generation Source of Truth       | Treats tutorial `.py` files as editable sources and notebooks as generated artifacts.                                 | [`notebook-generation.md`](accepted/notebook-generation.md)                                 |
+| Documentation        | Suggestion | Documentation CI and Build Verification   | Proposes strict MkDocs builds, API-derived docs, snippet smoke tests, link checks, and prose/spelling checks.         | [`documentation-ci-build.md`](suggestions/documentation-ci-build.md)                        |
+| Experiment model     | Accepted   | Immutable Experiment Type                 | Makes experiment type axes creation-time state rather than mutable runtime state.                                     | [`immutable-experiment-type.md`](accepted/immutable-experiment-type.md)                     |
+| Factories            | Accepted   | Factory Contracts and Metadata            | Standardizes factory construction, metadata, compatibility, and registration behavior.                                | [`factory-contracts.md`](accepted/factory-contracts.md)                                     |
+| Naming               | Accepted   | Factory Tag Naming                        | Defines canonical factory tag style and standard abbreviations.                                                       | [`factory-tag-naming.md`](accepted/factory-tag-naming.md)                                   |
+| Persistence          | Accepted   | Free-Flag CIF Encoding                    | Encodes fit free/fixed state through CIF uncertainty syntax instead of a separate free list.                          | [`free-flag-cif-encoding.md`](accepted/free-flag-cif-encoding.md)                           |
+| Persistence          | Accepted   | Loop Category Keys and Identity Naming    | Documents loop collection keys and naming rules aligned with CIF category keys.                                       | [`loop-category-key-identity.md`](accepted/loop-category-key-identity.md)                   |
+| Persistence          | Accepted   | Project Facade and Persistence Layout     | Documents the current `Project` facade and saved directory layout.                                                    | [`project-facade-and-persistence.md`](accepted/project-facade-and-persistence.md)           |
+| Persistence          | Accepted   | IUCr CIF Tag Alignment                    | Aligns default CIF tags with IUCr dictionaries and adds a clean IUCr-aligned report export.                           | [`iucr-cif-tag-alignment.md`](accepted/iucr-cif-tag-alignment.md)                           |
+| Persistence          | Accepted   | Python and CIF Category Correspondence    | Compares current Python paths and CIF tags, then records scoped one-to-one mapping for project-level categories.      | [`python-cif-category-correspondence.md`](accepted/python-cif-category-correspondence.md)   |
+| Quality              | Accepted   | Lint Complexity Thresholds                | Treats ruff PLR complexity limits as design guardrails that should not be bypassed.                                   | [`lint-complexity-thresholds.md`](accepted/lint-complexity-thresholds.md)                   |
+| Quality              | Accepted   | Test Strategy                             | Defines layered unit, functional, integration, script, and notebook testing.                                          | [`test-strategy.md`](accepted/test-strategy.md)                                             |
+| Structure model      | Accepted   | Type-Neutral ADP Parameters               | Keeps ADP parameter object identities stable across B/U and iso/ani switches.                                         | [`type-neutral-adp-parameters.md`](accepted/type-neutral-adp-parameters.md)                 |
+| User-facing API      | Accepted   | Crystal Structure 3D Visualization        | Adds a renderer-neutral scene model drawn by ASCII and interactive Three.js engines for viewing crystal structures.   | [`crysview-structure-visualization.md`](accepted/crysview-structure-visualization.md)       |
+| User-facing API      | Accepted   | Display UX Facade                         | Defines `project.display` and `project.rendering` responsibilities and display method names.                          | [`display-ux.md`](accepted/display-ux.md)                                                   |
+| User-facing API      | Accepted   | Fit Results Display Naming                | Short, IUCr/GUM-aligned column headers (`s.u.`, `value`, `95% CI`) with a footnote glossary on every fit table.       | [`fit-results-display-naming.md`](accepted/fit-results-display-naming.md)                   |
+| User-facing API      | Accepted   | Project Summary Rendering                 | Defines project report configuration plus terminal, HTML, TeX, PDF, and clean report-CIF metadata policy.             | [`project-summary-rendering.md`](accepted/project-summary-rendering.md)                     |
+| User-facing API      | Accepted   | Selector Families                         | Distinguishes backend selectors, switchable-category selectors, and active-sibling selectors.                         | [`selector-families.md`](accepted/selector-families.md)                                     |
+| User-facing API      | Accepted   | String Paths and Live Descriptors         | Separates persisted field selectors from references to live model parameters.                                         | [`string-paths-and-live-descriptors.md`](accepted/string-paths-and-live-descriptors.md)     |
+| User-facing API      | Accepted   | Switchable Category API                   | Places multi-type category selectors on the owner and omits public selectors for fixed or single-type categories.     | [`switchable-category-api.md`](accepted/switchable-category-api.md)                         |
+| User-facing API      | Accepted   | Switchable Category Owned Selectors       | Moves the writable `type` selector and `show_supported()` onto the category itself; collapses the CIF duplication.    | [`switchable-category-owned-selectors.md`](accepted/switchable-category-owned-selectors.md) |
+| User-facing API      | Accepted   | Value-Selector Discovery                  | Gives enumerated value fields a per-descriptor `show_supported()`, beside the three category-level selector families. | [`value-selector-discovery.md`](accepted/value-selector-discovery.md)                       |
diff --git a/docs/dev/issues/closed.md b/docs/dev/issues/closed.md
index cad61c363..c3574c2f2 100644
--- a/docs/dev/issues/closed.md
+++ b/docs/dev/issues/closed.md
@@ -15,9 +15,8 @@ set instead of hardcoding skipped keys.
 ## 101. Remove Dead Branch in `_fit_state_categories`
 
 Closed by the emcee minimizer implementation. The deterministic branch
-that returned the same category list as the
-fallthrough path was removed while preserving unsupported `result_kind`
-warning behavior.
+that returned the same category list as the fallthrough path was removed
+while preserving unsupported `result_kind` warning behavior.
 
 ---
 
diff --git a/docs/dev/plans/python-cif-category-correspondence.md b/docs/dev/plans/python-cif-category-correspondence.md
index a7a8df8a6..c916bc8ea 100644
--- a/docs/dev/plans/python-cif-category-correspondence.md
+++ b/docs/dev/plans/python-cif-category-correspondence.md
@@ -43,8 +43,8 @@ None.
 
 ## Concrete Files Likely To Change
 
-- `docs/dev/adrs/accepted/python-cif-category-correspondence.md`
-  (status and accepted-location link fixes after the move).
+- `docs/dev/adrs/accepted/python-cif-category-correspondence.md` (status
+  and accepted-location link fixes after the move).
 - `docs/dev/adrs/index.md`.
 - Accepted ADRs that link to the suggestion path:
   - `docs/dev/adrs/accepted/iucr-cif-tag-alignment.md`

From 2a0b221956ad56a23a716e8429ca5392b3ab4924 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 12:16:02 +0200
Subject: [PATCH 145/160] Sync tutorials index.json with index.md and add ed-23
 to ed-26

---
 docs/docs/tutorials/index.json | 44 +++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 8 deletions(-)

diff --git a/docs/docs/tutorials/index.json b/docs/docs/tutorials/index.json
index 40145a15e..92c9594c4 100644
--- a/docs/docs/tutorials/index.json
+++ b/docs/docs/tutorials/index.json
@@ -2,9 +2,9 @@
   "1": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-1/ed-1.ipynb",
     "original_name": "quick_from-cif_pd-neut-cwl_LBCO-HRPT",
-    "title": "Quick Start: LBCO from CIF",
-    "description": "Minimalistic Rietveld refinement of La0.5Ba0.5CoO3 using structure and experiment defined via CIF files",
-    "level": "quick"
+    "title": "Basic Tutorial: LBCO from CIF",
+    "description": "Basic Rietveld refinement of La0.5Ba0.5CoO3 with structure and experiment defined via CIF files",
+    "level": "basic"
   },
   "2": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-2/ed-2.ipynb",
@@ -16,7 +16,7 @@
   "3": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-3/ed-3.ipynb",
     "original_name": "basic_single-fit_pd-neut-cwl_LBCO-HRPT",
-    "title": "Basic Tutorial: LBCO, HRPT",
+    "title": "Complete Tutorial: LBCO, HRPT",
     "description": "Comprehensive Rietveld refinement of La0.5Ba0.5CoO3 following GUI-like workflow with detailed explanations",
     "level": "basic"
   },
@@ -135,15 +135,43 @@
   "21": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-21/ed-21.ipynb",
     "original_name": "",
-    "title": "Bayesian Analysis: LBCO, HRPT",
-    "description": "Bayesian analysis of the La0.5Ba0.5CoO3 crystal structure - Markov Chain Monte Carlo (MCMC) sampling.",
+    "title": "Bayesian Analysis (bumps-dream): LBCO, HRPT",
+    "description": "Bayesian analysis of La0.5Ba0.5CoO3 using Markov Chain Monte Carlo (MCMC) sampling with the bumps-DREAM minimizer, on constant wavelength neutron powder diffraction data from HRPT at PSI",
     "level": "advanced"
   },
   "22": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-22/ed-22.ipynb",
     "original_name": "",
-    "title": "Bayesian Analysis: Tb2TiO7, HEiDi",
-    "description": "Bayesian analysis of the Tb2TiO7 crystal structure - Markov Chain Monte Carlo (MCMC) sampling.",
+    "title": "Bayesian Analysis (emcee): Tb2TiO7, HEiDi",
+    "description": "Bayesian analysis of Tb2TiO7 using Markov Chain Monte Carlo (MCMC) sampling with the emcee minimizer, on constant wavelength neutron single crystal diffraction data from HEiDi at FRM II",
+    "level": "advanced"
+  },
+  "23": {
+    "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-23/ed-23.ipynb",
+    "original_name": "",
+    "title": "Structure Refinement: Co2SiO4, D20 (Resumed scan)",
+    "description": "Resume an interrupted sequential Rietveld refinement of Co2SiO4 by reloading a saved project; the remaining temperature-scan datasets are processed and appended to analysis/results.csv",
+    "level": "advanced"
+  },
+  "24": {
+    "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-24/ed-24.ipynb",
+    "original_name": "",
+    "title": "Bayesian Analysis Display (bumps-dream): LBCO, HRPT",
+    "description": "Reopen the saved bumps-DREAM Bayesian project for La0.5Ba0.5CoO3 and inspect persisted fit summaries, correlation matrix, and posterior plots without rerunning MCMC sampling",
+    "level": "advanced"
+  },
+  "25": {
+    "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-25/ed-25.ipynb",
+    "original_name": "",
+    "title": "Bayesian Analysis (emcee): LBCO, HRPT",
+    "description": "Bayesian analysis of La0.5Ba0.5CoO3 using Markov Chain Monte Carlo (MCMC) sampling with the emcee minimizer, on constant wavelength neutron powder diffraction data from HRPT at PSI",
+    "level": "advanced"
+  },
+  "26": {
+    "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-26/ed-26.ipynb",
+    "original_name": "",
+    "title": "Bayesian Analysis Resume (emcee): LBCO, HRPT",
+    "description": "Reload a saved emcee Bayesian project for La0.5Ba0.5CoO3, inspect the posterior, and resume MCMC sampling with additional steps (supported only for emcee, not bumps-DREAM)",
     "level": "advanced"
   }
 }

From 8a72a23eac94bb386deb7fd2998e5d24814ae0c1 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 12:55:59 +0200
Subject: [PATCH 146/160] Add optional width parameter to table rendering

---
 src/easydiffraction/display/tablers/base.py   |  4 +++
 src/easydiffraction/display/tablers/pandas.py |  4 +++
 src/easydiffraction/display/tablers/rich.py   |  6 +++++
 src/easydiffraction/display/tables.py         | 12 +++++++--
 src/easydiffraction/utils/utils.py            | 27 ++++++++++++++-----
 5 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/src/easydiffraction/display/tablers/base.py b/src/easydiffraction/display/tablers/base.py
index 5de381f86..8e5b39bcd 100644
--- a/src/easydiffraction/display/tablers/base.py
+++ b/src/easydiffraction/display/tablers/base.py
@@ -131,6 +131,7 @@ def render(
         alignments: object,
         df: object,
         display_handle: object | None = None,
+        width: int | None = None,
     ) -> object:
         """
         Render the provided DataFrame with backend-specific styling.
@@ -145,6 +146,9 @@ def render(
         display_handle : object | None, default=None
             Optional environment-specific handle to enable in-place
             updates.
+        width : int | None, default=None
+            Optional target table width. Honored by fixed-width
+            backends (e.g. Rich); ignored by reflowing ones (e.g. HTML).
 
         Returns
         -------
diff --git a/src/easydiffraction/display/tablers/pandas.py b/src/easydiffraction/display/tablers/pandas.py
index f5cfaa1f9..44ddbadd3 100644
--- a/src/easydiffraction/display/tablers/pandas.py
+++ b/src/easydiffraction/display/tablers/pandas.py
@@ -236,6 +236,7 @@ def render(
         alignments: object,
         df: object,
         display_handle: object | None = None,
+        width: int | None = None,
     ) -> object:
         """
         Render a styled DataFrame.
@@ -249,6 +250,9 @@ def render(
         display_handle : object | None, default=None
             Optional IPython DisplayHandle to update an existing output
             area in place when running in Jupyter.
+        width : int | None, default=None
+            Ignored. HTML tables reflow to the available width, so no
+            fixed table width is applied.
 
         Returns
         -------
diff --git a/src/easydiffraction/display/tablers/rich.py b/src/easydiffraction/display/tablers/rich.py
index e23334be3..393357ddb 100644
--- a/src/easydiffraction/display/tablers/rich.py
+++ b/src/easydiffraction/display/tablers/rich.py
@@ -157,6 +157,7 @@ def render(
         alignments: object,
         df: object,
         display_handle: object = None,
+        width: int | None = None,
     ) -> object:
         """
         Render a styled table using Rich.
@@ -169,6 +170,9 @@ def render(
             Index-aware DataFrame to render.
         display_handle : object, default=None
             Optional environment handle for in-place updates.
+        width : int | None, default=None
+            Optional target table width. When set, the table is sized
+            to this width so long cells wrap to fit the terminal.
 
         Returns
         -------
@@ -176,4 +180,6 @@ def render(
             Backend-defined return value (commonly ``None``).
         """
         table = self.build_renderable(alignments, df)
+        if width is not None:
+            table.width = width
         self._update_display(table, display_handle)
diff --git a/src/easydiffraction/display/tables.py b/src/easydiffraction/display/tables.py
index 574d245a0..b6d4697fc 100644
--- a/src/easydiffraction/display/tables.py
+++ b/src/easydiffraction/display/tables.py
@@ -116,7 +116,12 @@ def build_renderable(self, df: object) -> object:
         alignments, prepared_df = self._prepare_dataframe(df)
         return self._backend.build_renderable(alignments, prepared_df)
 
-    def render(self, df: object, display_handle: object | None = None) -> object:
+    def render(
+        self,
+        df: object,
+        display_handle: object | None = None,
+        width: int | None = None,
+    ) -> object:
         """
         Render a DataFrame as a table using the active backend.
 
@@ -129,6 +134,9 @@ def render(self, df: object, display_handle: object | None = None) -> object:
             Optional environment-specific handle used to update an
             existing output area in-place (e.g., an IPython
             DisplayHandle or a terminal live handle).
+        width : int | None, default=None
+            Optional target table width passed to the backend. Honored
+            by fixed-width backends (Rich); ignored by HTML.
 
         Returns
         -------
@@ -136,7 +144,7 @@ def render(self, df: object, display_handle: object | None = None) -> object:
             Backend-specific return value (usually ``None``).
         """
         alignments, prepared_df = self._prepare_dataframe(df)
-        return self._backend.render(alignments, prepared_df, display_handle)
+        return self._backend.render(alignments, prepared_df, display_handle, width)
 
 
 class TableRendererFactory(RendererFactoryBase):
diff --git a/src/easydiffraction/utils/utils.py b/src/easydiffraction/utils/utils.py
index 31615f9d0..9dabbfe02 100644
--- a/src/easydiffraction/utils/utils.py
+++ b/src/easydiffraction/utils/utils.py
@@ -16,6 +16,7 @@
 import pandas as pd
 import pooch
 from packaging.version import Version
+from rich.markup import escape
 from uncertainties import UFloat
 from uncertainties import ufloat
 from uncertainties import ufloat_fromstr
@@ -23,6 +24,7 @@
 from easydiffraction.display.tables import TableRenderer
 from easydiffraction.io.ascii import extract_project_from_zip
 from easydiffraction.utils.environment import resolve_artifact_path
+from easydiffraction.utils.logging import CONSOLE_PARAGRAPH_STYLE
 from easydiffraction.utils.logging import console
 from easydiffraction.utils.logging import log
 
@@ -558,8 +560,10 @@ def list_tutorials() -> None:
     """
     Display a table of available tutorial notebooks.
 
-    Shows tutorial ID, filename and title for all tutorials available
-    for the current version of easydiffraction.
+    Each row shows the tutorial ID, filename, and a combined entry with
+    the title on the first line and a dimmed description on the second,
+    for all tutorials available for the current version of
+    easydiffraction.
     """
     index = _fetch_tutorials_index()
     if not index:
@@ -569,20 +573,27 @@ def list_tutorials() -> None:
     version = _get_version_for_url()
     console.paragraph(f'Tutorials available for easydiffraction v{version}:')
 
-    columns_headers = ['id', 'file', 'title']
+    columns_headers = ['id', 'file', 'tutorial']
     columns_alignment = ['right', 'left', 'left']
     columns_data = []
 
     for tutorial_id in index:
         record = index[tutorial_id]
         filename = f'ed-{tutorial_id}.ipynb'
-        title = record.get('title', '')
-        columns_data.append([tutorial_id, filename, title])
+        title = escape(record.get('title', ''))
+        description = escape(record.get('description', ''))
+        styled_title = f'[{CONSOLE_PARAGRAPH_STYLE}]{title}[/]'
+        if description:
+            details = f'{styled_title}\n[dim]{description}[/dim]'
+        else:
+            details = styled_title
+        columns_data.append([tutorial_id, filename, details])
 
     render_table(
         columns_headers=columns_headers,
         columns_data=columns_data,
         columns_alignment=columns_alignment,
+        width=shutil.get_terminal_size().columns,
     )
 
 
@@ -733,6 +744,7 @@ def render_table(
     columns_alignment: object,
     columns_headers: object = None,
     display_handle: object = None,
+    width: int | None = None,
 ) -> None:
     """
     Render tabular data to the active display backend.
@@ -749,6 +761,9 @@ def render_table(
     display_handle : object, default=None
         Optional display handle for in-place updates (e.g. in Jupyter or
         a terminal Live context).
+    width : int | None, default=None
+        Optional target table width. Honored by fixed-width backends
+        (Rich); ignored by reflowing ones (HTML).
     """
     headers = [
         (col, align) for col, align in zip(columns_headers, columns_alignment, strict=False)
@@ -756,7 +771,7 @@ def render_table(
     df = pd.DataFrame(columns_data, columns=pd.MultiIndex.from_tuples(headers))
 
     tabler = TableRenderer.get()
-    tabler.render(df, display_handle=display_handle)
+    tabler.render(df, display_handle=display_handle, width=width)
 
 
 def build_table_renderable(

From 07ae7d24b5d4d810b116c0e820d8a105cf2ec5d0 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 12:59:21 +0200
Subject: [PATCH 147/160] Show plain tutorial title in Jupyter

---
 src/easydiffraction/display/tablers/base.py |  4 +--
 src/easydiffraction/display/tablers/rich.py |  4 +--
 src/easydiffraction/utils/utils.py          | 28 +++++++++++++--------
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/easydiffraction/display/tablers/base.py b/src/easydiffraction/display/tablers/base.py
index 8e5b39bcd..decb2282f 100644
--- a/src/easydiffraction/display/tablers/base.py
+++ b/src/easydiffraction/display/tablers/base.py
@@ -147,8 +147,8 @@ def render(
             Optional environment-specific handle to enable in-place
             updates.
         width : int | None, default=None
-            Optional target table width. Honored by fixed-width
-            backends (e.g. Rich); ignored by reflowing ones (e.g. HTML).
+            Optional target table width. Honored by fixed-width backends
+            (e.g. Rich); ignored by reflowing ones (e.g. HTML).
 
         Returns
         -------
diff --git a/src/easydiffraction/display/tablers/rich.py b/src/easydiffraction/display/tablers/rich.py
index 393357ddb..ceeb8dd9e 100644
--- a/src/easydiffraction/display/tablers/rich.py
+++ b/src/easydiffraction/display/tablers/rich.py
@@ -171,8 +171,8 @@ def render(
         display_handle : object, default=None
             Optional environment handle for in-place updates.
         width : int | None, default=None
-            Optional target table width. When set, the table is sized
-            to this width so long cells wrap to fit the terminal.
+            Optional target table width. When set, the table is sized to
+            this width so long cells wrap to fit the terminal.
 
         Returns
         -------
diff --git a/src/easydiffraction/utils/utils.py b/src/easydiffraction/utils/utils.py
index 9dabbfe02..5155bf571 100644
--- a/src/easydiffraction/utils/utils.py
+++ b/src/easydiffraction/utils/utils.py
@@ -23,6 +23,7 @@
 
 from easydiffraction.display.tables import TableRenderer
 from easydiffraction.io.ascii import extract_project_from_zip
+from easydiffraction.utils.environment import in_jupyter
 from easydiffraction.utils.environment import resolve_artifact_path
 from easydiffraction.utils.logging import CONSOLE_PARAGRAPH_STYLE
 from easydiffraction.utils.logging import console
@@ -560,10 +561,11 @@ def list_tutorials() -> None:
     """
     Display a table of available tutorial notebooks.
 
-    Each row shows the tutorial ID, filename, and a combined entry with
-    the title on the first line and a dimmed description on the second,
-    for all tutorials available for the current version of
-    easydiffraction.
+    In the terminal each row shows the tutorial ID, filename, and a
+    combined entry with the title on the first line and a dimmed
+    description on the second. In Jupyter the table shows the plain
+    title only, since the HTML backend cannot render the terminal
+    styling.
     """
     index = _fetch_tutorials_index()
     if not index:
@@ -577,16 +579,22 @@ def list_tutorials() -> None:
     columns_alignment = ['right', 'left', 'left']
     columns_data = []
 
+    use_markup = not in_jupyter()
     for tutorial_id in index:
         record = index[tutorial_id]
         filename = f'ed-{tutorial_id}.ipynb'
-        title = escape(record.get('title', ''))
-        description = escape(record.get('description', ''))
-        styled_title = f'[{CONSOLE_PARAGRAPH_STYLE}]{title}[/]'
-        if description:
-            details = f'{styled_title}\n[dim]{description}[/dim]'
+        title = record.get('title', '')
+        description = record.get('description', '')
+        if not use_markup:
+            # Jupyter uses the HTML table backend, which would show Rich
+            # markup as literal text; keep the plain title there.
+            details = title
         else:
-            details = styled_title
+            styled_title = f'[{CONSOLE_PARAGRAPH_STYLE}]{escape(title)}[/]'
+            if description:
+                details = f'{styled_title}\n[dim]{escape(description)}[/dim]'
+            else:
+                details = styled_title
         columns_data.append([tutorial_id, filename, details])
 
     render_table(

From 010f3c910b1aebb46ab45641fcca6554ca1fcd09 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 13:00:47 +0200
Subject: [PATCH 148/160] Specify instrument and data type in tutorials

---
 docs/docs/tutorials/index.json | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/docs/tutorials/index.json b/docs/docs/tutorials/index.json
index 92c9594c4..33a9e5537 100644
--- a/docs/docs/tutorials/index.json
+++ b/docs/docs/tutorials/index.json
@@ -3,28 +3,28 @@
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-1/ed-1.ipynb",
     "original_name": "quick_from-cif_pd-neut-cwl_LBCO-HRPT",
     "title": "Basic Tutorial: LBCO from CIF",
-    "description": "Basic Rietveld refinement of La0.5Ba0.5CoO3 with structure and experiment defined via CIF files",
+    "description": "Basic Rietveld refinement of La0.5Ba0.5CoO3 with structure and experiment defined via CIF files, using constant wavelength neutron powder diffraction data from HRPT at PSI",
     "level": "basic"
   },
   "2": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-2/ed-2.ipynb",
     "original_name": "quick_from-code_pd-neut-cwl_LBCO-HRPT",
     "title": "Quick Start: LBCO from Code",
-    "description": "Minimalistic Rietveld refinement of La0.5Ba0.5CoO3 with structure and experiment defined directly in code",
+    "description": "Minimalistic Rietveld refinement of La0.5Ba0.5CoO3 with structure and experiment defined directly in code, using constant wavelength neutron powder diffraction data from HRPT at PSI",
     "level": "quick"
   },
   "3": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-3/ed-3.ipynb",
     "original_name": "basic_single-fit_pd-neut-cwl_LBCO-HRPT",
     "title": "Complete Tutorial: LBCO, HRPT",
-    "description": "Comprehensive Rietveld refinement of La0.5Ba0.5CoO3 following GUI-like workflow with detailed explanations",
+    "description": "Comprehensive Rietveld refinement of La0.5Ba0.5CoO3 following a GUI-like workflow with detailed explanations, using constant wavelength neutron powder diffraction data from HRPT at PSI",
     "level": "basic"
   },
   "4": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-4/ed-4.ipynb",
     "original_name": "advanced_joint-fit_pd-neut-xray-cwl_PbSO4",
     "title": "Advanced: PbSO4 Joint NPD+XRD Fit",
-    "description": "Advanced Rietveld refinement of PbSO4 using joint fit of neutron and X-ray diffraction data",
+    "description": "Advanced Rietveld refinement of PbSO4 using a joint fit of constant wavelength neutron and X-ray powder diffraction data",
     "level": "advanced"
   },
   "5": {
@@ -52,35 +52,35 @@
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-8/ed-8.ipynb",
     "original_name": "cryst-struct_pd-neut-tof_multidata_NCAF-WISH",
     "title": "Crystal Structure: NCAF, WISH (Multi-Data)",
-    "description": "Rietveld refinement of Na2Ca3Al2F14 using time-of-flight neutron data from WISH at ISIS with joint fitting of two detector banks",
+    "description": "Rietveld refinement of Na2Ca3Al2F14 using time-of-flight neutron powder diffraction data from WISH at ISIS with joint fitting of two detector banks",
     "level": "intermediate"
   },
   "9": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-9/ed-9.ipynb",
     "original_name": "cryst-struct_pd-neut-tof_multiphase-LBCO-Si_McStas",
     "title": "Crystal Structure: LBCO+Si Multi-Phase (McStas)",
-    "description": "Rietveld refinement of La0.5Ba0.5CoO3 with Si impurity phase using time-of-flight neutron data simulated with McStas",
+    "description": "Rietveld refinement of La0.5Ba0.5CoO3 with a Si impurity phase using time-of-flight neutron powder diffraction data simulated with McStas",
     "level": "intermediate"
   },
   "10": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-10/ed-10.ipynb",
     "original_name": "pdf_pd-neut-cwl_Ni",
     "title": "PDF Analysis: Ni, NPD",
-    "description": "Pair distribution function (PDF) analysis of Ni using constant wavelength neutron powder diffraction data",
+    "description": "Pair distribution function (PDF) analysis of Ni using data from a constant wavelength neutron powder diffraction experiment",
     "level": "intermediate"
   },
   "11": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-11/ed-11.ipynb",
     "original_name": "pdf_pd-neut-tof_Si-NOMAD",
     "title": "PDF Analysis: Si, NOMAD (TOF)",
-    "description": "Pair distribution function (PDF) analysis of Si using time-of-flight neutron powder diffraction data from NOMAD at SNS",
+    "description": "Pair distribution function (PDF) analysis of Si using data from a time-of-flight neutron powder diffraction experiment at NOMAD at SNS",
     "level": "intermediate"
   },
   "12": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-12/ed-12.ipynb",
     "original_name": "pdf_pd-xray_NaCl",
     "title": "PDF Analysis: NaCl, XRD",
-    "description": "Pair distribution function (PDF) analysis of NaCl using X-ray powder diffraction data",
+    "description": "Pair distribution function (PDF) analysis of NaCl using data from an X-ray powder diffraction experiment",
     "level": "intermediate"
   },
   "13": {
@@ -94,14 +94,14 @@
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-14/ed-14.ipynb",
     "original_name": "",
     "title": "Crystal Structure: Tb2TiO7, HEiDi",
-    "description": "Crystal structure refinement of Tb2TiO7 using single crystal neutron diffraction data from HEiDi at FRM II",
+    "description": "Crystal structure refinement of Tb2TiO7 using constant wavelength single crystal neutron diffraction data from HEiDi at FRM II",
     "level": "intermediate"
   },
   "15": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-15/ed-15.ipynb",
     "original_name": "",
     "title": "Crystal Structure: Taurine, SENJU (TOF)",
-    "description": "Crystal structure refinement of Taurine using time-of-flight neutron single crystal diffraction data from SENJU at J-PARC",
+    "description": "Crystal structure refinement of Taurine using time-of-flight single crystal neutron diffraction data from SENJU at J-PARC",
     "level": "intermediate"
   },
   "16": {
@@ -122,14 +122,14 @@
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-18/ed-18.ipynb",
     "original_name": "",
     "title": "Quick Start: LBCO Load Project",
-    "description": "Most minimal example: load a saved project from a directory and run Rietveld refinement of La0.5Ba0.5CoO3",
+    "description": "Most minimal example: load a saved project and run a Rietveld refinement of La0.5Ba0.5CoO3 using constant wavelength neutron powder diffraction data from HRPT at PSI",
     "level": "quick"
   },
   "20": {
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-20/ed-20.ipynb",
     "original_name": "",
     "title": "Instrument calibration: BEER at ESS",
-    "description": "Instrument calibration of BEER at ESS using neutron powder diffraction data simulated with McStas",
+    "description": "Instrument calibration for BEER at ESS using time-of-flight neutron powder diffraction data simulated with McStas",
     "level": "intermediate"
   },
   "21": {
@@ -143,7 +143,7 @@
     "url": "https://easyscience.github.io/diffraction-lib/{version}/tutorials/ed-22/ed-22.ipynb",
     "original_name": "",
     "title": "Bayesian Analysis (emcee): Tb2TiO7, HEiDi",
-    "description": "Bayesian analysis of Tb2TiO7 using Markov Chain Monte Carlo (MCMC) sampling with the emcee minimizer, on constant wavelength neutron single crystal diffraction data from HEiDi at FRM II",
+    "description": "Bayesian analysis of Tb2TiO7 using Markov Chain Monte Carlo (MCMC) sampling with the emcee minimizer, on constant wavelength single crystal neutron diffraction data from HEiDi at FRM II",
     "level": "advanced"
   },
   "23": {

From b3f8b2567aaceb235fc83a0499482c8e8eb4100a Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 13:03:27 +0200
Subject: [PATCH 149/160] Consume Pandas table width argument

---
 src/easydiffraction/display/tablers/pandas.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/easydiffraction/display/tablers/pandas.py b/src/easydiffraction/display/tablers/pandas.py
index 44ddbadd3..25a013902 100644
--- a/src/easydiffraction/display/tablers/pandas.py
+++ b/src/easydiffraction/display/tablers/pandas.py
@@ -259,6 +259,7 @@ def render(
         object
             Backend-defined return value (commonly ``None``).
         """
+        del width
         styler = self._build_styler(alignments, df)
         self._update_display(styler, display_handle)
 

From 82092cb81621a3401bc13c0ecf75ba4adc3f21b7 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 13:05:30 +0200
Subject: [PATCH 150/160] Add table rendering follow-ups to open issues

---
 docs/dev/issues/open.md | 88 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/docs/dev/issues/open.md b/docs/dev/issues/open.md
index 4576913da..d1d400759 100644
--- a/docs/dev/issues/open.md
+++ b/docs/dev/issues/open.md
@@ -1820,6 +1820,90 @@ is chosen).
 
 ---
 
+## 109. 🟢 Let More Tables Adapt to Terminal Width
+
+**Type:** UX / Display
+
+`list_tutorials` now renders its table at the real terminal width via a
+new optional `width` parameter threaded through the table render path
+(`render_table` → `TableRenderer.render` → backend `render`; Rich
+applies it, the HTML backend ignores it). Every other table and all log
+output still go through the shared Rich console, whose width is floored
+at `ConsoleManager._MIN_CONSOLE_WIDTH = 130` ("to avoid cramped
+layouts"). On a standard ~80-column terminal that floor makes wide
+tables overflow and soft-wrap badly.
+
+**Fix:** decide on a global policy — either have `_detect_width` trust
+the detected terminal width (keeping 130 only as a fallback when
+detection fails), or pass the terminal width into more table call sites
+the way `list_tutorials` now does. A global change affects every table
+(fit results, parameters, ...) and all logs, so weigh it against the
+deliberate minimum-width choice.
+
+**Depends on:** related to issue 62.
+
+---
+
+## 110. 🟢 Render Styled Multi-Line Table Cells in the HTML Backend
+
+**Type:** Display / Notebook parity
+
+`list_tutorials` shows a two-line cell in the terminal — a colored title
+on the first line and a dimmed description on the second — using Rich
+markup and an embedded newline. The Jupyter table backend
+(`PandasTableBackend`) cannot render this: `_strip_rich_markup` only
+matches a single full-cell `[color]text[/color]`, and HTML collapses the
+newline, so the markup would show as literal text. `list_tutorials` is
+therefore gated via `in_jupyter()` to show only the plain title in
+notebooks, which drops the description and the color there.
+
+**Fix:** teach the HTML backend to render the same styling — translate
+embedded newlines to `<br>`, map `[dim]` to reduced opacity, and accept
+multiple/mixed markup tags per cell — then remove the terminal-only gate
+in `list_tutorials` so notebooks also get the styled two-line entry.
+
+**Depends on:** related to issue 62.
+
+---
+
+## 111. 🟢 Add Test Coverage for `list_tutorials` Two-Line Rendering
+
+**Type:** Test coverage
+
+The `list_tutorials` table gained a styled two-line cell (colored title
+plus dimmed description), a terminal-only `in_jupyter()` gate that falls
+back to the plain title, and a new optional `width` parameter on the
+table render path. Existing tests only assert that titles appear in the
+output.
+
+**Fix:** add unit tests for the description line appearing in the
+terminal (non-Jupyter) path, the Jupyter-gated path showing the plain
+title with no literal Rich markup, and the `width` parameter sizing the
+rendered Rich table. Run `pixi run fix` / `check` / `unit-tests` to
+confirm the shared-renderer signature change.
+
+**Depends on:** nothing.
+
+---
+
+## 112. 🟢 Suppress the Redundant Row-Index Column in Tables
+
+**Type:** Display / UX
+
+`TableRenderer._prepare_dataframe` bumps the DataFrame index to 1-based,
+and both the Rich and pandas backends always render it as the first
+column. For tables that already carry an explicit identifier — e.g.
+`list_tutorials`, whose `id` column duplicates that 1-based counter —
+the leading index column is redundant and reads as a duplicate.
+
+**Fix:** add an opt-out (e.g. a `show_index` flag on the render path) so
+callers with their own id column can hide the auto-generated index, or
+only render the index column when no explicit id column is present.
+
+**Depends on:** nothing.
+
+---
+
 ## Summary
 
 | #   | Issue                                             | Severity | Type                         |
@@ -1911,3 +1995,7 @@ is chosen).
 | 106 | Document `FitResultBase.result_kind` default      | 🟢 Low   | Code readability             |
 | 107 | Validate CIF report vs IUCr dictionaries          | 🟡 Med   | Test coverage                |
 | 108 | Smarter automatic bond detection (near-neighbour) | 🟢 Low   | UX / Visualization           |
+| 109 | Let more tables adapt to terminal width           | 🟢 Low   | UX / Display                 |
+| 110 | Styled multi-line table cells in HTML backend     | 🟢 Low   | Display / Notebook parity    |
+| 111 | Test coverage for `list_tutorials` rendering      | 🟢 Low   | Test coverage                |
+| 112 | Suppress redundant row-index column in tables     | 🟢 Low   | Display / UX                 |

From e8e10b0219df46c37f6d4ebf575f62ce27188740 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 15:44:58 +0200
Subject: [PATCH 151/160] Make Plotly modebar background transparent in both
 themes

---
 docs/docs/assets/javascripts/extra.js          | 1 +
 src/easydiffraction/display/plotters/plotly.py | 1 +
 2 files changed, 2 insertions(+)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index a693b43f0..4f4f660e3 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -105,6 +105,7 @@
       const update = {
         paper_bgcolor: colors.background,
         plot_bgcolor: colors.background,
+        'modebar.bgcolor': colors.background,
         'font.color': colors.foreground,
         'title.font.color': colors.foreground,
         'legend.bgcolor': colors.legend,
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 5aeccf554..2a052a4f8 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -1107,6 +1107,7 @@ def _theme_sync_post_script() -> str:
     const update = {
         paper_bgcolor: colors.background,
         plot_bgcolor: colors.background,
+        'modebar.bgcolor': colors.background,
         'font.color': colors.foreground,
         'title.font.color': colors.foreground,
         'legend.bgcolor': colors.legend,

From 312f42ea911660ff35df47fd71ecde09df28cfc2 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 15:51:00 +0200
Subject: [PATCH 152/160] Tweak axis frame and grid colors

---
 src/easydiffraction/display/theme.py            | 4 ++--
 tests/unit/easydiffraction/report/test_style.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/easydiffraction/display/theme.py b/src/easydiffraction/display/theme.py
index cbbad474c..ca8983bf2 100644
--- a/src/easydiffraction/display/theme.py
+++ b/src/easydiffraction/display/theme.py
@@ -10,10 +10,10 @@
 DARK_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0)'
 LIGHT_FOREGROUND_COLOR = '#222222'
 DARK_FOREGROUND_COLOR = '#e6e8ee'
-LIGHT_AXIS_FRAME_COLOR = '#e2e2e2'
+LIGHT_AXIS_FRAME_COLOR = '#e0e0e0'
 DARK_AXIS_FRAME_COLOR = '#333'
 LIGHT_INNER_TICK_GRID_COLOR = '#f2f2f2'
-DARK_INNER_TICK_GRID_COLOR = '#1e1e1e'
+DARK_INNER_TICK_GRID_COLOR = '#222'
 LIGHT_HOVER_BACKGROUND_COLOR = '#ffffff'
 DARK_HOVER_BACKGROUND_COLOR = '#212121'
 LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
diff --git a/tests/unit/easydiffraction/report/test_style.py b/tests/unit/easydiffraction/report/test_style.py
index 8a2266bef..56661a049 100644
--- a/tests/unit/easydiffraction/report/test_style.py
+++ b/tests/unit/easydiffraction/report/test_style.py
@@ -11,7 +11,7 @@ def test_report_style_context_exposes_hex_and_rgb_values():
 
     assert context['axis_hex'] == '#bec7d0'
     assert context['axis_rgb'] == '190,199,208'
-    assert context['grid_hex'] == '#e2e2e2'
+    assert context['grid_hex'] == '#e0e0e0'
     assert context['grid_rgb'] == '226,226,226'
     assert context['chart_grid_rgb'] == '235,240,248'
     assert context['subtitle'] == 'EasyDiffraction Report'

From 826f5bd59814b01b13cb59661752d81bda54f7f7 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 16:29:23 +0200
Subject: [PATCH 153/160] Size correlation matrix cells to 16 label characters

---
 docs/docs/assets/javascripts/extra.js         |  6 ++--
 .../display/plotters/plotly.py                | 22 +++++++++++++
 src/easydiffraction/display/plotting.py       | 32 ++++++++++++++++---
 .../easydiffraction/display/test_plotting.py  | 26 +++++++++------
 4 files changed, 69 insertions(+), 17 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index 4f4f660e3..1f5072152 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -34,15 +34,15 @@
         background: 'rgba(0, 0, 0, 0)', // DARK_BACKGROUND_COLOR
         foreground: '#e6e8ee', // DARK_FOREGROUND_COLOR
         axisFrame: '#333', // DARK_AXIS_FRAME_COLOR
-        innerTickGrid: '#1e1e1e', // DARK_INNER_TICK_GRID_COLOR
+        innerTickGrid: '#1c1c1c', // DARK_INNER_TICK_GRID_COLOR
         hoverBackground: '#212121', // DARK_HOVER_BACKGROUND_COLOR
-        legend: 'rgba(0, 0, 0, 0.5)', // DARK_LEGEND_BACKGROUND_COLOR
+        legend: 'rgba(33, 33, 33, 0.5)', // DARK_LEGEND_BACKGROUND_COLOR
       }
     }
     return {
       background: 'rgba(0, 0, 0, 0)', // LIGHT_BACKGROUND_COLOR
       foreground: '#222222', // LIGHT_FOREGROUND_COLOR
-      axisFrame: '#e2e2e2', // LIGHT_AXIS_FRAME_COLOR
+      axisFrame: '#e0e0e0', // LIGHT_AXIS_FRAME_COLOR
       innerTickGrid: '#f2f2f2', // LIGHT_INNER_TICK_GRID_COLOR
       hoverBackground: '#ffffff', // LIGHT_HOVER_BACKGROUND_COLOR
       legend: 'rgba(255, 255, 255, 0.5)', // LIGHT_LEGEND_BACKGROUND_COLOR
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 2a052a4f8..093176ad8 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -1289,6 +1289,24 @@ def _fixed_aspect_wrapper_aspect_ratio(cls, fig: object) -> str | None:
             return None
         return aspect_ratio
 
+    @classmethod
+    def _fixed_aspect_wrapper_max_width(cls, fig: object) -> int | None:
+        """Return the max wrapper width in pixels, if one was requested."""
+        meta = cls._figure_meta(fig)
+        if not isinstance(meta, dict):
+            return None
+
+        wrapper = meta.get(FIXED_ASPECT_WRAPPER_META_KEY)
+        if not isinstance(wrapper, dict):
+            return None
+
+        max_width = wrapper.get('max_width_pixels')
+        if not isinstance(max_width, (int, float)) or isinstance(max_width, bool):
+            return None
+        if max_width <= 0:
+            return None
+        return int(max_width)
+
     @classmethod
     def _wrap_html_figure(cls, fig: object, html_fig: str) -> str:
         """Wrap inline Plotly HTML in a fixed-aspect container."""
@@ -1296,10 +1314,14 @@ def _wrap_html_figure(cls, fig: object, html_fig: str) -> str:
         if aspect_ratio is None:
             return html_fig
 
+        max_width = cls._fixed_aspect_wrapper_max_width(fig)
+        max_width_css = f'    max-width: {max_width}px;\n' if max_width is not None else ''
+
         return (
             '<style>\n'
             f'.{FIXED_ASPECT_WRAPPER_CLASS_NAME} {{\n'
             '    width: 100%;\n'
+            f'{max_width_css}'
             f'    aspect-ratio: {aspect_ratio};\n'
             '}\n\n'
             f'.{FIXED_ASPECT_WRAPPER_CLASS_NAME} > div,\n'
diff --git a/src/easydiffraction/display/plotting.py b/src/easydiffraction/display/plotting.py
index f52cc3177..22d12f41b 100644
--- a/src/easydiffraction/display/plotting.py
+++ b/src/easydiffraction/display/plotting.py
@@ -171,6 +171,11 @@ class PosteriorPairPlotStyleEnum(StrEnum):
 SQUARE_MATRIX_BOTTOM_MARGIN_PIXELS = 40
 SQUARE_MATRIX_AXIS_TITLE_LINE_HEIGHT_PIXELS = 18
 SQUARE_MATRIX_TITLE_LEFT_PADDING_PIXELS = 14
+# Correlation-matrix cells are sized to roughly this many label-font
+# characters; the factor approximates one glyph's width per font pixel
+# for Plotly's default sans-serif axis labels.
+CORRELATION_CELL_LABEL_CHAR_COUNT = 16
+CORRELATION_LABEL_CHAR_WIDTH_FACTOR = 0.6
 POSTERIOR_PAIR_SAMPLE_MARKER_SIZE = 6
 POSTERIOR_PAIR_SAMPLE_HOVER_MARKER_SIZE = 6
 
@@ -2336,23 +2341,38 @@ def _square_matrix_target_plot_size_pixels(cls, n_parameters: int) -> float:
         )
         return cell_size * cls._square_matrix_plot_extent(n_parameters)
 
+    @staticmethod
+    def _correlation_cell_size_pixels() -> int:
+        """Return the correlation cell width in pixels (~16 label chars)."""
+        return round(
+            CORRELATION_CELL_LABEL_CHAR_COUNT
+            * CORRELATION_LABEL_CHAR_WIDTH_FACTOR
+            * POSTERIOR_PAIR_AXIS_TITLE_FONT_SIZE
+        )
+
     @classmethod
     def _square_matrix_layout_meta(
         cls,
         *,
         n_parameters: int,
         annotation_labels: list[str],
+        cell_size_pixels: int | None = None,
+        cap_width: bool = False,
     ) -> dict[str, object]:
         """Return wrapper metadata for square matrix plots."""
         margins = cls._square_matrix_layout_margin(annotation_labels)
-        plot_size = cls._square_matrix_target_plot_size_pixels(n_parameters)
+        if cell_size_pixels is None:
+            plot_size = cls._square_matrix_target_plot_size_pixels(n_parameters)
+        else:
+            plot_size = cell_size_pixels * cls._square_matrix_plot_extent(n_parameters)
         aspect_width = round(plot_size + int(margins['l']) + int(margins['r']))
         aspect_height = round(plot_size + int(margins['t']) + int(margins['b']))
-        return {
-            SQUARE_MATRIX_FIXED_ASPECT_META_KEY: {
-                'aspect_ratio': f'{aspect_width} / {aspect_height}',
-            }
+        wrapper: dict[str, object] = {
+            'aspect_ratio': f'{aspect_width} / {aspect_height}',
         }
+        if cap_width:
+            wrapper['max_width_pixels'] = aspect_width
+        return {SQUARE_MATRIX_FIXED_ASPECT_META_KEY: wrapper}
 
     def _finalize_posterior_pairs_figure(
         self,
@@ -4781,6 +4801,8 @@ def _build_correlation_heatmap_plot(
             meta=self._square_matrix_layout_meta(
                 n_parameters=context.n_cols,
                 annotation_labels=[*context.row_labels, *context.col_labels],
+                cell_size_pixels=self._correlation_cell_size_pixels(),
+                cap_width=True,
             ),
             showlegend=False,
         )
diff --git a/tests/unit/easydiffraction/display/test_plotting.py b/tests/unit/easydiffraction/display/test_plotting.py
index ea7da0c4e..b7350a45f 100644
--- a/tests/unit/easydiffraction/display/test_plotting.py
+++ b/tests/unit/easydiffraction/display/test_plotting.py
@@ -2107,17 +2107,25 @@ class Project:
     assert fig.layout.margin.b == (
         SQUARE_MATRIX_BOTTOM_MARGIN_PIXELS + 2 * SQUARE_MATRIX_AXIS_TITLE_LINE_HEIGHT_PIXELS
     )
+    correlation_wrapper_meta = Plotter._square_matrix_layout_meta(
+        n_parameters=2,
+        annotation_labels=[
+            'phase.<br>scale',
+            'phase.<br>cell.<br>length_c',
+            'phase.<br>scale',
+            'phase.<br>cell.<br>length_c',
+        ],
+        cell_size_pixels=Plotter._correlation_cell_size_pixels(),
+        cap_width=True,
+    )['fixed_aspect_wrapper']
     assert (
         fig.layout.meta['fixed_aspect_wrapper']['aspect_ratio']
-        == Plotter._square_matrix_layout_meta(
-            n_parameters=2,
-            annotation_labels=[
-                'phase.<br>scale',
-                'phase.<br>cell.<br>length_c',
-                'phase.<br>scale',
-                'phase.<br>cell.<br>length_c',
-            ],
-        )['fixed_aspect_wrapper']['aspect_ratio']
+        == correlation_wrapper_meta['aspect_ratio']
+    )
+    # Cells are capped to ~16 label characters wide via the wrapper max-width.
+    assert (
+        fig.layout.meta['fixed_aspect_wrapper']['max_width_pixels']
+        == correlation_wrapper_meta['max_width_pixels']
     )
     assert fig.layout.xaxis.showline is False
     assert fig.layout.xaxis.mirror is False

From 013bbc01e9fb971a7578333a0f79a32e24d9a77f Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 16:29:23 +0200
Subject: [PATCH 154/160] Merge atoms and asymmetric-unit into a cycle button

---
 .../structure/templates/structure.html.j2     | 46 +++++++++++++++----
 1 file changed, 37 insertions(+), 9 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 5353bd0c3..0bc934263 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -133,6 +133,7 @@ const ICONS = {
   atoms: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><path d="M11.8 12.2 14 10M12.9 16.1l1.8.4"/><circle cx="9" cy="15" r="4.2" fill="currentColor" stroke="none"/><circle cx="16" cy="8" r="3" fill="currentColor" stroke="none"/><circle cx="17" cy="17" r="2.6" fill="currentColor" stroke="none"/></svg>',
   bonds: '<svg viewBox="0 0 24 24"><line x1="8" y1="16" x2="16" y2="8" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"/><circle cx="6.7" cy="17.3" r="3.1" fill="currentColor"/><circle cx="17.3" cy="6.7" r="3.1" fill="currentColor"/></svg>',
   asymmetricUnit: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><circle cx="9" cy="15" r="4.2" fill="currentColor" stroke="none"/><circle cx="16" cy="8" r="3" opacity=".48"/><circle cx="17" cy="17" r="2.6" opacity=".34"/><path d="M11.8 12.2 14 10M12.9 16.1l1.8.4" opacity=".34"/></svg>',
+  atomsOff: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><path d="M11.8 12.2 14 10M12.9 16.1l1.8.4"/><circle cx="9" cy="15" r="4.2"/><circle cx="16" cy="8" r="3"/><circle cx="17" cy="17" r="2.6"/></svg>',
   moments: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20V5"/><path d="M7 10l5-6 5 6"/></svg>',
   labels: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round" stroke-linecap="round"><rect x="3.5" y="5" width="17" height="14" rx="2"/><path d="M9 15.5 12 8.5l3 7M10.1 13.2h3.8"/></svg>',
   camera: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"><path d="M4 8h3l1.5-2h7L17 8h3a1 1 0 0 1 1 1v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V9a1 1 0 0 1 1-1Z"/><circle cx="12" cy="13" r="3.4"/></svg>',
@@ -512,22 +513,50 @@ homeButton.addEventListener('click', () => {
 const featureGroup = document.createElement('div');
 featureGroup.className = 'mb-grp';
 let hasFeatureToggle = false;
-// Asymmetric-unit toggle: hide symmetry-equivalent copies, keep the reference atoms.
+// Atoms control: one button cycling all atoms -> asymmetric unit only -> no
+// atoms. The asymmetric-unit step is offered only when the scene actually
+// contains symmetry-equivalent copies to hide; otherwise it is a plain
+// show/hide toggle.
 const hasNonAU = SCENE.atoms.some((a) => !a.asymmetric)
   || SCENE.wedgeSpheres.some((s) => !s.asymmetric)
   || SCENE.ellipsoids.some((e) => !e.asymmetric);
-const addAsymmetricUnitToggle = (parent) => {
-  let auOnly = false;
-  const auButton = iconButton(parent, ICONS.asymmetricUnit, 'Asymmetric unit only', 'tog');
-  auButton.addEventListener('click', () => {
-    auOnly = !auOnly;
-    groups.atoms.children.forEach((m) => { m.visible = !auOnly || m.userData.asymmetric; });
-    auButton.classList.toggle('on', auOnly);
+const ATOM_STATES = hasNonAU
+  ? [
+      { key: 'all', icon: ICONS.atoms, on: true },
+      { key: 'asym', icon: ICONS.asymmetricUnit, on: true },
+      { key: 'none', icon: ICONS.atomsOff, on: false },
+    ]
+  : [
+      { key: 'all', icon: ICONS.atoms, on: true },
+      { key: 'none', icon: ICONS.atomsOff, on: false },
+    ];
+const ATOMS_TOOLTIP = hasNonAU
+  ? 'Atoms: all / asymmetric unit / none'
+  : 'Atoms: show / hide';
+const addAtomsControl = (parent) => {
+  let index = groups.atoms.visible ? 0 : ATOM_STATES.length - 1;
+  const start = ATOM_STATES[index];
+  const button = iconButton(parent, start.icon, ATOMS_TOOLTIP, 'tog' + (start.on ? ' on' : ''));
+  button.addEventListener('click', () => {
+    index = (index + 1) % ATOM_STATES.length;
+    const state = ATOM_STATES[index];
+    groups.atoms.visible = state.key !== 'none';
+    groups.atoms.children.forEach((m) => {
+      m.visible = state.key !== 'asym' || !!m.userData.asymmetric;
+    });
+    // CSS2D atom labels ignore ancestor visibility, so match them to the group.
+    groups.atoms.traverse((o) => { if (o.isCSS2DObject) o.visible = groups.atoms.visible; });
+    button.innerHTML = state.icon;
+    button.classList.toggle('on', state.on);
   });
 };
 for (const name of ['atoms', 'labels', 'bonds', 'cell', 'axes', 'moments']) {
   if (!groups[name] || groups[name].children.length === 0) continue;
   hasFeatureToggle = true;
+  if (name === 'atoms') {
+    addAtomsControl(featureGroup);
+    continue;
+  }
   const visible = groups[name].visible;
   const button = iconButton(featureGroup, ICONS[name], name.charAt(0).toUpperCase() + name.slice(1), 'tog' + (visible ? ' on' : ''));
   button.addEventListener('click', () => {
@@ -538,7 +567,6 @@ for (const name of ['atoms', 'labels', 'bonds', 'cell', 'axes', 'moments']) {
     groups[name].traverse((o) => { if (o.isCSS2DObject) o.visible = next; });
     button.classList.toggle('on', next);
   });
-  if (name === 'atoms' && hasNonAU) addAsymmetricUnitToggle(featureGroup);
 }
 if (hasFeatureToggle) {
   modebar.appendChild(featureGroup);

From 1ccf02a3ad899a37766d3b1efdcb82c6534ba2c9 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 16:29:23 +0200
Subject: [PATCH 155/160] Refine theme legend, grid, and frame colors

---
 src/easydiffraction/display/theme.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/easydiffraction/display/theme.py b/src/easydiffraction/display/theme.py
index ca8983bf2..e639e4498 100644
--- a/src/easydiffraction/display/theme.py
+++ b/src/easydiffraction/display/theme.py
@@ -13,11 +13,12 @@
 LIGHT_AXIS_FRAME_COLOR = '#e0e0e0'
 DARK_AXIS_FRAME_COLOR = '#333'
 LIGHT_INNER_TICK_GRID_COLOR = '#f2f2f2'
-DARK_INNER_TICK_GRID_COLOR = '#222'
+DARK_INNER_TICK_GRID_COLOR = '#1c1c1c'
 LIGHT_HOVER_BACKGROUND_COLOR = '#ffffff'
 DARK_HOVER_BACKGROUND_COLOR = '#212121'
+# Legend background mirrors the opaque theme base surface at 50% opacity.
 LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
-DARK_LEGEND_BACKGROUND_COLOR = 'rgba(0, 0, 0, 0.5)'
+DARK_LEGEND_BACKGROUND_COLOR = 'rgba(33, 33, 33, 0.5)'
 TABLE_AXIS_FRAME_CSS_VAR = '--ed-axis-frame-color'
 
 

From e5a053e86f1acf9be657813b352728dbcfd50cb8 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 16:43:54 +0200
Subject: [PATCH 156/160] Sync Plotly theme to annotations, shapes, heatmaps

---
 docs/docs/assets/javascripts/extra.js         |  64 ++++++-
 .../display/plotters/plotly.py                | 157 ++++++++++++++++--
 src/easydiffraction/display/plotting.py       |  21 ++-
 src/easydiffraction/display/theme.py          |   2 +-
 .../display/plotters/test_plotly.py           |  41 +++++
 .../easydiffraction/display/test_plotting.py  |  10 ++
 .../unit/easydiffraction/report/test_style.py |   2 +-
 7 files changed, 278 insertions(+), 19 deletions(-)

diff --git a/docs/docs/assets/javascripts/extra.js b/docs/docs/assets/javascripts/extra.js
index 1f5072152..32c1b2dda 100644
--- a/docs/docs/assets/javascripts/extra.js
+++ b/docs/docs/assets/javascripts/extra.js
@@ -34,7 +34,7 @@
         background: 'rgba(0, 0, 0, 0)', // DARK_BACKGROUND_COLOR
         foreground: '#e6e8ee', // DARK_FOREGROUND_COLOR
         axisFrame: '#333', // DARK_AXIS_FRAME_COLOR
-        innerTickGrid: '#1c1c1c', // DARK_INNER_TICK_GRID_COLOR
+        innerTickGrid: '#222', // DARK_INNER_TICK_GRID_COLOR
         hoverBackground: '#212121', // DARK_HOVER_BACKGROUND_COLOR
         legend: 'rgba(33, 33, 33, 0.5)', // DARK_LEGEND_BACKGROUND_COLOR
       }
@@ -49,6 +49,23 @@
     }
   }
 
+  function plotlyCorrelationColorscale(colors) {
+    return [
+      [0.0, '#d73027'],
+      [0.5, colors.background],
+      [1.0, '#4575b4'],
+    ]
+  }
+
+  function plotlyThemeSyncMeta(plot) {
+    const meta = plot.layout?.meta || plot._fullLayout?.meta
+    if (!meta || typeof meta !== 'object') return {}
+
+    const themeSync = meta.ed_plotly_theme_sync
+    if (!themeSync || typeof themeSync !== 'object') return {}
+    return themeSync
+  }
+
   function plotlyAxisNames(plot) {
     const names = new Set(['xaxis', 'yaxis'])
     ;[plot.layout, plot._fullLayout].forEach((layout) => {
@@ -62,6 +79,40 @@
     return names
   }
 
+  function applyPlotlyAnnotationTheme(plot, update, colors) {
+    const annotations = plot.layout?.annotations || plot._fullLayout?.annotations || []
+    for (let index = 0; index < annotations.length; index += 1) {
+      update[`annotations[${index}].font.color`] = colors.foreground
+    }
+  }
+
+  function applyPlotlyAxisFrameShapeTheme(update, colors, themeSync) {
+    const shapeIndexes = themeSync.axis_frame_shape_indexes
+    if (!Array.isArray(shapeIndexes)) return
+
+    shapeIndexes.forEach((shapeIndex) => {
+      if (!Number.isInteger(shapeIndex) || shapeIndex < 0) return
+      update[`shapes[${shapeIndex}].line.color`] = colors.axisFrame
+    })
+  }
+
+  function plotlyCorrelationHeatmapTraceIndexes(plot, themeSync) {
+    if (themeSync.correlation_heatmap !== true) return []
+
+    const indexes = []
+    ;(plot.data || []).forEach((trace, index) => {
+      if (trace?.type === 'heatmap') indexes.push(index)
+    })
+    return indexes
+  }
+
+  function restylePlotlyCorrelationHeatmaps(plot, colors, themeSync) {
+    const colorscale = plotlyCorrelationColorscale(colors)
+    return plotlyCorrelationHeatmapTraceIndexes(plot, themeSync).map((traceIndex) =>
+      window.Plotly.restyle(plot, { colorscale: [colorscale] }, [traceIndex]),
+    )
+  }
+
   function installPlotlyModebarThemeStyle() {
     const styleId = 'ed-plotly-modebar-theme-style'
     if (document.getElementById(styleId)) return
@@ -101,6 +152,7 @@
     const colors = themeColors()
     document.querySelectorAll('.plotly-graph-div').forEach((plot) => {
       if (!plot.layout && !plot._fullLayout) return
+      const syncMeta = plotlyThemeSyncMeta(plot)
       syncPlotlyModebarTheme(plot, colors)
       const update = {
         paper_bgcolor: colors.background,
@@ -121,10 +173,16 @@
         update[`${key}.title.font.color`] = colors.foreground
         update[`${key}.tickfont.color`] = colors.foreground
       })
+      applyPlotlyAnnotationTheme(plot, update, colors)
+      applyPlotlyAxisFrameShapeTheme(update, colors, syncMeta)
       try {
         const result = window.Plotly.relayout(plot, update)
-        if (result && typeof result.then === 'function') {
-          result.then(function () {
+        const restyleResults = restylePlotlyCorrelationHeatmaps(plot, colors, syncMeta)
+        const pending = [result, ...restyleResults].filter(
+          (item) => item && typeof item.then === 'function',
+        )
+        if (pending.length > 0) {
+          Promise.all(pending).then(function () {
             window.Plotly.redraw(plot)
           })
         } else {
diff --git a/src/easydiffraction/display/plotters/plotly.py b/src/easydiffraction/display/plotters/plotly.py
index 093176ad8..875b6ae55 100644
--- a/src/easydiffraction/display/plotters/plotly.py
+++ b/src/easydiffraction/display/plotters/plotly.py
@@ -108,6 +108,9 @@
 PREDICTIVE_DRAW_ARRAY_NDIM = 2
 FIXED_ASPECT_WRAPPER_META_KEY = 'fixed_aspect_wrapper'
 FIXED_ASPECT_WRAPPER_CLASS_NAME = 'ed-fixed-aspect-plotly-wrapper'
+THEME_SYNC_META_KEY = 'ed_plotly_theme_sync'
+THEME_SYNC_AXIS_FRAME_SHAPE_INDEXES_KEY = 'axis_frame_shape_indexes'
+THEME_SYNC_CORRELATION_HEATMAP_KEY = 'correlation_heatmap'
 
 
 def single_crystal_axis_range(
@@ -260,23 +263,25 @@ def _correlation_colorscale(cls) -> list[tuple[float, str]]:
         """
         Return a diverging colorscale for correlation heatmaps.
 
-        Dark mode uses black at zero correlation for lower visual
-        prominence. Light mode uses white at zero correlation.
+        The midpoint uses the active plot background so correlations
+        fade from red-like negative values through the host surface to
+        blue-like positive values.
 
         Returns
         -------
         list[tuple[float, str]]
             Plotly-compatible colorscale definition.
         """
-        if cls._is_dark_mode():
-            return [
-                (0.0, '#d73027'),
-                (0.5, '#000000'),
-                (1.0, '#4575b4'),
-            ]
+        return cls._correlation_colorscale_for_background(cls._background_color())
+
+    @staticmethod
+    def _correlation_colorscale_for_background(
+        background_color: str,
+    ) -> list[tuple[float, str]]:
+        """Return the correlation colorscale for a theme background."""
         return [
             (0.0, '#d73027'),
-            (0.5, '#f7f7f7'),
+            (0.5, background_color),
             (1.0, '#4575b4'),
         ]
 
@@ -441,6 +446,11 @@ def plot_correlation_heatmap(
         if label_trace is not None:
             traces.append(label_trace)
         fig = self._get_figure(traces, layout)
+        self._apply_theme_sync_meta(
+            fig,
+            axis_frame_shape_indexes=range(len(shapes)),
+            correlation_heatmap=True,
+        )
         fig.update_xaxes(
             side='bottom',
             tickangle=-10,
@@ -1043,6 +1053,29 @@ def _theme_sync_post_script() -> str:
     };
 };
 
+const correlationColorscale = function (colors) {
+    return [
+        [0.0, '#d73027'],
+        [0.5, colors.background],
+        [1.0, '#4575b4'],
+    ];
+};
+
+const themeSyncMeta = function () {
+    const meta = (
+        (graphDiv.layout && graphDiv.layout.meta)
+        || (graphDiv._fullLayout && graphDiv._fullLayout.meta)
+    );
+    if (!meta || typeof meta !== 'object') {
+        return {};
+    }
+    const themeSync = meta.__THEME_SYNC_META_KEY__;
+    if (!themeSync || typeof themeSync !== 'object') {
+        return {};
+    }
+    return themeSync;
+};
+
 const axisNames = function () {
     const names = new Set(['xaxis', 'yaxis']);
     [graphDiv.layout, graphDiv._fullLayout].forEach(function (layout) {
@@ -1058,6 +1091,55 @@ def _theme_sync_post_script() -> str:
     return names;
 };
 
+const applyAnnotationTheme = function (update, colors) {
+    const annotations = (
+        (graphDiv.layout && graphDiv.layout.annotations)
+        || (graphDiv._fullLayout && graphDiv._fullLayout.annotations)
+        || []
+    );
+    for (let index = 0; index < annotations.length; index += 1) {
+        update['annotations[' + index + '].font.color'] = colors.foreground;
+    }
+};
+
+const applyAxisFrameShapeTheme = function (update, colors, themeSync) {
+    const shapeIndexes = themeSync.__THEME_SYNC_AXIS_FRAME_SHAPE_INDEXES_KEY__;
+    if (!Array.isArray(shapeIndexes)) {
+        return;
+    }
+    shapeIndexes.forEach(function (shapeIndex) {
+        if (!Number.isInteger(shapeIndex) || shapeIndex < 0) {
+            return;
+        }
+        update['shapes[' + shapeIndex + '].line.color'] = colors.axisFrame;
+    });
+};
+
+const correlationHeatmapTraceIndexes = function (themeSync) {
+    if (themeSync.__THEME_SYNC_CORRELATION_HEATMAP_KEY__ !== true) {
+        return [];
+    }
+    const traces = graphDiv.data || [];
+    const indexes = [];
+    traces.forEach(function (trace, index) {
+        if (trace && trace.type === 'heatmap') {
+            indexes.push(index);
+        }
+    });
+    return indexes;
+};
+
+const restyleCorrelationHeatmaps = function (colors, themeSync) {
+    const colorscale = correlationColorscale(colors);
+    return correlationHeatmapTraceIndexes(themeSync).map(function (traceIndex) {
+        return window.Plotly.restyle(
+            graphDiv,
+            {colorscale: [colorscale]},
+            [traceIndex],
+        );
+    });
+};
+
 const installModebarThemeStyle = function () {
     const styleId = 'ed-plotly-modebar-theme-style';
     if (document.getElementById(styleId)) {
@@ -1097,6 +1179,7 @@ def _theme_sync_post_script() -> str:
 const applyTheme = function () {
     const theme = hostTheme();
     const colors = themeColors(theme);
+    const syncMeta = themeSyncMeta();
     applyModebarTheme(theme, colors);
 
     if (graphDiv.dataset.edPlotlyTheme === theme) {
@@ -1124,11 +1207,17 @@ def _theme_sync_post_script() -> str:
         update[axisName + '.title.font.color'] = colors.foreground;
         update[axisName + '.tickfont.color'] = colors.foreground;
     });
+    applyAnnotationTheme(update, colors);
+    applyAxisFrameShapeTheme(update, colors, syncMeta);
 
     try {
         const result = window.Plotly.relayout(graphDiv, update);
-        if (result && typeof result.then === 'function') {
-            result.then(function () {
+        const restyleResults = restyleCorrelationHeatmaps(colors, syncMeta);
+        const pending = [result].concat(restyleResults).filter(function (item) {
+            return item && typeof item.then === 'function';
+        });
+        if (pending.length > 0) {
+            Promise.all(pending).then(function () {
                 window.Plotly.redraw(graphDiv);
             });
         } else {
@@ -1169,6 +1258,15 @@ def _theme_sync_post_script() -> str:
 """
         return (
             script
+            .replace('__THEME_SYNC_META_KEY__', THEME_SYNC_META_KEY)
+            .replace(
+                '__THEME_SYNC_AXIS_FRAME_SHAPE_INDEXES_KEY__',
+                THEME_SYNC_AXIS_FRAME_SHAPE_INDEXES_KEY,
+            )
+            .replace(
+                '__THEME_SYNC_CORRELATION_HEATMAP_KEY__',
+                THEME_SYNC_CORRELATION_HEATMAP_KEY,
+            )
             .replace('__DARK_BACKGROUND_COLOR__', DARK_BACKGROUND_COLOR)
             .replace('__DARK_FOREGROUND_COLOR__', DARK_FOREGROUND_COLOR)
             .replace('__DARK_AXIS_FRAME_COLOR__', DARK_AXIS_FRAME_COLOR)
@@ -1269,6 +1367,39 @@ def _figure_meta(fig: object) -> dict[str, object] | None:
                 return meta
         return None
 
+    @classmethod
+    def _apply_theme_sync_meta(
+        cls,
+        fig: object,
+        *,
+        axis_frame_shape_indexes: object = (),
+        correlation_heatmap: bool = False,
+    ) -> None:
+        """Store figure-specific live theme-sync metadata."""
+        meta = cls._figure_meta(fig)
+        updated_meta = dict(meta) if isinstance(meta, dict) else {}
+
+        theme_sync = updated_meta.get(THEME_SYNC_META_KEY)
+        updated_theme_sync = dict(theme_sync) if isinstance(theme_sync, dict) else {}
+
+        indexes = [
+            int(index)
+            for index in axis_frame_shape_indexes
+            if isinstance(index, int) and not isinstance(index, bool) and index >= 0
+        ]
+        if indexes:
+            updated_theme_sync[THEME_SYNC_AXIS_FRAME_SHAPE_INDEXES_KEY] = indexes
+        if correlation_heatmap:
+            updated_theme_sync[THEME_SYNC_CORRELATION_HEATMAP_KEY] = True
+
+        if not updated_theme_sync:
+            return
+
+        updated_meta[THEME_SYNC_META_KEY] = updated_theme_sync
+        update_layout = getattr(fig, 'update_layout', None)
+        if callable(update_layout):
+            update_layout(meta=updated_meta)
+
     @classmethod
     def _fixed_aspect_wrapper_aspect_ratio(cls, fig: object) -> str | None:
         """Return the fixed aspect ratio requested for inline HTML."""
@@ -1291,7 +1422,9 @@ def _fixed_aspect_wrapper_aspect_ratio(cls, fig: object) -> str | None:
 
     @classmethod
     def _fixed_aspect_wrapper_max_width(cls, fig: object) -> int | None:
-        """Return the max wrapper width in pixels, if one was requested."""
+        """
+        Return the max wrapper width in pixels, if one was requested.
+        """
         meta = cls._figure_meta(fig)
         if not isinstance(meta, dict):
             return None
diff --git a/src/easydiffraction/display/plotting.py b/src/easydiffraction/display/plotting.py
index 22d12f41b..d7f3078b1 100644
--- a/src/easydiffraction/display/plotting.py
+++ b/src/easydiffraction/display/plotting.py
@@ -2343,7 +2343,9 @@ def _square_matrix_target_plot_size_pixels(cls, n_parameters: int) -> float:
 
     @staticmethod
     def _correlation_cell_size_pixels() -> int:
-        """Return the correlation cell width in pixels (~16 label chars)."""
+        """
+        Return the correlation cell width in pixels (~16 label chars).
+        """
         return round(
             CORRELATION_CELL_LABEL_CHAR_COUNT
             * CORRELATION_LABEL_CHAR_WIDTH_FACTOR
@@ -2383,6 +2385,11 @@ def _finalize_posterior_pairs_figure(
         subplot_border_shapes: list[dict[str, object]],
     ) -> None:
         """Apply final layout settings to the posterior pair plot."""
+        axis_frame_shape_indexes = [
+            index
+            for index, shape in enumerate(subplot_border_shapes)
+            if shape.get('type') == 'rect'
+        ]
         fig.update_layout(
             autosize=True,
             margin=self._square_matrix_layout_margin(context.annotation_labels),
@@ -2408,6 +2415,10 @@ def _finalize_posterior_pairs_figure(
                 'groupclick': 'togglegroup',
             },
         )
+        PlotlyPlotter._apply_theme_sync_meta(
+            fig,
+            axis_frame_shape_indexes=axis_frame_shape_indexes,
+        )
 
     @staticmethod
     def _square_matrix_layout_margin(annotation_labels: list[str]) -> dict[str, int | bool]:
@@ -4783,6 +4794,7 @@ def _build_correlation_heatmap_plot(
         if label_trace is not None:
             traces.append(label_trace)
         fig = go.Figure(data=traces)
+        shapes = self._correlation_heatmap_grid_shapes(context)
 
         fig.update_layout(
             autosize=True,
@@ -4797,7 +4809,7 @@ def _build_correlation_heatmap_plot(
                 x_centers=x_centers,
                 y_centers=y_centers,
             ),
-            shapes=self._correlation_heatmap_grid_shapes(context),
+            shapes=shapes,
             meta=self._square_matrix_layout_meta(
                 n_parameters=context.n_cols,
                 annotation_labels=[*context.row_labels, *context.col_labels],
@@ -4836,6 +4848,11 @@ def _build_correlation_heatmap_plot(
             scaleanchor='x',
             scaleratio=1,
         )
+        PlotlyPlotter._apply_theme_sync_meta(
+            fig,
+            axis_frame_shape_indexes=range(len(shapes)),
+            correlation_heatmap=True,
+        )
         return fig
 
     @classmethod
diff --git a/src/easydiffraction/display/theme.py b/src/easydiffraction/display/theme.py
index e639e4498..727dbf36f 100644
--- a/src/easydiffraction/display/theme.py
+++ b/src/easydiffraction/display/theme.py
@@ -16,7 +16,7 @@
 DARK_INNER_TICK_GRID_COLOR = '#1c1c1c'
 LIGHT_HOVER_BACKGROUND_COLOR = '#ffffff'
 DARK_HOVER_BACKGROUND_COLOR = '#212121'
-# Legend background mirrors the opaque theme base surface at 50% opacity.
+# Legend background mirrors the opaque theme base surface at 50% opacity
 LIGHT_LEGEND_BACKGROUND_COLOR = 'rgba(255, 255, 255, 0.5)'
 DARK_LEGEND_BACKGROUND_COLOR = 'rgba(33, 33, 33, 0.5)'
 TABLE_AXIS_FRAME_CSS_VAR = '--ed-axis-frame-color'
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 0c549b6f0..812ec9157 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -53,6 +53,40 @@ def test_get_layout_sets_title_axis_and_theme_colors(
     assert layout.yaxis.ticklabelstandoff == pp.Y_AXIS_TICK_LABEL_STANDOFF
 
 
+@pytest.mark.parametrize(
+    ('is_dark_mode', 'background_color'),
+    [
+        (False, 'light-background'),
+        (True, 'dark-background'),
+    ],
+)
+def test_correlation_colorscale_uses_theme_background(
+    monkeypatch,
+    is_dark_mode,
+    background_color,
+):
+    import easydiffraction.display.plotters.plotly as pp
+
+    monkeypatch.setattr(
+        pp.PlotlyPlotter,
+        '_is_dark_mode',
+        classmethod(lambda cls: is_dark_mode),
+    )
+    monkeypatch.setattr(
+        pp.PlotlyPlotter,
+        '_background_color',
+        classmethod(lambda cls: background_color),
+    )
+
+    colorscale = pp.PlotlyPlotter._correlation_colorscale()
+
+    assert colorscale == [
+        (0.0, '#d73027'),
+        (0.5, background_color),
+        (1.0, '#4575b4'),
+    ]
+
+
 def test_get_trace_and_plot(monkeypatch):
     import easydiffraction.display.plotters.plotly as pp
 
@@ -212,7 +246,14 @@ def __init__(self, html):
     assert 'ed-plotly-themed-modebar' in captured['post_script']
     assert '--ed-plotly-modebar-icon-color' in captured['post_script']
     assert '--ed-plotly-modebar-icon-hover-opacity' in captured['post_script']
+    assert 'const correlationColorscale = function (colors) {' in captured['post_script']
+    assert 'const themeSync = meta.ed_plotly_theme_sync;' in captured['post_script']
+    assert 'const applyAnnotationTheme = function (update, colors) {' in captured['post_script']
+    assert 'const shapeIndexes = themeSync.axis_frame_shape_indexes;' in captured['post_script']
+    assert 'if (themeSync.correlation_heatmap !== true) {' in captured['post_script']
+    assert 'window.Plotly.restyle(' in captured['post_script']
     assert 'window.Plotly.relayout(graphDiv, update)' in captured['post_script']
+    assert 'Promise.all(pending).then(function () {' in captured['post_script']
     assert 'window.Plotly.Plots.resize(graphDiv)' in captured['post_script']
     assert "document.addEventListener('visibilitychange'" in captured['post_script']
     assert "window.addEventListener('focus', scheduleResize);" in captured['post_script']
diff --git a/tests/unit/easydiffraction/display/test_plotting.py b/tests/unit/easydiffraction/display/test_plotting.py
index b7350a45f..08df9477d 100644
--- a/tests/unit/easydiffraction/display/test_plotting.py
+++ b/tests/unit/easydiffraction/display/test_plotting.py
@@ -461,6 +461,10 @@ def test_build_posterior_pairs_plot_hides_diagonal_ticks_and_uses_annotations():
             ],
         )['fixed_aspect_wrapper']['aspect_ratio']
     )
+    theme_sync = figure.layout.meta['ed_plotly_theme_sync']
+    assert theme_sync['axis_frame_shape_indexes'] == [
+        index for index, shape in enumerate(figure.layout.shapes) if shape.type == 'rect'
+    ]
     assert [annotation.text for annotation in figure.layout.annotations] == [
         'Posterior pair plot',
         'length_a',
@@ -2127,6 +2131,9 @@ class Project:
         fig.layout.meta['fixed_aspect_wrapper']['max_width_pixels']
         == correlation_wrapper_meta['max_width_pixels']
     )
+    theme_sync = fig.layout.meta['ed_plotly_theme_sync']
+    assert theme_sync['correlation_heatmap'] is True
+    assert theme_sync['axis_frame_shape_indexes'] == list(range(len(fig.layout.shapes)))
     assert fig.layout.xaxis.showline is False
     assert fig.layout.xaxis.mirror is False
     assert fig.layout.yaxis.showline is False
@@ -2139,6 +2146,9 @@ class Project:
     assert fig.layout.plot_bgcolor is None
     assert len(fig.layout.shapes) == 3
     assert all(shape.type == 'rect' for shape in fig.layout.shapes)
+    assert {shape.line.color for shape in fig.layout.shapes} == {
+        plotly_mod.PlotlyPlotter._axis_frame_color(),
+    }
 
 
 def test_plot_param_correlations_plotly_labels_respect_threshold(monkeypatch):
diff --git a/tests/unit/easydiffraction/report/test_style.py b/tests/unit/easydiffraction/report/test_style.py
index 56661a049..826789c9c 100644
--- a/tests/unit/easydiffraction/report/test_style.py
+++ b/tests/unit/easydiffraction/report/test_style.py
@@ -12,7 +12,7 @@ def test_report_style_context_exposes_hex_and_rgb_values():
     assert context['axis_hex'] == '#bec7d0'
     assert context['axis_rgb'] == '190,199,208'
     assert context['grid_hex'] == '#e0e0e0'
-    assert context['grid_rgb'] == '226,226,226'
+    assert context['grid_rgb'] == '224,224,224'
     assert context['chart_grid_rgb'] == '235,240,248'
     assert context['subtitle'] == 'EasyDiffraction Report'
     assert 'PT Sans' in context['html_font_family']

From 2e2d03620d49a6b29043e012626cffa2ae687b65 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 16:52:27 +0200
Subject: [PATCH 157/160] Sort notebook cell_metadata_filter to avoid diff
 churn

---
 tools/tweak_notebooks.py | 53 +++++++++++++++++++++++++++++++---------
 1 file changed, 42 insertions(+), 11 deletions(-)

diff --git a/tools/tweak_notebooks.py b/tools/tweak_notebooks.py
index 628305672..766c6431c 100644
--- a/tools/tweak_notebooks.py
+++ b/tools/tweak_notebooks.py
@@ -1,12 +1,16 @@
-"""Insert a bootstrap code cell as the first cell of every notebook.
+"""Post-process generated tutorial notebooks.
 
 Usage::
         python tools/tweak_notebooks.py tutorials/ [more_paths ...]
 
-The bootstrap cell:
+Inserts a bootstrap code cell as the first cell of every notebook. The
+bootstrap cell:
 - Checks if ``easydiffraction`` is importable; if not, installs it.
 - Adds the tag ``hide-in-docs``.
 - Idempotent: skipped if already present and identical.
+
+Also sorts each notebook's jupytext ``cell_metadata_filter`` so its entry
+order stays stable across runs and does not create noisy diffs.
 """
 
 from __future__ import annotations
@@ -94,7 +98,33 @@ def ensure_bootstrap(nb, bootstrap_source: str) -> bool:
     return True
 
 
-def process_notebook(path: Path, bootstrap_source: str) -> int:
+def normalize_cell_metadata_filter(nb) -> bool:
+    """Sort the jupytext ``cell_metadata_filter`` for a stable order.
+
+    jupytext derives this filter from an unordered set, so multi-entry
+    values (e.g. ``title,tags``) can swap order between runs and produce
+    noisy diffs. Sort the positive entries alphabetically and keep any
+    ``-``-prefixed directives (e.g. ``-all``) last.
+
+    Returns True if the stored value changed.
+    """
+    jupytext_meta = nb.metadata.get('jupytext')
+    if not isinstance(jupytext_meta, dict):
+        return False
+    current = jupytext_meta.get('cell_metadata_filter')
+    if not isinstance(current, str):
+        return False
+    entries = [part.strip() for part in current.split(',') if part.strip()]
+    positives = sorted(entry for entry in entries if not entry.startswith('-'))
+    negatives = sorted(entry for entry in entries if entry.startswith('-'))
+    normalized = ','.join(positives + negatives)
+    if normalized == current:
+        return False
+    jupytext_meta['cell_metadata_filter'] = normalized
+    return True
+
+
+def process_notebook(path: Path, bootstrap_source: str) -> list[str]:
     nb = nbformat.read(path, as_version=4)
 
     # Remove all 'tags' metadata from cells
@@ -102,16 +132,17 @@ def process_notebook(path: Path, bootstrap_source: str) -> int:
         if 'tags' in cell.metadata:
             cell.metadata.pop('tags')
 
-    # Add the bootstrap cell if needed
-    changed = 0
+    reasons: list[str] = []
     if ensure_bootstrap(nb, bootstrap_source):
-        changed += 1
+        reasons.append('inserted bootstrap cell')
+    if normalize_cell_metadata_filter(nb):
+        reasons.append('sorted cell_metadata_filter')
 
     # Normalize to ensure cell ids exist and structure is valid
-    if changed or any('id' not in c for c in nb.cells):
+    if reasons or any('id' not in c for c in nb.cells):
         normalize(nb)
         nbformat.write(nb, path)
-    return changed
+    return reasons
 
 
 def main(argv: list[str]) -> int:
@@ -131,9 +162,9 @@ def main(argv: list[str]) -> int:
 
     updated = 0
     for nb_path in targets:
-        changes = process_notebook(nb_path, bootstrap_source)
-        if changes:
-            print(f'UPDATED: {nb_path} (inserted bootstrap cell)')
+        reasons = process_notebook(nb_path, bootstrap_source)
+        if reasons:
+            print(f'UPDATED: {nb_path} ({"; ".join(reasons)})')
             updated += 1
 
     if updated == 0:

From 7293164a9f479ab7f35ee4e5bbf4fa13428e5f04 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 17:55:18 +0200
Subject: [PATCH 158/160] Use display units in parameter tables

---
 src/easydiffraction/analysis/analysis.py      | 16 ++++-
 .../analysis/test_analysis_access_params.py   | 60 +++++++++++++++++++
 .../analysis/test_analysis_coverage.py        |  7 ++-
 3 files changed, 80 insertions(+), 3 deletions(-)

diff --git a/src/easydiffraction/analysis/analysis.py b/src/easydiffraction/analysis/analysis.py
index 3e1aaae09..41ffc5443 100644
--- a/src/easydiffraction/analysis/analysis.py
+++ b/src/easydiffraction/analysis/analysis.py
@@ -78,6 +78,18 @@
 
 _SUMMARY_HIDDEN_PARAMETER_CATEGORIES = frozenset({'pd_data', 'total_data', 'refln'})
 _POSTERIOR_SAMPLE_NDIM = 3
+
+
+def _parameter_display_units(param: object) -> str:
+    """Return user-facing GUI units for one parameter."""
+    if hasattr(param, 'resolve_display_units'):
+        return param.resolve_display_units('gui')
+    units = getattr(param, 'units', 'N/A')
+    if units == 'none':
+        return ''
+    return units
+
+
 _FLATTENED_POSTERIOR_SAMPLE_NDIM = 2
 _CREDIBLE_INTERVAL_LEVEL_COUNT = 2
 _UNDO_REL_TOL = 1e-12
@@ -1219,7 +1231,7 @@ def _get_params_as_dataframe(
                 }
             if isinstance(param, (NumericDescriptor, Parameter)):
                 record |= {
-                    ('units', 'left'): param.units,
+                    ('units', 'left'): _parameter_display_units(param),
                 }
             if isinstance(param, Parameter):
                 record |= {
@@ -2899,7 +2911,7 @@ def _snapshot_params(self, expt_name: str, results: object) -> None:
             snapshot[param.unique_name] = {
                 'value': param.value,
                 'uncertainty': param.uncertainty,
-                'units': param.units,
+                'units': _parameter_display_units(param),
             }
         self._parameter_snapshots[expt_name] = snapshot
 
diff --git a/tests/unit/easydiffraction/analysis/test_analysis_access_params.py b/tests/unit/easydiffraction/analysis/test_analysis_access_params.py
index 96667689b..af3072e34 100644
--- a/tests/unit/easydiffraction/analysis/test_analysis_access_params.py
+++ b/tests/unit/easydiffraction/analysis/test_analysis_access_params.py
@@ -9,17 +9,25 @@ def _make_param(
     name,
     val,
     *,
+    units='none',
+    display_units=None,
     user_constrained=False,
     symmetry_constrained=False,
 ):
+    from easydiffraction.core.display_handler import DisplayHandler
     from easydiffraction.core.validation import AttributeSpec
     from easydiffraction.core.variable import Parameter
     from easydiffraction.io.cif.handler import CifHandler
 
+    display_handler = (
+        DisplayHandler(display_units=display_units) if display_units is not None else None
+    )
     param = Parameter(
         name=name,
+        units=units,
         value_spec=AttributeSpec(default=0.0),
         cif_handler=CifHandler(names=[f'_{cat}.{name}']),
+        display_handler=display_handler,
     )
     param.value = val
     param._identity.datablock_entry_name = lambda: db
@@ -295,3 +303,55 @@ def render(self, df):
 
     structure_df = rendered[0]
     assert structure_df['parameter', 'left'].tolist() == ['length_a']
+
+
+def test_free_params_uses_display_units_for_structures_and_experiments(monkeypatch):
+    import easydiffraction.analysis.analysis as analysis_mod
+    from easydiffraction.analysis.analysis import Analysis
+
+    structure_param = _make_param(
+        's1',
+        'cell',
+        '',
+        'length_a',
+        4.0,
+        units='angstrom_squared',
+        display_units='Ų',
+    )
+    experiment_param = _make_param(
+        'e1',
+        'time_of_flight',
+        '',
+        'time_offset',
+        12.0,
+        units='microseconds',
+        display_units='μs',
+    )
+
+    class Coll:
+        def __init__(self, params):
+            self.parameters = params
+            self.free_parameters = params
+
+        def __iter__(self):
+            return iter(())
+
+    class Project:
+        def __init__(self):
+            self.structures = Coll([structure_param])
+            self.experiments = Coll([experiment_param])
+
+    rendered = []
+
+    class FakeTableRenderer:
+        def render(self, df):
+            rendered.append(df)
+
+    monkeypatch.setattr(
+        analysis_mod.TableRenderer, 'get', staticmethod(lambda: FakeTableRenderer())
+    )
+    Analysis(Project()).display.free_params()
+
+    free_df = rendered[0]
+    assert free_df['parameter', 'left'].tolist() == ['length_a', 'time_offset']
+    assert free_df['units', 'left'].tolist() == ['Ų', 'μs']
diff --git a/tests/unit/easydiffraction/analysis/test_analysis_coverage.py b/tests/unit/easydiffraction/analysis/test_analysis_coverage.py
index ee0873277..70c2f8e28 100644
--- a/tests/unit/easydiffraction/analysis/test_analysis_coverage.py
+++ b/tests/unit/easydiffraction/analysis/test_analysis_coverage.py
@@ -194,7 +194,11 @@ class FakeParam:
             unique_name = 'p1'
             value = 1.23
             uncertainty = 0.01
-            units = 'Å'
+            units = 'angstroms'
+
+            def resolve_display_units(self, context):
+                assert context == 'gui'
+                return 'Å'
 
         class FakeResults:
             parameters = [FakeParam()]
@@ -203,6 +207,7 @@ class FakeResults:
         assert 'expt1' in a._parameter_snapshots
         assert a._parameter_snapshots['expt1']['p1']['value'] == 1.23
         assert a._parameter_snapshots['expt1']['p1']['uncertainty'] == 0.01
+        assert a._parameter_snapshots['expt1']['p1']['units'] == 'Å'
 
 
 class TestBayesianProjection:

From 54e22488a5bb133d14dca469737e7a4131d92ab6 Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 17:59:30 +0200
Subject: [PATCH 159/160] Adjust Three.js structure overlay styling

---
 .../display/structure/renderers/threejs.py    |  6 ++++
 .../structure/templates/structure.html.j2     | 14 ++++-----
 .../structure/renderers/test_threejs.py       | 31 +++++++++++++++++--
 3 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/src/easydiffraction/display/structure/renderers/threejs.py b/src/easydiffraction/display/structure/renderers/threejs.py
index ab318c602..fb154f996 100644
--- a/src/easydiffraction/display/structure/renderers/threejs.py
+++ b/src/easydiffraction/display/structure/renderers/threejs.py
@@ -152,6 +152,10 @@ def _rgb_css(rgb: tuple[int, int, int]) -> str:
     return f'rgb({rgb[0]}, {rgb[1]}, {rgb[2]})'
 
 
+def _rgba_css(rgb: tuple[int, int, int], alpha: float) -> str:
+    return f'rgba({rgb[0]}, {rgb[1]}, {rgb[2]}, {alpha:g})'
+
+
 class ThreeJsStructureRenderer(StructureRendererBase):
     """
     Interactive Three.js renderer for notebook and standalone HTML.
@@ -212,8 +216,10 @@ def render(
             background=_rgb_css(colours['background']),
             foreground=_rgb_css(colours['foreground']),
             light_background=_rgb_css(light_colours['background']),
+            light_panel_background=_rgba_css(light_colours['background'], 0.5),
             light_foreground=_rgb_css(light_colours['foreground']),
             dark_background=_rgb_css(dark_colours['background']),
+            dark_panel_background=_rgba_css(dark_colours['background'], 0.5),
             dark_foreground=_rgb_css(dark_colours['foreground']),
             theme='dark' if dark else 'light',
         )
diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index 0bc934263..ae2eb1ee8 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -2,7 +2,7 @@
      background:var(--cv-scene-bg);color:var(--cv-scene-fg);border:1px solid rgba(128,128,128,0.3);
      border-radius:0;box-sizing:border-box;overflow:hidden;isolation:isolate;z-index:0;
      font-family:system-ui,-apple-system,'Segoe UI',sans-serif;">
-  <div class="cv-canvas" style="position:absolute;inset:0;"></div>
+  <div class="cv-canvas" style="position:absolute;inset:0;z-index:1;"></div>
   <div class="cv-modebar cv-card"></div>
   <div class="cv-download"></div>
   <div class="cv-legend cv-card"></div>
@@ -12,7 +12,7 @@
 
 <style>
   #{{ container_id }} .cv-card {
-    position: absolute; z-index: 2; background: var(--cv-panel-bg);
+    position: absolute; z-index: 4; background: var(--cv-panel-bg);
     border: 1px solid var(--cv-panel-border); border-radius: 0;
     box-shadow: var(--cv-panel-shadow); font-size: 12px; color: var(--cv-panel-fg);
   }
@@ -24,7 +24,7 @@
     --cv-scene-bg: transparent;
     --cv-scene-fg: {{ dark_foreground }};
     --cv-label-shadow-bg: {{ dark_background }};
-    --cv-panel-bg: rgba(37, 37, 43, 0.95);
+    --cv-panel-bg: {{ dark_panel_background }};
     --cv-panel-border: #52545c;
     --cv-panel-fg: var(--cv-scene-fg);
     --cv-panel-shadow: 0 1px 8px rgba(0, 0, 0, 0.38);
@@ -40,7 +40,7 @@
     --cv-scene-bg: transparent;
     --cv-scene-fg: {{ light_foreground }};
     --cv-label-shadow-bg: {{ light_background }};
-    --cv-panel-bg: rgba(255, 255, 255, 0.94);
+    --cv-panel-bg: {{ light_panel_background }};
     --cv-panel-border: #e2e2e2;
     --cv-panel-fg: #222;
     --cv-panel-shadow: 0 1px 6px rgba(0, 0, 0, 0.12);
@@ -58,7 +58,7 @@
     background: none; border: none; box-shadow: none;
   }
   #{{ container_id }} .cv-download {
-    position: absolute; z-index: 2; right: 10px; bottom: 8px; display: flex;
+    position: absolute; z-index: 4; right: 10px; bottom: 8px; display: flex;
   }
   #{{ container_id }} .mb-grp { display: flex; gap: 4px; }
   #{{ container_id }} .mb {
@@ -91,13 +91,13 @@
     background-image: var(--cv-select-arrow);
     background-repeat: no-repeat; background-position: right 7px center; background-size: 9px 9px;
   }
-  #{{ container_id }} .cv-legend { top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; text-align: left; }
+  #{{ container_id }} .cv-legend { z-index: 5; top: 10px; left: 10px; padding: 8px 11px; line-height: 1.7; white-space: nowrap; text-align: left; }
   #{{ container_id }} .cv-legend .sw {
     display: inline-block; width: 11px; height: 11px; border-radius: 50%;
     margin-right: 7px; vertical-align: middle; border: 1px solid rgba(0, 0, 0, 0.18);
   }
   #{{ container_id }} .cv-hint {
-    position: absolute; z-index: 2; bottom: 8px; left: 10px; font-size: 11px;
+    position: absolute; z-index: 5; bottom: 8px; left: 10px; font-size: 11px;
     color: var(--cv-panel-fg); background: var(--cv-panel-bg);
     border: 1px solid var(--cv-panel-border); padding: 5px 9px; border-radius: 0;
     line-height: 1.5; text-align: left; box-shadow: var(--cv-panel-shadow);
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 25d3fa6ef..166288dff 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -245,6 +245,9 @@ def test_handles_channel_bounds(self):
         assert MUT._rgb_css((0, 0, 0)) == 'rgb(0, 0, 0)'
         assert MUT._rgb_css((255, 255, 255)) == 'rgb(255, 255, 255)'
 
+    def test_formats_triple_and_alpha_as_css_rgba(self):
+        assert MUT._rgba_css((1, 2, 3), 0.5) == 'rgba(1, 2, 3, 0.5)'
+
 
 # ------------------------------------------------------------------
 #  _scene_payload
@@ -519,7 +522,7 @@ def test_dark_theme_marks_document_dark(self, patched_theme):
             dark=True,
         )
         assert 'dark' in html
-        assert '--cv-panel-bg: rgba(37, 37, 43, 0.95);' in html
+        assert '--cv-panel-bg: rgba(10, 20, 30, 0.5);' in html
         assert "stroke='%23ebebeb'" in html
 
     def test_offline_embeds_inlined_module(self, patched_theme):
@@ -606,7 +609,31 @@ def test_viewer_is_isolated_from_page_header_stacking(self, patched_theme):
         )
 
         assert 'overflow:hidden;isolation:isolate;z-index:0;' in html
-        assert 'position: absolute; z-index: 2; background: var(--cv-panel-bg);' in html
+        assert 'style="position:absolute;inset:0;z-index:1;"' in html
+        assert 'position: absolute; z-index: 4; background: var(--cv-panel-bg);' in html
+
+    def test_legend_and_hint_overlay_axis_letters(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _rich_scene(),
+            features=frozenset({'axes'}),
+            offline=True,
+            dark=False,
+        )
+
+        assert '.cv-legend { z-index: 5;' in html
+        assert '.cv-hint {\n    position: absolute; z-index: 5;' in html
+        assert "className = 'cv-axis-letter';" in html
+
+    def test_legend_and_hint_use_half_transparent_background(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _identity_scene(),
+            features=frozenset(),
+            offline=True,
+            dark=False,
+        )
+
+        assert '--cv-panel-bg: rgba(10, 20, 30, 0.5);' in html
+        assert 'color: var(--cv-panel-fg); background: var(--cv-panel-bg);' in html
 
     def test_perspective_projection_uses_reduced_field_of_view(self, patched_theme):
         html = ThreeJsStructureRenderer().render(

From cc473507355ac95f9e9a16772429fb3a52f0a2fd Mon Sep 17 00:00:00 2001
From: Andrew Sazonov <andrew.sazonov@icloud.com>
Date: Mon, 1 Jun 2026 17:59:43 +0200
Subject: [PATCH 160/160] Keep structure-view secondary axis upright

---
 .../structure/templates/structure.html.j2       | 17 +++++++++++++----
 .../display/structure/renderers/test_threejs.py | 17 +++++++++++++++++
 2 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/src/easydiffraction/display/structure/templates/structure.html.j2 b/src/easydiffraction/display/structure/templates/structure.html.j2
index ae2eb1ee8..f32ee5882 100644
--- a/src/easydiffraction/display/structure/templates/structure.html.j2
+++ b/src/easydiffraction/display/structure/templates/structure.html.j2
@@ -459,14 +459,23 @@ const viewAlongAxis = (axisIndex) => {
     .map((axis, index) => ({ axis, index }))
     .filter(({ index }) => index !== axisIndex)
     .sort((left, right) => right.axis.length() - left.axis.length());
-  let horizontal = projectedOnViewPlane(remaining[0].axis.clone().normalize(), viewAxis);
+  let horizontalSource = remaining[0];
+  let secondarySource = remaining[1];
+  let horizontal = projectedOnViewPlane(horizontalSource.axis.clone().normalize(), viewAxis);
   if (horizontal.lengthSq() < 1e-8) {
-    horizontal = projectedOnViewPlane(remaining[1].axis.clone().normalize(), viewAxis);
+    [horizontalSource, secondarySource] = [secondarySource, horizontalSource];
+    horizontal = projectedOnViewPlane(horizontalSource.axis.clone().normalize(), viewAxis);
   }
   horizontal.normalize();
-  const look = viewAxis.clone().negate();
+  const secondary = projectedOnViewPlane(secondarySource.axis.clone().normalize(), viewAxis).normalize();
+  const cameraAxis = viewAxis.clone();
+  const look = cameraAxis.clone().negate();
   const up = new THREE.Vector3().crossVectors(horizontal, look).normalize();
-  viewAlong(viewAxis, up);
+  if (secondary.dot(up) < 0) {
+    cameraAxis.negate();
+    up.negate();
+  }
+  viewAlong(cameraAxis, up);
 };
 
 const iconButton = (parent, html, title, cls) => {
diff --git a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
index 166288dff..f951b48c0 100644
--- a/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
+++ b/tests/unit/easydiffraction/display/structure/renderers/test_threejs.py
@@ -662,6 +662,23 @@ def test_reset_view_resets_orthographic_zoom(self, patched_theme):
         assert 'camera.position.copy(home);' in html
         assert 'controls.target.copy(target);' in html
 
+    def test_axis_view_buttons_flip_camera_to_keep_secondary_axis_up(self, patched_theme):
+        html = ThreeJsStructureRenderer().render(
+            _rich_scene(),
+            features=frozenset({'axes'}),
+            offline=True,
+            dark=False,
+        )
+
+        assert 'let secondarySource = remaining[1];' in html
+        assert '[horizontalSource, secondarySource] = [secondarySource, horizontalSource];' in html
+        assert 'const cameraAxis = viewAxis.clone();' in html
+        assert 'if (secondary.dot(up) < 0) {' in html
+        assert 'cameraAxis.negate();' in html
+        assert 'up.negate();' in html
+        assert 'viewAlong(cameraAxis, up);' in html
+        assert 'viewAlong(viewAxis, up);' not in html
+
     def test_colour_scheme_select_matches_button_height(self, patched_theme):
         html = ThreeJsStructureRenderer().render(
             _rich_scene(),