onlyn00bs-badge

gen_stl.py (117659B)

---

 #!/usr/bin/env python3
 """
 DefCon friend-finder badge — prototype enclosure STL generator (dependency-free).
 
 Emits binary STL meshes for a two-piece tray+lid case (flat-sandwich fallback via
 PARAMS["walls"]). No external libraries: geometry is built from axis-aligned boxes,
 walls, and rounded corners, written as raw triangles. Watertight by construction.
 
 Two layouts (locked: B primary, A backup):
   B  Coplanar  — battery beside electronics. Bigger face, slimmer.   ~95 x 90 x 24 mm  <- PRIMARY
   A  Stacked   — battery behind electronics. Compact face, deeper.   ~95 x 74 x 30 mm
 
 Each layout produces TWO printable parts:
   *_front.stl  front bezel / LID — display-window cut + rounded corners + ears (flat)
   *_back.stl   back TRAY — floor + perimeter walls + M3 corner screw bosses + ears
                (set PARAMS["walls"]=False for the old flat slab)
 
 Run:  python3 gen_stl.py
 Out:  ./stl/badge_<ver>_{A,B}_{front,back}.stl  (ver from PARAMS) — stl/ holds only
       the CURRENT version; each run sweeps prior versions to ./stl_archive/. Plus a
       console size/weight report; each STL's 80-byte header names its version.
 
 All dims in mm. Tweak the PARAMS block; everything else is derived.
 """
 
 import struct
 import math
 import os
 import subprocess
 
 # ----------------------------------------------------------------------------
 # PARAMS  — every real-world measurement lives here. Verify w/ calipers on
 # arrival; these are datasheet/vendor numbers (the enclosure spec is ./README.md).
 # ----------------------------------------------------------------------------
 P = {
     # version stamp — baked into each STL's filename AND its 80-byte header, so
     # every iteration persists for posterity and a shared file names its version.
     # Bump MINOR for tweaks, MAJOR for a layout/structural milestone (v0 = the old
     # flat sandwich; v1 = walled tray + M3 bosses). The git short-rev is printed in
     # the console only (NOT baked into the STL, so regen stays churn-free) — mirrors
     # the firmware FW_VERSION (human) / GIT_REV (exact) split.
     "case_version": "v1.51",   # v1.51: maker URL virtualshack.io → LID top band (pixel font, band-centred, printable), off the cramped tray strip. v1.50: house in the battery pocket
 
     # OLED 2.42" SSD1309 module (the FACE driver) — v1.15: RE-BASED to caliper
     # actuals (2026-06-11, checklist #10–#13); the 71.0×43.5 datasheet ran 1.0
     # wide and 4.5 SHORT of the real module (the v1.10→v1.13 collar saga's root
     # cause). The window/collar OPENINGS are preserved exactly via the clearance/
     # extra mapping below — the dialed fit carries over; only the basis is real now.
     "oled_pcb_w": 70.0,        # PCB long edge (measured; datasheet said 71.0)
     "oled_pcb_h": 48.0,        # PCB short edge (measured; datasheet said 43.5!)
     "oled_active_w": 55.0,     # lit area (reference)
     "oled_active_h": 27.5,
     # v1.5: rectangular PASSTHROUGH window — sized to the glass panel + a small gap so
     # the OLED glass nests THROUGH the opening (PCB captured behind the lid). Replaced
     # the old active-area + bezel-lip window: easier assembly, no glass-offset guess.
     "oled_glass_w": 61.0,      # glass panel, measured: 4.5mm offset all around → CENTRED
     "oled_glass_h": 39.0,
     "window_clearance": 0.5,   # per-side glass→opening gap (re-base: opening stays 63.0×40.0)
     "window_extra_w": 1.0,     # extra WIDTH on top of the clearance (the validated v1.9 slack)
     "window_extra_h": 0.0,     # extra HEIGHT (the v1.8+v1.10 slack now lives in the real glass dims)
     # guide ridges — a short collar on the LID's inner face, framing the OLED PCB
     # outline; the module nests into it for XY registration during assembly (doesn't
     # touch the window opening, so it doesn't shrink the visible screen).
     "guide_ridges": True,
     "guide_h": 2.5,            # ridge height into the cavity
     "guide_t": 1.2,            # ridge wall thickness
     "guide_clearance": 0.25,   # gap PCB→ridge per side (re-base: opening stays 74.0×48.5)
     # collar-FOOTPRINT trim — adjusts the collar's XY opening ONLY (not the plate
     # outline or the display window). v1.15 re-base: the validated opening maps to
     # real dims as 0.25/side snug height + the historic width slack as extra_w.
     "collar_extra_w": 3.5,     # collar WIDTH slack on top of the clearance (historic, harmless)
     "collar_extra_h": 0.0,     # HEIGHT: the 0.25/side IS the validated v1.13 snug fit
     # OLED header notch — the module's 4-pin header sits on its RIGHT edge
     # (screen-facing; user pick 2026-06-11), so the collar wall on that edge gets a
     # centred gap for the header + leads. MIRROR NOTE (empirical, v1.17): the
     # v1.15 derivation put viewer-right at lid −x — the FIT PRINT proved that
     # WRONG (notch landed opposite the tray's USB wall). As assembled, viewer-
     # right = +x on BOTH parts; the notch lives on +x. Trust the print, not the
     # chirality argument.
     "oled_header_notch_w": 22.0,  # notch width (18mm header span + tolerance)
     # OLED mounting pegs — the measured pattern (#13): 4× Ø2.0 holes @ 64.66×42.21
     # c2c (near-edge caliper method). PEGS, not screws: an M2 can't engage a 2mm
     # lid and a boss can't pass the module's own Ø2 holes. Assembly: module drops
     # over the pegs (glass through the window, PCB flush on the lid), then melt
     # the peg tips with an iron to stake — or leave friction-fit.
     "oled_pegs": True,
     "oled_mount_w": 65.16,     # peg c2c, long axis: measured 64.66 + 0.5 width slack (v1.25 fit — height pair was perfect)
     "oled_mount_h": 42.21,     # hole-centre spacing, short axis
     "oled_peg_d": 1.8,         # peg Ø — clearance into the Ø2.0 holes
     "oled_peg_h": 4.0,         # ≈PCB (~1.6) + ~2.4 proud for heat-staking
 
     # front case button — EXTERNAL panel-mount momentary, wired GPIO27→GND in
     # parallel with the onboard dome: a round through-hole
     # in the LID below the screen, centred on W, mid-band between the bottom wall
     # and the guide collar. Hole Ø = the part's THREAD OD. The part of record is
     # the Twidec PBS-110 (7 mm momentary, pre-soldered leads) — VALIDATED on glass
     # 2026-06-11: it threads into the v1.14 as-printed Ø7.0 hole, nut seats flat.
     # Auto-skipped if the band is too tight to web the hole (layout A).
     "btn_hole": True,
     "btn_hole_d": 7.0,         # Twidec PBS-110 thread — validated by fit test
 
     # FireBeetle 2 ESP32-E (the DEPTH driver's neighbor) — caliper pass 2026-06-10:
     # 60.0 × 25.0 (short edge 0.4 under datasheet); USB-C overhangs the short edge
     # 2.0mm (62.0 total), 9.0mm wide, 3.45mm above the 1.55mm PCB. The USB wall slot
     # itself is deferred to the board-mounting pass (its vertical position needs the
     # standoff design); the outline trim lands here.
     "fb_w": 60.0,
     "fb_h": 25.0,              # measured (was 25.4 datasheet) — B plate height −0.4
     "fb_usb_overhang": 2.0,    # USB-C proud of the short edge (62.0 board+connector total)
     # FireBeetle mounting — the CAD-exact M2 pattern (±28.4 along the length,
     # ±11.1 across, about the board centre). Standoff bosses
     # rise from the TRAY floor; COMPONENTS FACE THE FLOOR (the 7mm JST sets the
     # height), keeping the lid side clear for the case button. M2 screws drop in
     # from the front during back-insertion assembly. B placement (v1.33): PORTRAIT,
     # mounted top-LEFT with the USB short edge facing the −y (bottom) wall and the
     # antenna short edge getting the +y margin. The board stays COMPONENT-DOWN (no
     # flip — standoff stack unchanged from v1.32), which lands the JST on the board's
     # right side, facing the top-RIGHT battery: a short, tidy wire run (the "mirror"
     # of a board flip — same wiring win, no re-validation). (v1.32 was landscape with
     # USB on the +x/right wall; recover it with fb_orient="landscape", usb_wall="+x".)
     "fb_standoffs": True,
     "fb_orient": "portrait",   # B board orientation: "portrait" (USB short edge → −y) | "landscape" (→ +x, v1.32)
     "usb_wall": "-y",          # wall the USB-C slot punches through: "-y" (bottom) | "+x" (right, v1.32)
     "fb_hole_dx": 28.4,        # hole offset along the board length (from vendor CAD)
     "fb_hole_dy": 11.1,        # hole offset across the board width  (from vendor CAD)
     "fb_standoff_h": 9.5,      # JST 7.0 + 2.5 floor clearance (v1.16: 8.5→9.5 — raises the
                                #   board, and with it the USB dremel path, +1mm off the back)
     "fb_standoff_r": 2.25,     # boss Ø4.5 — ~1.4mm wall around the M2 pilot
     "fb_pilot_r": 0.8,         # M2 self-tap pilot, Ø1.6
 
     # USB-C cutout (v1.20; relocated to the −y/bottom wall in v1.33) — a REAL through-
     # slot, replacing the v1.19 raised dremel outline (the slot position is geometrically
     # locked, so we model the hole for the fleet instead of cutting 20 by hand). Position
     # tracks the board so it can't drift: for the bottom wall (usb_wall "-y") it's X-centred
     # on the FireBeetle's −y short edge (the connector); for "+x" it's Y-centred on the +x
     # edge. z is slaved to the standoff height either way (so "the dremel path rises with the
     # board" — v1.16 — is automatic, and the board mounts identically, component-down). The
     # optional slot TOP 45° inverted-V roof prints SUPPORT-FREE floor-down (a flat top would
     # be a ~10mm bridge); the flat bottom is fine (an upward face). usb_cutout:False reverts
     # to a solid wall (usb_roof_45:False → plain rectangle). The wall is set by usb_wall above.
     "usb_cutout": True,
     "usb_slot_w": 10.0,        # slot opening along the wall (y) — 9mm connector + tolerance
     "usb_slot_h": 4.5,         # rectangular opening height (z) — the USB-C body
     "usb_slot_top_margin": 0.5,# rectangle top above the board plane (ft + fb_standoff_h)
     "usb_slot_z_offset": 1.0,  # v1.37: 0.0 → +1.0 (another 1mm UP); v1.34 took it −2.0 → 0.0 (− = DOWN) —
                                #   empirical fit nudge, kept separate from top_margin so it stays slaved to the standoff
     "usb_roof_45": False,      # plain rectangular slot — X1C/H2D bridge 10mm fine, and a tiny
                                #   support peels right off; the peak added no usable plug clearance
 
     # EEMB 103454 LiPo, 3.7V 2000mAh — the cell in hand (×4); plugs straight into
     # the FireBeetle JST-PH, no holder. Caliper-confirm thickness — pouches run a
     # hair over the 10.0 nominal. (Thinner alt on hand: Qimoo 503035, 5×30×35,
     # 500mAh — slimmer case but well under a con day, so a backup not the hero.)
     "bat_w": 54.0,    # length (103454 = 4mm longer than the old 103450 model)
     "bat_h": 34.0,    # width  → drives layout-B face height
     "bat_t": 10.0,    # thickness → the depth driver
 
     # battery retention (v1.34) — a FULL collar cradling the 103454 pouch (vertical, in
     # B-portrait's RIGHT column, v1.35 hard against the right wall — leads are long). Walls
     # stand on the tray floor (compose-by-overlap like the standoffs). The floor under the
     # pocket stays SOLID (no vents — debris/short keepout).
     # B-portrait only (A stacks the cell behind the board, no floor pocket).
     "bat_collar": True,
     "bat_collar_h": 8.0,       # wall height (z) — cradles ~8 of the 10mm pouch; the soft top bulges free
     "bat_collar_t": 2.0,       # wall thickness
     "bat_collar_clear": 1.0,   # clearance per side on the TOP/BOTTOM (horizontal, y) walls
     "bat_collar_clear_x": 0.5, # clearance per side on the LEFT/RIGHT (vertical, x) walls — v1.35: 0.5 (1mm snugger)
     "bat_notch": False,        # JST-lead notch in the −x wall — v1.35: OFF (leads route around; long enough)
     "bat_notch_w": 16.0,       # notch width (y span) when bat_notch is on, biased low toward the FB's JST
 
     # plate / shell
     "plate_t": 2.0,            # thickness of each flat plate
     "cavity_pad": 4.0,         # extra internal depth clearance (adds to cavity → +overall depth)
     "edge_margin": 12.0,       # plastic border — keeps the 7mm corner bosses clear of the OLED guide
                                # collar (v1.7: 6→11; v1.12: 11→12 once the collar grew +2mm)
     "corner_r": 3.0,           # rounded outer corners
     "corner_seg": 8,           # arc resolution per corner
     # v1.18: soften the two EXPOSED face↔wall edges (lid front, tray back) with a
     # 45° chamfer — comfort against the chest, snag + chip resistance. Outer-only
     # and modest, so it never reaches the window/button/bosses or the wall interior.
     # The lid↔tray PARTING SEAM stays square (flush seat). Chamfer (not fillet):
     # prints clean in any orientation and stays watertight in this box-soup builder.
     "chamfer": True,
     "chamfer_size": 1.0,       # 45° bevel depth on the exposed face edges (mm)
     # honeycomb venting — hex perforations in BOTH the back floor (a full field) and the
     # front lid (a grille below the window). Built per-cell (each cell = rect minus one
     # hex) so a field stays watertight; cells go solid near keepouts (screw bosses, FB
     # standoffs, OLED pegs). Same hex spec on both faces (5/1.6). The front's converging
     # vent notches need the robust diagonal-split cap triangulator (_triangulate).
     "vent_back": True,         # honeycomb hex field in the back floor (spliced as a notch)
     "vent_hex_flats": 5.0,     # hex across-flats (mm)
     "vent_wall": 1.6,          # min wall between hexes (mm) — sturdy + printable
     "vent_margin": 9.0,        # back: keep the field this far inside the perimeter walls
     "vent_keepout_r": 6.0,     # leave a cell solid within this of a screw/standoff/peg centre
     # front-lid grille (v1.23, now OFF): the hex-strip-below-the-window machinery. vent_front
     # is False since v1.45 (the two front portholes replaced it), so front_vent_regions now
     # only positions those portholes. B only (A's centred window has no clean bottom band).
     "vent_front": False,       # v1.45: front honeycomb grille OFF (replaced by the front_hole_d portholes)
     "vent_front_margin": 3.5,  # keep the field this far inside the lid edge (> corner_r, off the arcs)
     "vent_front_gap": 1.2,     # clearance from the collar footprint / button / window
     # v1.45: two large round holes where the front grille used to be — one centred in each grille
     # band flanking the button (reuses front_vent_regions for placement). Each seats a bottom-edge
     # vertex below it (_with_base) so it bridges straight down. Replaces the hex grille + the top holes.
     "front_holes": True,
     "front_hole_d": 12.0,      # porthole diameter
     "front_hole_seg": 36,      # circle resolution
     "front_hole_dx": 7.0,      # v1.47: shift each porthole this far toward its nearer L/R edge (outward from
                                #   the region centre). Left porthole is the limit — at +2 up it's ~2.6mm from the
                                #   outer-bottom FB standoff (13.4,5.6) at dx=7 (was 4mm at dx=5).
     "front_hole_dy": 2.0,      # v1.47: shift the portholes UP (leaves ~1.7mm to the OLED collar — near the max)
     "vent_front_btn_clear_cols": 1,  # v1.39: leave this many innermost hex columns SOLID beside the button
                                # (each field: the left field's rightmost col + the right field's leftmost col).
                                # Widens the clear band around the button; every other hex stays bit-identical.
     # side-wall honeycomb vents (v1.38) — hex perforations through the −x/+x perimeter walls
     # (B only), matching the floor + lid fields. FLAT-TOP hexes (circle_loop's default) so the
     # vertical wall prints SUPPORT-FREE: the hole top is a short ~3mm bridge and the side faces
     # sit 30° off vertical. Inset with a solid border (doesn't reach the edges, like the lid
     # grille) + clears the corner bosses. −y wall (USB slot + floor keyhole) and +y wall (ear)
     # stay solid. Same flats/wall as the other fields (vent_hex_flats / vent_wall).
     "vent_walls": True,        # hex vents through the two side (−x/+x) walls (B)
     "vent_wall_margin": 2.5,   # solid border between the field and the wall edges / corner bosses
 
     # tray walls + M3 corner screw bosses — the back piece is now a TRAY (floor +
     # perimeter walls), the front stays the flat LID. Board-independent geometry,
     # so it's safe to print for reference before the boards are measured.
     "walls": True,             # False → fall back to the v0 flat back slab
     "wall_t": 2.0,             # perimeter wall thickness
     # M3 corner lid screws — ONE boss design serves both fastening methods: the
     # post is sized for a heat-set insert (the larger bore), and "fastener" picks
     # the hole — self-tap for the prototype, insert for production. Same posts and
     # positions either way, so the self-tap prototype validates the layout for both.
     "fastener": "selftap",     # "selftap" (prototype, threads into plastic) | "insert" (production heat-set)
     "boss_r": 3.5,             # post radius — sized for the insert (~1.5mm wall around a 4mm bore)
     "boss_hole_selftap": 1.25, # M3 self-tap pilot, 2.5mm dia
     "boss_hole_insert": 2.0,   # M3 heat-set insert bore, 4.0mm dia — confirm to YOUR insert's datasheet
     "boss_seg": 24,            # boss cylinder resolution
     "boss_clear_r": 1.7,       # screw-shank clearance hole (M3 ~3.4mm) in the tray floor (back insertion)
 
     # lanyard ears (two, top corners) — now with a real through-hole
     "ear_front": False,        # v1.42: top loop REMOVED from the front lid (relocating the attachment)
     "ear_back": True,          # still on the back tray for now (next steps move it)
     "ear_w": 9.0,              # v1.48: 10→9 — trim the excess front-on width; with ear_h 9 the tab is square
     "ear_h": 9.0,              # v1.48: 7→9 — taller tab to hold the 4mm bore (1mm lip + 4 bore + 1 wall + 3 cap)
     "ear_hole_r": 2.0,         # 4mm hole, ~1.5mm walls inside a 7mm ear
     "ear_hole_seg": 16,
     "ear_full_depth": True,    # v1.43: solid block (vs a flat 2mm tab), extruded z0→z1. v1.48: z1 is the tray
                                #   WALL TOP (plate_t + cavity), so the tab ends flush with the walls — it no
                                #   longer overhangs the extra plate_t out to the front-face plane
     "ear_corner_r": 3.0,       # v1.43: round the tab's top corners (mirrors the badge's corner_r)
     "ear_bore": True,          # v1.44: side-to-side (X) rounded-rect bore through the tab — the lanyard interface
     "ear_bore_y": 4.0,         # v1.48: 2→4 — taller bore opening (more room for cord/clip)
     "ear_bore_z": 6.0,         # bore depth (Z) — centred at the tab's mid-depth (≈ the depth-wise CoG) so the
                                #   badge hangs face-vertical: a worn badge tips in pitch until its CoG sits
                                #   under the cord, so putting the cord over the CoG ≈ zero tip
     "ear_bore_y0": 1.0,        # bore bottom this far above the badge top edge (thin non-load lip below)
     "ear_bore_r": 0.8,         # bore corner radius (rounded rectangle)
 
     # build-number imprint — raised 7-seg digits of the case version on the inner
     # face of each part (readable on a loose printed part; hidden once assembled).
     "imprint": True,
     "imprint_h": 0.8,          # raised height
     "imprint_digit_w": 4.0,    # digit cell width
     "imprint_digit_h": 6.0,    # digit cell height (v1.7: bigger so it prints legibly)
     "imprint_seg": 1.0,        # segment thickness
 
     # maker's mark (v1.50) — an ASCII house raised in the (solid) battery pocket of the
     # BACK tray: a signature found on teardown, hidden under the cell once assembled. The
     # build-number, which used to share the pocket, moves up above the FireBeetle. v1.51:
     # the site-tag URL LEAVES the cramped tray bottom strip (0.5mm px wouldn't print) and
     # takes the LID's inner-face top band instead — 76mm of clear run there fits it at
     # near-version size, still hidden on teardown (placed in make_front). Both at imprint_h.
     "maker_mark": True,        # the house in the battery pocket
     "maker_px": 1.5,           # house pixel size (mm) — grid is 12x10 → ~18 x 15mm
     "maker_tag": "virtualshack.io",  # site-tag URL, now on the lid's top band ("" = off → lid keeps the 7-seg version stamp)
     "maker_tag_px": 0.8,       # lid tag pixel size (mm) → 5.6mm glyphs; ~71mm run centred in the 76mm clear band
 
     # front-face text (v1.26) — raised 5x7 pixel text on the LID's outer face, in the solid
     # bands the honeycomb grille leaves clear: TOP runs horizontal above the window; the SIDES
     # run vertical alongside it (left reads up, right reads down). Set the three strings to your
     # text (A-Z 0-9 space - . / ! : + #); "" = that zone is blank. B-tuned; A renders too.
     "front_text": True,
     "front_text_top": "OnlyN00bs",    # v1.46: restored — the top band is clear again (top holes gone in v1.45)
                                       #   (was blanked in v1.40 when the top hole row lived here)
     "front_text_left": "DC34",        # vertical up the left side
     "front_text_right": "2026",       # vertical down the right side
     "front_text_px": 1.2,      # pixel size (mm): a glyph is 5px wide x 7px tall (~6 x 8.4mm)
     "front_text_h": 0.6,       # colour-inlay depth INTO the face (mm) — the 2nd-filament layer thickness
     "front_text_col_gap": 1.0, # blank columns between glyphs (in px units)
 
     # top-band hole row (v1.40) — a centred row of round through-holes across the top band of the B
     # lid (above the OLED window), replacing the old top text. Each hole is auto-skipped if it can't
     # keep clear of the two top corner M3 bosses (so it's safe if n/pitch grow). The lid's version
     # imprint is dropped when this is on (the band is now holes); the TRAY keeps its imprint.
     "top_holes": False,        # v1.45: top Ø12 row removed (restores the full OLED collar)
     "top_hole_d": 12.0,        # hole diameter (v1.41: 5→12 — too big for the band above the collar, so the
                                #   collar's top bar is notched around each hole; ~2mm of OLED PCB edge shows
                                #   in the bottom of each hole, and the bar survives between/beside the holes)
     "top_hole_pitch": 30.0,    # centre-to-centre spacing along x
     "top_hole_n": 2,           # number of holes (centred about the lid midline)
     "top_hole_y": 75.0,        # centre y — balanced ~2mm walls to the top edge and the window
     "top_hole_seg": 36,        # circle resolution
 
     # material — the print material of record (also drives the weight estimate)
     "material": "PETG",        # PETG for the build (heat/impact-tolerant for Vegas); PLA is fine for fit tests
     "infill": 0.30,            # rough effective fill incl. perimeters/top-bottom
 }
 
 # filament density (g/cc) for the weight estimate — PLA ~1.24, PETG ~1.27.
 _DENSITY_G_CC = {"PLA": 1.24, "PETG": 1.27}
 
 # ----------------------------------------------------------------------------
 # tiny mesh kit — triangles as ((x,y,z),(x,y,z),(x,y,z))
 # ----------------------------------------------------------------------------
 
 def box(x0, y0, z0, x1, y1, z1):
     """Axis-aligned box -> 12 triangles, outward normals."""
     # 8 corners
     p = [
         (x0, y0, z0), (x1, y0, z0), (x1, y1, z0), (x0, y1, z0),  # bottom 0-3
         (x0, y0, z1), (x1, y0, z1), (x1, y1, z1), (x0, y1, z1),  # top    4-7
     ]
     # faces as quads (ccw seen from outside)
     quads = [
         (0, 3, 2, 1),  # bottom (-z)
         (4, 5, 6, 7),  # top    (+z)
         (0, 1, 5, 4),  # front  (-y)
         (2, 3, 7, 6),  # back   (+y)
         (1, 2, 6, 5),  # right  (+x)
         (3, 0, 4, 7),  # left   (-x)
     ]
     tris = []
     for a, b, c, d in quads:
         tris.append((p[a], p[b], p[c]))
         tris.append((p[a], p[c], p[d]))
     return tris
 
 
 def prism(poly, z0, z1):
     """Extrude a CCW 2D polygon [(x,y),...] from z0 to z1 -> closed mesh.
     Caps via fan triangulation (poly must be convex for correct caps)."""
     tris = []
     n = len(poly)
     # walls
     for i in range(n):
         x0, y0 = poly[i]
         x1, y1 = poly[(i + 1) % n]
         a = (x0, y0, z0); b = (x1, y1, z0)
         c = (x1, y1, z1); d = (x0, y0, z1)
         tris.append((a, b, c))
         tris.append((a, c, d))
     # bottom cap (-z, reversed for outward normal) + top cap (+z)
     for i in range(1, n - 1):
         a = (poly[0][0], poly[0][1], z0)
         b = (poly[i][0], poly[i][1], z0)
         c = (poly[i + 1][0], poly[i + 1][1], z0)
         tris.append((a, c, b))                       # bottom faces -z
         ta = (poly[0][0], poly[0][1], z1)
         tb = (poly[i][0], poly[i][1], z1)
         tc = (poly[i + 1][0], poly[i + 1][1], z1)
         tris.append((ta, tb, tc))                     # top faces +z
     return tris
 
 
 def rounded_rect(x0, y0, x1, y1, r, seg):
     """CCW polygon of an axis-aligned rect with rounded corners."""
     if r <= 0:
         return [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
     pts = []
     # corner centers + sweep ranges (ccw starting bottom-right)
     corners = [
         (x1 - r, y0 + r, -90, 0),    # bottom-right
         (x1 - r, y1 - r, 0, 90),     # top-right
         (x0 + r, y1 - r, 90, 180),   # top-left
         (x0 + r, y0 + r, 180, 270),  # bottom-left
     ]
     for cx, cy, a0, a1 in corners:
         for s in range(seg + 1):
             ang = math.radians(a0 + (a1 - a0) * s / seg)
             pts.append((cx + r * math.cos(ang), cy + r * math.sin(ang)))
     return pts
 
 
 def disc(cx, cy, r, z0, z1, seg):
     """A solid cylinder (used as a negative — but we build positive then skip)."""
     poly = [(cx + r * math.cos(2 * math.pi * i / seg),
              cy + r * math.sin(2 * math.pi * i / seg)) for i in range(seg)]
     return prism(poly, z0, z1)
 
 
 def ensure_ccw(poly):
     """Return poly wound counter-clockwise (positive signed area)."""
     return poly if signed_area(poly) >= 0 else poly[::-1]
 
 
 def circle_loop(cx, cy, r, k):
     """CCW loop of k points on a circle (a hole boundary)."""
     return [(cx + r * math.cos(2 * math.pi * i / k),
              cy + r * math.sin(2 * math.pi * i / k)) for i in range(k)]
 
 
 def perimeter_sample(poly, k):
     """Resample a closed polygon's perimeter into exactly k points, spaced evenly
     by arc length, preserving orientation. Lets a hole loop carry the SAME point
     count as its outer loop so the two can be stitched index-to-index."""
     n = len(poly)
     seglen, total = [], 0.0
     for i in range(n):
         x0, y0 = poly[i]; x1, y1 = poly[(i + 1) % n]
         d = math.hypot(x1 - x0, y1 - y0); seglen.append(d); total += d
     step = total / k
     pts, i, acc = [], 0, 0.0
     for j in range(k):
         target = j * step
         while i < n and acc + seglen[i] < target - 1e-9:
             acc += seglen[i]; i += 1
         if i >= n:
             i = n - 1
         x0, y0 = poly[i]; x1, y1 = poly[(i + 1) % n]
         t = 0.0 if seglen[i] == 0 else (target - acc) / seglen[i]
         pts.append((x0 + (x1 - x0) * t, y0 + (y1 - y0) * t))
     return pts
 
 
 def _orient(a, b, c, target):
     """Return the triangle wound so its normal points along `target` (dot ≥ 0)."""
     nx, ny, nz = tri_normal((a, b, c))
     return (a, b, c) if nx*target[0] + ny*target[1] + nz*target[2] >= 0 else (a, c, b)
 
 
 def annulus_slab(outer, inner, z0, z1):
     """Watertight slab of the region between an outer loop and an inner (hole)
     loop — both CCW with the SAME point count. Caps tile the ring; outer walls
     face outward, inner walls face into the hole. Normals are oriented by
     construction, so the result is a closed 2-manifold (use perimeter_sample /
     circle_loop to match counts). This is the one primitive behind the display
     window, the ear holes, and any future screw holes."""
     assert len(outer) == len(inner), "outer/inner loops must match point count"
     k = len(outer)
     ocx = sum(p[0] for p in outer) / k; ocy = sum(p[1] for p in outer) / k
     icx = sum(p[0] for p in inner) / k; icy = sum(p[1] for p in inner) / k
     tris = []
     for i in range(k):
         j = (i + 1) % k
         oA, oB = outer[i], outer[j]
         iA, iB = inner[i], inner[j]
         # caps: ring quad [oA, oB, iB, iA] at each z (−z bottom, +z top)
         for zz, up in ((z0, (0, 0, -1)), (z1, (0, 0, 1))):
             A = (oA[0], oA[1], zz); B = (oB[0], oB[1], zz)
             C = (iB[0], iB[1], zz); D = (iA[0], iA[1], zz)
             tris.append(_orient(A, B, C, up))
             tris.append(_orient(A, C, D, up))
         # outer wall — normal points away from the outer centroid
         tgt = (oA[0] - ocx, oA[1] - ocy, 0)
         A = (oA[0], oA[1], z0); B = (oB[0], oB[1], z0)
         C = (oB[0], oB[1], z1); D = (oA[0], oA[1], z1)
         tris.append(_orient(A, B, C, tgt)); tris.append(_orient(A, C, D, tgt))
         # inner (hole) wall — normal points toward the hole centroid
         tgt = (icx - iA[0], icy - iA[1], 0)
         A = (iA[0], iA[1], z0); B = (iB[0], iB[1], z0)
         C = (iB[0], iB[1], z1); D = (iA[0], iA[1], z1)
         tris.append(_orient(A, B, C, tgt)); tris.append(_orient(A, C, D, tgt))
     return tris
 
 
 def edge_manifold_issues(tris):
     """Count undirected edges NOT shared by exactly two triangles. 0 → the mesh
     is a closed 2-manifold (watertight). Stronger than the tri-count==bytes check."""
     cnt = {}
     def key(p, q):
         a = (round(p[0], 4), round(p[1], 4), round(p[2], 4))
         b = (round(q[0], 4), round(q[1], 4), round(q[2], 4))
         return (a, b) if a <= b else (b, a)
     for a, b, c in tris:
         for e in (key(a, b), key(b, c), key(c, a)):
             cnt[e] = cnt.get(e, 0) + 1
     return sum(1 for v in cnt.values() if v != 2)
 
 
 def signed_area(poly):
     a = 0.0
     n = len(poly)
     for i in range(n):
         x0, y0 = poly[i]; x1, y1 = poly[(i + 1) % n]
         a += x0 * y1 - x1 * y0
     return a / 2.0
 
 
 def tri_normal(t):
     (ax, ay, az), (bx, by, bz), (cx, cy, cz) = t
     ux, uy, uz = bx - ax, by - ay, bz - az
     vx, vy, vz = cx - ax, cy - ay, cz - az
     nx, ny, nz = uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx
     L = math.sqrt(nx*nx + ny*ny + nz*nz) or 1.0
     return nx/L, ny/L, nz/L
 
 
 def mesh_volume_cc(tris):
     """Signed volume via divergence (sum of tetra), mm^3 -> cc."""
     vol = 0.0
     for (a, b, c) in tris:
         vol += (a[0]*(b[1]*c[2]-b[2]*c[1])
                 - a[1]*(b[0]*c[2]-b[2]*c[0])
                 + a[2]*(b[0]*c[1]-b[1]*c[0])) / 6.0
     return abs(vol) / 1000.0
 
 
 def git_rev():
     """Git short rev of the tree generating these STLs, for the console report
     (mirrors the firmware's GIT_REV). A trailing '+' marks uncommitted tracked
     changes under hardware/cad/; 'nogit' if not in a repo. Deliberately NOT baked
     into the STL header — that would re-stamp every file on each regen."""
     here = os.path.dirname(os.path.abspath(__file__))
 
     def _git(args, default=""):
         try:
             return subprocess.check_output(["git"] + args, cwd=here,
                                            stderr=subprocess.DEVNULL).decode().strip()
         except Exception:
             return default
 
     rev = _git(["rev-parse", "--short", "HEAD"], "nogit")
     if rev != "nogit":
         dirty = subprocess.call(["git", "diff", "--quiet", "HEAD", "--", "."],
                                 cwd=here, stderr=subprocess.DEVNULL) != 0
         if dirty:
             rev += "+"
     return rev
 
 
 def write_stl(path, tris, header=""):
     # binary-STL header is a free 80-byte comment field — stamp it (version label)
     head = header.encode("ascii", "replace")[:80]
     head = head + b"\0" * (80 - len(head))
     with open(path, "wb") as f:
         f.write(head)
         f.write(struct.pack("<I", len(tris)))
         for t in tris:
             nx, ny, nz = tri_normal(t)
             f.write(struct.pack("<3f", nx, ny, nz))
             for v in t:
                 f.write(struct.pack("<3f", *v))
             f.write(struct.pack("<H", 0))
 
 
 def bbox(tris):
     xs = [v[0] for t in tris for v in t]
     ys = [v[1] for t in tris for v in t]
     zs = [v[2] for t in tris for v in t]
     return (max(xs)-min(xs), max(ys)-min(ys), max(zs)-min(zs))
 
 # ----------------------------------------------------------------------------
 # tray + boss kit — open surface pieces that compose into ONE closed solid.
 # (annulus_slab handles single-hole slabs; a tray is a floor + walls, so it
 # needs the floor/wall/rim pieces below to stay watertight without an interior
 # cap.) Normals are forced per-triangle via _orient, so winding can't go wrong.
 # ----------------------------------------------------------------------------
 
 def cavity_depth(layout):
     """Internal clearance between the two plate inner faces (front lid ↔ back
     floor). OLED zone + the behind-stack; the tray wall height equals this."""
     oled_zone = 6.0
     behind = (6.0 + P["bat_t"]) if layout == "A" else max(6.0, P["bat_t"])
     return oled_zone + behind + P["cavity_pad"]   # +pad. A: 6+16+pad,  B: 6+10+pad
 
 
 def _fan_cap(poly, z, updir):
     """Flat cap of a CONVEX polygon at height z, every tri forced to face updir."""
     tris = []
     a = (poly[0][0], poly[0][1], z)
     for i in range(1, len(poly) - 1):
         b = (poly[i][0], poly[i][1], z)
         c = (poly[i + 1][0], poly[i + 1][1], z)
         tris.append(_orient(a, b, c, updir))
     return tris
 
 
 def _ring_cap(outer, inner, z, updir):
     """Flat ring between matched outer/inner loops (same point count) at height z."""
     k = len(outer)
     tris = []
     for i in range(k):
         j = (i + 1) % k
         A = (outer[i][0], outer[i][1], z); B = (outer[j][0], outer[j][1], z)
         C = (inner[j][0], inner[j][1], z); D = (inner[i][0], inner[i][1], z)
         tris.append(_orient(A, B, C, updir)); tris.append(_orient(A, C, D, updir))
     return tris
 
 
 def _side_wall(loop, z0, z1, outward, skip=None):
     """Vertical wall around a closed loop, z0→z1. Normals face away from the loop
     centroid (outward=True) or toward it (outward=False). `skip(a, b)` → True drops
     the edge between loop points a and b (v1.20: the +x straight run is skipped so a
     windowed face — `_vwall_with_window` — can replace it with the USB-C cutout)."""
     k = len(loop)
     cx = sum(p[0] for p in loop) / k; cy = sum(p[1] for p in loop) / k
     tris = []
     for i in range(k):
         j = (i + 1) % k
         if skip and skip(loop[i], loop[j]):
             continue
         A = (loop[i][0], loop[i][1], z0); B = (loop[j][0], loop[j][1], z0)
         C = (loop[j][0], loop[j][1], z1); D = (loop[i][0], loop[i][1], z1)
         mx = (loop[i][0] + loop[j][0]) / 2.0; my = (loop[i][1] + loop[j][1]) / 2.0
         tgt = (mx - cx, my - cy, 0) if outward else (cx - mx, cy - my, 0)
         tris.append(_orient(A, B, C, tgt)); tris.append(_orient(A, C, D, tgt))
     return tris
 
 
 def boss_positions(W, H):
     """Four screw bosses, one per corner, inset just inside the perimeter walls."""
     d = P["wall_t"] + P["boss_r"]
     return [(d, d), (W - d, d), (d, H - d), (W - d, H - d)]
 
 
 def screw_bosses(W, H, z0, z1):
     """M3 corner bosses: closed tubes (post + bore) standing on the cavity floor.
     The bore bottoms out on the floor below (blind hole from the top), so a screw
     through the lid threads straight in. "fastener" picks the bore — a narrow
     self-tap pilot (prototype) or a wider heat-set-insert bore (production); the
     post is the same size either way. Each is its own watertight solid that
     overlaps the floor — same compose-by-overlap trick as the lanyard ears."""
     bs, seg = P["boss_r"], P["boss_seg"]
     hr = P["boss_hole_insert"] if P["fastener"] == "insert" else P["boss_hole_selftap"]
     tris = []
     for cx, cy in boss_positions(W, H):
         outer = ensure_ccw(circle_loop(cx, cy, bs, seg))
         inner = ensure_ccw(circle_loop(cx, cy, hr, seg))
         tris += annulus_slab(outer, inner, z0, z1)
     return tris
 
 
 # ----------------------------------------------------------------------------
 # polygon-with-holes triangulation — ear clipping + hole bridging. Lets a flat
 # face carry MULTIPLE true through-holes (screw clearance, USB, vents) where the
 # single-hole annulus can't. Holes are CW loops inside a CCW outer loop.
 # ----------------------------------------------------------------------------
 _EPS = 1e-9
 
 def _tri_area2(a, b, c):
     return (b[0]-a[0])*(c[1]-a[1]) - (c[0]-a[0])*(b[1]-a[1])
 
 
 def _strictly_inside(p, a, b, c):
     d1=_tri_area2(p,a,b); d2=_tri_area2(p,b,c); d3=_tri_area2(p,c,a)
     if abs(d1)<_EPS or abs(d2)<_EPS or abs(d3)<_EPS:
         return False                      # on an edge / coincident → doesn't block an ear
     return (d1>0)==(d2>0)==(d3>0)
 
 
 def _earclip(poly):
     """Triangulate a simple CCW polygon to coord-triples (ear clipping, O(n²))."""
     pts=list(poly); idx=list(range(len(pts))); tris=[]; guard=0
     while len(idx)>3 and guard<50000:
         guard+=1; made=False
         for ii in range(len(idx)):
             i0,i1,i2=idx[(ii-1)%len(idx)],idx[ii],idx[(ii+1)%len(idx)]
             a,b,c=pts[i0],pts[i1],pts[i2]
             if _tri_area2(a,b,c)<=_EPS:                          # reflex / degenerate
                 continue
             if any(_strictly_inside(pts[j],a,b,c) for j in idx if j not in (i0,i1,i2)):
                 continue
             tris.append((a,b,c)); idx.pop(ii); made=True; break
         if not made:
             break
     if len(idx)==3:
         tris.append((pts[idx[0]],pts[idx[1]],pts[idx[2]]))
     return tris
 
 
 def _on_seg(p, a, b):
     """p on the CLOSED segment a-b (collinear within tol AND inside the bbox)."""
     if abs(_tri_area2(a, b, p)) > 1e-7:
         return False
     return (min(a[0], b[0]) - 1e-7 <= p[0] <= max(a[0], b[0]) + 1e-7 and
             min(a[1], b[1]) - 1e-7 <= p[1] <= max(a[1], b[1]) + 1e-7)
 
 
 def _proper_cross(a, b, c, d):
     """True iff segments a-b and c-d cross at a point interior to BOTH (strict)."""
     d1 = _tri_area2(c, d, a); d2 = _tri_area2(c, d, b)
     d3 = _tri_area2(a, b, c); d4 = _tri_area2(a, b, d)
     return (((d1 > _EPS and d2 < -_EPS) or (d1 < -_EPS and d2 > _EPS)) and
             ((d3 > _EPS and d4 < -_EPS) or (d3 < -_EPS and d4 > _EPS)))
 
 
 def _pt_in_poly(p, poly):
     """Even-odd ray cast: True iff p is strictly inside the polygon."""
     ins = False; n = len(poly)
     for i in range(n):
         a, b = poly[i], poly[(i + 1) % n]
         if (a[1] > p[1]) != (b[1] > p[1]):
             xi = a[0] + (p[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0])
             if p[0] < xi:
                 ins = not ins
     return ins
 
 
 def _valid_diagonal(poly, i, j):
     """True iff poly[i]-poly[j] is a real internal diagonal: it crosses no edge, no other
     vertex lies on it, and its midpoint is inside the polygon. This is what makes the
     triangulator robust to the keyhole slits — a diagonal that would span a zero-width
     slit fails the on-segment / midpoint test, where a plain convex-ear test does not."""
     n = len(poly); a, b = poly[i], poly[j]
     for k in range(n):
         if k in (i, j) or (k + 1) % n in (i, j):
             continue                                  # edge incident to a diagonal endpoint
         u, v = poly[k], poly[(k + 1) % n]
         if _proper_cross(a, b, u, v):
             return False
         if _on_seg(u, a, b):                          # a non-incident vertex sits on the diagonal
             return False
     return _pt_in_poly(((a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0), poly)
 
 
 def _dedup(poly):
     """Drop consecutive (and wrap-around) duplicate vertices — the zero-length edges the
     keyhole bridges/slits leave behind, which otherwise stall the triangulator."""
     out = []
     for p in poly:
         if not out or abs(p[0] - out[-1][0]) > 1e-7 or abs(p[1] - out[-1][1]) > 1e-7:
             out.append(p)
     while len(out) > 1 and abs(out[0][0] - out[-1][0]) <= 1e-7 and abs(out[0][1] - out[-1][1]) <= 1e-7:
         out.pop()
     return out
 
 
 def _triangulate(poly):
     """Triangulate a (weakly-)simple CCW polygon to coord-triples, Steiner-free (uses only
     input vertices, so the cap keeps matching the walls/cells that share its loops). Ear-clips
     where it can; when it STALLS — which converging v1.22 keyhole slits cause in one cap (the
     front grille: vent notches flanking the button, plus the window) — it splits on a valid
     internal diagonal and recurses. Both halves share that diagonal, so the mesh stays
     watertight. Supersedes plain _earclip, which can't finish such a cap. CAVEAT: the diagonal-
     split path still mis-meshes some thin/tall single-/two-column notches — cap_with_holes
     guards against shipping those via an area check. Replace with a vetted CDT to lift that."""
     poly = _dedup(poly)
     if len(poly) < 3:
         return []
     tris = []
     work = poly
     while len(work) > 3:
         m = len(work); clipped = False
         for ii in range(m):
             i0, i1, i2 = (ii - 1) % m, ii, (ii + 1) % m
             a, b, c = work[i0], work[i1], work[i2]
             if _tri_area2(a, b, c) <= _EPS:                      # reflex / collinear
                 continue
             if any(k not in (i0, i1, i2) and _strictly_inside(work[k], a, b, c) for k in range(m)):
                 continue
             if not _valid_diagonal(work, i0, i2):                # blocks slit-spanning ears
                 continue
             tris.append((a, b, c)); work = work[:ii] + work[ii + 1:]; clipped = True; break
         if clipped:
             continue
         # stalled: split on a valid diagonal and recurse — the two halves share the cut edge
         split = None
         for ai in range(m):
             for bi in range(ai + 2, m):
                 if ai == 0 and bi == m - 1:
                     continue
                 if _valid_diagonal(work, ai, bi):
                     split = (ai, bi); break
             if split:
                 break
         if split is None:
             break                                                # unreachable for a valid polygon
         ai, bi = split
         return tris + _triangulate(work[ai:bi + 1]) + _triangulate(work[bi:] + work[:ai + 1])
     if len(work) == 3:
         tris.append((work[0], work[1], work[2]))
     return tris
 
 
 def _hole_loop(cx, cy, r, seg):
     """CW circle loop — a hole boundary for cap_with_holes."""
     return list(reversed(circle_loop(cx, cy, r, seg)))
 
 
 def _bridge_holes(outer, holes):
     """Merge CW holes into a CCW outer loop via short corner-facing slits → one
     simple CCW polygon. Each hole bridges outward to its nearest outer vertex
     (using the hole vertex facing it), so the slit can't cut back across the hole."""
     assign={}
     for hole in holes:
         hx=sum(p[0] for p in hole)/len(hole); hy=sum(p[1] for p in hole)/len(hole)
         oi=min(range(len(outer)), key=lambda k:(outer[k][0]-hx)**2+(outer[k][1]-hy)**2)
         ov=outer[oi]
         hj=min(range(len(hole)), key=lambda k:(hole[k][0]-ov[0])**2+(hole[k][1]-ov[1])**2)
         assign.setdefault(oi,[]).append(hole[hj:]+hole[:hj])
     merged=[]
     for i,ov in enumerate(outer):
         merged.append(ov)
         for rot in assign.get(i,[]):
             merged += rot + [rot[0], ov]
     return merged
 
 
 def cap_with_holes(outer, holes, z, updir):
     """Flat cap of a CCW outer loop with CW holes at height z, facing updir.
     Falls back to a plain fan when there are no holes, so it's a drop-in cap."""
     if not holes:
         return _fan_cap(outer, z, updir)
     poly = _dedup(_bridge_holes(outer, holes))
     tris2d = _earclip(poly)
     # earclip can STALL (too few tris) or, worse, run to full count yet place a triangle
     # across a keyhole slit (covering a vent cell) — caught by comparing the triangulated
     # area to the polygon's own area. Either failure → the robust diagonal-split path.
     want = abs(signed_area(poly))
     got = sum(abs(_tri_area2(a, b, c)) for a, b, c in tris2d) / 2.0
     if len(tris2d) < len(poly) - 2 or abs(got - want) > 1e-3 * max(1.0, want):
         tris2d = _triangulate(poly)
     return [_orient((a[0],a[1],z),(b[0],b[1],z),(c[0],c[1],z),updir) for a,b,c in tris2d]
 
 
 def honeycomb_region(x0, y0, x1, y1, z0, z1, flats, wall, keep=None):
     """Honeycomb-vented slab section filling [x0,x1]x[y0,y1] from z0 to z1. Tiled into
     a grid of cells, each capped top+bottom as 'cell rect minus one hex' — a SINGLE
     hole per cell, so hole-bridging is always valid (cap_with_holes is robust for one
     hole, NOT for a whole field of them). Adjacent cells share corner-matched edges, so
     the field is watertight by construction. keep(cx,cy)->True leaves a cell solid (no
     hex) for keepouts. Returns (tris, meta) where meta=(x0,y0,x1,y1,nx,ny,cw,ch) — the
     grid metrics the host slab uses to splice this region in as a notch (splice_vent_notch)."""
     pitch = flats + wall
     nx = max(1, int(round((x1 - x0) / pitch)))
     ny = max(1, int(round((y1 - y0) / pitch)))
     cw = (x1 - x0) / nx
     ch = (y1 - y0) / ny
     r = (min(cw, ch) - wall) / math.sqrt(3.0)         # circumradius → across-flats = min(cw,ch)-wall
     tris = []
     for j in range(ny):
         for i in range(nx):
             ax, ay = x0 + i * cw, y0 + j * ch
             bx, by = ax + cw, ay + ch
             rect = [(ax, ay), (bx, ay), (bx, by), (ax, by)]      # CCW cell
             cx, cy = (ax + bx) / 2.0, (ay + by) / 2.0
             holes = [] if (keep and keep(cx, cy)) else [_hole_loop(cx, cy, r, 6)]
             tris += cap_with_holes(rect, holes, z1, (0, 0, 1))   # top face (up)
             tris += cap_with_holes(rect, holes, z0, (0, 0, -1))  # bottom face (down)
             for h in holes:
                 tris += _side_wall(h, z0, z1, False)             # hex wall, faces into the hole
     return tris, (x0, y0, x1, y1, nx, ny, cw, ch)                # grid metrics for the notch splice
 
 
 def splice_vent_notch(outline, meta, slit_idx):
     """Splice the honeycomb region's rectangular boundary into a CCW floor `outline` as
     a NOTCH (concavity) reachable by one zero-width slit rising from the outline's bottom
     edge at the vent's slit_idx column — instead of a hole. So the floor cap only has to
     bridge the few remaining real holes (the corner screws), which it does fine; the big
     central opening that crossed bridge-slits is gone. Vent edges are subdivided to the
     cell grid so the cells stitch with no T-junctions."""
     x0, y0, x1, y1, nx, ny, cw, ch = meta
     si = max(1, min(nx - 1, slit_idx))
     slit_x = x0 + si * cw
     B = [(x0 + i * cw, y0) for i in range(nx + 1)]       # bottom edge L→R
     L = [(x0, y0 + j * ch) for j in range(ny + 1)]       # left edge   B→T
     T = [(x0 + i * cw, y1) for i in range(nx + 1)]       # top edge    L→R
     R = [(x1, y0 + j * ch) for j in range(ny + 1)]       # right edge  B→T
     vloop  = [B[i] for i in range(si, -1, -1)]           # B[si]..B[0]   (=L[0])
     vloop += [L[j] for j in range(1, ny + 1)]            # L[1]..L[ny]   (=T[0])
     vloop += [T[i] for i in range(1, nx + 1)]            # T[1]..T[nx]   (=R[ny])
     vloop += [R[j] for j in range(ny - 1, -1, -1)]       # R[ny-1]..R[0] (=B[nx])
     vloop += [B[i] for i in range(nx - 1, si, -1)]       # B[nx-1]..B[si+1]  (CW around the vent)
     ymin = min(p[1] for p in outline); eps = 1e-6
     base = (slit_x, ymin)
     for k, pp in enumerate(outline):                     # base already a shared vertex (preferred)
         if abs(pp[0] - slit_x) < eps and abs(pp[1] - ymin) < eps:
             return outline[:k + 1] + vloop + [B[si], base] + outline[k + 1:]
     for k in range(len(outline)):                        # else splice it onto the bottom segment
         p, q = outline[k], outline[(k + 1) % len(outline)]
         if abs(p[1] - ymin) < eps and abs(q[1] - ymin) < eps and \
            min(p[0], q[0]) - eps < slit_x < max(p[0], q[0]) + eps:
             return outline[:k + 1] + [base] + vloop + [B[si], base] + outline[k + 1:]
     return outline                                       # no bottom edge found → unchanged
 
 
 def _with_base(outline, slit_x):
     """Insert a collinear vertex at (slit_x, ymin) on the outline's bottom edge so the
     vent-slit base is SHARED by the floor cap and the skirt / walls / rim that touch the
     same edge — without it the cap subdivides the bottom edge and they don't (T-junction)."""
     ymin = min(p[1] for p in outline); eps = 1e-6
     for k in range(len(outline)):
         p, q = outline[k], outline[(k + 1) % len(outline)]
         if abs(p[1] - ymin) < eps and abs(q[1] - ymin) < eps and \
            min(p[0], q[0]) - eps < slit_x < max(p[0], q[0]) + eps:
             return outline[:k + 1] + [(slit_x, ymin)] + outline[k + 1:]
     return outline
 
 
 def _with_top(outline, hole_x):
     """Insert a collinear vertex at (hole_x, ymax) on the outline's TOP edge — the mirror of
     `_with_base`. Gives each top-band through-hole a nearby outer vertex straight above it, so
     cap_with_holes bridges it with a short vertical slit instead of a long diagonal to a far
     corner (which, when two holes share that corner, crosses itself → non-manifold)."""
     ymax = max(p[1] for p in outline); eps = 1e-6
     for k in range(len(outline)):
         p, q = outline[k], outline[(k + 1) % len(outline)]
         if abs(p[1] - ymax) < eps and abs(q[1] - ymax) < eps and \
            min(p[0], q[0]) - eps < hole_x < max(p[0], q[0]) + eps:
             return outline[:k + 1] + [(hole_x, ymax)] + outline[k + 1:]
     return outline
 
 
 # ----------------------------------------------------------------------------
 # plate builders
 # ----------------------------------------------------------------------------
 
 def plate_outline(layout):
     """Return (W, H) of the outer plate for the given layout, OLED-driven width,
     content-driven height."""
     em = P["edge_margin"]
     W = P["oled_pcb_w"] + 2 * em
     if layout == "A":
         # face = OLED + margins (battery/board hide behind)
         H = P["oled_pcb_h"] + 2 * em
     else:
         # B coplanar: OLED on top; FireBeetle + battery sit BEHIND it (in z) and only the
         # overage pokes below. v1.33 portrait — the FB (left) is BOTTOM-PINNED at the USB
         # wall and a vertical battery (right) sits beside it; their ROW width (fb_h + bat_h =
         # 25+34 = 59) stays under the OLED's 70 so the OLED keeps driving W (no growth). We
         # deliberately keep the v1.32 PLATE HEIGHT rather than growing to the raw 60mm board
         # length: bottom-pinned, the 60mm FB tops out ~19mm below the +y wall at H=83 (ample
         # antenna margin), AND 83 is the tallest height the validated front-vent grille
         # triangulates cleanly (84+ trips a thin-notch bug in the cap triangulator — see _triangulate).
         electronics_col = P["fb_h"] + P["bat_h"]      # 25.4 + 34 = 59.4 → H 83 (both boards fit within it)
         H = max(P["oled_pcb_h"], electronics_col) + 2 * em
     return W, H
 
 
 def ear(x, y, t):
     """A lanyard ear with a round through-hole. (x, y) is its lower-left corner;
     it sits ear_w × ear_h above the plate's top edge. Watertight via annulus."""
     ew, eh = P["ear_w"], P["ear_h"]
     hr, hseg = P["ear_hole_r"], P["ear_hole_seg"]
     rect = ensure_ccw([(x, y), (x + ew, y), (x + ew, y + eh), (x, y + eh)])
     outer = perimeter_sample(rect, hseg)
     inner = ensure_ccw(circle_loop(x + ew / 2.0, y + eh / 2.0, hr, hseg))
     return annulus_slab(outer, inner, 0, t)
 
 
 def _swap_to_x(tris):
     """Re-map every vertex (a,b,c)→(c,a,b): a Z-extruded build whose 2D loops are (worldY, worldZ)
     becomes a tunnel running along worldX. The swap is cyclic (det +1), so annulus_slab's
     by-construction normals survive (same trick as the v1.38 side-wall vents)."""
     return [((a[2], a[0], a[1]), (b[2], b[0], b[1]), (c[2], c[0], c[1])) for a, b, c in tris]
 
 
 def lanyard_tab(x, y, z0, z1):
     """Lanyard tab (ear_w × ear_h above the plate top edge) extruded z0→z1 (the FULL case depth, vs
     the old flat ear), with rounded TOP corners (ear_corner_r) to mirror the badge. With `ear_bore`,
     a side-to-side (X) rounded-rectangular bore — the lanyard interface — is cut through the lower
     block, centred at MID-DEPTH (≈ the depth-wise CoG) so the cord sits over the CoG and the badge
     hangs face-vertical (no pitch tip). Built as region A (the bore tube — an X-extruded washer via
     annulus_slab + coord-swap) ∪ region B (the rounded cap); each a closed solid overlapping the
     other (compose-by-overlap, watertight)."""
     ew, eh = P["ear_w"], P["ear_h"]
     r = min(P["ear_corner_r"], ew / 2.0, eh - 0.5)
     seg = P["corner_seg"]
     cyr = y + eh - r                                  # top-corner arc-centre height
 
     def cap_poly(ybot):                              # rounded-top footprint from a straight bottom edge
         poly = [(x, ybot), (x + ew, ybot)]
         for s in range(seg + 1):                     # top-RIGHT arc 0°→90°
             a = math.radians(90.0 * s / seg)
             poly.append((x + ew - r + r * math.cos(a), cyr + r * math.sin(a)))
         for s in range(seg + 1):                     # top-LEFT arc 90°→180°
             a = math.radians(90.0 + 90.0 * s / seg)
             poly.append((x + r + r * math.cos(a), cyr + r * math.sin(a)))
         return ensure_ccw(poly)
 
     if not P["ear_bore"]:
         return prism(cap_poly(y), z0, z1)            # solid block (no interface yet)
 
     # region A — lower block y[y, y+eh-r], z[z0,z1], with the side-to-side bore (an X tunnel)
     by0 = y + P["ear_bore_y0"]; by1 = by0 + P["ear_bore_y"]
     bz0 = z0 + (z1 - z0) / 2.0 - P["ear_bore_z"] / 2.0; bz1 = bz0 + P["ear_bore_z"]   # centred at mid-depth
     yA1 = y + eh - r                                  # block top = where the corner rounding starts
     N = 64
     outer = perimeter_sample(ensure_ccw([(y, z0), (yA1, z0), (yA1, z1), (y, z1)]), N)  # (worldY,worldZ) rect
     inner = perimeter_sample(ensure_ccw(rounded_rect(by0, bz0, by1, bz1, P["ear_bore_r"], 8)), N)
     A = _swap_to_x(annulus_slab(outer, inner, x, x + ew))                            # tunnel along worldX
     # region B — rounded cap above the bore (down to the bore top → overlaps A, no coincident faces)
     B = prism(cap_poly(by1), z0, z1)
     return A + B
 
 
 # 7-segment glyphs — lit segments per char (a=top b=up-R c=lo-R d=bottom e=lo-L f=up-L g=mid)
 _SEG7 = {"0":"abcdef", "1":"bc", "2":"abdeg", "3":"abcdg", "4":"bcfg", "5":"acdfg",
          "6":"acdefg", "7":"abc", "8":"abcdefg", "9":"abcdfg",
          "A":"abcefg", "B":"cdefg"}   # A; B as 7-seg lowercase 'b' (uppercase B = 8)
 
 def _seg_boxes(ch, x0, y0, z0, z1):
     """Raised boxes for one 7-seg char at cell origin (x0,y0). '.' → a small dot.
     Segments are gapped apart so no two boxes share an exact edge (stays manifold,
     like the bosses) — they only sit on the face cap below them."""
     w, h, s = P["imprint_digit_w"], P["imprint_digit_h"], P["imprint_seg"]
     g = 0.3
     if ch == ".":
         return box(x0, y0, z0, x0 + s, y0 + s, z1)
     rects = {
         "a": (x0+s+g, y0+h-s,        x0+w-s-g, y0+h),
         "g": (x0+s+g, y0+(h-s)/2,    x0+w-s-g, y0+(h+s)/2),
         "d": (x0+s+g, y0,            x0+w-s-g, y0+s),
         "f": (x0,     y0+h/2+g,      x0+s,     y0+h-g),
         "b": (x0+w-s, y0+h/2+g,      x0+w,     y0+h-g),
         "e": (x0,     y0+g,          x0+s,     y0+h/2-g),
         "c": (x0+w-s, y0+g,          x0+w,     y0+h/2-g),
     }
     tris = []
     for k in _SEG7.get(ch, ""):
         ax, ay, bx, by = rects[k]
         tris += box(ax, ay, z0, bx, by, z1)
     return tris
 
 def imprint_text(text, x0, y0, z_face):
     """Raised 7-seg `text` starting at (x0, y0) on a face at z_face (raised +z)."""
     if not P["imprint"]:
         return []
     z0, z1 = z_face, z_face + P["imprint_h"]
     adv, dotadv = P["imprint_digit_w"] + 1.0, P["imprint_seg"] + 1.0
     tris, x = [], x0
     for ch in text:
         tris += _seg_boxes(ch, x, y0, z0, z1)
         x += dotadv if ch == "." else adv
     return tris
 
 
 def _imprint_run_len(text):
     """Width (mm) of an imprint_text run — for centring. Sums per-char advances and
     drops the trailing gap after the last glyph (cf. the advances in imprint_text)."""
     adv, dotadv = P["imprint_digit_w"] + 1.0, P["imprint_seg"] + 1.0
     w = sum(dotadv if ch == "." else adv for ch in text)
     return max(0.0, w - 1.0)
 
 
 # ----------------------------------------------------------------------------
 # 5x7 pixel font — for parametric raised text on the front face (top + sides).
 # Each glyph is 7 rows (top→bottom) x 5 cols, '1' = a lit pixel. Lit pixels become
 # raised boxes (box-soup native, watertight by construction like the 7-seg imprint).
 # ----------------------------------------------------------------------------
 _FONT5X7 = {
     " ": ["00000","00000","00000","00000","00000","00000","00000"],
     "A": ["01110","10001","10001","11111","10001","10001","10001"],
     "B": ["11110","10001","10001","11110","10001","10001","11110"],
     "C": ["01110","10001","10000","10000","10000","10001","01110"],
     "D": ["11110","10001","10001","10001","10001","10001","11110"],
     "E": ["11111","10000","10000","11110","10000","10000","11111"],
     "F": ["11111","10000","10000","11110","10000","10000","10000"],
     "G": ["01110","10001","10000","10111","10001","10001","01111"],
     "H": ["10001","10001","10001","11111","10001","10001","10001"],
     "I": ["01110","00100","00100","00100","00100","00100","01110"],
     "J": ["00111","00010","00010","00010","00010","10010","01100"],
     "K": ["10001","10010","10100","11000","10100","10010","10001"],
     "L": ["10000","10000","10000","10000","10000","10000","11111"],
     "M": ["10001","11011","10101","10101","10001","10001","10001"],
     "N": ["10001","10001","11001","10101","10011","10001","10001"],
     "O": ["01110","10001","10001","10001","10001","10001","01110"],
     "P": ["11110","10001","10001","11110","10000","10000","10000"],
     "Q": ["01110","10001","10001","10001","10101","10010","01101"],
     "R": ["11110","10001","10001","11110","10100","10010","10001"],
     "S": ["01111","10000","10000","01110","00001","00001","11110"],
     "T": ["11111","00100","00100","00100","00100","00100","00100"],
     "U": ["10001","10001","10001","10001","10001","10001","01110"],
     "V": ["10001","10001","10001","10001","10001","01010","00100"],
     "W": ["10001","10001","10001","10101","10101","11011","10001"],
     "X": ["10001","10001","01010","00100","01010","10001","10001"],
     "Y": ["10001","10001","01010","00100","00100","00100","00100"],
     "Z": ["11111","00001","00010","00100","01000","10000","11111"],
     "0": ["01110","10001","10011","10101","11001","10001","01110"],
     "1": ["00100","01100","00100","00100","00100","00100","01110"],
     "2": ["01110","10001","00001","00010","00100","01000","11111"],
     "3": ["11111","00010","00100","00010","00001","10001","01110"],
     "4": ["00010","00110","01010","10010","11111","00010","00010"],
     "5": ["11111","10000","11110","00001","00001","10001","01110"],
     "6": ["00110","01000","10000","11110","10001","10001","01110"],
     "7": ["11111","00001","00010","00100","01000","01000","01000"],
     "8": ["01110","10001","10001","01110","10001","10001","01110"],
     "9": ["01110","10001","10001","01111","00001","00010","01100"],
     "-": ["00000","00000","00000","11111","00000","00000","00000"],
     ".": ["00000","00000","00000","00000","00000","01100","01100"],
     "/": ["00001","00010","00010","00100","01000","01000","10000"],
     "!": ["00100","00100","00100","00100","00100","00000","00100"],
     ":": ["00000","01100","01100","00000","01100","01100","00000"],
     "+": ["00000","00100","00100","11111","00100","00100","00000"],
     "#": ["01010","01010","11111","01010","11111","01010","01010"],
     # lowercase — 8 rows: baseline stays at row 6 (shared with the 7-row caps/digits), an
     # extra row 7 carries descenders (g j p q y). x-height letters fill rows 2-6, ascenders
     # (b d f h k l t) go full height. pixel_text maps row 7 to -px, so they hang below.
     "a": ["00000","00000","01110","00001","01111","10001","01111","00000"],
     "b": ["10000","10000","10000","11110","10001","10001","11110","00000"],
     "c": ["00000","00000","01110","10000","10000","10000","01110","00000"],  # open right side (no col-4 closers) so it doesn't read as 'o' when printed
     "d": ["00001","00001","00001","01111","10001","10001","01111","00000"],
     "e": ["00000","00000","01110","10001","11111","10000","01110","00000"],
     "f": ["00110","01000","11110","01000","01000","01000","01000","00000"],
     "g": ["00000","00000","01111","10001","10001","01111","00001","01110"],
     "h": ["10000","10000","10000","11110","10001","10001","10001","00000"],
     "i": ["00100","00000","00100","00100","00100","00100","00100","00000"],
     "j": ["00010","00000","00010","00010","00010","00010","10010","01100"],
     "k": ["10000","10000","10010","10100","11000","10100","10010","00000"],
     "l": ["01100","00100","00100","00100","00100","00100","01110","00000"],
     "m": ["00000","00000","11010","10101","10101","10101","10101","00000"],
     "n": ["00000","00000","10110","11001","10001","10001","10001","00000"],
     "o": ["00000","00000","01110","10001","10001","10001","01110","00000"],
     "p": ["00000","00000","11110","10001","10001","11110","10000","10000"],
     "q": ["00000","00000","01111","10001","10001","01111","00001","00001"],
     "r": ["00000","00000","10110","11001","10000","10000","10000","00000"],
     "s": ["00000","00000","01111","10000","01110","00001","11110","00000"],
     "t": ["01000","01000","11110","01000","01000","01001","00110","00000"],
     "u": ["00000","00000","10001","10001","10001","10011","01101","00000"],
     "v": ["00000","00000","10001","10001","10001","01010","00100","00000"],
     "w": ["00000","00000","10001","10001","10101","10101","01010","00000"],
     "x": ["00000","00000","10001","01010","00100","01010","10001","00000"],
     "y": ["00000","00000","10001","10001","10001","01111","00001","01110"],
     "z": ["00000","00000","11111","00010","00100","01000","11111","00000"],
 }
 
 
 def _text_run_len(text, px, col_gap):
     """Length of `text` along the run direction (mm) — 5-wide glyphs spaced by col_gap."""
     n = len(text)
     return ((n * (5 + col_gap) - col_gap) * px) if n else 0.0
 
 
 def pixel_text(text, ox, oy, run, rise, z0, z1, px, col_gap=1.0, row_gap=0.2):
     """Raised 5x7 pixel `text` on a face, z0→z1. `run`=(rx,ry) is the unit direction along the
     text line (also each glyph's column/width axis); `rise`=(ux,uy) the unit direction along the
     glyph rows (height); both must be axis-aligned (±x/±y). Horizontal text: run=(1,0),rise=(0,1).
     Vertical: run=(0,±1),rise=(∓1,0). Lit pixels are merged into per-row run boxes (solid strokes)
     with a thin row_gap so no two boxes share an edge (stays manifold, like the imprint segments);
     a sub-nozzle gap prints as a solid block. Unknown chars advance as a space."""
     tris = []
     bx, by = ox, oy
     for ch in text:
         glyph = _FONT5X7.get(ch) or _FONT5X7.get(ch.upper())   # exact case first, else fold to caps
         if glyph:
             for row in range(len(glyph)):                       # 7-row caps/digits or 8-row lowercase
                 line, col = glyph[row], 0
                 while col < 5:
                     if line[col] == "1":
                         c0 = col
                         while col < 5 and line[col] == "1":
                             col += 1
                         rs0 = (6 - row) * px                 # this row's band along rise
                         corners = [(c0 * px, rs0), (col * px, rs0),
                                    (c0 * px, rs0 + px - row_gap), (col * px, rs0 + px - row_gap)]
                         xs = [bx + rl * run[0] + rsv * rise[0] for rl, rsv in corners]
                         ys = [by + rl * run[1] + rsv * rise[1] for rl, rsv in corners]
                         tris += box(min(xs), min(ys), z0, max(xs), max(ys), z1)
                     else:
                         col += 1
         bx += (5 + col_gap) * px * run[0]
         by += (5 + col_gap) * px * run[1]
     return tris
 
 
 # ASCII-house maker's mark (v1.50) — a bitmap grid, '#'=raised pixel, top row first.
 # CAPPED chimney at the top-right corner (the body's right wall carries up as its outer
 # wall); gable roof; one window. Rendered by pixel_art as raised boxes (box-soup native,
 # watertight like pixel_text). 12 wide x 10 tall.
 _MAKER_HOUSE = [
     "...####..###",
     "..#....#.#.#",
     ".#......##.#",
     "#........#.#",
     "############",
     "#..........#",
     "#..######..#",
     "#..#....#..#",
     "#..#....#..#",
     "############",
 ]
 
 
 def pixel_art(grid, ox, oy, z0, z1, px, row_gap=0.2):
     """Raised bitmap `grid` (rows of '#'/'1' = lit, top→bottom) on a face, z0→z1. (ox,oy)
     is the art's bottom-left; +x runs along columns, +y up the rows. Lit pixels merge into
     per-row run boxes with a thin row_gap so no two boxes share an edge (stays manifold —
     the same trick as pixel_text / the imprint segments)."""
     tris = []
     n = len(grid)
     for r, line in enumerate(grid):
         yb = (n - 1 - r) * px                             # row 0 = top row
         col, w = 0, len(line)
         while col < w:
             if line[col] in "1#":
                 c0 = col
                 while col < w and line[col] in "1#":
                     col += 1
                 tris += box(ox + c0 * px, oy + yb, z0,
                             ox + col * px, oy + yb + px - row_gap, z1)
             else:
                 col += 1
     return tris
 
 
 def guide_collar(cx, cy, z_face, top_gaps=None):
     """Short ridge frame on the lid's inner face around the OLED PCB outline, for
     XY registration during assembly (v1.10). v1.15: rebuilt from overlapping BOXES
     (was a closed annulus) so the header edge carries a NOTCH — the module's pin
     header exits through a gap instead of fouling the wall. Viewer-right = model
     −x on the lid (see the mirror note in PARAMS), so the notch lives on −x.
     Boxes overlap at the corners but the top/bottom walls are inset 0.6 where
     they meet the side walls — no two boxes share an exact face/edge (coincident
     geometry breaks the manifold check; same trick as the imprint segments).
     v1.41: `top_gaps` = [(x_centre, half_width), …] cuts those x-spans out of the TOP
     bar so a top-band through-hole doesn't leave collar fragments poking into it —
     the bar survives as the segments between the gaps (OLED still registers on the
     pegs + the 3 other sides + the remaining top segments)."""
     if not P["guide_ridges"]:
         return []
     gc, gt = P["guide_clearance"], P["guide_t"]
     hw = P["oled_pcb_w"] / 2.0 + gc + P["collar_extra_w"] / 2.0
     hh = P["oled_pcb_h"] / 2.0 + gc + P["collar_extra_h"] / 2.0
     z0, z1 = z_face, z_face + P["guide_h"]
     x0, x1 = cx - hw, cx + hw                    # collar INNER faces
     y0, y1 = cy - hh, cy + hh
     ov = 0.6                                     # corner overlap inset
     nw2 = P["oled_header_notch_w"] / 2.0
     tris = []
     tris += box(x0 - gt, y0 - gt, z0, x0, y1 + gt, z1)             # −x wall (viewer-LEFT), full
     tris += box(x1, y0 - gt, z0, x1 + gt, cy - nw2, z1)            # +x wall below the notch
     tris += box(x1, cy + nw2, z0, x1 + gt, y1 + gt, z1)            # +x wall above the notch
     tris += box(x0 - gt + ov, y0 - gt, z0, x1 + gt - ov, y0, z1)   # bottom wall
     # top wall — split into the segments left clear by top_gaps (else one solid bar)
     txl, txr = x0 - gt + ov, x1 + gt - ov
     cuts = sorted((max(txl, g0 - g1), min(txr, g0 + g1)) for g0, g1 in (top_gaps or []))
     cur = txl
     for clo, chi in cuts:
         if clo > cur + 0.5:
             tris += box(cur, y1, z0, clo, y1 + gt, z1)
         cur = max(cur, chi)
     if txr > cur + 0.5:
         tris += box(cur, y1, z0, txr, y1 + gt, z1)
     return tris
 
 
 def oled_pegs(cx, cy, z_face):
     """Four Ø-oled_peg_d posts on the lid's inner face at the OLED's measured
     mounting pattern (checklist #13). The module drops over them — glass through
     the window, PCB flush on the lid — then the tips get heat-staked (or stay
     friction-fit). Each peg is a closed cylinder overlapping the lid cap, the
     same compose-by-overlap as the bosses."""
     if not P["oled_pegs"]:
         return []
     r = P["oled_peg_d"] / 2.0
     dx, dy = P["oled_mount_w"] / 2.0, P["oled_mount_h"] / 2.0
     tris = []
     for sx in (-1, 1):
         for sy in (-1, 1):
             tris += disc(cx + sx * dx, cy + sy * dy, r,
                          z_face, z_face + P["oled_peg_h"], 16)
     return tris
 
 
 def fb_board_center(layout, W, H):
     """FireBeetle centre in the face plane. B portrait (v1.33): mounted top-LEFT, USB
     short edge facing the −y/bottom wall (the 2.0mm connector overhang reaching the wall
     inner face), antenna short edge getting the +y margin. B landscape (v1.32): top edge
     on the OLED's top line, USB short edge toward the +x wall. A (backup): plate centre."""
     if layout == "A":
         return W / 2.0, H / 2.0
     if P["fb_orient"] == "portrait":
         # x: board (fb_h wide) seated at the left edge_margin, clear of the corner bosses.
         # y: USB end at the bottom wall — cy = wall + overhang + half the board LENGTH.
         cx = P["edge_margin"] + P["fb_h"] / 2.0
         cy = P["wall_t"] + P["fb_usb_overhang"] + P["fb_w"] / 2.0
         return cx, cy
     cx = W - P["wall_t"] - P["fb_usb_overhang"] - P["fb_w"] / 2.0
     cy = (H - P["edge_margin"]) - P["fb_h"] / 2.0
     return cx, cy
 
 
 def fb_standoff_positions(layout, W, H):
     """The four M2 standoff centres at the FireBeetle's CAD-exact hole pattern (±28.4 along
     the board LENGTH, ±11.1 across the WIDTH), rotated for the board's orientation. Single
     source of truth so the standoff bosses and the vent keepouts can never disagree."""
     cx, cy = fb_board_center(layout, W, H)
     if layout == "B" and P["fb_orient"] == "portrait":
         ax, ay = P["fb_hole_dy"], P["fb_hole_dx"]   # portrait: length(28.4) runs along y, width(11.1) along x
     else:
         ax, ay = P["fb_hole_dx"], P["fb_hole_dy"]   # landscape / A: length along x
     return [(cx + sx * ax, cy + sy * ay) for sx in (-1, 1) for sy in (-1, 1)]
 
 
 def fb_standoffs(layout, W, H, z0):
     """Four M2 standoff bosses on the tray floor at the FireBeetle's CAD-exact
     hole pattern. Height clears the 7mm JST (components face the floor); screws
     drop in from the front during back-insertion assembly. Same closed-tube
     primitive as the M3 lid bosses."""
     if not P["fb_standoffs"]:
         return []
     tris = []
     for px, py in fb_standoff_positions(layout, W, H):
         outer = ensure_ccw(circle_loop(px, py, P["fb_standoff_r"], P["boss_seg"]))
         inner = ensure_ccw(circle_loop(px, py, P["fb_pilot_r"], P["boss_seg"]))
         tris += annulus_slab(outer, inner, z0, z0 + P["fb_standoff_h"])
     return tris
 
 
 def battery_footprint(layout, W, H):
     """The 103454 LiPo pouch's floor footprint (34 wide × 54 tall, VERTICAL) for B-portrait.
     v1.35: hard against the RIGHT (opposite the FB — leads are long), the collar's outer wall
     1mm clear of the right corner bosses. Returns (x0,y0,x1,y1) or None (A / landscape stack
     the cell elsewhere — no floor pocket)."""
     if layout != "B" or P["fb_orient"] != "portrait":
         return None
     boss_left = W - P["wall_t"] - 2 * P["boss_r"]                      # left edge of the right corner bosses (~85)
     x1 = (boss_left - 1.0) - P["bat_collar_t"] - P["bat_collar_clear_x"]   # pouch right edge (wall 1mm off the boss)
     x0 = x1 - P["bat_h"]                                               # 34mm across (vertical pouch)
     # v1.36: top-pinned (as far UP as possible) — the −y wall sits 1mm off the cavity's top
     # inner wall, clearing the centred case-button terminals down at the bottom band.
     y1 = (H - P["wall_t"] - 1.0) - P["bat_collar_t"] - P["bat_collar_clear"]   # pouch top edge
     y0 = y1 - P["bat_w"]                                               # 54mm tall
     return (x0, y0, x1, y1)
 
 
 def battery_keepout_rect(layout, W, H):
     """The floor rectangle kept SOLID (no vent cells) under the battery collar — the wall-outer
     rect grown half a hex so no wall foots on a half-cell. None when there's no pocket."""
     fp = battery_footprint(layout, W, H)
     if fp is None or not P["bat_collar"]:
         return None
     gx = P["bat_collar_clear_x"] + P["bat_collar_t"] + P["vent_hex_flats"] / 2.0
     gy = P["bat_collar_clear"] + P["bat_collar_t"] + P["vent_hex_flats"] / 2.0
     return (fp[0] - gx, fp[1] - gy, fp[2] + gx, fp[3] + gy)
 
 
 def battery_collar(layout, W, H, ft):
     """Full retention collar for the pouch: four walls framing the footprint, standing on the
     tray floor. LEFT/RIGHT (vertical) walls use bat_collar_clear_x; TOP/BOTTOM use bat_collar_
     clear. Each wall is a closed box that overlaps its neighbours at the corners and embeds into
     the floor — the codebase's compose-by-overlap trick (watertight by construction; the slicer
     unions the overlaps). Optional JST-lead notch (bat_notch) splits the −x wall."""
     fp = battery_footprint(layout, W, H)
     if fp is None or not P["bat_collar"]:
         return []
     x0, y0, x1, y1 = fp
     cx, cy, t, h = P["bat_collar_clear_x"], P["bat_collar_clear"], P["bat_collar_t"], P["bat_collar_h"]
     px0, py0, px1, py1 = x0 - cx, y0 - cy, x1 + cx, y1 + cy            # pocket inner faces (per-axis clearance)
     ox0, oy0, ox1, oy1 = px0 - t, py0 - t, px1 + t, py1 + t            # wall outer faces
     z0, z1 = ft - 0.5, ft + h                                          # embed 0.5 into the floor for a clean union
     ih = t / 2.0                                                       # left/right walls own the corners (full y)
     tris  = box(px1, oy0, z0, ox1, oy1, z1)                            # right (+x) wall, full y
     if P["bat_notch"]:
         ny0 = y0 + 1.0; ny1 = ny0 + P["bat_notch_w"]                  # JST-lead notch, biased low
         tris += box(ox0, oy0, z0, px0, ny0, z1)                       # −x wall below the notch
         tris += box(ox0, ny1, z0, px0, oy1, z1)                       # −x wall above the notch
     else:
         tris += box(ox0, oy0, z0, px0, oy1, z1)                       # −x (FB-facing) wall, solid (no notch)
     tris += box(ox0 + ih, py1, z0, ox1 - ih, oy1, z1)                 # top (+y) wall — inset x, interpenetrates the sides
     tris += box(ox0 + ih, oy0, z0, ox1 - ih, py0, z1)                 # bottom (−y) wall — inset x, no coincident corner edge
     return tris
 
 
 def usb_slot_profile(layout, W, H, ft):
     """The USB-C cutout opening as a CW loop in the USB wall's (u, z) plane — u is the
     in-wall coordinate: x for the −y/bottom wall, y for the +x/right wall. Centred on the
     FireBeetle's USB short edge (x-centre for "-y", y-centre for "+x"); z slaved to the
     standoff height so the slot rises with the board (the board mounts identically either
     way). Optionally topped by a 45° inverted-V (usb_roof_45). Returns None when off. CW
     because a hole loop inside the CCW wall-face rectangle is wound opposite (cf. _hole_loop)."""
     if not P["usb_cutout"]:
         return None
     wall = P["usb_wall"] if layout == "B" else "+x"        # A (centered backup) stays on the +x wall
     cx, cy = fb_board_center(layout, W, H)
     u = cx if wall == "-y" else cy                         # connector centred on the USB short edge
     u0, u1 = u - P["usb_slot_w"] / 2.0, u + P["usb_slot_w"] / 2.0
     z1 = ft + P["fb_standoff_h"] + P["usb_slot_top_margin"] + P["usb_slot_z_offset"]  # top — slaved to the board + offset
     z0 = z1 - P["usb_slot_h"]                                # rectangle bottom (flat, prints clean)
     if P["usb_roof_45"]:
         hw = (u1 - u0) / 2.0                             # 45° apex: rises half the width above z1
         prof = [(u0, z0), (u1, z0), (u1, z1), ((u0 + u1) / 2.0, z1 + hw), (u0, z1)]
     else:
         prof = [(u0, z0), (u1, z0), (u1, z1), (u0, z1)]   # plain rectangle (supports needed)
     return prof if signed_area(prof) < 0 else prof[::-1]  # force CW (hole winding)
 
 
 def _vwall_with_window(const, rect_uv, hole_cw, outward, plane="x"):
     """A FLAT vertical wall face at a constant coordinate, carrying a CW hole in a CCW
     rectangle (ear-clip + hole-bridge, the same machinery as the lid window), then lifted
     to 3D. plane="x": face at x=const, (u,v)=(y,z), normal (outward,0,0) — the +x/right
     wall. plane="y": face at y=const, (u,v)=(x,z), normal (0,outward,0) — the −y/bottom
     wall. The hole boundary edges land exactly on the tunnel quads, and the rectangle
     boundary edges land on the loop walls / skirt / rim that surround this run — watertight."""
     tris2d = _earclip(_bridge_holes(ensure_ccw(list(rect_uv)), [hole_cw]))
     if plane == "x":
         lift = lambda u, v: (const, u, v); tgt = (outward, 0, 0)
     else:
         lift = lambda u, v: (u, const, v); tgt = (0, outward, 0)
     return [_orient(lift(*a), lift(*b), lift(*c), tgt) for a, b, c in tris2d]
 
 
 def usb_tunnel(hole_cw, c_out, c_in, plane="x"):
     """The slot passage: one quad per hole edge, bridging the exterior hole (const=c_out)
     to the interior hole (const=c_in). Normals face INTO the passage (toward the hole's
     centroid), like a clearance-hole wall. plane="x": (u,v)=(y,z) at constant x. plane="y":
     (u,v)=(x,z) at constant y. Shares every hole edge with the two windowed faces."""
     k = len(hole_cw)
     cu = sum(p[0] for p in hole_cw) / k; cv = sum(p[1] for p in hole_cw) / k
     lift = (lambda c, u, v: (c, u, v)) if plane == "x" else (lambda c, u, v: (u, c, v))
     tris = []
     for i in range(k):
         j = (i + 1) % k
         Pi, Pj = hole_cw[i], hole_cw[j]
         A = lift(c_out, Pi[0], Pi[1]); B = lift(c_out, Pj[0], Pj[1])
         C = lift(c_in, Pj[0], Pj[1]);  D = lift(c_in, Pi[0], Pi[1])
         mu = (Pi[0] + Pj[0]) / 2.0; mv = (Pi[1] + Pj[1]) / 2.0
         tgt = (0, cu - mu, cv - mv) if plane == "x" else (cu - mu, 0, cv - mv)
         tris.append(_orient(A, B, C, tgt)); tris.append(_orient(A, C, D, tgt))
     return tris
 
 
 def _subdiv_rect(u0, v0, u1, v1, nu, nv):
     """CCW rectangle perimeter subdivided on an nu×nv grid — shares every vertex with a
     honeycomb_region of the same metrics, so a face that bridges this as a hole stitches to
     the field cells with NO T-junctions."""
     cw = (u1 - u0) / nu; ch = (v1 - v0) / nv
     pts  = [(u0 + i * cw, v0) for i in range(nu)]          # bottom L→R
     pts += [(u1, v0 + j * ch) for j in range(nv)]          # right  B→T
     pts += [(u0 + (nu - i) * cw, v1) for i in range(nu)]   # top    R→L
     pts += [(u0, v1 - j * ch) for j in range(nv)]          # left   T→B
     return pts
 
 
 def _vwall_cap(const, rect_uv, holes_cw, outward, plane="x"):
     """Like _vwall_with_window but robust for a many-vertex hole: ear-clip with the
     area-check + _triangulate fallback (cf. cap_with_holes), then lift to 3D. plane "x"
     → face at x=const, (u,v)=(y,z); plane "y" → y=const, (u,v)=(x,z)."""
     outer = ensure_ccw(list(rect_uv))
     if holes_cw:
         poly = _dedup(_bridge_holes(outer, holes_cw))
         tris2d = _earclip(poly)
         want = abs(signed_area(poly))
         got = sum(abs(_tri_area2(a, b, c)) for a, b, c in tris2d) / 2.0
         if len(tris2d) < len(poly) - 2 or abs(got - want) > 1e-3 * max(1.0, want):
             tris2d = _triangulate(poly)
     else:
         tris2d = _earclip(outer)
     lift = (lambda u, v: (const, u, v)) if plane == "x" else (lambda u, v: (u, const, v))
     tgt = (outward, 0, 0) if plane == "x" else (0, outward, 0)
     return [_orient(lift(*a), lift(*b), lift(*c), tgt) for a, b, c in tris2d]
 
 
 def wall_vent(layout, W, H, side, ft, ext_z0, top, r, r_in):
     """Honeycomb vent through one side ('+x' / '-x') wall of the B tray. The field is an
     INSET box in the wall's (y,z) plane — flat-top hexes (support-free up a vertical wall).
     Build the cells in a canonical honeycomb box (its x→wall-y, y→wall-z, z→wall-thickness)
     then rotate (hx,hy,hz)→(hz,hx,hy) into place (a det=+1 cyclic swap → normals survive).
     The exterior + interior faces are rebuilt here as `wall-run rect minus the field hole`
     (a single hole → robust), the hole subdivided on the cell grid so it stitches to the
     cells. The caller SKIPS this wall's straight run in _side_wall. [] when off / not B."""
     if not (P["vent_walls"] and layout == "B"):
         return []
     wt = P["wall_t"]
     m = P["vent_wall_margin"]; bd = wt + P["boss_r"]
     uf0 = bd + P["boss_r"] + m;  uf1 = H - bd - P["boss_r"] - m       # along-wall (y): clear both corners
     vf0 = ft + m;                vf1 = top - m                        # up (z): above floor, below rim
     if side == "+x":
         zt0, zt1 = W - wt, W                  # thickness span (→ wall x); z1 cap (normal +z→+x) = exterior
         x_out, s_out, x_in, s_in = W, +1, W - wt, -1
     else:                                     # "-x": z0 cap (normal −z→−x) at x=0 = exterior
         zt0, zt1 = 0.0, wt
         x_out, s_out, x_in, s_in = 0.0, -1, wt, +1
     cells, vmeta = honeycomb_region(uf0, vf0, uf1, vf1, zt0, zt1, P["vent_hex_flats"], P["vent_wall"])
     cells = [tuple((p[2], p[0], p[1]) for p in tri) for tri in cells]   # rotate canonical → wall (x,y,z)
     x0, y0, x1, y1, nx, ny, cw, ch = vmeta
     fh_cw = _subdiv_rect(x0, y0, x1, y1, nx, ny)[::-1]                  # field perimeter as a CW hole
     ext_rect = [(r, ext_z0), (H - r, ext_z0), (H - r, top), (r, top)]              # exterior run (y,z)
     in_rect  = [(wt + r_in, ft), (H - wt - r_in, ft), (H - wt - r_in, top), (wt + r_in, top)]
     tris  = cells
     tris += _vwall_cap(x_out, ext_rect, [fh_cw], s_out, "x")           # exterior face + field hole
     tris += _vwall_cap(x_in,  in_rect,  [fh_cw], s_in,  "x")           # cavity face + field hole
     return tris
 
 
 def _chamfer_inset(W, H, r, seg, c):
     """The outer rounded-rect inset by `c` on every side — same `seg`, so it carries
     the SAME point count as the full outer and the two stitch index-to-index for a
     bevel skirt. Corner radius shrinks with the inset (clamped ≥0.5)."""
     return ensure_ccw(rounded_rect(c, c, W - c, H - c, max(0.5, r - c), seg))
 
 
 def _skirt(lo, hi, zlo, zhi, zdir):
     """45° bevel band linking loop `lo` @zlo (the inset face edge) to loop `hi` @zhi
     (the full-size wall foot) — matched point counts. Normals face outward AND along
     zdir (−1 = a front/underside chamfer, facing down-and-out). This is the softened
     case edge; the wall continues vertically from `hi` above it."""
     k = len(lo)
     cx = sum(p[0] for p in lo) / k; cy = sum(p[1] for p in lo) / k
     tris = []
     for i in range(k):
         j = (i + 1) % k
         A = (lo[i][0], lo[i][1], zlo); B = (lo[j][0], lo[j][1], zlo)
         C = (hi[j][0], hi[j][1], zhi); D = (hi[i][0], hi[i][1], zhi)
         mx = (lo[i][0] + lo[j][0]) / 2.0; my = (lo[i][1] + lo[j][1]) / 2.0
         tgt = (mx - cx, my - cy, zdir)
         tris.append(_orient(A, B, C, tgt)); tris.append(_orient(A, C, D, tgt))
     return tris
 
 
 def front_vent_regions(layout, W, H, cx, cy, bx, bhw):
     """Honeycomb bottom grille on the lid: a hex strip below the OLED window, split into two
     by the case button. It sits below the guide-collar footprint and inside the corner bosses,
     reached by a slit up from the bottom edge (the v1.22 keyhole). Returns (regions, keepc):
     keepc = boss + peg centres left solid. B only — A's centred window leaves no clean band.
     vent_front is OFF since v1.45, so this now only positions the two front portholes."""
     if layout != "B":
         return [], []
     m, g = P["vent_front_margin"], P["vent_front_gap"]
     col_hh = P["oled_pcb_h"] / 2.0 + P["guide_clearance"] + P["collar_extra_h"] / 2.0 + P["guide_t"]
     col_y0 = cy - col_hh
     by0, by1 = m, col_y0 - g                          # below the collar footprint
     bd = P["wall_t"] + P["boss_r"]                     # corner-boss inset from the edge
     x0, x1 = bd + P["vent_keepout_r"] + 1.0, W - bd - P["vent_keepout_r"] - 1.0   # clear the bosses
     regions = []
     if bx is not None:                                # split around the case button
         regions.append((x0, by0, bx - bhw - g, by1))
         regions.append((bx + bhw + g, by0, x1, by1))
     else:
         regions.append((x0, by0, x1, by1))
     keepc = list(boss_positions(W, H))                # 4 corner M3 bosses
     dx, dy = P["oled_mount_w"] / 2.0, P["oled_mount_h"] / 2.0
     keepc += [(cx + sx * dx, cy + sy * dy) for sx in (-1, 1) for sy in (-1, 1)]   # 4 OLED pegs
     return regions, keepc
 
 
 def make_front(layout):
     """Front bezel / LID: rounded plate with a true display-window hole, the M3
     screw bosses (posts standing into the cavity — back insertion: screws come up
     from the rear through the tray floor into these), and a single centred lanyard
     loop. Clean front face — no screw heads on the screen side."""
     W, H = plate_outline(layout)
     t = P["plate_t"]; r = P["corner_r"]; seg = P["corner_seg"]
 
     win_w = P["oled_glass_w"] + 2 * P["window_clearance"] + P["window_extra_w"]   # glass passthrough (rectangular)
     win_h = P["oled_glass_h"] + 2 * P["window_clearance"] + P["window_extra_h"]
 
     # OLED centered in A; in the top band for B
     if layout == "A":
         cx, cy = W / 2.0, H / 2.0
     else:
         cx = W / 2.0
         cy = H - P["edge_margin"] - P["oled_pcb_h"] / 2.0
 
     wx0, wx1 = cx - win_w / 2.0, cx + win_w / 2.0
     wy0, wy1 = cy - win_h / 2.0, cy + win_h / 2.0
 
     outer = ensure_ccw(rounded_rect(0, 0, W, H, r, seg))
     window = ensure_ccw([(wx0, wy0), (wx1, wy0), (wx1, wy1), (wx0, wy1)])
 
     # v1.14: lid plate as a MULTI-hole slab (cap_with_holes — the same machinery as
     # the tray floor's screw holes) instead of the single-hole annulus, so it can
     # carry the display window AND the round front-button hole together.
     holes = [list(reversed(window))]                     # CW hole loops
     btn_cx = None                                        # case-button centre (splits the bottom vent)
     if P["btn_hole"]:
         hh_out = (P["oled_pcb_h"] / 2.0 + P["guide_clearance"]
                   + P["collar_extra_h"] / 2.0 + P["guide_t"])
         band_lo = P["wall_t"]                            # inner face of the bottom wall
         band_hi = cy - hh_out                            # bottom edge of the guide collar
         if band_hi - band_lo >= P["btn_hole_d"] + 3.0:   # hole + ~1.5mm web each side
             bx, by = W / 2.0, (band_lo + band_hi) / 2.0
             holes.append(_hole_loop(bx, by, P["btn_hole_d"] / 2.0, P["boss_seg"]))
             btn_cx = bx
     # v1.40: a centred row of Ø5 through-holes across the top band (B), replacing the old top text.
     # Skip any hole that can't clear the two top corner M3 bosses (keeps it safe if n/pitch change).
     # Each placed hole also seats a vertex on the top edge straight above it (top_xs → _with_top),
     # so it bridges with a short vertical slit instead of a self-crossing diagonal to a far corner.
     top_xs = []
     if P["top_holes"] and layout == "B":
         n, pitch, hy = P["top_hole_n"], P["top_hole_pitch"], P["top_hole_y"]
         hr = P["top_hole_d"] / 2.0
         min_boss = P["boss_r"] + hr + 1.0                 # ≥1mm web to a boss post
         for i in range(n):
             hx = W / 2.0 + (i - (n - 1) / 2.0) * pitch
             if all((hx - bxx) ** 2 + (hy - byy) ** 2 >= min_boss ** 2 for bxx, byy in boss_positions(W, H)):
                 holes.append(_hole_loop(hx, hy, hr, P["top_hole_seg"]))
                 top_xs.append(hx)
     # v1.45: large round holes where the front honeycomb grille used to be — one centred in each of
     # the two grille bands flanking the button (reuses front_vent_regions for placement). Each seats a
     # bottom-edge vertex below it (front_xs → _with_base) so it bridges straight down, not across.
     front_xs = []
     if P["front_holes"] and layout == "B":
         fr = P["front_hole_d"] / 2.0
         regions, _ = front_vent_regions(layout, W, H, cx, cy, btn_cx, P["btn_hole_d"] / 2.0)
         for rx0, ry0, rx1, ry1 in regions:
             fx, fy = (rx0 + rx1) / 2.0, (ry0 + ry1) / 2.0
             fx += (-1.0 if fx < W / 2.0 else 1.0) * P["front_hole_dx"]   # v1.47: toward the nearer L/R edge
             fy += P["front_hole_dy"]                                     #         and up
             holes.append(_hole_loop(fx, fy, fr, P["front_hole_seg"]))
             front_xs.append(fx)
         if btn_cx is not None:
             front_xs.append(btn_cx)                      # seat the button's bottom bridge too (no vent notch now)
     # v1.23: honeycomb grille. Each region is a per-cell hex panel (0→t, watertight by
     # construction); its rectangular boundary is spliced into BOTH lid caps as a notch
     # reached by one slit up from the bottom edge (the v1.22 back-floor keyhole), so the
     # caps only bridge the real window/button holes. The slit BASE of every region is shared
     # into the outer + chamfer-inset outlines (_with_base) so the skirt/rim stitch with no
     # T-junction. The converging slits make cap_with_holes fall back to _triangulate.
     vmetas, slit_xs, vent_cells = [], [], []
     if P["vent_front"]:
         regions, keepc = front_vent_regions(layout, W, H, cx, cy, btn_cx, P["btn_hole_d"] / 2.0)
         kr2 = P["vent_keepout_r"] ** 2
         keep = lambda X, Y: any((X - kx) ** 2 + (Y - ky) ** 2 < kr2 for kx, ky in keepc)
         ncols = P["vent_front_btn_clear_cols"]            # innermost columns to leave SOLID beside the button
         split = btn_cx is not None and len(regions) == 2  # left/right fields flank the button
         pitch = P["vent_hex_flats"] + P["vent_wall"]
         for ridx, (rx0, ry0, rx1, ry1) in enumerate(regions):
             rkeep = keep
             if split and ncols > 0:                       # v1.39: button-side column(s) → solid (no hex)
                 nx_r = max(1, int(round((rx1 - rx0) / pitch)))
                 cw_r = (rx1 - rx0) / nx_r                 # SAME metric honeycomb_region uses → other cells untouched
                 if ridx == 0:                             # LEFT field → its rightmost (button-adjacent) column
                     thr = rx1 - ncols * cw_r
                     rkeep = (lambda bk, x_: lambda X, Y: bk(X, Y) or X > x_)(keep, thr)
                 else:                                     # RIGHT field → its leftmost (button-adjacent) column
                     thr = rx0 + ncols * cw_r
                     rkeep = (lambda bk, x_: lambda X, Y: bk(X, Y) or X < x_)(keep, thr)
             cells, vm = honeycomb_region(rx0, ry0, rx1, ry1, 0.0, t,
                                          P["vent_hex_flats"], P["vent_wall"], rkeep)
             nx = vm[4]
             sidx = max(1, min(nx - 1, nx // 2))          # interior slit column (perpendicular)
             vent_cells += cells
             vmetas.append((vm, sidx))
             slit_xs.append(vm[0] + sidx * vm[6])
 
     def based(ol):                                       # share each slit base with skirt/rim
         for sx in slit_xs:
             ol = _with_base(ol, sx)
         for hx in top_xs:                                # seat a vertex above each top-band hole
             ol = _with_top(ol, hx)
         for fx in front_xs:                              # seat a vertex below each front porthole / button
             ol = _with_base(ol, fx)
         if front_xs:                                     # front holes present → seat a TOP vertex above the
             ol = _with_top(ol, cx)                       # window centre so it bridges UP, not down through the button
         return ol
 
     def facecap(outline, z, updir):                      # splice every notch, then cap + bridge holes
         ol = outline
         for vm, sidx in vmetas:
             ol = splice_vent_notch(ol, vm, sidx)
         return cap_with_holes(ol, holes, z, updir)
 
     # v1.18: chamfer the exposed FRONT face↔rim edge (z=0). The front face shrinks
     # to an inset outline, a 45° skirt ramps out to full size over `c`, and the rim
     # wall starts at z=c. Holes (window/button) sit far from the perimeter, so they
     # keep full-height walls untouched. The inner face (z=t, the lid↔tray seam) stays
     # square for a flush seat.
     c = P["chamfer_size"] if P["chamfer"] else 0.0
     outer_b = based(outer)                               # bottom edge carries the shared slit bases
     if 0 < c < t:
         outer_in = based(_chamfer_inset(W, H, r, seg, c))
         tris  = facecap(outer_in, 0, (0, 0, -1))         # inset front face + vent notches
         tris += _skirt(outer_in, outer_b, 0, c, -1)      # 45° bevel
         tris += _side_wall(outer_b, c, t, True)          # rim above the bevel
     else:
         tris  = facecap(outer_b, 0, (0, 0, -1))          # front face + vent notches
         tris += _side_wall(outer_b, 0, t, True)          # plate rim
     tris += facecap(outer_b, t, (0, 0, 1))   # inner face (seam side — square) + vent notches
     for h in holes:
         tris += _side_wall(h, 0, t, False)               # window + button hole walls
     tris += vent_cells                                   # honeycomb cells fill the notches
     # bosses live on the LID for back insertion — posts spanning the cavity, bore
     # opening at the tip (which meets the tray floor when assembled).
     tris += screw_bosses(W, H, t, t + cavity_depth(layout))
     if P["ear_front"]:
         tris += ear((W - P["ear_w"]) / 2.0, H, t)   # single centred lanyard loop
     # LID top band (above the window/collar, clear of the top corner bosses): the maker URL,
     # band-centred in the 5x7 pixel font (v1.51). px 0.8 → 5.6mm glyphs, ~the 7-seg version
     # height, with a ~71mm run centred in the 76mm clear span. Inner face → hidden on teardown,
     # and it prints clean (the lid prints face-DOWN, so this face is UP). The build-number is
     # NOT duplicated here anymore; the TRAY carries it (above the FB) for teardown ID. A blank
     # tag falls back to the 7-seg version stamp. v1.40: skipped when the top-hole row owns this band (B).
     if not (P["top_holes"] and layout == "B"):
         if P["maker_tag"]:
             upx = P["maker_tag_px"]
             uox = W / 2.0 - _text_run_len(P["maker_tag"], upx, 1.0) / 2.0   # centred on the plate midline (= band centre)
             uoy = (H - 2.0) - 7 * upx                                       # ascender tops flush ~2mm below the top edge
             tris += pixel_text(P["maker_tag"], uox, uoy, (1.0, 0.0), (0.0, 1.0),
                                t, t + P["imprint_h"], upx)
         else:
             tris += imprint_text(P["case_version"].lstrip("v") + layout, 12.0, H - P["imprint_digit_h"] - 2.0, t)
     # OLED registration ridges on the inner face — notch the top bar around any top-band holes
     collar_gaps = [(hx, P["top_hole_d"] / 2.0 + 0.6) for hx in top_xs]
     tris += guide_collar(cx, cy, t, top_gaps=collar_gaps)
     tris += oled_pegs(cx, cy, t)      # OLED mounting pegs (measured #13 pattern)
     # v1.30: the front face stays FLAT — raised text broke face-down FDM printing (it would sit
     # below the bed). The front text is now a SEPARATE colour-inlay mesh (make_front_text →
     # *_front_text.stl), extruded INTO the face, to drop into an AMS slice as a 2nd-filament part.
     return tris
 
 
 def _reflect_x(tris, xm):
     """Mirror geometry across the vertical plane x=xm (x → 2·xm − x). Reflection reverses
     orientation, so swap two vertices per triangle to keep normals pointing outward."""
     out = []
     for a, b, c in tris:
         ra = (2 * xm - a[0], a[1], a[2])
         rb = (2 * xm - b[0], b[1], b[2])
         rc = (2 * xm - c[0], c[1], c[2])
         out.append((ra, rc, rb))                         # swap b,c to restore winding
     return out
 
 
 def front_text_tris(layout, z0, z1):
     """The front-face pixel text as glyph boxes spanning z0→z1, in the solid bands the grille
     leaves clear: TOP horizontal above the window, SIDES vertical alongside it (left reads up,
     right down). Factored out so the colour-inlay mesh and any future inline use share one
     placement. B-tuned; A renders too. "" zones are skipped.
 
     MIRROR: the lid prints face-DOWN, so the show face is viewed along +z — where +x runs left,
     which mirrors text laid out +x-right. Each block is reflected about its OWN x-centre, so it
     reads correctly from the front while staying in its band (top centred, left at −x, right +x)."""
     if not P["front_text"]:
         return []
     W, H = plate_outline(layout)
     if layout == "A":
         cx, cy = W / 2.0, H / 2.0
     else:
         cx, cy = W / 2.0, H - P["edge_margin"] - P["oled_pcb_h"] / 2.0
     win_w = P["oled_glass_w"] + 2 * P["window_clearance"] + P["window_extra_w"]
     win_h = P["oled_glass_h"] + 2 * P["window_clearance"] + P["window_extra_h"]
     wx0, wx1, wy1 = cx - win_w / 2.0, cx + win_w / 2.0, cy + win_h / 2.0
     px, cg, m = P["front_text_px"], P["front_text_col_gap"], 2.0
 
     def placed(s, ox, oy, run, rise):                    # render a block, then un-mirror in place
         blk = pixel_text(s, ox, oy, run, rise, z0, z1, px, cg)
         if not blk:
             return []
         xs = [v[0] for tr in blk for v in tr]
         return _reflect_x(blk, (min(xs) + max(xs)) / 2.0)
 
     tris = []
     if P["front_text_top"]:                              # horizontal, centred above the window
         s = P["front_text_top"]
         ox = (W - _text_run_len(s, px, cg)) / 2.0
         oy = (wy1 + (H - m)) / 2.0 - 3.5 * px            # centre the 7px glyph in the top band
         tris += placed(s, ox, oy, (1.0, 0.0), (0.0, 1.0))
     if P["front_text_left"]:                             # vertical, reading up the left band
         s = P["front_text_left"]
         oy = cy - _text_run_len(s, px, cg) / 2.0
         ox = (m + (wx0 - 1.5)) / 2.0 + 3.5 * px          # centre the 7px glyph across the band
         tris += placed(s, ox, oy, (0.0, 1.0), (-1.0, 0.0))
     if P["front_text_right"]:                            # vertical, reading down the right band
         s = P["front_text_right"]
         oy = cy + _text_run_len(s, px, cg) / 2.0
         ox = ((wx1 + 1.5) + (W - m)) / 2.0 - 3.5 * px
         tris += placed(s, ox, oy, (0.0, -1.0), (1.0, 0.0))
     return tris
 
 
 def make_front_text(layout):
     """Front-face colour INLAY: the pixel text extruded from the face (z=0) INTO the plate by
     front_text_h, as a standalone mesh (disjoint closed glyph boxes → passes the watertight
     check). It OVERLAPS the flat lid; in the slicer, add it as a part of the lid object and
     assign your 2nd filament — the slicer colours the glyph volume, the face stays flat, and it
     prints face-down (the inlay is the bottom layers). 'Multi-colour by parts'."""
     return front_text_tris(layout, 0.0, P["front_text_h"])
 
 
 def make_back(layout):
     """Back piece / TRAY (walls on, default): floor + rounded perimeter walls, open
     to the front so the boards drop in. For BACK insertion the screw bosses live on
     the lid, so the floor carries the M3 screw-shank CLEARANCE holes (heads sit on
     the back). Single centred lanyard loop. Built as one closed solid: underside
     floor + outer walls + top rim (lid seat) + inner cavity walls + cavity floor,
     with clearance holes punched through the floor. walls off → v0 flat slab."""
     W, H = plate_outline(layout)
     t = P["plate_t"]; r = P["corner_r"]; seg = P["corner_seg"]
 
     if not P["walls"]:
         poly = ensure_ccw(rounded_rect(0, 0, W, H, r, seg))
         tris = prism(poly, 0, t)
         if P["ear_back"]:
             tris += ear((W - P["ear_w"]) / 2.0, H, t)   # single centred lanyard loop
         return tris
 
     wt = P["wall_t"]
     r_in = max(0.5, r - wt)
     outer = ensure_ccw(rounded_rect(0, 0, W, H, r, seg))
     inner = ensure_ccw(rounded_rect(wt, wt, W - wt, H - wt, r_in, seg))  # same pt count
     ft = t                                # floor thickness
     top = ft + cavity_depth(layout)       # wall top = lid seat
 
     # back-insertion: screws come up through the floor into the lid bosses, so the
     # floor carries 4 clearance holes (bosses themselves now live on the lid).
     clr = [_hole_loop(cx, cy, P["boss_clear_r"], P["boss_seg"]) for cx, cy in boss_positions(W, H)]
 
     # honeycomb vent field: a per-cell hex panel filling a margin-inset rect of the
     # floor, cells left solid near the screw bosses + FB standoffs. It's a coplanar
     # section of the floor slab (0→ft); its perimeter is punched as ONE subdivided hole
     # in both floor faces (floor_holes, below) and the cells fill it (no perimeter wall —
     # continuous slab). The screw-hole WALLS stay on `clr` only.
     vents_tris, vmeta = [], None
     if P["vent_back"]:
         m = P["vent_margin"]
         keepc = list(boss_positions(W, H)) + fb_standoff_positions(layout, W, H)
         kr2 = P["vent_keepout_r"] ** 2
         bk = battery_keepout_rect(layout, W, H)          # keep the floor SOLID under the battery collar
         in_bat = (lambda cx, cy: bk[0] <= cx <= bk[2] and bk[1] <= cy <= bk[3]) if bk else (lambda cx, cy: False)
         keep = lambda cx, cy: in_bat(cx, cy) or any((cx - kx) ** 2 + (cy - ky) ** 2 < kr2 for kx, ky in keepc)
         vents_tris, vmeta = honeycomb_region(wt + m, wt + m, W - wt - m, H - wt - m,
                                              0.0, ft, P["vent_hex_flats"], P["vent_wall"], keep)
 
     # the floor caps get the vent spliced in as a NOTCH (keyhole) so they only bridge
     # the corner screw holes (clr); the cells (vents_tris) fill the notch. The slit base
     # is shared (via _with_base) with the skirt/walls/rim so there's no T-junction there.
     slit_x = (vmeta[0] + (vmeta[4] // 2) * vmeta[6]) if vmeta else None
     based = (lambda ol: _with_base(ol, slit_x)) if vmeta else (lambda ol: ol)
     def floorcap(outline, z, updir):
         ol = splice_vent_notch(outline, vmeta, vmeta[4] // 2) if vmeta else outline
         return cap_with_holes(ol, clr, z, updir)
     # v1.18: chamfer the exposed BACK face↔wall edge (z=0), mirroring the lid front.
     # Clearance holes sit ~5.5mm in (well clear of a ≤1.5mm inset); the top rim (the
     # lid seat) stays square.
     # v1.20: a real USB-C through-slot — its STRAIGHT run is skipped in both the exterior
     # and interior loop walls; in its place go two windowed faces (flat verticals carrying
     # the slot hole) joined by a tunnel. The hole boundary stitches to the tunnel, the
     # rectangle boundary to the surrounding walls/skirt/rim. v1.33: the wall is set by
     # usb_wall — "+x" (right) skips the +x run; "-y" (bottom) skips the bottom run (and the
     # rebuilt bottom faces re-thread the vent-slit base vertex so the floor-cap notch still
     # stitches). eps>0 isolates the straight edge(s); adjacent corner-arc points fall short.
     penta = usb_slot_profile(layout, W, H, ft)
     eps = 1e-6
     usb_w = P["usb_wall"] if layout == "B" else "+x"     # A (centered backup) stays on the +x wall
     vw = P["vent_walls"] and layout == "B"               # hex-vent the −x/+x side walls (rebuilt below)
     o_conds, i_conds = [], []                            # straight runs to SKIP, rebuilt as windowed/vented faces
     if penta and usb_w == "-y":                          # USB on the bottom wall: skip the y≈0 / y≈wt runs
         o_conds.append(lambda a, b: a[1] < eps and b[1] < eps)
         i_conds.append(lambda a, b: a[1] < wt + eps and b[1] < wt + eps)
     elif penta:                                          # USB on the +x/right wall (v1.32 / A)
         o_conds.append(lambda a, b: a[0] > W - eps and b[0] > W - eps)
         i_conds.append(lambda a, b: a[0] > (W - wt) - eps and b[0] > (W - wt) - eps)
     if vw:                                               # +x and −x runs → vented faces (wall_vent)
         o_conds.append(lambda a, b: a[0] > W - eps and b[0] > W - eps)
         o_conds.append(lambda a, b: a[0] < eps and b[0] < eps)
         i_conds.append(lambda a, b: a[0] > (W - wt) - eps and b[0] > (W - wt) - eps)
         i_conds.append(lambda a, b: a[0] < wt + eps and b[0] < wt + eps)
     skip_o = (lambda a, b: any(c(a, b) for c in o_conds)) if o_conds else None
     skip_i = (lambda a, b: any(c(a, b) for c in i_conds)) if i_conds else None
 
     # v1.18: chamfer the exposed BACK face↔wall edge (z=0), mirroring the lid front.
     # Clearance holes sit ~5.5mm in (well clear of a ≤1.5mm inset); the top rim (the
     # lid seat) stays square.
     c = P["chamfer_size"] if P["chamfer"] else 0.0
     outer_b = based(outer)                               # bottom edge carries the shared slit base
     inner_b = based(inner)
     if 0 < c < ft:
         outer_in = based(_chamfer_inset(W, H, r, seg, c))
         tris  = floorcap(outer_in, 0.0, (0, 0, -1))             # inset underside floor + vent notch
         tris += _skirt(outer_in, outer_b, 0.0, c, -1)           # 45° bevel
         tris += _side_wall(outer_b, c, top, True, skip=skip_o)  # exterior walls above the bevel
         ext_z0 = c
     else:
         tris  = floorcap(outer_b, 0.0, (0, 0, -1))              # underside floor + screws + vent notch
         tris += _side_wall(outer_b, 0.0, top, True, skip=skip_o)  # exterior walls (full height)
         ext_z0 = 0.0
     tris += _ring_cap(outer_b, inner_b, top, (0, 0, 1))     # top rim — the lid rests here
     tris += _side_wall(inner_b, ft, top, False, skip=skip_i)  # cavity inner walls
     tris += floorcap(inner_b, ft, (0, 0, 1))                # cavity floor + screws + vent notch
     for h in clr:
         tris += _side_wall(h, 0.0, ft, False)            # clearance-hole walls (face into the hole)
     tris += vents_tris                                   # honeycomb vent cells (fill the punched region)
     if vw:                                               # hex vents through the −x/+x side walls (B)
         tris += wall_vent(layout, W, H, "+x", ft, ext_z0, top, r, r_in)
         tris += wall_vent(layout, W, H, "-x", ft, ext_z0, top, r, r_in)
     if penta and usb_w == "+x":                          # USB-C slot replaces the skipped +x run
         ext_rect = [(r, ext_z0), (H - r, ext_z0), (H - r, top), (r, top)]   # +x exterior face (y,z)
         in_rect  = [(wt + r_in, ft), (H - wt - r_in, ft),                   # +x interior face (y,z)
                     (H - wt - r_in, top), (wt + r_in, top)]
         tris += _vwall_with_window(W, ext_rect, penta, +1)       # exterior face + hole (faces +x)
         tris += _vwall_with_window(W - wt, in_rect, penta, -1)   # cavity face + hole (faces −x)
         tris += usb_tunnel(penta, W, W - wt)                     # the slot passage walls
     elif penta:                                          # "-y" bottom wall — faces in the (x,z) plane
         def _yrect(xL, xR, zb):                          # CCW (x,z) face; vent-slit vertex on BOTH horizontal
             s = slit_x if (slit_x is not None and xL + eps < slit_x < xR - eps) else None
             bot  = [(xL, zb), (s, zb), (xR, zb)] if s is not None else [(xL, zb), (xR, zb)]     # ← floor cap/skirt
             top_ = [(xR, top), (s, top), (xL, top)] if s is not None else [(xR, top), (xL, top)]  # ← ring rim
             return bot + top_
         ext_rect = _yrect(r, W - r, ext_z0)                         # −y exterior (x,z)
         in_rect  = _yrect(wt + r_in, W - wt - r_in, ft)             # −y interior (x,z)
         tris += _vwall_with_window(0.0, ext_rect, penta, -1, "y")   # exterior bottom face (faces −y)
         tris += _vwall_with_window(wt, in_rect, penta, +1, "y")     # cavity bottom face (faces +y)
         tris += usb_tunnel(penta, 0.0, wt, "y")                     # the slot passage walls
     tris += fb_standoffs(layout, W, H, ft)               # FireBeetle M2 standoff bosses
     tris += battery_collar(layout, W, H, ft)             # B-portrait: pouch retention collar (top-right)
     if P["ear_back"]:
         ex = (W - P["ear_w"]) / 2.0                      # centred lanyard tab
         if P["ear_full_depth"]:
             tris += lanyard_tab(ex, H, 0.0, P["plate_t"] + cavity_depth(layout))  # v1.48: end at the tray WALL TOP
             #   (flush with the perimeter walls / lid seat) — no longer runs the extra plate_t to the front face
         else:
             tris += ear(ex, H, t)                        # legacy flat 2mm loop
     # inner-floor marks (v1.50). B-portrait has a solid battery pocket + top/bottom solid
     # strips (the vent field is inset by vent_margin), so all three land on solid floor with
     # no vent surgery: the maker's-mark HOUSE fills the pocket (hidden under the cell); the
     # build-number moves UP above the FireBeetle; the site TAG runs the bottom strip. Other
     # layouts (no pocket) keep the legacy bottom-left build-number.
     vstr = P["case_version"].lstrip("v") + layout
     bfp = battery_footprint(layout, W, H)
     if bfp:
         # maker's house — centred in the pocket
         if P["maker_mark"]:
             hpx = P["maker_px"]
             hw, hh = len(_MAKER_HOUSE[0]) * hpx, len(_MAKER_HOUSE) * hpx
             hox = (bfp[0] + bfp[2]) / 2.0 - hw / 2.0
             hoy = (bfp[1] + bfp[3]) / 2.0 - hh / 2.0
             tris += pixel_art(_MAKER_HOUSE, hox, hoy, ft, ft + P["imprint_h"], hpx)
         # build-number → top solid strip above the FB (vent field ends at H-wt-vent_margin),
         # centred on the board so it reads over the mounting area.
         fbx, _ = fb_board_center(layout, W, H)
         ix = fbx - _imprint_run_len(vstr) / 2.0
         iy = H - P["wall_t"] - 1.0 - P["imprint_digit_h"]
         tris += imprint_text(vstr, ix, iy, ft)
         # v1.51: the site-tag URL moved OFF this bottom strip (0.5mm px was unprintable) up to the
         # LID's top band — see make_front. The pocket now carries just the house + build-number.
     else:
         tris += imprint_text(vstr, 12.0, 2.0, ft)
     return tris
 
 
 def est_weight_g(tris):
     cc = mesh_volume_cc(tris)
     density = _DENSITY_G_CC.get(P["material"], 1.27)
     return cc * density * P["infill"], cc
 
 # ----------------------------------------------------------------------------
 # main
 # ----------------------------------------------------------------------------
 
 def main():
     here = os.path.dirname(os.path.abspath(__file__))
     out = os.path.join(here, "stl")
     os.makedirs(out, exist_ok=True)
 
     ver = P["case_version"]
     rev = git_rev()
     print(f"DefCon badge enclosure — STL generator   case {ver}  (git {rev})")
     print(f"material {P['material']} (~{_DENSITY_G_CC.get(P['material'], 1.27):.2f} g/cc, "
           f"{P['infill']*100:.0f}% fill — weight est. only)")
     _bore = P['boss_hole_insert'] if P['fastener'] == 'insert' else P['boss_hole_selftap']
     print(f"lid fastener: M3 {P['fastener']} (boss Ø{2*P['boss_r']:.0f}mm, bore Ø{2*_bore:.1f}mm)")
     print(f"display window: {P['oled_glass_w']+2*P['window_clearance']+P['window_extra_w']:.1f} x "
           f"{P['oled_glass_h']+2*P['window_clearance']+P['window_extra_h']:.1f} mm (glass passthrough"
           f"{', + guide ridges' if P['guide_ridges'] else ''})")
     if P["btn_hole"]:
         print(f"case button: Ø{P['btn_hole_d']:.1f} mm lid hole below the screen (Twidec PBS-110, "
               f"fit-validated); auto-skipped where the band is too tight")
     if P["oled_pegs"]:
         print(f"oled mount: 4x Ø{P['oled_peg_d']:.1f} pegs @ {P['oled_mount_w']:.2f} x "
               f"{P['oled_mount_h']:.2f} c2c + {P['oled_header_notch_w']:.0f}mm collar notch "
               f"(header edge: screen-right)")
     if P["fb_standoffs"]:
         _orient_note = (f"{P['fb_orient']}, USB → {P['usb_wall']} wall (B); JST faces the battery side"
                         if P['fb_orient'] == 'portrait' else "landscape, USB toward viewer-right")
         print(f"fb standoffs: 4x M2 bosses Ø{2*P['fb_standoff_r']:.1f} (pilot Ø{2*P['fb_pilot_r']:.1f}) "
               f"h={P['fb_standoff_h']:.1f} — components face the floor; {_orient_note}")
     if P["chamfer"]:
         print(f"edge chamfer: {P['chamfer_size']:.1f}mm 45° on the exposed faces "
               f"(lid front + tray back); parting seam left square")
     if P["usb_cutout"]:
         _wall_name = {"-y": "−y/bottom", "+x": "+x/right"}.get(P['usb_wall'], P['usb_wall'])
         print(f"usb-c cutout: {P['usb_slot_w']:.0f}x{P['usb_slot_h']:.1f}mm through-slot in the {_wall_name} wall (B) "
               f"(z slaved to standoffs){', 45° self-supporting roof' if P['usb_roof_45'] else ''}")
     if P["bat_collar"]:
         _notch = f" + {P['bat_notch_w']:.0f}mm JST notch" if P["bat_notch"] else " (no notch)"
         print(f"battery collar (B): full {P['bat_collar_h']:.0f}mm pocket for the {P['bat_w']:.0f}x{P['bat_h']:.0f} pouch, "
               f"hard-right; clearance {P['bat_collar_clear_x']:.1f}/side (x) · {P['bat_collar_clear']:.1f}/side (y){_notch}")
     if P["vent_walls"]:
         print(f"side-wall vents (B): flat-top {P['vent_hex_flats']:.0f}mm hexes through the −x/+x walls, "
               f"inset {P['vent_wall_margin']:.1f}mm border (support-free)")
     if P["imprint"]:
         _lid = f"maker URL '{P['maker_tag']}' @ {P['maker_tag_px']:.1f}mm px" if P["maker_tag"] else "7-seg version"
         print(f"imprint: 7-seg '{P['case_version'].lstrip('v')}' + variant (A/B) on the TRAY inner face; {_lid} on the LID top band")
     if P["front_text"]:
         zt = [z for z in (("top", P["front_text_top"]), ("left", P["front_text_left"]),
                           ("right", P["front_text_right"])) if z[1]]
         print(f"front text: 5x7 pixels @ {P['front_text_px']:.1f}mm px, {P['front_text_h']:.1f}mm colour "
               f"INLAY (→ *_front_text.stl, add as an AMS part) — " + ", ".join(f"{k}='{v}'" for k, v in zt))
     print("=" * 58)
     total_plastic = {"A": 0.0, "B": 0.0}
     for layout in ("A", "B"):
         W, H = plate_outline(layout)
         depth = 2 * P["plate_t"] + cavity_depth(layout)
         label = "Stacked (battery behind)" if layout == "A" else "Coplanar (battery beside)"
         kind = "walled tray + flat lid" if P["walls"] else "flat sandwich"
         print(f"\n[{layout}] {label}")
         print(f"    outer plate : {W:.1f} x {H:.1f} mm  (+ {P['ear_h']:.0f}mm lanyard ears)")
         print(f"    assembled   : ~{depth:.0f} mm deep  ({kind}; "
               f"{cavity_depth(layout):.0f}mm cavity)")
         roles = {"front": "lid", "back": "tray" if P["walls"] else "back", "front_text": "colour inlay"}
         builders = [("front", make_front), ("back", make_back)]
         if P["front_text"]:
             builders.append(("front_text", make_front_text))   # separate AMS 2nd-filament part
         for part, builder in builders:
             tris = builder(layout)
             if not tris:                                       # e.g. front_text with all zones blank
                 continue
             path = os.path.join(out, f"badge_{ver}_{layout}_{part}.stl")
             write_stl(path, tris, f"DEFCON badge case {ver} {P['fastener']} | {layout}_{part}")
             g, cc = est_weight_g(tris)
             bx, by, bz = bbox(tris)
             if part != "front_text":                           # the inlay overlaps the lid — not extra plastic
                 total_plastic[layout] += g
             issues = edge_manifold_issues(tris)
             wt = "watertight" if issues == 0 else f"⚠ {issues} open edges"
             tag = f"{part} ({roles[part]})"
             print(f"    - {tag:<12} {bx:5.1f} x {by:5.1f} x {bz:4.1f} mm  "
                   f"~{g:4.1f} g plastic  [{wt}]  ->  {os.path.relpath(path, here)}")
         # add the fixed payload for a total badge weight guess
         payload = 22 + 38 + 6 + 8   # oled + battery + firebeetle + fasteners
         print(f"    est. TOTAL badge: ~{total_plastic[layout] + payload:.0f} g "
               f"({total_plastic[layout]:.0f} g plastic + {payload} g payload)")
 
     # keep stl/ to the CURRENT version — sweep any prior-version STLs into stl_archive/
     archive = os.path.join(here, "stl_archive")
     moved = 0
     for fn in sorted(os.listdir(out)):
         if fn.startswith("badge_") and fn.endswith(".stl") and f"_{ver}_" not in fn:
             os.makedirs(archive, exist_ok=True)
             os.replace(os.path.join(out, fn), os.path.join(archive, fn))
             moved += 1
     if moved:
         print(f"\narchived {moved} prior-version STL(s) → stl_archive/  (stl/ keeps {ver})")
 
     print("\nNote: LID = window + button hole + M3 bosses + OLED collar/notch/pegs +")
     print("centred loop + imprint; TRAY = floor (screw-clearance holes) + walls + FB")
     print("standoffs (B: portrait, top-left) + USB-C through-slot in the −y/bottom wall +")
     print("a full battery-retention collar (B, top-right) + honeycomb vents in the back floor")
     print("AND the −x/+x side walls (B). Back insertion (heads on the rear). Each part is")
     print("checked for watertightness (every edge shared by exactly two triangles).")
 
 
 if __name__ == "__main__":
     main()