diff --git a/README.md b/README.md
index e362b102..899d98af 100644
--- a/README.md
+++ b/README.md
@@ -809,17 +809,18 @@ round-trips through the raw `POINT` buffer.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/gp-lineart-contour/"><img src="examples/gp-lineart-contour/preview.webp" alt="GP Line Art contour: a faceted teal crystal on a dark studio floor outlined in neon cyan Grease Pencil Line Art strokes, proving modifiers.new LINEART with source_object silhouette evaluation" /></a>
+<a href="examples/gp-lineart-contour/"><img src="examples/gp-lineart-contour/preview.webp" alt="GP Line Art contour: a cel-shaded red-and-white lighthouse on a rocky islet with a keeper's cottage and rowboat, inked in bold black Grease Pencil Line Art strokes, proving modifiers.new LINEART with source_object evaluation" /></a>
 </td>
 <td valign="middle">
 
 ### [gp-lineart-contour](examples/gp-lineart-contour/)
 
-Grease Pencil `LINEART` modifier contours via the depsgraph — not Freestyle and
-not hand-drawn strokes. `source_object` is load-bearing (clear → 0 strokes);
-contour+crease off → 0; restore recovers **10** strokes / **34** points on both
-binaries. Stroke width: `thickness` exists on 4.5, `AttributeError` on 5.1 —
-portable path is `radius`.
+Grease Pencil `LINEART` modifier ink via the depsgraph on a cel-shaded
+lighthouse diorama — not Freestyle and not hand-drawn strokes. `source_object`
+is load-bearing (clear → 0 strokes); every edge type off → 0; the drawing is
+**255** strokes / **1393** points on all three binaries, gated so dropping any
+one edge type fails. Stroke width: `thickness` exists on 4.5, `AttributeError`
+on 5.1 — portable path is `radius`.
 
 </td>
 </tr>
diff --git a/docs/gallery/assets/gp-lineart-contour-hero.webp b/docs/gallery/assets/gp-lineart-contour-hero.webp
index 86ac76d1..9856c8c3 100644
Binary files a/docs/gallery/assets/gp-lineart-contour-hero.webp and b/docs/gallery/assets/gp-lineart-contour-hero.webp differ
diff --git a/docs/gallery/contact-sheets/gp-lineart-contour-contact-sheet.webp b/docs/gallery/contact-sheets/gp-lineart-contour-contact-sheet.webp
index a5618234..2a10bce3 100644
Binary files a/docs/gallery/contact-sheets/gp-lineart-contour-contact-sheet.webp and b/docs/gallery/contact-sheets/gp-lineart-contour-contact-sheet.webp differ
diff --git a/docs/gallery/gp-lineart-contour/index.html b/docs/gallery/gp-lineart-contour/index.html
index d3fd89bd..e6f3904b 100644
--- a/docs/gallery/gp-lineart-contour/index.html
+++ b/docs/gallery/gp-lineart-contour/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>gp-lineart-contour — Examples — Blender Developer Tools</title>
-  <meta name="description" content="Grease Pencil LINEART modifier contours via the depsgraph on a faceted crystal. source_object is load-bearing (clear yields 0 strokes); contour+crease off yields 0; restore recovers 2 strokes / 12 points on 4.5.11, 5.1.2 and 5.2.1. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius." />
+  <meta name="description" content="Grease Pencil LINEART modifier ink via the depsgraph on a cel-shaded lighthouse diorama. source_object is load-bearing (clear yields 0 strokes); every edge type off yields 0; the drawing is 255 strokes / 1393 points on 4.5.11, 5.1.2 and 5.2.1, gated above the count left when any one of contour, crease, material-border or intersection edges is dropped. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/gp-lineart-contour/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta name="color-scheme" content="dark" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="gp-lineart-contour — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="Grease Pencil LINEART modifier contours via the depsgraph on a faceted crystal. source_object is load-bearing (clear yields 0 strokes); contour+crease off yields 0; restore recovers 2 strokes / 12 points on 4.5.11, 5.1.2 and 5.2.1. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius." />
+  <meta property="og:description" content="Grease Pencil LINEART modifier ink via the depsgraph on a cel-shaded lighthouse diorama. source_object is load-bearing (clear yields 0 strokes); every edge type off yields 0; the drawing is 255 strokes / 1393 points on 4.5.11, 5.1.2 and 5.2.1, gated above the count left when any one of contour, crease, material-border or intersection edges is dropped. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/gp-lineart-contour/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gp-lineart-contour-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes." />
+  <meta property="og:image:alt" content="A red-and-white lighthouse on a rocky islet with a keeper&#x27;s cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="gp-lineart-contour — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="Grease Pencil LINEART modifier contours via the depsgraph on a faceted crystal. source_object is load-bearing (clear yields 0 strokes); contour+crease off yields 0; restore recovers 2 strokes / 12 points on 4.5.11, 5.1.2 and 5.2.1. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius." />
+  <meta name="twitter:description" content="Grease Pencil LINEART modifier ink via the depsgraph on a cel-shaded lighthouse diorama. source_object is load-bearing (clear yields 0 strokes); every edge type off yields 0; the drawing is 255 strokes / 1393 points on 4.5.11, 5.1.2 and 5.2.1, gated above the count left when any one of contour, crease, material-border or intersection edges is dropped. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gp-lineart-contour-hero.webp" />
-  <meta name="twitter:image:alt" content="A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes." />
+  <meta name="twitter:image:alt" content="A red-and-white lighthouse on a rocky islet with a keeper&#x27;s cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,25 +265,27 @@
   </div>
   <header class="hero">
     <h1>gp-lineart-contour</h1>
