@bitmagic/cli 0.1.83-dev.2 → 0.1.83-dev.4

package/dist/vendor/hud-theme/engine/hud/presets.js

@@ -0,0 +1,80 @@
+import { BITMAGIC_THEME_DATA } from './themes/bitmagic.js';
+import { RIFT_RAIDER_THEME_DATA } from './themes/rift-raider.js';
+import { VILLAGE_KEEP_THEME_DATA } from './themes/village-keep.js';
+import { NEXUS_THEME_DATA } from './themes/nexus.js';
+import { SIMULATOR_THEME_DATA } from './themes/simulator.js';
+import { RACING_THEME_DATA } from './themes/racing.js';
+import { validateAndResolveTheme } from './validateTheme.js';
+// Built-in theme presets — THE FIVE SELECTABLE STYLES. Each preset's raw data
+// lives in its own TS module (themes/*.ts) and goes through
+// validateAndResolveTheme — so the same path that user themes go through
+// catches preset bugs at engine boot.
+//
+// `bitmagic` is deliberately NOT in this set. It is the engine's DEFAULT/
+// FALLBACK look (what a game with no `hud.theme` — or an invalid one — renders
+// with), exported as DEFAULT_HUD_THEME. Listing it as a preset made every "cycle
+// all styles" feature show six looks and every agent catalogue advertise a
+// style that is really the absence of one.
+//
+// Built-in presets are TS modules, not .json files, because the engine runtime
+// loads modules from /dist/ where tsc doesn't copy non-TS files. User-authored
+// themes ship as theme.json on disk (next to world.json) and are fetched +
+// validated at game load time.
+/** The five selectable presets, in catalogue order. `PresetName` is derived from this list. */
+export const PRESET_NAMES = ['rift-raider', 'village-keep', 'nexus', 'simulator', 'racing'];
+/**
+ * Each preset's RAW data — the inline-theme shape, plus its `evokes` label — before
+ * validation. Tools that patch a preset start from this ("preset X but with orange
+ * accents"): it can be spread, edited and written back as an inline theme.
+ */
+export const PRESET_THEME_DATA = {
+    'rift-raider': RIFT_RAIDER_THEME_DATA,
+    'village-keep': VILLAGE_KEEP_THEME_DATA,
+    nexus: NEXUS_THEME_DATA,
+    simulator: SIMULATOR_THEME_DATA,
+    racing: RACING_THEME_DATA,
+};
+/** The default look's raw data (`bitmagic`) — the patch base when a game sets no theme. */
+export const DEFAULT_THEME_DATA = BITMAGIC_THEME_DATA;
+/**
+ * The one-line mood label each preset carries beside its tokens.
+ *
+ * Exported separately because `evokes` is deliberately NOT part of `ThemeTokens`
+ * — it is authoring metadata for whoever (or whatever) is choosing a preset, not
+ * a rendering token, and `validateAndResolveTheme` drops it on the way through.
+ * The agent's catalogue reads it from here, so a style and its description are
+ * one edit.
+ */
+export const PRESET_EVOKES = {
+    'rift-raider': PRESET_THEME_DATA['rift-raider'].evokes,
+    'village-keep': PRESET_THEME_DATA['village-keep'].evokes,
+    nexus: PRESET_THEME_DATA.nexus.evokes,
+    simulator: PRESET_THEME_DATA.simulator.evokes,
+    racing: PRESET_THEME_DATA.racing.evokes,
+};
+function resolvePreset(raw, name) {
+    const result = validateAndResolveTheme(raw);
+    if (!result.ok) {
+        throw new Error(`Built-in preset "${name}" failed validation: ` +
+            result.errors.map(e => `${e.path}: ${e.message}`).join('; '));
+    }
+    return result.theme;
+}
+/**
+ * The engine's default look — applied when a game sets no `hud.theme`, and the
+ * fallback when a theme is unknown or fails validation. Not a selectable preset.
+ */
+export const BITMAGIC_THEME = resolvePreset(BITMAGIC_THEME_DATA, 'bitmagic');
+export const DEFAULT_HUD_THEME = BITMAGIC_THEME;
+export const RIFT_RAIDER_THEME = resolvePreset(RIFT_RAIDER_THEME_DATA, 'rift-raider');
+export const VILLAGE_KEEP_THEME = resolvePreset(VILLAGE_KEEP_THEME_DATA, 'village-keep');
+export const NEXUS_THEME = resolvePreset(NEXUS_THEME_DATA, 'nexus');
+export const SIMULATOR_THEME = resolvePreset(SIMULATOR_THEME_DATA, 'simulator');
+export const RACING_THEME = resolvePreset(RACING_THEME_DATA, 'racing');
+export const HUD_PRESETS = {
+    'rift-raider': RIFT_RAIDER_THEME,
+    'village-keep': VILLAGE_KEEP_THEME,
+    nexus: NEXUS_THEME,
+    simulator: SIMULATOR_THEME,
+    racing: RACING_THEME,
+};

