blockyard 0.0.9 → 0.1.1

package/public/js/settings.js

@@ -19,9 +19,27 @@
 // survivable, and `sky` below is the first one to take it.
 
 export const SETTINGS_KEY = 'blockyard.settings';
-export const SCHEMA_VERSION = 4;
+export const SCHEMA_VERSION = 6;
 
 export const DEFAULTS = Object.freeze({
+  // APPEARANCE (operator, 2026-09-16: "add an appearance section in preferences to change the colors
+  // of our layout. Our current scheme should be the default appearance ... as well as options for
+  // configure custom schemes by allowing users to pick colors and save to settings so it sticks").
+  // The faces themselves live in theme.js; this holds the choice and the nine custom colours, whose
+  // defaults are the shipped dark look so that Custom starts where the page starts.
+  appearance: Object.freeze({
+    mode: 'dark',             // 'light' | 'dark' | 'system' -- which face of the theme
+    theme: 'blockyard',       // a preset in theme.js PRESETS, or 'custom'
+    customBg: '#0b0d10',      // the page
+    customPanel: '#12151a',   // cards, the header, the settings sheet
+    customText: '#dfe5ee',
+    customMuted: '#96a0b0',
+    customAccent: '#f7931a',
+    customLine: '#262c36',
+    customOk: '#2ecc8f',
+    customWarn: '#f0b429',
+    customBad: '#ef5a5a',
+  }),
   space: Object.freeze({
     // OFF by default (operator, 2026-09-12: "make simple cubes the default, disable shadows by
     // default"). Shadows are the costliest single thing the board draws -- one per resting stone
@@ -59,7 +77,7 @@ export const DEFAULTS = Object.freeze({
     // ON (operator, 2026-09-13: "the current settings I have saved out should be the shipping
     // defaults"). It was opt-in because a twinkling field means the board never stops repainting.
     // That cost is now paid deliberately rather than avoided: it is the look that was chosen.
-    stars: true,
+    sky: 'galaxy',        // 'galaxy' | 'earth' | 'none' -- which sky this board draws (docs/PLAN-SKIES.md)
     dome: 5,              // how far the board bows toward the viewer, 0 = flat
     // HEIGHT THAT FORESHORTENS (operator, 2026-09-13: "I'm not seeing the bottom or the front face
     // changing at all during movement ... fix camera stuff"). The oblique camera is parallel: height
@@ -81,6 +99,7 @@ export const DEFAULTS = Object.freeze({
     // ten stops. A stored value above it clamps on load.
     perspective: 0,       // 0 = the parallel camera; 0.001 the most allowed
     light: 'overhead',    // where the lamp is (operator, 2026-09-12: "directly above the board centered")
+    lightHeight: 'middle', // and how high it hangs when it is not overhead: 'low' | 'middle' | 'high'
     detail: 'simple',     // 'full' | 'simple' | 'flat' -- facet and crown thresholds below; simple by default
     motion: 'full',       // 'full' | 'quick' | 'still' -- the refresh choreography
     // HOW CUBES LEAVE AND ARRIVE (operator, 2026-09-13: "all the left and right side blocks are
@@ -100,11 +119,24 @@ export const DEFAULTS = Object.freeze({
     // unknown choice to this default, so those boards land on 'normal' rather than on nothing.
     departures: 'normal',  // 'normal' | 'arcing'
   }),
-  // THE SKY IS ONE SKY. density and brightness lived under `markets` and were passed only to the
-  // markets board, so the Block space star field -- the same stars, drawn by the same code -- had
-  // no density or brightness control at all. Whether each board shows stars stays per board
-  // (space.stars, markets.stars); what the stars LOOK like belongs to neither.
+  // TWO SKIES, GALAXY AND EARTH (docs/PLAN-SKIES.md; operator, 2026-09-16: "The skybox settings are
+  // not clear in the preferences, for which sky settings apply to which panel"). This group is what
+  // each sky is MADE of. WHICH sky a board draws is that board's own `sky` key -- 'galaxy', 'earth'
+  // or 'none' -- and the Sky tab opens with a table of every board's choice. There is no global
+  // switch any more: the one that was here picked Space or Living for every board at once, beside
+  // six scattered "Star field" toggles, and nobody could tell which board drew what.
   sky: Object.freeze({
+    // THE EARTH SKY (operator: "something realistic with blue skies, clouds, the sun, change of
+    // day, night with the moon coming out"; livingsky.js)
+    clock: 'real',        // 'real' (this machine's time) | 'cycle' (a day every 24 minutes) | 'fixed' (the hour below)
+    hour: 17.5,           // the hour to admire when the clock is fixed
+    weather: 'scattered', // 'clear' | 'scattered' | 'overcast' | 'storm'
+    cover: -1,            // cloud cover 0..1; -1 leaves it to the weather
+    lat: -100,            // latitude for real sunrise and season; -100 means "not set": a six-to-six day
+    rays: true,           // crepuscular rays when the sun is low
+    rainbow: true,        // a rainbow opposite a low sun in scattered weather
+    shooting: true,       // shooting stars at night
+    moon: 'night',        // 'night' (up every night, highest at midnight) | 'real' (its real track and phase)
     density: 3,           // multiplies the star count (0.2 .. 3) -- the shipped look sits at the top of the range
     brightness: 1,        // multiplies each star's alpha (0.2 .. 1.5)
     galaxy: true,         // the same stars laid on spiral arms, turning once a quarter hour
@@ -123,7 +155,11 @@ export const DEFAULTS = Object.freeze({
   // the grid glow. that's just terrible"). Never-show makes the switch a control nobody may use,
   // and a control that must stay off is worse than no control: the board forces it off now.
   markets: Object.freeze({
-    stars: true,
+    // THE SWITCH (operator, 2026-09-15: "an app wide 'Enable Market Polling' checkbox"): off out
+    // of the box, so a fresh monitor makes no outbound connection but to the node. The server
+    // reads it from the shared settings file on every market request (http/api.js).
+    polling: false,
+    sky: 'galaxy',        // 'galaxy' | 'earth' | 'none'
     effects: true,        // the idle effects and the flight when the candles refresh
     // THE TOOLBAR REMEMBERS (operator, 2026-09-12: "We need to remember the user settings for the
     // Markets page"). Which exchange and how many hours were a click that survived until the tab
@@ -166,9 +202,12 @@ export const DEFAULTS = Object.freeze({
   // for, and the board picks among whatever is left on (scheduleFx). Turn them all off and the
   // board simply rests, which `idleFx` also does in one click.
   effects: Object.freeze({
-    ripple: true, outline: true, tide: true, cascade: true, twinkle: true, scan: true,
+    ripple: true, outline: true, tide: true, cascade: true, twinkle: true, scan: true, xray: true,
     lightcycle: true, ball: true,
-    shockwave: true, nova: true, firework: true, flare: true, wave: true, quake: true,
+    // FIREWORKS ARE KEPT FOR OCCASIONS (operator, 2026-09-15: "make it disabled by default. I want
+    // to re-use that one for special occasions in the future, and don't want it in the rotation
+    // unless user selects it"): off on both boards until someone ticks it
+    shockwave: true, nova: true, firework: false, flare: true, wave: true, quake: true,
     rain: true, sparkle: true, checker: true, radar: true, vortex: true, powerup: true, combo: true, aurora: true, plasma: true,
     // the agents: something happening on the board, rather than a pattern over it
     centipede: true, tractor: true, missile: true, boulderdash: true, stormball: true,
@@ -192,10 +231,14 @@ export const DEFAULTS = Object.freeze({
   // should ship with ... Many of the effects don't translate over to the market chart"). Its own
   // no-repeat window too. All on, twelve.
   marketEffects: Object.freeze({
-    ripple: true, outline: true, tide: true, cascade: true, twinkle: true, scan: true,
+    ripple: true, outline: true, tide: true, cascade: true, twinkle: true, scan: true, xray: true,
     pulse: true,          // the surge that runs the price line
     bulge: true,          // a sphere rolls through the pipe and it swells round it
-    firework: true, flare: true, wave: true, stormball: true,
+    breathe: true,        // the line breathes between the wire and the pulse's heat
+    saber: true,          // the line ignites as a light saber
+    blackhole: true,      // the chart collapses into a black hole
+    firework: false,      // kept for occasions, off until ticked (see the block board's list)
+    flare: true, wave: true, stormball: true,
     noRepeat: 12,
     // no firstAfter here: the candle board does not land (operator, 2026-09-14: "there is no
     // 'landing' for the markets display"); after a refresh its first effect keeps the cadence below
@@ -206,9 +249,7 @@ export const DEFAULTS = Object.freeze({
   // in another tab, using our engine"). The same shape as the Tetrust group: the game says whether
   // there is a sky and a galaxy; what the sky is MADE of comes from the Sky group.
   blockout: Object.freeze({
-    stars: true,
-    galaxy: true,
-    galaxyAt: 'center',
+    sky: 'galaxy',        // 'galaxy' | 'earth' | 'none'
     neon: false,          // the bricks as dim bodies under lit tubes
     neonSource: 'brick',  // 'brick' (each row's own colour) | 'colour'
     neonColour: '#3d8bff',
@@ -223,9 +264,7 @@ export const DEFAULTS = Object.freeze({
   // engine, and make it a new Diversion called 'Blockanoid'"). Blockout's shape plus the two
   // switches Arkanoid earns: whether capsules fall at all, and whether the minions turn up.
   blockanoid: Object.freeze({
-    stars: true,
-    galaxy: true,
-    galaxyAt: 'center',
+    sky: 'galaxy',        // 'galaxy' | 'earth' | 'none'
     neon: false,
     neonSource: 'brick',  // 'brick' (the brick's own colour) | 'colour'
     neonColour: '#3d8bff',
@@ -242,9 +281,7 @@ export const DEFAULTS = Object.freeze({
   // those settings in the game and have them persistent in settings"). The sky is the panel's own
   // canvas behind the well, so it costs the game nothing per key press.
   tetrust: Object.freeze({
-    stars: true,          // the star field across the whole panel
-    galaxy: true,         // the spiral galaxy in it
-    galaxyAt: 'center',   // where its centre sits: behind the title
+    sky: 'galaxy',        // 'galaxy' | 'earth' | 'none' -- the panel's own canvas behind the well
     // the landing marker's colour (operator: "I want to be able to set the ghost wireframe
     // color"). Its own setting, not the neon tubes': the wireframe is drawn instead of a block,
     // so the neon finish never touches it.
@@ -260,6 +297,33 @@ export const DEFAULTS = Object.freeze({
     gridColour: '#1844bf',   // blue rather than the engine green
     gridBrightness: 1.55,    // and above full, which the blue needs to read at all
   }),
+  // SCORCHED YARD (operator, 2026-09-16; docs/PLAN-SCORCHED-YARD.md): the sky and the sound as the
+  // other games have them, and the rules the original exposed in its own menus
+  scorched: Object.freeze({
+    sky: 'earth',         // an artillery duel wants a day and a horizon (docs/PLAN-SKIES.md §3)
+    sfx: true,
+    music: true,          // the march
+    talk: true,           // what the tanks say, over the field
+    roundSky: true,       // under the Living sky, each round draws its own hour
+    fast: false,          // shells fly at three times the pace
+    cheat: false,         // cheat mode: the firing solution drawn live, wind and gravity and all
+    aimGuide: 'short',    // 'off' | 'short' (the first fifth of the flight) | 'full': the ranging arc while you aim
+    helper: true,         // mark a target, see how your last shot missed it, and C corrects the power
+    confirmLast: true,    // the last of a one-of-a-kind weapon asks once before it goes
+    demo: false,          // attract mode: every seat is a computer player, and it plays on by itself
+    grid: false,          // the quiet grid under the field, off: the land is the picture
+    gridColour: '#2a5a8f',
+    gridBrightness: 1,
+    opponents: 2,         // computer players against the one human; up to seven, for the original's eight seats
+    opponentKind: 'mix',  // 'mix' (Shooter, Tosser, Chooser, Spoiler, Cyborg, Poolshark in turn) or one of the manual's eight
+    rounds: 5,
+    walls: 'none',        // the manual's default: 'none' | 'concrete' | 'padded' | 'rubber' | 'spring' | 'wrap'
+    wind: 'round',        // 'round' (one wind a round, the shipped mode) | 'turn' | 'shot' | 'none'
+    gravity: 1,           // 1 = Earth
+    land: 'hills',        // 'hills' | 'mountains' | 'valley' | 'flat'
+    cash: 10000,          // to start, dollars
+    interest: 5,          // per cent, on what is left between rounds
+  }),
 });
 
 const DETAIL = {
@@ -287,15 +351,19 @@ const FX_ROW = Object.freeze({
   tide: Object.freeze({ label: 'Tide', hint: 'A swell that lifts the blocks it passes under' }),
   cascade: Object.freeze({ label: 'Cascade', hint: 'The blocks light in feerate order, richest first' }),
   twinkle: Object.freeze({ label: 'Twinkle', hint: 'Scattered blocks flash white, each on its own beat' }),
-  scan: Object.freeze({ label: 'Scan line', hint: 'A tight line crossing the board, edge to edge' }),
+  scan: Object.freeze({ label: 'Scan line', hint: 'A curtain of light standing on the board, floor to top, sweeping across: a white core, soft cyan faces, raster rippling down it, a bar it hangs from, a glowing foot with a phosphor tail, motes in the beam' }),
+  xray: Object.freeze({ label: 'X-ray', hint: 'A front sweeps the board and everything behind it goes x-ray -- bodies to glass, edges and a raster lit -- then develops back to solid' }),
   lightcycle: Object.freeze({ label: 'Light cycles', hint: 'Two riders from opposite edges, leaving light walls, until one crashes' }),
   ball: Object.freeze({ label: 'Lightning ball', hint: 'A plasma ball tracing the grid, throwing bolts and a dust trail' }),
   pulse: Object.freeze({ label: 'Energy pulse', hint: 'The surge that runs the price line on Markets, blue behind the head' }),
   bulge: Object.freeze({ label: 'Pipe bulge', hint: 'On Markets: a glowing sphere rolls through the price line left to right, and the pipe swells around it as it passes' }),
+  breathe: Object.freeze({ label: 'Breathe', hint: 'The price line breathes: three slow swells from the plain wire to the pulse\u2019s white heat and back' }),
+  saber: Object.freeze({ label: 'Light saber', hint: 'The price line ignites from its left end as a light saber -- blue, green, red or purple -- hums, spits sparks, and retracts' }),
+  blackhole: Object.freeze({ label: 'Black hole', hint: 'A point of darkness opens on the price line and grows, then drifts slowly across the chart from one side to the other: the line bends round it, the candles nearest are swallowed into orbit, and an accretion disk of the chart\u2019s own colours spirals in round the shadow -- brighter on the side coming toward you, its far side arched over the top -- until it lets everything go' }),
   shockwave: Object.freeze({ label: 'Shockwave', hint: 'A hard ring that throws the blocks it passes into the air' }),
   nova: Object.freeze({ label: 'Nova', hint: 'An implosion to the middle, then a brighter blast back out' }),
-  firework: Object.freeze({ label: 'Fireworks', hint: 'Three bursts, each at its own moment and place' }),
-  flare: Object.freeze({ label: 'Solar flare', hint: 'One block goes supernova and lights its neighbourhood' }),
+  firework: Object.freeze({ label: 'Fireworks', hint: 'A display of up to ten shells, each at its own moment and place, with its smoke. Off by default -- kept for special occasions; tick it to put it in the rotation' }),
+  flare: Object.freeze({ label: 'Supernova', hint: 'One block goes supernova: a star swells and blows out in a white-out, a debris cloud of gas expands and cools white to blue to violet, a shockwave throws what it crosses, and a pulsar is left beating at the centre' }),
   wave: Object.freeze({ label: 'Wave', hint: 'Several crests rolling across the board, the blocks riding them' }),
   quake: Object.freeze({ label: 'Quake', hint: 'The board shakes, hardest at the start, and settles' }),
   rain: Object.freeze({ label: 'Code rain', hint: 'A drop falls down every column with a white head and a green tail' }),
@@ -315,12 +383,13 @@ const FX_ROW = Object.freeze({
 });
 // where an effect reads differently on the price board, the price board's hint
 const MARKET_HINT = Object.freeze({
+  blackhole: 'A point of darkness opens on the price line and grows, then drifts slowly along the hours from one side to the other: the line bends round it, the candles nearest are swallowed into orbit, and an accretion disk of the chart\u2019s own colours spirals in round the shadow -- brighter on the side coming toward you, its far side arched over the top -- until it lets everything go',
   twinkle: 'Scattered candles flash white, each on its own beat',
-  pulse: 'The surge that runs the price line, blue behind the head',
+  pulse: 'The surge that runs the price line: the tube swells round the head and goes white-hot behind it',
   bulge: 'A glowing sphere rolls through the price line left to right, and the pipe swells around it as it passes',
   stormball: 'An electric blue sphere in a nebula flies through the chart, striking candles and charging the price line where it passes; a struck candle often throws a green arc on to another, and that one sometimes on to a third',
   cascade: 'The candles light in order, tallest first',
-  flare: 'One candle goes supernova and lights its neighbourhood',
+  flare: 'One candle goes supernova: it swells white-hot, blows out in a flash and a lens flare, a shockwave rings out across the chart, plasma is flung on every side, and a ring nebula expands and cools for the rest of the run',
 });
 // THE WINDOW'S TOP IS THE LIST'S LENGTH (operator, 2026-09-14: "for the markets page, all we have
 // is 12 effects, so max the slider out at max effects"): a window wider than the list is the same
@@ -349,7 +418,56 @@ export function fxCadence(g) {
   return { idleEvery, idleFirst };
 }
 
-export const PANEL = Object.freeze([
+// THE TABS, IN ORDER AND IN ROWS (operator, 2026-09-16: "we really need to group these better.
+// Diversions go at the very end"). The groups are written below in the order they were added; the
+// sheet shows them in this order, each row of the strip labelled: the boards, their effects, the
+// games last.
+export const TAB_ROWS = Object.freeze([
+  Object.freeze({ label: 'Boards', groups: Object.freeze(['appearance', 'space', 'sky', 'markets']) }),
+  Object.freeze({ label: 'Effects', groups: Object.freeze(['effects', 'marketEffects']) }),
+  Object.freeze({ label: 'Diversions', groups: Object.freeze(['tetrust', 'blockout', 'blockanoid', 'scorched']) }),
+]);
+/** The three answers to "which sky": the Galaxy, the Earth, or none. */
+export const SKIES = Object.freeze(['galaxy', 'earth', 'none']);
+export const SKY_CHOICES = Object.freeze([['galaxy', 'Galaxy'], ['earth', 'Earth'], ['none', 'None']]);
+export const SKY_LABELS = Object.freeze({ galaxy: 'Galaxy', earth: 'Earth', none: 'no sky' });
+/** Every board that has a sky behind it, in the order the Sky tab's table lists them. */
+export const SKY_BOARDS = Object.freeze([
+  Object.freeze({ group: 'space', label: 'Block space', note: 'also the Kiosk\u2019s left panel' }),
+  Object.freeze({ group: 'markets', label: 'Markets & Price', note: 'also the Kiosk\u2019s right panel' }),
+  Object.freeze({ group: 'tetrust', label: 'Tetrust', note: '' }),
+  Object.freeze({ group: 'blockout', label: 'Blockout', note: '' }),
+  Object.freeze({ group: 'blockanoid', label: 'Blockanoid', note: '' }),
+  Object.freeze({ group: 'scorched', label: 'Scorched Yard', note: '' }),
+]);
+/** The next sky round the ring, for the games' one-button switch. */
+export function nextSky(v) { return SKIES[(SKIES.indexOf(v) + 1) % SKIES.length]; }
+
+const PANEL_GROUPS = Object.freeze([
+  Object.freeze({
+    group: 'appearance',
+    title: 'Appearance',
+    note: 'The colours of the layout: the page, its cards, text, lines, accent and charts. The 3D boards are space whatever is chosen here, and the Explorer\u2019s block and transaction pages keep their own dark cards.',
+    rows: Object.freeze([
+      Object.freeze({
+        key: 'mode', label: 'Theme mode', kind: 'segment', hint: 'Light or dark, or whichever the operating system asks for (System follows it as it changes)',
+        options: Object.freeze([['light', 'Light'], ['dark', 'Dark'], ['system', 'System']]),
+      }),
+      Object.freeze({
+        key: 'theme', label: 'Theme', kind: 'cards', hint: 'Each has a light and a dark face; the mode above picks which. Custom is the nine colours below',
+        options: Object.freeze([['blockyard', 'BlockYard'], ['mono', 'Mono'], ['nous', 'Nous'], ['github', 'GitHub'], ['catppuccin', 'Catppuccin'], ['custom', 'Custom']]),
+      }),
+      Object.freeze({ key: 'customBg', label: 'Page', kind: 'colour', hint: 'The colour behind everything. Whether Custom is a light or a dark theme follows from this one: the derived shades go the other way', custom: true }),
+      Object.freeze({ key: 'customPanel', label: 'Panels', kind: 'colour', hint: 'Cards, the header, tables and the settings sheet. Raised panels and hovers are this nudged toward the text colour', custom: true }),
+      Object.freeze({ key: 'customText', label: 'Text', kind: 'colour', hint: 'Body text and figures', custom: true }),
+      Object.freeze({ key: 'customMuted', label: 'Muted text', kind: 'colour', hint: 'Labels, hints and notes. The fainter text is this halfway to the page colour', custom: true }),
+      Object.freeze({ key: 'customAccent', label: 'Accent', kind: 'colour', hint: 'Titles, the active tab, links, buttons and the primary lines of charts', custom: true }),
+      Object.freeze({ key: 'customLine', label: 'Lines', kind: 'colour', hint: 'Card borders and table rules. The softer rules are this halfway to the page colour', custom: true }),
+      Object.freeze({ key: 'customOk', label: 'Good', kind: 'colour', hint: 'Synced, fresh, a block on time', custom: true }),
+      Object.freeze({ key: 'customWarn', label: 'Warning', kind: 'colour', hint: 'Late, stale, a caveat', custom: true }),
+      Object.freeze({ key: 'customBad', label: 'Bad', kind: 'colour', hint: 'Overdue, failed, offline', custom: true }),
+    ]),
+  }),
   Object.freeze({
     group: 'space',
     title: 'Block space',
@@ -373,7 +491,7 @@ export const PANEL = Object.freeze([
         key: 'sheenStyle', label: 'Metallic finish', kind: 'choice', hint: 'Chrome mirrors a horizon in every face that slides as the blocks move; satin is a softer highlight along the lit edge. Needs Metallic sheen on',
         options: Object.freeze([['chrome', 'Chrome'], ['satin', 'Satin']]),
       }),
-      Object.freeze({ key: 'stars', label: 'Star field', kind: 'toggle', hint: 'Stars behind the board. They twinkle, so the board keeps repainting while they are on' }),
+      Object.freeze({ key: 'sky', label: 'Sky', kind: 'choice', hint: 'Which sky stands behind the board: the Galaxy, the Earth, or none. What each sky is made of is the Sky tab\u2019s; this is only the choice. The Kiosk\u2019s left panel is this board', options: SKY_CHOICES }),
       Object.freeze({
         key: 'detail', label: 'Level of detail', kind: 'choice', hint: 'Simpler cubes draw fewer polygons at the same size',
         options: Object.freeze([['full', 'Full'], ['simple', 'Simple cubes'], ['flat', 'Flat tiles']]),
@@ -391,37 +509,78 @@ export const PANEL = Object.freeze([
       Object.freeze({ key: 'perspective', label: 'Depth', kind: 'range', min: 0, max: 0.001, step: 0.0001, hint: 'How much height foreshortens. 0 is the flat parallel camera the board shipped with: a cube is the same size however high it flies. Raise it and a cube’s top grows a little wider than its base and a flying block swells slightly as it rises' }),
       Object.freeze({
         key: 'light', label: 'Light', kind: 'choice', hint: 'Where the lamp hangs. Straight above lights the whole board evenly; a corner shades the far slope of the curve and the sides turned away',
-        options: Object.freeze([['overhead', 'Straight above'], ['upper-left', 'Upper left'], ['upper-right', 'Upper right'], ['front', 'From the viewer']]),
+        options: Object.freeze([['overhead', 'Straight above'], ['top-left', 'Top left'], ['top-right', 'Top right'], ['bottom-left', 'Bottom left'], ['bottom-right', 'Bottom right'], ['front', 'From the viewer']]),
+      }),
+      Object.freeze({
+        key: 'lightHeight', label: 'Light height', kind: 'choice', hint: 'How high the lamp hangs over that place: low rakes the sides and shades the far slope hard, high is nearly overhead',
+        options: Object.freeze([['low', 'Low'], ['middle', 'Middle'], ['high', 'High']]),
       }),
     ]),
   }),
   Object.freeze({
     group: 'sky',
     title: 'Sky',
-    note: 'The star field itself, wherever it is drawn — behind the Block space board and behind the candles. Each board decides whether to show it; this decides what it looks like.',
+    note: 'Two skies, and which board draws which. The table is the whole map: every board that has a sky behind it, and the sky it is drawing \u2014 change one here or in the board\u2019s own tab, it is the same setting. Below it, what each sky is made of.',
     rows: Object.freeze([
-      Object.freeze({ key: 'galaxy', label: 'Spiral galaxy', kind: 'toggle', hint: 'Lay the stars on slowly turning spiral arms instead of scattering them evenly. One turn takes about fifteen minutes' }),
+      Object.freeze({ key: 'map', label: 'Which sky, where', kind: 'skymap', hint: 'Every board with a sky, and the one it draws' }),
+      Object.freeze({ key: 'galaxyHead', label: 'The Galaxy', kind: 'heading', hint: 'The star field: stars on slowly turning spiral arms, with the layers of a real galaxy. BlockYard\u2019s own sky' }),
+      Object.freeze({ key: 'galaxy', label: 'Spiral arms', kind: 'toggle', hint: 'Lay the stars on slowly turning spiral arms instead of scattering them evenly. One turn takes about fifteen minutes' }),
       Object.freeze({
-        key: 'galaxyAt', label: 'Galaxy centre', kind: 'choice',
-        hint: 'Where its middle sits. A corner crowds the bright centre there and sweeps the arms across; behind the board shows the whole spiral',
+        key: 'galaxyAt', label: 'Arms centre', kind: 'choice',
+        hint: 'Where the middle of the spiral sits. A corner crowds the bright centre there and sweeps the arms across; behind the board shows the whole spiral',
         options: Object.freeze([['center', 'Behind the board'], ['top-left', 'Top left'], ['top-right', 'Top right'], ['bottom-left', 'Bottom left'], ['bottom-right', 'Bottom right']]),
       }),
+      Object.freeze({ key: 'density', label: 'Star density', kind: 'range', min: 0.2, max: 8, step: 0.1, hint: 'How many stars, against the shipped number. High values are a lot of drawing on a big panel' }),
+      Object.freeze({ key: 'brightness', label: 'Star brightness', kind: 'range', min: 0.2, max: 1.5, step: 0.1, hint: 'How brightly they burn' }),
+      Object.freeze({ key: 'colours', label: 'Star colours', kind: 'toggle', hint: 'Warm old stars in the middle, blue-white young ones in the arms. Off is one colour of starlight' }),
+      Object.freeze({ key: 'glints', label: 'Star glints', kind: 'toggle', hint: 'The halo and cross glint on the brightest stars' }),
       Object.freeze({ key: 'nebulae', label: 'Nebulae', kind: 'toggle', hint: 'Clouds of gas along the spiral arms, in the colours of star-forming lanes' }),
       Object.freeze({ key: 'dust', label: 'Dust lanes', kind: 'toggle', hint: 'Dark ribbons along the inner edge of each arm, the way a real spiral carries them' }),
-      Object.freeze({ key: 'clusters', label: 'Star clusters', kind: 'toggle', hint: 'Tight knots of stars out in the halo, turning with the galaxy' }),
+      Object.freeze({ key: 'clusters', label: 'Star clusters', kind: 'toggle', hint: 'Tight knots of stars out in the halo, turning with the arms' }),
       Object.freeze({ key: 'galaxies', label: 'Distant galaxies', kind: 'toggle', hint: 'Other galaxies, small and faint and far, behind everything else' }),
-      Object.freeze({ key: 'colours', label: 'Star colours', kind: 'toggle', hint: 'Warm old stars in the middle, blue-white young ones in the arms. Off is one colour of starlight' }),
-      Object.freeze({ key: 'glints', label: 'Star glints', kind: 'toggle', hint: 'The halo and cross glint on the brightest stars' }),
-      Object.freeze({ key: 'density', label: 'Star density', kind: 'range', min: 0.2, max: 8, step: 0.1, hint: 'How many stars, against the shipped number. High values are a lot of drawing on a big panel' }),
-      Object.freeze({ key: 'brightness', label: 'Star brightness', kind: 'range', min: 0.2, max: 1.5, step: 0.1, hint: 'How brightly they burn' }),
+      Object.freeze({ key: 'earthHead', label: 'The Earth', kind: 'heading', hint: 'A real day from this machine\u2019s clock: the sun, clouds, dusk, the moon at its phase, and the stars at night' }),
+      Object.freeze({
+        key: 'clock', label: 'Clock', kind: 'choice', hint: 'What time the Earth sky shows',
+        options: Object.freeze([['real', 'Real time'], ['cycle', 'A day every 24 minutes'], ['fixed', 'A fixed hour']]),
+      }),
+      Object.freeze({ key: 'hour', label: 'Fixed hour', kind: 'range', min: 0, max: 24, step: 0.25, hint: 'The hour the Earth sky holds when the clock is fixed; 17.5 is late afternoon' }),
+      Object.freeze({
+        key: 'weather', label: 'Weather', kind: 'choice', hint: 'How much cloud, and whether it rains',
+        options: Object.freeze([['clear', 'Clear'], ['scattered', 'Scattered cloud'], ['overcast', 'Overcast'], ['storm', 'Storm: rain and lightning']]),
+      }),
+      Object.freeze({ key: 'cover', label: 'Cloud cover', kind: 'range', min: -1, max: 1, step: 0.05, hint: 'Overrides the weather\u2019s cloud amount, 0 to 1; -1 leaves it to the weather' }),
+      Object.freeze({ key: 'lat', label: 'Latitude', kind: 'range', min: -100, max: 90, step: 1, hint: 'Your latitude, for real sunrise and sunset and the season; -100 leaves a six-to-six day' }),
+      Object.freeze({ key: 'rays', label: 'Sun rays', kind: 'toggle', hint: 'Crepuscular rays when the sun is low' }),
+      Object.freeze({ key: 'rainbow', label: 'Rainbow', kind: 'toggle', hint: 'A rainbow opposite a low sun in scattered weather' }),
+      Object.freeze({ key: 'shooting', label: 'Shooting stars', kind: 'toggle', hint: 'Now and then, at night' }),
+      Object.freeze({
+        key: 'moon', label: 'Moon', kind: 'choice', hint: 'Up every night, highest at midnight, never thinner than a fat crescent \u2014 or on its real track at its real phase, which some nights means no moon at all',
+        options: Object.freeze([['night', 'Up every night'], ['real', 'Its real track and phase']]),
+      }),
     ]),
   }),
   Object.freeze({
     group: 'markets',
     title: 'Markets & Price',
-    note: 'The candle board on Markets and Kiosk.',
+    note: 'The exchange feed, and the candle board on Markets and Kiosk.',
     rows: Object.freeze([
-      Object.freeze({ key: 'stars', label: 'Star field', kind: 'toggle', hint: 'The twinkling sky behind the candles' }),
+      Object.freeze({
+        key: 'polling', label: 'Enable market polling', kind: 'toggle',
+        hint: 'Let the server ask five exchanges (Coinbase, Kraken, Bitstamp, Bitfinex, OKX) for prices, candles and order books. '
+          + 'Off out of the box: this is the only thing the monitor ever says to anyone but your node, and until it is on, '
+          + 'Markets and Kiosk say so and the explorer shows no dollar figures. On, the server asks only while someone is looking, '
+          + 'and stops ten minutes after the last look. Shared by every screen of this monitor',
+      }),
+      // right under the polling switch it depends on (operator, 2026-09-15: "Move price line on Overview
+      // underneath Enable Market Polling")
+      Object.freeze({
+        key: 'overviewSummary', label: 'Price line on Overview', kind: 'toggle',
+        hint: 'Median, spread, 24 h volume and how many books reported, at the top of Overview. '
+          + 'It needs market polling (above); with that on, leaving this on means this monitor contacts '
+          + 'five exchanges whenever Overview is open, not only on Markets and Kiosk. '
+          + 'Switch it off and the landing page talks to nothing but your node.',
+      }),
+      Object.freeze({ key: 'sky', label: 'Sky', kind: 'choice', hint: 'Which sky stands behind the candles: the Galaxy, the Earth, or none. The Kiosk\u2019s right panel is this board', options: SKY_CHOICES }),
       Object.freeze({ key: 'effects', label: 'Board effects', kind: 'toggle', hint: 'The idle effects while the board rests (which of them is the Market effects tab) and the flight when the candles refresh. Off draws the board and leaves it alone' }),
       Object.freeze({
         key: 'exchange', label: 'Exchange', kind: 'choice', hint: 'Whose candles the chart and the 3D board draw. The others stay as overlay lines',
@@ -431,13 +590,6 @@ export const PANEL = Object.freeze([
         key: 'range', label: 'Range', kind: 'choice', hint: 'How many hours the chart covers when the page opens',
         options: Object.freeze([['24', '24 hours'], ['48', '48 hours'], ['168', '7 days']]),
       }),
-      Object.freeze({
-        key: 'overviewSummary', label: 'Price line on Overview', kind: 'toggle',
-        hint: 'Median, spread, 24 h volume and how many books reported, at the top of Overview. '
-          + 'On by default: it needs the exchange feed, so leaving it on means this monitor '
-          + 'contacts five exchanges whenever Overview is open, not only on Markets and Kiosk. '
-          + 'Switch it off and the landing page talks to nothing but your node.',
-      }),
       Object.freeze({
         key: 'priceView', label: 'Price view', kind: 'choice', hint: 'Which one the Markets page draws. Only one at a time — they show the same hours, and two tall panels of it filled the screen',
         options: Object.freeze([['2d', 'Flat chart'], ['3d', '3D candle board']]),
@@ -449,12 +601,7 @@ export const PANEL = Object.freeze([
     title: 'Blockout',
     note: 'The Breakout court. These switches are also on the game\u2019s own panel; the sky takes its density, brightness and layers from Sky above.',
     rows: Object.freeze([
-      Object.freeze({ key: 'stars', label: 'Star field', kind: 'toggle', hint: 'The sky across the whole panel, behind the court' }),
-      Object.freeze({ key: 'galaxy', label: 'Spiral galaxy', kind: 'toggle', hint: 'The galaxy in that sky, turning' }),
-      Object.freeze({
-        key: 'galaxyAt', label: 'Galaxy centre', kind: 'choice', hint: 'Where the galaxy\u2019s centre sits on the panel',
-        options: Object.freeze([['center', 'Behind the court'], ['top-left', 'Top left'], ['top-right', 'Top right'], ['bottom-left', 'Bottom left'], ['bottom-right', 'Bottom right']]),
-      }),
+      Object.freeze({ key: 'sky', label: 'Sky', kind: 'choice', hint: 'Which sky stands behind the court: the Galaxy, the Earth, or none. Also a button on the game\u2019s panel', options: SKY_CHOICES }),
       Object.freeze({ key: 'neon', label: 'Neon bricks', kind: 'toggle', hint: 'The wall, the bat and the ball as dim bodies under lit tubes' }),
       Object.freeze({
         key: 'neonSource', label: 'Neon colour from', kind: 'choice', hint: 'Each brick row\u2019s own colour, or all in one colour',
@@ -473,12 +620,7 @@ export const PANEL = Object.freeze([
     title: 'Blockanoid',
     note: 'The Arkanoid court: silver bricks that take more than one hit, gold that takes none, and capsules that fall out of what you break. These switches are also on the game’s own panel.',
     rows: Object.freeze([
-      Object.freeze({ key: 'stars', label: 'Star field', kind: 'toggle', hint: 'The sky across the whole panel, behind the court' }),
-      Object.freeze({ key: 'galaxy', label: 'Spiral galaxy', kind: 'toggle', hint: 'The galaxy in that sky, turning' }),
-      Object.freeze({
-        key: 'galaxyAt', label: 'Galaxy centre', kind: 'choice', hint: 'Where the galaxy’s centre sits on the panel',
-        options: Object.freeze([['center', 'Behind the court'], ['top-left', 'Top left'], ['top-right', 'Top right'], ['bottom-left', 'Bottom left'], ['bottom-right', 'Bottom right']]),
-      }),
+      Object.freeze({ key: 'sky', label: 'Sky', kind: 'choice', hint: 'Which sky stands behind the court: the Galaxy, the Earth, or none. Also a button on the game\u2019s panel', options: SKY_CHOICES }),
       Object.freeze({ key: 'neon', label: 'Neon bricks', kind: 'toggle', hint: 'The wall, Vaus and the ball as dim bodies under lit tubes' }),
       Object.freeze({
         key: 'neonSource', label: 'Neon colour from', kind: 'choice', hint: 'Each brick’s own colour, or all in one colour',
@@ -503,7 +645,7 @@ export const PANEL = Object.freeze([
     note: 'What the Block space board may play while it rests. One is chosen at random every seven to thirteen seconds, never one played within the no-repeat window \u2014 so the more you leave on, the less often you see any one of them. The Markets board has a list of its own, on the next tab.',
     bulk: true,
     rows: fxRows([
-      'ripple', 'outline', 'tide', 'cascade', 'twinkle', 'scan', 'lightcycle', 'ball', 'shockwave', 'nova',
+      'ripple', 'outline', 'tide', 'cascade', 'twinkle', 'scan', 'xray', 'lightcycle', 'ball', 'shockwave', 'nova',
       'firework', 'flare', 'wave', 'quake', 'rain', 'sparkle', 'checker', 'radar', 'vortex', 'powerup',
       'combo', 'aurora', 'plasma', 'centipede', 'tractor', 'missile', 'boulderdash', 'stormball',
     ]),
@@ -511,10 +653,10 @@ export const PANEL = Object.freeze([
   Object.freeze({
     group: 'marketEffects',
     title: 'Market effects',
-    note: 'What the candle board on Markets and Kiosk may play while it rests, chosen the same way as on Block space but from the twelve that translate to a chart: fronts along the hours, bursts from the candle row, the candles lit where they stand, and the price line\u2019s own pulse, bulge and ball lightning. The Board effects switch on the Markets & Price tab is the master.',
+    note: 'What the candle board on Markets and Kiosk may play while it rests, chosen the same way as on Block space but from the sixteen that translate to a chart: fronts along the hours, bursts from the candle row, the candles lit where they stand, and the price line\u2019s own pulse, bulge and ball lightning. The Board effects switch on the Markets & Price tab is the master.',
     bulk: true,
     rows: fxRows([
-      'ripple', 'outline', 'tide', 'cascade', 'twinkle', 'scan', 'pulse', 'bulge', 'firework', 'flare', 'wave', 'stormball',
+      'ripple', 'outline', 'tide', 'cascade', 'twinkle', 'scan', 'xray', 'pulse', 'bulge', 'breathe', 'saber', 'blackhole', 'firework', 'flare', 'wave', 'stormball',
     ], MARKET_HINT, { landing: false, top: 300 }),
   }),
   Object.freeze({
@@ -522,12 +664,7 @@ export const PANEL = Object.freeze([
     title: 'Tetrust',
     note: 'The game. These switches are also on the game’s own panel; the sky takes the star field’s density, brightness and layers from Sky above.',
     rows: Object.freeze([
-      Object.freeze({ key: 'stars', label: 'Star field', kind: 'toggle', hint: 'The sky across the whole panel, behind the well' }),
-      Object.freeze({ key: 'galaxy', label: 'Spiral galaxy', kind: 'toggle', hint: 'The galaxy in that sky, turning' }),
-      Object.freeze({
-        key: 'galaxyAt', label: 'Galaxy centre', kind: 'choice', hint: 'Where the galaxy’s centre sits on the panel: behind the title, or a corner',
-        options: Object.freeze([['center', 'Behind the title'], ['top-left', 'Top left'], ['top-right', 'Top right'], ['bottom-left', 'Bottom left'], ['bottom-right', 'Bottom right']]),
-      }),
+      Object.freeze({ key: 'sky', label: 'Sky', kind: 'choice', hint: 'Which sky stands behind the well: the Galaxy, the Earth, or none. Also a button on the game\u2019s panel', options: SKY_CHOICES }),
       Object.freeze({ key: 'ghostColour', label: 'Landing marker', kind: 'colour', hint: 'The wireframe on the floor of the well showing where the falling piece will land. Its own colour: the neon finish below never touches it, because the marker is drawn instead of a block rather than over one' }),
       Object.freeze({ key: 'ghostWidth', label: 'Landing marker thickness', kind: 'range', min: 0.3, max: 2.5, step: 0.1, hint: 'How heavy the marker\u2019s lines are. 1 is the shipped weight; below it the outline thins out of the way of the stack behind it' }),
       Object.freeze({ key: 'music', label: 'Music', kind: 'toggle', hint: 'Korobeiniki, on oscillators' }),
@@ -544,7 +681,58 @@ export const PANEL = Object.freeze([
       Object.freeze({ key: 'gridBrightness', label: 'Grid intensity', kind: 'range', min: 0, max: 2, step: 0.05, hint: 'How strongly the grid shows; 1 is the shipped weight, 0 hides it' }),
     ]),
   }),
+  Object.freeze({
+    group: 'scorched',
+    title: 'Scorched Yard',
+    note: 'The artillery game. The switches are also on the game\u2019s own panel; the rules below take effect at the next new game.',
+    rows: Object.freeze([
+      Object.freeze({ key: 'sky', label: 'Sky', kind: 'choice', hint: 'Which sky stands behind the field: the Galaxy, the Earth, or none. Earth is the shipped choice here: an artillery duel wants a day and a horizon, and each round draws its own hour of it. Also a button on the game\u2019s panel', options: SKY_CHOICES }),
+      Object.freeze({ key: 'sfx', label: 'Sound effects', kind: 'toggle', hint: 'The shot, the blast, a hit, a fall, a death' }),
+      Object.freeze({ key: 'music', label: 'Music', kind: 'toggle', hint: 'A march in D minor, on oscillators' }),
+      Object.freeze({ key: 'talk', label: 'Talk', kind: 'toggle', hint: 'What the tanks say when they fire, are hit, or die' }),
+      Object.freeze({ key: 'roundSky', label: 'A sky per round', kind: 'toggle', hint: 'Under the Living sky, each round draws its own hour: dawn, noon, dusk, night' }),
+      Object.freeze({ key: 'fast', label: 'Fast shells', kind: 'toggle', hint: 'Shells fly at three times the pace, for the impatient' }),
+      Object.freeze({
+        key: 'aimGuide', label: 'Aim guide', kind: 'choice', hint: 'A ghost of the shell\u2019s path while you aim, under this round\u2019s wind and gravity. Short shows the first fifth of the flight: enough to read the lean of the shot without giving the landing away. Off is the original',
+        options: Object.freeze([['short', 'Short'], ['full', 'The whole flight'], ['off', 'Off']]),
+      }),
+      Object.freeze({ key: 'helper', label: 'Correction helper', kind: 'toggle', hint: 'Click an enemy tank to mark it: the panel then says how far your last shot fell short of it or went over, and C corrects your power from that miss. Nothing is solved for you \u2014 the wind and the hills are still yours to read' }),
+      Object.freeze({ key: 'confirmLast', label: 'Confirm the last of a weapon', kind: 'toggle', hint: 'The last Nuke, the last Death\u2019s Head \u2014 any weapon sold one at a time \u2014 asks once before it goes: press fire again to send it' }),
+      Object.freeze({ key: 'cheat', label: 'Cheat mode', kind: 'toggle', hint: 'Draw the firing solution while you aim: the shell\u2019s own path under this round\u2019s wind and the game\u2019s gravity, clipped where it meets the dirt, with a ring where it lands. It moves as you move' }),
+      Object.freeze({ key: 'demo', label: 'Attract mode', kind: 'toggle', hint: 'Every seat is a computer player and the war runs on by itself, for a wall display' }),
+      Object.freeze({ key: 'grid', label: 'Grid', kind: 'toggle', hint: 'A quiet grid under the field' }),
+      Object.freeze({ key: 'gridColour', label: 'Grid colour', kind: 'colour', hint: 'The colour of that grid' }),
+      Object.freeze({ key: 'gridBrightness', label: 'Grid intensity', kind: 'range', min: 0, max: 2, step: 0.05, hint: 'How strongly the grid shows; 0 hides it' }),
+      Object.freeze({ key: 'opponents', label: 'Computer players', kind: 'range', min: 1, max: 7, step: 1, hint: 'How many tanks the computer fields against you. Two is the shipped game; seven fills the original\u2019s eight seats' }),
+      Object.freeze({
+        key: 'opponentKind', label: 'Their kind', kind: 'choice', hint: 'The manual\u2019s personalities: a mix climbs from the easy ones, or every seat the one you name. Moron fires at random; Shooter takes straight shots; Poolshark banks off rubber walls; Tosser lobs and corrects; Chooser picks its method; Spoiler nearly never misses; Cyborg is a Spoiler with a grudge; Unknown is one of them, drawn each round',
+        options: Object.freeze([['mix', 'A mix'], ['moron', 'Morons'], ['shooter', 'Shooters'], ['poolshark', 'Poolsharks'], ['tosser', 'Tossers'], ['chooser', 'Choosers'], ['spoiler', 'Spoilers'], ['cyborg', 'Cyborgs'], ['unknown', 'Unknowns']]),
+      }),
+      Object.freeze({ key: 'rounds', label: 'Rounds', kind: 'range', min: 1, max: 10, step: 1, hint: 'A game is this many rounds; the highest score at the end wins' }),
+      Object.freeze({
+        key: 'walls', label: 'Walls', kind: 'choice', hint: 'What a shell does at the edge of the field',
+        options: Object.freeze([['none', 'None: it is lost (the original\u2019s default)'], ['concrete', 'Concrete: it explodes there'], ['padded', 'Padded: it stops and drops'], ['rubber', 'Rubber: it bounces'], ['spring', 'Spring: it bounces back harder'], ['wrap', 'Wraparound: it comes in the other side']]),
+      }),
+      Object.freeze({
+        key: 'wind', label: 'Wind', kind: 'choice', hint: 'Whether the wind blows, and how often it changes. Once a round holds its direction and strength for the whole round, so the air blows one way while you read it; every turn is the original\u2019s, and it can turn right around between two shots',
+        options: Object.freeze([['round', 'Once a round'], ['turn', 'Changes every turn'], ['shot', 'Changes every shot'], ['none', 'No wind']]),
+      }),
+      Object.freeze({ key: 'gravity', label: 'Gravity', kind: 'range', min: 0.4, max: 2, step: 0.1, hint: 'How hard shells fall; 1 is Earth' }),
+      Object.freeze({
+        key: 'land', label: 'Landscape', kind: 'choice', hint: 'The shape of the land each round is drawn from',
+        options: Object.freeze([['hills', 'Rolling hills'], ['mountains', 'Mountains'], ['valley', 'A valley'], ['flat', 'Flat']]),
+      }),
+      Object.freeze({ key: 'cash', label: 'Starting cash', kind: 'range', min: 0, max: 100000, step: 5000, hint: 'What every tank has to spend at the first shop; damage and kills earn more' }),
+      Object.freeze({ key: 'interest', label: 'Interest', kind: 'range', min: 0, max: 25, step: 1, hint: 'Per cent paid on unspent cash between rounds' }),
+    ]),
+  }),
 ]);
+/** The groups in the sheet's order: row by row of TAB_ROWS, then anything a row forgot (a test says nothing is). */
+export const PANEL = Object.freeze([
+  ...TAB_ROWS.flatMap((row) => row.groups.map((id) => PANEL_GROUPS.find((g) => g.group === id)).filter(Boolean)),
+  ...PANEL_GROUPS.filter((g) => !TAB_ROWS.some((row) => row.groups.includes(g.group))),
+]);
+
 
 // "group.key" -> the row that defines it. The bounds live in exactly one place now.
 const ROWS = new Map();
@@ -700,6 +888,35 @@ const MIGRATIONS = {
     const fx = raw.effects && typeof raw.effects === 'object' ? raw.effects : {};
     return { ...raw, marketEffects: { ...fx } };
   },
+  // v4 -> v5: the lamp's placements were renamed as six places at three heights (2026-09-16):
+  // upper-left is top-left, upper-right top-right; front stays; the height is new (middle)
+  4: (raw) => {
+    const sp = raw.space && typeof raw.space === 'object' ? raw.space : {};
+    const map = { 'upper-left': 'top-left', 'upper-right': 'top-right' };
+    return { ...raw, space: { ...sp, light: map[sp.light] ?? sp.light } };
+  },
+
+  // v5 -> v6: ONE SKY PER BOARD (docs/PLAN-SKIES.md). One global `sky.type` (space | living) plus a
+  // `stars` toggle on each of six boards becomes a `sky` choice on each board (galaxy | earth |
+  // none), and the games' private `galaxy` / `galaxyAt` are dropped in favour of the Sky tab's.
+  // The mapping keeps every installation drawing exactly what it drew.
+  //
+  // IDEMPOTENT ON PURPOSE: settings stored on the server carry no schema version, so this runs on
+  // every boot. It acts only on a board that still has the old key and lacks the new one, and a
+  // store already in the new shape passes through untouched.
+  5: (raw) => {
+    const type = raw.sky && typeof raw.sky === 'object' ? raw.sky.type : undefined;
+    const out = { ...raw };
+    if (out.sky && typeof out.sky === 'object' && 'type' in out.sky) { const { type: _t, ...rest } = out.sky; out.sky = rest; }
+    for (const board of ['space', 'markets', 'tetrust', 'blockout', 'blockanoid', 'scorched']) {
+      const g = raw[board];
+      if (!g || typeof g !== 'object') continue;
+      const { stars, galaxy: _g, galaxyAt: _a, ...rest } = g;
+      if (g.sky === undefined && stars !== undefined) rest.sky = stars === false ? 'none' : type === 'living' ? 'earth' : 'galaxy';
+      out[board] = rest;
+    }
+    return out;
+  },
 };
 
 function migrate(raw) {
@@ -855,13 +1072,71 @@ export function isDefault(s) {
  * Merged OVER the caller's own options, so a mode's resolution and slab still win where they are
  * the point of the mode; these are the user's preferences about how it is drawn.
  */
+/** The living sky's settings as board options, for every board that draws a sky. */
+/** Which sky a board draws, from its own key: 'galaxy' | 'earth' | 'none'. */
+export function skyOf(n, board) {
+  const v = n[board]?.sky;
+  return SKIES.includes(v) ? v : 'galaxy';
+}
+
+/**
+ * THE DEEP SKY belongs to the Galaxy: spiral arms, nebulae, dust lanes, halo clusters and distant
+ * galaxies are wrong over a real day and a real night (operator, 2026-09-16: "It's counter
+ * intuitive in the preferences to display a spiral galaxy for a night/day scene"). Gated by the
+ * board's choice, so a board back on the Galaxy gets them all exactly as saved.
+ */
+export function deepSky(n, sky = 'galaxy') {
+  const off = sky !== 'galaxy';
+  return {
+    galaxy: n.sky.galaxy && !off,
+    galaxyAt: n.sky.galaxyAt,
+    nebulae: n.sky.nebulae && !off,
+    galaxies: n.sky.galaxies && !off,
+    dust: n.sky.dust && !off,
+    clusters: n.sky.clusters && !off,
+  };
+}
+
+/** The Earth sky's settings as renderer options. */
+export function skyExtras(n) {
+  const sky = n.sky;
+  return {
+    skyClock: sky.clock, skyHour: sky.hour, skyWeather: sky.weather,
+    skyCover: sky.cover < 0 ? undefined : sky.cover, skyLat: sky.lat <= -95 ? undefined : sky.lat,
+    skyRays: sky.rays, skyRainbow: sky.rainbow, skyShooting: sky.shooting, skyMoon: sky.moon,
+  };
+}
+
+/**
+ * ONE ANSWER PER BOARD (docs/PLAN-SKIES.md): everything the renderer needs to draw the sky this
+ * board chose. `sky` is the choice, `stars` whether any sky is drawn at all, `skyType` which one
+ * ('galaxy' or 'earth'); then the Earth's settings and the Galaxy's, the deep layers gated off
+ * under the Earth. Every board's option builder spreads this and nothing else about the sky.
+ */
+export function skyFor(n, board) {
+  const sky = skyOf(n, board);
+  return {
+    sky,
+    stars: sky !== 'none',
+    skyType: sky === 'earth' ? 'earth' : 'galaxy',
+    ...skyExtras(n),
+    starDensity: n.sky.density,
+    starBrightness: n.sky.brightness,
+    starColours: n.sky.colours, starGlints: n.sky.glints,
+    ...deepSky(n, sky),
+  };
+}
+
 export function spaceOptions(s) {
   const n = normalise(s);
   const sp = n.space;
   const d = DETAIL[sp.detail] ?? DETAIL.full;
   const out = {
     shadows: sp.shadows,
-    idleFx: sp.idleFx,
+    // THE SPACE EFFECTS GO OFF UNDER THE LIVING SKY (operator, 2026-09-16: "We have to toggle all
+    // the Space effects off when Living Sky is selected"): supernovae and black holes over a blue
+    // afternoon are wrong. Gated here, not by flipping the switches, so space gets them back as saved.
+    idleFx: sp.idleFx && skyOf(n, 'space') !== 'earth',
     grid: sp.grid,
     neon: sp.neon,
     sheen: sp.sheen,
@@ -869,18 +1144,12 @@ export function spaceOptions(s) {
     // `space` is the board STYLE (no deck texture, a translucent floor); `stars` is the sky. They
     // travel together here, which is the block-space board's shipped behaviour, but they are two
     // options now so the markets board can keep its style while turning its sky off.
-    space: sp.stars,
-    stars: sp.stars,
+    space: skyOf(n, 'space') !== 'none',
     dome: sp.dome,
     facetPx: d.facetPx,
     crownPx: d.crownPx,
-    // the same sky the markets board draws: this board had stars and no way to thin them
-    starDensity: n.sky.density,
-    starBrightness: n.sky.brightness,
-    galaxy: n.sky.galaxy,
-    galaxyAt: n.sky.galaxyAt,
-    nebulae: n.sky.nebulae, galaxies: n.sky.galaxies, dust: n.sky.dust, clusters: n.sky.clusters,
-    starColours: n.sky.colours, starGlints: n.sky.glints,
+    // the sky this board chose, and what it is made of (skyFor): the Kiosk's left panel is this board
+    ...skyFor(n, 'space'),
   };
   // the seam belongs to the Stone edges switch at every level of detail: a control that does
   // nothing in one mode is worse than no control (operator: "stone edges don't work in flat tile
@@ -891,10 +1160,11 @@ export function spaceOptions(s) {
   if (motion) out.transition = motion;
   out.departures = sp.departures;
   out.light = sp.light;
+  out.lightHeight = sp.lightHeight;
   // merged into the camera by details3d (it owns the oblique constants); 0 leaves it exactly as it
   // has always been, so the switch costs nothing until someone moves it
   out.obliqueRise = sp.perspective;
-  out.fxKinds = enabledEffects(n);
+  out.fxKinds = skyOf(n, 'space') === 'earth' ? [] : enabledEffects(n);
   out.fxNoRepeat = n.effects.noRepeat;
   Object.assign(out, fxCadence(n.effects));
   out.neonSource = sp.neonSource; out.neonColour = sp.neonColour; out.neonBrightness = sp.neonBrightness;
@@ -930,9 +1200,8 @@ export function enabledEffects(s, group = 'effects') {
 /** Blockout's switches, with the sky's make-up from the Sky group (as tetrustOptions does). */
 export function blockoutOptions(s) {
   const n = normalise(s);
-  const sky = spaceOptions(s);
   return {
-    stars: n.blockout.stars, galaxy: n.blockout.galaxy, galaxyAt: n.blockout.galaxyAt, sfx: n.blockout.sfx,
+    sky: skyFor(n, 'blockout'), sfx: n.blockout.sfx,
     neon: n.blockout.neon,
     // the engine calls the data-coloured source "temperature"; here that is the brick's own row
     neonSource: n.blockout.neonSource === 'colour' ? 'colour' : 'temperature',
@@ -941,43 +1210,45 @@ export function blockoutOptions(s) {
     // composed here rather than in the screen, so the court needs no new import and the renderer
     // keys stay in one place. 0.18 is the weight this court was hand-tuned at.
     gridOpts: courtGridColours(n.blockout.gridColour, n.blockout.gridBrightness, 0.18),
-    starDensity: sky.starDensity, starBrightness: sky.starBrightness,
-    nebulae: sky.nebulae, galaxies: sky.galaxies, dust: sky.dust, clusters: sky.clusters,
-    starColours: sky.starColours, starGlints: sky.starGlints,
   };
 }
 
 /** Blockanoid's switches. Blockout's shape, plus the two that are Arkanoid's own. */
 export function blockanoidOptions(s) {
   const n = normalise(s);
-  const sky = spaceOptions(s);
   return {
-    stars: n.blockanoid.stars, galaxy: n.blockanoid.galaxy, galaxyAt: n.blockanoid.galaxyAt, sfx: n.blockanoid.sfx,
+    sky: skyFor(n, 'blockanoid'), sfx: n.blockanoid.sfx,
     capsules: n.blockanoid.capsules, enemies: n.blockanoid.enemies,
     neon: n.blockanoid.neon,
     neonSource: n.blockanoid.neonSource === 'colour' ? 'colour' : 'temperature',
     neonColour: n.blockanoid.neonColour, neonBrightness: n.blockanoid.neonBrightness,
     grid: n.blockanoid.grid, gridColour: n.blockanoid.gridColour, gridBrightness: n.blockanoid.gridBrightness,
     gridOpts: courtGridColours(n.blockanoid.gridColour, n.blockanoid.gridBrightness, 0.18),
-    starDensity: sky.starDensity, starBrightness: sky.starBrightness,
-    nebulae: sky.nebulae, galaxies: sky.galaxies, dust: sky.dust, clusters: sky.clusters,
-    starColours: sky.starColours, starGlints: sky.starGlints,
   };
 }
 
 export function tetrustOptions(s) {
   const n = normalise(s);
-  const sky = spaceOptions(s);
   return {
-    stars: n.tetrust.stars, galaxy: n.tetrust.galaxy, galaxyAt: n.tetrust.galaxyAt, music: n.tetrust.music, sfx: n.tetrust.sfx,
+    sky: skyFor(n, 'tetrust'), music: n.tetrust.music, sfx: n.tetrust.sfx,
     ghostColour: n.tetrust.ghostColour, ghostWidth: n.tetrust.ghostWidth,
     neon: n.tetrust.neon, neonSource: n.tetrust.neonSource === 'colour' ? 'colour' : 'temperature', neonColour: n.tetrust.neonColour, neonBrightness: n.tetrust.neonBrightness,
     grid: n.tetrust.grid, gridColour: n.tetrust.gridColour, gridBrightness: n.tetrust.gridBrightness,
     // 0.06, not 0.18: the well draws its grid fainter than the brick courts do, because the stack
     // sits on top of it. That difference was hardcoded in tetrust.js; it lives here now.
     gridOpts: courtGridColours(n.tetrust.gridColour, n.tetrust.gridBrightness, 0.06),
-    starDensity: sky.starDensity, starBrightness: sky.starBrightness,
-    nebulae: sky.nebulae, galaxies: sky.galaxies, dust: sky.dust, clusters: sky.clusters, starColours: sky.starColours, starGlints: sky.starGlints,
+  };
+}
+
+/** Scorched Yard's switches and rules, with the sky's make-up from the Sky group. */
+export function scorchedOptions(s) {
+  const n = normalise(s);
+  const sc = n.scorched;
+  return {
+    sky: skyFor(n, 'scorched'), sfx: sc.sfx, music: sc.music, talk: sc.talk, roundSky: sc.roundSky, fast: sc.fast, cheat: sc.cheat, aimGuide: sc.aimGuide, helper: sc.helper, confirmLast: sc.confirmLast, demo: sc.demo,
+    grid: sc.grid, gridColour: sc.gridColour, gridBrightness: sc.gridBrightness,
+    gridOpts: courtGridColours(sc.gridColour, sc.gridBrightness, 0.08),
+    opponents: sc.opponents, opponentKind: sc.opponentKind, rounds: sc.rounds, walls: sc.walls, wind: sc.wind, gravity: sc.gravity, land: sc.land, cash: sc.cash, interest: sc.interest,
   };
 }
 
@@ -990,13 +1261,8 @@ export function marketsOptions(s) {
     // as the sky, so driving it from the star switch restyled the whole board when the operator
     // only wanted the stars gone. The sky has its own option now.
     space: true,
-    stars: mk.stars,
-    starDensity: n.sky.density,
-    starBrightness: n.sky.brightness,
-    galaxy: n.sky.galaxy,
-    galaxyAt: n.sky.galaxyAt,
-    nebulae: n.sky.nebulae, galaxies: n.sky.galaxies, dust: n.sky.dust, clusters: n.sky.clusters,
-    starColours: n.sky.colours, starGlints: n.sky.glints,
+    // the sky this board chose (skyFor): the Kiosk's right panel is this board
+    ...skyFor(n, 'markets'),
     // never, at any setting: the halo under the grid lines is not wanted on this board
     neonHalo: 'rgba(0,0,0,0)',
     gridGlow: 'rgba(0,0,0,0)',
@@ -1007,7 +1273,9 @@ export function marketsOptions(s) {
     ...(mk.effects ? {} : { idleFx: false, transition: MOTION.still }),
     // ITS OWN SWITCHES (operator, 2026-09-14: "settings specific to market panel"): the Market
     // effects group, not the block board's
-    fxKinds: enabledEffects(n, 'marketEffects'),
+    // the market effects go off under the Earth the way the Space effects do: a supernova over a
+    // blue afternoon is wrong on this board too
+    fxKinds: skyOf(n, 'markets') === 'earth' ? [] : enabledEffects(n, 'marketEffects'),
     fxNoRepeat: n.marketEffects.noRepeat,
     ...fxCadence(n.marketEffects),
   };