-    <p>Grease Pencil LINEART modifier contours via the depsgraph on a faceted crystal. source_object is load-bearing (clear yields 0 strokes); contour+crease off yields 0; restore recovers 2 strokes / 12 points on 4.5.11, 5.1.2 and 5.2.1. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius.</p>
+    <p>Grease Pencil LINEART modifier ink via the depsgraph on a cel-shaded lighthouse diorama. source_object is load-bearing (clear yields 0 strokes); every edge type off yields 0; the drawing is 255 strokes / 1393 points on 4.5.11, 5.1.2 and 5.2.1, gated above the count left when any one of contour, crease, material-border or intersection edges is dropped. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes.">
-      <img src="../assets/gp-lineart-contour-hero.webp" alt="A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A red-and-white lighthouse on a rocky islet with a keeper&#x27;s cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink.">
+      <img src="../assets/gp-lineart-contour-hero.webp" alt="A red-and-white lighthouse on a rocky islet with a keeper&#x27;s cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> AI code still sets LINEART.thickness on 5.1 (AttributeError) or hand-draws strokes / enables Freestyle instead of modifiers.new(..., &#x27;LINEART&#x27;). Clearing source_object or leaving contour+crease off silently yields an empty drawing — the check proves both failure modes and recovery.</div>
+    <div class="callout"><span class="tag">witnesses</span> AI code still sets LINEART.thickness on 5.1 (AttributeError) or hand-draws strokes / enables Freestyle instead of modifiers.new(..., &#x27;LINEART&#x27;). Clearing source_object or leaving every edge type off silently yields an empty drawing — the check proves both failure modes and recovery.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/gp-lineart-contour/gp_lineart_contour.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a faceted crystal, attaches a Grease Pencil <code>LINEART</code> modifier with <code>source_type=&#x27;OBJECT&#x27;</code>, and proves the contour contract through the depsgraph — including the 4.5 → 5.1 stroke-width trap.</p>
+<p>A runnable example that builds a lighthouse on a rocky islet — tower, gallery, lantern room, keeper&#x27;s cottage, a hauled-up rowboat and a diorama sea — as one cel-shaded mesh, attaches a Grease Pencil <code>LINEART</code> modifier with <code>source_type=&#x27;OBJECT&#x27;</code>, and proves the contour contract through the depsgraph, including the 4.5 → 5.1 stroke-width trap.</p>
 <p><strong>What it witnesses:</strong> the Line Art modifier contract AI-generated NPR code most often gets wrong.</p>
-<ul><li><strong>Contours are a modifier, not Freestyle and not hand-authored strokes.</strong> <code>modifiers.new(..., &#x27;LINEART&#x27;)</code> on a GPv3 object, with <code>target_layer</code> / <code>target_material</code> set, evaluates silhouette edges into drawing strokes.</li><li><strong><code>source_object</code> is load-bearing.</strong> Clearing it yields <strong>0</strong> evaluated strokes (proven in the same check pass). Restoring it recovers the contour.</li><li><strong>Edge-type flags matter.</strong> A freshly added LINEART with <code>use_contour</code> and <code>use_crease</code> both off emits <strong>0</strong> strokes; turning contour (+ crease) back on recovers the silhouette (<strong>2</strong> strokes / <strong>12</strong> points on every binary for this crystal + camera; Line Art chains the bipyramid&#x27;s edges into long strokes, so the count is low and the gates are lower bounds).</li><li><strong>Stroke width renamed.</strong> 4.5 exposes both <code>thickness</code> (legacy px, set to 45 here) and <code>radius</code>; 5.1 removes <code>thickness</code> (<code>AttributeError</code>) and keeps <code>radius</code> only (portable path: <code>mod.radius = 0.028</code>).</li><li><strong>GPv3 address</strong> matches <code>grease-pencil-rosette</code>: <code>grease_pencils_v3</code> on 4.5, <code>grease_pencils</code> on 5.x.</li></ul>
-<p><strong>What each check catches on failure:</strong> wrong GPv3 collection (exit 2), <code>thickness</code> present/absent on the wrong side of 5.0 (exit 3), lost <code>source_object</code> assignment (exit 4), contour too thin (exit 5), source clear not zeroing strokes (exit 6), flags-off or restore failure (exit 7).</p>
-<p><strong>Version witness:</strong> stroke counts match on 4.5.11 LTS, 5.1.2 and 5.2.1 LTS (2 strokes / 12 points). The divergence is <code>thickness</code> vs <code>radius</code>.</p>
-<p><strong>The still:</strong> the crystal is a hexagonal bipyramid (an equator ring and two apexes), set tip-down in a two-tier hex mount on the floor. The mount is render staging, derived from the crystal&#x27;s lowest evaluated vertex; it is built after the check, so it never enters the Line Art counts. The still&#x27;s camera drops its aim and dollies in along the check camera&#x27;s bearing, so the crystal fills the frame with the mount&#x27;s foot inside it.</p>
+<ul><li><strong>Contours are a modifier, not Freestyle and not hand-authored strokes.</strong> <code>modifiers.new(..., &#x27;LINEART&#x27;)</code> on a GPv3 object, with <code>target_layer</code> / <code>target_material</code> set, evaluates the source mesh&#x27;s edges into drawing strokes.</li><li><strong><code>source_object</code> is load-bearing.</strong> Clearing it yields <strong>0</strong> evaluated strokes (proven in the same check pass). Restoring it recovers the drawing.</li><li><strong>Edge-type flags matter.</strong> A freshly added LINEART with every edge type off (contour, crease, material borders, intersections, loose, edge marks) emits <strong>0</strong> strokes. The configured modifier draws <strong>255</strong> strokes / <strong>1393</strong> points on every binary, and the gates (<strong>≥ 240</strong> strokes, <strong>≥ 1320</strong> points) sit above the count left when any <em>one</em> edge type is dropped — contour 234 strokes, crease 171 / 1099, material borders 247 / 1305, intersections 179 / 921 — so each is load-bearing: the band borders on the tower are material-border ink, the waterline around each rock is intersection ink. Rebuilding the modifier must recover exactly the first pass&#x27;s counts.</li><li><strong>Stroke width renamed.</strong> 4.5 exposes both <code>thickness</code> (legacy px, set to 22 here) and <code>radius</code>; 5.1 removes <code>thickness</code> (<code>AttributeError</code>) and keeps <code>radius</code> only (portable path: <code>mod.radius = 0.021</code>).</li><li><strong>GPv3 address</strong> matches <code>grease-pencil-rosette</code>: <code>grease_pencils_v3</code> on 4.5, <code>grease_pencils</code> on 5.x.</li></ul>
+<p><strong>What each check catches on failure:</strong> wrong GPv3 collection (exit 2), <code>thickness</code> present/absent on the wrong side of 5.0 (exit 3), lost <code>source_object</code> assignment or <code>use_contour</code> (exit 4), drawing below the gates (exit 5), source clear not zeroing strokes (exit 6), flags-off not zeroing strokes or a rebuild not recovering the same counts (exit 7).</p>
+<p><strong>Version witness:</strong> stroke counts match on 4.5.11 LTS, 5.1.2 and 5.2.1 LTS (255 strokes / 1393 points). The divergence is <code>thickness</code> vs <code>radius</code>.</p>
+<p><strong>The still:</strong> the check and the still share one camera, because Line Art is view-dependent — the strokes the check counts are the strokes the still draws. The mesh is shaded flat (three cel tones), so the black ink is what makes it read as an inked illustration: clear <code>source_object</code> and the same render is a flat, lineless low-poly model — no band borders, no waterline, no outlines.</p>
+<h3>Stage deviation</h3>
+<p>Line Art is a non-photoreal contract: the hero&#x27;s materials are cel-shaded (Diffuse → Shader to RGB → constant ramp, emitted) instead of Principled, so the ink reads against flat tone fields. The stage itself — floor, wall, world, key, fill and warm wedge — is the default. The cel shading uses Shader to RGB, which is EEVEE-only, so <code>--engine cycles</code> does not render the look.</p>
 <h2>Run</h2>
 <pre><code># Depsgraph contour check — the CI check:
 blender --background --python gp_lineart_contour.py --
@@ -295,7 +297,7 @@ <h2>Run</h2>
 blender --background --python gp_lineart_contour.py -- --output lineart.png</code></pre>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> is the shared framing helper.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage; also GPv3 collection address contract</td></tr><tr><td>3</td><td>LINEART <code>thickness</code> / <code>radius</code> trap for this Blender</td></tr><tr><td>4</td><td>LINEART type, source, or <code>use_contour</code> (<code>--no-contour</code> lands here)</td></tr><tr><td>5</td><td>Evaluated contour too thin</td></tr><tr><td>6</td><td>Cleared <code>source_object</code> still produced strokes</td></tr><tr><td>7</td><td>Contour+crease off still produced strokes, or restore failed</td></tr><tr><td>8</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage; also GPv3 collection address contract</td></tr><tr><td>3</td><td>LINEART <code>thickness</code> / <code>radius</code> trap for this Blender</td></tr><tr><td>4</td><td>LINEART type, source, or <code>use_contour</code> (<code>--no-contour</code> lands here)</td></tr><tr><td>5</td><td>Evaluated drawing below the stroke/point gates</td></tr><tr><td>6</td><td>Cleared <code>source_object</code> still produced strokes</td></tr><tr><td>7</td><td>Every edge type off still produced strokes, or the rebuild did not recover the same counts</td></tr><tr><td>8</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--no-contour</code>.</p>
     </section>
     <section class="detail-section src">
@@ -313,15 +315,18 @@ <h2>Source</h2>
    not from freestyle or hand-drawn strokes.
 2. ``source_type=&#x27;OBJECT&#x27;`` + ``source_object`` is load-bearing — clearing
    the source yields zero evaluated strokes.
-3. ``use_contour`` must be on for silhouette edges; with contour and crease
-   both off the evaluator emits nothing.
+3. ``use_contour`` must be on for silhouette edges; with every edge-type
+   flag off the evaluator emits nothing.
 4. Stroke width: 4.5 exposes both ``thickness`` (legacy px) and ``radius``;
    5.1 removes ``thickness`` (AttributeError) and keeps ``radius`` only.
 5. GPv3 datablock address matches grease-pencil-rosette: ``grease_pencils_v3``
    on 4.5, ``grease_pencils`` on 5.x.
 
-The check evaluates the modifier through the depsgraph (no bake required)
-and asserts stroke/point lower bounds against the known failure modes above.
+The subject is a lighthouse on a rocky islet with its keeper&#x27;s cottage —
+one mesh object, toon-shaded, so the Line Art ink is what turns it into an
+inked illustration. The check evaluates the modifier through the depsgraph
+(no bake required) from the same camera the still renders from and asserts
+stroke/point lower bounds against the known failure modes above.
 
 ``--no-contour`` clears ``use_contour`` after the modifier is built and
 still asserts it is True. That is the falsifier (``--same-axis`` in
@@ -334,28 +339,36 @@ <h2>Source</h2>
     blender --background --python gp_lineart_contour.py -- --no-contour
     blender --background --python gp_lineart_contour.py -- --output l.png
 &quot;&quot;&quot;</span>
-<span class="k">import</span> bpy, bmesh, sys, os, math, argparse
+<span class="k">import</span> bpy, bmesh, sys, os, math, argparse, random
 
 <span class="c"># Shared Layer 1 framing measurement (render path only) — see gallery_framing.py</span>
 sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = <span class="k">True</span>  <span class="c"># keep examples/__pycache__ out of the repo tree</span>
 <span class="k">import</span> gallery_framing
-<span class="k">from</span> mathutils <span class="k">import</span> Matrix
+<span class="k">from</span> mathutils <span class="k">import</span> Matrix, Vector
 
-<span class="c"># Faceted crystal (octahedron-ish) — enough silhouette edges to read at thumbnail</span>
-CRYSTAL_SCALE = <span class="n">1.15</span>
-CRYSTAL_R = <span class="n">0.72</span>        <span class="c"># bipyramid equator radius (before CRYSTAL_SCALE)</span>
-CRYSTAL_APEX = <span class="n">0.88</span>     <span class="c"># apex height above/below the equator</span>
-STROKE_MIN = <span class="n">1</span>
-POINT_MIN = <span class="n">4</span>
-RADIUS = <span class="n">0.028</span>
+<span class="c"># Gates on the evaluated drawing. Measured 255 strokes / 1393 points on 4.5.11,</span>
+<span class="c"># 5.1.2 and 5.2.1. Each gate sits above the count left when any ONE of the four</span>
+<span class="c"># edge types is dropped (contour 234 s, crease 171 s / 1099 p, material 1305 p,</span>
+<span class="c"># intersection 179 s / 921 p), so every edge type is load-bearing on the count.</span>
+STROKE_MIN = <span class="n">240</span>
+POINT_MIN = <span class="n">1320</span>
+RADIUS = <span class="n">0.021</span>        <span class="c"># ink half-width in world units (portable width path)</span>
+THICKNESS_45 = <span class="n">22</span>       <span class="c"># 4.5-only legacy px width, set before radius</span>
 
-<span class="c"># render staging only (not part of the check)</span>
-MOUNT_R = <span class="n">0.46</span>          <span class="c"># hex plinth base radius</span>
-MOUNT_BASE_H = <span class="n">0.07</span>     <span class="c"># base tier height, standing on the floor</span>
-MOUNT_SOCKET = <span class="n">0.10</span>     <span class="c"># depth the crystal&#x27;s lower tip sinks into the mount</span>
-STILL_AIM_Z = <span class="n">1.05</span>      <span class="c"># still camera aim height (the check&#x27;s is 1.15)</span>
-STILL_DOLLY = <span class="n">0.94</span>     <span class="c"># still camera distance, relative to the check&#x27;s</span>
+<span class="c"># Lighthouse proportions (world units; the islet stands on the floor at z=0)</span>
+TOWER_N = <span class="n">32</span>            <span class="c"># tower ring segments (fine enough: no facet creases)</span>
+TOWER_Z0 = <span class="n">0.34</span>         <span class="c"># tower foot, on top of the plinth</span>
+TOWER_H = <span class="n">2.05</span>
+TOWER_R0 = <span class="n">0.40</span>         <span class="c"># radius at the foot</span>
+TOWER_R1 = <span class="n">0.27</span>         <span class="c"># radius at the gallery</span>
+TOWER_BANDS = <span class="n">5</span>         <span class="c"># red / white / red / white / red</span>
+
+<span class="c"># Material slots on the single source mesh</span>
+RED, WHITE, IRON, GLOW, ROCK, STONE, SLATE, SEA = range(<span class="n">8</span>)
+SEA_Z = <span class="n">0.07</span>            <span class="c"># top of the diorama sea disc</span>
+
+INK = (<span class="n">0.015</span>, <span class="n">0.014</span>, <span class="n">0.02</span>, <span class="n">1.0</span>)
 
 
 <span class="k">def</span> eevee_engine_id():
@@ -392,91 +405,363 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="n">0</span>
 
 
-<span class="k">def</span> build_crystal(sc):
-    <span class="s">&quot;&quot;&quot;A designed faceted crystal — not a raw cube.&quot;&quot;&quot;</span>
-    me = bpy.data.meshes.new(<span class="s">&quot;Crystal&quot;</span>)
+<span class="c"># --- the source mesh: one object, many named parts via material slots --------</span>
+
+<span class="k">def</span> toon_material(name, color):
+    <span class="s">&quot;&quot;&quot;Flat cel shading: Diffuse -&gt; Shader to RGB -&gt; constant ramp, times the
+    base colour, emitted. Three tones (shadow / mid / lit) so the key light
+    still shapes the form while the Line Art ink carries the drawing.&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    nt.nodes.clear()
+    diff = nt.nodes.new(<span class="s">&quot;ShaderNodeBsdfDiffuse&quot;</span>)
+    diff.inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
+    to_rgb = nt.nodes.new(<span class="s">&quot;ShaderNodeShaderToRGB&quot;</span>)
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.interpolation = <span class="s">&quot;CONSTANT&quot;</span>
+    els = ramp.color_ramp.elements
+    els[<span class="n">0</span>].position = <span class="n">0.0</span>
+    els[<span class="n">0</span>].color = (<span class="n">0.30</span>, <span class="n">0.30</span>, <span class="n">0.34</span>, <span class="n">1.0</span>)     <span class="c"># shadow tone, slightly cool</span>
+    els[<span class="n">1</span>].position = <span class="n">0.10</span>
+    els[<span class="n">1</span>].color = (<span class="n">0.62</span>, <span class="n">0.62</span>, <span class="n">0.64</span>, <span class="n">1.0</span>)     <span class="c"># mid tone</span>
+    lit = els.new(<span class="n">0.34</span>)
+    lit.color = (<span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)           <span class="c"># lit tone</span>
+    mul = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mul.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mul.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    mul.inputs[<span class="s">&quot;Factor&quot;</span>].default_value = <span class="n">1.0</span>
+    mul.inputs[<span class="n">6</span>].default_value = color         <span class="c"># A</span>
+    emit = nt.nodes.new(<span class="s">&quot;ShaderNodeEmission&quot;</span>)
+    emit.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.0</span>
+    out = nt.nodes.new(<span class="s">&quot;ShaderNodeOutputMaterial&quot;</span>)
+    nt.links.new(diff.outputs[<span class="n">0</span>], to_rgb.inputs[<span class="n">0</span>])
+    nt.links.new(to_rgb.outputs[<span class="s">&quot;Color&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], mul.inputs[<span class="n">7</span>])  <span class="c"># B</span>
+    nt.links.new(mul.outputs[<span class="n">2</span>], emit.inputs[<span class="s">&quot;Color&quot;</span>])
+    nt.links.new(emit.outputs[<span class="n">0</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> glow_material(name, color, strength):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    nt.nodes.clear()
+    emit = nt.nodes.new(<span class="s">&quot;ShaderNodeEmission&quot;</span>)
+    emit.inputs[<span class="s">&quot;Color&quot;</span>].default_value = color
+    emit.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = strength
+    out = nt.nodes.new(<span class="s">&quot;ShaderNodeOutputMaterial&quot;</span>)
+    nt.links.new(emit.outputs[<span class="n">0</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> _tag(bm, verts, mat):
+    faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
+    <span class="k">for</span> f <span class="k">in</span> faces:
+        f.material_index = mat
+
+
+<span class="k">def</span> _cyl(bm, mat, r1, r2, z0, z1, segs, x=<span class="n">0.0</span>, y=<span class="n">0.0</span>, rot=<span class="n">0.0</span>):
+    res = bmesh.ops.create_cone(
+        bm, cap_ends=<span class="k">True</span>, segments=segs, radius1=r1, radius2=r2,
+        depth=z1 - z0,
+        matrix=Matrix.Translation((x, y, (z0 + z1) / <span class="n">2</span>)) @ Matrix.Rotation(rot, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>),
+    )
+    _tag(bm, res[<span class="s">&quot;verts&quot;</span>], mat)
+    <span class="k">return</span> res[<span class="s">&quot;verts&quot;</span>]
+
+
+<span class="k">def</span> _box(bm, mat, center, size, rot_z=<span class="n">0.0</span>):
+    m = (Matrix.Translation(center) @ Matrix.Rotation(rot_z, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>)
+         @ Matrix.Diagonal((size[<span class="n">0</span>], size[<span class="n">1</span>], size[<span class="n">2</span>], <span class="n">1.0</span>)))
+    res = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>, matrix=m)
+    _tag(bm, res[<span class="s">&quot;verts&quot;</span>], mat)
+    <span class="k">return</span> res[<span class="s">&quot;verts&quot;</span>]
+
+
+<span class="k">def</span> tower_radius(z):
+    t = (z - TOWER_Z0) / TOWER_H
+    <span class="k">return</span> TOWER_R0 + (TOWER_R1 - TOWER_R0) * t
+
+
+<span class="k">def</span> _tower(bm):
+    <span class="s">&quot;&quot;&quot;Tapered, banded tower: shared rings, so the only line between bands is
+    the material border Line Art reads from the slots.&quot;&quot;&quot;</span>
+    rings = []
+    <span class="k">for</span> i <span class="k">in</span> range(TOWER_BANDS + <span class="n">1</span>):
+        z = TOWER_Z0 + TOWER_H * i / TOWER_BANDS
+        r = tower_radius(z)
+        rings.append([bm.verts.new((r * math.cos(<span class="n">2</span> * math.pi * k / TOWER_N),
+                                    r * math.sin(<span class="n">2</span> * math.pi * k / TOWER_N), z))
+                      <span class="k">for</span> k <span class="k">in</span> range(TOWER_N)])
+    <span class="k">for</span> i <span class="k">in</span> range(TOWER_BANDS):
+        lo, hi = rings[i], rings[i + <span class="n">1</span>]
+        <span class="k">for</span> k <span class="k">in</span> range(TOWER_N):
+            f = bm.faces.new((lo[k], lo[(k + <span class="n">1</span>) % TOWER_N],
+                              hi[(k + <span class="n">1</span>) % TOWER_N], hi[k]))
+            f.material_index = RED <span class="k">if</span> i % <span class="n">2</span> == <span class="n">0</span> <span class="k">else</span> WHITE
+    bm.faces.new(list(reversed(rings[<span class="n">0</span>]))).material_index = WHITE
+    bm.faces.new(rings[-<span class="n">1</span>]).material_index = IRON
+
+
+<span class="k">def</span> _on_tower(az, z, depth):
+    <span class="s">&quot;&quot;&quot;Placement matrix for a fixture set into the tower wall at azimuth az.&quot;&quot;&quot;</span>
+    r = tower_radius(z) - depth * <span class="n">0.35</span>
+    <span class="k">return</span> Vector((r * math.cos(az), r * math.sin(az), z)), az
+
+
+<span class="k">def</span> _lantern(bm, z_top):
+    <span class="s">&quot;&quot;&quot;Gallery deck, railing, lantern room with mullions, roof and vent ball.&quot;&quot;&quot;</span>
+    deck_z1 = z_top + <span class="n">0.07</span>
+    _cyl(bm, IRON, <span class="n">0.46</span>, <span class="n">0.46</span>, z_top, deck_z1, <span class="n">32</span>)
+    <span class="c"># railing: posts + top rail</span>
+    rail_r, post_h = <span class="n">0.43</span>, <span class="n">0.19</span>
+    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">18</span>):
+        a = <span class="n">2</span> * math.pi * k / <span class="n">18</span>
+        _cyl(bm, IRON, <span class="n">0.011</span>, <span class="n">0.011</span>, deck_z1, deck_z1 + post_h, <span class="n">6</span>,
+             rail_r * math.cos(a), rail_r * math.sin(a))
+    _cyl(bm, IRON, rail_r + <span class="n">0.018</span>, rail_r + <span class="n">0.018</span>, deck_z1 + post_h - <span class="n">0.02</span>,
+         deck_z1 + post_h + <span class="n">0.005</span>, <span class="n">32</span>)
+    <span class="c"># lantern base, glass, mullions</span>
+    base_z1 = deck_z1 + <span class="n">0.09</span>
+    _cyl(bm, RED, <span class="n">0.26</span>, <span class="n">0.25</span>, deck_z1, base_z1, <span class="n">8</span>, rot=math.pi / <span class="n">8</span>)
+    glass_z1 = base_z1 + <span class="n">0.36</span>
+    _cyl(bm, GLOW, <span class="n">0.215</span>, <span class="n">0.215</span>, base_z1, glass_z1, <span class="n">8</span>, rot=math.pi / <span class="n">8</span>)
+    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">8</span>):
+        a = <span class="n">2</span> * math.pi * k / <span class="n">8</span>
+        r = <span class="n">0.215</span> / math.cos(math.pi / <span class="n">8</span>) * <span class="n">0.99</span>
+        _box(bm, IRON, (r * math.cos(a), r * math.sin(a), (base_z1 + glass_z1) / <span class="n">2</span>),
+             (<span class="n">0.03</span>, <span class="n">0.03</span>, glass_z1 - base_z1), a)
+    <span class="c"># roof: eaves ring, cone, vent ball</span>
+    _cyl(bm, IRON, <span class="n">0.29</span>, <span class="n">0.29</span>, glass_z1, glass_z1 + <span class="n">0.035</span>, <span class="n">8</span>, rot=math.pi / <span class="n">8</span>)
+    roof_z1 = glass_z1 + <span class="n">0.035</span> + <span class="n">0.27</span>
+    _cyl(bm, RED, <span class="n">0.30</span>, <span class="n">0.02</span>, glass_z1 + <span class="n">0.035</span>, roof_z1, <span class="n">8</span>, rot=math.pi / <span class="n">8</span>)
+    res = bmesh.ops.create_uvsphere(
+        bm, u_segments=<span class="n">12</span>, v_segments=<span class="n">8</span>, radius=<span class="n">0.055</span>,
+        matrix=Matrix.Translation((<span class="n">0.0</span>, <span class="n">0.0</span>, roof_z1 + <span class="n">0.03</span>)))
+    _tag(bm, res[<span class="s">&quot;verts&quot;</span>], IRON)
+    _cyl(bm, IRON, <span class="n">0.008</span>, <span class="n">0.008</span>, roof_z1 + <span class="n">0.07</span>, roof_z1 + <span class="n">0.2</span>, <span class="n">6</span>)
+
+
+<span class="k">def</span> _rock(bm, rng, center, scale, rot):
+    res = bmesh.ops.create_icosphere(bm, subdivisions=<span class="n">1</span>, radius=<span class="n">1.0</span>)
+    <span class="k">for</span> v <span class="k">in</span> res[<span class="s">&quot;verts&quot;</span>]:
+        v.co *= <span class="n">1.0</span> + rng.uniform(-<span class="n">0.16</span>, <span class="n">0.16</span>)
+    m = (Matrix.Translation(center) @ Matrix.Rotation(rot, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>)
+         @ Matrix.Diagonal((scale[<span class="n">0</span>], scale[<span class="n">1</span>], scale[<span class="n">2</span>], <span class="n">1.0</span>)))
+    bmesh.ops.transform(bm, matrix=m, verts=res[<span class="s">&quot;verts&quot;</span>])
+    _tag(bm, res[<span class="s">&quot;verts&quot;</span>], ROCK)
+
+
+<span class="k">def</span> _wave(bm, cx, cy, r, a0, span, steps=<span class="n">12</span>, width=<span class="n">0.11</span>, lift=<span class="n">0.025</span>):
+    <span class="s">&quot;&quot;&quot;A stylised wave crest: a thin curved bar lying on the sea, tapering
+    to points at both ends — the comic shorthand for a wave.&quot;&quot;&quot;</span>
+    rings = []
+    <span class="k">for</span> i <span class="k">in</span> range(steps + <span class="n">1</span>):
+        s = i / steps
+        a = a0 + span * s
+        w = width * max(<span class="n">0.08</span>, math.sin(math.pi * s))
+        d = Vector((math.cos(a), math.sin(a), <span class="n">0.0</span>))
+        c = Vector((cx, cy, SEA_Z)) + d * r
+        rings.append([bm.verts.new(c - d * w / <span class="n">2</span> + Vector((<span class="n">0</span>, <span class="n">0</span>, -<span class="n">0.01</span>))),
+                      bm.verts.new(c + d * w / <span class="n">2</span> + Vector((<span class="n">0</span>, <span class="n">0</span>, -<span class="n">0.01</span>))),
+                      bm.verts.new(c + d * w / <span class="n">2</span> + Vector((<span class="n">0</span>, <span class="n">0</span>, lift))),
+                      bm.verts.new(c - d * w / <span class="n">2</span> + Vector((<span class="n">0</span>, <span class="n">0</span>, lift)))])
+    <span class="k">for</span> i <span class="k">in</span> range(steps):
+        a, b = rings[i], rings[i + <span class="n">1</span>]
+        <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+            bm.faces.new((a[k], a[(k + <span class="n">1</span>) % <span class="n">4</span>], b[(k + <span class="n">1</span>) % <span class="n">4</span>], b[k])).material_index = WHITE
+    bm.faces.new(list(reversed(rings[<span class="n">0</span>]))).material_index = WHITE
+    bm.faces.new(rings[-<span class="n">1</span>]).material_index = WHITE
+
+
+<span class="k">def</span> _islet(bm):
+    rng = random.Random(<span class="n">1907</span>)
+    rocks = [
+        ((<span class="n">0.05</span>, <span class="n">0.05</span>, <span class="n">0.02</span>), (<span class="n">1.05</span>, <span class="n">0.95</span>, <span class="n">0.30</span>), <span class="n">0.2</span>),
+        ((-<span class="n">0.95</span>, <span class="n">0.30</span>, <span class="n">0.0</span>), (<span class="n">0.95</span>, <span class="n">0.70</span>, <span class="n">0.26</span>), <span class="n">0.9</span>),
+        ((<span class="n">0.78</span>, -<span class="n">0.20</span>, <span class="n">0.0</span>), (<span class="n">0.55</span>, <span class="n">0.48</span>, <span class="n">0.30</span>), <span class="n">0.5</span>),
+        ((<span class="n">0.55</span>, <span class="n">0.55</span>, <span class="n">0.0</span>), (<span class="n">0.50</span>, <span class="n">0.45</span>, <span class="n">0.36</span>), <span class="n">1.3</span>),
+        ((-<span class="n">0.40</span>, -<span class="n">0.72</span>, <span class="n">0.0</span>), (<span class="n">0.42</span>, <span class="n">0.35</span>, <span class="n">0.24</span>), <span class="n">2.1</span>),
+        ((<span class="n">1.18</span>, <span class="n">0.30</span>, <span class="n">0.0</span>), (<span class="n">0.30</span>, <span class="n">0.26</span>, <span class="n">0.22</span>), <span class="n">0.4</span>),
+        ((-<span class="n">1.55</span>, <span class="n">0.05</span>, <span class="n">0.0</span>), (<span class="n">0.34</span>, <span class="n">0.30</span>, <span class="n">0.20</span>), <span class="n">2.6</span>),
+        ((<span class="n">0.20</span>, -<span class="n">0.95</span>, <span class="n">0.0</span>), (<span class="n">0.22</span>, <span class="n">0.20</span>, <span class="n">0.14</span>), <span class="n">1.7</span>),
+    ]
+    <span class="k">for</span> c, s, r <span class="k">in</span> rocks:
+        _rock(bm, rng, c, s, r)
+    <span class="c"># diorama sea: a shallow disc the rocks break through, so Line Art&#x27;s</span>
+    <span class="c"># intersection edges ink the waterline around every rock</span>
+    _cyl(bm, SEA, <span class="n">2.05</span>, <span class="n">2.0</span>, <span class="n">0.0</span>, SEA_Z, <span class="n">48</span>)
+    <span class="k">for</span> cx, cy, r, a0, span <span class="k">in</span> ((-<span class="n">1.30</span>, -<span class="n">0.70</span>, <span class="n">0.30</span>, <span class="n">205</span>, <span class="n">115</span>),
+                                (-<span class="n">0.45</span>, -<span class="n">1.30</span>, <span class="n">0.34</span>, <span class="n">225</span>, <span class="n">110</span>),
+                                (<span class="n">0.55</span>, -<span class="n">1.30</span>, <span class="n">0.28</span>, <span class="n">250</span>, <span class="n">110</span>),
+                                (<span class="n">1.50</span>, -<span class="n">0.55</span>, <span class="n">0.26</span>, <span class="n">280</span>, <span class="n">100</span>),
+                                (<span class="n">1.35</span>, <span class="n">0.85</span>, <span class="n">0.24</span>, <span class="n">300</span>, <span class="n">100</span>),
+                                (-<span class="n">1.45</span>, <span class="n">1.00</span>, <span class="n">0.24</span>, <span class="n">180</span>, <span class="n">110</span>)):
+        _wave(bm, cx, cy, r, math.radians(a0), math.radians(span))
+    <span class="c"># stepped stone plinth the tower stands on</span>
+    _cyl(bm, STONE, <span class="n">0.60</span>, <span class="n">0.58</span>, <span class="n">0.10</span>, <span class="n">0.24</span>, <span class="n">12</span>, rot=math.pi / <span class="n">12</span>)
+    _cyl(bm, STONE, <span class="n">0.50</span>, <span class="n">0.46</span>, <span class="n">0.24</span>, TOWER_Z0 + <span class="n">0.02</span>, <span class="n">12</span>, rot=math.pi / <span class="n">12</span>)
+
+
+<span class="k">def</span> _cottage(bm):
+    <span class="s">&quot;&quot;&quot;Keeper&#x27;s cottage behind-left of the tower: walls, pitched roof with
+    overhang, chimney, door and two windows.&quot;&quot;&quot;</span>
+    cx, cy, rot = -<span class="n">1.15</span>, <span class="n">0.30</span>, math.radians(-<span class="n">14</span>)
+    w, d, h = <span class="n">0.95</span>, <span class="n">0.62</span>, <span class="n">0.46</span>
+    z0 = <span class="n">0.16</span>
+    R = Matrix.Rotation(rot, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>)
+    base = Matrix.Translation((cx, cy, <span class="n">0.0</span>)) @ R
+
+    <span class="k">def</span> local(p):
+        <span class="k">return</span> base @ Vector(p)
+
+    _box(bm, WHITE, local((<span class="n">0</span>, <span class="n">0</span>, z0 + h / <span class="n">2</span>)), (w, d, h), rot)
+    <span class="c"># pitched roof prism with overhang</span>
+    ow, od, rh = w / <span class="n">2</span> + <span class="n">0.07</span>, d / <span class="n">2</span> + <span class="n">0.08</span>, <span class="n">0.30</span>
+    zr = z0 + h
+    pts = [(-ow, -od, zr - <span class="n">0.02</span>), (ow, -od, zr - <span class="n">0.02</span>), (ow, <span class="n">0</span>, zr + rh),
+           (-ow, <span class="n">0</span>, zr + rh), (-ow, od, zr - <span class="n">0.02</span>), (ow, od, zr - <span class="n">0.02</span>)]
+    v = [bm.verts.new(local(p)) <span class="k">for</span> p <span class="k">in</span> pts]
+    faces = [(v[<span class="n">0</span>], v[<span class="n">1</span>], v[<span class="n">2</span>], v[<span class="n">3</span>]), (v[<span class="n">3</span>], v[<span class="n">2</span>], v[<span class="n">5</span>], v[<span class="n">4</span>]),
+             (v[<span class="n">0</span>], v[<span class="n">3</span>], v[<span class="n">4</span>]), (v[<span class="n">1</span>], v[<span class="n">5</span>], v[<span class="n">2</span>]), (v[<span class="n">0</span>], v[<span class="n">4</span>], v[<span class="n">5</span>], v[<span class="n">1</span>])]
+    <span class="k">for</span> f <span class="k">in</span> faces:
+        bm.faces.new(f).material_index = SLATE
+    <span class="c"># chimney</span>
+    _box(bm, STONE, local((<span class="n">0.24</span>, <span class="n">0.12</span>, zr + <span class="n">0.26</span>)), (<span class="n">0.11</span>, <span class="n">0.11</span>, <span class="n">0.36</span>), rot)
+    _box(bm, IRON, local((<span class="n">0.24</span>, <span class="n">0.12</span>, zr + <span class="n">0.45</span>)), (<span class="n">0.14</span>, <span class="n">0.14</span>, <span class="n">0.04</span>), rot)
+    <span class="c"># door + windows on the camera-facing wall (local -y)</span>
+    _box(bm, SLATE, local((<span class="n">0.20</span>, -d / <span class="n">2</span>, z0 + <span class="n">0.15</span>)), (<span class="n">0.15</span>, <span class="n">0.04</span>, <span class="n">0.30</span>), rot)
+    <span class="k">for</span> x <span class="k">in</span> (-<span class="n">0.25</span>, -<span class="n">0.02</span>):
+        _box(bm, GLOW, local((x, -d / <span class="n">2</span>, z0 + <span class="n">0.25</span>)), (<span class="n">0.12</span>, <span class="n">0.035</span>, <span class="n">0.12</span>), rot)
+
+
+<span class="k">def</span> _rowboat(bm):
+    <span class="s">&quot;&quot;&quot;A clinker-style rowboat hauled up on the rocks: an open hull lofted
+    through U-shaped sections, a thwart and a painted gunwale strip.&quot;&quot;&quot;</span>
+    L, W, D = <span class="n">1.0</span>, <span class="n">0.21</span>, <span class="n">0.14</span>
+    n_sec, n_prof = <span class="n">9</span>, <span class="n">9</span>
+    yaw = <span class="n">0.35</span>
+    <span class="c"># heeled toward the camera so the open hull and thwart read</span>
+    place = (Matrix.Translation((<span class="n">1.22</span>, -<span class="n">0.58</span>, <span class="n">0.10</span>)) @ Matrix.Rotation(yaw, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>)
+             @ Matrix.Rotation(math.radians(<span class="n">14</span>), <span class="n">4</span>, <span class="s">&quot;X&quot;</span>))
+    secs = []
+    <span class="k">for</span> i <span class="k">in</span> range(n_sec):
+        t = -<span class="n">1.0</span> + <span class="n">2.0</span> * i / (n_sec - <span class="n">1</span>)
+        half_w = W * max(<span class="n">0.04</span>, (<span class="n">1.0</span> - t * t) ** <span class="n">0.6</span>)
+        sheer = D * (<span class="n">1.0</span> + <span class="n">0.35</span> * t * t)          <span class="c"># bow and stern rise</span>
+        depth = D * (<span class="n">1.0</span> - <span class="n">0.55</span> * t * t)
+        ring = []
+        <span class="k">for</span> j <span class="k">in</span> range(n_prof):
+            a = math.pi * j / (n_prof - <span class="n">1</span>)
+            y = -half_w * math.cos(a)
+            z = sheer - (sheer - (D - depth)) * math.sin(a)
+            ring.append(bm.verts.new(place @ Vector((t * L / <span class="n">2</span>, y, z))))
+        secs.append(ring)
+    <span class="k">for</span> i <span class="k">in</span> range(n_sec - <span class="n">1</span>):
+        <span class="k">for</span> j <span class="k">in</span> range(n_prof - <span class="n">1</span>):
+            f = bm.faces.new((secs[i][j], secs[i + <span class="n">1</span>][j],
+                              secs[i + <span class="n">1</span>][j + <span class="n">1</span>], secs[i][j + <span class="n">1</span>]))
+            f.material_index = RED <span class="k">if</span> j <span class="k">in</span> (<span class="n">0</span>, n_prof - <span class="n">2</span>) <span class="k">else</span> SLATE
+    <span class="c"># thwart (seat) across the middle</span>
+    c = place @ Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, D * <span class="n">0.78</span>))
+    _box(bm, STONE, c, (<span class="n">0.08</span>, <span class="n">2</span> * W * <span class="n">0.95</span>, <span class="n">0.025</span>), yaw)
+
+
+<span class="k">def</span> build_lighthouse(sc):
+    me = bpy.data.meshes.new(<span class="s">&quot;Lighthouse&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
-        <span class="c"># Hexagonal bipyramid: one equator ring, an apex above and below.</span>
-        <span class="c"># (Two overlapped open cones, the earlier build, crossed into an</span>
-        <span class="c"># hourglass with open ends and an inner spike.)</span>
-        ring = [bm.verts.new((CRYSTAL_R * math.cos(math.pi * k / <span class="n">3</span>),
-                              CRYSTAL_R * math.sin(math.pi * k / <span class="n">3</span>), <span class="n">0.0</span>))
-                <span class="k">for</span> k <span class="k">in</span> range(<span class="n">6</span>)]
-        <span class="k">for</span> apex_z <span class="k">in</span> (CRYSTAL_APEX, -CRYSTAL_APEX):
-            apex = bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, apex_z))
-            <span class="k">for</span> k <span class="k">in</span> range(<span class="n">6</span>):
-                bm.faces.new((ring[k], ring[(k + <span class="n">1</span>) % <span class="n">6</span>], apex))
-        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
-        bmesh.ops.scale(bm, vec=(CRYSTAL_SCALE,) * <span class="n">3</span>, verts=bm.verts)
+        _islet(bm)
+        _tower(bm)
+        <span class="c"># door and two windows set into the tower on the camera side</span>
+        <span class="k">for</span> az, z, size, mat <span class="k">in</span> ((-<span class="n">1.02</span>, TOWER_Z0 + <span class="n">0.17</span>, (<span class="n">0.08</span>, <span class="n">0.17</span>, <span class="n">0.32</span>), SLATE),
+                                 (-<span class="n">0.80</span>, TOWER_Z0 + <span class="n">0.95</span>, (<span class="n">0.06</span>, <span class="n">0.11</span>, <span class="n">0.17</span>), GLOW),
+                                 (-<span class="n">1.25</span>, TOWER_Z0 + <span class="n">1.62</span>, (<span class="n">0.06</span>, <span class="n">0.10</span>, <span class="n">0.15</span>), GLOW)):
+            c, rot = _on_tower(az, z, size[<span class="n">0</span>])
+            _box(bm, mat, c, size, rot)
+        _lantern(bm, TOWER_Z0 + TOWER_H)
+        _cottage(bm)
+        _rowboat(bm)
+        bm.normal_update()
         bm.to_mesh(me)
     <span class="k">finally</span>:
         bm.free()
     <span class="k">for</span> p <span class="k">in</span> me.polygons:
         p.use_smooth = <span class="k">False</span>
-    mat = bpy.data.materials.new(<span class="s">&quot;CrystalMat&quot;</span>)
-    mat.use_nodes = <span class="k">True</span>
-    b = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    b.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.12</span>, <span class="n">0.38</span>, <span class="n">0.48</span>, <span class="n">1.0</span>)
-    b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.42</span>
-    b.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.2</span>
-    emit = b.inputs.get(<span class="s">&quot;Emission Color&quot;</span>) <span class="k">or</span> b.inputs.get(<span class="s">&quot;Emission&quot;</span>)
-    <span class="k">if</span> emit <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
-        emit.default_value = (<span class="n">0.05</span>, <span class="n">0.2</span>, <span class="n">0.28</span>, <span class="n">1.0</span>)
-        b.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.15</span>
-    me.materials.append(mat)
-    ob = bpy.data.objects.new(<span class="s">&quot;Crystal&quot;</span>, me)
-    ob.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.15</span>)
-    ob.rotation_euler = (math.radians(<span class="n">8</span>), math.radians(<span class="n">12</span>), math.radians(<span class="n">22</span>))
+    <span class="k">for</span> name, col <span class="k">in</span> ((<span class="s">&quot;Lighthouse.Red&quot;</span>, (<span class="n">0.72</span>, <span class="n">0.07</span>, <span class="n">0.05</span>, <span class="n">1.0</span>)),
+                      (<span class="s">&quot;Lighthouse.White&quot;</span>, (<span class="n">0.93</span>, <span class="n">0.90</span>, <span class="n">0.82</span>, <span class="n">1.0</span>)),
+                      (<span class="s">&quot;Lighthouse.Iron&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.12</span>, <span class="n">0.15</span>, <span class="n">1.0</span>)),
+                      (<span class="k">None</span>, <span class="k">None</span>),
+                      (<span class="s">&quot;Lighthouse.Rock&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.15</span>, <span class="n">0.24</span>, <span class="n">1.0</span>)),
+                      (<span class="s">&quot;Lighthouse.Stone&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.55</span>, <span class="n">0.44</span>, <span class="n">1.0</span>)),
+                      (<span class="s">&quot;Lighthouse.Slate&quot;</span>, (<span class="n">0.05</span>, <span class="n">0.30</span>, <span class="n">0.34</span>, <span class="n">1.0</span>)),
+                      (<span class="s">&quot;Lighthouse.Sea&quot;</span>, (<span class="n">0.02</span>, <span class="n">0.14</span>, <span class="n">0.32</span>, <span class="n">1.0</span>))):
+        <span class="k">if</span> name <span class="k">is</span> <span class="k">None</span>:
+            me.materials.append(glow_material(<span class="s">&quot;Lighthouse.Lamp&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.62</span>, <span class="n">0.14</span>, <span class="n">1.0</span>), <span class="n">1.0</span>))
+        <span class="k">else</span>:
+            me.materials.append(toon_material(name, col))
+    ob = bpy.data.objects.new(<span class="s">&quot;Lighthouse&quot;</span>, me)
     sc.collection.objects.link(ob)
     <span class="k">return</span> ob
 
 