package/dist/vendor/hud-theme/engine/hud/resolveWorldTheme.js

@@ -0,0 +1,66 @@
+import { DEFAULT_HUD_THEME, HUD_PRESETS } from './presets.js';
+import { suggestClosest, validateAndResolveTheme } from './validateTheme.js';
+// Resolve a `hud.theme` value from world.json into a ThemeTokens.
+//
+//   - undefined / null / unknown shape → DEFAULT_HUD_THEME (the engine's default look)
+//   - string matching a preset name    → the preset
+//   - string not matching any preset   → DEFAULT_HUD_THEME + console warning
+//                                        (this includes legacy names such as
+//                                        'bitmagic' and 'horror' — the first
+//                                        IS the default, so it is visually a
+//                                        no-op; the second no longer ships)
+//   - object                           → validateAndResolveTheme(obj). On success,
+//                                        the resolved theme. On failure, DEFAULT_HUD_THEME
+//                                        + console warning that includes field paths.
+//
+// This is the single integration point: don't bypass it. The engine calls it
+// once per loadGame() after world data is parsed. Failures never block the game
+// from loading — a broken theme is recoverable; failing the load is not.
+/**
+ * The marker on every theme-resolution console warning, and the two phrases that say which
+ * failure it was. `bitmagic verify` parses them out of the console (it imports these constants
+ * through `@bitmagic/hud-theme`), and it reads warnings from engines of every vendored version, so
+ * the wording is frozen: never reword these, only append detail after them.
+ */
+export const HUD_THEME_LOG_MARKER = '[HUD]';
+/** The phrase after the marker when `hud.theme` is a string that names no preset. */
+export const HUD_UNKNOWN_PRESET_PHRASE = 'Unknown theme preset';
+/** The phrase after the marker when `hud.theme` is an object the validator rejected. */
+export const HUD_INVALID_THEME_PHRASE = 'Custom theme failed validation';
+function isPresetName(value) {
+    return value in HUD_PRESETS;
+}
+export function resolveWorldTheme(value) {
+    if (value === undefined || value === null)
+        return DEFAULT_HUD_THEME;
+    if (typeof value === 'string') {
+        if (isPresetName(value))
+            return HUD_PRESETS[value];
+        // The closest-match hint catches the two real spelling traps: the
+        // unhyphenated internal style keys (`riftraider`) and plain typos.
+        const close = suggestClosest(value, Object.keys(HUD_PRESETS));
+        console.warn(`${HUD_THEME_LOG_MARKER} ${HUD_UNKNOWN_PRESET_PHRASE} "${value}". Known presets: ${Object.keys(HUD_PRESETS).join(', ')}.`
+            + `${close ? ` Closest match: "${close}".` : ''} Falling back to the default theme.`);
+        return DEFAULT_HUD_THEME;
+    }
+    const result = validateAndResolveTheme(value);
+    // Suggestions ride in parentheses INSIDE each issue. The validator's
+    // `suggestion` field carries the actionable half of every message — the
+    // closest-match name, the font-case remedy — and this warn used to format
+    // only `path: message`, so the hint was computed and then thrown away at
+    // the last hop. This console line is the ONLY channel the CLI lane has
+    // (`bitmagic verify` parses it; there is no write-tool there to return
+    // suggestions), so dropping it here dropped it everywhere.
+    // The marker and the two leading phrases are `bitmagic verify`'s parse
+    // contract (see the constants above) — the suggestion text extends the
+    // detail and must never reword them.
+    const formatIssue = (issue) => `${issue.path}: ${issue.message}${issue.suggestion ? ` (${issue.suggestion})` : ''}`;
+    if (!result.ok) {
+        console.warn(`${HUD_THEME_LOG_MARKER} ${HUD_INVALID_THEME_PHRASE}; falling back to the default theme. Errors:`, result.errors.map(formatIssue).join('; '));
+        return DEFAULT_HUD_THEME;
+    }
+    if (result.warnings.length > 0) {
+        console.warn(`${HUD_THEME_LOG_MARKER} Custom theme has warnings:`, result.warnings.map(formatIssue).join('; '));
+    }
+    return result.theme;
+}

