Visual Experiments 5

Summary

Continuation of the ricochet-template visual-experiments arc (follows "Visual Experiments 4"). This session built the component catalog — all of reference sheet 02/03/05's UI elements as default builds in BOTH skins — then ran a UI-API ergonomics pass (uniform returns, contract + layout helpers), then made the package genuinely fork-ready (moved the core into ricochet/, labs into lab/), wrote docs (README + CLAUDE.md fork guide), and published the GitHub repo a327ex/ricochet-template.

Orientation + the key finding (up front):

The work target was ricochet-template/ (not RETICLE/). The user's framing — "both smooth and rough skins," "cards in the rough lab but not smooth" — is the two-skin toolkit in ricochet-template/ricochet/ (skin_smooth.lua + skin_rough.lua). RETICLE/ is a smooth-only scaffold; its design.md + reference/visual_reference.html and the numbered sheets in E:/a327ex/Ricochet/reference/ (02 GENERAL UI ELEMENTS, 03 TYPOGRAPHY, 05 GAME OBJECTS) are the visual reference only.
Audit finding: the composites the user remembered (cards/hud bars/etc.) were never ported into either skin — they existed only as screen-local functions (smooth in showcase.lua: card/hud_bar/badge_row/ability_bar/segbar/ tooltip; rough inline in main_rough.lua's draw_shop/draw_hud). So the task = promote them into real ui_* widgets in both skins + show them in screens.
Reference-image cropping gotcha: PowerShell System.Drawing hit a hard ~1-large-bitmap-per-process GDI+ ceiling in this sandbox (deterministic "Out of memory"/"Parameter is not valid" after the first bitmap, even with Dispose+GC). Workaround: one source image + one crop per process invocation. Leaned on the CODE (showcase.lua / rough_ui.lua / the skins) as the authoritative fidelity source instead of squinting at the 1491×1055 sheets.

Decisions (AskUserQuestion): catalog style (mirror sheet 02, labeled sub-sections) · "everything reusable" (even composites become ui_* widgets) · build order = mine. Standing rule reaffirmed: smooth and rough are different DESIGNS, not just sizes — smooth = more expressive, rough = more constrained; note the divergence per element.

Screens built (one increment each, user tested between):

CARDS & UPGRADE CHIPS — new ui_card + ui_upgrade_chip. Corrections the user drove: removed the rarity colored outline (smooth 2px inner border / rough accent top-edge); selection = ink corner brackets only; rarity shown as a [ RARE ] bracket-tag bottom-left (the ui_tag idiom); added monochrome mode (ricochet_mono global + ric.accent(col) → ink when on; catalog toggles with C). Rough card spacing reworked to mirror the lab SHOP card (16px top margin, 32px icon, footer floated to bottom; m.inset=4 was too tight). Rarity→token map: common→mid_grey, uncommon→green, rare→blue, epic→pink, legendary→orange.
BUTTONS & CONTROLS — new shared ui_icon_button (square icon-only; same design both skins, only size differs → lives in ui.lua, reads new metrics.icon_btn 38/18). Added a disabled flag to ui_button. Fixed ui_segment's right-edge sliver (integer floor(sw/n) per cell left a remainder inside the outer frame → switched to fractional-floor cell widths like tabs).
COUNTERS & BADGES — new ui_counter (small-caps label above a framed [icon value] box) + ui_status_tag (framed [icon UPPERCASE] buff/debuff chip).
TOP HUD BARS — new composite widgets ui_hud_bar (icon + filled track + value), ui_segbar (segmented wave/xp meter), ui_ability_slot (slot + icon + corner keycap + bottom-up cooldown sweep). Fixed rough hud_bar value text overrunning the track border: value reserve now computed from text_width(value) (any font).
PANELS & WINDOWS — new ui_menu_item (smooth = left stripe + recess fill; rough = centered + corner brackets, matching ru_menu_item). Composed PAUSED / WAVE SUMMARY / SETTINGS panels. SFX/SCREEN SHAKE toggles → checkboxes (user: toggles are "always confusing… why not a checkbox"). Flipped ric.brackets arm direction (vertex sits gap outside the corner, arms run INWARD along the edges — the lab's ru_brackets "frame-corner" look) so the rough menu selection points outward and only sticks out by gap (was flaring out arm+gap and overlapping the title divider / neighbors). This was a package-wide bracket fix.
SELECTORS & INPUTS — new ui_text_input (focus-aware: click to focus → recess fill + caret; real key entry isn't in the substrate so value is caller-supplied). Screen: tabs/segment/slider/toggle/checkbox/radio (col A), dropdown/stepper/cycler-field/text-input/states (col B). Runtime crash fixed: ui_stepper builds id..'_dn' → passing no id threw "attempt to concatenate nil"; added id='s_step' (later hardened by ric.req_id).
TYPOGRAPHY — layout-craft specimen mirroring Anchor2/site/main.lua (numbered mono micro-labels, full-width hairline rhythm, 3-level ink hierarchy ink/mid_light/mid_grey). New shared ric.text_scaled (integer-upscale pixel fonts for crisp rough titles). Smooth registers specimen Oswald 44/30/20 + Plex 16/13 + Cascadia 13/11 locally; rough uses theme pixel fonts + text_scaled. Smooth = 3-column scale (DISPLAY/BODY/MONO) + paragraph w/ emphasis run; rough = stacked scale + 3-line paragraph. Fixed the wordmark/breadcrumb top-left overlap (started at top where the chrome draws → moved to content_top) and gave the smooth "Section Heading" more room above the 01/02 rule.

UI-API ergonomics pass (after the user asked whether the API is generalizable):

Surveyed snkrx-template's snkrx/ and the Anchor App (Anchor2/app-archive/) UI for insights (both: opts-table immediate-mode, caller-owned state, explicit ids, RectCut layout; snkrx returns "always a table", the App ui_button returns a bare bool; the App has rect_contract/center/split + ui_strip_text_* flow + declarative workspace slot templates).
Diagnosed ricochet's warts: inconsistent return shapes (number / table / nil, unpredictable), no layout help surfaced (rectcut shipped but unused; heading/ sublabel/spacing lived in components.lua), contract boilerplate + the silent effect_clear footgun, and the id-crash.
Fix (user chose "cheap bundle + standardize returns + layout helpers"):
- Uniform returns — every widget returns a TABLE via ric.ret(x,y,w,h,fields): always next_x/next_y (+ sp.s2 gap, for chaining) plus its fields (clicked/value/checked/on/index/dir/content_y/…). Rewrote both skin files (geometry preserved verbatim, only returns + id-guards changed).
- Contract helpers — ui_capture_input() (update), ui_begin() (= ui_state_begin_frame + effect_clear(ui_layer)), ui_end() (reset edges).
- Layout helpers — ricochet_theme.sp spacing scale (per mode), package ui_heading/ui_sublabel, and ui_stack(x,y[,gap]) cursor (:take(h) / :heading / :sublabel). components.lua rewritten to demonstrate them (ui_stack drives BUTTONS + SELECTORS).
- id guard — ric.req_id(o,'name') → clear error; ric.interact asserts.
- main.lua updated (its ui_panel{...} + M.inset would crash now panel returns a table → .content_y). Verified: no bare returns remain, all files parse.

Fork-readiness / generalization (the final task — the VE-4 plan that didn't land):

VE-4 deliberately KEPT effect/palette/ui_state/rectcut at root so the frozen labs' bare require('effect') wouldn't break — leaving root cluttered. The user wanted true snkrx-parity: a fork copies the folder, edits main.lua + own files, require('ricochet').
Moves (no git repo, plain mv): the 4 requireless core leaf modules → ricochet/; the 7 frozen v1 files (lab/main_rough/ui/ui_controls/ showcase/editor/rough_ui) → lab/ (kept runnable). Only 4 entry files needed require-path edits: ricochet/init.lua (→ ricochet.effect etc.), main.lua (require('lab.lab')), lab/lab.lua + lab/main_rough.lua (core via ricochet.*, own files via lab.*). The 5 v1 widget files use only globals — no edits. Verified: no stale bare requires; every dotted require resolves to a real file; all 18 files parse. (Dotted-require subdir resolution was confirmed in VE-4.)

Docs + repo + close-out:

Wrote README.md (fork-and-use quickstart: copy the folder, 3-line boot, draw an effect, draw UI, the per-frame contract, what's in the box, the two skins).
Updated .claude/CLAUDE.md throughout: "New here? start with README + components.lua" pointer, the widget-API/return contract, the per-frame contract, the "Layout — fork-ready" section, the file-map tree (core in ricochet/, labs in lab/), the rough-build reference, and the roadmap (marked composite screens DONE, recorded the ergonomics pass; remaining: swatch_row + smooth stepper-icon nit + optional DATA/MISC screen; snkrx effect-swap; flow-field rotation; engine CJK atlas).
Added .gitignore (tools/node_modules/), git init -b main, committed (226 files, ~8.6 MB; node_modules excluded, anchor.exe committed), and gh repo create a327ex/ricochet-template --public --source=. --push → https://github.com/a327ex/ricochet-template.

New widgets/helpers this session: ui_card ui_upgrade_chip ui_counter ui_status_tag ui_hud_bar ui_segbar ui_ability_slot ui_icon_button ui_menu_item ui_text_input · ric.ret ric.req_id ric.accent ric.text_scaled · ui_capture_input ui_begin ui_end · ui_heading ui_sublabel ui_stack · ricochet_theme.sp · metrics.icon_btn · ricochet_mono.

Let's continue with the visual experiments. Read the last session's log summary to get aligned. I believe the next task was building multiple component screens to make sure that all UI elements have a default way they're built for both smooth and rough skins. I'll go over which elements exactly I want built for both skins, remember that the skins are different in some slight but important ways, use the differences between the screens that already exist in both labs as guidance, but also use the reference images from the ricochet reference folder. Here, for each image, I'll describe which elements in it that I want you to do:

02 - GENERAL UI ELEMENTS: TOP HUD BARS, COUNTERS & BADGES, BUTTONS & CONTROLS, CARDS & UPGRADE CHIPS (cards already available in rough lab, but I don't think we built their equivalent in smooth mode), PANELS & WINDOWS (some of these also already available in rough lab, no equivalent in smooth mode), SELECTORS & INPUTS.

03 - TYPOGRAPHY: this is already decided for both skins, what I'm looking for here is nailing the spacing between elements, does sequential text with titles of different sizes, paragraphs, etc, look right, do you know how to place it correctly? For the rest, the correct typography for each screen is implicit in all other screens.

05 - GAME OBJECTS: UPGRADE CHIPS - this is the only ones from that image I want

For everything, use a327ex/RETICLE/reference/visual_reference.html as well as the reference. This is the one that's closest to the style in actual code you can read, so where doubt appears, everything should be somewhat based on this as well as a mix of what we already have.

I'll start by getting oriented. Let me find the last session's log summary and explore the RETICLE project structure.

Bash (ls -la "E:/a327ex/RETICLE/" 2>/dev/null && echo "---REFERENCE---" && ls -la "E:/...)

total 4186
drwxr-xr-x 1 adn 197121       0 Apr 22 14:34 ./
drwxr-xr-x 1 adn 197121       0 May 30 22:31 ../
drwxr-xr-x 1 adn 197121       0 Apr 22 14:34 .git/
-rw-r--r-- 1 adn 197121     255 Apr 22 14:13 .gitignore
-rw-r--r-- 1 adn 197121    1280 Apr 22 14:16 README.md
drwxr-xr-x 1 adn 197121       0 Apr 22 14:13 anchor/
-rwxr-xr-x 1 adn 197121 4179968 Apr 22 14:13 anchor.exe*
drwxr-xr-x 1 adn 197121       0 Apr 22 14:13 assets/
-rw-r--r-- 1 adn 197121   72745 Apr 22 14:34 design.md
-rw-r--r-- 1 adn 197121    3527 Apr 22 14:15 main.lua
drwxr-xr-x 1 adn 197121       0 Apr 22 14:13 reference/
-rw-r--r-- 1 adn 197121      42 Apr 22 14:13 run.bat
---REFERENCE---
total 276
drwxr-xr-x 1 adn 197121      0 Apr 22 14:13 ./
drwxr-xr-x 1 adn 197121      0 Apr 22 14:34 ../
-rw-r--r-- 1 adn 197121 276553 Apr 22 14:13 visual_reference.html

Bash (ls -lat "E:/a327ex/a327ex-site/logs/" 2>/dev/null | head -20)

total 58668
drwxr-xr-x 1 adn 197121       0 May 30 23:57 ./
-rw-r--r-- 1 adn 197121  594657 May 30 23:57 visual-experiments-4.md
drwxr-xr-x 1 adn 197121       0 May 30 17:31 ../
-rw-r--r-- 1 adn 197121  397855 May 30 17:29 visual-experiments-3.md
-rw-r--r-- 1 adn 197121  741471 May 29 21:42 visual-experiments-2.md
-rw-r--r-- 1 adn 197121 1117414 May 28 23:33 visual-experiments-1.md
-rw-r--r-- 1 adn 197121  234271 May 27 23:49 mini-looper-road-and-editor.md
-rw-r--r-- 1 adn 197121  237701 May 27 23:41 invoker-template-usage-test.md
-rw-r--r-- 1 adn 197121  248793 May 26 12:21 word-game.md
-rw-r--r-- 1 adn 197121  715128 May 25 01:43 ui-generalization-2.md
-rw-r--r-- 1 adn 197121 1453745 May 21 21:59 ui-generalization-1.md
-rw-r--r-- 1 adn 197121  184851 May 20 22:43 attack-system-generalization-4.md
-rw-r--r-- 1 adn 197121  397076 May 20 17:38 attack-system-generalization-3.md
-rw-r--r-- 1 adn 197121  356736 May 17 22:52 attack-system-generalization-2.md
-rw-r--r-- 1 adn 197121  247453 May 17 14:13 attack-system-generalization-1.md
-rw-r--r-- 1 adn 197121  253566 May 16 23:34 edition-system-generalization.md
-rw-r--r-- 1 adn 197121  287664 May 16 17:34 emoji-aimer-8.md
-rw-r--r-- 1 adn 197121  217144 May 14 23:09 invoker-spellcasting-tree-structure.md
-rw-r--r-- 1 adn 197121  337848 May 14 22:58 emoji-aimer-7.md

The last session is visual-experiments-4.md. Let me read its summary, and explore the lab structure in parallel.

Read (E:/a327ex/a327ex-site/logs/visual-experiments-4.md)

1    Title: Visual Experiments 4
2   Date: 2026-05-30 23:52:20
3   
4   # Visual Experiments 4
5   
6   ## Summary
7   
8   Continuation of the `ricochet-template` visual-experiments work (follows "Visual Experiments 3"). This session did two big things: (1) made the entire effect system + UI read at **480×270 "rough" mode** (the SNKRX low-res render target), and (2) **generalized the whole template into a reusable, resolution-agnostic package** (`require('ricochet')`) with a **two-skin UI toolkit** — mirroring how snkrx-template was generalized. Ended with a slimmed minimal `main.lua`, frozen v1 dev galleries, trimmed assets, a folder-agnostic `run.bat`, and a rewritten `CLAUDE.md`.
9   
10  **Alignment + key architecture facts (up front):**
11  - Read the VE-3 summary + `ricochet-template/.claude/CLAUDE.md`. Confirmed via `anchor.c` that layers are created at `game_width × game_height` (4899) and the draw shader renders into the layer viewport (3975), so at game-size 480×270 **`gl_FragCoord` runs 0..480/0..270** — the dither/shape grids become true 1-logical-pixel cells, upscaled 4× by `rough` (nearest) → crisp pixel-art dithering with **zero shader changes**. The low-res effect work was therefore a *visual tuning + culling* pass, not a rewrite.
12  - Engine constraint: a single global `game_size`; low-res is a **mode switch** (flip the config), not a side-by-side. User chose "do the whole thing as 480×270, fork based on a setting."
13  
14  **`run.bat` made folder-agnostic:** rewrote it to derive its own folder name (`for %%I in ("%~dp0.") do set "GAME=%%~nxI"`) so a copied/renamed fork (e.g. `mini-looper/`) runs without editing run.bat. Verified the cmd idiom in a renamed-copy probe (the MINGW `cmd /c` mangles `/c` → use `cmd //c`).
15  
16  **Icons — picked + fetched (HackerNoon):**
17  - Wrote `tools/compare_pixel_packs.mjs` (Iconify collection API). Data: Pixelarticons 813 names but **no filled style on Iconify** (only `-sharp`); HackerNoon Pixel Icon Library (`pixel` prefix) has clean outline + `-solid` pairs for every core game/HUD icon (heart/star/coin/trophy/crown/fire/bolt/…), 248 solids. Decision: **HackerNoon** (filled requirement decisive; pixel-native 24px grid stays crisp at 16/24 where downscaled Tabler softens). The user confirmed twice by eye ("the 5th column" = HackerNoon).
18  - Fetched 36 HackerNoon icons (outline + `_filled`) via new `tools/fetch_pixel_icons.mjs` → `assets/icons/pixel/`; fill-based, integer-grid viewBox `0 0 24 24` → crisp at native 24. Also fetched **Pixelarticons** (34, base/outline only — user fills manually) via `tools/fetch_pixelarticons.mjs` → `assets/icons/pixelarticons/`; it has the weapon/RPG shapes HackerNoon lacks (sword/shield/potion/skull/gamepad/target).
19  
20  **Fonts — research, downloads, trio chosen:**
21  - Researched pixel/bitmap fonts (WebSearch). Downloaded **Departure Mono** (OFL), **Cozette** (MIT/OFL), **Pixel Operator** family (CC0, dafont) + on-hand Ark/Fusion(latin)/Lana/monogram/m5x7/FatPixel/BoldPixels into `assets/fonts/`.
22  - **Chosen trio (fonts-in-context bench): body Ark10 · header PxOpB (PixelOperator-Bold) · mono Monogram (+ PxOp8 chrome).** User requirement: the *text* font must be CJK-capable (Ark/Fusion/Lana qualify); headers can be Latin-only.
23  - ⚠️ **Critical finding:** the engine font atlas bakes only **ASCII 32–127** (`FONT_FIRST_CHAR`/`FONT_NUM_CHARS` in `anchor.c:976–995`), so **CJK does not render yet regardless of font file**. Treated CJK-capability as a forward-looking *selection criterion*; extending the atlas is a deferred engine task.
24  - Per-font vertical nudge: Monogram "sits 1px low" — added a `font.voff` field applied in the text helper (`voff = -1` for Monogram).
25  
26  **The rough (480×270) low-res build — `main_rough.lua` + `rough_ui.lua`:**
27  - `main.lua` got a `ROUGH` flag forking to `main_rough.lua` (480×270 / scale 4 / `rough`). Built `rough_ui.lua` — a low-res pixel-scale port of the Ricochet UI language (filled-rect hairlines crisp under nearest, corner brackets, inverted-fill active states); the 1-logical-px line *is* the crispest pixel-art line, so the chrome translated directly.
28  - Screens (Tab): FONTS/BODY + FONTS/DISPLAY specimens, ICONS 3-pack compare grid (PA/HN/TB column labels), then **mock game screens showing fonts in context**: HUD (bars/pips/ability slots), MENU (panel + slider + segments + buttons), SHOP (item cards), TITLE (3×-scaled title + menu selection), COMPONENTS (kitchen-sink: checkbox/radio/toggle/stepper/field/dropdown/tabs/tags/badges/keyhints/table/sparkline). Live **font-role swap** (B/H/M keys) so the same UI re-renders per candidate.
29  
30  **Effects/shapes at low res (the original core goal):**
... [90 more lines]

Bash (find "E:/a327ex/RETICLE" -type d -not -path "/.git/" 2>/dev/null | head -50)

E:/a327ex/RETICLE
E:/a327ex/RETICLE/.git
E:/a327ex/RETICLE/anchor
E:/a327ex/RETICLE/assets
E:/a327ex/RETICLE/assets/fonts
E:/a327ex/RETICLE/reference

RETICLE doesn't have the lab files described in the summary. Let me check ricochet-template/ and understand the relationship, plus look at RETICLE's actual contents.

Bash (echo "=== RETICLE root files ===" && ls -la "E:/a327ex/RETICLE/" | grep -E ".lu...)

=== RETICLE root files ===
-rw-r--r-- 1 adn 197121    1280 Apr 22 14:16 README.md
-rw-r--r-- 1 adn 197121   72745 Apr 22 14:34 design.md
-rw-r--r-- 1 adn 197121    3527 Apr 22 14:15 main.lua

=== ricochet-template exists? ===
-rw-r--r-- 1 adn 197121    9679 May 30 16:54 editor.lua
-rw-r--r-- 1 adn 197121   24775 May 30 17:20 effect.lua
-rw-r--r-- 1 adn 197121   24791 May 30 23:39 lab.lua
-rw-r--r-- 1 adn 197121    4010 May 30 23:46 main.lua
-rw-r--r-- 1 adn 197121   30888 May 30 22:38 main_rough.lua
-rw-r--r-- 1 adn 197121    4387 May 28 00:21 palette.lua
-rw-r--r-- 1 adn 197121    3695 May 28 13:02 rectcut.lua
-rw-r--r-- 1 adn 197121   16071 May 30 21:36 rough_ui.lua
-rw-r--r-- 1 adn 197121   15558 May 29 21:26 showcase.lua
-rw-r--r-- 1 adn 197121   26240 May 29 10:14 ui.lua
-rw-r--r-- 1 adn 197121    7026 May 30 16:49 ui_controls.lua
-rw-r--r-- 1 adn 197121    1934 May 28 13:03 ui_state.lua

=== RETICLE assets ===
fonts/

=== git log RETICLE ===
fb0e085 RETICLE scaffold: empty Anchor2 project + design.md spec

RETICLE is a fresh scaffold; the actual lab work lives in ricochet-template/. The user pointed me at numbered reference images ("02 - GENERAL UI ELEMENTS", etc.) in a "ricochet reference folder". Let me locate those and check the ricochet/ package structure.

Bash (echo "=== ricochet-template full tree (non-git) ===" && find "E:/a327ex/ricochet...)

=== ricochet-template full tree (non-git) ===
E:/a327ex/ricochet-template
E:/a327ex/ricochet-template/.claude
E:/a327ex/ricochet-template/anchor
E:/a327ex/ricochet-template/assets
E:/a327ex/ricochet-template/assets/fonts
E:/a327ex/ricochet-template/assets/icons
E:/a327ex/ricochet-template/assets/icons/pixel
E:/a327ex/ricochet-template/assets/icons/pixelarticons
E:/a327ex/ricochet-template/assets/icons/tabler
E:/a327ex/ricochet-template/assets/images
E:/a327ex/ricochet-template/ricochet
E:/a327ex/ricochet-template/tools
E:/a327ex/ricochet-template/tools/node_modules
E:/a327ex/ricochet-template/tools/node_modules/@resvg
E:/a327ex/ricochet-template/tools/node_modules/@resvg/resvg-js
E:/a327ex/ricochet-template/tools/node_modules/@resvg/resvg-js-win32-x64-msvc

=== ricochet subfolder? ===
total 56
drwxr-xr-x 1 adn 197121     0 May 30 23:24 ./
drwxr-xr-x 1 adn 197121     0 May 30 23:46 ../
-rw-r--r-- 1 adn 197121  2224 May 30 22:39 init.lua
-rw-r--r-- 1 adn 197121 12922 May 30 23:24 skin_rough.lua
-rw-r--r-- 1 adn 197121 14515 May 30 23:23 skin_smooth.lua
-rw-r--r-- 1 adn 197121  2978 May 30 23:18 theme.lua
-rw-r--r-- 1 adn 197121  5883 May 30 23:24 ui.lua

=== Search for numbered reference images (02, 03, 05) ===
E:/a327ex/Invoker-old/reference/archive/0567f50c-db16-406f-8f2a-af58755ba13b.png
... [28 more lines]

The reference images live in E:/a327ex/Ricochet/reference/. The lab files (smooth lab.lua, rough main_rough.lua) and the new ricochet/ toolkit are in ricochet-template/. RETICLE is a fresh scaffold with a design.md spec + visual_reference.html. Let me orient on all of these. First the three reference images and RETICLE's identity files.

Read (E:/a327ex/Ricochet/reference/02 - GENERAL UI ELEMENTS .png)

[
  {
    "type": "image",
    "source": {
      "type": "base64",
      "data": "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",
      "media_type": "image/png"
    }
  }
]

Read (E:/a327ex/Ricochet/reference/03 - TYPOGRAPHY.png)

[
  {
    "type": "image",
    "source": {
      "type": "base64",
      "data": "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",
      "media_type": "image/png"
    }
  }
]

Read (E:/a327ex/Ricochet/reference/05 - GAME OBJECTS.png)

[
  {
    "type": "image",
    "source": {
      "type": "base64",
      "data": "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",
      "media_type": "image/png"
    }
  }
]

These are "blueprint room" technical design sheets — exactly the Ricochet aesthetic. They're low-res as shown; I'll crop regions for detail later. First let me understand RETICLE's identity and the existing toolkit.

Read (E:/a327ex/RETICLE/README.md)

1    # RETICLE
2   
3   A monochrome, schematic UI kit for games. Built on Anchor 2.
4   
5   - **Spec:** [`design.md`](./design.md) — complete specification of visual language, components, states, and transitions. The source of truth.
6   - **Visual reference:** [`reference/visual_reference.html`](./reference/visual_reference.html) — the 8-sheet design board the spec is drawn from. Open in a browser.
7   - **Bootstrap:** [`main.lua`](./main.lua) — empty Anchor 2 project. Runs, renders paper + registration marks + a thin-line demo circle. UI kit implementation will grow from here.
8   
9   ## Running
10  
11  ```bash
12  cd E:/a327ex/RETICLE
13  ./run.bat
14  ```
15  
16  Requires the Anchor 2 engine build (`anchor.exe`) committed in this folder.
17  The engine source lives in `E:/a327ex/Anchor2/engine/` — rebuild there and
18  copy the binary back here when the engine changes.
19  
20  ## Status
21  
22  Scaffold complete. UI kit components are unimplemented — see `design.md` for
23  what needs to be built and in what order.
24  
25  ## Dependencies
26  
27  - **Anchor 2** — framework files copied into `anchor/` from `E:/a327ex/Anchor2/framework/anchor/` at scaffold time.
28  - **Fonts** (not bundled in repo — see `assets/fonts/README.md`):
29    - Oswald (variable weight) — display
30    - Archivo (variable weight) — body
... [2 more lines]

Read (E:/a327ex/RETICLE/main.lua)

1    --[[
2     RETICLE — empty Anchor2 bootstrap.
3   
4     This file is intentionally minimal. It stands up a window, a smooth-mode UI
5     layer, and the paper background — just enough to confirm the engine runs and
6     to serve as the canvas for the RETICLE UI kit.
7   
8     The UI kit itself is specified in design.md. Implementation lives in
9     anchor/ui/ (to be added in future sessions) as a set of reusable draw
10    functions and stateful widgets on top of the Anchor2 framework.
11  
12    Visual reference: reference/visual_reference.html
13  ]]
14  
15  require('anchor')({
16    width = 1280,
17    height = 800,
18    title = 'RETICLE',
19    scale = 1,
20    filter = 'smooth',  -- UI kit assumes smooth-mode rendering (see design.md §2.6)
21  })
22  
23  -- Palette (see design.md §3.1). Colors use Anchor2's `color(r, g, b)` helper,
24  -- RGB 0–255. Values match the #f2eee4 / #0e0e0e tokens.
25  -- Colors are tables with a __call metamethod. Call with () when passing as
26  -- a draw parameter: `layer_rectangle(... paper())`.
27  paper    = color(242, 238, 228)
28  ink      = color( 14,  14,  14)
29  charcoal = color( 42,  42,  42)
30  steel    = color(122, 127, 135)
... [65 more lines]

Read (E:/a327ex/ricochet-template/main.lua)

1    --[[
2     ricochet-template — main.lua : the clean reference scene a forked game edits.
3   
4     Fork the folder (run.bat resolves the new name automatically), then build your
5     game in this file. It ships almost nothing — a full-screen effect and one small
6     control panel — but it shows the whole skeleton: the MODE flag, the boot order,
7     the layers, the four-axis effect call, and the per-frame UI interaction
8     contract. The reusable theme lives in `ricochet/` (one `require`).
9   
10    MODE picks the resolution profile. A Ricochet game is high-res-SMOOTH or
11    low-res-ROUGH (never both); flip the flag and the matching engine config +
12    theme (fonts / icons / metrics / UI skin) are selected. The effect engine and
13    the widget API are identical at both; only the look + sizing differ.
14  
15    LAB = true runs the example galleries (lab.lua) instead of this scene — the
16    full tour of every pattern / shape / dither / icon / font + the UI in context
17    (the frozen v1 dev tools, kept as usage reference). Composite example screens
18    built on the NEW toolkit will live in their own gallery (next session).
19  
20    How to use the UI toolkit (see ricochet/ for the full widget set):
21      update(): capture mouse edges into ui_mouse_pressed / ui_mouse_released
22      draw():   ui_state_begin_frame(); effect_clear(ui_layer); <widgets...>;
23                render + draw game_layer then ui_layer; reset the edge globals.
24      Widgets take one opts table; pass `id` for interactive, omit for static;
25      state is caller-owned (you pass value/checked, the widget reports clicks).
26  ]]
27  
28  local MODE = 'rough'   -- 'rough' (480x270 pixel-art) | 'smooth' (1920x1080)
29  local LAB  = false     -- true -> run the example galleries (lab.lua) instead
30  
... [56 more lines]

Read (E:/a327ex/ricochet-template/ricochet/init.lua)

1    --[[
2     ricochet/init.lua — the toolkit aggregator. `require('ricochet')` (in a game's
3     main.lua, AFTER `require('anchor')({...})`) loads the whole Ricochet theme and
4     does the cross-cutting setup, mirroring snkrx/init.lua.
5   
6     What it pulls together:
7       - the resolution-AGNOSTIC core (shared with the frozen labs, kept at root so
8         those keep working untouched): the four-axis effect engine, the palette,
9         the immediate-mode interaction substrate, and rectcut layout.
10      - the resolution-PROFILED UI theme (ricochet.theme) and — added next step —
11        the widget toolkit (ricochet.ui).
12  
13    Boot in main.lua:
14      require('anchor')({ width=480, height=270, scale=4, filter='rough' })  -- or smooth
15      require('ricochet')
16      ricochet_setup({ mode = 'rough' })   -- palette + shader + theme, in order
17  
18    A game is high-res-smooth OR low-res-rough; `mode` picks the theme profile to
19    match the resolution chosen in require('anchor'). Everything else (the effect
20    API, the widgets) is the same at both.
21  ]]
22  
23  require('effect')          -- four-axis effect system  (root; shared, agnostic)
24  require('palette')         -- palette tokens           (root)
25  require('ui_state')        -- hot/active/focus interaction substrate (root)
26  require('rectcut')         -- rectcut layout primitive (root)
27  require('ricochet.theme')  -- resolution profiles: fonts + metrics + icon set
28  require('ricochet.ui')     -- the Ricochet widget toolkit (primitives + interactive)
29  
30  -- The layer the UI widgets draw to. A game draws its world on its own layer(s);
... [15 more lines]

Now I understand the landscape. Key tension: the user points me at RETICLE/reference/visual_reference.html (a fresh scaffold with a 72KB design.md spec) but describes the work in terms of ricochet-template's two skins and "both labs" (lab.lua smooth + main_rough.lua rough). Let me understand both places before deciding where to build. Let me inspect the visual_reference structure, RETICLE's design.md, and the current skin coverage.

Bash (echo "=== visual_reference.html section structure ==="
grep -oiE '<h[1-3][^>]*>...)

=== visual_reference.html section structure ===

=== visual_reference.html size / line count ===
3255 E:/a327ex/RETICLE/reference/visual_reference.html

Bash (echo "=== RETICLE/design.md TOC (headers) ==="
grep -nE '^#{1,3} ' "E:/a327ex/RE...)

=== RETICLE/design.md TOC (headers) ===
1:# RETICLE
8:## Table of contents
45:## 0. Foreword
64:## 1. Philosophy
93:## 2. Foundations
95:### 2.1 Grid
110:### 2.2 Line weights
127:### 2.3 Caps, joints, terminators
144:### 2.4 Dots
160:### 2.5 Tone & texture
182:### 2.6 Rendering assumptions (Anchor 2)
214:## 3. Design tokens
216:### 3.1 Color
288:### 3.2 Typography
344:### 3.3 Spacing
361:### 3.4 Stroke
371:### 3.5 Motion
410:## 4. Surface primitives
414:### 4.1 Sheet frame
434:### 4.2 Rails
462:### 4.3 Section headers
477:### 4.4 Dividers
491:## 5. Interactive state model
497:### 5.1 States
510:### 5.2 Compositions
520:### 5.3 Transitions
536:### 5.4 Input affordances
548:## 6. Core components
554:### 6.1 Button
... [51 more lines]

This is clearly a ricochet-template task: the work targets "both smooth and rough skins" (the two-skin toolkit in ricochet/), uses "both labs" (lab.lua + main_rough.lua) as guidance, and RETICLE is smooth-only — so RETICLE serves as the reference, not the build target. Let me audit the current skin coverage and get the reference images at full detail.

Read (E:/a327ex/ricochet-template/ricochet/theme.lua)

1    --[[
2     ricochet/theme.lua — the resolution PROFILE for the Ricochet UI.
3   
4     The Ricochet drawing language is resolution-agnostic (filled-rect hairlines,
5     corner brackets, inverted fills — all crisp under both the smooth and rough
6     filters). The only things that genuinely differ between a high-res and a
7     low-res game are the FONTS and the ICON set, plus a few default METRICS
8     (row height, label width, etc.). This module bundles those into two named
9     profiles; `ricochet_theme_set('rough' | 'smooth')` swaps the active one.
10  
11    Widgets read the role-font globals (`ui_font_title/body/mono/small`) and
12    `ricochet_theme.metrics`, so the SAME widget code renders pixel-crisp at
13    480x270 and vector-clean at 1920x1080. A game calls this once at boot (via
14    `ricochet_setup`) to match the resolution it chose in `require('anchor')`.
15  
16      rough  — pixel fonts (Ark10 / PxOpB / Monogram / PxOp8) + HackerNoon pixel
17               icons; tight metrics for a 480x270 canvas.
18      smooth — vector fonts (Oswald / IBM Plex Sans / Cascadia) + Tabler icons;
19               larger metrics for a 1920x1080 canvas.
20  ]]
21  
22  ricochet_theme = ricochet_theme or {}
23  
24  -- register a font + stash its per-font vertical nudge (some pixel fonts sit low)
25  local function rf(name, file, size, filter, voff)
26    local f = font_register(name, file, size, filter)
27    f.voff = voff or 0
28    return f
29  end
30  
... [31 more lines]

Read (E:/a327ex/ricochet-template/ricochet/ui.lua)

1    --[[
2     ricochet/ui.lua — the Ricochet UI toolkit: shared core + the skin binder.
3   
4     The smooth (hi-res) and rough (low-res) Ricochet UIs are genuinely different
5     DESIGNS — not just sizes. Across the board the treatments differ (smooth radio
6     is a CIRCLE, rough is a square; smooth toggle has a green track; smooth tabs
7     invert the active cell; etc.). So EVERY widget that has a distinct look per
8     mode lives in a SKIN: `ricochet/skin_smooth.lua` (matches the smooth lab /
9     showcase + the reference sheets) and `ricochet/skin_rough.lua` (matches the
10    rough lab). `ricochet_use_skin(mode)` binds the active skin's functions onto
11    the public `ui_*` globals; `ricochet_theme_set` calls it. A game writes
12    mode-agnostic UI (`ui_panel{...}`); flipping MODE swaps look + metrics + fonts.
13  
14    This file holds only what is TRULY shared:
15      - the immediate-mode interaction step (`ric.interact`)
16      - text + hairline + bracket + icon draw helpers the skins compose from
17      - the handful of mode-independent public widgets (frame / text / icon / divider)
18      - `ricochet_use_skin`
19  
20    Per-frame contract (game's update + draw):
21      update(): capture mouse edges -> ui_mouse_pressed / ui_mouse_released
22      draw():   ui_state_begin_frame(); effect_clear(ui_layer); [widgets];
23                layer_render/draw(ui_layer); ui_mouse_pressed=ui_mouse_released=false
24  ]]
25  
26  ric = ric or {}
27  
28  -- immediate-mode step: claim hot -> press grabs active -> release-on-hot fires.
29  function ric.interact(id, rect)
30    ui_claim_hot(id, rect)
... [116 more lines]

PowerShell

02 - GENERAL UI ELEMENTS .png  =>  1491 x 1055
03 - TYPOGRAPHY.png  =>  1491 x 1055
05 - GAME OBJECTS.png  =>  1491 x 1055

The reference sheets are 1491×1055 — too dense to read whole. Let me crop sheet 02 (the densest, holds most of the requested categories) into readable tiles.

PowerShell

Exception calling "Clone" with "2" argument(s): "Out of memory."
At line:15 char:5

+     $crop = ($img).Clone($rect, $img.PixelFormat)
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : OutOfMemoryException
 
New-Object : Exception calling ".ctor" with "2" argument(s): "Parameter is not valid."
At line:18 char:12
+     $bmp = New-Object System.Drawing.Bitmap($sw, $sh)
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [New-Object], MethodInvocationException
    + FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand
 
Exception calling "FromImage" with "1" argument(s): "Parameter is not valid."
At line:19 char:5
+     $g = [System.Drawing.Graphics]::FromImage($bmp)
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception setting "InterpolationMode": "Parameter is not valid."
At line:20 char:5
+     $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMod ...
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], SetValueInvocationException
    + FullyQualifiedErrorId : ExceptionWhenSetting
 
Exception calling "DrawImage" with "5" argument(s): "Parameter is not valid."
At line:21 char:5
... [102 more lines]

Clone with the indexed pixel format failed. Let me use Graphics.DrawImage with a source rectangle instead.

PowerShell

New-Object : Exception calling ".ctor" with "2" argument(s): "Parameter is not valid."
At line:11 char:14

+       $bmp = New-Object System.Drawing.Bitmap($sw, $sh)
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [New-Object], MethodInvocationException
    + FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand
 
Exception calling "FromImage" with "1" argument(s): "Parameter is not valid."
At line:12 char:7
+       $g = [System.Drawing.Graphics]::FromImage($bmp)
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception setting "InterpolationMode": "Parameter is not valid."
At line:13 char:7
+       $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationM ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], SetValueInvocationException
    + FullyQualifiedErrorId : ExceptionWhenSetting
 
Exception calling "DrawImage" with "7" argument(s): "Parameter is not valid."
At line:15 char:7
+       $g.DrawImage($img, $dst, $x, $y, $w, $h, [System.Drawing.Graphi ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception calling "Save" with "1" argument(s): "Parameter is not valid."
At line:16 char:7
... [82 more lines]

GDI is exhausting resources mid-loop. Let me load the source once into a 32bpp in-memory bitmap, then crop with explicit disposal and GC per tile.

PowerShell

New-Object : Exception calling ".ctor" with "3" argument(s): "Parameter is not valid."
At line:20 char:14

+ ...      $bmp = New-Object System.Drawing.Bitmap($sw,$sh,[System.Drawing. ...
+                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [New-Object], MethodInvocationException
    + FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand
 
Exception calling "FromImage" with "1" argument(s): "Parameter is not valid."
At line:21 char:7
+       $g = [System.Drawing.Graphics]::FromImage($bmp)
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception setting "InterpolationMode": "Parameter is not valid."
At line:22 char:7
+       $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationM ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], SetValueInvocationException
    + FullyQualifiedErrorId : ExceptionWhenSetting
 
Exception calling "DrawImage" with "7" argument(s): "Parameter is not valid."
At line:24 char:7
+       $g.DrawImage($base,$dst,$x,$y,$w,$h,[System.Drawing.GraphicsUni ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception calling "Save" with "2" argument(s): "Parameter is not valid."
At line:26 char:7
... [82 more lines]

Deterministic failure (same 3 tiles) — it's a GDI+ native-memory ceiling in this process, not a leak. Let me drop the upscale to 1.0 (smaller bitmaps) which should fit.

PowerShell

New-Object : Exception calling ".ctor" with "3" argument(s): "Parameter is not valid."
At line:12 char:14

+ ...      $bmp = New-Object System.Drawing.Bitmap($w,$h,[System.Drawing.Im ...
+                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [New-Object], MethodInvocationException
    + FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand
 
Exception calling "FromImage" with "1" argument(s): "Parameter is not valid."
At line:13 char:7
+       $g = [System.Drawing.Graphics]::FromImage($bmp)
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception calling "DrawImage" with "7" argument(s): "Parameter is not valid."
At line:15 char:7
+       $g.DrawImage($orig,$dst,$x,$y,$w,$h,[System.Drawing.GraphicsUni ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception calling "Save" with "2" argument(s): "Parameter is not valid."
At line:17 char:7
+       $bmp.Save("$out\${prefix}_r${r}_c${c}.png",[System.Drawing.Imag ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
New-Object : Exception calling ".ctor" with "3" argument(s): "Parameter is not valid."
At line:12 char:14
... [61 more lines]

Exactly 3 succeed every time regardless of size/format — that's a GDI handle cap in the sandboxed process, not memory. Let me test whether disabling the sandbox lifts it (these are pure local image crops to temp — safe).

PowerShell

New-Object : Exception calling ".ctor" with "3" argument(s): "Parameter is not valid."
At line:13 char:14

+ ...      $bmp = New-Object System.Drawing.Bitmap($sw,$sh,[System.Drawing. ...
+                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [New-Object], MethodInvocationException
    + FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand
 
Exception calling "FromImage" with "1" argument(s): "Parameter is not valid."
At line:14 char:7
+       $g = [System.Drawing.Graphics]::FromImage($bmp)
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception setting "InterpolationMode": "Parameter is not valid."
At line:15 char:7
+       $g.InterpolationMode=[System.Drawing.Drawing2D.InterpolationMod ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], SetValueInvocationException
    + FullyQualifiedErrorId : ExceptionWhenSetting
 
Exception calling "DrawImage" with "7" argument(s): "Parameter is not valid."
At line:17 char:7
+       $g.DrawImage($orig,$dst,$x,$y,$w,$h,[System.Drawing.GraphicsUni ...
+       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception calling "Save" with "2" argument(s): "Parameter is not valid."
At line:19 char:7
... [298 more lines]

Reliable pattern found: ~3 GDI bitmaps per source image per process. I'll generate 3 full-width horizontal bands per sheet (one call each), which fits that budget and keeps text readable.

PowerShell

New-Object : Exception calling ".ctor" with "3" argument(s): "Parameter is not valid."
At line:11 char:10

+   $bmp = New-Object System.Drawing.Bitmap($sw,$sh,[System.Drawing.Ima ...
+          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [New-Object], MethodInvocationException
    + FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand
 
Exception calling "FromImage" with "1" argument(s): "Parameter is not valid."
At line:12 char:3
+   $g = [System.Drawing.Graphics]::FromImage($bmp)
+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception setting "InterpolationMode": "Parameter is not valid."
At line:13 char:3
+   $g.InterpolationMode=[System.Drawing.Drawing2D.InterpolationMode]:: ...
+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], SetValueInvocationException
    + FullyQualifiedErrorId : ExceptionWhenSetting
 
Exception calling "DrawImage" with "7" argument(s): "Parameter is not valid."
At line:15 char:3
+   $g.DrawImage($orig,$dst,0,$y,$W,$h,[System.Drawing.GraphicsUnit]::P ...
+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : ArgumentException
 
Exception calling "Save" with "2" argument(s): "Parameter is not valid."
At line:16 char:17
... [10 more lines]

The environment caps GDI to ~1 large bitmap per process. Rather than burn many calls squinting at 1491px sheets, the authoritative source for fidelity is the code — the user even said the HTML reference is "closest to the style in actual code." Let me read the four files that define current coverage: the two v1 references (showcase.lua, rough_ui.lua) and the two skins.

Read (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

1    --[[
2     ricochet/skin_smooth.lua — the HI-RES Ricochet UI design (matches the smooth
3     lab / the reference sheets): FLAT page-colored panels (palette.field) with a
4     hairline ink border, subtle palette.mid_light corner brackets, a 2-row slider
5     with 5 tick marks + a square knob, and wider spacing. Glyph chevrons. A table
6     of widget-drawing functions bound onto the ui_* globals by
7     `ricochet_use_skin('smooth')`. Reads `ricochet_theme.metrics` for sizing.
8   ]]
9   
10  RICOCHET_SKIN_SMOOTH = {}
11  local S = RICOCHET_SKIN_SMOOTH
12  local function M() return ricochet_theme.metrics end
13  
14  function S.brackets(rect)
15    local m = M(); ric.brackets(rect, palette.mid_light(), m.corner_arm, m.corner_gap)
16  end
17  
18  function S.panel(o)
19    local r, m = o.rect, M()
20    if o.brackets then S.brackets(r) end       -- subtle grey L-brackets, outside
21    layer_rectangle(ui_layer, r.x, r.y, r.w, r.h, palette.field())  -- flat, page-colored
22    ric.frame(r, palette.ink())
23    if o.title then
24      local th = m.title_h
25      ric.text(ui_font_title, string.upper(o.title), r.x + m.inset, ric.vcenter(ui_font_title, r.y, th), palette.ink())
26      ric.hline(r.x, r.y + th, r.w, palette.ink())   -- divider under the title bar
27      return r.y + th + 1
28    end
29    return r.y
30  end
... [285 more lines]

Read (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

1    --[[
2     ricochet/skin_rough.lua — the LOW-RES Ricochet UI design (matches the rough
3     lab): panel-fill (elevated) containers, ink corner brackets, plain single-row
4     sliders, tight pixel spacing. A table of widget-drawing functions composed
5     from the shared `ric.*` helpers; bound onto the ui_* globals by
6     `ricochet_use_skin('rough')`. Reads `ricochet_theme.metrics` for sizing.
7   ]]
8   
9   RICOCHET_SKIN_ROUGH = {}
10  local R = RICOCHET_SKIN_ROUGH
11  local function M() return ricochet_theme.metrics end
12  
13  function R.brackets(rect)
14    local m = M(); ric.brackets(rect, palette.ink(), m.corner_arm, m.corner_gap)
15  end
16  
17  function R.panel(o)
18    local r, m = o.rect, M()
19    layer_rectangle(ui_layer, r.x, r.y, r.w, r.h, palette.panel())
20    ric.frame(r, palette.ink())
21    if o.brackets then R.brackets(r) end
22    if o.title then
23      local th = m.title_h
24      layer_rectangle(ui_layer, r.x, r.y, r.w, th, palette.recess())
25      ric.hline(r.x, r.y + th, r.w, palette.ink())
26      ric.text(ui_font_title, o.title, r.x + 5, ric.vcenter(ui_font_title, r.y, th), palette.ink())
27      return r.y + th + 1
28    end
29    return r.y
30  end
... [263 more lines]

Now I have full widget coverage. Let me see how the rough lab builds the cards/panels the user referenced ("cards already available in rough lab") and the smooth element catalog, plus the spec's card/chip/spacing/typography definitions.

Read (E:/a327ex/ricochet-template/showcase.lua)

1    --[[
2     showcase.lua — flat "UI KIT" screen (Tab toggles it from the pattern gallery).
3   
4     A live catalogue of themed UI elements built with the chosen icon pack
5     (TABLER) so the whole vocabulary can be eyeballed in the Ricochet theme.
6     Everything is FLAT: raw palette colors on `ui_layer`, NO effect pipeline.
7   
8     Icons are 44px white PNGs at assets/icons/tabler/<concept>.png, loaded into
9     the global `icons[concept]` table by main.lua and tinted to a palette token
10    on draw (white * token = token). Generated by tools/fetch_icons.mjs.
11  
12    Three columns of element groups (full screen width now that it's one pack):
13      HUD          resource badges, vitals bars, ability bar, life pips, wave bar
14      PROGRESSION  upgrade card, tooltip, leaderboard list
15      CONTROLS     tabs, toggle/checkbox/radio, stepper, stat block, keycaps, tags
16  
17    DRAW ORIGIN REMINDER: layer_image / layer_circle are CENTERED at (x,y);
18    layer_rectangle / layer_text are TOP-LEFT. (See the framework gotcha note.)
19  ]]
20  
21  local COL_W = 580
22  local COL_X = { 40, 670, 1300 }
23  local TOP   = 120
24  local HAIR  = 1
25  local ICON  = 44   -- matches the rasterized PNG size (tools/fetch_icons.mjs SIZE)
26  
27  -- ============================================================================
28  -- primitives (all draw to ui_layer, screen-space)
29  -- ============================================================================
30  
... [341 more lines]

12:    PATTERNS -> SHAPES -> IMAGES -> HUD -> MENU -> SHOP -> TITLE -> COMPONENTS
199:local SCREENS = { 'patterns', 'shapes', 'images', 'hud', 'menu', 'shop', 'title', 'widgets', 'icons', 'spec_body', 'spec_disp' }
300:-- Mock screen: SHOP
302:local function draw_shop()
303:  ru_text(rough_font_title, 'SHOP', 8, 5)
306:  local cards = {
312:  for i, c in ipairs(cards) do
643:  elseif s == 'shop' then draw_shop(); draw_status()

showcase.lua confirms it: the smooth card, hud_bar, badge_row, ability_bar, segbar, and tooltip exist only as local functions in the lab screen — never ported into skin_smooth. Same story in the rough lab. That's the real gap. Let me read the rough shop cards, the spec's card/typography/spacing sections, and grab one targeted crop of the cards/badges region.

Read (E:/a327ex/ricochet-template/main_rough.lua)

228    if input_pressed('rough_s3')      then icon_size = 24 end
229 end
230 
231 -- -----------------------------------------------------------------------------
232 -- Mock screen: HUD
233 -- -----------------------------------------------------------------------------
234 local function draw_hud()
235   ru_text_center(rough_font_title, 'WAVE 3', 0, width, 4)
236 
237   ru_icon(ic_hnf.heart, 13, 26, 12, palette.red())
238   ru_text(rough_font_body, 'HP', 22, ru_vcenter(rough_font_body, 20, 12))
239   ru_bar(44, 20, 110, 12, 84/100, palette.red(), '84/100')
240 
241   ru_icon(ic_hnf.bolt, 13, 42, 12, palette.blue())
242   ru_text(rough_font_body, 'MP', 22, ru_vcenter(rough_font_body, 36, 12))
243   ru_bar(44, 36, 110, 12, 40/60, palette.blue(), '40/60')
244 
245   ru_stat(ic_hnf.coin,  372, 18, 12, '250',  palette.yellow())
246   ru_stat(ic_hnf.star,  424, 18, 12, '1.2k', palette.orange())
247   ru_stat(ic_hn.clock,  372, 34, 12, '01:23')
248 
249   -- ability bar
250   local ax, ay = 168, 222
251   local slots = { ic_hnf.flame, ic_hnf.bolt, ic_hnf.star, ic_hnf.skull }
252   local keys  = { 'Q', 'W', 'E', 'R' }
253   local cds   = { 3, 0, 2, 0 }
254   for i = 1, 4 do
255     local sx = ax + (i - 1) * 30
256     ru_panel(sx, ay, 24, 24)
257     ru_icon(slots[i], sx + 12, ay + 12, 16, palette.ink())
... [100 more lines]

Read (E:/a327ex/RETICLE/design.md)

288  ### 3.2 Typography
289 
290 Three families. That's all that is permitted. Subheads and captions pick
291 from these; we do not add a fourth.
292 
293 | Family | Axes used | Files |
294 |---|---|---|
295 | **Oswald** (display) | `wght` 300–700 | `Oswald-VariableFont_wght.ttf` |
296 | **Archivo** (body) | `wght` 400–700, `wdth` 100 (default only) | `Archivo-VariableFont_wdth,wght.ttf` |
297 | **IBM Plex Mono** (mono) | `wght` 400–700 | `IBMPlexMono-Regular.ttf`, plus `-Medium` and `-Bold` |
298 
299 Anchor 2 registers fonts at a given pixel size. Variable axes are then set
300 per call. The kit needs the following named registrations:
301 
302 ```
303 display-xl  → Oswald @ 96 px, wght 700
304 display-lg  → Oswald @ 64 px, wght 700
305 display-md  → Oswald @ 40 px, wght 700
306 display-sm  → Oswald @ 22 px, wght 500
307 display-xs  → Oswald @ 14 px, wght 500
308 body-lg     → Archivo @ 14 px, wght 400
309 body        → Archivo @ 12 px, wght 400
310 body-em     → Archivo @ 12 px, wght 600
311 mono-sm     → IBM Plex Mono @ 10 px, wght 400
312 mono        → IBM Plex Mono @ 11 px, wght 400
313 mono-em     → IBM Plex Mono @ 11 px, wght 600
314 label       → Oswald @ 11 px, wght 500, tracking +0.18em, UPPERCASE
315 ```
316 
317 #### Type scale (specimen + use)
... [60 more lines]

PowerShell

saved

Let me view the cropped reference (counters/badges + cards/chips) and read the spec's panel/card section.

Read (C:/Users/adn/AppData/Local/Temp/refcrop/s02_counters_cards.png)

[
  {
    "type": "image",
    "source": {
      "type": "base64",
      "data": "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",
      "media_type": "image/png"
    }
  }
]

Read (E:/a327ex/RETICLE/design.md)

826  ### 6.16 Panel frames & cards
827 
828 A panel is a bordered region with optional title. A card is a small panel
829 containing a preview.
830 
831 - **Default panel:** 1-px stroke rectangle, fill `paper-raised`.
832 - **Panel with title:** title bar of height 28 px, 10 px horizontal padding,
833   `label @ 10` text, 1-px bottom stroke separating from body.
834 - **Panel with corner dots:** 5-px filled ink dots at each corner, aligned
835   to the outer stroke.
836 - **Panel with corner brackets:** 12-px L-brackets at each corner, outside
837   the stroke, instead of the stroke. Used for "registered" / important
838   cards.
839 - **Card:** 1-px stroke, padding 8–10 px, 6-px gap between internal elements.
840   Contents: icon/thumbnail + label + sub-label + optional count.
841 
842 ### 6.17 Cursors
843 
844 Seven cursor forms. Used by `CURSOR_SET(type)` equivalent at the engine
845 level or by overriding system cursor in game-focus.
846 
847 - `cur-default` — arrow. A 4×4 px filled kite, tail 15-px toward bottom-left.
848 - `cur-pointer` — hand. Simplified 4-finger glyph; only for clickable links
849   (rare in our kit — most clickable things are buttons with their own cues).
850 - `cur-text` — I-beam. Two 6-px horizontal caps + 14-px vertical stem.
851 - `cur-resize` — double-headed arrow along the resize axis.
852 - `cur-move` — 4-way arrow.
853 - `cur-not-allowed` — circle with slash.
854 - `cur-busy` — dashed circle (2-on / 2-off), rotating at 0.5 rev/s.
855 
... [25 more lines]

The crop reveals the counter/badge/tag treatment clearly (icon+number in thin boxes, small label above; status tags = icon+UPPERCASE chips). Let me grab the cards/buttons band and the panels/selectors band, plus list the rough widget functions.

PowerShell

saved A

PowerShell

saved B

Grep (^function (ru\w+)|^local function (ru\w+))

18:function ru_text(font, text, x, y, col)
24:function ru_text_right(font, text, right, y, col)
29:function ru_text_center(font, text, x, w, y, col)
34:function ru_vcenter(font, y, h)
40:function ru_frame(x, y, w, h, col)
49:function ru_brackets(x, y, w, h, arm, gap)
62:function ru_panel(x, y, w, h, title, brackets)
78:function ru_icon(img, cx, cy, size, col)
87:function ru_stat(img, x, y, h, value, icon_col)
93:function ru_bar(x, y, w, h, frac, fill_col, value)
102:function ru_list_row(x, y, w, h, label, value)
108:function ru_button(x, y, w, h, text, active)
116:function ru_segment(x, y, w, h, opts, idx)
129:function ru_pips(x, y, n, filled, size, gap)
139:function ru_text_scaled(font, text, x, y, s, col)
144:function ru_text_scaled_center(font, text, x, w, y, s, col)
149:function ru_tabs(x, y, w, h, opts, idx)
162:function ru_checkbox(x, y, sz, checked, label)
169:function ru_radio(x, y, sz, on, label)
176:function ru_toggle(x, y, w, h, on, label)
184:function ru_stepper(x, y, h, value, vw)
194:function ru_field(x, y, w, h, text, caret)
205:function ru_dropdown(x, y, w, h, text)
214:function ru_tag(x, y, h, text)
222:function ru_badge(x, y, h, text)
230:function ru_keyhint(x, y, h, key, label)
240:function ru_divider(x, y, w)
245:function ru_sparkline(x, y, w, h, vals, col)
262:function ru_menu_item(x, y, w, h, text, selected)
277:function ru_iconbtn(id, x, y, sz, dir)
... [4 more lines]

Confirmed — neither skin has card as a widget; both labs draw cards inline. rough_ui also has a text-input ru_field (caret) and ru_menu_item that the skins lack. Let me view the two remaining reference crops.

Read (C:/Users/adn/AppData/Local/Temp/refcrop/s02_band_buttons_cards.png)

[
  {
    "type": "image",
    "source": {
      "type": "base64",
      "data": "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",
      "media_type": "image/png"
    }
  }
]

Read (C:/Users/adn/AppData/Local/Temp/refcrop/s02_panels_selectors.png)

[
  {
    "type": "image",
    "source": {
      "type": "base64",
      "data": "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",
      "media_type": "image/png"
    }
  }
]

I'm fully oriented. Here's where things stand and a proposed plan — then a few design forks I want your call on before I write the brief.

Where the work lives

This is a ricochet-template/ task, not RETICLE. The thing you're describing — "both smooth and rough skins," "cards in the rough lab but not smooth" — is the two-skin toolkit in ricochet-template/ricochet/ (skin_smooth.lua + skin_rough.lua). RETICLE is smooth-only scaffold; its design.md + visual_reference.html are the reference I'll consult (and I've now read the relevant spec sections + cropped the sheet-02 regions). The deferred roadmap item #1 ("composite example screens on the new toolkit, both modes") is exactly this.

The key finding from the audit

The cards/bars/counters you remember were never ported into either skin. They exist only as screen-local functions: smooth ones in showcase.lua (card, hud_bar, badge_row, ability_bar, segbar, tooltip), rough ones inline in main_rough.lua's draw_shop/draw_hud. Neither skin_smooth nor skin_rough has a card widget at all. So "make sure every element has a default build in both skins" = promote these composites into real ui_* widgets in both skins, then show them in screens.

Coverage audit (your requested categories → what's built)

Sheet-02 category	Already a skin widget	Gap to build (both skins)
TOP HUD BARS	`bar`, `stat`, `pips`	`hud_bar` (icon+label+track+value), `segbar` (wave/segmented), `ability_slot` (slot+key+cooldown)
COUNTERS & BADGES	`badge`, `tag`	`counter` (icon+number framed, label-above), `status_tag` (icon + UPPERCASE chip — the BURN/SLOW/SHIELD style)
BUTTONS & CONTROLS	`button`(primary/secondary), `segment`, `slider`, `stepper`, `dropdown`	`icon_button` (public square icon btn), chip-buttons (x1/x5/MAX = small segment variant)
CARDS & UPGRADE CHIPS	— (nothing)	`card` (icon+title+desc+footer, rarity accent), `upgrade_chip` (small icon+label+value) — biggest gap; also = sheet 05
PANELS & WINDOWS	`panel` (title+brackets)	`menu_item` (pause/title menu row, selected state); window/summary are panel + content compositions
SELECTORS & INPUTS	`field`(cycler), `segment`, `dropdown`, `slider`, `stepper`, `checkbox`, `radio`, `toggle`, `tabs`	`text_input` (label+value+caret — rough has `ru_field`, smooth lacks); focus/hover/disabled state demo
03 TYPOGRAPHY	fonts decided	a layout-craft screen: hierarchy (H-sizes), paragraphs, captions, numerals, correct vertical rhythm (uses §3.3 spacing tokens). Smooth may need extra Oswald sizes registered.

Proposed plan of attack (incremental — you test between)

Scaffold a mode-aware components.lua gallery (Tab-cycles category screens; reads ricochet_theme.mode; flip MODE in main.lua to compare skins — the engine has one global resolution so they can't sit side-by-side). Plus a shared heading + spacing helper so layout rhythm is consistent.
Then one category per step: add its missing widgets to both skins → build its screen → you test → next.

Before I write the design brief, three forks are genuinely yours to call:

AskUserQuestion

Your questions have been answered: "How should these component screens present the elements?"="Catalog (mirror sheet 02)", "Which elements should become reusable ui_* widgets in both skins (vs. drawn as screen-only layout code)?"="Everything reusable", "You test between steps — how should I sequence the build?"="Your choice. Please remember that the skin for smooth and rough modes gets slightly different treatment. For each element, note the differences in already existing elements, and for ones that don't yet exist in both, reason what the differences might be. Smooth mode generally allows for more expressivity while rough mode is more constrained and has to keep things simpler.". You can now continue with these answers in mind.

Got it — catalog style, everything reusable as widgets, build order my call. And I'll treat the smooth/rough split as first-class per element (smooth = more expressive, rough = simpler/constrained), noting the divergence for each.

My sequencing choice: scaffold → CARDS & UPGRADE CHIPS first (biggest gap, explicitly what you remembered missing, and it doubles as sheet 05's upgrade chips). Here's the design brief.

Design Brief — Component gallery scaffold + CARDS & UPGRADE CHIPS

Part 0 — Shared scaffold (`components.lua`, new root file)

Approach. A new components.lua that mirrors the frozen labs' self-contained pattern: it boots anchor + ricochet itself and is launched from main.lua by a COMPONENTS flag (2 lines, parallel to the existing LAB flag — if COMPONENTS then return require('components') end, placed by the LAB branch). It has its own MODE flag at the top ('smooth'|'rough'); flipping it re-runs the whole gallery in the other skin (the engine has one global resolution, so smooth/rough can't share a screen — comparison is by flag flip, same as the labs).

Lifecycle / per-frame contract. Standard package contract: update() captures mouse edges into ui_mouse_pressed/released; draw() runs ui_state_begin_frame() → effect_clear(ui_layer) → fills palette.field() background → draws the current screen → layer_render/draw(ui_layer) → resets edges.

Screen registry + navigation. SCREENS = { 'hud', 'counters', 'buttons', 'cards', 'panels', 'selectors', 'typography' }, Tab advances, number keys jump. A thin top chrome line (title + TAB ▸ next) and a bottom status strip showing MODE + screen name. In this increment only the cards screen has real content; the others register as stubs (empty + a faint "TODO" label) so the scaffold is complete and the rest fill in per increment.

Layout helpers (the "does it look right" machinery).

heading(label, x, y, w) — muted uppercase label + hairline rule under it; returns y below. (Same idiom as showcase.lua's heading, but mode-scaled.)
A per-mode spacing scale SP derived from design.md §3.3 (smooth: 4-px base → s1=4…s6=24, s8=32; rough: compressed → s1=2, s2=3, s3=4, s4=6, s5=8, s6=10). All vertical rhythm in the screens goes through SP, so spacing is consistent and tunable in one place.
A simple labeled sub-section cursor: each category screen lays out columns of heading + element clusters, matching sheet 02's "PRIMARY BUTTON / ICON BUTTONS / CARD-COMMON…" grid.

Interfaces. Reuses the whole package as-is: ui_* widgets, ric.* helpers, ricochet_theme.metrics, palette. New widgets get added to skin_smooth.lua / skin_rough.lua and bound through the existing ricochet_use_skin table (I'll add the two new keys to the binder in ricochet/ui.lua).

Part 1 — The two new widgets

Both go into both skins (the S. table in skin_smooth.lua, the R. table in skin_rough.lua), bound onto ui_card / ui_upgrade_chip.

`ui_card{ rect, icon, title, desc, footer, rarity, selected, id }`

A small panel with an icon, title, sub-text, and a footer line — the shop/reward card. desc is 1–2 caller-supplied lines (no auto-wrap). rarity picks an accent token; id (optional) makes it clickable (returns {clicked}). Reuses ric.frame, ric.icon, ric.text_in, ric.brackets, ric.hline, and the skin's interact.

Rarity → palette token (proposed, your call): common → mid_grey (neutral, no accent), uncommon → green, rare → blue, epic → pink, legendary → orange. Drawn from the 13-token palette, not inline RGB.

Smooth vs rough divergence:

	Smooth (expressive)	Rough (constrained)
Body fill	`palette.field()` (flat, matches smooth panel)	`palette.panel()` (elevated, matches rough panel)
Border / rarity	ink hairline + 2-px inner accent border in the rarity color; a small rarity tag chip ("RARE") top-right	1-px ink frame + 1-px accent edge on top only (no double border, no rarity chip — too busy at 480)
Icon	larger (44), centered top with padding `s4`	small (32), centered top, padding `s2`
Text	title Oswald, desc Archivo `mid_light` (up to 2 lines), footer divider + cost (mono) + cost-icon	title PxOpB, one sub-line max (Ark10), footer = coin `stat` + BUY
Selected	accent double-border thickens + brackets appear	inverted title bar or ink corner brackets

Rationale: smooth has the pixels for a rarity chip + double border + two desc lines; rough drops to a single accent edge and one sub-line so it stays legible at 4× nearest.

`ui_upgrade_chip{ x, y, icon, label, value, accent, id }`

The small horizontal perk chip (icon + label + delta value, e.g. 🔥 FIRE RATE +15%). Position-only (x,y), auto-sizes to content, returns next x so a row packs left-to-right (like ui_tag/ui_badge). value tinted by accent (default green for buffs). This is the sheet-05 "UPGRADE CHIPS" element too.

Smooth vs rough divergence:

	Smooth	Rough
Frame	hairline box, `field` fill, padding `s2`	1-px frame, `panel` fill, padding 2 px
Content	small tinted icon + label (Archivo) + value (mono, accent)	12-px icon + value (mono); label only if it fits
Emphasis	accent on the value text	accent kept minimal (value text only)

What I'm NOT doing this step

Other category screens stay stubs; the typography screen (which will need extra registered Oswald display sizes for smooth) is a later increment. No changes to the frozen labs.

Two things I'd like a thumbs-up / correction on before I write it: the rarity→token mapping, and whether ui_card's desc as caller-supplied lines (vs. me adding word-wrap) is fine. If both are good, I'll build the scaffold + cards screen + the two widgets in both skins.

Go ahead.

Approved — building it. Let me first confirm how icons are loaded in this project (the widgets need img.width) so components.lua loads them correctly.

Bash (cd "E:/a327ex/ricochet-template"
echo "=== icon/image loading in main_rough.lua ...)

=== icon/image loading in main_rough.lua (top) ===
9:  Plus the raw icon-pack grid and font specimen pages for reference.
23:    F        icon fill toggle      (ICONS screen)
24:    1/2/3    icon size 12/16/24    (ICONS screen)
53:-- Font registry. Each candidate loaded once with the 'rough' filter (1-bit
84:-- once the trio was chosen; removed here so the lab doesn't load missing files.)
103:-- Icons. HackerNoon fully (mock pack + grid col 2); Pixelarticons + Tabler
122:local ic_hn, ic_hnf, ic_pa, ic_tb, ic_tbf = {}, {}, {}, {}, {}
124:  ic_hn[c]  = image_load('hn_'  .. c, 'assets/icons/pixel/' .. c .. '.png')
125:  ic_hnf[c] = image_load('hnf_' .. c, 'assets/icons/pixel/' .. c .. '_filled.png')
128:  ic_pa[c] = image_load('pa_' .. c, 'assets/icons/pixelarticons/' .. c .. '.png')
129:  ic_tb[c] = image_load('tb_' .. c, 'assets/icons/tabler/' .. c .. '.png')
131:    ic_tbf[c] = image_load('tbf_' .. c, 'assets/icons/tabler/' .. c .. '_filled.png')
180:  content_imgs[n] = image_load('content_' .. n, 'assets/images/' .. n .. '.png')
182:local ri_image       = 'girl'
199:local SCREENS = { 'patterns', 'shapes', 'images', 'hud', 'menu', 'shop', 'title', 'widgets', 'icons', 'spec_body', 'spec_disp' }
201:local icon_size = 16
202:local icon_fill = false
225:  if input_pressed('rough_fill')    then icon_fill = not icon_fill end
226:  if input_pressed('rough_s1')      then icon_size = 12 end
227:  if input_pressed('rough_s2')      then icon_size = 16 end
228:  if input_pressed('rough_s3')      then icon_size = 24 end
237:  ru_icon(ic_hnf.heart, 13, 26, 12, palette.red())
241:  ru_icon(ic_hnf.bolt, 13, 42, 12, palette.blue())
245:  ru_stat(ic_hnf.coin,  372, 18, 12, '250',  palette.yellow())
246:  ru_stat(ic_hnf.star,  424, 18, 12, '1.2k', palette.orange())
247:  ru_stat(ic_hn.clock,  372, 34, 12, '01:23')
251:  local slots = { ic_hnf.flame, ic_hnf.bolt, ic_hnf.star, ic_hnf.skull }
257:    ru_icon(slots[i], sx + 12, ay + 12, 16, palette.ink())
262:  ru_icon(ic_hnf.skull, 13, 250, 10)
... [11 more lines]

image_load(name, path) it is. Let me grab the available icon concept names (shared across packs) so the cards/chips reference real icons in both modes.

Read (E:/a327ex/ricochet-template/main_rough.lua)

103  -- Icons. HackerNoon fully (mock pack + grid col 2); Pixelarticons + Tabler
104 -- only for the SHARED set used by the comparison grid.
105 -- -----------------------------------------------------------------------------
106 local HN = {
107   'heart','star','flame','bolt','trophy','crown','coin','coins','flag','skull',
108   'bug','gear','user','users','bell','home','lock','clock','moon','sun','sparkle',
109   'eye','music','book','search','plus','minus','check','x','chevron','play',
110   'pause','grid','trash','save','question',
111 }
112 local SHARED = {
113   'heart','star','flame','bolt','trophy','coin','skull','user','bell',
114   'home','search','plus','minus','check','x','chevron','play',
115 }
116 local tabler_filled_set = {
117   heart=true, star=true, flame=true, bolt=true, trophy=true, coin=true,
118   user=true, bell=true, search=true, plus=true, check=true, x=true,
119   chevron=true, play=true, home=true,
120 }
121 
122 local ic_hn, ic_hnf, ic_pa, ic_tb, ic_tbf = {}, {}, {}, {}, {}
123 for _, c in ipairs(HN) do
124   ic_hn[c]  = image_load('hn_'  .. c, 'assets/icons/pixel/' .. c .. '.png')
125   ic_hnf[c] = image_load('hnf_' .. c, 'assets/icons/pixel/' .. c .. '_filled.png')
126 end
127 for _, c in ipairs(SHARED) do
128   ic_pa[c] = image_load('pa_' .. c, 'assets/icons/pixelarticons/' .. c .. '.png')
129   ic_tb[c] = image_load('tb_' .. c, 'assets/icons/tabler/' .. c .. '.png')
130   if tabler_filled_set[c] then
131     ic_tbf[c] = image_load('tbf_' .. c, 'assets/icons/tabler/' .. c .. '_filled.png')
132   end
... [105 more lines]

Confirmed: image_load(name, path), and both packs expose <concept>_filled.png for the icons I need (flame/bolt/star/coin/heart/trophy). Building now — starting with the shared rarity helper + binder in ui.lua.

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the smooth skin's card + upgrade_chip (expressive treatment):

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the rough skin's card + upgrade_chip (tighter, simpler — sentence-case title, single accent edge, one desc line):

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the scaffold — components.lua:

Write (E:/a327ex/ricochet-template/components.lua)

File created successfully at: E:/a327ex/ricochet-template/components.lua (file state is current in your context — no need to Read it back)

Now wire the COMPONENTS flag into main.lua (parallel to LAB):

Edit (E:/a327ex/ricochet-template/main.lua)

The file E:/a327ex/ricochet-template/main.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now syntax-check all changed files (parse-only, per the project rule):

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   main.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

All parse clean. Let me sync the two docs that are now out of date (widget list + file map in the template's CLAUDE.md). Reading the exact regions first:

Bash (cd "E:/a327ex/ricochet-template"
grep -nE "ui_list_row` `ui_tag`|main.lua \s...)

156:  `ui_list_row` `ui_tag` `ui_badge` `ui_keyhint` `ui_sparkline`.
875:├── main.lua                    # CLEAN reference a forked game edits (MODE flag,
877:├── lab.lua                     # FROZEN smooth dev galleries (was main.lua; its own

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

153  - **Per-skin** (bound by `use_skin`): `ui_panel` `ui_brackets` `ui_field`
154   `ui_segment` `ui_slider` `ui_button` `ui_bar` `ui_checkbox` `ui_radio`
155   `ui_toggle` `ui_stepper` `ui_dropdown` `ui_tabs` `ui_pips` `ui_stat`
156   `ui_list_row` `ui_tag` `ui_badge` `ui_keyhint` `ui_sparkline`.
157

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

875  ricochet-template/
876 ├── main.lua                    # CLEAN reference a forked game edits (MODE flag,
877 │                               #   boot, one effect + one panel; LAB=true -> lab.lua)
878 ├── lab.lua                     # FROZEN smooth dev galleries (was main.lua; its own
879 │                               #   ROUGH flag forks to main_rough.lua). Uses v1 ui.lua.
880 ├── main_rough.lua              # FROZEN rough lab: 480×270 font/icon/UI bench (v1 rough_ui)

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

One sizing risk I want to fix before you test: at cw = 96, a rough card title like "Piercing Shot" in PixelOperator-Bold would overflow 96 px. Widening rough cards to 118 (3×118 + gaps = 370 < 480, still fits):

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Done — scaffold + the CARDS & UPGRADE CHIPS screen, with ui_card and ui_upgrade_chip built into both skins. All five touched files parse clean.

How to test

In main.lua, set COMPONENTS = true (line 3).
Run ./run.bat. It opens on the CARDS screen in smooth mode.
To compare skins: flip MODE at the top of components.lua (line 24) between 'smooth' and 'rough' and re-run — same screen, the other skin. (Two flags because components.lua is self-contained like the frozen labs; main.lua's own MODE is bypassed when COMPONENTS is on.)
Keys: Tab = next screen, 1–7 = jump, T = palette dark/light. Screens 1,2,3,5,6,7 are intentional — TODO stubs for now; only 4 = CARDS has content.

What you're looking at

Three cards (COMMON / RARE / EPIC) + two rows of upgrade chips (a labeled row and a compact icon+value row), laid out under sheet-02-style section headings with the §3.3 spacing scale.

Smooth vs rough divergences I implemented (per your note)

Element	Smooth (expressive)	Rough (constrained)
card body	flat `field` fill (matches smooth panel)	`panel` fill, elevated (matches rough panel)
card rarity	ink hairline + 2-px accent inner border; selected adds a 3rd inner border + corner brackets	1-px ink frame + single 2-px accent top edge; selected adds brackets only
card title	UPPERCASE (Oswald, H3-in-small-context)	sentence case (PixelOperator-Bold) — matches the rough shop
card text	up to 2 desc lines (`mid_light`) + footer label tinted to rarity color + coin cost	1 desc line (`mid_grey`) + coin cost; rarity label only shown for rare+
upgrade chip	`field` box, 8-px padding, accent on value	`panel` box, 2-px padding, tighter; label drops out cleanly if omitted

Rationale baked in: smooth has the pixels for the double border + rarity-tinted footer + two desc lines; rough collapses to a single accent edge and one line so it stays legible at 4× nearest.

The rarity→token map is common→mid_grey · uncommon→green · rare→blue · epic→pink · legendary→orange (all from the 13-token palette, no inline RGB).

Test it and tell me what reads wrong — sizing, the rarity accent weight, spacing rhythm — then I'll move to the next category. Which would you like next: BUTTONS & CONTROLS (mostly exists, cheap), COUNTERS & BADGES, or TOP HUD BARS?

Remove the colored outline from the cards, doesn't look good. Card selection should use the chevrons on the corner to signify the card is currently selected, otherwise just having the rare/epic/etc text on the bottom left is fine. That text on the bottom left should follow the guideline we have for tags, which is showing them as "[ tag ]". Allow me an option for a monochrome version of the UI as well, so I can see what it looks like without colors. Make sure that the colors chosen are correct. Smooth lab used largely correct colors, I'm not sure if the text you're using for these cards is the right one.

Clear set of corrections. I'll make these changes:

Drop the rarity color border entirely (smooth inner border + rough top edge gone).
Selection = ink corner brackets only.
Rarity → [ RARE ] bracket-tag, bottom-left, muted mid_light mono (matching the ui_tag guideline).
Monochrome toggle: a reusable ricochet_mono flag + ric.accent() helper the skins route accent picks through; catalog binds C to toggle it.
Fonts/colors: cards already use the same role fonts the smooth lab used (Oswald title / IBM Plex body / Cascadia mono) and palette accent tokens (no inline RGB) — I'll confirm specifics below.

Starting with the shared monochrome mechanism:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the smooth card — strip the accent border, selection→brackets, rarity→tag, route the coin tint through ric.accent:

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the rough card — same treatment (strip accent edge, selection→brackets, rarity→tag bottom-left, cost→bottom-right, coin via ric.accent):

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the monochrome toggle (key C) in the catalog chrome + input:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now let me verify the "are the colors/fonts correct" concern against the actual palette + the smooth lab, and syntax-check everything:

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Read (E:/a327ex/ricochet-template/palette.lua)

1    --[[
2     palette.lua — Ricochet's locked color palette.
3   
4     Two parallel tables — palette_dark (default) and palette_light — both keyed
5     by the same 13 token names. palette_init('dark' | 'light') selects one as
6     the active `palette` global; if effect.lua's `effect_write_palette` exists,
7     the new colors are pushed to the shader's u_palette[] uniform array
8     immediately. Otherwise the next effect_setup() call picks them up.
9   
10    Token roles (mapped consistently across modes):
11      field      window/scene background
12      panel      lifted card surface (light: collapses to field; dark: distinct
13                 slight elevation per design.md)
14      recess     depressed region (light: light_grey; dark: distinct deeper)
15      ink        primary lines, text, walls. The "text/structure" color.
16      mid_light  secondary strokes, subdued text
17      mid_grey   inactive elements
18      deep_grey  panel fills, divider hairlines, ghosted states. The "soft
19                 negative" color.
20      blue       information, projectiles, default/selected
21      orange     warnings, timers near expiry
22      green      mana, positive, upgrades
23      pink       special, rare, focus
24      yellow     gold, pickups, currency
25      red        danger
26  
27    Hex values come from Ricochet/design.md § Visual design. Light-mode panel
28    and deep_grey collapse to existing tokens (paper and light_grey) — design.md
29    doesn't define separate panel/recess surfaces for light mode. Forked games
30    that need explicit elevation in light mode can override the table.
... [75 more lines]

All files parse. Here's the confirmation you asked for on colors/fonts, from palette.lua and the smooth lab:

Colors — correct & palette-sourced. Every color is a palette token (no inline RGB), and they match the smooth lab's usage. Per the palette's documented roles: coin/currency = yellow ✓ (used for the cost icon), and the chip accents (orange/blue/yellow/green) are all tokens the smooth lab uses. In monochrome they all collapse to ink. The rarity tag is mid_light (muted), same as ui_tag — never an accent.

Fonts — same as the smooth lab. Card title = Oswald (ui_font_title), desc = IBM Plex Sans (ui_font_body), tag + cost = Cascadia (ui_font_mono) — identical files/sizes to the lab's ui_font_title/ui_font_label/ui_font_value, just the package's role names. So the text is the right one. One nuance: the package registers Oswald at 18 for all titles, while design.md §3.2 spec'd card headers a touch larger (Oswald 22, "H3"). I left it at 18 for now — say the word if you want bigger card titles (a small theme change).

What changed

Removed the colored outline — no more rarity border (smooth) / accent top-edge (rough).
Selection = ink corner brackets only (the middle "RARE" card is flagged selected so you can see it).
Rarity → [ RARE ] bracket-tag, bottom-left, muted mono — follows the tag guideline. Cost moved to bottom-right in both skins.
Monochrome mode — reusable ricochet_mono flag + ric.accent() helper the skins route accents through; toggle with C in the catalog (status strip shows COLOR/MONO).

Test

With COMPONENTS = true (already set), run ./run.bat → CARDS screen.

C toggles monochrome, T toggles dark/light palette, Tab/1–7 navigate.
For the rough skin: set MODE = 'rough' at the top of components.lua and re-run.

Check the bracket-selection read, the [ RARE ] tag, and that C cleanly desaturates the coin icons + chip values. Then tell me the next category — or if the chip accent semantics should be pinned (e.g. damage→red, heal→green) rather than the current varied demo set.

For the rough skin, we already had a screen in the labs with cards made, and those looked good there, the ones you have now don't look properly spaced.

Right — the rough lab's SHOP cards (145×178, icon ~36px down, generous gaps, footer floated to the bottom) look good, while my rough R.card crammed everything with a 4px inset into a 120px box. Let me rebuild the rough card's internal rhythm to mirror the lab, and resize the catalog's rough cards to match.

First, R.card — lab-like spacing (16px top margin, 32px icon, ~6px gaps, 2 desc lines, footer floated to the bottom):

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the catalog: rough cards to 145×150 with a 10px gap (matching the lab), and confine the compact second chip row to smooth so the taller rough cards leave room:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/skin_rough.lua

Both parse. Done — the rough cards now follow the lab's SHOP-card rhythm.

What changed (rough only — smooth was untouched)

R.card internal spacing now mirrors the lab: 16px top margin, 32px icon, ~6px gaps, both desc lines rendered (was clipping to one), and the footer ([ RARE ] tag + cost) floated to the bottom instead of jammed against a 4px inset. The card stopped using m.inset (4px — fine for dense controls, far too tight for a card).
Catalog rough card size → 145×150 (was 118×120), gap 10 — matching the lab's cw=145 proportions. Three cards land at x = 8 / 163 / 318, ending at 463 (~17px right margin).
Compact second chip row is now smooth-only — at 270px tall, 150px cards + heading + one chip row already reach ~245px; a second row would hit the status strip. Rough still shows the full labeled chip row.

Test

Rough is already selected (MODE = 'rough' in components.lua:22). Run ./run.bat → CARDS screen. Compare the spacing against the lab's SHOP screen (it's the rough card rhythm it's based on). C = mono, T = palette, then flip MODE = 'smooth' to recheck that skin.

If the rough cards still read off — too tall, footer gap too large, icon too high — tell me which offset and I'll nudge it. Otherwise, which category next: BUTTONS & CONTROLS, COUNTERS & BADGES, or TOP HUD BARS?

Go ahead, your choice.

I'll take BUTTONS & CONTROLS next — it's mostly covered (ui_button, ui_segment), so it locks the screen-layout pattern cheaply while adding the one real gap: a public ui_icon_button. First let me confirm which filled icons actually exist in both packs (the icon-button row needs action glyphs available in tabler + pixel):

Bash (cd "E:/a327ex/ricochet-template/assets/icons"
echo "=== tabler *_filled ===" && ...)

=== tabler *_filled ===
bell bolt bomb bow check chevron coin dice flame flask gear heart home key play plus search shield star trophy user x 
=== tabler outline (non-filled) ===
bag bell bolt bomb bow check chevron coin dice flame flask gear heart home key map minus play plus search shield skull star sword target trophy user x 
=== pixel *_filled ===
bell bolt book bug check chevron clock coin coins crown eye flag flame gear grid heart home lock minus moon music pause play plus question save search skull sparkle star sun trash trophy user users x

Confirmed — both packs share filled icons for plus check x search gear play bell home star bolt heart etc. Here's the plan for BUTTONS & CONTROLS, then I'll build it (per your "go ahead"):

Design brief. The only real gap is a public ui_icon_button (square, icon-only). Unlike radio/toggle, its design is identical across skins (square · hover=recess · pressed=ink fill + field-tinted icon) — only the size differs — so it goes in ui.lua as a shared widget reading a new metrics.icon_btn (smooth 38 / rough 18), not duplicated per skin. I'll also add a disabled flag to ui_button (muted, non-interactive) for the reference's disabled state. The screen mirrors sheet 02: PRIMARY (filled) · SECONDARY (outline) · DISABLED · ICON BUTTONS (row) · CHIP BUTTONS (x1/x5/MAX segment) — two columns in smooth, stacked in rough.

Starting with the metric + the shared widget:

Edit (E:/a327ex/ricochet-template/ricochet/theme.lua)

The file E:/a327ex/ricochet-template/ricochet/theme.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/theme.lua)

The file E:/a327ex/ricochet-template/ricochet/theme.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the shared ui_icon_button in ui.lua (next to the other shared widgets):

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the disabled flag on ui_button in both skins:

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now wire up the catalog: load the action icons, add draw_buttons, register it.

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now draw_buttons + register it:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua
OK   ricochet/theme.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

All parse. Updating the shared-widget list in the template CLAUDE.md (ui_icon_button is shared, not per-skin):

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Done — BUTTONS & CONTROLS built, all six files parse clean.

What's new

ui_icon_button — square, icon-only button. Shared in ui.lua (identical design in both skins — square · hover=recess · pressed=ink fill + field-tinted icon — only size differs), driven by a new metrics.icon_btn (smooth 38 / rough 18).
disabled flag on ui_button — muted fill, deep_grey frame, mid_grey text, non-interactive (both skins).
BUTTONS screen mirroring sheet 02: PRIMARY (filled, via active) · SECONDARY (outline) · DISABLED · ICON BUTTONS (plus/check/x/search/gear row) · CHIP BUTTONS (x1/x5/MAX segment, live-selectable). Two columns in smooth, stacked in rough.

The catalog now opens on the BUTTONS screen (screen 3). Primary = always filled, secondary = outline that fills only on press — matching the reference's primary/secondary contrast.

Test

Run ./run.bat (rough is selected). You'll land on BUTTONS:

Hover/press the buttons and icon buttons to see the recess→ink state flow; the disabled "LOCKED" button stays muted and inert.
Click the x1/x5/MAX chips — selection persists (inverted active cell).
C mono, T palette, Tab/1–7 to other screens (CARDS = 4). Flip MODE = 'smooth' in components.lua:22 for the other skin.

Tell me what reads off, or I'll continue — COUNTERS & BADGES next (adds counter + status_tag), then TOP HUD BARS.

[Pasted image/png]

Chip buttons have a slight inconsistency on the right side there, not sure if intentional.

[Request interrupted by user]

You can fix this without giving me a turn, just move on to the next big task.

Two things: the segment's right-edge gap (last cell stops short of the outer frame due to integer rounding), then on to COUNTERS & BADGES. Fixing the segment first — switching to fractional-floor cell widths so the last cell meets the outer frame exactly (same technique tabs already uses):

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the new COUNTERS & BADGES widgets — counter (labeled boxed readout) and status_tag (icon + UPPERCASE chip), in both skins. Smooth first:

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now bind the two new widgets:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the COUNTERS & BADGES screen + registration, and start on it:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now syntax-check everything and update the widget list in the template CLAUDE.md:

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Both done; all files parse. The catalog now opens on COUNTERS & BADGES (screen 2).

Segment fix

ui_segment (both skins) now sizes cells with fractional-floor widths (floor(i·sw/n) − floor((i−1)·sw/n)) instead of floor(sw/n) per cell. The last cell now reaches the outer frame exactly — the ~2px right-edge sliver is gone. This was the rounding remainder (3 cells of 66 = 198 inside a 200-wide frame); fix applies to every segment (chip buttons, menu options, etc.).

COUNTERS & BADGES — two new widgets (both skins)

ui_counter{ x, y, label, icon, value, accent, w } — small-caps label above a framed [icon value] box (the HUD-style readout). accent tints the icon (mono → ink); value stays ink. Returns next x.
ui_status_tag{ x, y, icon, label, accent } — framed [icon UPPERCASE] buff/debuff chip. Accent tints the icon; label is ink. Returns next x.

Screen: GOLD/SCORE/WAVE/LEVEL counters · BURN/SHOCK/LUCKY/HEAL status tags · a coverage row of existing badge / tag / pips.

Smooth vs rough divergence (per your standing note): smooth = field fill, 18px icons, Cascadia value, 10px padding; rough = panel fill, 12px icons, tiny PxOp8 labels, 2–3px padding. Same monochrome-respecting accent path as the cards/chips.

Test

Run ./run.bat → lands on COUNTERS. Check the counter label/box alignment and spacing, the status-tag row, and C monochrome (icons should desaturate, structure unchanged). Tab/1–7 to BUTTONS (3) / CARDS (4); flip MODE in components.lua:22 for rough.

Next up unless you redirect: TOP HUD BARS (hud_bar, segbar, ability_slot — the composite widgets), then PANELS & WINDOWS, SELECTORS & INPUTS, and TYPOGRAPHY.

Yea, these are fine, next.

These read fine — moving to TOP HUD BARS. This one's the composite-widget set: hud_bar (icon + filled track + value), segbar (wave/segmented meter), and ability_slot (slot + icon + keycap + cooldown sweep), porting the smooth lab's showcase.lua/rough draw_hud compositions into reusable widgets. Adding them to both skins, then the screen.

Smooth widgets:

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Rough widgets:

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the TOP HUD BARS screen + registration, starting on it:

Edit (E:/a327ex/ricochet-template/components.lua)

<tool_use_error>File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.</tool_use_error>

Read (E:/a327ex/ricochet-template/components.lua)

150    if seg.changed then chip_i = seg.index end
151 end
152 
153 local function draw_counters()
154   local x0 = inset
155   local hy = heading('COUNTERS & BADGES', x0, content_top, width - 2*inset)
156 
157   -- counters: each draws its own small-caps label above a framed [icon value] box
158   local cx = x0
159   cx = ui_counter{ x = cx, y = hy, label = 'GOLD',  icon = icons.coin, value = '1,250', accent = palette.yellow() }
160   cx = ui_counter{ x = cx, y = hy, label = 'SCORE', icon = icons.star, value = '12.4k' }
161   cx = ui_counter{ x = cx, y = hy, label = 'WAVE',  value = '05 / 12' }
162   cx = ui_counter{ x = cx, y = hy, label = 'LEVEL', value = 'LVL 03' }
163 
164   -- status tags (icon + UPPERCASE label chips; accent tints the icon)
165   local sy = sublabel('STATUS TAGS', x0, hy + (smooth and 58 or 34))
166   local tx = x0
167   tx = ui_status_tag{ x = tx, y = sy, icon = icons.flame, label = 'BURN',  accent = palette.red() }
168   tx = ui_status_tag{ x = tx, y = sy, icon = icons.bolt,  label = 'SHOCK', accent = palette.blue() }
169   tx = ui_status_tag{ x = tx, y = sy, icon = icons.star,  label = 'LUCKY', accent = palette.yellow() }
170   tx = ui_status_tag{ x = tx, y = sy, icon = icons.heart, label = 'HEAL',  accent = palette.green() }
171 
172   -- existing badge / bracket-tag / pips widgets, for coverage
173   local by = sublabel('BADGES / TAGS / PIPS', x0, sy + (smooth and 40 or 22))
174   local bx = x0
175   bx = ui_badge{ x = bx, y = by, text = 'x3' }
176   bx = ui_badge{ x = bx, y = by, text = 'NEW' }
177   bx = ui_tag{ x = bx + SP.s3, y = by, text = 'RARE' }
178   bx = ui_tag{ x = bx, y = by, text = 'FIRE' }
179   ui_pips{ x = bx + SP.s4, y = by + 2, n = 5, filled = 3 }
... [10 more lines]

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Now update the widget list in the template CLAUDE.md:

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

TOP HUD BARS done; all files parse. Catalog opens on HUD (screen 1).

Three new composite widgets (both skins)

ui_hud_bar{ x, y, w, icon, frac, value, fill } — one-line resource bar: icon + filled track + right-aligned value. fill tints the filled portion (mono → ink). Returns next y so bars stack.
ui_segbar{ x, y, w, segs, filled, label, fill } — segmented wave/xp meter: label over N cells, filled solid + rest mid_grey frames. Returns next y. (Reuses the fractional-floor cell math so segments tile evenly.)
ui_ability_slot{ x, y, icon, key, cooldown, size } — recessed slot + centered icon + corner keycap + bottom-up cooldown sweep with a remaining count. Returns next x so slots tile into a bar.

Screen: VITALS (HP red / energy blue bars) · WAVE (10-seg meter) · ABILITIES (Q/W/E/R slots, two on cooldown).

Smooth vs rough: smooth = 16px bars / 24px icons / 44px slots; rough = 10px bars / 12px icons / 24px slots, tighter gaps. Fills + icon tints all route through ric.accent, so C monochrome desaturates them to ink while structure holds.

Test

Run ./run.bat (rough) → HUD screen. Check the bar fills + value alignment, the segmented wave meter, and the cooldown sweep on the W/R slots (darkened bottom portion + count). C mono, Tab/1–7 to the others; flip MODE for smooth.

Remaining: PANELS & WINDOWS (panel/window compositions + menu_item), SELECTORS & INPUTS (text_input + state demo), TYPOGRAPHY (hierarchy/spacing). Continuing with PANELS next unless you redirect.

[Pasted image/png]

Text on the right on rough mode is off. Fix this and go next without giving me a turn.

The rough value reserve (vres=34) is narrower than "72/100" in Monogram, so the value spills left over the track's right border. Fix: compute the reserve from the actual value text width (works for any value/font, both skins). Then on to PANELS.

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now PANELS & WINDOWS. Let me check the rough lab's ru_menu_item to match its look, and the smooth lab's panel/menu treatment:

Read (E:/a327ex/ricochet-template/rough_ui.lua)

262  function ru_menu_item(x, y, w, h, text, selected)
263   ru_text_center(rough_font_body, text, x, w, ru_vcenter(rough_font_body, y, h),
264                  selected and palette.ink() or palette.mid_grey())
265   if selected then ru_brackets(x, y, w, h, 5, 2) end
266 end
267 
268 -- ===========================================================================
269 -- INTERACTIVE widgets — immediate-mode, ported from the smooth ui.lua flow:
270 -- claim hot (cursor inside) -> press grabs active -> release-on-hot fires.
271 -- They read the sticky edge globals `ui_mouse_pressed` / `ui_mouse_released`
272 -- (captured in update(), reset at end of draw()) and use `ui_state` from
273 -- ui_state.lua. Call `ui_state_begin_frame()` once at the top of draw() first.
274 -- ===========================================================================
275 
276 -- small chevron button (dir = -1 left / +1 right); returns clicked
277 function ru_iconbtn(id, x, y, sz, dir)

The rough menu_item is centered text + brackets when selected (ru_menu_item). I'll match that for rough and give smooth the more expressive left-aligned-with-stripe treatment. Building PANELS & WINDOWS with the new ui_menu_item + panel compositions.

Smooth menu_item:

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the catalog: state vars, the PANELS screen, registration, start screen. Adding state:

Edit (E:/a327ex/ricochet-template/components.lua)

<tool_use_error>File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.</tool_use_error>

Read (E:/a327ex/ricochet-template/components.lua)

69   -- ---------------------------------------------------------------------------
70  -- screens
71  -- ---------------------------------------------------------------------------
72  local SCREENS = { 'hud', 'counters', 'buttons', 'cards', 'panels', 'selectors', 'typography' }
73  local screen_i = 1   -- start on the freshly-built screen (hud)
74  local chip_i   = 2   -- CHIP BUTTONS segment selection (caller-owned state)
75  
76  local function draw_cards()

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Both done — HUD value-text fix + PANELS & WINDOWS. All files parse.

Fix

ui_hud_bar (both skins) now reserves the value area from the actual text_width(value) + pad instead of a fixed width. The rough "72/100" no longer overruns the track's right border; the track simply ends a few px before the value. Robust for any value string or font.

PANELS & WINDOWS

New widget ui_menu_item{ rect, label, selected, id } (both skins):

Smooth — left-aligned title-font label; selected/hover = recess fill + 2px ink left stripe + ink label (mid_light otherwise). More expressive.
Rough — centered body label (ink when selected/hover, else mid_grey) + ink corner brackets when selected — matches the lab's ru_menu_item.

Screen — three panel compositions on existing ui_panel:

PAUSED — bracketed panel + a selectable menu (ui_menu_item, click to move selection).
WAVE 05 — titled panel + ui_stat rows (TIME/KILLS/SCORE/COMBO) + CONTINUE ui_button.
SETTINGS — titled panel + ui_toggle × 2 / ui_checkbox / ui_segment (difficulty), all with persistent state.

Three panels across in both modes (rough: 146px each, fits 480 with margins).

Test

Run ./run.bat (rough) → opens on PANELS (screen 5). Click the pause menu items (selection + brackets follow), toggle the settings, pick difficulty, hover CONTINUE. Recheck HUD (screen 1) — value text should sit clean. C mono, flip MODE for smooth.

Remaining: SELECTORS & INPUTS (text_input + focus/hover/disabled states) and TYPOGRAPHY (hierarchy + spacing). Continuing with SELECTORS next.

The SFX/screen shake buttons, whatever those are called, we need to do them differently. It's always confusing how those buttons work for me. Why not just have a checkbox or something of that nature instead?

No response requested.

Selectors on the paused panel on rough mode use the chevrons, but that looks wrong, I believe the lab one has the right idea, the one where we have the main menu for RICOCHET.

Let me look at how the lab's RICOCHET main-menu (title screen) renders its selected menu item — that's the treatment the user wants instead of the current rough menu_item brackets.

Grep (draw_title|RICOCHET|menu_item|selected)

421--- Mock screen: TITLE / MAIN MENU
422--- -----------------------------------------------------------------------------
423:local function draw_title()
424-  ru_brackets(16, 16, width - 32, height - 32, 8, 0)
425:  ru_text_scaled_center(rough_font_title, 'RICOCHET', 0, width, 54, 3)
426-  ru_text_center(rough_font_body, 'a blueprint roguelike', 0, width, 108, palette.mid_grey())
427-  local items = { 'PLAY', 'CONTINUE', 'OPTIONS', 'QUIT' }
428-  for i, it in ipairs(items) do
429:    ru_menu_item(width / 2 - 50, 134 + (i - 1) * 18, 100, 14, it, i == 1)
430-  end
431-  ru_text(rough_font_mono, 'v0.1.0', 24, height - 26)
--
642-  elseif s == 'menu' then draw_menu(); draw_status()
643-  elseif s == 'shop' then draw_shop(); draw_status()
644:  elseif s == 'title' then draw_title(); draw_status()
645-  elseif s == 'widgets' then draw_widgets(); draw_status()
646-  elseif s == 'icons' then draw_icons()

The lab title menu uses ru_menu_item (which I mirrored). So the discrepancy is likely in the bracket primitive itself. Let me compare ru_brackets (lab) against ric.brackets (package):

Read (E:/a327ex/ricochet-template/rough_ui.lua)

49   function ru_brackets(x, y, w, h, arm, gap)
50    arm = arm or 5; gap = gap or 2
51    local c = palette.ink()
52    local r = function(px, py, rw, rh) layer_rectangle(game_layer, px, py, rw, rh, c) end
53    r(x-gap, y-gap, arm, 1);             r(x-gap, y-gap, 1, arm)              -- TL
54    r(x+w+gap-arm, y-gap, arm, 1);       r(x+w+gap-1, y-gap, 1, arm)          -- TR
55    r(x-gap, y+h+gap-1, arm, 1);         r(x-gap, y+h+gap-arm, 1, arm)        -- BL
56    r(x+w+gap-arm, y+h+gap-1, arm, 1);   r(x+w+gap-1, y+h+gap-arm, 1, arm)    -- BR
57  end
58  
59  -- ---- panel -----------------------------------------------------------------
60  -- Elevated panel with hairline border. With `title`, draws a title bar (title
61  -- font) and returns the content-top y. `brackets` adds corner brackets.

The lab's title menu uses ru_menu_item (which I mirrored), so the words "chevrons" and "looks wrong" don't line up with what I built — I should look at the actual render rather than guess. Let me check the running app.

ToolSearch

[
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__computer_batch"
  },
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__cursor_position"
  },
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__double_click"
  },
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__hold_key"
  },
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__key"
  },
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__left_click"
  },
  {
    "type": "tool_reference",
    "tool_name": "mcp__computer-use__left_click_drag"
  },
  {
... [80 more lines]

Before I guess at "chevrons," let me look at the actual render — the app should be on the PANELS screen. Let me request access to the game window.

mcpcomputer-userequest_access

[
  {
    "type": "text",
    "text": "{\"granted\":[],\"denied\":[],\"notInstalled\":{\"apps\":[{\"requestedName\":\"ricochet components\",\"didYouMean\":[\"Component Services\"]},{\"requestedName\":\"anchor\",\"didYouMean\":[]},{\"requestedName\":\"anchor.exe\",\"didYouMean\":[]}],\"guidance\":\"\\\"ricochet components\\\", \\\"anchor\\\", \\\"anchor.exe\\\" don't match any installed or running application. The request was NOT shown to the user. Did you mean: ricochet components \u2192 \\\"Component Services\\\"? Retry request_access with the corrected names (include any other apps from this call too \u2014 the whole call was short-circuited). If you're unsure of the exact name, ask the user.\"},\"screenshotFiltering\":\"mask\"}"
  }
]

The game window isn't a Start-menu app, so I can't capture it — I'll reason from the code. Here's what's almost certainly happening with the rough paused menu: the selected item's corner brackets (ric.brackets, gap 2px outside the item) collide with the panel's own border and the panel's brackets=true corner marks, since the items are inset only 2px. That corner clutter reads as stray "chevrons." The lab title menu looks clean because its bracketed items sit free on a full screen with room. Fix: drop the panel's double-brackets and give the menu items room so the selection brackets sit cleanly inside — matching the lab. Plus the SFX/shake toggles → checkboxes.

Let me read the current draw_panels to edit precisely:

Read (E:/a327ex/ricochet-template/components.lua)

211  
212 local function draw_panels()
213   local x0 = inset
214   local hy = heading('PANELS & WINDOWS', x0, content_top, width - 2*inset)
215   local pw  = smooth and 280 or 146
216   local gap = smooth and SP.s6 or SP.s5
217   local ph  = smooth and 320 or 192
218   local ih  = smooth and 36 or 18
219 
220   -- panel 1: PAUSE overlay — a menu of selectable items
221   local px = x0
222   local cy = ui_panel{ rect = rect_new(px, hy, pw, ph), title = 'PAUSED', brackets = true }
223   local iy = cy + SP.s3
224   for i, it in ipairs({ 'RESUME', 'RESTART', 'SETTINGS', 'QUIT' }) do
225     local mi = ui_menu_item{ rect = rect_new(px + SP.s2, iy, pw - 2*SP.s2, ih), label = it, selected = (i == menu_i), id = 'mi_' .. i }
226     if mi.clicked then menu_i = i end
227     iy = iy + ih + SP.s1
228   end
229 
230   -- panel 2: WAVE summary — stat rows + a continue button
231   px = x0 + (pw + gap)
232   cy = ui_panel{ rect = rect_new(px, hy, pw, ph), title = 'WAVE 05' }
233   local sx, sw = px + SP.s3, pw - 2*SP.s3
234   local sy = cy + SP.s3
235   for _, st in ipairs({ { 'TIME', '01:24' }, { 'KILLS', '38' }, { 'SCORE', '12,400' }, { 'COMBO', 'x9' } }) do
236     ui_stat{ rect = rect_new(sx, sy, sw, smooth and 18 or 9), label = st[1], value = st[2] }
237     sy = sy + (smooth and 28 or 14)
238   end
239   ui_button{ rect = rect_new(sx, hy + ph - (smooth and 50 or 24), sw, smooth and 36 or 16), id = 'p_cont', text = 'CONTINUE', active = true }
240 
... [12 more lines]

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua

Both fixed; parses clean.

SFX / SCREEN SHAKE → checkboxes

The SETTINGS panel now uses checkboxes for SFX / SCREEN SHAKE / FULLSCREEN (consistent, unambiguous on/off) instead of toggles. The ui_toggle widget still exists in the toolkit — I'll show it once on the upcoming SELECTORS screen for coverage, but say the word if you'd rather drop it entirely.

Rough paused-menu selection

Two changes to the PAUSED panel so it reads like the lab's RICOCHET title menu:

Dropped the panel's brackets = true — it was stacking panel corner-brackets on top of the selected item's corner-brackets near the top corners.
Inset the menu items (SP.s4 margin + wider row gap) so the selected item's brackets sit cleanly inside the panel instead of colliding with its border. That collision was the stray "chevron"-looking clutter.

The widget itself (R.menu_item = centered text + ink corner brackets when selected) already matches ru_menu_item; the problem was the cramped panel context, so the fix is in the screen layout, not the widget.

I couldn't capture the running game window to confirm by eye (it's not a Start-menu app, so computer-use can't grab it). If after running it the rough selection still doesn't match the lab title menu, tell me what's off and I'll adjust.

Test

Run ./run.bat (rough) → PANELS (screen 5). Check: selected pause item's brackets sit clean inside the panel; SETTINGS shows three checkboxes + difficulty segment. Flip MODE = 'smooth' to confirm that skin too.

Want me to continue to SELECTORS & INPUTS (text_input + focus/hover/disabled states, and the toggle demo), then TYPOGRAPHY?

[Pasted image/png]

Just flip them so they're pointing outwards instead, and make sure they don't go over anything.

Now I can see it clearly. The selected item's brackets currently have their arms flaring outward (away from the item by arm+gap ≈ 7px), so the corners poke up over the title divider and down toward RESTART. The lab's ru_brackets does the opposite: the vertex sits just outside the corner and both arms run inward along the edges (a tight frame-corner / crop-mark) — that's the "pointing outwards" look you want, and it only sticks out by gap (2px), so it won't cover anything.

ric.brackets (the shared primitive behind every bracket in the package) is simply mirrored vs ru_brackets. Flipping the two arm directions fixes it everywhere consistently:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   ricochet/ui.lua

Done — parses clean. The fix is in the shared ric.brackets primitive, so it applies everywhere brackets appear (menu selection, selected card, panel brackets) — all now use the lab's outward-pointing frame-corner orientation, consistent with ru_brackets.

What changed: each corner L now has its vertex gap (2px) outside the corner with both arms running inward along the edges, instead of flaring outward by arm+gap (~7px). So the selected RESUME item's brackets hug its corners and stick out only 2px — they no longer reach up over the title divider or down into RESTART.

Test

Run ./run.bat (rough) → PANELS (5). The selected pause item should now read as a tidy crop-mark frame that stays clear of the divider and neighbors. Quick glance at CARDS (4) too — the selected card's brackets flipped the same way (should look cleaner/tighter there as well); tell me if you'd rather cards keep more spread.

Continue to SELECTORS & INPUTS next (text_input + focus/hover/disabled states, plus the toggle demo), then TYPOGRAPHY?

Perfect, continue. For typography, check Anchor2/site/main.lua. The typography there is based on the same references but done extremely well visually, so read what's going on there and try to apply it here.

[Request interrupted by user]

Although that one is only valid for smooth mode, no rough mode there.

No response requested.

Continue.

Continuing with SELECTORS & INPUTS. The one new widget is ui_text_input (the rough lab has ru_field with a caret; smooth has none). Real text entry isn't in the interaction substrate, so it'll be a focus-aware display widget — click to focus (sets focus_id), shows a caret + recess fill when focused — which covers the reference's TEXT INPUT + the focus state. Everything else reuses existing widgets.

Smooth text_input:

Edit (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the catalog state + the SELECTORS screen. Let me read the current state-var and DRAW regions:

Read (E:/a327ex/ricochet-template/components.lua)

72   local SCREENS = { 'hud', 'counters', 'buttons', 'cards', 'panels', 'selectors', 'typography' }
73  local screen_i = 5   -- start on the freshly-built screen (panels)
74  local chip_i   = 2   -- CHIP BUTTONS segment selection (caller-owned state)
75  -- PANELS screen state (caller-owned)
76  local menu_i   = 1
77  local diff_i   = 2
78  local sfx_on, shake_on, full_on = true, false, true
79

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

SELECTORS & INPUTS done; all files parse. Catalog opens on it (screen 6).

New widget: `ui_text_input{ rect, value, placeholder, id }` (both skins)

Focus-aware field — click to focus (sets focus_id → recess fill + caret after the value); placeholder shown muted when empty. Real key entry isn't in the interaction substrate (it was dropped from ui_state), so value is caller-supplied; this gives the visual + the focus interaction the reference shows. Smooth = field fill / 8px pad / 2px caret; rough = panel fill / 3px pad / 1px caret (matches ru_field).

Screen (two columns, both modes)

A: TAB SWITCHER · SEGMENTED CONTROL · SLIDER (VOLUME 40%) · TOGGLE (AUTO FIRE) · CHECKBOX (VSYNC) · RADIO (LOW/MED/HIGH)
B: DROPDOWN (SORT: NEWEST) · QUANTITY STEPPER · CYCLER FIELD (QUALITY < MED >) · TEXT INPUT · STATES (default + disabled buttons; hover the default, click the input to focus)

The ui_toggle you wanted relocated lives here now (clear AUTO FIRE context), not in the settings panel.

Test

Run ./run.bat (rough) → SELECTORS. Exercise each: tabs/segment select, slider drags, toggle/checkbox flip, radio is exclusive, stepper ±, cycler </>, click the text input (caret appears), hover DEFAULT / note DISABLED stays muted. C mono, flip MODE for smooth.

Next: TYPOGRAPHY

Per your note I'll study Anchor2/site/main.lua (smooth-only there — I'll derive a rough scale for the rough skin since the site has none) and build the hierarchy/spacing screen. That's the last sheet section. Want me to continue straight into it?

Lua draw() error: ricochet/skin_rough.lua:187: attempt to concatenate a nil value (field 'id')

ui_stepper needs an id (it builds id .. '_dn'/'_up' for its nudge buttons), and I omitted it in the SELECTORS stepper call. Fixing:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK components.lua

Fixed — the SELECTORS stepper now passes id = 's_step'. Parses clean.

That was the only id-less interactive widget on the screen (the other id-less calls — ui_counter, ui_upgrade_chip, ui_stat, ui_ability_slot, ui_hud_bar, ui_segbar — are pure display widgets that never touch ric.interact, so they're safe). Re-run ./run.bat and the SELECTORS screen should draw.

Great, it all works.

Glad it works. Now the last screen — TYPOGRAPHY — and you pointed me at Anchor2/site/main.lua as the well-executed reference (smooth-only there). Let me study how its type system and vertical rhythm work before I build.

Read (E:/a327ex/Anchor2/site/main.lua)

1    --[[
2     Anchor site renderer — visual identity proof-of-life (locked).
3   
4     Same shape as the original Phase 0 scene, but the 3-column section that
5     compared display-font candidates (Bebas / Oswald / Barlow) is now a
6     3-column type-scale section showing the locked-in families: Oswald for
7     display, IBM Plex Sans for body, Cascadia for mono. The rest — brand
8     wordmark, body typography paragraph, accent palette — is unchanged in
9     intent, just driven by the post-decision theme.
10  
11    This is a snapshot view, not the active development scene. The canvas
12    renderer (data/canvases/test.lua + comparison.lua flow) is what main.lua
13    reverts to once the body-font pick lands.
14  ]]
15  
16  require('anchor')({
17    width = 1920,
18    height = 1080,
19    title = 'Anchor — site renderer',
20    scale = 1,
21    vsync = true,
22    filter = 'smooth',
23  })
24  
25  require('theme')
26  
27  ui_layer = layer_new('ui')
28  
29  -- ============================================================
30  -- Layout constants
... [137 more lines]

This is the key reference. What makes the site's typography read well, to carry over:

Numbered mono micro-labels (01 · TYPE SCALE · …) in secondary ink heading each section.
Full-width hairline rules separating major sections, on a consistent rhythm.
A labeled type-scale block — display H1/H2/H3 stacked, body variants, mono variants, each with a tiny mono header.
A real prose paragraph stepping by a fixed line-height (24 for 16px body), with an inline emphasis run — this is the "does sequential text look right" demonstration.
Restrained 3-level ink hierarchy (primary/secondary/muted), generous consistent left margin.

One gap: the package theme ships only 4 font roles (title/body/mono/small), but a type scale needs several display sizes. Let me confirm what font files are available before I brief the approach.

Bash (cd "E:/a327ex/ricochet-template/assets"
echo "=== smooth vector fonts (root) ===...)

=== smooth vector fonts (root) ===
CascadiaCode-Regular.ttf
IBMPlexSans-Regular.ttf
Oswald-Medium.ttf
=== fonts/ (pixel + any others) ===
fonts/BoldPixels.ttf
fonts/CozetteVector.ttf
fonts/FatPixelFont.ttf
fonts/PixelOperator-Bold.ttf
fonts/PixelOperator.ttf
fonts/PixelOperator8.ttf
fonts/PixelOperatorMono.ttf
fonts/PixelOperatorMono8.ttf
fonts/ark-pixel-10px-proportional-latin.ttf
fonts/m5x7.ttf
fonts/monogram.ttf
=== italic anywhere? ===
(no italic)
=== ru_text_scaled in rough_ui (rough integer upscale helper) ===
139:function ru_text_scaled(font, text, x, y, s, col)
140-  layer_push(game_layer, x, y, 0, s, s)
141-  layer_text(game_layer, text, font, 0, (font.voff or 0), col or palette.ink())
142-  layer_pop(game_layer)
143-end
144-function ru_text_scaled_center(font, text, x, w, y, s, col)
145-  ru_text_scaled(font, text, x + math.floor((w - font:text_width(text) * s) / 2), y, s, col)

Everything I need is here. Oswald/IBM Plex Sans/Cascadia are available for smooth; no italic (I'll use secondary-ink for emphasis instead, since the kit forbids synthetic styling anyway). Here's the design brief for the TYPOGRAPHY screen.

Design Brief — TYPOGRAPHY screen

Goal. Demonstrate typographic layout craft — hierarchy, paragraph rhythm, captions, correct vertical spacing — mirroring Anchor2/site/main.lua's approach. This screen is about placement, not new widgets.

What I'm carrying over from the site:

Numbered mono micro-labels (01 · TYPE SCALE, 02 · BODY COPY) in secondary ink heading each block.
Full-width hairline rules between blocks on a consistent rhythm.
A labeled type-scale block (display H1/H2/H3 + body + caption + mono samples, each tagged with its role).
A real prose block — a sub-heading + multi-line paragraph stepping by a fixed line-height, with one emphasized run — the "does sequential text read right" proof.
Three-level ink hierarchy: primary ink / secondary mid_light / muted mid_grey. Consistent left margin.

Fonts (the one structural need). The package theme ships only 4 roles, but a scale needs several display sizes:

Smooth: register specimen sizes locally in components.lua — Oswald @ {44, 30, 20}, IBM Plex Sans @ {16, 13}, Cascadia @ {13, 11}. (Same TTFs the theme already uses, just more sizes.) Local to this screen; I won't bloat the theme.
Rough: reuse the theme's pixel fonts (PxOpB / Ark10 / Monogram / PxOp8); big display sizes come from integer-upscaling via a new shared helper ric.text_scaled(font, text, x, y, scale, col) (push/scale on ui_layer + voff — the package version of the lab's ru_text_scaled), so titles stay crisp at 4×.

Layout, top to bottom (both skins, scaled per mode):

Page wordmark (H1) + caption beneath.
hairline.
01 · TYPE SCALE — smooth: the site's 3-column display/body/mono layout; rough: a single stacked list (no room for 3 columns at 480), each sample with a small role label.
hairline.
02 · BODY COPY — a sub-heading + a 4–5 line paragraph stepping by line-height, one phrase in secondary ink for emphasis; then a second short paragraph to show inter-paragraph spacing.
hairline + a muted mono footer line.

Rhythm. Vertical cursor advances in explicit steps derived from the body line-height (smooth ≈ 24 for 16px; rough ≈ body.height + 3), section gaps a multiple of it — matching the site's deliberate spacing.

Per-skin divergence. Smooth = vector, generous, 3-column scale (faithful to the site). Rough = pixel, constrained, stacked scale, integer-scaled titles — the "no rough reference, derive it simpler" case.

Two checks before I build: the Oswald 44/30/20 display sizes for smooth (vs. design.md's larger 64/40/22 — I sized down so a full page fits one screen without scrolling), and that a stacked rough scale (vs. smooth's 3-column) is the right call for 480px. Good to go?

Go ahead.

Approved — building. First the shared ric.text_scaled helper in ui.lua:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the specimen-font table in components.lua (after the layout constants):

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now draw_typography + registration. Let me check the current DRAW line:

Grep (^local DRAW =)

344:local DRAW = { hud = draw_hud, cards = draw_cards, buttons = draw_buttons, counters = draw_counters,

Read (E:/a327ex/ricochet-template/components.lua)

344  local DRAW = { hud = draw_hud, cards = draw_cards, buttons = draw_buttons, counters = draw_counters,
345                panels = draw_panels, selectors = draw_selectors }
346

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now start on the typography screen and update the status docblock:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   components.lua
OK   ricochet/ui.lua

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

<tool_use_error>String to replace not found in file.
String:   `ui_divider`, plus the `ric.*` helpers (interact / text_in / vcenter / hline /
  vline / frame / brackets / icon) the skins compose from.</tool_use_error>

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

149  
150 - **Shared** (mode-independent, in `ui.lua`): `ui_frame` `ui_text` `ui_icon`
151   `ui_icon_button` `ui_divider`, plus the `ric.*` helpers (interact / text_in / vcenter / hline /
152   vline / frame / brackets / icon) the skins compose from.
153 - **Per-skin** (bound by `use_skin`): `ui_panel` `ui_brackets` `ui_field`
154   `ui_segment` `ui_slider` `ui_button` `ui_bar` `ui_checkbox` `ui_radio`

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

TYPOGRAPHY built; all files parse. That completes all seven sheet-02 sections in both skins — the component catalog is done.

What the typography screen does

Mirrors Anchor2/site/main.lua's structure: wordmark + caption → hairline → 01 · TYPE SCALE → hairline → 02 · BODY COPY → (smooth) footer, with the numbered mono micro-labels, full-width hairline rhythm, and three-level ink hierarchy (ink/mid_light/mid_grey).

Smooth — faithful to the site: a 3-column scale (DISPLAY Oswald H1/H2/H3 · BODY Plex regular + caption · MONO Cascadia code/label/tiny), then a real paragraph stepping by a 24px line-height with one phrase in secondary ink, an inter-paragraph gap, and a muted footer. Uses locally-registered Oswald 44/30/20 + Plex 16/13 + Cascadia 13/11.
Rough — derived (no site reference): wordmark via ric.text_scaled(PxOpB, ×2), a stacked scale with inline role labels (HEAD/BODY/CAP/MONO showing the real 16/10/8/16px hierarchy), and a 4-line paragraph at the Ark10 line-height. Sized to fit 480×270.

New shared helper ric.text_scaled(font, text, x, y, scale, col) (the package version of the lab's ru_text_scaled) — integer-upscales pixel fonts crisply for the rough titles.

Test

Run ./run.bat (rough) → opens on TYPOGRAPHY (screen 7). Check the hierarchy reads cleanly and the paragraph rhythm looks right; T for dark/light. Then flip MODE = 'smooth' in components.lua:22 and re-run — the smooth 3-column scale is the one meant to match the Anchor site closely.

The hand-tuned offsets (smooth column baselines, rough vertical budget) are the likely spots to nudge — tell me if any spacing reads off.

That's the full task you set out: every UI element from sheets 02/03/05 now has a default build in both the smooth and rough skins, demonstrated across seven catalog screens. Possible follow-ups when you want them: a pass to refresh the CLAUDE.md roadmap (mark the composite-screens item done), or circle back to any screen for visual polish. What's next?

[Pasted image/png]

[Pasted image/png]

A little off on the top left, Section Heading also needs more space. This is for smooth. For rough, same issue on the top left.

Two fixes. The top-left collision (both modes): draw_typography starts its wordmark at y = top, but top is exactly where draw_chrome draws the "COMPONENTS / TYPOGRAPHY" breadcrumb — so they overlap. Every other screen starts at content_top (which leaves room below the chrome). And the smooth "Section Heading" needs more breathing room above it and below it (it's crammed against the 01/02 rule).

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now trim the rough paragraph to 3 lines so it still fits comfortably below the lowered wordmark:

Edit (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK components.lua

Fixed; parses clean.

Changes

Top-left overlap (both modes): draw_typography was starting its RICOCHET wordmark at y = top — the exact line where draw_chrome draws the COMPONENTS / TYPOGRAPHY breadcrumb. Now it starts at content_top (below the chrome), like every other screen, so the wordmark clears the breadcrumb.
Smooth "Section Heading" spacing: widened the display column — H1→H2 gap 58, H2→H3 gap 44 (was 38), and the block end pushed to s + 168 (was 144). H3 now has ~30px of clearance to the 01/02 rule instead of being crammed against it.
Rough: trimmed the body paragraph from 4→3 lines so the screen still fits comfortably (the lowered wordmark cost ~22px of vertical budget at 270px).

Test

Run ./run.bat → TYPOGRAPHY (screen 7). The RICOCHET wordmark should sit cleanly below the breadcrumb (no overlap), and "Section Heading" should breathe above the divider. Flip MODE to check both. If the smooth column gaps want one more nudge, tell me the spot.

Very good. Is this the end?

Functionally, yes — the task you set out is complete. Every category you enumerated is built and demonstrated in both skins:

Sheet 02: TOP HUD BARS · COUNTERS & BADGES · BUTTONS & CONTROLS · CARDS & UPGRADE CHIPS · PANELS & WINDOWS · SELECTORS & INPUTS
Sheet 03: TYPOGRAPHY (hierarchy + paragraph rhythm)
Sheet 05: UPGRADE CHIPS

Across that, ~13 new reusable widgets landed in the toolkit (card, upgrade_chip, counter, status_tag, hud_bar, segbar, ability_slot, icon_button, menu_item, text_input, + ric.accent/text_scaled/monochrome), plus the segment and bracket-orientation fixes.

Two honest loose ends, both optional and beyond your enumerated list:

A few pre-existing toolkit widgets aren't shown on any catalog screen — list_row (leaderboard rows), sparkline, keyhint (keycaps), the bare bar, and divider. They do have builds in both skins (from the earlier generalization), they're just not demonstrated. If you want true "every widget visible," that's a small DATA / MISC screen or folding them into existing ones. Not in your sheet-02/03/05 ask, so I left them.
The template's CLAUDE.md roadmap is now stale — it still lists "composite example screens" as the deferred NEXT-SESSION item, which this session completed. Worth a close-out edit to mark it done and record components.lua + the new widgets, so the next instance isn't misled. (Doc-only; I can do it now.)

The broader roadmap items remain separate efforts: swatch_row, replacing snkrx-template's effect system with this one, flow-field per-cell rotation, and the engine CJK atlas.

Want me to do the CLAUDE.md roadmap close-out, add the small DATA screen for the undemonstrated widgets, or call it here?

I'm more interested in making sure that things are properly generalized and usable. We already made sure the API for drawing the effects is simple to use, is the API for doing all these UI elements also simple to use and generalizable? What does the code look like for the most part? I just want to make sure next instances don't have to struggle too much when building and manipulating UI elements.

[Request interrupted by user]

Maybe check SNKRX template as well as other UI-related code like the Anchor App we've been playing with recently to see if there are any insights there.

Good question to pause on — and the right instinct before more building. Let me actually examine the three codebases rather than assert from memory: re-confirm the ricochet UI API surface, and survey SNKRX-template + the Anchor App for ergonomics insights. Launching the two surveys in parallel while I tally the ricochet signatures.

Grep (^function (S|R).(\w+)(o))

18:function S.panel(o)
43:function S.field(o)
58:function S.segment(o)
86:function S.slider(o)
114:function S.button(o)
131:function S.bar(o)
143:function S.checkbox(o)
159:function S.radio(o)
172:function S.toggle(o)
187:function S.stepper(o)
208:function S.dropdown(o)
220:function S.tabs(o)
243:function S.pips(o)
253:function S.stat(o)
267:function S.list_row(o)
281:function S.tag(o)
288:function S.badge(o)
297:function S.keyhint(o)
311:function S.sparkline(o)
331:function S.card(o)
366:function S.upgrade_chip(o)
388:function S.counter(o)
407:function S.status_tag(o)
426:function S.hud_bar(o)
443:function S.segbar(o)
460:function S.ability_slot(o)
477:function S.menu_item(o)
492:function S.text_input(o)

Agent

[
  {
    "type": "text",
    "text": "Excellent. I have all the information I need. Let me compile my findings into a comprehensive report.\n\n---\n\n## snkrx-template UI Toolkit \u2014 Ergonomics Survey\n\n### 1. **Invocation Style**\n\n**One opts table per widget.** No positional args; everything is keyed in a single dict/table.\n\n**Examples:**\n\n```lua\n-- Static (no interaction):\nui_label({ x = 8, y = 8, text = 'lvl 7' })\n\n-- Interactive with explicit rect:\nlocal res = ui_button({\n  rect = rect_new(8, 8, 60, 22),\n  id = 'pause',\n  label = 'pause',\n  variant = 'secondary'\n})\nif res.clicked then game_paused = not game_paused end\n\n-- Auto-sized button (x/y instead of rect):\nui_button({ x = 8, y = 8, label = 'play' })\n\n-- Immediate-mode pattern (state is caller-owned):\nlocal r = ui_checkbox({\n  rect = rect_new(8, 54, 16, 16),\n  id = 'chk1',\n  checked = my_opt,\n  label = 'enable option'\n})\nif r.clicked then my_opt = r.checked end\n```\n\nWidget families differ slightly:\n- **Rect-positioned** widgets: `opts.rect = {x, y, w, h}` (from RectCut).\n- **Position-only** widgets (labels, chips, pips): `opts.x, opts.y` + auto-size.\n- **Rect-optional** widgets (buttons): either `opts.rect` OR `opts.x + opts.y + label`.\n\n---\n\n### 2. **Return Values**\n\n**Consistent across widgets: always a table.** No nil or scalar returns; every widget returns a table you index.\n\n**Standard return shape:**\n\n```lua\n-- Click-only widgets (button, slot, list_row, card):\n{ hovered = bool, clicked = bool, ...extra }\n\n-- Stateful widgets (checkbox, radio, slider, text_input):\n{ checked = bool, clicked = bool }           -- checkbox\n{ selected = bool, clicked = bool }          -- radio\n{ value = 0..1, changed = bool }             -- slider\n{ text = string, focused = bool, submitted = bool }  -- text_input\n\n-- Tabs (multi-item active selection):\n{ active = int, clicked = int or nil }\n\n-- Buttons also return their rect (for chaining layout):\n{ hovered = bool, clicked = bool, x = N, y = N, w = N, h = N }\n```\n\n**Immediate-mode pattern:** The widget reports what *changed this frame* (clicked, submitted); caller owns and passes in the full state (`checked`, `value`, `text`, etc.). State flows: `caller \u2192 widget opts \u2192 widget return \u2192 caller updates own state`.\n\nExample with slider:\n```lua\nlocal sl = ui_slider({ rect = r, id = 'sld_vol', value = gallery_volume })\ngallery_volume = sl.value  -- caller updates its own var\n```\n\n---\n\n### 3. **Positioning / Layout**\n\n**No auto-layout or container stack.** Caller must hand-compute or use **RectCut** \u2014 a rect-cutting utility that mutates and splits rects destructively.\n\n**RectCut (snkrx/ui/rect.lua):**\n```lua\nlocal r = rect_new(8, 8, width - 16, height - 16)   -- full screen minus 16px pad\nlocal topbar = rect_cut_top(r, 24)                  -- r mutates; slice returned\nlocal botbar = rect_cut_bot(r, 22)                  -- r mutates again; now r is body\n-- Now: r is the middle, topbar is 24px top, botbar is 22px bottom\n```\n\nFunctions: `rect_cut_left/right/top/bot` (mutate + return), `rect_get_*` (pure), `rect_add_*` (adjacent rects), `rect_contract/expand` (inset/outset), `rect_center`, `rect_split_h/v` (divide into n equal parts).\n\n**Gallery idiom for row layout:**\n```lua\nlocal row = rect_new(8, 50, width - 16, 34)\nfor _, p in ipairs(panels) do\n  local cell = rect_cut_left(row, 72)      -- eat 72px from row\n  rect_cut_left(row, 8)                    -- eat 8px gap\n  ui_panel({ rect = cell, ... })\nend\n```\n\n**No implicit stacking:** You hand-compute y-offsets for vertical stacks. No flexbox / CSS grid. The gallery shows this throughout \u2014 caller owns all coordinate math.\n\n---\n\n### 4. **State**\n\n**Rules: frame-local interaction state is implicit; persistent state is explicit caller-owned.**\n\n**Frame-local (managed by toolkit, reset each frame):**\n- `ui_state.hot_id` \u2014 widget under cursor this frame.\n- `ui_state.active_id` \u2014 widget the mouse landed on (persists until release).\n- `ui_state.focus_id` \u2014 last clicked widget.\n- These are rebuilt in `ui_state_begin_frame()` (top of each frame).\n\n**Persistent / data state (caller-owned, passed in + read back):**\n- Widget data (checked, selected, value, text, \u2026) flows `caller \u2192 opts \u2192 result`.\n- Identity: explicit string `id` (e.g., `id = 'pause'`, `id = 'inv1'`). No auto-IDs.\n\n**Interaction state persistence example (slider):**\n```lua\n-- State machine lives in ui_state.active_id\nif hovered and mouse_is_pressed(1) then\n  ui_state.active_id = id  -- \"now active\"\nend\nif ui_state.active_id == id then\n  -- Drag updates the value every frame until release\n  value = math.clamp((mx - r.x - knob_r)/travel, 0, 1)\n  if mouse_is_released(1) then ui_state.active_id = nil end\nend\n```\n\nThe drag state (active_id persisting across frames) IS the \"being dragged\" signal. No separate flag needed.\n\n**Retained juice (springs + HP-bar tweens):**\n```lua\nui_juice[id]     = { spring = ..., was_hovered = ... }\nui_bar_juice[id] = { front, back, shown_value, target, ... }\n```\nThese are keyed by widget id and persisted across frames for smooth animation. The HP bar tweens (front/back easing) are scheduled in a shared timer (`ui_timer`).\n\n---\n\n### 5. **Per-Frame Contract**\n\n**In `update()` (before any widget calls):**\n```lua\nui_typed_text = engine_get_typed_text()    -- drain SDL buffer\nui_state_begin_frame()                     -- reset hot/active/focus\nui_juice_update(dt)                        -- tick springs + bar tweens\n-- ... widget calls queue draws onto ui_layer ...\n```\n\n**In `draw()` (after game scene, before UI compositing):**\n```lua\nlayer_render(ui_layer)                     -- flush widget commands\nlayer_clear(ui_shadow_layer)\nlayer_draw_from(ui_shadow_layer, ui_layer, ui_shadow_shader)  -- shadow pass\nlayer_draw(ui_shadow_layer, shadow_offset_x, shadow_offset_y) -- shadow beneath\nlayer_draw(ui_layer)                       -- UI on top\n```\n\n**Details:**\n- `ui_typed_text` MUST be drained each frame (even if no widget reads it) or SDL's text queue fills up after ~32 keypresses and warns forever.\n- `ui_state_begin_frame()` resets hot/active/focus before widgets hit-test, so each frame's interaction is clean.\n- `ui_juice_update(dt)` runs springs + the bar tween scheduler.\n- Widgets queue draws onto `ui_layer` in immediate-mode calls (during update).\n- The shadow shader (one pass per frame) derives soft drop shadows from `ui_layer`'s alpha channel.\n\n---\n\n### 6. **Ergonomic Wins & Warts**\n\n**Wins:**\n\n1. **Single opts table is clean.** No positional arg overload hell. Callers see `{ rect = ..., id = ..., label = ... }` at the call site \u2014 immediately readable.\n\n2. **RectCut is a clever layout primitive.** Destructive cuts walk a rect; pure `get_*` / `add_*` let you query without mutating. The gallery shows this scales well for modest grids and lists.\n\n3. **Immediate-mode + explicit IDs.** State lives in caller code, not hidden in the widget. A game can snapshot `gallery_sel = nil; if res.clicked then gallery_sel = id end` in a single frame loop \u2014 no special \"managed state\" machinery. Debugging is direct.\n\n4. **Edition-backed coloring is subtle.** Every palette token has a mimic edition (shader modes 50..67) so UI colors shimmer like game entities \u2014 not baked, not separate. The whole UI \"breathes\" coherently.\n\n5. **Drop shadow via shader.** One pass per frame over `ui_layer`'s canvas; no per-widget overhead. \"No shadow inside a panel\" emerges automatically because the panel's body fill covers the offset shadow.\n\n6. **Juice is consistent.** Scale-pop bounces, hover sounds, and area-scaled intensity (`sqrt(900 / area)` so cards pop gently, buttons pop hard) are applied uniformly across widgets via `ui_juice_pull / hover`. New widgets inherit the SNKRX feel for free.\n\n**Warts:**\n\n1. **No auto-layout means repetitive coordinate math.** Every row/column/grid requires explicit hand-cutting or loop-computed offsets. RectCut helps, but you're still writing:\n   ```lua\n   local sx = 30\n   for _, it in ipairs(items) do\n     ui_slot({ rect = rect_new(sx, 74, 28, 28), ... })\n     sx = sx + 100\n   end\n   ```\n   A stack/row/column container helper would reduce this.\n\n2. **RectCut is Halt-style destructive mutation.** Idiomatic to that pattern, but unintuitive if you expect functional / immutable APIs. You must pass rects by reference and understand \"after this cut, the rect has shrunk.\"\n\n3. **Stateful widgets require explicit ID naming.** No auto-ID generation. The gallery carries line-scoped `local gallery_sel = nil` for inventory selection \u2014 state and rendering are decoupled. For a game with dynamic lists (e.g., 100 inventory items) you must generate IDs procedurally (`id = 'inv' .. i`). Works, but verbose.\n\n4. **Text input is end-pinned only.** No mid-string cursor, no selection. Append + backspace only. Fine for names, but not general-purpose text editing.\n\n5. **Modal raises `ui_input_locked` BEFORE drawing the screen behind it.** Caller must:\n   ```lua\n   ui_input_locked = true\n   -- draw the game world / UI behind the modal\n   ui_modal({ ... })  -- draws the scrim + panel, lowers ui_input_locked for its own content\n   ```\n   If you forget to set ui_input_locked early, the background stays interactive. It's easy to get wrong.\n\n6. **No scrolling / pagination primitives.** The gallery implements pagination by hand (page tables + `ui_gallery_page` index). Games must roll their own scroll containers, clipping, etc.\n\n7. **Shadow offset is global (`ui_shadow_offset_x / y` in init.lua).** All elements cast the same shadow direction. No per-widget override. Fine for SNKRX's flat aesthetic, but limits shadow customization.\n\n---\n\n## Summary\n\nThe snkrx UI toolkit is **pragmatic and immediate-mode**, trading auto-layout convenience for explicit control and clarity. Every widget takes a single opts table; state is caller-owned; interaction is rules-based (derived from `ui_state` each frame) with a small retained juice sliver. Layout is hand-computed via RectCut or procedural loops. The per-frame contract (typed-text drain, state-begin-frame, juice-update, layer-render-shadow-composite) is straightforward.\n\n**Best for:** SNKRX / Orblike UI aesthetics, menus, HUDs, and screens that benefit from full control (edition shimmer, drop shadow uniformity, precise juice tuning). Scales well up to ~20 widgets per screen.\n\n**Not best for:** Large dynamic lists, complex layout (flexbox/grid), or rapid UI iteration where hand-coordinate math is tedious. Consider a higher-level wrapper if you ship many screens."
  }
]

Agent

[
  {
    "type": "text",
    "text": "Perfect! Now I have a comprehensive view of the UI architecture. Let me create a detailed report on the findings.\n\n---\n\n## **Anchor App UI-API Ergonomics Survey**\n\nBased on analysis of `E:/a327ex/Anchor2/app-archive/`, here are concrete findings on the Anchor App's UI architecture:\n\n### **1. INVOCATION STYLE**\n\nThe UI uses **immediate-mode widget functions** with a single table argument. Widgets are global functions named `ui_<name>`:\n\n```lua\n-- widgets.lua, line 251-289: ui_button invocation\nif ui_button({id='save', rect=r, label='Save'}) then\n  save_document()\nend\n\n-- widgets.lua, line 88-108: ui_text\nui_text({rect=r, text=opts.text, font=font, color=color, align_h='left'})\n\n-- widgets.lua, line 194-217: ui_panel_header\nui_panel_header({\n  rect = r,\n  title = title,\n  font = font,\n  color = color,\n  pad_x = pad_x,\n  bg = bg\n})\n```\n\n**Pattern**: Options table with required keys (`id`, `rect`, `text`, `label`, etc.) + optional overrides for font/color/alignment. Caller-provided explicit IDs, not auto-generated. Typical call site from `panes/status_top.lua`:\n\n```lua\nui_strip_text_left({strip=content, text='Anchor', font=fonts.sans_brand, gap=8})\nui_strip_text_right({strip=content, text='time 14:23', font=fonts.mono_tiny})\n```\n\n**Ergonomic note**: Positional args replaced entirely by named-table options, making call sites verbose but self-documenting.\n\n---\n\n### **2. RETURN VALUES & EVENT HANDLING**\n\n**Widgets return interaction results directly**; no callbacks or polling.\n\n```lua\n-- widgets.lua, line 251-289: ui_button returns clicked bool\nfunction ui_button(opts)\n  local id = opts.id\n  local r = opts.rect\n  -- ... hit-test and state machine ...\n  local clicked = false\n  if ui_state.active_id == id and mouse_is_released(1) then\n    if ui_state.hot_id == id then clicked = true end\n    ui_state.active_id = nil\n  end\n  return clicked\nend\n```\n\n**State machine inside the widget**: claim hot (hover), set active on press, return true on release. Caller just checks the return:\n\n```lua\nif ui_button({id='save', rect=r, label='Save'}) then\n  save_document()\nend\n```\n\n**Global `ui_state` table** holds frame-local interaction state:\n\n```lua\n-- widgets.lua, lines 45-57\nui_state = {\n  hot_id = nil,      -- widget under cursor this frame\n  active_id = nil,   -- widget mouse-down was received on\n  focus_id = nil,    -- widget last clicked\n}\n\nfunction ui_state_begin_frame()\n  ui_state.hot_id = nil  -- reset once per update\nend\n```\n\n**No callbacks, no subscriptions**. Hit-test + state machine all run in the widget call itself. Very synchronous.\n\n---\n\n### **3. POSITIONING / LAYOUT**\n\n**RectCut is the core layout primitive** \u2014 a small module (`rect.lua`, ~100 lines) based on the Halt pattern:\n\n```lua\n-- rect.lua, lines 24-43: Mutating parent style\nfunction rect_cut_left(r, n)\n  local s = {x = r.x, y = r.y, w = n, h = r.h}\n  r.x = r.x + n\n  r.w = r.w - n\n  return s\nend\n\nfunction rect_cut_right(r, n)\n  r.w = r.w - n\n  return {x = r.x + r.w, y = r.y, w = n, h = r.h}\nend\n```\n\n**Idiom**: Successive cuts walk the rect:\n\n```lua\n-- panes/status_top.lua, lines 22-40\nlocal bar = rect_new(rect.x, rect.y, rect.w, rect.h)\nui_divider({rect = rect_cut_bot(bar, 1)})  -- extract 1px bottom, bar shrinks upward\nlocal content = rect_contract(bar, 0, 10, 0, 10)  -- inset by 10px left/right\n\nlocal glyph_cell = rect_cut_left(content, 10)  -- eat 10px from left\nlocal glyph = rect_center(glyph_cell, 10, 10)  -- center a 10\u00d710 square inside\n\nui_strip_text_left({strip=content, text='Anchor'})  -- mutates content as it goes\n```\n\n**Additional helpers** (rect.lua, lines 45-99):\n- `rect_get_*`: non-mutating peeks\n- `rect_add_*`: outside parent (overlays)\n- `rect_contract / rect_expand`: inset/outset by uniform or CSS-style margins\n- `rect_center(r, w, h)`: center a w\u00d7h rect inside r\n- `rect_split_h / rect_split_v`: divide into n equal pieces\n\n**No flex layout, no constraints**. Purely imperative: calculate rects, pass them to widgets. Layout is caller's responsibility, executed line-by-line in the update method.\n\n**Workspace-level slot layout** (workspace.lua, lines 133-147):\n\n```lua\nfunction workspace_compute_slot_rects()\n  local r = rect_new(0, 0, width, height)\n  local slots = {}\n  for _, slot in ipairs(tpl) do\n    if     slot.edge == 'top'    then slots[slot.name] = rect_cut_top(r, slot.size)\n    elseif slot.edge == 'bottom' then slots[slot.name] = rect_cut_bot(r, slot.size)\n    elseif slot.edge == 'left'   then slots[slot.name] = rect_cut_left(r, slot.size)\n    elseif slot.edge == 'right'  then slots[slot.name] = rect_cut_right(r, slot.size)\n    elseif slot.fill             then slots[slot.name] = r\n    end\n  end\n  return slots\nend\n```\n\nTemplate slots (main.lua, lines 151-155) define the schema:\n\n```lua\nworkspace_register_template('writing', {\n  {name='status_top', edge='top',    size=24},\n  {name='status_bot', edge='bottom', size=22},\n  {name='main',       fill=true},\n})\n```\n\nNo constraint solver. RectCut walks in declaration order; fill slot takes the remainder.\n\n---\n\n### **4. STATE MANAGEMENT**\n\n**Interaction state**: frame-local, global `ui_state`:\n\n```lua\n-- widgets.lua, lines 45-58\nui_state = {\n  hot_id = nil,      -- one per frame (reset in ui_state_begin_frame)\n  active_id = nil,   -- persists until mouse release\n  focus_id = nil,    -- persists until next click\n}\n```\n\n**Widget identity**: explicit caller-provided string IDs. No auto-ID or source-location hash:\n\n```lua\nui_button({id='save', rect=r, label='Save'})\nui_button({id='discard', rect=r, label='Discard'})\n```\n\n**Persistent UI state** (scroll, cursor, edit state): held by the **pane**, passed to widgets each frame. Panes own their state explicitly:\n\n```lua\n-- pane.lua, lines 66-80 (simplified)\npane = class()\nfunction pane:new(opts)\n  self.id       = opts.id\n  self.type     = opts.type\n  self.state    = opts.state or {}    -- caller-owned state table\n  self.model_id = opts.model_id\n  panes[self.id] = self                -- registry keyed by id\nend\n```\n\n**Model-view separation**: panes reference models by ID, not by direct pointer (docs/ui_architecture.md \u00a7 5):\n\n> **Cross-entity references use IDs**: `self.model_id = 'canvas:scratch'`, resolved per frame via `model_get(id)`.\n\n**Canvas pane example** (canvas.lua, top comment):\n\n```lua\n-- Elements are indexed by reference, not position\n{type='text', content={{text='...', style={bold=,...}}, ...}, x=, y=, w=, h=}\n{type='image', blob_id='blob:<hex>.<ext>', image=<image>, x=, y=, w=, h=}\n{type='embedded_view', pane_id=<string>, model_id=<string>, pane=<pane instance>, x=, y=, w=, h=}\n```\n\n---\n\n### **5. PER-FRAME / UPDATE STRUCTURE**\n\n**All state-machine + layer-command queueing runs in a single `pane:update(dt, input, rect)` call, NOT in a separate draw pass.**\n\nMain loop (main.lua, lines 203-213):\n\n```lua\nfunction update(dt)\n  sync_engine_globals()\n  ui_state_begin_frame()          -- clear hot_id once per update\n  workspace_update(dt, nil)       -- walks panes, calls pane:update for each\n  if verify_mode then engine_quit() end\nend\n\nfunction draw()\n  layer_render(ui_layer)          -- no UI logic here \u2014 just flush the queue\n  layer_draw(ui_layer)\nend\n```\n\n**Workspace frame walk** (workspace.lua, inferred from context):\n\n1. Compute slot rects from the template via `rect_cut_*`.\n2. Update drag state (track Ctrl+mouse).\n3. Compute `workspace_pointer_target` (deepest pane under cursor, handling embedded views).\n4. For each (slot, pane_id) in the active mode's assignment:\n   - Call `pane:update(dt, input, slot_rect)`.\n   - Pane runs its state machine AND queues layer commands in this single call.\n5. Route drops to the deepest pane.\n6. Handle global keybinds (mode switch, undo, palette).\n\n**Why update, not draw?** (docs/ui_architecture.md \u00a7 4):\n\n> 1. The engine calls `input_post_update()` between update and draw, so `mouse_is_pressed/released` only return true during `update`. Widgets need those edges for click detection.\n> 2. `layer_rectangle / layer_text` don't render immediately \u2014 they queue commands that get cleared at the start of each update and flushed by `layer_render` at draw time. Queueing in update is the natural fit.\n\n**Result**: Panes execute a full state machine + rendering pass each update frame. With the engine's 2:1 physics:render ratio, panes update ~2\u00d7 per visible frame \u2014 this is fine because the state machine is idempotent, and the layer queue is re-queued each update so only the last update's queue renders.\n\n---\n\n### **6. ERGONOMIC WINS & WARTS**\n\n**Wins:**\n\n1. **RectCut is terse and fluent**. Successive cuts walk a rect intuitively:\n   ```lua\n   local topbar = rect_cut_top(r, 24)\n   local botbar = rect_cut_bot(r, 22)\n   -- r is now the body between them\n   ```\n\n2. **Immediate-mode widgets are predictable**. No widget tree, no event bubbling. Call a widget \u2192 it hit-tests, updates state, renders, returns result \u2014 all in one go. Easy to reason about.\n\n3. **Explicit widget IDs + centralized `ui_state`**. No magic auto-IDs. The state table is small and visible. Debugging is straightforward: print `ui_state` at any frame.\n\n4. **Single `pane:update(dt, input, rect)` method**. No split between state machine and rendering. The pane's entire behavioral contract is one method. Reduces cognitive load.\n\n5. **Model-view separation via IDs**. Panes hold `model_id` strings, resolved per frame. Multiple views of the same model sync automatically \u2014 no special \"sync\" code needed.\n\n**Warts:**\n\n1. **RectCut is mutating-parent** \u2014 destructive on the parent. Easy to accidentally carry a shrunk rect too far. Requires discipline; no compiler help. Mitigated by keeping cuts close together:\n   ```lua\n   -- OK: cuts are local, intent clear\n   local bar = rect_new(...)\n   local top = rect_cut_top(bar, 24)\n   local bot = rect_cut_bot(bar, 22)\n   \n   -- Bad (but possible): loses the original top rect\n   local bar = rect_new(...)\n   local top = rect_cut_top(bar, 24)\n   -- ... 20 lines later ...\n   local bot = rect_cut_bot(bar, 22)  -- bar has already been mutated\n   ```\n\n2. **No layout composition**. If you want a row of buttons with automatic spacing, you hand-roll it with RectCut. No row/column helpers (helpers like `ui_strip_text_left` exist but are hand-written). Scaling to complex UIs requires careful nesting.\n\n3. **Explicit widget IDs are verbose** but necessary for `ui_state` keying. Each button/chip needs a unique string. Long panes have lots of ID strings:\n   ```lua\n   ui_button({id='file_save', ...})\n   ui_button({id='file_export', ...})\n   ui_button({id='edit_undo', ...})\n   -- ...\n   ```\n\n4. **No focus management for modal dialogs yet**. Palette (Ctrl+P) works, but the architecture is still being fleshed out. `workspace_modal_active()` gate exists but other panes don't fully respect it yet.\n\n5. **Pane state is untyped Lua table**. Callers must document the shape. No schema validation. If a pane's expected state field goes missing, you get a nil reference at runtime, not a compile-time error.\n\n6. **No visual feedback on hover for most widgets**. `ui_button` shows `bg_hover`, but chips and text labels are inert. The interactive state is invisible unless you specifically define it.\n\n---\n\n### **Concrete Code Example: Full Pane Update**\n\nHere's the entire top status bar (panes/status_top.lua, 42 lines):\n\n```lua\npane_register_type('status_top', {\n  update = function(self, dt, input, rect)\n    -- Bg fill + 1px bottom border\n    layer_rectangle(ui_layer, rect.x, rect.y, rect.w, rect.h, theme.bg_panel())\n    local bar = rect_new(rect.x, rect.y, rect.w, rect.h)\n    ui_divider({rect = rect_cut_bot(bar, 1)})\n    local content = rect_contract(bar, 0, 10, 0, 10)\n\n    -- Left: brand glyph + wordmark\n    local glyph_cell = rect_cut_left(content, 10)\n    local glyph = rect_center(glyph_cell, 10, 10)\n    layer_rectangle(ui_layer, glyph.x, glyph.y, glyph.w, glyph.h, theme.mauve())\n    rect_cut_left(content, 8)\n\n    ui_strip_text_left({strip=content, text='Anchor', font=fonts.sans_brand, gap=8})\n    ui_strip_text_left({strip=content, text='workspace \u00b7 alanis', font=fonts.mono_tiny})\n\n    -- Right cluster (right-to-left)\n    ui_strip_text_right({strip=content, text='time 14:23', font=fonts.mono_tiny, gap=14})\n    ui_strip_text_right({strip=content, text='filter smooth', font=fonts.mono_tiny, gap=14})\n    ui_strip_text_right({strip=content, text='target 1920\u00d71080', font=fonts.mono_tiny, gap=14})\n    ui_strip_text_right({strip=content, text='build 2026.04.28', font=fonts.mono_tiny})\n  end,\n})\n```\n\nThat's the entire pane. No state, no event handlers \u2014 pure render from a rect. All UI logic flows top-to-bottom, no hidden behavior. The pane does one thing: fills a rect with chrome.\n\n---\n\n## **Summary**\n\n| **Dimension** | **Finding** |\n|---|---|\n| **Invocation** | Immediate-mode functions (`ui_button()`, `ui_text()`) taking a single options table; explicit caller-provided IDs. |\n| **Events** | Return values + early-exit (if `ui_button() then handle_click()`). Frame-local state in global `ui_state` table. No callbacks or polling. |\n| **Layout** | RectCut (mutating-parent rect-slicing primitive) + RectCut helpers (contract, center, split). Purely imperative; no constraints, no flex. |\n| **State** | Interaction state (hover/active/focus) is transient, global. Persistent state lives in the pane as an untyped table. Models referenced by ID. |\n| **Main loop** | Single `pane:update(dt, input, rect)` runs state machine + layer queueing. No separate draw phase. `draw()` just flushes the layer queue. |\n| **Ergonomic wins** | Terse RectCut; simple immediate-mode predictability; explicit IDs; single update method; automatic multi-view sync via model IDs. |\n| **Ergonomic warts** | Mutating-parent RectCut requires discipline; no layout composition helpers; verbose IDs; untyped pane state; minimal hover feedback; modal focus management incomplete. |"
  }
]

I've now got the full picture — the ricochet API surface, plus how SNKRX-template and the Anchor App solve the same problems. Here's an honest appraisal.

Verdict

The architecture is right — it's the same immediate-mode family as both proven toolkits: one opts-table per widget, caller-owned state, explicit string ids, draws queued to a layer. A next instance who's seen SNKRX or the App will recognize it. But there are four rough edges that will make them stumble, and they're all fixable without changing the architecture.

What's already good (keep)

Single opts table per widget — self-documenting call sites, matches both references exactly.
Caller-owned state + explicit ids — the correct immediate-mode model; no hidden retained state to fight.
The two-skin binding (ui_panel resolves to the active skin) — genuinely nice; game code is skin-agnostic, something neither reference needs but ricochet gets for free.
ric.* composition helpers (text_in/frame/brackets/hline/icon/accent/text_scaled) — a solid substrate for building new widgets.

The rough edges

1. Return values are inconsistent — the biggest wart. Three different return styles, not predictable from the widget name:

returns	widgets
a table (`.clicked`/`.value`/`.index`/`.checked`/`.on`/`.dir`)	button, checkbox, radio, toggle, stepper, dropdown, tabs, slider, segment, field, card, menu_item, text_input, list_row
a number (next-x, for row packing)	tag, badge, keyhint, counter, status_tag, upgrade_chip, ability_slot
a number (next-y)	hud_bar, segbar
a number (content-top y)	panel
nothing	bar, pips, stat, sparkline

SNKRX's rule is "always a table"; the App's is "bool-or-nothing." Ours is neither — a next instance has to read the source to know whether ui_hud_bar{...} gives them .clicked or a y. There's a partial logic (xy-flow widgets return the next cursor) but it's not uniform (ability_slot is rect-ish yet returns a number; counter returns a number but isn't interactive).

2. No layout help is surfaced from the package. rectcut.lua ships (reused from SNKRX) but nothing uses it — and the useful bits (heading, sublabel, the SP spacing scale, the y-cursor pattern) live in components.lua, not the toolkit. A next instance building a screen gets zero layout assistance from ricochet/ and will hand-compute coordinates exactly like I did. Both references lean hard on RectCut + helpers: the App even has rect_contract/center/split_h/v and a ui_strip_text_left/right flow helper (mutate a strip, auto-advance), plus declarative workspace slot templates ({edge='top', size=24} → rect_cut_top). We have the primitive but don't encourage or build on it.

3. Per-frame contract is boilerplate-heavy with a silent footgun. A game must, every frame: capture mouse edges into ui_mouse_pressed/released globals (update), then ui_state_begin_frame() + effect_clear(ui_layer) + widgets + layer_render/draw + reset the edge globals (draw). Forgetting effect_clear means the global shader silently carves your flat UI — a confusing failure. The draw()-queued model is justified (the documented 144Hz flicker fix), but it's more ceremony than the App's "just run in update()."

4. The id footgun — the crash you hit. Compound-id widgets do o.id .. '_dn'; a missing id throws a cryptic "attempt to concatenate nil" instead of "ui_stepper requires an id."

A representative call site (what the code looks like)

local cy = ui_panel{ rect = rect_new(px, hy, pw, ph), title = 'PAUSED' }   -- number (content-top y)
local mi = ui_menu_item{ rect = rect_new(mx, iy, mw, ih), label='RESUME', selected=true, id='mi1' }
if mi.clicked then ... end                                                  -- table
sfx_on = ui_checkbox{ x=ox, y=oy, checked=sfx_on, label='SFX', id='sfx' }.checked   -- table.field
local x = ui_tag{ x=bx, y=by, text='RARE' }                                 -- number (next-x)
iy = iy + ih + SP.s2                                                        -- caller hand-advances y

Clean per call, but the reader can't predict the three different return shapes, and every vertical step is hand-math.

Recommended ergonomics pass (none change the architecture)

Cheap, high-value: (a) guard ids with a clear assert; (b) a ui_begin()/ui_end(layers) pair + ui_capture_input() that hide the edge-globals + effect_clear + reset ceremony so it can't be forgotten; (c) promote heading/sublabel/spacing scale into the package and document rectcut (+ maybe an App-style ui_row/strip-flow helper) so screens stop hand-mathing coordinates.
More invasive: standardize returns to always-a-table ({next_x=…}/{next_y=…} for flow widgets, interaction fields for the rest) — uniform like SNKRX, at the cost of touching every widget + the catalog call sites.

AskUserQuestion

Your questions have been answered: "Want me to do an ergonomics pass on the UI API, and at what scope?"="Cheap bundle + standardize returns + layout helpers.". You can now continue with these answers in mind.

The full pass it is. This is a sizable refactor across ~6 files and the new API shapes are real design decisions, so per the workflow I'll brief the exact contracts before touching code. First let me confirm what rectcut.lua already provides (so I don't propose adding what's there):

Read (E:/a327ex/ricochet-template/rectcut.lua)

1    --[[
2     rectcut.lua — RectCut layout primitive for the UI control panel.
3   
4     A rect is a plain table {x, y, w, h}. Three families of operations:
5   
6       cut_*(r, n) — mutates r (eats n pixels from one side), returns the slice.
7       get_*(r, n) — pure: returns a slice of r without mutating.
8       add_*(r, n) — pure: returns a new rect adjacent to r (extends outward).
9   
10    Plus utilities: contract / expand (inset / outset), center (place a w×h
11    rect centered inside another), split_h / split_v (divide into n equal
12    parts).
13  
14    Origin: Halt's RectCut pattern. Cuts are destructive on the parent so
15    successive cuts walk the rect. Canonical idiom:
16      local topbar = rect_cut_top(r, 24)   -- r is now the body below the topbar
17      local botbar = rect_cut_bot(r, 22)   -- r is now the body between bars
18  
19    Verbatim port from snkrx-template's snkrx/ui/rect.lua, which is itself
20    the Anchor App's app/rect.lua — proven, unchanged.
21  ]]
22  
23  function rect_new(x, y, w, h)
24    return {x = x, y = y, w = w, h = h}
25  end
26  
27  -- cut_*: mutate r (eat n from one side), return the eaten slice.
28  function rect_cut_left(r, n)
29    local s = {x = r.x, y = r.y, w = n, h = r.h}
30    r.x = r.x + n
... [73 more lines]

rectcut.lua is already full-featured (cut/get/add/contract/expand/center/split) — it's just not surfaced or used. So the layout work is conveniences on top, not a new primitive. Here's the design brief for the whole pass. Since this is core API design touching ~6 files, I want your sign-off on the shapes before I write it.

Design Brief — UI API ergonomics pass

1. Uniform return contract (every widget → a table `r`)

The fix for the biggest wart. Every ui_* widget returns a table, never a bare number/nil. Fields:

Always: r.next_x, r.next_y — the position just past the widget (right edge / bottom + a standard sp.s2 gap), so you can chain in either direction. Documented that they include the gap; use the rect you passed for exact bounds.
Interaction (when applicable): r.clicked, r.hovered.
Value echo (immediate-mode): r.value (slider), r.checked (checkbox), r.on (toggle), r.index+r.changed (segment/tabs), r.dir (stepper), r.focused (text_input), r.prev_clicked/r.next_clicked (field).
Container: panel returns r.content_y (content-top) — replacing today's bare-number return.

Call sites become uniformly .field: lua local p = ui_panel{ rect=r, title='PAUSED' } -- p.content_y if ui_menu_item{...}.clicked then ... end sfx = ui_checkbox{ checked=sfx, ... }.checked x = ui_tag{ x=x, y=y, text='RARE' }.next_x -- chains via next_x

2. Contract helpers (kill the boilerplate + the `effect_clear` footgun)

-- update():
ui_capture_input()        -- captures mouse edges into the sticky globals
-- draw():
ui_begin()                -- ui_state_begin_frame() + effect_clear(ui_layer)
  <widgets...>
  <game draws + layer_render/draw, as the game wants — order stays explicit>
ui_end()                  -- resets the edge globals

Removes the three silent footguns (forgetting effect_clear, forgetting the edge reset, the edge-capture-in-update dance). Render/draw order stays the game's call (it's layout-specific).

3. Layout conveniences (on top of the existing rectcut)

Spacing scale into the theme: ricochet_theme.sp = {s1..s8} per mode (smooth 4-px base / rough compressed). Replaces the local SP in the catalog.
Promote ui_heading{text,x,y,w} / ui_sublabel{text,x,y} into the package (return {next_y}).
ui_stack(x, y[, gap]) — a vertical cursor (gap defaults sp.s3), the fix for hand-mathed y = y + h + gap: lua local col = ui_stack(inset, content_top) col:heading('BUTTONS & CONTROLS', cw) -- draws + advances col:sublabel('PRIMARY BUTTON') ui_button{ rect = rect_new(col.x, col:take(bh), bw, bh), id='b1', text='START' } col:gap(sp.s4) Methods: :take(h)→y (advance), :gap(n), :heading(text,w), :sublabel(text), fields .x/.y.
Horizontal stays covered by next_x chaining (auto-sized) + rect_split_h(row, n) (fixed cells) — both already exist; I'll just document them rather than add a redundant ui_flow.
Document rectcut as the intended region-layout primitive (cut/contract/center/split) in CLAUDE.md, with the canonical idiom.

4. id guard (kill the cryptic crash)

ric.req_id(o, 'stepper') → returns o.id or errors with "ricochet: ui_stepper requires an id". Used by every interactive widget; ric.interact also asserts. No more "attempt to concatenate nil".

Files touched

theme.lua (sp scale) · ui.lua (contract helpers, req_id, heading/sublabel, ui_stack, shared-widget table returns, interact assert) · skin_smooth.lua + skin_rough.lua (uniform table returns + req_id) · components.lua (adopt the new contract / stack / returns; drop local heading/sublabel/SP) · main.lua (show the clean contract in the reference scene) · .claude/CLAUDE.md (document conventions, returns, contract, layout, id rule).

Risk / scope note

The return standardization is mechanical but wide: ~28 widgets × 2 skins + every catalog call site. I'll keep each widget's existing fields and just (a) wrap bare returns into tables and (b) add next_x/next_y. Behavior is unchanged; only the call-site read shape changes. I'll syntax-check after each file and the catalog is the live test of every widget.

Two things to confirm: (a) baking a standard sp.s2 gap into next_x/next_y (convenient chaining, slightly magical) vs. exact edges (predictable, but chained tags would touch) — I lean baked-gap; and (b) the ui_stack cursor shape above. Good to build?

Go ahead.

Building the full pass. Starting with the spacing scale in theme.lua (both profiles):

Edit (E:/a327ex/ricochet-template/ricochet/theme.lua)

The file E:/a327ex/ricochet-template/ricochet/theme.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/theme.lua)

The file E:/a327ex/ricochet-template/ricochet/theme.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the ui.lua infrastructure. Let me re-read it fresh (I've edited it several times):

Read (E:/a327ex/ricochet-template/ricochet/ui.lua)

1    --[[
2     ricochet/ui.lua — the Ricochet UI toolkit: shared core + the skin binder.
3   
4     The smooth (hi-res) and rough (low-res) Ricochet UIs are genuinely different
5     DESIGNS — not just sizes. Across the board the treatments differ (smooth radio
6     is a CIRCLE, rough is a square; smooth toggle has a green track; smooth tabs
7     invert the active cell; etc.). So EVERY widget that has a distinct look per
8     mode lives in a SKIN: `ricochet/skin_smooth.lua` (matches the smooth lab /
9     showcase + the reference sheets) and `ricochet/skin_rough.lua` (matches the
10    rough lab). `ricochet_use_skin(mode)` binds the active skin's functions onto
11    the public `ui_*` globals; `ricochet_theme_set` calls it. A game writes
12    mode-agnostic UI (`ui_panel{...}`); flipping MODE swaps look + metrics + fonts.
13  
14    This file holds only what is TRULY shared:
15      - the immediate-mode interaction step (`ric.interact`)
16      - text + hairline + bracket + icon draw helpers the skins compose from
17      - the handful of mode-independent public widgets (frame / text / icon / divider)
18      - `ricochet_use_skin`
19  
20    Per-frame contract (game's update + draw):
21      update(): capture mouse edges -> ui_mouse_pressed / ui_mouse_released
22      draw():   ui_state_begin_frame(); effect_clear(ui_layer); [widgets];
23                layer_render/draw(ui_layer); ui_mouse_pressed=ui_mouse_released=false
24  ]]
25  
26  ric = ric or {}
27  
28  -- immediate-mode step: claim hot -> press grabs active -> release-on-hot fires.
29  function ric.interact(id, rect)
30    ui_claim_hot(id, rect)
... [168 more lines]

Now the ui.lua edits. First the interact assert + req_id guard:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the shared widgets (table returns) + the contract & layout helpers:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Updating the ui.lua docblock to reflect the new contract:

Edit (E:/a327ex/ricochet-template/ricochet/ui.lua)

The file E:/a327ex/ricochet-template/ricochet/ui.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   ricochet/theme.lua
OK   ricochet/ui.lua

Now the skins — every widget's return becomes a uniform ric.ret(...) table, plus req_id on the compound-id widgets. The return lines aren't unique enough for safe targeted edits (e.g. return { clicked = clicked } recurs), so I'll re-read each skin and rewrite it carefully, changing only return statements and id-guards while preserving all the approved geometry verbatim. Re-reading smooth first:

Read (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

1    --[[
2     ricochet/skin_smooth.lua — the HI-RES Ricochet UI design (matches the smooth
3     lab / the reference sheets): FLAT page-colored panels (palette.field) with a
4     hairline ink border, subtle palette.mid_light corner brackets, a 2-row slider
5     with 5 tick marks + a square knob, and wider spacing. Glyph chevrons. A table
6     of widget-drawing functions bound onto the ui_* globals by
7     `ricochet_use_skin('smooth')`. Reads `ricochet_theme.metrics` for sizing.
8   ]]
9   
10  RICOCHET_SKIN_SMOOTH = {}
11  local S = RICOCHET_SKIN_SMOOTH
12  local function M() return ricochet_theme.metrics end
13  
14  function S.brackets(rect)
15    local m = M(); ric.brackets(rect, palette.mid_light(), m.corner_arm, m.corner_gap)
16  end
17  
18  function S.panel(o)
19    local r, m = o.rect, M()
20    if o.brackets then S.brackets(r) end       -- subtle grey L-brackets, outside
21    layer_rectangle(ui_layer, r.x, r.y, r.w, r.h, palette.field())  -- flat, page-colored
22    ric.frame(r, palette.ink())
23    if o.title then
24      local th = m.title_h
25      ric.text(ui_font_title, string.upper(o.title), r.x + m.inset, ric.vcenter(ui_font_title, r.y, th), palette.ink())
26      ric.hline(r.x, r.y + th, r.w, palette.ink())   -- divider under the title bar
27      return r.y + th + 1
28    end
29    return r.y
30  end
... [476 more lines]

Now rewriting skin_smooth.lua with uniform ric.ret returns + req_id on the compound-id widgets (field/segment/slider/stepper/tabs) — geometry preserved verbatim:

Write (E:/a327ex/ricochet-template/ricochet/skin_smooth.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_smooth.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK skin_smooth

Read (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

1    --[[
2     ricochet/skin_rough.lua — the LOW-RES Ricochet UI design (matches the rough
3     lab): panel-fill (elevated) containers, ink corner brackets, plain single-row
4     sliders, tight pixel spacing. A table of widget-drawing functions composed
5     from the shared `ric.*` helpers; bound onto the ui_* globals by
6     `ricochet_use_skin('rough')`. Reads `ricochet_theme.metrics` for sizing.
7   ]]
8   
9   RICOCHET_SKIN_ROUGH = {}
10  local R = RICOCHET_SKIN_ROUGH
11  local function M() return ricochet_theme.metrics end
12  
13  function R.brackets(rect)
14    local m = M(); ric.brackets(rect, palette.ink(), m.corner_arm, m.corner_gap)
15  end
16  
17  function R.panel(o)
18    local r, m = o.rect, M()
19    layer_rectangle(ui_layer, r.x, r.y, r.w, r.h, palette.panel())
20    ric.frame(r, palette.ink())
21    if o.brackets then R.brackets(r) end
22    if o.title then
23      local th = m.title_h
24      layer_rectangle(ui_layer, r.x, r.y, r.w, th, palette.recess())
25      ric.hline(r.x, r.y + th, r.w, palette.ink())
26      ric.text(ui_font_title, o.title, r.x + 5, ric.vcenter(ui_font_title, r.y, th), palette.ink())
27      return r.y + th + 1
28    end
29    return r.y
30  end
... [444 more lines]

Now rewriting skin_rough.lua with the same transformations:

Write (E:/a327ex/ricochet-template/ricochet/skin_rough.lua)

The file E:/a327ex/ricochet-template/ricochet/skin_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Both skins parse. Now components.lua — the "how to use it" artifact — gets rewritten to the new API: the ui_begin/ui_end/ui_capture_input contract, package ui_heading/ui_sublabel/ui_stack, ricochet_theme.sp, and the uniform return shapes (.content_y, .next_x, .next_y). Re-reading it fresh first:

Read (E:/a327ex/ricochet-template/components.lua)

Wasted call — file unchanged since your last Read. Refer to that earlier tool_result instead.

Let me read the rest of components.lua (I have 1–154 from context):

Read (E:/a327ex/ricochet-template/components.lua)

155    ui_button{ rect = rect_new(x0, y, bw, bh), id = 'b_prim', text = 'START WAVE', active = true }
156   y = y + bh + SP.s5
157   y = sublabel('SECONDARY BUTTON', x0, y)
158   ui_button{ rect = rect_new(x0, y, bw, bh), id = 'b_sec', text = 'UPGRADE' }
159   y = y + bh + SP.s5
160   y = sublabel('DISABLED BUTTON', x0, y)
161   ui_button{ rect = rect_new(x0, y, bw, bh), text = 'LOCKED', disabled = true }
162   y = y + bh + SP.s5
163 
164   -- column 2 (smooth) / continued stack (rough): icon buttons + chip buttons
165   local cx = smooth and col2 or x0
166   local cy = smooth and hy or y
167   cy = sublabel('ICON BUTTONS', cx, cy)
168   local ibx = cx
169   for _, ic in ipairs({ 'plus', 'check', 'x', 'search', 'gear' }) do
170     ui_icon_button{ x = ibx, y = cy, icon = icons[ic], id = 'ib_' .. ic }
171     ibx = ibx + isz + SP.s2
172   end
173   cy = cy + isz + SP.s5
174   cy = sublabel('CHIP BUTTONS', cx, cy)
175   local seg = ui_segment{ rect = rect_new(cx, cy, smooth and 200 or 110, bh),
176                           id = 'chips', options = { 'x1', 'x5', 'MAX' }, index = chip_i }
177   if seg.changed then chip_i = seg.index end
178 end
179 
180 local function draw_counters()
181   local x0 = inset
182   local hy = heading('COUNTERS & BADGES', x0, content_top, width - 2*inset)
183 
184   -- counters: each draws its own small-caps label above a framed [icon value] box
... [140 more lines]

Read (E:/a327ex/ricochet-template/components.lua)

325    end)
326   group(colB, 'QUANTITY STEPPER', M.btn, function(x, y)
327     sel_step = math.max(0, sel_step + ui_stepper{ x = x, y = y, value = tostring(sel_step), id = 's_step' }.dir)
328   end)
329   group(colB, 'CYCLER FIELD', rowh, function(x, y)
330     local f = ui_field{ rect = rect_new(x, y, cw, rowh), id = 's_fld', label = 'QUALITY', value = QUALITY_OPTS[sel_qual] }
331     if f.prev_clicked then sel_qual = (sel_qual - 2) % #QUALITY_OPTS + 1 end
332     if f.next_clicked then sel_qual = sel_qual % #QUALITY_OPTS + 1 end
333   end)
334   group(colB, 'TEXT INPUT', rowh, function(x, y)
335     ui_text_input{ rect = rect_new(x, y, cw, rowh), id = 's_txt', value = txt_val, placeholder = 'search...' }
336   end)
337   group(colB, 'STATES (hover / focus / disabled)', bh, function(x, y)
338     local w2 = (cw - g) / 2
339     ui_button{ rect = rect_new(x, y, w2, bh), id = 's_btn', text = 'DEFAULT' }
340     ui_button{ rect = rect_new(x + w2 + g, y, w2, bh), text = 'DISABLED', disabled = true }
341   end)
342 end
343 
344 -- TYPOGRAPHY: a layout-craft specimen (hierarchy + paragraph rhythm), mirroring
345 -- Anchor2/site/main.lua. Smooth = vector 3-column scale; rough = constrained
346 -- stacked scale with integer-scaled pixel titles. Ink hierarchy: ink / mid_light
347 -- / mid_grey = primary / secondary / muted.
348 local function draw_typography()
349   local x0 = inset
350   local cw = width - 2*inset
351   local y  = content_top   -- below the chrome breadcrumb (top is where it draws)
352   local lh = smooth and 24 or 13   -- body line-height
353 
354   local function rule()
... [60 more lines]

Read (E:/a327ex/ricochet-template/components.lua)

415      for _, ln in ipairs({
416       'Every wall hit spawns a',
417       'projectile that homes on',
418       'the nearest enemy.',
419     }) do ric.text(tf.body, ln, x0, y, palette.ink()); y = y + lh end
420   end
421 end
422 
423 local DRAW = { hud = draw_hud, cards = draw_cards, buttons = draw_buttons, counters = draw_counters,
424                panels = draw_panels, selectors = draw_selectors, typography = draw_typography }
425 
426 local function draw_stub(name)
427   local msg = string.upper(name) .. '  —  TODO'
428   ric.text_in({ x = 0, y = 0, w = width, h = height }, msg, ui_font_title, palette.mid_grey(), 'center')
429 end
430 
431 -- ---------------------------------------------------------------------------
432 -- chrome + frame
433 -- ---------------------------------------------------------------------------
434 local function draw_chrome()
435   ric.text(ui_font_title, 'COMPONENTS  /  ' .. string.upper(SCREENS[screen_i]), inset, top, palette.ink())
436   local hint = 'TAB > NEXT    T PALETTE    C MONO'
437   ric.text(ui_font_small, hint, width - inset - ui_font_small:text_width(hint), top + 2, palette.mid_light())
438   local by = height - top - ui_font_small.height
439   ric.hline(inset, by - SP.s2, width - 2*inset, palette.deep_grey())
440   local status = string.upper(MODE) .. '  ·  ' .. (ricochet_mono and 'MONO' or 'COLOR') .. '  ·  ' .. screen_i .. ' / ' .. #SCREENS
441   ric.text(ui_font_small, status, inset, by, palette.mid_light())
442 end
443 
444 -- ---------------------------------------------------------------------------
... [32 more lines]

I have the complete file. Rewriting components.lua to the new API — ui_begin/ui_end/ui_capture_input, package ui_heading/ui_sublabel/ui_stack (demonstrated in BUTTONS + SELECTORS), ricochet_theme.sp, and the uniform .content_y/.next_x/.next_y reads:

Write (E:/a327ex/ricochet-template/components.lua)

The file E:/a327ex/ricochet-template/components.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now main.lua — the clean reference scene — must adopt the new contract, and critically its ui_panel{...} + M.inset will break now that panel returns a table. Let me re-read it:

Read (E:/a327ex/ricochet-template/main.lua)

1    --[[
2     ricochet-template — main.lua : the clean reference scene a forked game edits.
3   
4     Fork the folder (run.bat resolves the new name automatically), then build your
5     game in this file. It ships almost nothing — a full-screen effect and one small
6     control panel — but it shows the whole skeleton: the MODE flag, the boot order,
7     the layers, the four-axis effect call, and the per-frame UI interaction
8     contract. The reusable theme lives in `ricochet/` (one `require`).
9   
10    MODE picks the resolution profile. A Ricochet game is high-res-SMOOTH or
11    low-res-ROUGH (never both); flip the flag and the matching engine config +
12    theme (fonts / icons / metrics / UI skin) are selected. The effect engine and
13    the widget API are identical at both; only the look + sizing differ.
14  
15    LAB = true runs the example galleries (lab.lua) instead of this scene — the
16    full tour of every pattern / shape / dither / icon / font + the UI in context
17    (the frozen v1 dev tools, kept as usage reference). Composite example screens
18    built on the NEW toolkit will live in their own gallery (next session).
19  
20    How to use the UI toolkit (see ricochet/ for the full widget set):
21      update(): capture mouse edges into ui_mouse_pressed / ui_mouse_released
22      draw():   ui_state_begin_frame(); effect_clear(ui_layer); <widgets...>;
23                render + draw game_layer then ui_layer; reset the edge globals.
24      Widgets take one opts table; pass `id` for interactive, omit for static;
25      state is caller-owned (you pass value/checked, the widget reports clicks).
26  ]]
27  
28  local MODE = 'rough'   -- 'rough' (480x270 pixel-art) | 'smooth' (1920x1080)
29  local LAB  = false     -- true -> run the example galleries (lab.lua) instead
30  local COMPONENTS = true -- true -> run the component catalog (components.lua; has its own MODE)
... [58 more lines]

Updating main.lua to the new contract + .content_y (its ui_panel{...} + M.inset would now error on a table):

Edit (E:/a327ex/ricochet-template/main.lua)

The file E:/a327ex/ricochet-template/main.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/main.lua)

The file E:/a327ex/ricochet-template/main.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/main.lua)

The file E:/a327ex/ricochet-template/main.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Syntax-checking everything:

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK   main.lua
OK   components.lua
OK   ricochet/init.lua
OK   ricochet/theme.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

All parse. Let me grep for any missed call sites — leftover bare-number reads, old heading/sublabel/SP references, or panel returns used as numbers:

Bash (cd "E:/a327ex/ricochet-template"
echo "=== leftover SP. / local heading/sublabel...)

=== leftover SP. / local heading/sublabel / bare ui_panel{ ===
components.lua:139:  colA:sublabel('PRIMARY BUTTON');   ui_button{ rect = rect_new(colA.x, colA:take(bh), bw, bh), id = 'b_prim', text = 'START WAVE', active = true }
components.lua:140:  colA:sublabel('SECONDARY BUTTON'); ui_button{ rect = rect_new(colA.x, colA:take(bh), bw, bh), id = 'b_sec', text = 'UPGRADE' }
components.lua:141:  colA:sublabel('DISABLED BUTTON');  ui_button{ rect = rect_new(colA.x, colA:take(bh), bw, bh), text = 'LOCKED', disabled = true }
components.lua:145:  colB:sublabel('ICON BUTTONS')
components.lua:150:  colB:sublabel('CHIP BUTTONS')
components.lua:267:    col:sublabel(label)
=== widget calls whose number return might be read bare (should end .next_x/.next_y) ===
(none — all chained returns use .next_x/.next_y)
=== ui_mouse_pressed leftover manual handling in components/main ===
(none — contract helpers handle it)

Clean — all sublabel( hits are the ui_stack:sublabel method form (correct), no leftover bare reads or manual input handling. Now the docs. Let me update the contract + API sections in the template CLAUDE.md:

Bash (cd "E:/a327ex/ricochet-template"
grep -nE "Per-frame UI contract|opts-table, snk...)

143:### The widget API (opts-table, snkrx convention)
145:pure draw; **interactive** (pass `id`) = hit-test + report. **Caller-owned state**
150:- **Shared** (mode-independent, in `ui.lua`): `ui_frame` `ui_text` `ui_icon`
160:### Per-frame UI contract

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

143  ### The widget API (opts-table, snkrx convention)
144 Every widget takes ONE opts table and draws to `ui_layer`. **Static** (no `id`) =
145 pure draw; **interactive** (pass `id`) = hit-test + report. **Caller-owned state**
146 (pass `value`/`checked`/`index`; widget returns `clicked`/`changed`/value).
147 Rect-positioned take `opts.rect = {x,y,w,h}` (a rectcut rect); a few are
148 position-only (`x,y`, auto-size + return next-x).
149 
150 - **Shared** (mode-independent, in `ui.lua`): `ui_frame` `ui_text` `ui_icon`
151   `ui_icon_button` `ui_divider`, plus the `ric.*` helpers (interact / text_in / vcenter / hline /
152   vline / frame / brackets / icon / accent / text_scaled) the skins compose from.
153 - **Per-skin** (bound by `use_skin`): `ui_panel` `ui_brackets` `ui_field`
154   `ui_segment` `ui_slider` `ui_button` `ui_bar` `ui_checkbox` `ui_radio`
155   `ui_toggle` `ui_stepper` `ui_dropdown` `ui_tabs` `ui_pips` `ui_stat`
156   `ui_list_row` `ui_tag` `ui_badge` `ui_keyhint` `ui_sparkline` `ui_card`
157   `ui_upgrade_chip` `ui_counter` `ui_status_tag` `ui_hud_bar` `ui_segbar`
158   `ui_ability_slot` `ui_menu_item` `ui_text_input`.
159 
160 ### Per-frame UI contract
161 ```lua
162 update(): if mouse_is_pressed(1) then ui_mouse_pressed = true end  -- + released
163 draw():   ui_state_begin_frame(); effect_clear(ui_layer)   -- passthrough baseline
164           <widget calls, queued on ui_layer>
165           effect_clear(game_layer); <world draws>
166           layer_render(game_layer); layer_render(ui_layer)
167           layer_draw(game_layer);   layer_draw(ui_layer)
168           ui_mouse_pressed, ui_mouse_released = false, false
169 ```
170 `effect_clear(layer)` before flat draws is REQUIRED: the shader is installed
171 globally, so without it, stale pattern/shape uniforms carve the flat UI.
172 
... [12 more lines]

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Final verification — scan the skins for any return that isn't the uniform ric.ret (a missed bare-number or bare-table return):

Bash (cd "E:/a327ex/ricochet-template"
echo "=== returns in skins NOT using ric.ret (s...)

=== returns in skins NOT using ric.ret (should be empty except brackets helper which returns nothing) ===
---done---
=== final syntax check ===
OK   main.lua
OK   components.lua
OK   ricochet/init.lua
OK   ricochet/theme.lua
OK   ricochet/ui.lua
OK   ricochet/skin_smooth.lua
OK   ricochet/skin_rough.lua

Done — the full ergonomics pass is in, all seven files parse, and every widget return now flows through ric.ret (the grep confirms no bare returns remain).

What changed

1. Uniform returns. Every ui_* widget now returns a table via ric.ret(x,y,w,h,fields) — always next_x/next_y (for chaining either direction) plus its own fields (clicked/value/checked/on/index/dir/content_y/…). No more "is it a number, a table, or nil?" guessing. Panel → .content_y; flow widgets (tag/badge/chip/counter/hud_bar/…) → .next_x/.next_y.

2. Contract helpers (kill the boilerplate + the silent effect_clear footgun): lua update(): ui_capture_input() draw(): ui_begin() -- ui_state_begin_frame + effect_clear(ui_layer) ...widgets... ; ...world... ; layer_render/draw(...) ui_end() -- consumes the mouse edges

3. Layout helpers in the package: ricochet_theme.sp (per-mode spacing scale), ui_heading / ui_sublabel, and ui_stack(x,y[,gap]) (:take(h) / :heading / :sublabel) for vertical rhythm — no more hand-mathed y = y + h + gap. rectcut documented as the region tool.

4. id guard. ric.req_id(o,'name') → "ricochet: ui_stepper requires an id" instead of the cryptic concat-nil crash; ric.interact asserts too.

5. components.lua rewritten as the clean reference — it now demonstrates the new API (ui_stack drives the BUTTONS and SELECTORS columns; every call site reads .content_y/.next_x/.next_y). main.lua updated to the new contract (its ui_panel{...} + M.inset would otherwise crash now that panel returns a table). Docs (CLAUDE.md) updated: API/return contract + per-frame contract.

Risk note (honest)

Both skin files were rewritten, not edited line-by-line — I preserved every geometry value verbatim and only touched return statements + id-guards, but a rewrite of ~500-line files means the real regression test is your eyes. The catalog exercises all ~30 widgets across 7 screens in both modes, so it's a thorough check.

Test

COMPONENTS = true, run ./run.bat. Cycle all 7 screens (Tab/1–7) in both modes (flip MODE in components.lua). Confirm nothing shifted vs. before, and interactions still work (clicks, hovers, the stepper, sliders, menu selection, focus).
Then COMPONENTS = false and run — the main.lua reference scene (EFFECT panel + COLOR cycler) should work via the new .content_y + ui_begin/ui_end contract.

If anything looks off, it'll be a geometry transcription slip in a specific widget — tell me which and I'll fix that one.

Yep, everything works the same. Anything else to do?

The task and the ergonomics pass are both complete and verified. The substantive work is done. One genuine loose end I should close (doc hygiene — I'd otherwise be leaving the docs misleading): the template's CLAUDE.md roadmap still lists "composite example screens" as the deferred NEXT-SESSION item, which this whole session finished. Let me read it and bring it current:

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

178  installed globally, so without it stale pattern/shape uniforms carve the flat UI).
179 `ui_begin` / `ui_end` / `ui_capture_input` are thin wrappers; bodies in
180 `ricochet/ui.lua` if a game needs to inline them. Vertical rhythm: `ui_stack`
181 (`:take(h)` / `:heading` / `:sublabel`); regions: `rectcut`.
182 
183 ---
184 
185 ## Roadmap — what's next (READ THIS FIRST, next instance)
186 
187 Built and settled. **Visual Experiments 4** closed the low-res arc AND the
188 generalization: patterns/shapes verified + tuned at 480×270, icons (HackerNoon) +
189 fonts (Ark10/PxOpB/Monogram) chosen, and the whole thing **packaged into
190 `ricochet/`** with the **two-skin UI toolkit** (smooth from `showcase.lua`, rough
191 from `rough_ui.lua`), a minimal `main.lua`, frozen labs, a folder-agnostic
192 `run.bat`, and trimmed assets. Visual Experiments 1–3 built the effect system
193 itself: the four-axis pipeline, the gallery + **effect editor**, the **ramp
194 editor**, image-as-SHAPE + image-as-CONTENT, shape **ROTATION**, and the
195 **single-call API** (`effect_rectangle` / `effect_circle` / `effect_image`).
196 
197 Locked decisions:
198 - **Icon pack = Tabler** (`assets/icons/tabler/`, fetched by
199   `tools/fetch_icons.mjs`, thin 0.75 stroke; outline + `_filled` variants).
200   Phosphor/Remix were compared and dropped (`tools/compare_packs.mjs`).
201 - **Color axis COMPLETE** — `none / solid / mix / ramp`. `shade` was built and
202   removed; `invert` / `desaturate` declined.
203 - **Shape axis COMPLETE** — `circle` / `square` / `diamond` / `triangle` /
204   `hexagon` / `ring` / `cross` + `icon (bg)` / `icon (field)`. Triangle was the
205   last primitive; further *recognizable* shapes go through icons, NOT new SDF
206   branches. One open idea (parked): a fill/outline modifier (hollow versions of
207   every shape — `ring` is already the hollow circle).
... [18 more lines]

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

226  2. **Two missing widgets + a fidelity nit.** `menu_item` (title-screen) and
227    `swatch_row` (palette picker) aren't ported (both skins). And the smooth
228    `stepper` uses `-`/`+` glyphs where `showcase.lua` used the Tabler minus/plus
229    ICONS (would need icon-loading in the smooth theme).
230 3. **Replace the snkrx-template effect system** (its `edition.lua` + dither stack)
231    with this one — the original end goal. Now that the toolkit is generalized,
232    this is "drop `ricochet/` into a real game and call `effect_*`."
233 4. **Flow-field shape rotation** (the Orblike/Invoker "wall icon" effect): a
234    per-cell rotation angle from a field, vs today's single global ROTATION. The
235    hook is the rotation math at the top of `shape_mask` in the shader.
236 5. **Engine: extend the font atlas past ASCII** so the CJK-capable body font
237    (Ark) actually renders Japanese/Chinese/Korean. Affects every Anchor 2 project.
238 
239 ## The rough (480×270) low-res build
240 
241 Forked by `ROUGH = true` at the top of `main.lua` → **`main_rough.lua`**, a
242 self-contained entry (`require('anchor')({width=480, height=270, scale=4,
243 filter='rough'})` + its own fonts / icons / screens; the smooth dev-tools build
244 is skipped). Built in "Visual Experiments 4" as the bench for everything that
245 does NOT translate unchanged from 1920 → 480: **fonts, icons, the UI chrome**.
246 No effect pipeline yet (flat draws) — porting the patterns/shapes is Roadmap #1.
247

I'll update the roadmap: mark the composite-screens item done, record this session + the ergonomics pass, and re-list what genuinely remains.

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Fixing one dangling "Roadmap #1" reference in the rough-build section (the roadmap renumbered):

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Docs are synced now — the roadmap reflects this session and the genuinely-remaining items.

Honest answer: no, nothing required. The arc you set out is complete:

All seven sheet-02/03/05 sections built in both skins (the component catalog).
The UI API generalized and made ergonomic — uniform table returns, contract helpers, layout helpers, id guards — verified working with no visual regressions.
Docs (CLAUDE.md) brought current: API/return contract, per-frame contract, and the roadmap.

Optional leftovers (all flagged in the roadmap, none blocking):

swatch_row (the one unported sheet widget) + the smooth stepper using -/+ glyphs instead of Tabler icons.
A DATA/MISC catalog screen for the 5 widgets that exist in both skins but aren't shown anywhere (list_row, sparkline, keyhint, bare bar, divider).
The broader, separate efforts: dropping ricochet/ into a real game to replace snkrx-template's effect system, flow-field per-cell rotation, and the engine CJK atlas.

Two housekeeping notes: I haven't committed anything — that's your call (the project's git is yours to manage; only the site auto-pushes). And whenever you're ready to close out, there's the /end-session flow to log it.

So: stop here cleanly, pick up an optional leftover, or commit/close out — your call.

Last session, at the end of it I think, I asked the previous instance to generalize things like the SNKRX template, it said it would do it, but I see the folder and it's still mostly files alongside main.lua instead of inside the ricochet/ folder. I'd like something that a new instance can copy and then it just edits main.lua and its own files it creates at that level, while either using or referencing the files inside the ricochet/ folder. If you read the last session log you'll see that the previous instance had a plan for this, but I think maybe the session ended before it. Either way, I'd like something like that now as the final task.

This is a good final task — making the package genuinely fork-ready like snkrx-template. The user references a plan from last session that didn't get executed. Let me find it in the VE-4 log, then look at the current root layout to see exactly what needs moving.

Bash (cd "E:/a327ex/ricochet-template"
echo "=== current root files (what a fork sees)...)

=== current root files (what a fork sees) ===
anchor.exe
components.lua
editor.lua
effect.lua
lab.lua
main.lua
main_rough.lua
palette.lua
rectcut.lua
rough_ui.lua
run.bat
showcase.lua
ui.lua
ui_controls.lua
ui_state.lua
--- dirs ---
anchor/
assets/
ricochet/
tools/

=== which root .lua files does ricochet/ require? (the 'shared' ones) ===
ricochet/init.lua:23:require('effect')          -- four-axis effect system  (root; shared, agnostic)
ricochet/init.lua:24:require('palette')         -- palette tokens           (root)
ricochet/init.lua:25:require('ui_state')        -- hot/active/focus interaction substrate (root)
ricochet/init.lua:26:require('rectcut')         -- rectcut layout primitive (root)

=== which root files do the FROZEN labs require? ===
lab.lua:34:if ROUGH then return require('main_rough') end
... [14 more lines]

Now let me find the previous instance's plan in the VE-4 log:

Bash (cd "E:/a327ex/a327ex-site/logs"
echo "=== search VE-4 log for the move-into-rico...)

=== search VE-4 log for the move-into-ricochet / self-contained plan ===
39:- Created `ricochet/` (loaded by `require('ricochet')` → `ricochet/init.lua` + `ricochet_setup{mode}` doing palette_init → effect_setup → theme_set, and creating global `ui_layer`). Reuses root `effect.lua`/`palette.lua`/`ui_state.lua`/`rectcut.lua` (so the frozen labs keep working untouched) + its own `theme.lua` + `ui.lua` + the two skins.
79:20      and how. Include this whenever the feature is not self-contained.
367:a327ex-site\logs\visual-experiments-1.md:1280:I picked it because it's the only font Ricochet ships in its `assets/`, so copying it kept the template self-contained. But per Ricochet's design.md § Typography, the *intended* HUD font is actually a "neutral sans / mono-like" (Inter / IBM Plex Sans / IBM Plex Mono / Work Sans) — LanaPixel is a pixel-art body font, which doesn't really fit the "engineering datasheet" voice the design doc is going for.
701:E:/a327ex/Anchor2/app-archive/assets/LanaPixel.ttf
702:E:/a327ex/Anchor2/app-archive/assets/RobotoMono-Regular.ttf
1011:departure.zip:     Zip archive data, made by v2.0, extract using at least v2.0, last modified, last modified Sun, Jan 01 1980 00:00:00, uncompressed size 84480, method=deflate
1012:pixelop.zip:       Zip archive data, made by v3.0 UNIX, extract using at least v2.0, last modified, last modified Sun, Oct 04 2018 12:15:00, uncompressed size 7169, method=deflate
1013:ark12.zip:         Zip archive data, at least v2.0 to extract, compression method=store
1014:fusion12.zip:      Zip archive data, at least v2.0 to extract, compression method=store
1049:tar didn't extract these. Let me relocate the archives to a Windows-visible path and use PowerShell's Expand-Archive.
1227:All fonts are in place. Let me clean up the temp archives and pull the relevant `pixel` icon names so I can fetch a good game subset.
1373:My recommendation: **treat CJK-capability as the selection criterion now and defer the engine work.** Extending the atlas is a self-contained engine change that shouldn't block the low-res visual comparison, and it touches the shared `Anchor2` engine (affects every project). I downloaded only the `-latin` subsets since ASCII renders identically — the full CJK builds are one re-fetch away (URLs documented) once the engine supports them. But if you'd rather I tackle the engine extension as part of this arc, say so and I'll scope it separately.
1636:All engine details check out (`texture_load` is GL_NEAREST → crisp icons; entry is `main.lua`). I have what I need. Building now — a `ROUGH` flag in `main.lua` that branches to a self-contained `main_rough.lua` at 480×270.
1647:Now the self-contained low-res comparison build:
1719:**Low-res build:** `main.lua` now has a `ROUGH = true` flag at the top that forks to a new self-contained **`main_rough.lua`** — 480×270, scale 4, `rough` (nearest) filter → a 1920×1080 window of pure pixel-art. The hi-res dev tools are untouched; flip `ROUGH = false` to get them back.
3008:20    and how. Include this whenever the feature is not self-contained.
3027:- A self-contained toolkit in a subdir (`snkrx/`), loaded by a single `require('snkrx')` → `snkrx/init.lua` (the aggregator that requires every file + does cross-cutting setup).
3098:- **`ricochet/` package** reuses the already-agnostic root files rather than moving them (so the frozen labs' `require('effect')`/`require('palette')`/etc. keep working untouched): `ricochet/init.lua` (aggregator) requires the root `effect.lua`/`palette.lua`/`ui_state.lua`/`rectcut.lua` **plus** the new `ricochet/theme.lua` + `ricochet/primitives.lua` + `ricochet/widgets.lua` (the opts-table, profile-driven UI). `require('ricochet')` gives a new game everything.
3340:Let me syntax-check the whole new package + the new main.lua + the frozen lab.
3354:All compile. Before handing off, let me verify the package require convention actually resolves in this engine (does `require('ricochet')` → `ricochet/init.lua` and `require('ricochet.theme')` → `ricochet/theme.lua`?) by checking how snkrx's aggregator does its sub-requires.
3430:- `ricochet/init.lua` — aggregator: pulls the root agnostic core (effect/palette/ui_state/rectcut, so the frozen labs keep working) + the theme + UI, creates `ui_layer`, and exposes `ricochet_setup{ mode }` (palette + shader + theme in one call).
3713:2. **Docs** — rewrite the template `CLAUDE.md` around the package: the `require('ricochet')` contract, the two-skin model, `ricochet_setup`/`ricochet_theme_set`, the widget API, and the file map (the frozen labs, the new package, the trimmed assets, the folder-agnostic `run.bat`).
4170:- Frozen labs (`lab.lua` + `main_rough.lua`), folder-agnostic `run.bat`, trimmed assets (~19 MB lighter), the minimal `main.lua` reference.

The VE-4 plan deliberately kept the core files at root (so the frozen labs' require('effect') etc. wouldn't break) — that's exactly the half-measure you're seeing. You want to go further: a clean fork root. Let me check the lab files' require graph so I can brief an accurate move.

Bash (cd "E:/a327ex/ricochet-template"
echo "=== requires inside the v1 frozen-lab fil...)

=== requires inside the v1 frozen-lab files ===
--- ui.lua ---
(no requires — uses globals)
--- ui_controls.lua ---
(no requires — uses globals)
--- showcase.lua ---
(no requires — uses globals)
--- editor.lua ---
(no requires — uses globals)
--- rough_ui.lua ---
(no requires — uses globals)

=== does anything require 'components' / 'lab' / 'main_rough'? ===
./lab.lua:34:if ROUGH then return require('main_rough') end
./main.lua:32:if LAB then return require('lab') end
./main.lua:33:if COMPONENTS then return require('components') end

=== shader asset path references (stay at root assets/) ===
ricochet/init.lua:38:--   opts.shader  = path                 (default 'assets/draw_shader.frag')
ricochet/init.lua:42:  effect_setup({ draw_shader = opts.shader or 'assets/draw_shader.frag' })

The v1 lab files have no internal requires (pure globals) — so only their two entry points (lab.lua, main_rough.lua) + ricochet/init.lua + main.lua need require-path edits. Let me confirm the 4 core files have no internal requires, and read lab.lua:

Bash (cd "E:/a327ex/ricochet-template"
echo "=== requires inside the 4 core files (eff...)

=== requires inside the 4 core files (effect/palette/ui_state/rectcut) ===
--- effect.lua ---
(no requires — leaf module, moves cleanly)
--- palette.lua ---
(no requires — leaf module, moves cleanly)
--- ui_state.lua ---
(no requires — leaf module, moves cleanly)
--- rectcut.lua ---
(no requires — leaf module, moves cleanly)

=== is ricochet-template a git repo? ===
no .git

Everything checks out for a clean move: the 4 core modules are requireless leaves, the 5 v1 widget files use only globals, so only 4 entry files need require-path edits. Not a git repo, so plain mv. Here's the brief.

Design Brief — fork-ready package (snkrx-parity)

Target root (what a fork sees)

ricochet-template/
├── main.lua            # the fork's entry — edit this
├── components.lua      # the component catalog (living, package-based usage reference)
├── ricochet/           # THE PACKAGE — self-contained, require('ricochet')
│   ├── init.lua  effect.lua  palette.lua  ui_state.lua  rectcut.lua   ← 4 moved in
│   ├── theme.lua  ui.lua  skin_smooth.lua  skin_rough.lua
├── lab/                # FROZEN v1 dev galleries (reference only; a fork ignores it)
│   ├── lab.lua  main_rough.lua  ui.lua  ui_controls.lua  showcase.lua  editor.lua  rough_ui.lua
├── assets/  anchor/  anchor.exe  tools/  run.bat  .claude/

Moves

4 core leaf modules effect/palette/ui_state/rectcut → ricochet/ (no content edits — they have no internal requires).
7 v1 frozen files → lab/ (kept runnable as historical reference).
main.lua + components.lua stay at root — the two current, package-based files a fork reads/edits.

Require-path edits (the only content changes, 4 files)

ricochet/init.lua: require('effect'|'palette'|'ui_state'|'rectcut') → require('ricochet.<x>')
main.lua: require('lab') → require('lab.lab')
lab/lab.lua: core → ricochet.<x>; ui/ui_controls/showcase/editor → lab.<x>; main_rough → lab.main_rough
lab/main_rough.lua: core → ricochet.<x>; rough_ui → lab.rough_ui

Why it's safe

The moved files register the same globals regardless of location; only the require paths change. The labs never load require('ricochet') (they pull the moved core directly via ricochet.effect etc.) and never coexist with the package in one process, so no global clashes. Dotted requires (ricochet.x / lab.x) resolve to subdir/file.lua (verified in VE-4). I'll syntax-check all touched files; the catalog + main.lua are the live test.

Docs

Update CLAUDE.md file map + drop the now-obsolete "root shared files / so the frozen labs keep working untouched" language — the package is self-contained; labs live in lab/.

One genuine call before I move files:

AskUserQuestion

Your questions have been answered: "What should happen to the 7 frozen v1 lab files (lab/main_rough/ui/ui_controls/showcase/editor/rough_ui)?"="Move to lab/, keep runnable". You can now continue with these answers in mind.

Executing the move. Creating lab/ and relocating files:

Bash (cd "E:/a327ex/ricochet-template"
mkdir -p lab

`4 core leaf modules -> ricochet/...)`

=== new root (.lua files) ===
anchor/
assets/
components.lua
lab/
main.lua
ricochet/
tools/
=== ricochet/ ===
effect.lua
init.lua
palette.lua
rectcut.lua
skin_rough.lua
skin_smooth.lua
theme.lua
ui.lua
ui_state.lua
=== lab/ ===
editor.lua
lab.lua
main_rough.lua
rough_ui.lua
showcase.lua
ui.lua
ui_controls.lua

All moved. Now the require-path edits. First ricochet/init.lua:

Edit (E:/a327ex/ricochet-template/ricochet/init.lua)

The file E:/a327ex/ricochet-template/ricochet/init.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Updating init.lua's docblock (the "kept at root" language is now obsolete):

Edit (E:/a327ex/ricochet-template/ricochet/init.lua)

The file E:/a327ex/ricochet-template/ricochet/init.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now main.lua — the LAB flag:

Edit (E:/a327ex/ricochet-template/main.lua)

The file E:/a327ex/ricochet-template/main.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Now the lab entry points. Reading their require blocks:

Read (E:/a327ex/ricochet-template/lab/lab.lua)

30   -- (these dev tools) or rough/low-res (the SNKRX-style render target) — never
31  -- both, so this is a hard fork, not a per-screen toggle. Flip to false to
32  -- return to the gallery / editor / showcase dev tools.
33  local ROUGH = true
34  if ROUGH then return require('main_rough') end
35  
36  require('anchor')({
37    width            = 1920,
38    height           = 1080,
39    title            = "ricochet-template",
40    scale            = 1,
41    filter           = "smooth",
42    render_uncapped  = true,
43    display          = 0,
44  })
45  
46  require('palette')
47  require('effect')
48  require('rectcut')
49  require('ui_state')
50  require('ui')
51  require('ui_controls')
52  require('showcase')
53  require('editor')
54  
55  -- -----------------------------------------------------------------------------

Edit (E:/a327ex/ricochet-template/lab/lab.lua)

The file E:/a327ex/ricochet-template/lab/lab.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Edit (E:/a327ex/ricochet-template/lab/lab.lua)

The file E:/a327ex/ricochet-template/lab/lab.lua has been updated successfully. (file state is current in your context — no need to Read it back)

Read (E:/a327ex/ricochet-template/lab/main_rough.lua)

40   
41  require('palette')
42  require('effect')
43  require('ui_state')
44  require('rough_ui')
45  palette_init('dark')

Edit (E:/a327ex/ricochet-template/lab/main_rough.lua)

The file E:/a327ex/ricochet-template/lab/main_rough.lua has been updated successfully. (file state is current in your context — no need to Read it back)

All require paths updated. Syntax-checking the moved + edited files:

Bash (cd "E:/a327ex/ricochet-template"
LUA="E:/a327ex/Anchor/reference/love-compare/to...)

OK  main.lua
OK  components.lua
OK  ricochet/init.lua
OK  ricochet/effect.lua
OK  ricochet/palette.lua
OK  ricochet/ui_state.lua
OK  ricochet/rectcut.lua
OK  ricochet/theme.lua
OK  ricochet/ui.lua
OK  ricochet/skin_smooth.lua
OK  ricochet/skin_rough.lua
OK  lab/lab.lua
OK  lab/main_rough.lua
OK  lab/ui.lua
OK  lab/ui_controls.lua
OK  lab/showcase.lua
OK  lab/editor.lua
OK  lab/rough_ui.lua

All parse, and the target files exist for each dotted require. Let me sweep for any stale bare requires I might have missed (these would resolve to now-missing root files at runtime):

Bash (cd "E:/a327ex/ricochet-template"
echo "=== any remaining BARE requires of moved ...)

=== any remaining BARE requires of moved modules (should be NONE) ===
--- end (empty above = clean) ---

=== confirm every dotted require resolves to a real file ===
ok   ricochet -> ricochet/init.lua
ok   ricochet.effect -> ricochet/effect.lua
ok   ricochet.palette -> ricochet/palette.lua
ok   ricochet.ui_state -> ricochet/ui_state.lua
ok   ricochet.rectcut -> ricochet/rectcut.lua
ok   ricochet.theme -> ricochet/theme.lua
ok   ricochet.ui -> ricochet/ui.lua
ok   ricochet.skin_smooth -> ricochet/skin_smooth.lua
ok   ricochet.skin_rough -> ricochet/skin_rough.lua
ok   lab.lab -> lab/lab.lua
ok   lab.main_rough -> lab/main_rough.lua
ok   lab.ui -> lab/ui.lua
ok   lab.ui_controls -> lab/ui_controls.lua
ok   lab.showcase -> lab/showcase.lua
ok   lab.editor -> lab/editor.lua
ok   lab.rough_ui -> lab/rough_ui.lua
ok   components -> components.lua

No stale requires; every module resolves. The restructure is mechanically complete. Now the docs — let me locate the CLAUDE.md sections that describe the old root layout:

Bash (cd "E:/a327ex/ricochet-template"
grep -nE "Files at the root|Reuses the|kept at ...)

73:### Files at the root
78:- **`lab.lua`** + **`main_rough.lua`** — the **frozen v1 dev galleries**, kept as
81:  gallery/editor/showcase (with its own `ROUGH` flag forking to `main_rough.lua`,
83:- **`ricochet/`** — the generalized toolkit (`require('ricochet')`). Reuses the
93:  low-res widgets, used ONLY by `main_rough.lua`. Frozen.
245:Forked by `ROUGH = true` at the top of `main.lua` → **`main_rough.lua`**, a
888:## File map
892:├── main.lua                    # CLEAN reference a forked game edits (MODE flag,
893:│                               #   boot, one effect + one panel; LAB/COMPONENTS flags)
894:├── components.lua              # COMPONENT CATALOG on the new toolkit (own MODE flag);
895:│                               #   one screen per sheet-02 section. COMPONENTS=true runs it.
896:├── lab.lua                     # FROZEN smooth dev galleries (was main.lua; its own
897:│                               #   ROUGH flag forks to main_rough.lua). Uses v1 ui.lua.
898:├── main_rough.lua              # FROZEN rough lab: 480×270 font/icon/UI bench (v1 rough_ui)
899:├── ricochet/                   # THE PACKAGE — require('ricochet')
900:│   ├── init.lua                #   aggregator + ricochet_setup{mode}; creates ui_layer
901:│   ├── theme.lua               #   2 resolution profiles (fonts/metrics/icons) + use_skin
902:│   ├── ui.lua                  #   shared core (ric.*) + ricochet_use_skin binder
903:│   ├── skin_smooth.lua         #   SMOOTH widget skin (matches showcase.lua + reference)
904:│   └── skin_rough.lua          #   ROUGH widget skin (matches rough_ui.lua)
905:├── effect.lua                  # 4-axis spec API + effect_rectangle/circle/image (SHARED)
906:├── palette.lua                 # 2 palettes × 13 tokens; palette_init (SHARED)
907:├── ui_state.lua                # frame-local hot/active/focus + ui_claim_hot (SHARED)
908:├── rectcut.lua                 # RectCut layout primitive (SHARED)
909:├── ui.lua                      # v1 smooth widgets — lab.lua only (FROZEN)
910:├── ui_controls.lua             # v1 gallery/editor control blocks — lab.lua only (FROZEN)
911:├── showcase.lua                # v1 flat Tabler UI-kit screen — lab.lua only (FROZEN)
912:├── editor.lua                  # v1 effect editor screen — lab.lua only (FROZEN)
913:├── rough_ui.lua                # v1 low-res widgets (ru_*) — main_rough.lua only (FROZEN)
914:├── anchor/                     # Anchor 2 framework
... [13 more lines]

Let me read and update the "Files at the root" section (73–95):

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

71   differ. See **"The ricochet/ package"** below.
72  
73  ### Files at the root
74  
75  - **`main.lua`** — the clean reference a forked game edits: MODE flag, boot,
76    layers, one full-screen effect + one example panel, the per-frame UI contract.
77    Minimal on purpose. `LAB = true` runs the frozen galleries instead.
78  - **`lab.lua`** + **`main_rough.lua`** — the **frozen v1 dev galleries**, kept as
79    usage/reference. ⚠️ They use the ORIGINAL `ui.lua` / `rough_ui.lua`, NOT the new
80    package — do not refactor them onto it. `lab.lua` = the smooth
81    gallery/editor/showcase (with its own `ROUGH` flag forking to `main_rough.lua`,
82    the low-res font/icon/UI bench). They're the historical exploration.
83  - **`ricochet/`** — the generalized toolkit (`require('ricochet')`). Reuses the
84    root `effect.lua` / `palette.lua` / `ui_state.lua` / `rectcut.lua` (so the
85    frozen labs keep working) + its own `theme.lua` + `ui.lua` + the two skins.
86  - **`effect.lua`** — the four-axis effect API (registries, `effect_set`,
87    `effect_rectangle/circle/image`, cycles). Unchanged; shared by package + labs.
88  - **`palette.lua`** — 2 palettes × 13 tokens; `palette_init('dark'|'light')`.
89  - **`ui_state.lua`** — frame-local hot/active/focus + `ui_claim_hot` (shared
90    interaction substrate). **`rectcut.lua`** — RectCut layout primitive.
91  - **`ui.lua` / `ui_controls.lua` / `showcase.lua` / `editor.lua`** — v1 smooth
92    dev-tool UI + screens, used ONLY by `lab.lua`. Frozen. **`rough_ui.lua`** — v1
93    low-res widgets, used ONLY by `main_rough.lua`. Frozen.
94  - **`assets/draw_shader.frag`** — the unified shader (replaces the engine default).
95    **`assets/fonts/`** — pixel fonts. **`assets/icons/tabler|pixel|pixelarticons/`**
96    — Tabler (smooth), HackerNoon pixel (rough pick), Pixelarticons (rough compare).
97    **`assets/images/`** — editor/IMAGE test photos (downscaled to ~640px).
98  - **`tools/`** — Iconify→PNG fetchers + pack-compare scripts (node, by hand).
99  - **`anchor/` + `anchor.exe`** — Anchor 2 framework + patched engine binary.
100 - **`run.bat`** — folder-agnostic launcher: resolves its own folder name, so a

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Now the rough-build section reference (line ~245):

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

241  4. **Engine: extend the font atlas past ASCII** so the CJK-capable body font
242    (Ark) actually renders Japanese/Chinese/Korean. Affects every Anchor 2 project.
243 
244 ## The rough (480×270) low-res build
245 
246 Forked by `ROUGH = true` at the top of `main.lua` → **`main_rough.lua`**, a
247 self-contained entry (`require('anchor')({width=480, height=270, scale=4,
248 filter='rough'})` + its own fonts / icons / screens; the smooth dev-tools build

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Now the file-map tree. Reading it fully:

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

886  
887 ---
888 
889 ## File map
890 
891 ```
892 ricochet-template/
893 ├── main.lua                    # CLEAN reference a forked game edits (MODE flag,
894 │                               #   boot, one effect + one panel; LAB/COMPONENTS flags)
895 ├── components.lua              # COMPONENT CATALOG on the new toolkit (own MODE flag);
896 │                               #   one screen per sheet-02 section. COMPONENTS=true runs it.
897 ├── lab.lua                     # FROZEN smooth dev galleries (was main.lua; its own
898 │                               #   ROUGH flag forks to main_rough.lua). Uses v1 ui.lua.
899 ├── main_rough.lua              # FROZEN rough lab: 480×270 font/icon/UI bench (v1 rough_ui)
900 ├── ricochet/                   # THE PACKAGE — require('ricochet')
901 │   ├── init.lua                #   aggregator + ricochet_setup{mode}; creates ui_layer
902 │   ├── theme.lua               #   2 resolution profiles (fonts/metrics/icons) + use_skin
903 │   ├── ui.lua                  #   shared core (ric.*) + ricochet_use_skin binder
904 │   ├── skin_smooth.lua         #   SMOOTH widget skin (matches showcase.lua + reference)
905 │   └── skin_rough.lua          #   ROUGH widget skin (matches rough_ui.lua)
906 ├── effect.lua                  # 4-axis spec API + effect_rectangle/circle/image (SHARED)
907 ├── palette.lua                 # 2 palettes × 13 tokens; palette_init (SHARED)
908 ├── ui_state.lua                # frame-local hot/active/focus + ui_claim_hot (SHARED)
909 ├── rectcut.lua                 # RectCut layout primitive (SHARED)
910 ├── ui.lua                      # v1 smooth widgets — lab.lua only (FROZEN)
911 ├── ui_controls.lua             # v1 gallery/editor control blocks — lab.lua only (FROZEN)
912 ├── showcase.lua                # v1 flat Tabler UI-kit screen — lab.lua only (FROZEN)
913 ├── editor.lua                  # v1 effect editor screen — lab.lua only (FROZEN)
914 ├── rough_ui.lua                # v1 low-res widgets (ru_*) — main_rough.lua only (FROZEN)
915 ├── anchor/                     # Anchor 2 framework
... [16 more lines]

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Let me sweep CLAUDE.md for any remaining stale references to the old root layout:

Bash (cd "E:/a327ex/ricochet-template"
grep -nE "kept at root|shared by package|at the...)

79:- **`main.lua`** (root) — the clean reference a forked game edits: MODE flag, boot,
82:- **`components.lua`** (root) — the component catalog, the living **package-based**
--- (empty = clean) ---

Done. The template is now genuinely fork-ready, snkrx-parity. All 18 files parse, no stale requires, every dotted require resolves to a real file.

New layout

ricochet-template/
├── main.lua          ← the fork's entry (edit this)
├── components.lua    ← living package-based usage reference
├── ricochet/         ← THE PACKAGE, self-contained (require('ricochet'))
│     init · effect · palette · ui_state · rectcut · theme · ui · skin_smooth · skin_rough
├── lab/              ← frozen v1 dev galleries (reference; a fork ignores it)
│     lab · main_rough · ui · ui_controls · showcase · editor · rough_ui
└── assets/  anchor/  anchor.exe  tools/  run.bat  .claude/

A fork now = copy the folder, edit main.lua (+ your own files at root), require('ricochet'). Everything the package needs is inside ricochet/; nothing reusable sits loose at root anymore.

What moved + why it's safe

4 core leaf modules (effect/palette/ui_state/rectcut) → ricochet/. They have no internal requires and define globals, so only the require paths changed (in ricochet/init.lua).
7 v1 frozen files → lab/, kept runnable — their entry points (lab/lab.lua, lab/main_rough.lua) now pull the moved core via ricochet.* and their own widgets via lab.*. The 5 widget files needed no edits (pure globals).
main.lua require('lab') → require('lab.lab'). Docs (CLAUDE.md): Layout section, rough-build ref, and file-map tree all updated; the obsolete "shared at root so the labs keep working" language is gone.

Test (3 entry paths — the require graph changed, so check each)

In main.lua:

COMPONENTS = true → runs components.lua → require('ricochet') (the key test that the moved core resolves). Cycle the screens.
COMPONENTS = false, LAB = false → the main.lua reference scene (EFFECT panel).
LAB = true → lab/lab.lua (flip its ROUGH flag to test both the smooth gallery and lab/main_rough.lua).

If any path errors, it'll be a require-resolution issue I can pinpoint immediately — but the dotted-require convention is the same one ricochet.theme already used, and all targets exist.

That closes out the generalization the previous session set up but didn't finish — the package is now the clean, copyable thing you described.

OK, update documentation, including instructions for a new instance on how to copy and use the template, then create a GitHub repo for this and end the session, Visual Experiments 5.

On it — three things: docs (README + a fork guide in CLAUDE.md), the GitHub repo, then end the session as Visual Experiments 5. Let me first check tooling + repo size before committing anything.

Bash (cd "E:/a327ex/ricochet-template"
echo "=== gh auth ===" && gh auth status 2>&1 |...)

=== gh auth ===
github.com
  ✓ Logged in to github.com account a327ex (keyring)
  - Active account: true
  - Git operations protocol: ssh
  - Token: gho_************************************
=== git identity ===
a327ex
a327ex@gmail.com
=== does repo already exist? ===
GraphQL: Could not resolve to a Repository with the name 'a327ex/ricochet-template'. (repository)
=== sizes (what would be committed) ===
13M .
node_modules:
4.4M    tools/node_modules
anchor.exe:
4.0M
assets:
3.5M    assets
=== existing .gitignore? ===
(none)

gh is authed as a327ex (ssh), repo doesn't exist, ~8.6M after ignoring node_modules. Let me write the README (the main "how to copy and use" deliverable):

Write (E:/a327ex/ricochet-template/README.md)

File created successfully at: E:/a327ex/ricochet-template/README.md (file state is current in your context — no need to Read it back)

Now a pointer at the top of CLAUDE.md so a new instance starts in the right place. Reading the intro:

Read (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

42   If unsure, treat as non-trivial and write a brief.
43  
44  ---
45  
46  ## What this is
47  
48  A starter Anchor 2 project that ships **Ricochet's visual identity** plus
49  a clean four-axis effect system (pattern × color × dither × shape). Fork the
50  folder, drop your game code into `main.lua`, prototype. The template
51  itself ships no gameplay — that's the forking dev's job.
52  
53  The full visual identity (palette philosophy, dotted motif, typography,
54  shape language, motion principles) lives in `Ricochet/design.md`. This
55  template implements the palette + the effect pipeline only; everything
56  else in design.md is guidance for how a forked project should look.
57

Edit (E:/a327ex/ricochet-template/.claude/CLAUDE.md)

The file E:/a327ex/ricochet-template/.claude/CLAUDE.md has been updated successfully. (file state is current in your context — no need to Read it back)

Docs done. Now the GitHub repo. Creating .gitignore (ignore the regenerable node_modules):

Write (E:/a327ex/ricochet-template/.gitignore)

File created successfully at: E:/a327ex/ricochet-template/.gitignore (file state is current in your context — no need to Read it back)

Bash (cd "E:/a327ex/ricochet-template"
git init -b main >/dev/null 2>&1 || { git init ...)

warning: in the working copy of '.claude/CLAUDE.md', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of '.gitignore', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'README.md', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/animation.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/camera.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/class.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/collider.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/color.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/font.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/image.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/init.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/input.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/memory.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/object.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/physics.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/shake.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/spring.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/spritesheet.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'anchor/timer.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'assets/draw_shader.frag', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'assets/images/CREDITS.txt', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'components.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/editor.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/lab.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/main_rough.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/rough_ui.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/showcase.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/ui.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'lab/ui_controls.lua', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'main.lua', LF will be replaced by CRLF the next time Git touches it
... [34 more lines]

node_modules excluded, 226 files staged (CRLF warnings are harmless). Committing, then creating + pushing the repo:

Bash (cd "E:/a327ex/ricochet-template"
git commit -q -m "Initial commit: ricochet-temp...)

=== commit done ===
8963bf0 Initial commit: ricochet-template (Anchor 2 Ricochet starter)
=== creating + pushing repo ===
https://github.com/a327ex/ricochet-template
branch 'main' set up to track 'origin/main'.
To github.com:a327ex/ricochet-template.git
 * [new branch]      HEAD -> main

Repo is live: https://github.com/a327ex/ricochet-template (public, main pushed). Docs done (README + CLAUDE.md fork guide). Now ending the session as Visual Experiments 5:

Skill

Launching skill: end-session

Base directory for this skill: E:\a327ex.claude\skills\end-session

End Session Workflow

This skill is invoked from the same conversation where the work was done. You already have the full session context in memory — you do NOT need to read the transcript.

Step 1: Get Session Info

Ask the user for the session title (max 30 characters). Examples: "Anchor Phase 10 Part 5", "Physics Arena Setup", "Timer System Fix", "Thalien Lune Design".

Determine the project yourself from your session context — you know which repo(s) were worked on, which files were created/modified, and where they live. No need to ask. See Step 5 for the list of known project roots; if the session touched something outside the list, infer the root from the paths you actually edited.

Step 2: Write Summary

Write the summary from your conversation memory. You have the full session context — no need to read any files.

The summary should be thorough and detailed. Each major topic deserves its own section with multiple specific bullet points. Don't compress — expand.

Purpose: These summaries serve as searchable records. Future Claude instances will grep through past logs to find how specific topics were handled. The more detail you include, the more useful the summary becomes for finding relevant context later.

Format (this is just an example structure — adapt sections to match what actually happened):
# [Title]

## Summary

[1-2 sentence overview of the session's main focus]

**[Topic 1 - e.g., "Spring Module Implementation"]:**
- First specific detail about what was done
- Second detail - include file names, function names
- User correction or feedback (quote if notable)
- Technical decisions and why

**[Topic 2 - e.g., "Camera Research"]:**
- What was researched
- Key findings
- How it influenced implementation

**[Topic 3 - e.g., "Errors and Fixes"]:**
- Specific error message encountered
- Root cause identified
- How it was fixed

[Continue for each major topic...]

---

[Rest of transcript follows]
Rules: - Be thorough — If in doubt, include more detail, not less. Each topic should be as detailed as possible while still being a summary. - Think searchability — Future instances will search these logs. Include keywords, function names, error messages that someone might grep for. - One section per major topic — Don't combine unrelated work into one section - Chronological order — Sections should match conversation flow - Specific details — Error messages, file names, function names, parameter values - Include user quotes — When user gave notable feedback, quote it (e.g., "k/d variables are not intuitive at all") - Weight planning equally — Research, proposals, alternatives considered, user feedback on approach are as important as implementation - Weight problems solved — Errors, root causes, fixes, user corrections all matter - Technical specifics — Include formulas, API signatures, parameter changes when relevant

Step 3: Proceed Without Approval

Do NOT show the summary to the user for approval. Write it directly. The user can review the committed log after the fact and request a follow-up edit if anything is off.

Step 4: Convert Transcript and Write the Log File
# Find recent sessions (Claude + Cursor + Codex). Same script lives in Anchor2:
python E:/a327ex/Anchor2/scripts/find-recent-session.py --limit 5
# or: python E:/a327ex/Anchor/scripts/find-recent-session.py --limit 5
The script shows sessions sorted by when they ended. The first result is the current conversation (since end-session was invoked here). Use it.

Use a lowercase hyphenated slug derived from the title (e.g., "anchor-primitives-hitstop-animation").

Get the end timestamp for the Date frontmatter — this is the wall-clock time when end-session was invoked, NOT the time the JSONL started. Sessions often span multiple days, and the log should be filed under the day the work was wrapped up:
date "+%Y-%m-%d %H:%M:%S"
Use this output verbatim. Do not substitute the JSONL start timestamp; the log appears in the sidebar sorted by Date, and a multi-day session with a Date pinned to day 1 will sort below sessions that ended later but started later, hiding the most recent work.

Convert the transcript to markdown:
python E:/a327ex/Anchor2/scripts/jsonl-to-markdown.py [SESSION_PATH] /tmp/session-log.md
# or: python E:/a327ex/Anchor/scripts/jsonl-to-markdown.py ...
The same script auto-detects Claude Code JSONL vs Cursor/Composer agent JSONL (~/.cursor/projects/.../agent-transcripts/...) vs Codex rollouts (~/.codex/sessions/...). For Composer sessions, use find-recent-session.py (it merges all sources) and pick the [cursor] line for the current chat.

Replace the default header (# Session YYYY-MM-DD...) at the top of /tmp/session-log.md with the approved title and summary, AND prepend frontmatter. The final file shape:
Title: [Title]
Date: YYYY-MM-DD HH:MM:SS

# [Title]

## Summary

[approved summary text from step 2]

---

[transcript content from jsonl-to-markdown script]
Frontmatter is non-negotiable. Every log file MUST start with Title: and Date: lines. Without them, the site's sidebar shows the slug as the title and 0 (epoch) as the sort date. The backfill script in a327ex-site/deploy/backfill_metadata.py is a safety net, not a substitute — write it correctly the first time.

Then copy the final file to the log destination:
cp /tmp/session-log.md E:/a327ex/a327ex-site/logs/[slug].md
Step 4.5: Decrement the lock (if active)

Read E:/a327ex/a327ex-site/.lock.json if it exists. If it contains {"remaining": N} with N > 0:

Decrement N by 1

Write {"remaining": N-1} back to the file

If N becomes 0, the lock is cleared. You may leave the file at {"remaining": 0} or delete it; both work.

The lock file lives in the a327ex-site repo, so the change is staged automatically by git add -A in Step 6.

If no lock file exists or remaining is already 0, do nothing. (See the /lock skill for the lock's full design.)

Step 5: Commit Project Repo

Identify the project repo(s) worked on this session from your own context — you already know which repos were touched and which files changed. For the common projects:

Project Root Stage command

Anchor E:/a327ex/Anchor git add docs/ framework/ engine/ scripts/ reference/

Anchor2 E:/a327ex/Anchor2 git add framework/ engine/ arena/ reference/ scripts/ docs/ .claude/

emoji-ball-battles E:/a327ex/emoji-ball-battles git add -A

invoker E:/a327ex/Invoker git add -A

thalien-lune E:/a327ex/thalien-lune git add -A

a327ex-site E:/a327ex/a327ex-site git add -A (this IS one of the web repos — the log file added in Step 4 is staged here automatically)

For a project not listed, infer the root from the files you actually created or modified this session and stage those. If multiple candidate roots look valid, ask the user which files to stage.

cd into the project root, stage, run git status to verify before committing.

IMPORTANT — FULL SUMMARY IN COMMIT: The commit message MUST include the FULL summary from the log file. Read the summary back from the log file to ensure nothing is missing.

IMPORTANT — COMMIT METHOD: The summary contains backticks, special characters, and markdown that WILL break heredocs and git commit -m. ALWAYS use the file-based method below. NEVER try a heredoc first — it will fail and produce a malformed commit that needs amending.
# Skip until we hit the line "## Summary", then take everything after the next
# blank line until the --- separator that precedes the transcript.
awk '/^## Summary$/{found=1; next} found && NR>1 && /^---$/{exit} found' \
    E:/a327ex/a327ex-site/logs/[slug].md > /tmp/commit_msg.txt

# Prepend the title (plain text, no #) and append attribution
sed -i "1i [Title]\n" /tmp/commit_msg.txt
printf "\nGenerated with [Claude Code](https://claude.com/claude-code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>\n" >> /tmp/commit_msg.txt

git commit -F /tmp/commit_msg.txt
Step 6: Push the Repos

Two pushes — project (to GitHub) and a327ex-site (to the VPS):
# Project repo to GitHub. Skip this push if the project IS a327ex-site
# (handled by the second push below — don't duplicate).
git push origin main

# a327ex-site to the VPS (post-receive hook restarts the Lua server).
cd E:/a327ex/a327ex-site
git add -A
git commit -m "[Title]"
git push prod main 2>&1 | tail -3
Failure handling: if either push fails, the other still happens. Local commits stay intact, so the user can re-push manually once they've fixed whatever blocked it. Don't roll back; the committed state on disk is the source of truth.

Step 7: Confirm

Tell the user: - Project commit hash + GitHub push result - a327ex-site commit hash + VPS push result

Format:
Logged — "[Title]".
  project (Anchor2):  abc1234  pushed to GitHub
  a327ex-site:        ghi9012  pushed to a327ex.com (post-receive deployed)
If a push failed, surface that explicitly with the error.

Notes

Frontmatter is non-negotiable. Every log file MUST have Title: and Date: at the top. Enforced at write time in step 4. The backfill script is a safety net, not a substitute.

If the project IS a327ex-site (e.g., you spent the session writing the renderer or fixing the theme), there's no separate "project repo to GitHub" push — the a327ex-site push at the end IS the project push. Don't duplicate.

Legacy note: this skill used to also dual-write to anchor.blot.im/logs/ and anchor.blot.im/context/. Post-cutover (May 2026), anchor.blot.im is a JS redirect to a327ex.com and no longer receives content. Drop those steps if you find any older docs that still reference them.

ARGUMENTS: Visual Experiments 5

Project	Root	Stage command
Anchor	`E:/a327ex/Anchor`	`git add docs/ framework/ engine/ scripts/ reference/`
Anchor2	`E:/a327ex/Anchor2`	`git add framework/ engine/ arena/ reference/ scripts/ docs/ .claude/`
emoji-ball-battles	`E:/a327ex/emoji-ball-battles`	`git add -A`
invoker	`E:/a327ex/Invoker`	`git add -A`
thalien-lune	`E:/a327ex/thalien-lune`	`git add -A`
a327ex-site	`E:/a327ex/a327ex-site`	`git add -A` (this IS one of the web repos — the log file added in Step 4 is staged here automatically)

Executing the end-session workflow. First, locate the session transcript + get the wrap-up timestamp:

Bash (python E:/a327ex/Anchor2/scripts/find-recent-session.py --limit 5 2>&1 | head -2...)

2026-05-31T14:40:26.225Z c125dd2c-61d9-4ab1-9397-0c1e640d0074 [claude] <-- MOST RECENT
   C:\Users\adn\.claude\projects\E--a327ex\c125dd2c-61d9-4ab1-9397-0c1e640d0074.jsonl

2026-05-31T14:04:17.512Z aca39077-9a40-4d7e-ac77-c4c05ac51979 [claude]
   C:\Users\adn\.claude\projects\E--a327ex\aca39077-9a40-4d7e-ac77-c4c05ac51979.jsonl

2026-05-31T12:43:22.625Z 6e9ef6a3-51f9-4901-9a50-0edfff7d8be4 [claude]
   C:\Users\adn\.claude\projects\E--a327ex\6e9ef6a3-51f9-4901-9a50-0edfff7d8be4.jsonl

2026-05-31T02:58:41.094Z 481ad3a8-6d9e-43dc-bc39-f5417426e5a5 [claude]
   C:\Users\adn\.claude\projects\E--a327ex\481ad3a8-6d9e-43dc-bc39-f5417426e5a5.jsonl

2026-05-30T21:49:44.805Z 06f5cfc2-4245-4927-9a2d-d7f372358eff [claude]
   C:\Users\adn\.claude\projects\E--a327ex\06f5cfc2-4245-4927-9a2d-d7f372358eff.jsonl

=== wrap-up timestamp ===
2026-05-31 11:40:51

Current session is c125dd2c. Converting the transcript:

Visual Experiments 5

Summary

Where the work lives

The key finding from the audit

Coverage audit (your requested categories → what's built)

Proposed plan of attack (incremental — you test between)

Design Brief — Component gallery scaffold + CARDS & UPGRADE CHIPS

Part 0 — Shared scaffold (components.lua, new root file)

Part 1 — The two new widgets

ui_card{ rect, icon, title, desc, footer, rarity, selected, id }

ui_upgrade_chip{ x, y, icon, label, value, accent, id }

What I'm NOT doing this step

How to test

What you're looking at

Smooth vs rough divergences I implemented (per your note)

What changed

Test

What changed (rough only — smooth was untouched)

Test

What's new

Test

Segment fix

COUNTERS & BADGES — two new widgets (both skins)

Test

Three new composite widgets (both skins)

Test

Fix

PANELS & WINDOWS

Test

SFX / SCREEN SHAKE → checkboxes

Rough paused-menu selection

Test

Test

New widget: ui_text_input{ rect, value, placeholder, id } (both skins)

Screen (two columns, both modes)

Test

Next: TYPOGRAPHY

Design Brief — TYPOGRAPHY screen

What the typography screen does

Test

Changes

Test

Verdict

What's already good (keep)

The rough edges

A representative call site (what the code looks like)

Recommended ergonomics pass (none change the architecture)

Design Brief — UI API ergonomics pass

1. Uniform return contract (every widget → a table r)

2. Contract helpers (kill the boilerplate + the effect_clear footgun)

3. Layout conveniences (on top of the existing rectcut)

4. id guard (kill the cryptic crash)

Files touched

Risk / scope note

What changed

Risk note (honest)

Test

Design Brief — fork-ready package (snkrx-parity)

Target root (what a fork sees)

Moves

Require-path edits (the only content changes, 4 files)

Why it's safe

Docs

4 core leaf modules -> ricochet/...)

New layout

What moved + why it's safe

Test (3 entry paths — the require graph changed, so check each)

End Session Workflow

Step 1: Get Session Info

Step 2: Write Summary

Step 3: Proceed Without Approval

Step 4: Convert Transcript and Write the Log File

Step 4.5: Decrement the lock (if active)

Step 5: Commit Project Repo

Step 6: Push the Repos

Step 7: Confirm

Notes

Part 0 — Shared scaffold (`components.lua`, new root file)

`ui_card{ rect, icon, title, desc, footer, rarity, selected, id }`

`ui_upgrade_chip{ x, y, icon, label, value, accent, id }`

New widget: `ui_text_input{ rect, value, placeholder, id }` (both skins)

1. Uniform return contract (every widget → a table `r`)

2. Contract helpers (kill the boilerplate + the `effect_clear` footgun)

`4 core leaf modules -> ricochet/...)`