+<span class="c"># --- the Line Art object ------------------------------------------------------</span>
+
+<span class="k">def</span> configure_lineart(mod, source, gp_mat):
+    mod.source_type = <span class="s">&quot;OBJECT&quot;</span>
+    mod.source_object = source
+    mod.use_contour = <span class="k">True</span>
+    mod.use_crease = <span class="k">True</span>
+    <span class="k">if</span> hasattr(mod, <span class="s">&quot;use_material&quot;</span>):
+        mod.use_material = <span class="k">True</span>          <span class="c"># ink between the red and white bands</span>
+    <span class="k">if</span> hasattr(mod, <span class="s">&quot;use_intersection&quot;</span>):
+        mod.use_intersection = <span class="k">True</span>      <span class="c"># ink where fixtures meet the tower</span>
+    mod.crease_threshold = math.radians(<span class="n">130</span>)
+    mod.target_layer = <span class="s">&quot;Ink&quot;</span>
+    mod.target_material = gp_mat
+    <span class="c"># Width: radius is portable; thickness is 4.5-only</span>
+    <span class="k">if</span> hasattr(mod, <span class="s">&quot;thickness&quot;</span>):
+        mod.thickness = THICKNESS_45
+    mod.radius = RADIUS
+
+
 <span class="k">def</span> build_lineart(sc, source):
     gp = gp_data_new(<span class="s">&quot;LineArtGP&quot;</span>)
     ob = bpy.data.objects.new(<span class="s">&quot;LineArt&quot;</span>, gp)
     sc.collection.objects.link(ob)
 