package/dist/vendor/hud-theme/engine/hud/themes/bitmagic.js

@@ -0,0 +1,29 @@
+// Bitmagic theme — the default. Mirrors creator/DESIGN.md (Aquamarine primary,
+// Shocking Pink danger, etc.). Goes through validateAndResolveTheme in presets.ts
+// so any drift between this object and the schema fails at engine boot.
+export const BITMAGIC_THEME_DATA = {
+    name: 'Bitmagic',
+    font: {
+        key: 'red-hat-display',
+        case: 'upper',
+        weightBody: 400,
+        weightHeading: 700,
+        trackingLabel: 1.6,
+    },
+    colors: {
+        primary: '#A0DAB9',
+        danger: '#E0218A',
+        warning: '#FF8200',
+        success: '#F9E547',
+        background: '#0b0b0b',
+        surface: '#181818',
+        text: '#ffffff',
+        textMuted: '#b3b3b3',
+    },
+    shape: {
+        radiusPill: 500,
+        radiusCard: 8,
+        glow: 'aqua',
+        imageRendering: 'auto',
+    },
+};

package/dist/vendor/hud-theme/engine/hud/themes/nexus.js

@@ -0,0 +1,69 @@
+// Nexus theme — holographic sci-fi conventions (the "Nexus" kit style):
+// hairline cyan on near-black, chamfer-small radii, wide-tracked tech caps,
+// corner brackets and a circuitry backdrop. Depth is carried by glow alone —
+// hairline PANELS; buttons carry a bevel and a 2px rim. Threat states run orange.
+export const NEXUS_THEME_DATA = {
+    name: 'Nexus',
+    // One-line mood label, read by the agent catalogue so an AI picks the right
+    // preset without trying each one. It lives HERE, beside the tokens it
+    // describes, so that changing the style and changing its description are the
+    // same edit — it drifted badly when it lived only in the agent mirror. The
+    // engine validator ignores unknown top-level keys, so this never reaches
+    // ThemeTokens; `PRESET_EVOKES` in presets.ts is what exposes it.
+    evokes: 'Holographic sci-fi — hairline cyan on near-black, corner brackets, lit teal plate buttons with a graded cyan bezel, depth by glow (Mass Effect-style)',
+    font: {
+        key: 'chakra-petch',
+        case: 'upper',
+        weightBody: 500,
+        weightHeading: 700,
+        // 1.4, not 2.5: orbitron is the widest face in the catalogue and at
+        // 2.5px per glyph a label like "RIFT PROGRESS" nearly fills the corner
+        // anchor budget on a phone, breaking mid-word. Wide tracking also costs
+        // word cohesion at HUD sizes — the opposite defect from the lab's Nexus.
+        trackingLabel: 1.4,
+        outlineWidth: 0,
+    },
+    colors: {
+        primary: '#4FD8E8',
+        danger: '#FF6B4A',
+        warning: '#F0A22E',
+        success: '#6FD9A4',
+        background: '#04070C',
+        surface: '#0A121A',
+        text: '#E6F6FA',
+        // Lifted from '#7EA3B2'. Checked against the panel's LIT header band
+        // rather than its nominal face — a secondary label that clears on the
+        // flat colour can still miss where the face gradient is brightest.
+        textMuted: '#9DBBC8',
+        outline: '#2E9FB5',
+    },
+    shape: {
+        // Buttons are OBJECTS even when the panels are flat: `bevel` paints the
+        // white-top/dark-bottom gradient over buttons, counters and bars, and a
+        // 2px border in colors.outline follows the radius. The plates keep their
+        // hairline language — only the controls gain relief.
+        radiusPill: 6,
+        radiusCard: 4,
+        glow: 'cyan',
+        imageRendering: 'auto',
+        borderWidth: 2,
+        bevel: 0.5,
+    },
+    // NO `controls` backdrop. `circuit-trace` used to sit here and rendered as
+    // GIANT CROSSHAIRS across the controls overlay rather than the fine PCB
+    // texture it is meant to be — see the sizing note on the decoration itself.
+    // The pattern is fixed now, but this style does not need it: the corner
+    // brackets already carry the scanner language, and a texture behind the
+    // control hints competed with the type sitting on top of it.
+    decorations: {
+        progressBar: { borderImage: 'bracket-frame' },
+        counter: { borderImage: 'bracket-frame' },
+        // `backdrop`, not `decorationBefore`. The before/after slots are 12px
+        // strips hung OUTSIDE the element, so what this asked for was a glow
+        // floating above the crosshair rather than around it — and glow-aura's
+        // whole intent is "soft radial glow halo BEHIND the element". It never
+        // showed either way, because the slot itself could not render (see
+        // buildSlotCss), so the mistake was invisible until the slot was fixed.
+        reticle: { backdrop: 'glow-aura' },
+    },
+};