-    layer = gp.layers.new(<span class="s">&quot;Contours&quot;</span>)
+    layer = gp.layers.new(<span class="s">&quot;Ink&quot;</span>)
     layer.frames.new(<span class="n">1</span>)
 
-    mat = bpy.data.materials.new(<span class="s">&quot;NeonContour&quot;</span>)
+    mat = bpy.data.materials.new(<span class="s">&quot;Ink&quot;</span>)
     bpy.data.materials.create_gpencil_data(mat)
-    <span class="c"># Neon cyan ink</span>
     gp_set = mat.grease_pencil
     <span class="k">if</span> hasattr(gp_set, <span class="s">&quot;color&quot;</span>):
-        gp_set.color = (<span class="n">0.05</span>, <span class="n">0.95</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
+        gp_set.color = INK
     gp.materials.append(mat)
 
     mod = ob.modifiers.new(<span class="s">&quot;LineArt&quot;</span>, <span class="s">&quot;LINEART&quot;</span>)
-    mod.source_type = <span class="s">&quot;OBJECT&quot;</span>
-    mod.source_object = source
-    mod.use_contour = <span class="k">True</span>
-    mod.use_crease = <span class="k">True</span>
-    <span class="k">if</span> hasattr(mod, <span class="s">&quot;use_material&quot;</span>):
-        mod.use_material = <span class="k">False</span>
-    mod.target_layer = <span class="s">&quot;Contours&quot;</span>
-    mod.target_material = mat
-    <span class="c"># Width: radius is portable; thickness is 4.5-only</span>
-    <span class="k">if</span> hasattr(mod, <span class="s">&quot;thickness&quot;</span>):
-        mod.thickness = <span class="n">45</span>
-    mod.radius = RADIUS
+    configure_lineart(mod, source, mat)
 
-    <span class="c"># Disable lights on the GP layer so neon stays vivid</span>
+    <span class="c"># Ink is flat black: keep scene lights off the GP layer</span>
     <span class="k">if</span> hasattr(layer, <span class="s">&quot;use_lights&quot;</span>):
         layer.use_lights = <span class="k">False</span>
     <span class="k">return</span> ob, mod, gp
 
 
 <span class="k">def</span> setup_camera(sc):
+    <span class="s">&quot;&quot;&quot;One camera for the check and the still: Line Art is view-dependent, so
+    the counts the check gates are the strokes the still draws.&quot;&quot;&quot;</span>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">3.95</span>, -<span class="n">4.9</span>, <span class="n">2.62</span>)
+    cam.location = (<span class="n">5.78</span>, -<span class="n">10.25</span>, <span class="n">3.5</span>)
     sc.collection.objects.link(cam)
     sc.camera = cam
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.15</span>)
+    aim.location = (-<span class="n">0.12</span>, <span class="n">0.0</span>, <span class="n">1.52</span>)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     tr.target = aim
@@ -571,64 +856,49 @@ <h2>Source</h2>
         <span class="k">return</span> <span class="n">6</span>
     print(<span class="s">&quot;nosource_ok strokes=0 points=0&quot;</span>)
 
-    <span class="c"># Failure mode B: rebuild modifier with contour+crease off → zero strokes</span>
+    <span class="c"># Failure mode B: rebuild modifier with every edge type off → zero strokes</span>
+    gp_mat = la_ob.data.materials[<span class="n">0</span>]
     <span class="k">while</span> la_ob.modifiers:
         la_ob.modifiers.remove(la_ob.modifiers[<span class="n">0</span>])
     mod_off = la_ob.modifiers.new(<span class="s">&quot;LineArtOff&quot;</span>, <span class="s">&quot;LINEART&quot;</span>)
-    mod_off.source_type = <span class="s">&quot;OBJECT&quot;</span>
-    mod_off.source_object = source
-    mod_off.use_contour = <span class="k">False</span>
-    mod_off.use_crease = <span class="k">False</span>
-    <span class="k">if</span> hasattr(mod_off, <span class="s">&quot;use_loose&quot;</span>):
-        mod_off.use_loose = <span class="k">False</span>
-    <span class="k">if</span> hasattr(mod_off, <span class="s">&quot;use_intersection&quot;</span>):
-        mod_off.use_intersection = <span class="k">False</span>
-    <span class="k">if</span> hasattr(mod_off, <span class="s">&quot;use_material&quot;</span>):
-        mod_off.use_material = <span class="k">False</span>
-    <span class="k">if</span> hasattr(mod_off, <span class="s">&quot;use_edge_mark&quot;</span>):
-        mod_off.use_edge_mark = <span class="k">False</span>
-    mod_off.target_layer = <span class="s">&quot;Contours&quot;</span>
-    gp_mat = la_ob.data.materials[<span class="n">0</span>]
-    mod_off.target_material = gp_mat
-    mod_off.radius = RADIUS
+    configure_lineart(mod_off, source, gp_mat)
+    <span class="k">for</span> flag <span class="k">in</span> (<span class="s">&quot;use_contour&quot;</span>, <span class="s">&quot;use_crease&quot;</span>, <span class="s">&quot;use_loose&quot;</span>, <span class="s">&quot;use_intersection&quot;</span>,
+                 <span class="s">&quot;use_material&quot;</span>, <span class="s">&quot;use_edge_mark&quot;</span>):
+        <span class="k">if</span> hasattr(mod_off, flag):
+            setattr(mod_off, flag, <span class="k">False</span>)
     z_s, z_p = eval_stroke_counts(la_ob)
     <span class="k">if</span> z_s != <span class="n">0</span> <span class="k">or</span> z_p != <span class="n">0</span>:
         print(
-            <span class="s">f&quot;</span><span class="s">ERROR: contour+crease off still produced strokes=</span>{z_s}<span class="s"> points=</span>{z_p}<span class="s">&quot;</span>,
+            <span class="s">f&quot;</span><span class="s">ERROR: every edge type off still produced strokes=</span>{z_s}<span class="s"> points=</span>{z_p}<span class="s">&quot;</span>,
             file=sys.stderr,
         )
         <span class="k">return</span> <span class="n">7</span>
     print(<span class="s">&quot;noflags_ok strokes=0 points=0&quot;</span>)
 
-    <span class="c"># Restore working Line Art modifier for optional still</span>
+    <span class="c"># Restore the working Line Art modifier for the optional still</span>
     <span class="k">while</span> la_ob.modifiers:
         la_ob.modifiers.remove(la_ob.modifiers[<span class="n">0</span>])
     mod_on = la_ob.modifiers.new(<span class="s">&quot;LineArt&quot;</span>, <span class="s">&quot;LINEART&quot;</span>)
-    mod_on.source_type = <span class="s">&quot;OBJECT&quot;</span>
-    mod_on.source_object = source
-    mod_on.use_contour = <span class="k">True</span>
-    mod_on.use_crease = <span class="k">True</span>
-    mod_on.target_layer = <span class="s">&quot;Contours&quot;</span>
-    mod_on.target_material = gp_mat
-    <span class="k">if</span> hasattr(mod_on, <span class="s">&quot;thickness&quot;</span>):
-        mod_on.thickness = <span class="n">45</span>
-    mod_on.radius = RADIUS
+    configure_lineart(mod_on, source, gp_mat)
     n_s2, n_p2 = eval_stroke_counts(la_ob)
-    <span class="k">if</span> n_s2 &lt; STROKE_MIN <span class="k">or</span> n_p2 &lt; POINT_MIN:
+    <span class="k">if</span> (n_s2, n_p2) != (n_s, n_p):
         print(
             <span class="s">f&quot;</span><span class="s">ERROR: contours did not recover after restore: </span><span class="s">&quot;</span>
-            <span class="s">f&quot;</span><span class="s">strokes=</span>{n_s2}<span class="s"> points=</span>{n_p2}<span class="s">&quot;</span>,
+            <span class="s">f&quot;</span><span class="s">strokes=</span>{n_s2}<span class="s"> points=</span>{n_p2}<span class="s"> (first pass </span>{n_s}<span class="s">/</span>{n_p}<span class="s">)</span><span class="s">&quot;</span>,
             file=sys.stderr,
         )
         <span class="k">return</span> <span class="n">7</span>
     print(
-        <span class="s">f&quot;</span><span class="s">restored_ok strokes=</span>{n_s2}<span class="s"> points=</span>{n_p2}<span class="s"> radius=</span>{mod_on.radius}<span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">restored_ok strokes=</span>{n_s2}<span class="s"> points=</span>{n_p2}<span class="s"> radius=</span>{mod_on.radius:<span class="s">.4f</span>}<span class="s">&quot;</span>
     )
     <span class="k">return</span> <span class="n">0</span>
 
 
+<span class="c"># --- render staging (not part of the check) -----------------------------------</span>
+
 <span class="k">def</span> build_studio(sc):
-    <span class="c"># Default-stage-ish dark floor + wall — Line Art neon is the proof</span>
+    <span class="s">&quot;&quot;&quot;Default stage floor, wall and world; lighting re-weighted for toon
+    shading (see the README&#x27;s Stage deviation line).&quot;&quot;&quot;</span>
     <span class="k">def</span> plane(name, size, loc, rot):
         me = bpy.data.meshes.new(name)
         bm = bmesh.new()
@@ -650,7 +920,7 @@ <h2>Source</h2>
         <span class="k">return</span> ob
 
     plane(<span class="s">&quot;Floor&quot;</span>, <span class="n">30.0</span>, (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>), (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>))
-    plane(<span class="s">&quot;Wall&quot;</span>, <span class="n">30.0</span>, (<span class="n">0</span>, <span class="n">9</span>, <span class="n">0</span>), (math.radians(<span class="n">90</span>), <span class="n">0</span>, <span class="n">0</span>))
+    plane(<span class="s">&quot;Wall&quot;</span>, <span class="n">30.0</span>, (<span class="n">0</span>, <span class="n">8</span>, <span class="n">0</span>), (math.radians(<span class="n">90</span>), <span class="n">0</span>, <span class="n">0</span>))
 
     world = bpy.data.worlds.new(<span class="s">&quot;World&quot;</span>)
     world.use_nodes = <span class="k">True</span>
@@ -669,59 +939,12 @@ <h2>Source</h2>
         ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
         sc.collection.objects.link(ob)
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4</span>, -<span class="n">5</span>, <span class="n">6</span>), <span class="n">420.0</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">35</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4</span>, -<span class="n">5</span>, <span class="n">6</span>), <span class="n">520.0</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">35</span>))
     light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">90.0</span>, <span class="n">9.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), (<span class="n">65</span>, <span class="n">0</span>, <span class="n">50</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>), <span class="n">280.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</span>))
-
-
-<span class="k">def</span> build_mount(sc, crystal):
-    <span class="s">&quot;&quot;&quot;Render staging only: a two-tier hex plinth seated on the floor whose
-    top swallows the crystal&#x27;s lower tip, so the crystal is set in a mount
-    instead of hovering. Derived from the evaluated crystal; the crystal
-    itself (and so every Line Art count above) is untouched.&quot;&quot;&quot;</span>
-    bpy.context.view_layer.update()
-    mw = crystal.matrix_world
-    tip = min((mw @ v.co <span class="k">for</span> v <span class="k">in</span> crystal.data.vertices), key=<span class="k">lambda</span> p: p.z)
-    top = tip.z + MOUNT_SOCKET
-    me = bpy.data.meshes.new(<span class="s">&quot;Mount&quot;</span>)
-    bm = bmesh.new()
-    <span class="k">try</span>:
-        <span class="k">for</span> r, z0, z1 <span class="k">in</span> ((MOUNT_R, -<span class="n">0.003</span>, MOUNT_BASE_H),
-                          (MOUNT_R * <span class="n">0.72</span>, MOUNT_BASE_H - <span class="n">0.003</span>, top)):
-            bmesh.ops.create_cone(
-                bm, cap_ends=<span class="k">True</span>, segments=<span class="n">6</span>, radius1=r, radius2=r,
-                depth=z1 - z0,
-                matrix=Matrix.Translation((tip.x, tip.y, (z0 + z1) / <span class="n">2</span>))
-                @ Matrix.Rotation(crystal.rotation_euler.z, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>),
-            )
-        bm.to_mesh(me)
-    <span class="k">finally</span>:
-        bm.free()
-    <span class="k">for</span> p <span class="k">in</span> me.polygons:
-        p.use_smooth = <span class="k">False</span>
-    mat = bpy.data.materials.new(<span class="s">&quot;MountStone&quot;</span>)
-    mat.use_nodes = <span class="k">True</span>
-    b = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    b.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.06</span>, <span class="n">0.062</span>, <span class="n">0.07</span>, <span class="n">1.0</span>)
-    b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</span>
-    me.materials.append(mat)
-    ob = bpy.data.objects.new(<span class="s">&quot;Mount&quot;</span>, me)
-    sc.collection.objects.link(ob)
-    <span class="k">return</span> ob
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.8</span>, <span class="n">4.6</span>, <span class="n">4.2</span>), <span class="n">420.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">62</span>, <span class="n">0</span>, <span class="n">190</span>))
 
 
 <span class="k">def</span> render_still(sc, path, engine):
-    source = sc.objects[<span class="s">&quot;Crystal&quot;</span>]
-    mount = build_mount(sc, source)
-    <span class="c"># reframe for the still only (the check ran from the setup_camera view):</span>
-    <span class="c"># lower the aim so the mount&#x27;s foot clears the bottom edge, and dolly in</span>
-    <span class="c"># along the same bearing so the crystal still fills the frame</span>
-    aim = sc.objects[<span class="s">&quot;Aim&quot;</span>]
-    cam = sc.camera
-    bearing = cam.location - aim.location
-    aim.location.z = STILL_AIM_Z
-    cam.location = aim.location + bearing * STILL_DOLLY
-    bpy.context.view_layer.update()
     sc.render.engine = <span class="s">&quot;CYCLES&quot;</span> <span class="k">if</span> engine == <span class="s">&quot;cycles&quot;</span> <span class="k">else</span> eevee_engine_id()
     <span class="k">if</span> engine == <span class="s">&quot;cycles&quot;</span>:
         sc.cycles.device = <span class="s">&quot;CPU&quot;</span>
@@ -736,21 +959,16 @@ <h2>Source</h2>
     sc.render.resolution_y = <span class="n">720</span>
     sc.render.image_settings.file_format = <span class="s">&quot;PNG&quot;</span>
     sc.render.filepath = path
+    <span class="c"># Standard, not AgX: the toon tones are emitted colours and must land</span>
+    <span class="c"># on screen as authored, not desaturated toward pastel</span>
     sc.view_settings.view_transform = <span class="s">&quot;Standard&quot;</span>
     <span class="c"># Layer 1 framing gate (silhouette matte) — exit 10 on violation, before</span>
-    <span class="c"># the beauty render so a defective composition ships no artifact. The two</span>
-    <span class="c"># hero subjects are the crystal source mesh and the GP stroke object; the</span>
-    <span class="c"># mount is staging, so it must clear the edges but does not count as fill.</span>
+    <span class="c"># the beauty render so a defective composition ships no artifact. The</span>
+    <span class="c"># hero is the source mesh plus the GP ink object it evaluates into.</span>
     stage = [o <span class="k">for</span> o <span class="k">in</span> sc.objects <span class="k">if</span> o.name <span class="k">in</span> {<span class="s">&quot;Floor&quot;</span>, <span class="s">&quot;Wall&quot;</span>}]
-    hero = [
-        o <span class="k">for</span> o <span class="k">in</span> sc.objects
-        <span class="k">if</span> o.type <span class="k">in</span> {<span class="s">&quot;MESH&quot;</span>, <span class="s">&quot;GREASEPENCIL&quot;</span>} <span class="k">and</span> o <span class="k">not</span> <span class="k">in</span> stage <span class="k">and</span> o != mount
-    ]
+    hero = [sc.objects[<span class="s">&quot;Lighthouse&quot;</span>], sc.objects[<span class="s">&quot;LineArt&quot;</span>]]
     fcode = gallery_framing.check_framing(
-        sc, sc.camera,
-        hero=hero,
-        elements=hero + [mount],
-        stage=stage,
+        sc, sc.camera, hero=hero, elements=hero, stage=stage,
     )
     <span class="k">if</span> fcode:
         <span class="k">return</span> fcode
@@ -765,10 +983,10 @@ <h2>Source</h2>
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     sc = bpy.context.scene
     build_studio(sc)
-    crystal = build_crystal(sc)
-    la_ob, mod, gp = build_lineart(sc, crystal)
+    source = build_lighthouse(sc)
     setup_camera(sc)
-    <span class="k">return</span> sc, crystal, la_ob, mod
+    la_ob, mod, gp = build_lineart(sc, source)
+    <span class="k">return</span> sc, source, la_ob, mod
 
 
 <span class="k">def</span> main():
@@ -779,7 +997,7 @@ <h2>Source</h2>
         <span class="s">&quot;--engine&quot;</span>,
         default=<span class="s">&quot;eevee&quot;</span>,
         choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>),