package/dist/vendor/hud-theme/engine/hud/themes/racing.js

@@ -0,0 +1,57 @@
+// Racing theme — motorsport telemetry conventions (the "Racing" kit style):
+// white line-art structure on near-black, red reserved for STATE, tall condensed
+// display caps, hard corners, nothing glazed. Danger is a hot red-orange kept
+// distinct from the crimson brand; caution is amber; sectors are green.
+export const RACING_THEME_DATA = {
+    name: 'Racing',
+    // One-line mood label, read by the agent catalogue so an AI picks the right
+    // preset without trying each one. It lives HERE, beside the tokens it
+    // describes, so that changing the style and changing its description are the
+    // same edit — it drifted badly when it lived only in the agent mirror. The
+    // engine validator ignores unknown top-level keys, so this never reaches
+    // ThemeTokens; `PRESET_EVOKES` in presets.ts is what exposes it.
+    evokes: 'Motorsport telemetry — white line-art chrome on black with red reserved for state, tall narrow gothic caps, amber caution / green sector',
+    font: {
+        key: 'archivo-narrow',
+        case: 'upper',
+        weightBody: 500,
+        weightHeading: 700,
+        trackingLabel: 1.2,
+        outlineWidth: 0,
+    },
+    colors: {
+        // NOT red. The engine spends `primary` on both FILLS and accent TYPE —
+        // 13 `color: var(--hud-color-primary)` sites in hudBaseStyles/modalCard
+        // (lobby title + status, success toast, reticle, counters, modal title)
+        // plus whatever the game's own panels use it for. Any red here is red
+        // TYPE on a near-black HUD, which is what kept getting reported, and no
+        // saturated red can be fixed by tuning: even pure #FF0000 tops out at
+        // 4.87:1 on this surface.
+        //
+        // So Racing takes the OTHER half of its own reference: white line-art
+        // chrome, with red reserved for state. Red did not leave the style — it
+        // moved to `danger` below, where it means the redline, a failed run and
+        // critical health, which is exactly how a real timing board uses it.
+        primary: '#E8EDF2',
+        danger: '#FF4D3A',
+        warning: '#FFB000',
+        success: '#22C55E',
+        background: '#07090C',
+        surface: '#0E1319',
+        text: '#F2F5F8',
+        textMuted: '#9BA4AE', // 5.99:1 -> 7.39:1 under bebas-neue's narrow strokes
+        outline: '#C9D2DA',
+    },
+    shape: {
+        // Buttons are OBJECTS even when the panels are flat: `bevel` paints the
+        // white-top/dark-bottom gradient over buttons, counters and bars, and a
+        // 2px border in colors.outline follows the radius. The plates keep their
+        // hairline language — only the controls gain relief.
+        radiusPill: 4,
+        radiusCard: 2,
+        glow: 'none',
+        imageRendering: 'auto',
+        borderWidth: 2,
+        bevel: 0.5,
+    },
+};