-        help=<span class="s">&quot;render engine for --output&quot;</span>,
+        help=<span class="s">&quot;render engine for --output (the toon shading is EEVEE-only)&quot;</span>,
     )
     p.add_argument(
         <span class="s">&quot;--no-contour&quot;</span>,
@@ -789,11 +1007,11 @@ <h2>Source</h2>
     args = p.parse_args(argv)
 
     print(<span class="s">f&quot;</span><span class="s">binary version: </span>{bpy.app.version}<span class="s"> (</span>{bpy.app.version_string}<span class="s">)</span><span class="s">&quot;</span>)
-    sc, crystal, la_ob, mod = build_scene()
+    sc, source, la_ob, mod = build_scene()
     <span class="k">if</span> args.no_contour:
         mod.use_contour = <span class="k">False</span>
 
-    code = check(sc, crystal, la_ob, mod)
+    code = check(sc, source, la_ob, mod)
     <span class="k">if</span> code:
         <span class="k">return</span> code
 
@@ -821,7 +1039,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/gp-lineart-contour-hero.webp" alt="A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes." />
+    <img src="../assets/gp-lineart-contour-hero.webp" alt="A red-and-white lighthouse on a rocky islet with a keeper&#x27;s cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index a24bf2f5..33423daf 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -728,12 +728,12 @@ <h2><a href="sky-texture-sun-elevation/">sky-texture-sun-elevation</a></h2>
       </article>
       <article class="card" data-tags="grease-pencil line-art modifiers">
         <a class="card-media" href="gp-lineart-contour/" tabindex="-1" aria-hidden="true">
-          <img src="assets/gp-lineart-contour-hero.webp" alt="A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes." loading="lazy" decoding="async" />
+          <img src="assets/gp-lineart-contour-hero.webp" alt="A red-and-white lighthouse on a rocky islet with a keeper&#x27;s cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="gp-lineart-contour/">gp-lineart-contour</a></h2>
-          <p class="teaches">Grease Pencil LINEART modifier contours via the depsgraph on a faceted crystal. source_object is load-bearing (clear yields 0 strokes); contour+crease off yields 0; restore recovers 2 strokes / 12 points on 4.5.11, 5.1.2 and 5.2.1. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> AI code still sets LINEART.thickness on 5.1 (AttributeError) or hand-draws strokes / enables Freestyle instead of modifiers.new(..., &#x27;LINEART&#x27;). Clearing source_object or leaving contour+crease off silently yields an empty drawing — the check proves both failure modes and recovery.</p>
+          <p class="teaches">Grease Pencil LINEART modifier ink via the depsgraph on a cel-shaded lighthouse diorama. source_object is load-bearing (clear yields 0 strokes); every edge type off yields 0; the drawing is 255 strokes / 1393 points on 4.5.11, 5.1.2 and 5.2.1, gated above the count left when any one of contour, crease, material-border or intersection edges is dropped. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> AI code still sets LINEART.thickness on 5.1 (AttributeError) or hand-draws strokes / enables Freestyle instead of modifiers.new(..., &#x27;LINEART&#x27;). Clearing source_object or leaving every edge type off silently yields an empty drawing — the check proves both failure modes and recovery.</p>
           <a class="card-link" href="gp-lineart-contour/">View example<span class="sr-only"> gp-lineart-contour</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/examples/gallery.json b/examples/gallery.json
index 859f6490..aef0e07e 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -473,9 +473,9 @@
     {
       "name": "gp-lineart-contour",
       "dir": "examples/gp-lineart-contour",
-      "teaches": "Grease Pencil LINEART modifier contours via the depsgraph on a faceted crystal. source_object is load-bearing (clear yields 0 strokes); contour+crease off yields 0; restore recovers 2 strokes / 12 points on 4.5.11, 5.1.2 and 5.2.1. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius.",
-      "alt": "A translucent teal crystal, a six-sided double pyramid set tip-down in a dark hex mount, its edges traced by cyan Line Art contour strokes.",
-      "witnessesFix": "AI code still sets LINEART.thickness on 5.1 (AttributeError) or hand-draws strokes / enables Freestyle instead of modifiers.new(..., 'LINEART'). Clearing source_object or leaving contour+crease off silently yields an empty drawing — the check proves both failure modes and recovery.",
+      "teaches": "Grease Pencil LINEART modifier ink via the depsgraph on a cel-shaded lighthouse diorama. source_object is load-bearing (clear yields 0 strokes); every edge type off yields 0; the drawing is 255 strokes / 1393 points on 4.5.11, 5.1.2 and 5.2.1, gated above the count left when any one of contour, crease, material-border or intersection edges is dropped. Stroke width: thickness exists on 4.5, AttributeError on 5.1 — portable path is radius.",
+      "alt": "A red-and-white lighthouse on a rocky islet with a keeper's cottage and a rowboat, on a round blue sea with white wave crests, drawn like a comic panel in bold black Line Art ink.",
+      "witnessesFix": "AI code still sets LINEART.thickness on 5.1 (AttributeError) or hand-draws strokes / enables Freestyle instead of modifiers.new(..., 'LINEART'). Clearing source_object or leaving every edge type off silently yields an empty drawing — the check proves both failure modes and recovery.",
       "hero": "docs/gallery/assets/gp-lineart-contour-hero.webp",
       "preview": "examples/gp-lineart-contour/preview.webp",
       "tags": [
diff --git a/examples/gp-lineart-contour/README.md b/examples/gp-lineart-contour/README.md
index 6d73806d..0c93ff7a 100644
--- a/examples/gp-lineart-contour/README.md
+++ b/examples/gp-lineart-contour/README.md
@@ -1,42 +1,56 @@
 # GP Line Art Contour
 
-A runnable example that builds a faceted crystal, attaches a Grease Pencil
-`LINEART` modifier with `source_type='OBJECT'`, and proves the contour contract
-through the depsgraph — including the 4.5 → 5.1 stroke-width trap.
+A runnable example that builds a lighthouse on a rocky islet — tower, gallery,
+lantern room, keeper's cottage, a hauled-up rowboat and a diorama sea — as one
+cel-shaded mesh, attaches a Grease Pencil `LINEART` modifier with
+`source_type='OBJECT'`, and proves the contour contract through the depsgraph,
+including the 4.5 → 5.1 stroke-width trap.
 
 **What it witnesses:** the Line Art modifier contract AI-generated NPR code most
 often gets wrong.
 
 - **Contours are a modifier, not Freestyle and not hand-authored strokes.**
   `modifiers.new(..., 'LINEART')` on a GPv3 object, with `target_layer` /
-  `target_material` set, evaluates silhouette edges into drawing strokes.
+  `target_material` set, evaluates the source mesh's edges into drawing strokes.
 - **`source_object` is load-bearing.** Clearing it yields **0** evaluated
-  strokes (proven in the same check pass). Restoring it recovers the contour.
-- **Edge-type flags matter.** A freshly added LINEART with `use_contour` and
-  `use_crease` both off emits **0** strokes; turning contour (+ crease) back on
-  recovers the silhouette (**2** strokes / **12** points on every binary for
-  this crystal + camera; Line Art chains the bipyramid's edges into long
-  strokes, so the count is low and the gates are lower bounds).
-- **Stroke width renamed.** 4.5 exposes both `thickness` (legacy px, set to 45
+  strokes (proven in the same check pass). Restoring it recovers the drawing.
+- **Edge-type flags matter.** A freshly added LINEART with every edge type off
+  (contour, crease, material borders, intersections, loose, edge marks) emits
+  **0** strokes. The configured modifier draws **255** strokes / **1393**
+  points on every binary, and the gates (**≥ 240** strokes, **≥ 1320** points)
+  sit above the count left when any *one* edge type is dropped — contour 234
+  strokes, crease 171 / 1099, material borders 247 / 1305, intersections
+  179 / 921 — so each is load-bearing: the band borders on the tower are
+  material-border ink, the waterline around each rock is intersection ink.
+  Rebuilding the modifier must recover exactly the first pass's counts.
+- **Stroke width renamed.** 4.5 exposes both `thickness` (legacy px, set to 22
   here) and `radius`; 5.1 removes `thickness` (`AttributeError`) and keeps
-  `radius` only (portable path: `mod.radius = 0.028`).
+  `radius` only (portable path: `mod.radius = 0.021`).
 - **GPv3 address** matches `grease-pencil-rosette`: `grease_pencils_v3` on 4.5,
   `grease_pencils` on 5.x.
 
 **What each check catches on failure:** wrong GPv3 collection (exit 2),
 `thickness` present/absent on the wrong side of 5.0 (exit 3), lost
-`source_object` assignment (exit 4), contour too thin (exit 5), source clear
-not zeroing strokes (exit 6), flags-off or restore failure (exit 7).
+`source_object` assignment or `use_contour` (exit 4), drawing below the gates
+(exit 5), source clear not zeroing strokes (exit 6), flags-off not zeroing
+strokes or a rebuild not recovering the same counts (exit 7).
 
 **Version witness:** stroke counts match on 4.5.11 LTS, 5.1.2 and 5.2.1 LTS
-(2 strokes / 12 points). The divergence is `thickness` vs `radius`.
+(255 strokes / 1393 points). The divergence is `thickness` vs `radius`.
 
-**The still:** the crystal is a hexagonal bipyramid (an equator ring and two
-apexes), set tip-down in a two-tier hex mount on the floor. The mount is
-render staging, derived from the crystal's lowest evaluated vertex; it is built
-after the check, so it never enters the Line Art counts. The still's camera
-drops its aim and dollies in along the check camera's bearing, so the crystal
-fills the frame with the mount's foot inside it.
+**The still:** the check and the still share one camera, because Line Art is
+view-dependent — the strokes the check counts are the strokes the still draws.
+The mesh is shaded flat (three cel tones), so the black ink is what makes it
+read as an inked illustration: clear `source_object` and the same render is a
+flat, lineless low-poly model — no band borders, no waterline, no outlines.
+
+### Stage deviation
+
+Line Art is a non-photoreal contract: the hero's materials are cel-shaded
+(Diffuse → Shader to RGB → constant ramp, emitted) instead of Principled, so
+the ink reads against flat tone fields. The stage itself — floor, wall, world,
+key, fill and warm wedge — is the default. The cel shading uses Shader to RGB,
+which is EEVEE-only, so `--engine cycles` does not render the look.
 
 ## Run
 
@@ -63,9 +77,9 @@ against it. `10` is the shared framing helper.
 | 2 | argparse / usage; also GPv3 collection address contract |
 | 3 | LINEART `thickness` / `radius` trap for this Blender |
 | 4 | LINEART type, source, or `use_contour` (`--no-contour` lands here) |
-| 5 | Evaluated contour too thin |
+| 5 | Evaluated drawing below the stroke/point gates |
 | 6 | Cleared `source_object` still produced strokes |
-| 7 | Contour+crease off still produced strokes, or restore failed |
+| 7 | Every edge type off still produced strokes, or the rebuild did not recover the same counts |
 | 8 | `--output` produced no file |
 | 10 | Gallery framing violation |
 
diff --git a/examples/gp-lineart-contour/gp_lineart_contour.py b/examples/gp-lineart-contour/gp_lineart_contour.py
index e8c37d55..4e3c45bd 100644
--- a/examples/gp-lineart-contour/gp_lineart_contour.py
+++ b/examples/gp-lineart-contour/gp_lineart_contour.py
@@ -7,15 +7,18 @@
    not from freestyle or hand-drawn strokes.
 2. ``source_type='OBJECT'`` + ``source_object`` is load-bearing — clearing
    the source yields zero evaluated strokes.
-3. ``use_contour`` must be on for silhouette edges; with contour and crease
-   both off the evaluator emits nothing.
+3. ``use_contour`` must be on for silhouette edges; with every edge-type
+   flag off the evaluator emits nothing.
 4. Stroke width: 4.5 exposes both ``thickness`` (legacy px) and ``radius``;
    5.1 removes ``thickness`` (AttributeError) and keeps ``radius`` only.
 5. GPv3 datablock address matches grease-pencil-rosette: ``grease_pencils_v3``
    on 4.5, ``grease_pencils`` on 5.x.
 
-The check evaluates the modifier through the depsgraph (no bake required)
-and asserts stroke/point lower bounds against the known failure modes above.
+The subject is a lighthouse on a rocky islet with its keeper's cottage —
+one mesh object, toon-shaded, so the Line Art ink is what turns it into an
+inked illustration. The check evaluates the modifier through the depsgraph
+(no bake required) from the same camera the still renders from and asserts
+stroke/point lower bounds against the known failure modes above.
 
 ``--no-contour`` clears ``use_contour`` after the modifier is built and
 still asserts it is True. That is the falsifier (``--same-axis`` in
@@ -28,28 +31,36 @@
     blender --background --python gp_lineart_contour.py -- --no-contour
     blender --background --python gp_lineart_contour.py -- --output l.png
 """
-import bpy, bmesh, sys, os, math, argparse
+import bpy, bmesh, sys, os, math, argparse, random
 
 # Shared Layer 1 framing measurement (render path only) — see gallery_framing.py
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = True  # keep examples/__pycache__ out of the repo tree
 import gallery_framing
-from mathutils import Matrix
+from mathutils import Matrix, Vector
 
-# Faceted crystal (octahedron-ish) — enough silhouette edges to read at thumbnail
-CRYSTAL_SCALE = 1.15
-CRYSTAL_R = 0.72        # bipyramid equator radius (before CRYSTAL_SCALE)
-CRYSTAL_APEX = 0.88     # apex height above/below the equator
-STROKE_MIN = 1
-POINT_MIN = 4
-RADIUS = 0.028
+# Gates on the evaluated drawing. Measured 255 strokes / 1393 points on 4.5.11,
+# 5.1.2 and 5.2.1. Each gate sits above the count left when any ONE of the four
+# edge types is dropped (contour 234 s, crease 171 s / 1099 p, material 1305 p,
+# intersection 179 s / 921 p), so every edge type is load-bearing on the count.
+STROKE_MIN = 240
+POINT_MIN = 1320
+RADIUS = 0.021        # ink half-width in world units (portable width path)
+THICKNESS_45 = 22       # 4.5-only legacy px width, set before radius
 
-# render staging only (not part of the check)
-MOUNT_R = 0.46          # hex plinth base radius
-MOUNT_BASE_H = 0.07     # base tier height, standing on the floor
-MOUNT_SOCKET = 0.10     # depth the crystal's lower tip sinks into the mount
-STILL_AIM_Z = 1.05      # still camera aim height (the check's is 1.15)
-STILL_DOLLY = 0.94     # still camera distance, relative to the check's
+# Lighthouse proportions (world units; the islet stands on the floor at z=0)
+TOWER_N = 32            # tower ring segments (fine enough: no facet creases)
+TOWER_Z0 = 0.34         # tower foot, on top of the plinth
+TOWER_H = 2.05
+TOWER_R0 = 0.40         # radius at the foot
+TOWER_R1 = 0.27         # radius at the gallery
+TOWER_BANDS = 5         # red / white / red / white / red
+
+# Material slots on the single source mesh
+RED, WHITE, IRON, GLOW, ROCK, STONE, SLATE, SEA = range(8)
+SEA_Z = 0.07            # top of the diorama sea disc
+
+INK = (0.015, 0.014, 0.02, 1.0)
 
 
 def eevee_engine_id():
@@ -86,91 +97,363 @@ def check_gp_version_gate():
     return 0
 
 
-def build_crystal(sc):
-    """A designed faceted crystal — not a raw cube."""
-    me = bpy.data.meshes.new("Crystal")
+# --- the source mesh: one object, many named parts via material slots --------
+
+def toon_material(name, color):
+    """Flat cel shading: Diffuse -> Shader to RGB -> constant ramp, times the
+    base colour, emitted. Three tones (shadow / mid / lit) so the key light
+    still shapes the form while the Line Art ink carries the drawing."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    nt.nodes.clear()
+    diff = nt.nodes.new("ShaderNodeBsdfDiffuse")
+    diff.inputs["Color"].default_value = (1.0, 1.0, 1.0, 1.0)
+    to_rgb = nt.nodes.new("ShaderNodeShaderToRGB")
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.interpolation = "CONSTANT"
+    els = ramp.color_ramp.elements
+    els[0].position = 0.0
+    els[0].color = (0.30, 0.30, 0.34, 1.0)     # shadow tone, slightly cool
+    els[1].position = 0.10
+    els[1].color = (0.62, 0.62, 0.64, 1.0)     # mid tone
+    lit = els.new(0.34)
+    lit.color = (1.0, 1.0, 1.0, 1.0)           # lit tone
+    mul = nt.nodes.new("ShaderNodeMix")
+    mul.data_type = "RGBA"
+    mul.blend_type = "MULTIPLY"
+    mul.inputs["Factor"].default_value = 1.0
+    mul.inputs[6].default_value = color         # A
+    emit = nt.nodes.new("ShaderNodeEmission")
+    emit.inputs["Strength"].default_value = 1.0
+    out = nt.nodes.new("ShaderNodeOutputMaterial")
+    nt.links.new(diff.outputs[0], to_rgb.inputs[0])
+    nt.links.new(to_rgb.outputs["Color"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], mul.inputs[7])  # B
+    nt.links.new(mul.outputs[2], emit.inputs["Color"])
+    nt.links.new(emit.outputs[0], out.inputs["Surface"])
+    return mat
+
+
+def glow_material(name, color, strength):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    nt.nodes.clear()
+    emit = nt.nodes.new("ShaderNodeEmission")
+    emit.inputs["Color"].default_value = color
+    emit.inputs["Strength"].default_value = strength
+    out = nt.nodes.new("ShaderNodeOutputMaterial")
+    nt.links.new(emit.outputs[0], out.inputs["Surface"])
+    return mat
+
+
+def _tag(bm, verts, mat):
+    faces = {f for v in verts for f in v.link_faces}
+    for f in faces:
+        f.material_index = mat
+
+
+def _cyl(bm, mat, r1, r2, z0, z1, segs, x=0.0, y=0.0, rot=0.0):
+    res = bmesh.ops.create_cone(
+        bm, cap_ends=True, segments=segs, radius1=r1, radius2=r2,
+        depth=z1 - z0,
+        matrix=Matrix.Translation((x, y, (z0 + z1) / 2)) @ Matrix.Rotation(rot, 4, "Z"),
+    )
+    _tag(bm, res["verts"], mat)
+    return res["verts"]
+
+
+def _box(bm, mat, center, size, rot_z=0.0):
+    m = (Matrix.Translation(center) @ Matrix.Rotation(rot_z, 4, "Z")
+         @ Matrix.Diagonal((size[0], size[1], size[2], 1.0)))
+    res = bmesh.ops.create_cube(bm, size=1.0, matrix=m)
+    _tag(bm, res["verts"], mat)
+    return res["verts"]
+
+
+def tower_radius(z):
+    t = (z - TOWER_Z0) / TOWER_H
+    return TOWER_R0 + (TOWER_R1 - TOWER_R0) * t
+
+
+def _tower(bm):
+    """Tapered, banded tower: shared rings, so the only line between bands is
+    the material border Line Art reads from the slots."""
+    rings = []
+    for i in range(TOWER_BANDS + 1):
+        z = TOWER_Z0 + TOWER_H * i / TOWER_BANDS
+        r = tower_radius(z)
+        rings.append([bm.verts.new((r * math.cos(2 * math.pi * k / TOWER_N),
+                                    r * math.sin(2 * math.pi * k / TOWER_N), z))
+                      for k in range(TOWER_N)])
+    for i in range(TOWER_BANDS):
+        lo, hi = rings[i], rings[i + 1]
+        for k in range(TOWER_N):
+            f = bm.faces.new((lo[k], lo[(k + 1) % TOWER_N],
+                              hi[(k + 1) % TOWER_N], hi[k]))
+            f.material_index = RED if i % 2 == 0 else WHITE
+    bm.faces.new(list(reversed(rings[0]))).material_index = WHITE
+    bm.faces.new(rings[-1]).material_index = IRON
+
+
+def _on_tower(az, z, depth):
+    """Placement matrix for a fixture set into the tower wall at azimuth az."""
+    r = tower_radius(z) - depth * 0.35
+    return Vector((r * math.cos(az), r * math.sin(az), z)), az
+
+
+def _lantern(bm, z_top):
+    """Gallery deck, railing, lantern room with mullions, roof and vent ball."""
+    deck_z1 = z_top + 0.07
+    _cyl(bm, IRON, 0.46, 0.46, z_top, deck_z1, 32)
+    # railing: posts + top rail
+    rail_r, post_h = 0.43, 0.19
+    for k in range(18):
+        a = 2 * math.pi * k / 18
+        _cyl(bm, IRON, 0.011, 0.011, deck_z1, deck_z1 + post_h, 6,
+             rail_r * math.cos(a), rail_r * math.sin(a))
+    _cyl(bm, IRON, rail_r + 0.018, rail_r + 0.018, deck_z1 + post_h - 0.02,
+         deck_z1 + post_h + 0.005, 32)
+    # lantern base, glass, mullions
+    base_z1 = deck_z1 + 0.09
+    _cyl(bm, RED, 0.26, 0.25, deck_z1, base_z1, 8, rot=math.pi / 8)
+    glass_z1 = base_z1 + 0.36
+    _cyl(bm, GLOW, 0.215, 0.215, base_z1, glass_z1, 8, rot=math.pi / 8)
+    for k in range(8):
+        a = 2 * math.pi * k / 8
+        r = 0.215 / math.cos(math.pi / 8) * 0.99
+        _box(bm, IRON, (r * math.cos(a), r * math.sin(a), (base_z1 + glass_z1) / 2),
+             (0.03, 0.03, glass_z1 - base_z1), a)
+    # roof: eaves ring, cone, vent ball
+    _cyl(bm, IRON, 0.29, 0.29, glass_z1, glass_z1 + 0.035, 8, rot=math.pi / 8)
+    roof_z1 = glass_z1 + 0.035 + 0.27
+    _cyl(bm, RED, 0.30, 0.02, glass_z1 + 0.035, roof_z1, 8, rot=math.pi / 8)
+    res = bmesh.ops.create_uvsphere(
+        bm, u_segments=12, v_segments=8, radius=0.055,
+        matrix=Matrix.Translation((0.0, 0.0, roof_z1 + 0.03)))
+    _tag(bm, res["verts"], IRON)
+    _cyl(bm, IRON, 0.008, 0.008, roof_z1 + 0.07, roof_z1 + 0.2, 6)
+
+
+def _rock(bm, rng, center, scale, rot):
+    res = bmesh.ops.create_icosphere(bm, subdivisions=1, radius=1.0)
+    for v in res["verts"]:
+        v.co *= 1.0 + rng.uniform(-0.16, 0.16)
+    m = (Matrix.Translation(center) @ Matrix.Rotation(rot, 4, "Z")
+         @ Matrix.Diagonal((scale[0], scale[1], scale[2], 1.0)))
+    bmesh.ops.transform(bm, matrix=m, verts=res["verts"])
+    _tag(bm, res["verts"], ROCK)
+
+
+def _wave(bm, cx, cy, r, a0, span, steps=12, width=0.11, lift=0.025):
+    """A stylised wave crest: a thin curved bar lying on the sea, tapering
+    to points at both ends — the comic shorthand for a wave."""
+    rings = []
+    for i in range(steps + 1):
+        s = i / steps
+        a = a0 + span * s
+        w = width * max(0.08, math.sin(math.pi * s))
+        d = Vector((math.cos(a), math.sin(a), 0.0))
+        c = Vector((cx, cy, SEA_Z)) + d * r
+        rings.append([bm.verts.new(c - d * w / 2 + Vector((0, 0, -0.01))),
+                      bm.verts.new(c + d * w / 2 + Vector((0, 0, -0.01))),
+                      bm.verts.new(c + d * w / 2 + Vector((0, 0, lift))),
+                      bm.verts.new(c - d * w / 2 + Vector((0, 0, lift)))])
+    for i in range(steps):
+        a, b = rings[i], rings[i + 1]
+        for k in range(4):
+            bm.faces.new((a[k], a[(k + 1) % 4], b[(k + 1) % 4], b[k])).material_index = WHITE
+    bm.faces.new(list(reversed(rings[0]))).material_index = WHITE
+    bm.faces.new(rings[-1]).material_index = WHITE
+
+
+def _islet(bm):
+    rng = random.Random(1907)
+    rocks = [
+        ((0.05, 0.05, 0.02), (1.05, 0.95, 0.30), 0.2),
+        ((-0.95, 0.30, 0.0), (0.95, 0.70, 0.26), 0.9),
+        ((0.78, -0.20, 0.0), (0.55, 0.48, 0.30), 0.5),
+        ((0.55, 0.55, 0.0), (0.50, 0.45, 0.36), 1.3),
+        ((-0.40, -0.72, 0.0), (0.42, 0.35, 0.24), 2.1),
+        ((1.18, 0.30, 0.0), (0.30, 0.26, 0.22), 0.4),
+        ((-1.55, 0.05, 0.0), (0.34, 0.30, 0.20), 2.6),
+        ((0.20, -0.95, 0.0), (0.22, 0.20, 0.14), 1.7),
+    ]
+    for c, s, r in rocks:
+        _rock(bm, rng, c, s, r)
+    # diorama sea: a shallow disc the rocks break through, so Line Art's
+    # intersection edges ink the waterline around every rock
+    _cyl(bm, SEA, 2.05, 2.0, 0.0, SEA_Z, 48)
+    for cx, cy, r, a0, span in ((-1.30, -0.70, 0.30, 205, 115),
+                                (-0.45, -1.30, 0.34, 225, 110),
+                                (0.55, -1.30, 0.28, 250, 110),
+                                (1.50, -0.55, 0.26, 280, 100),
+                                (1.35, 0.85, 0.24, 300, 100),
+                                (-1.45, 1.00, 0.24, 180, 110)):
+        _wave(bm, cx, cy, r, math.radians(a0), math.radians(span))
+    # stepped stone plinth the tower stands on
+    _cyl(bm, STONE, 0.60, 0.58, 0.10, 0.24, 12, rot=math.pi / 12)
+    _cyl(bm, STONE, 0.50, 0.46, 0.24, TOWER_Z0 + 0.02, 12, rot=math.pi / 12)
+
+
+def _cottage(bm):
+    """Keeper's cottage behind-left of the tower: walls, pitched roof with
+    overhang, chimney, door and two windows."""
+    cx, cy, rot = -1.15, 0.30, math.radians(-14)
+    w, d, h = 0.95, 0.62, 0.46
+    z0 = 0.16
+    R = Matrix.Rotation(rot, 4, "Z")
+    base = Matrix.Translation((cx, cy, 0.0)) @ R
+
+    def local(p):
+        return base @ Vector(p)
+
+    _box(bm, WHITE, local((0, 0, z0 + h / 2)), (w, d, h), rot)
+    # pitched roof prism with overhang
+    ow, od, rh = w / 2 + 0.07, d / 2 + 0.08, 0.30
+    zr = z0 + h
+    pts = [(-ow, -od, zr - 0.02), (ow, -od, zr - 0.02), (ow, 0, zr + rh),
+           (-ow, 0, zr + rh), (-ow, od, zr - 0.02), (ow, od, zr - 0.02)]
+    v = [bm.verts.new(local(p)) for p in pts]
+    faces = [(v[0], v[1], v[2], v[3]), (v[3], v[2], v[5], v[4]),
+             (v[0], v[3], v[4]), (v[1], v[5], v[2]), (v[0], v[4], v[5], v[1])]
+    for f in faces:
+        bm.faces.new(f).material_index = SLATE
+    # chimney
+    _box(bm, STONE, local((0.24, 0.12, zr + 0.26)), (0.11, 0.11, 0.36), rot)
+    _box(bm, IRON, local((0.24, 0.12, zr + 0.45)), (0.14, 0.14, 0.04), rot)
+    # door + windows on the camera-facing wall (local -y)
+    _box(bm, SLATE, local((0.20, -d / 2, z0 + 0.15)), (0.15, 0.04, 0.30), rot)
+    for x in (-0.25, -0.02):
+        _box(bm, GLOW, local((x, -d / 2, z0 + 0.25)), (0.12, 0.035, 0.12), rot)
+
+
+def _rowboat(bm):
+    """A clinker-style rowboat hauled up on the rocks: an open hull lofted
+    through U-shaped sections, a thwart and a painted gunwale strip."""
+    L, W, D = 1.0, 0.21, 0.14
+    n_sec, n_prof = 9, 9
+    yaw = 0.35
+    # heeled toward the camera so the open hull and thwart read
+    place = (Matrix.Translation((1.22, -0.58, 0.10)) @ Matrix.Rotation(yaw, 4, "Z")
+             @ Matrix.Rotation(math.radians(14), 4, "X"))
+    secs = []
+    for i in range(n_sec):
+        t = -1.0 + 2.0 * i / (n_sec - 1)
+        half_w = W * max(0.04, (1.0 - t * t) ** 0.6)
+        sheer = D * (1.0 + 0.35 * t * t)          # bow and stern rise
+        depth = D * (1.0 - 0.55 * t * t)
+        ring = []
+        for j in range(n_prof):
+            a = math.pi * j / (n_prof - 1)
+            y = -half_w * math.cos(a)
+            z = sheer - (sheer - (D - depth)) * math.sin(a)
+            ring.append(bm.verts.new(place @ Vector((t * L / 2, y, z))))
+        secs.append(ring)
+    for i in range(n_sec - 1):
+        for j in range(n_prof - 1):
+            f = bm.faces.new((secs[i][j], secs[i + 1][j],
+                              secs[i + 1][j + 1], secs[i][j + 1]))
+            f.material_index = RED if j in (0, n_prof - 2) else SLATE
+    # thwart (seat) across the middle
+    c = place @ Vector((0.0, 0.0, D * 0.78))
+    _box(bm, STONE, c, (0.08, 2 * W * 0.95, 0.025), yaw)
+
+
+def build_lighthouse(sc):
+    me = bpy.data.meshes.new("Lighthouse")
     bm = bmesh.new()
     try:
-        # Hexagonal bipyramid: one equator ring, an apex above and below.
-        # (Two overlapped open cones, the earlier build, crossed into an
-        # hourglass with open ends and an inner spike.)
-        ring = [bm.verts.new((CRYSTAL_R * math.cos(math.pi * k / 3),
-                              CRYSTAL_R * math.sin(math.pi * k / 3), 0.0))
-                for k in range(6)]
-        for apex_z in (CRYSTAL_APEX, -CRYSTAL_APEX):
-            apex = bm.verts.new((0.0, 0.0, apex_z))
-            for k in range(6):
-                bm.faces.new((ring[k], ring[(k + 1) % 6], apex))
-        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
-        bmesh.ops.scale(bm, vec=(CRYSTAL_SCALE,) * 3, verts=bm.verts)
+        _islet(bm)
+        _tower(bm)
+        # door and two windows set into the tower on the camera side
+        for az, z, size, mat in ((-1.02, TOWER_Z0 + 0.17, (0.08, 0.17, 0.32), SLATE),
+                                 (-0.80, TOWER_Z0 + 0.95, (0.06, 0.11, 0.17), GLOW),
+                                 (-1.25, TOWER_Z0 + 1.62, (0.06, 0.10, 0.15), GLOW)):
+            c, rot = _on_tower(az, z, size[0])
+            _box(bm, mat, c, size, rot)
+        _lantern(bm, TOWER_Z0 + TOWER_H)
+        _cottage(bm)
+        _rowboat(bm)
+        bm.normal_update()
         bm.to_mesh(me)
     finally:
         bm.free()
     for p in me.polygons:
         p.use_smooth = False
-    mat = bpy.data.materials.new("CrystalMat")
-    mat.use_nodes = True
-    b = mat.node_tree.nodes["Principled BSDF"]
-    b.inputs["Base Color"].default_value = (0.12, 0.38, 0.48, 1.0)
-    b.inputs["Roughness"].default_value = 0.42
-    b.inputs["Metallic"].default_value = 0.2
-    emit = b.inputs.get("Emission Color") or b.inputs.get("Emission")
-    if emit is not None:
-        emit.default_value = (0.05, 0.2, 0.28, 1.0)
-        b.inputs["Emission Strength"].default_value = 0.15
-    me.materials.append(mat)
-    ob = bpy.data.objects.new("Crystal", me)
-    ob.location = (0.0, 0.0, 1.15)
-    ob.rotation_euler = (math.radians(8), math.radians(12), math.radians(22))
+    for name, col in (("Lighthouse.Red", (0.72, 0.07, 0.05, 1.0)),
+                      ("Lighthouse.White", (0.93, 0.90, 0.82, 1.0)),
+                      ("Lighthouse.Iron", (0.10, 0.12, 0.15, 1.0)),
+                      (None, None),
+                      ("Lighthouse.Rock", (0.10, 0.15, 0.24, 1.0)),
+                      ("Lighthouse.Stone", (0.62, 0.55, 0.44, 1.0)),
+                      ("Lighthouse.Slate", (0.05, 0.30, 0.34, 1.0)),
+                      ("Lighthouse.Sea", (0.02, 0.14, 0.32, 1.0))):
+        if name is None:
+            me.materials.append(glow_material("Lighthouse.Lamp", (1.0, 0.62, 0.14, 1.0), 1.0))
+        else:
+            me.materials.append(toon_material(name, col))
+    ob = bpy.data.objects.new("Lighthouse", me)
     sc.collection.objects.link(ob)
     return ob
 
 
+# --- the Line Art object ------------------------------------------------------
+
+def configure_lineart(mod, source, gp_mat):
+    mod.source_type = "OBJECT"
+    mod.source_object = source
+    mod.use_contour = True
+    mod.use_crease = True
+    if hasattr(mod, "use_material"):
+        mod.use_material = True          # ink between the red and white bands
+    if hasattr(mod, "use_intersection"):
+        mod.use_intersection = True      # ink where fixtures meet the tower
+    mod.crease_threshold = math.radians(130)
+    mod.target_layer = "Ink"
+    mod.target_material = gp_mat
+    # Width: radius is portable; thickness is 4.5-only
+    if hasattr(mod, "thickness"):
+        mod.thickness = THICKNESS_45
+    mod.radius = RADIUS
+
+
 def build_lineart(sc, source):
     gp = gp_data_new("LineArtGP")
     ob = bpy.data.objects.new("LineArt", gp)
     sc.collection.objects.link(ob)
 
-    layer = gp.layers.new("Contours")
+    layer = gp.layers.new("Ink")
     layer.frames.new(1)
 
-    mat = bpy.data.materials.new("NeonContour")
+    mat = bpy.data.materials.new("Ink")
     bpy.data.materials.create_gpencil_data(mat)
-    # Neon cyan ink
     gp_set = mat.grease_pencil
     if hasattr(gp_set, "color"):
-        gp_set.color = (0.05, 0.95, 1.0, 1.0)
+        gp_set.color = INK
     gp.materials.append(mat)
 
     mod = ob.modifiers.new("LineArt", "LINEART")
-    mod.source_type = "OBJECT"
-    mod.source_object = source
-    mod.use_contour = True
-    mod.use_crease = True
-    if hasattr(mod, "use_material"):
-        mod.use_material = False
-    mod.target_layer = "Contours"
-    mod.target_material = mat
-    # Width: radius is portable; thickness is 4.5-only
-    if hasattr(mod, "thickness"):
-        mod.thickness = 45
-    mod.radius = RADIUS
+    configure_lineart(mod, source, mat)
 
-    # Disable lights on the GP layer so neon stays vivid
+    # Ink is flat black: keep scene lights off the GP layer
     if hasattr(layer, "use_lights"):
         layer.use_lights = False
     return ob, mod, gp
 
 
 def setup_camera(sc):
+    """One camera for the check and the still: Line Art is view-dependent, so
+    the counts the check gates are the strokes the still draws."""
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (3.95, -4.9, 2.62)
+    cam.location = (5.78, -10.25, 3.5)
     sc.collection.objects.link(cam)
     sc.camera = cam
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 1.15)
+    aim.location = (-0.12, 0.0, 1.52)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new("TRACK_TO")
     tr.target = aim
@@ -265,64 +548,49 @@ def check(sc, source, la_ob, mod):
         return 6
     print("nosource_ok strokes=0 points=0")
 
-    # Failure mode B: rebuild modifier with contour+crease off → zero strokes
+    # Failure mode B: rebuild modifier with every edge type off → zero strokes
+    gp_mat = la_ob.data.materials[0]
     while la_ob.modifiers:
         la_ob.modifiers.remove(la_ob.modifiers[0])
     mod_off = la_ob.modifiers.new("LineArtOff", "LINEART")
-    mod_off.source_type = "OBJECT"
-    mod_off.source_object = source
-    mod_off.use_contour = False
-    mod_off.use_crease = False
-    if hasattr(mod_off, "use_loose"):
-        mod_off.use_loose = False
-    if hasattr(mod_off, "use_intersection"):
-        mod_off.use_intersection = False
-    if hasattr(mod_off, "use_material"):
-        mod_off.use_material = False
-    if hasattr(mod_off, "use_edge_mark"):
-        mod_off.use_edge_mark = False
-    mod_off.target_layer = "Contours"
-    gp_mat = la_ob.data.materials[0]
-    mod_off.target_material = gp_mat
-    mod_off.radius = RADIUS
+    configure_lineart(mod_off, source, gp_mat)
+    for flag in ("use_contour", "use_crease", "use_loose", "use_intersection",
+                 "use_material", "use_edge_mark"):
+        if hasattr(mod_off, flag):
+            setattr(mod_off, flag, False)
     z_s, z_p = eval_stroke_counts(la_ob)
     if z_s != 0 or z_p != 0:
         print(
-            f"ERROR: contour+crease off still produced strokes={z_s} points={z_p}",
+            f"ERROR: every edge type off still produced strokes={z_s} points={z_p}",
             file=sys.stderr,
         )
         return 7
     print("noflags_ok strokes=0 points=0")
 
-    # Restore working Line Art modifier for optional still
+    # Restore the working Line Art modifier for the optional still
     while la_ob.modifiers:
         la_ob.modifiers.remove(la_ob.modifiers[0])
     mod_on = la_ob.modifiers.new("LineArt", "LINEART")
-    mod_on.source_type = "OBJECT"
-    mod_on.source_object = source
-    mod_on.use_contour = True
-    mod_on.use_crease = True
-    mod_on.target_layer = "Contours"
-    mod_on.target_material = gp_mat
-    if hasattr(mod_on, "thickness"):
-        mod_on.thickness = 45
-    mod_on.radius = RADIUS
+    configure_lineart(mod_on, source, gp_mat)
     n_s2, n_p2 = eval_stroke_counts(la_ob)
-    if n_s2 < STROKE_MIN or n_p2 < POINT_MIN:
+    if (n_s2, n_p2) != (n_s, n_p):
         print(
             f"ERROR: contours did not recover after restore: "
-            f"strokes={n_s2} points={n_p2}",
+            f"strokes={n_s2} points={n_p2} (first pass {n_s}/{n_p})",
             file=sys.stderr,
         )
         return 7
     print(
-        f"restored_ok strokes={n_s2} points={n_p2} radius={mod_on.radius}"
+        f"restored_ok strokes={n_s2} points={n_p2} radius={mod_on.radius:.4f}"
     )
     return 0
 
 
+# --- render staging (not part of the check) -----------------------------------
+
 def build_studio(sc):
-    # Default-stage-ish dark floor + wall — Line Art neon is the proof
+    """Default stage floor, wall and world; lighting re-weighted for toon
+    shading (see the README's Stage deviation line)."""
     def plane(name, size, loc, rot):
         me = bpy.data.meshes.new(name)
         bm = bmesh.new()
@@ -344,7 +612,7 @@ def plane(name, size, loc, rot):
         return ob
 
     plane("Floor", 30.0, (0, 0, 0), (0, 0, 0))
-    plane("Wall", 30.0, (0, 9, 0), (math.radians(90), 0, 0))
+    plane("Wall", 30.0, (0, 8, 0), (math.radians(90), 0, 0))
 
     world = bpy.data.worlds.new("World")
     world.use_nodes = True
@@ -363,59 +631,12 @@ def light(name, loc, energy, size, col, rot):
         ob.rotation_euler = tuple(math.radians(a) for a in rot)
         sc.collection.objects.link(ob)
 
-    light("Key", (-4, -5, 6), 420.0, 5.0, (1.0, 0.96, 0.9), (48, 0, -35))
+    light("Key", (-4, -5, 6), 520.0, 5.0, (1.0, 0.96, 0.9), (48, 0, -35))
     light("Fill", (5, -3.5, 2.5), 90.0, 9.0, (0.75, 0.85, 1.0), (65, 0, 50))
-    light("Wedge", (2.5, 5.5, 4.0), 280.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
-
-
-def build_mount(sc, crystal):
-    """Render staging only: a two-tier hex plinth seated on the floor whose
-    top swallows the crystal's lower tip, so the crystal is set in a mount
-    instead of hovering. Derived from the evaluated crystal; the crystal
-    itself (and so every Line Art count above) is untouched."""
-    bpy.context.view_layer.update()
-    mw = crystal.matrix_world
-    tip = min((mw @ v.co for v in crystal.data.vertices), key=lambda p: p.z)
-    top = tip.z + MOUNT_SOCKET
-    me = bpy.data.meshes.new("Mount")
-    bm = bmesh.new()
-    try:
-        for r, z0, z1 in ((MOUNT_R, -0.003, MOUNT_BASE_H),
-                          (MOUNT_R * 0.72, MOUNT_BASE_H - 0.003, top)):
-            bmesh.ops.create_cone(
-                bm, cap_ends=True, segments=6, radius1=r, radius2=r,
-                depth=z1 - z0,
-                matrix=Matrix.Translation((tip.x, tip.y, (z0 + z1) / 2))
-                @ Matrix.Rotation(crystal.rotation_euler.z, 4, "Z"),
-            )
-        bm.to_mesh(me)
-    finally:
-        bm.free()
-    for p in me.polygons:
-        p.use_smooth = False
-    mat = bpy.data.materials.new("MountStone")
-    mat.use_nodes = True
-    b = mat.node_tree.nodes["Principled BSDF"]
-    b.inputs["Base Color"].default_value = (0.06, 0.062, 0.07, 1.0)
-    b.inputs["Roughness"].default_value = 0.55
-    me.materials.append(mat)
-    ob = bpy.data.objects.new("Mount", me)
-    sc.collection.objects.link(ob)
-    return ob
+    light("Wedge", (1.8, 4.6, 4.2), 420.0, 6.0, (1.0, 0.76, 0.5), (-62, 0, 190))
 
 
 def render_still(sc, path, engine):
-    source = sc.objects["Crystal"]
-    mount = build_mount(sc, source)
-    # reframe for the still only (the check ran from the setup_camera view):
-    # lower the aim so the mount's foot clears the bottom edge, and dolly in
-    # along the same bearing so the crystal still fills the frame
-    aim = sc.objects["Aim"]
-    cam = sc.camera
-    bearing = cam.location - aim.location
-    aim.location.z = STILL_AIM_Z
-    cam.location = aim.location + bearing * STILL_DOLLY
-    bpy.context.view_layer.update()
     sc.render.engine = "CYCLES" if engine == "cycles" else eevee_engine_id()
     if engine == "cycles":
         sc.cycles.device = "CPU"
@@ -430,21 +651,16 @@ def render_still(sc, path, engine):
     sc.render.resolution_y = 720
     sc.render.image_settings.file_format = "PNG"
     sc.render.filepath = path
+    # Standard, not AgX: the toon tones are emitted colours and must land
+    # on screen as authored, not desaturated toward pastel
     sc.view_settings.view_transform = "Standard"
     # Layer 1 framing gate (silhouette matte) — exit 10 on violation, before
-    # the beauty render so a defective composition ships no artifact. The two
-    # hero subjects are the crystal source mesh and the GP stroke object; the
-    # mount is staging, so it must clear the edges but does not count as fill.
+    # the beauty render so a defective composition ships no artifact. The
+    # hero is the source mesh plus the GP ink object it evaluates into.
     stage = [o for o in sc.objects if o.name in {"Floor", "Wall"}]
-    hero = [
-        o for o in sc.objects
-        if o.type in {"MESH", "GREASEPENCIL"} and o not in stage and o != mount
-    ]
+    hero = [sc.objects["Lighthouse"], sc.objects["LineArt"]]
     fcode = gallery_framing.check_framing(
-        sc, sc.camera,
-        hero=hero,
-        elements=hero + [mount],
-        stage=stage,
+        sc, sc.camera, hero=hero, elements=hero, stage=stage,
     )
     if fcode:
         return fcode
@@ -459,10 +675,10 @@ def build_scene():
     bpy.ops.wm.read_factory_settings(use_empty=True)
     sc = bpy.context.scene
     build_studio(sc)
-    crystal = build_crystal(sc)
-    la_ob, mod, gp = build_lineart(sc, crystal)
+    source = build_lighthouse(sc)
     setup_camera(sc)
-    return sc, crystal, la_ob, mod
+    la_ob, mod, gp = build_lineart(sc, source)
+    return sc, source, la_ob, mod
 
 
 def main():
@@ -473,7 +689,7 @@ def main():
         "--engine",
         default="eevee",
         choices=("eevee", "cycles"),
-        help="render engine for --output",
+        help="render engine for --output (the toon shading is EEVEE-only)",
     )
     p.add_argument(
         "--no-contour",
@@ -483,11 +699,11 @@ def main():
     args = p.parse_args(argv)
 
     print(f"binary version: {bpy.app.version} ({bpy.app.version_string})")
-    sc, crystal, la_ob, mod = build_scene()
+    sc, source, la_ob, mod = build_scene()
     if args.no_contour:
         mod.use_contour = False
 
-    code = check(sc, crystal, la_ob, mod)
+    code = check(sc, source, la_ob, mod)
     if code:
         return code
 
diff --git a/examples/gp-lineart-contour/preview.webp b/examples/gp-lineart-contour/preview.webp
index 912f8c73..5e04c764 100644
Binary files a/examples/gp-lineart-contour/preview.webp and b/examples/gp-lineart-contour/preview.webp differ