package/dist/vendor/hud-theme/engine/hud/themes/rift-raider.js

@@ -0,0 +1,63 @@
+// Rift Raider theme — mobile action-RPG conventions (the "Rift Raider" kit
+// style): cast-gold medallion frames on dark INDIGO glass, cream display type
+// with a dark bronze stroke, ornate royal borders and a leather-grain backdrop.
+// The outline token is the dark keyline, not the gold: it edges gold buttons AND
+// strokes cream text, and both read right in bronze.
+//
+// The reference's material law is that GOLD IS TRIM, NOT FILL — it belongs to
+// the band around a dark face, never to the face itself. `primary` stays gold
+// because the engine spends it on frames, rules and accent type; the faces it
+// sits against come from `surface`.
+export const RIFT_RAIDER_THEME_DATA = {
+    name: 'Rift Raider',
+    // One-line mood label, read by the agent catalogue so an AI picks the right
+    // preset without trying each one. It lives HERE, beside the tokens it
+    // describes, so that changing the style and changing its description are the
+    // same edit — it drifted badly when it lived only in the agent mirror. The
+    // engine validator ignores unknown top-level keys, so this never reaches
+    // ThemeTokens; `PRESET_EVOKES` in presets.ts is what exposes it.
+    evokes: 'Mobile action-RPG — cast-gold medallion frames on dark indigo glass, chunky cream type with a dark ink ring, royal borders (Diablo-style)',
+    font: {
+        // Baloo 2, not lilita-one: Google serves Lilita One at a single weight,
+        // so `weightBody` and `weightHeading` both collapsed to 400 and this
+        // preset had NO type hierarchy at all — the one thing a HUD needs to
+        // separate a label from the value it labels. Baloo 2 is the same
+        // rounded chunky voice and ships 400-800, and it is the face the kit
+        // half of this style already uses.
+        key: 'baloo-2',
+        case: 'upper',
+        weightBody: 500,
+        weightHeading: 700,
+        trackingLabel: 0.8,
+        outlineWidth: 2,
+    },
+    colors: {
+        primary: '#F0B23A',
+        danger: '#D6332E',
+        warning: '#E07A28',
+        success: '#5FB35A',
+        // The dark ladder sits at hue ~256, not the old ~217. This style's
+        // violet accents live at 269, and against a hue-217 navy the surfaces
+        // and the accents read as two unrelated colour families sharing a
+        // screen. Lightness is held; only hue moves.
+        background: '#0B0716',
+        surface: '#191228',
+        text: '#FFF6E2',
+        textMuted: '#B9A889',
+        outline: '#5A3D0C',
+    },
+    shape: {
+        radiusPill: 14,
+        radiusCard: 14,
+        glow: 'gold',
+        imageRendering: 'auto',
+        borderWidth: 2,
+        bevel: 0.85,
+    },
+    decorations: {
+        progressBar: { borderImage: 'royal-frame' },
+        healthBar: { borderImage: 'royal-frame' },
+        toast: { borderImage: 'royal-frame' },
+        controls: { backdrop: 'grain-texture' },
+    },
+};

package/dist/vendor/hud-theme/engine/hud/themes/simulator.js

@@ -0,0 +1,55 @@
+// Simulator theme — instrument-panel conventions (the "Simulator" kit style):
+// flat slate plates, hard corners, neutral grey-blue structure and ONE azure
+// accent reserved for state. No glow and no decoration on the plates — the seriousness
+// IS the absence of jewellery. Bars run semantic green / amber / red.
+export const SIMULATOR_THEME_DATA = {
+    name: 'Simulator',
+    // One-line mood label, read by the agent catalogue so an AI picks the right
+    // preset without trying each one. It lives HERE, beside the tokens it
+    // describes, so that changing the style and changing its description are the
+    // same edit — it drifted badly when it lived only in the agent mirror. The
+    // engine validator ignores unknown top-level keys, so this never reaches
+    // ThemeTokens; `PRESET_EVOKES` in presets.ts is what exposes it.
+    evokes: 'Serious instrument panel — flat slate, hard corners, one azure accent for state, thin meters and a bare dial, no glow or ornament (flight/truck sim)',
+    font: {
+        key: 'ibm-plex-sans',
+        case: 'upper',
+        weightBody: 400,
+        weightHeading: 700,
+        trackingLabel: 0.8,
+        outlineWidth: 0,
+    },
+    colors: {
+        primary: '#2E9BDB',
+        danger: '#C8453F',
+        warning: '#D8A32E',
+        success: '#4E9E57',
+        background: '#0E141B',
+        surface: '#161E27',
+        text: '#DDE5EC',
+        textMuted: '#A2B0BE', // 4.84:1 -> 7.60:1; 4.5:1 is a 12-14px bar, not a 10px one
+        outline: '#46586A',
+    },
+    shape: {
+        // CONTOURED, NOT MOULDED — and that split is deliberate.
+        //
+        // The reference has neither: across eight screens of the Farming
+        // Simulator UI there is not one moulded control, and the first pass
+        // took it literally and set `bevel: 0`. Dead flat read as underdrawn
+        // next to the rest of the kit, so the call was made to depart from the
+        // reference here: `bevel` is what paints the white-top/dark-bottom
+        // gradient over buttons, counters and bars, and a modest 0.35 gives the
+        // fill and edge some depth.
+        //
+        // What stays gone is the SILHOUETTE moulding — the lip, the dome, the
+        // cast shadow — which is what made this style look like a mobile game
+        // wearing a simulator's palette. `borderWidth` stays 1: the edge here is
+        // a hairline, not the 2px rim the four physical styles carry.
+        radiusPill: 4,
+        radiusCard: 2,
+        glow: 'none',
+        imageRendering: 'auto',
+        borderWidth: 1,
+        bevel: 0.35,
+    },
+};

package/dist/vendor/hud-theme/engine/hud/themes/village-keep.js

@@ -0,0 +1,108 @@
+// Village Keep theme — cartoon-strategy conventions (the "Village Keep" kit
+// style): a light parchment ground for the big UI, darker moulded furniture for
+// the HUD itself, candy-green buttons, rounded everything, maximum gloss and
+// zero glow.
+//
+// THREE LEVELS, and they are the whole point of this preset:
+//
+//   background  #E9E1CE   the light ground the BIG UI stands on — a game's own
+//                         dialogs and panels paint themselves with this, and the
+//                         lobby's text input is a light well because of it.
+//   surface     #6E5C44   the HUD FURNITURE — counters, timers, toasts, the
+//                         controls box, bubbles. 4.92:1 darker than the ground it
+//                         sits on and 3.29:1 against a sunny-green world, so it
+//                         reads as an object laid over the field rather than a
+//                         patch of it.
+//   trough      #3A3126   per-element, for the two bars: a channel has to be the
+//                         darkest thing in the widget or the fill cannot be the
+//                         brightest.
+//
+// Getting those three apart needed an engine token. `text` used to carry two
+// jobs — ink on the light ground AND ink on the furniture — which only agree on a
+// uniformly dark theme. With one ink the furniture caps out around #9E9276, which
+// is 1.4:1 against grass and so is not furniture at all; that ceiling is why this
+// style spent three rounds flipping between a washed-out HUD and a uniformly dark
+// one. `--hud-color-on-surface` (see ThemeManager) derives the second ink, so the
+// ground can stay light while the furniture goes as dark as it needs to. Here it
+// resolves to white at 6.41:1, and its muted companion to #DEDAD5 at 4.65:1.
+//
+// What the palette still has to solve by hand:
+//
+//  - `primary`, `danger` and `warning` are each a FILL colour and an accent TYPE
+//    colour, and on this style the type sits on `surface` (five of the six
+//    `color: var(--hud-color-primary)` rules do). Type wants a light value,
+//    which is the opposite of the usual instinct for a fill — but going light
+//    lets `--hud-color-on-primary` / `--hud-color-on-danger` derive BLACK, and a
+//    dark label on a bright candy fill clears far more than white on a mid one.
+//    Both jobs come out ahead.
+//  - the one place that trade does NOT hold is the health bar, whose fill sits in
+//    a near-black trough where a pale salmon reads as neither red nor alarming.
+//    That is what the per-element overrides at the bottom are for.
+export const VILLAGE_KEEP_THEME_DATA = {
+    name: 'Village Keep',
+    // One-line mood label, read by the agent catalogue so an AI picks the right
+    // preset without trying each one. It lives HERE, beside the tokens it
+    // describes, so that changing the style and changing its description are the
+    // same edit — it drifted badly when it lived only in the agent mirror. The
+    // engine validator ignores unknown top-level keys, so this never reaches
+    // ThemeTokens; `PRESET_EVOKES` in presets.ts is what exposes it.
+    evokes: 'Cartoon strategy — light parchment panels with darker moulded HUD chips over a sunny world, candy-green glossy buttons, ink-outlined type, zero glow (Clash-style)',
+    font: {
+        key: 'fredoka',
+        case: 'upper',
+        weightBody: 500,
+        weightHeading: 700,
+        trackingLabel: 0.6,
+        // Light type on the furniture wants a dark ring — the pairing the ink
+        // ring was invented for, and what keeps the bar's inside-value legible
+        // where it crosses its own fill.
+        outlineWidth: 2,
+    },
+    colors: {
+        primary: '#9BDB4F', // 3.86:1 as accent type on the furniture; auto-label black 12.64
+        danger: '#FFA898', // 3.45:1 as type; auto-label black 11.31
+        warning: '#FFC46B', // 4.08:1 as type; the mobile button's black label 13.36
+        success: '#A5E27E', // 4.20:1 as type
+        background: '#E9E1CE',
+        surface: '#6E5C44',
+        text: '#413A2C', // 8.64:1 on the ground — this ink is for the BIG UI
+        textMuted: '#585040', // 6.12:1 on the ground
+        outline: '#3A6212', // dark forest edge: the button's ring and the panel's border
+    },
+    shape: {
+        radiusPill: 14,
+        radiusCard: 18,
+        glow: 'none',
+        imageRendering: 'auto',
+        borderWidth: 3,
+        bevel: 0.9,
+    },
+    decorations: {
+        // The gloss is on the small pill only. On a near-black surface it cost
+        // nothing to put it on the controls box as well, but against mid-brown
+        // furniture the highlight lifts the backdrop under the first key rows far
+        // enough to take their muted label from 4.65:1 to 3.88:1 — and a
+        // highlight is a button-and-chip device in the reference anyway, not
+        // something laid across an information panel.
+        toast: { backdrop: 'candy-gloss' },
+    },
+    elements: {
+        // `background` is the light ground now, and `hudBaseStyles` paints a bar
+        // TRACK with it — which would put a light fill inside a light channel and
+        // leave the reading to guesswork. The reference settles it the same way:
+        // its resource meters are near-black troughs precisely so the coloured
+        // fill is the brightest thing in the bar.
+        progressBar: { colors: { background: '#3A3126' } },
+        healthBar: {
+            colors: {
+                background: '#3A3126',
+                // Deeper than the global values, which are tuned to be legible as
+                // TYPE on the mid-brown furniture. In a near-black trough that
+                // tuning inverts: a pale salmon is 1.9:1 there and reads as
+                // neither red nor urgent, where this is 3.11:1 and unmistakable.
+                danger: '#E2452F',
+                warning: '#E89A2A',
+            },
+        },
+    },
+};