From efd2e551dd727153463d22bd91d5cbe5484e7c3f Mon Sep 17 00:00:00 2001
From: Craig Jennings <c@cjennings.net>
Date: Sat, 18 Jul 2026 10:50:18 -0500
Subject: refactor(gallery): rename GW namespace to DUPRE, kit to The Dupre Kit

The gallery and its library are now The Dupre Kit, named for the dupre color theme. GW was too opaque to remember. The stylesheet id is now dupre-css, the card handle property is .dupre, and page prose says instrument instead of widget. File names stay put. Renaming them is a separate decision.

Historical log entries in todo.org keep their GW references as a record.
---
 docs/prototypes/README.org                         |  52 +--
 docs/prototypes/gallery-widget.el                  |   4 +-
 docs/prototypes/panel-widget-gallery.html          | 356 +++++++++----------
 docs/prototypes/widgets.js                         | 390 ++++++++++-----------
 .../specs/2026-07-12-component-generation-spec.org |  14 +-
 tests/gallery-probes/probe-fams.mjs                |   4 +-
 tests/gallery-probes/probe.mjs                     | 108 +++---
 todo.org                                           |   2 +-
 8 files changed, 465 insertions(+), 465 deletions(-)

diff --git a/docs/prototypes/README.org b/docs/prototypes/README.org
index 1cb75c6..a4f591f 100644
--- a/docs/prototypes/README.org
+++ b/docs/prototypes/README.org
@@ -15,32 +15,32 @@ point at.
   affordance for the NETWORKS/NEARBY headers (busy-style throbber + list fade).
 - [[file:2026-07-03-sound-panel-prototype.html][2026-07-03-sound-panel-prototype.html]] — the audio/pulsemixer console; layout
   reference for [[file:../specs/2026-07-03-audio-panel-spec.org][the audio-panel spec]].
-- [[file:panel-widget-gallery.html][panel-widget-gallery.html]] — the shared instrument-console
-  widget kit (lamps, engraved sections, console keys, needle gauges). The
-  living catalogue: every widget here is the visual + behavioral spec for
-  its reusable-component ports. All widgets build from [[file:widgets.js][widgets.js]] (below);
+- [[file:panel-widget-gallery.html][panel-widget-gallery.html]] — The Dupre Kit: the shared instrument-console
+  gallery (lamps, engraved sections, console keys, needle gauges). The
+  living catalogue: every instrument here is the visual + behavioral spec for
+  its reusable-component ports. All instruments build from [[file:widgets.js][widgets.js]] (below);
   the gallery page is the reference consumer.
 - [[file:2026-07-03-waybar-redesign-prototype.html][2026-07-03-waybar-redesign-prototype.html]] — three directions for sprucing up
   waybar in the dupre instrument-console aesthetic (future work).
 
-* Widget library ([[file:widgets.js][widgets.js]])
+* The Dupre Kit ([[file:widgets.js][widgets.js]])
 
 The whole kit lives in =widgets.js= — a classic script (no modules, no build
-step) exposing the =GW= namespace with one builder per gallery card. Load it
+step) exposing the =DUPRE= namespace with one builder per gallery card. Load it
 with =<script src="widgets.js"></script>= and call builders directly.
 
 ** Builder contract
 
-=GW.name(host, opts)= → handle ={el, get, set, ...}=. =host= is an empty
-element the widget renders into. =opts.onChange(value, text)= fires on every
-state change, including the initial paint; =text= is the widget's canonical
+=DUPRE.name(host, opts)= → handle ={el, get, set, ...}=. =host= is an empty
+element the instrument renders into. =opts.onChange(value, text)= fires on every
+state change, including the initial paint; =text= is the instrument's canonical
 readout string. (Exception: live meters whose original init was silent — they
 paint on the first =set=/=push=.)
 
 ** Styling
 
-Widget-internal CSS ships inside =widgets.js= (the =GW_CSS= block, injected
-once as =<style id="gw-css">= at load), so widgets are fully styled on any
+Instrument-internal CSS ships inside =widgets.js= (the =DUPRE_CSS= block, injected
+once as =<style id="dupre-css">= at load), so instruments are fully styled on any
 page. The design tokens (=--gold=, =--glow-hi=, the amber family, =--mono=,
 =--pulse-rate=, …) must be defined on =:root= by the consumer — the gallery's
 generated =:root= block is the reference; =tokens.json= is the source.
@@ -56,60 +56,60 @@ Live meters expose value-driven handles that repaint synchronously and fire
   the ring buffer)
 - =set(samples, amp)= for sampled traces (samples normalized)
 
-Widget-owned animation (the R17 scope trace, R31 radar sweep, R44 servo
+Instrument-owned animation (the R17 scope trace, R31 radar sweep, R44 servo
 chase, R52 pseudo-PC, R53 day clock, R10 TIME page) runs inside the builder,
 gated on =prefers-reduced-motion=.
 
-** Keyboard contract (widgets that take keys)
+** Keyboard contract (instruments that take keys)
 
 Sibling of the tick contract above, and the same split: focus is an ambient
 resource like the clock — exactly one thing holds it across the whole page —
 so *the target owns focus and delivery, the builder declares what it accepts*.
-Neither half works alone. Only the page knows which widget is live; only the
-widget knows that Backspace means DEL.
+Neither half works alone. Only the page knows which instrument is live; only the
+instrument knows that Backspace means DEL.
 
 *The builder declares* a =KEYS= table on itself, mapping a canonical key name
 to the argument its handle's =press= takes:
 
-: GW.abcKeypad.KEYS = { A:'A', ..., '0':'0', ..., Space:'SPC', Backspace:'DEL', Enter:'ENT' }
+: DUPRE.abcKeypad.KEYS = { A:'A', ..., '0':'0', ..., Space:'SPC', Backspace:'DEL', Enter:'ENT' }
 
 One declaration, wired natively per target:
 
 - *Web* — the builder attaches a =keydown= listener *to its own focusable
-  element* (=tabindex=0=, focused on click). =GW.slideRule= is the precedent:
+  element* (=tabindex=0=, focused on click). =DUPRE.slideRule= is the precedent:
   arrows step it, scoped to its own element. The browser's focus system does
   the arbitration, which is why it doesn't fight the gallery's own global
   Escape handler.
 - *Emacs* — the SVG region is an image and never sees a keypress, so the mode
   installs the same table into its keymap and calls =press=. This is why the
   declaration is a table and not a function over a DOM event: a port that
-  can't read the widget's intent has to re-derive it, and then the two drift.
+  can't read the instrument's intent has to re-derive it, and then the two drift.
 - *waybar* — GTK focus, same shape.
 
 Rules, each of them a bug someone will otherwise ship:
 
-- *Never listen on =document= or =window=.* A widget that does fights every
+- *Never listen on =document= or =window=.* An instrument that does fights every
   sibling and the page's own handlers; on the gallery, every keystroke
   anywhere would type into whichever card bound last.
 - *=preventDefault= only what has a default worth suppressing* — Space scrolls
   the page, Backspace can navigate back. Nothing else.
 - *Let Tab and Escape bubble.* Tab is how the page is navigable at all, and
-  the gallery's audit stepper owns Escape. A widget that swallows either
+  the gallery's audit stepper owns Escape. An instrument that swallows either
   breaks something it can't see.
 - *=press= filters, it does not trust.* A handle that appends whatever it is
   handed will cheerfully append "F1". The table is the allowlist.
 - *Click and key must land in the same place* — both route through =press=, so
   the two paths cannot drift apart or fire different events.
 
-A widget with no =KEYS= table takes no keys, which is most of them: the kit is
+An instrument with no =KEYS= table takes no keys, which is most of them: the kit is
 click-first and that is what makes it port. Keys are additive, and in Emacs
 they are the *more* native idiom, not the less.
 
 ** Style options
 
-Widgets with named style axes take them as constructor opts backed by a
-=STYLES= table on the builder — e.g. =GW.slideToggle(host, {onStyle:'green',
-thumb:'brass'})= with the axes enumerated in =GW.slideToggle.STYLES=, and
+Instruments with named style axes take them as constructor opts backed by a
+=STYLES= table on the builder — e.g. =DUPRE.slideToggle(host, {onStyle:'green',
+thumb:'brass'})= with the axes enumerated in =DUPRE.slideToggle.STYLES=, and
 =handle.setStyle(axis, name)= to restyle a live instance. The gallery's
 option chips are demo rigs driving =setStyle=.
 
@@ -130,8 +130,8 @@ family, glows, pulse rate). [[file:gen_tokens.py][gen_tokens.py]] regenerates al
 - [[file:tokens-waybar.css][tokens-waybar.css]] — GTK =@define-color= declarations for the waybar panels
 - [[file:gallery-tokens.el][gallery-tokens.el]] — an elisp alist for svg.el renderers
 
-[[file:gallery-widget.el][gallery-widget.el]] is the Emacs renderer (proof widget: the needle gauge,
-gallery card 10) — it reads gallery-tokens.el and emits the widget as SVG via
+[[file:gallery-widget.el][gallery-widget.el]] is the Emacs renderer (proof instrument: the needle gauge,
+gallery card 10) — it reads gallery-tokens.el and emits the instrument as SVG via
 svg.el, so the same look renders inside Emacs. Tests:
 =tests/gallery-tokens/= (generator, unittest) and =tests/gallery-widgets/=
 (renderer, ERT), both in =make test-unit=.
diff --git a/docs/prototypes/gallery-widget.el b/docs/prototypes/gallery-widget.el
index 1c96f45..5d69148 100644
--- a/docs/prototypes/gallery-widget.el
+++ b/docs/prototypes/gallery-widget.el
@@ -85,7 +85,7 @@ bottom center, 40px needle sweeping -60..+60 degrees, readout below."
      svg
      (dom-node 'defs nil
                (dom-node 'filter
-                         '((id . "gw-glow") (x . "-75%") (y . "-75%")
+                         '((id . "dupre-glow") (x . "-75%") (y . "-75%")
                            (width . "250%") (height . "250%"))
                          (dom-node 'feGaussianBlur
                                    '((in . "SourceGraphic")
@@ -119,7 +119,7 @@ bottom center, 40px needle sweeping -60..+60 degrees, readout below."
                           :stroke-width "4"
                           :stroke-linecap "round"
                           :opacity "0.55"
-                          :filter "url(#gw-glow)")
+                          :filter "url(#dupre-glow)")
     (gallery-widget--node svg 'line
                           :class "needle"
                           :x1 (gallery-widget--fmt cx)
diff --git a/docs/prototypes/panel-widget-gallery.html b/docs/prototypes/panel-widget-gallery.html
index 9eaf18a..0bf3ab8 100644
--- a/docs/prototypes/panel-widget-gallery.html
+++ b/docs/prototypes/panel-widget-gallery.html
@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Panel widget gallery — dupre instrument console (interactive)</title>
+<title>The Dupre Kit — retro instrument console (interactive)</title>
 <style>
 :root{
 /* @tokens:start */
@@ -72,8 +72,8 @@ h1{color:var(--gold);font-size:1.5rem;margin:.35rem 0 .4rem}
 .toc .scr{position:absolute;width:5px;height:5px;border-radius:50%;
   background:radial-gradient(circle at 35% 30%,#524d43,#161310);box-shadow:0 .5px 0 rgba(255,255,255,.08)}
 html{scroll-behavior:smooth}
-/* WIDGETS/ROW sets an explicit column count (1-4); the stage zoom scales with it
-   so a widget fills its column — fewer per row, bigger widgets. The card text
+/* INSTRUMENTS/ROW sets an explicit column count (1-4); the stage zoom scales with it
+   so an instrument fills its column — fewer per row, bigger instruments. The card text
    stays at its own (slightly raised) size, untouched by the zoom. */
 body[data-cols="1"] .grid{grid-template-columns:1fr}
 body[data-cols="2"] .grid{grid-template-columns:repeat(2,1fr)}
@@ -83,7 +83,7 @@ body[data-cols="1"] .stagew{zoom:2.8}
 body[data-cols="2"] .stagew{zoom:2.1}
 body[data-cols="3"] .stagew{zoom:1.55}
 body[data-cols="4"] .stagew{zoom:1.15}
-/* intrinsically tiny widgets get an extra bump so they do not float in an empty stage */
+/* intrinsically tiny instruments get an extra bump so they do not float in an empty stage */
 .stagew.boost{zoom:1.5}
 body[data-cols="1"] .stagew.boost{zoom:4.2}
 body[data-cols="2"] .stagew.boost{zoom:3.15}
@@ -208,17 +208,17 @@ a.no{text-decoration:none;cursor:pointer}
 <div class="wrap">
 <header class="masthead">
   <div class="eyebrow">archsetup · dupre panel family · live kit</div>
-  <h1>Widget gallery — the instrument-console kit, fully driveable</h1>
+  <h1>The Dupre Kit — the instrument console, fully driveable</h1>
   <div class="mastrow">
   <div class="mastintro">
   <p>Every control + display idiom in the dupre faceplate language, merged into one live console — the base kit,
      the candidate batch, and the growing reference batch (R: modeled on period hardware), all rendering from
      the same tokens the net / bt / sound panels use.
      <b>Controls</b> take input; <b>meters &amp; gauges</b> show a live analog value; <b>indicators &amp;
-     readouts</b> show state or a number. Every widget is operable: drag the faders, knobs and gauges; click the
+     readouts</b> show state or a number. Every instrument is operable: drag the faders, knobs and gauges; click the
      switches, keys and lamps. Each card carries a live readout that tracks what you do. The trace displays run
      a live signal; the pointer types drive from your drag.</p>
-    <div class="szbar"><span class="lab">widgets/row</span>
+    <div class="szbar"><span class="lab">instruments/row</span>
       <button class="key" data-cols="1">1</button>
       <button class="key" data-cols="2">2</button>
       <button class="key on" data-cols="3">3</button>
@@ -240,7 +240,7 @@ a.no{text-decoration:none;cursor:pointer}
     <span class="scr" style="top:6px;left:6px"></span><span class="scr" style="top:6px;right:6px"></span>
     <span class="scr" style="bottom:6px;left:6px"></span><span class="scr" style="bottom:6px;right:6px"></span>
     <div class="tt">Policy</div>
-    <div class="pnote">What each widget's colour is bound by, and what it may change and stay true. Click a row to walk its cards; open a card's spec sheet for the reason and the authentic range.</div>
+    <div class="pnote">What each instrument's colour is bound by, and what it may change and stay true. Click a row to walk its cards; open a card's spec sheet for the reason and the authentic range.</div>
     <div class="vtally ptally" id="ptally"></div>
   </nav>
   </div>
@@ -264,7 +264,7 @@ a.no{text-decoration:none;cursor:pointer}
 <script src="widgets.js"></script>
 <script>
 const $ = id => document.getElementById(id);
-const {svgEl,polar,dragX,dragY,dragDelta,seg7,buildBars,VUDB,vuDb,SCREEN_FAMS}=GW;
+const {svgEl,polar,dragX,dragY,dragDelta,seg7,buildBars,VUDB,vuDb,SCREEN_FAMS}=DUPRE;
 const reduced = matchMedia('(prefers-reduced-motion: reduce)').matches;
 document.querySelectorAll('.szbar .key').forEach(b=>b.addEventListener('click',()=>{
   document.body.dataset.cols=b.dataset.cols;
@@ -275,7 +275,7 @@ document.querySelectorAll('.szbar .key').forEach(b=>b.addEventListener('click',(
   if(!s||!/^[1234]$/.test(s))return;
   document.body.dataset.cols=s;
   document.querySelectorAll('.szbar .key').forEach(k=>k.classList.toggle('on',k.dataset.cols===s));})();
-/* boost the intrinsically tiny widgets (audit: content under 10% of the stage) */
+/* boost the intrinsically tiny instruments (audit: content under 10% of the stage) */
 const BOOST=['01','07','08','12','13','N14','18'];
 
 /* ---- palette: the named instrument colors, grouped by role. No codes shown — names and uses. ---- */
@@ -339,7 +339,7 @@ const PALETTE=[
       host.appendChild(tile);}}
 })();
 
-/* ---- screen-color families: period-authentic alternates for the screen widgets ----
+/* ---- screen-color families: period-authentic alternates for the screen instruments ----
    green  = P1 CRT phosphor (radar/scopes; hi reuses --phos, graticule keeps the kit's scope green)
    amber  = P3 phosphor / backlit amber (the gold family the kit already speaks)
    red    = neon orange-red, the nixie's color pulled out as a family
@@ -348,7 +348,7 @@ const PALETTE=[
    white  = monochrome LCD/CRT white
    Exploration data, deliberately NOT in tokens.json yet — families get tokenized once picked,
    the same way amber earned its tokens. Values keyed by the CSS custom property they drive. */
-/* SCREEN_FAMS lives in widgets.js (GW.SCREEN_FAMS) */
+/* SCREEN_FAMS lives in widgets.js (DUPRE.SCREEN_FAMS) */
 function screenChips(no,el,fams,def){
   const cardEl=el.closest('.card'); if(!cardEl)return;
   const row=document.createElement('div'); row.className='famchips';
@@ -364,9 +364,9 @@ function screenChips(no,el,fams,def){
   cardEl.querySelector('.opts').appendChild(row);
 }
 /* ---- per-card spec sheets ----
-   input      how you drive it, incl. the model: click widgets port to every target (Emacs click-regions
-              included); drag widgets have no Emacs drag equivalent and need a click/key idiom there;
-              display widgets take no input in real use (gallery interaction is demo only).
+   input      how you drive it, incl. the model: click instruments port to every target (Emacs click-regions
+              included); drag instruments have no Emacs drag equivalent and need a click/key idiom there;
+              display instruments take no input in real use (gallery interaction is demo only).
    period     present only when the component is clearly not timeless — use it to keep a console
               period-consistent (swap a modern part for its historical counterpart or vice versa). */
 const INFO={
@@ -1214,26 +1214,26 @@ function auditStop(){const p=$('vaudit');if(p)p.remove();}
 addEventListener('keydown',e=>{if(e.key==='Escape')auditStop();});
 /* card(host, no, name, htmlOrBuild, note) — the declarative card record.
    htmlOrBuild: a legacy stage-HTML string, or a builder function (stage, rd) => handle
-   that instantiates a GW.* widget into the stage; rd(txt) writes the card readout. */
-/* Recover a card's builder from the arrow it was handed — the first GW.<name>(
+   that instantiates a DUPRE.* instrument into the stage; rd(txt) writes the card readout. */
+/* Recover a card's builder from the arrow it was handed — the first DUPRE.<name>(
    in the source — and read its POLICY record off it. Single source: the record
-   lives on GW.<builder>.POLICY in widgets.js and the card only displays it, so the
+   lives on DUPRE.<builder>.POLICY in widgets.js and the card only displays it, so the
    page can't drift from the code. Unclassified cards read '—', which is the point:
    the gallery becomes the colour pass's visible worklist. */
 function cardPolicy(html){
   if(typeof html!=='function') return null;
-  /* Assumes the FIRST GW.<name>( in the arrow is the builder — true because every
-     card is (st,rd)=>GW.builder(st,{...}) and helpers are destructured, called
-     bare. An arrow that referenced a second GW.<name>( before its builder would
+  /* Assumes the FIRST DUPRE.<name>( in the arrow is the builder — true because every
+     card is (st,rd)=>DUPRE.builder(st,{...}) and helpers are destructured, called
+     bare. An arrow that referenced a second DUPRE.<name>( before its builder would
      mis-derive; none do. A wrapped or renamed builder reads '—' rather than
      wrong, which is safe. */
-  const m=html.toString().match(/GW\.(\w+)\s*\(/);
-  return (m && GW[m[1]] && GW[m[1]].POLICY) || null;
+  const m=html.toString().match(/DUPRE\.(\w+)\s*\(/);
+  return (m && DUPRE[m[1]] && DUPRE[m[1]].POLICY) || null;
 }
 function card(host, no, name, html, note){
   const isBuild=typeof html==='function';
   const P=cardPolicy(html), kind=P&&P.kind;
-  const meta=kind&&GW.POLICIES[kind];
+  const meta=kind&&DUPRE.POLICIES[kind];
   const free=meta&&meta.free;
   const polTip=meta?(meta.gist||''):'policy not yet classified';
   const c=document.createElement('div'); c.className='card'; c.id='card-'+no;
@@ -1264,7 +1264,7 @@ function card(host, no, name, html, note){
     d.innerHTML=`<summary>spec sheet</summary><div class="igrid">${rows}</div>`;
     c.appendChild(d);}
   host.appendChild(c);
-  if(isBuild)c.gw=html(c.querySelector('.stagew'),txt=>setRd(no,txt));
+  if(isBuild)c.dupre=html(c.querySelector('.stagew'),txt=>setRd(no,txt));
   return c;
 }
 function setRd(no,txt){const e=$('rd-'+no);if(e)e.textContent=txt;}
@@ -1290,376 +1290,376 @@ function updatePolTally(){
     if(!hits.length)return; const i=PJUMP[g]++%hits.length;
     location.hash=''; location.hash=hits[i].id;}));
 }
-/* drag helpers, seg7, buildBars live in widgets.js (GW) */
+/* drag helpers, seg7, buildBars live in widgets.js (DUPRE) */
 
 /* ============ CONTROLS ============ */
 const C=$('controls');
 card(C,'01','Slide toggle',
-  (st,rd)=>GW.slideToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.slideToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
   '<b>on / off, the touchscreen way.</b> The one born-digital control in the kit — the smartphone pill toggle the live net/bt/audio panels use. Click to flip; readout shows the state. Physical cousins: the bat-handle (R03) and the rocker (N01).');
 card(C,'02','Console key',
-  (st,rd)=>GW.consoleKeys(st,{onChange:(i,t)=>rd(t)}),
+  (st,rd)=>DUPRE.consoleKeys(st,{onChange:(i,t)=>rd(t)}),
   '<b>physical push button.</b> Mutually exclusive — click one to engage. Green = live, terracotta = muted, gold = any other engaged key.');
 card(C,'03','Horizontal fader',
-  (st,rd)=>GW.faderH(st,{value:68,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.faderH(st,{value:68,onChange:(v,t)=>rd(t)}),
   '<b>continuous 0-100.</b> Per-device volume, brightness. Drag the gold cap; readout tracks.');
 card(C,'04','Vertical fader',
   (st,rd)=>{let ready=false;
     const upd=()=>{if(ready)rd('A '+Math.round(a.get())+' · B '+Math.round(b.get()));};
-    const a=GW.faderV(st,{value:60,onChange:upd});
-    const b=GW.faderV(st,{value:35,onChange:upd});
+    const a=DUPRE.faderV(st,{value:60,onChange:upd});
+    const b=DUPRE.faderV(st,{value:35,onChange:upd});
     ready=true;upd();return {a,b};},
   '<b>channel-strip style.</b> A mixer column per device. Drag each fader up or down.');
 card(C,'05','Rotary knob',
-  (st,rd)=>GW.knob(st,{value:53,onChange:v=>rd('gain '+Math.round(v))}),
+  (st,rd)=>DUPRE.knob(st,{value:53,onChange:v=>rd('gain '+Math.round(v))}),
   '<b>dial in a value.</b> Volume/gain the analog way. Drag up/down to turn; readout shows the level.');
 card(C,'06','Segmented selector',
-  (st,rd)=>GW.segmented(st,{onChange:(i,t)=>rd(t)}),
+  (st,rd)=>DUPRE.segmented(st,{onChange:(i,t)=>rd(t)}),
   '<b>pick one of a few.</b> Timer type, layout mode. Click a segment; readout names the choice. The lit segment ships in amber, green, or red — the accent chips below switch it.');
 card(C,'07','Chip toggle',
-  (st,rd)=>GW.chipToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.chipToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
   '<b>inline binary.</b> A soft toggle inside a line of text. Click to flip. The lit colour is the consumer\'s to pick from the accent family, because "on" is good news in one panel and a fault in the next — amber by default.');
 card(C,'08','Arm-to-fire',
-  (st,rd)=>GW.armButton(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.armButton(st,{onChange:(v,t)=>rd(t)}),
   '<b>two-stage confirm.</b> Destructive actions. First click arms (red), second fires. Readout shows the stage.');
 card(C,'09','Lamp row',
-  (st,rd)=>GW.lampRow(st,{onChange:(i,t)=>rd(t)}),
+  (st,rd)=>DUPRE.lampRow(st,{onChange:(i,t)=>rd(t)}),
   '<b>actionable list item.</b> Lamp + name + status. Click to cycle idle → connecting → connected.');
 card(C,'24','Rotary selector',
-  (st,rd)=>GW.rotarySelector(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.rotarySelector(st,{onChange:(v,t)=>rd(t)}),
   '<b>pick one of N by position.</b> Printed detents, the pointer names the value. Click to turn; readout shows it.');
 card(C,'25','Slide-rule dial',
-  (st,rd)=>GW.slideRule(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.slideRule(st,{onChange:(v,t)=>rd(t)}),
   '<b>value on a printed scale.</b> A lit pointer glides a warm-backlit strip. Printed numerals are the majors; the units between them carry minor ticks. Click any of them to jump, or focus and press ←/→ (↑/↓) to step a unit; readout shows it. Four faces — warm backlit, chrome, 80s black glass, marantz blue — on the chips below.');
 card(C,'N01','Rocker power switch',
-  (st,rd)=>GW.rocker(st,{on:true,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.rocker(st,{on:true,onChange:(v,t)=>rd(t)}),
   '<b>hard on / off, lit legend.</b> A master power paddle — the pressed half glows. Click to rock.');
 card(C,'N02','Transport cluster',
-  (st,rd)=>GW.transport(st,{mode:'play',animate:!reduced,onChange:(m,t)=>rd(t)}),
+  (st,rd)=>DUPRE.transport(st,{mode:'play',animate:!reduced,onChange:(m,t)=>rd(t)}),
   '<b>run / pause / capture.</b> One mode lit at a time, reels turn while it plays. Click a button.');
 card(C,'N03','Radio preset bank',
-  (st,rd)=>GW.presetBank(st,{onChange:(i,t)=>rd(t)}),
+  (st,rd)=>DUPRE.presetBank(st,{onChange:(i,t)=>rd(t)}),
   '<b>pick one, the rest release.</b> The car-radio preset row — mechanically exclusive. Click one.');
 card(C,'N04','Concentric dual knob',
-  (st,rd)=>GW.dualKnob(st,{outer:50,inner:50,onChange:(o,i)=>rd('bass '+Math.round(o)+' · treble '+Math.round(i))}),
+  (st,rd)=>DUPRE.dualKnob(st,{outer:50,inner:50,onChange:(o,i)=>rd('bass '+Math.round(o)+' · treble '+Math.round(i))}),
   '<b>two values on one spindle.</b> Bass / treble, coarse / fine. Drag the outer ring or inner cap — each is independent.');
 card(C,'N05','Rotary encoder + LED ring',
-  (st,rd)=>GW.encoder(st,{value:7,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.encoder(st,{value:7,onChange:(v,t)=>rd(t)}),
   '<b>endless dial, lit position.</b> A detentless encoder; the LED arc lights to the level and the value keeps accumulating. Drag to turn.');
 card(C,'N06','Keyed mode switch',
-  (st,rd)=>GW.keySwitch(st,{index:1,onChange:(i,t)=>rd(t)}),
+  (st,rd)=>DUPRE.keySwitch(st,{index:1,onChange:(i,t)=>rd(t)}),
   '<b>guarded three-position mode.</b> Off · on · run. The key-bit points at the live position. Click to turn.');
 card(C,'N07','Center-detented crossfader',
-  (st,rd)=>GW.crossfader(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.crossfader(st,{onChange:(v,t)=>rd(t)}),
   '<b>throw to either side of zero.</b> A fader notched at center — balance, L/R mix. Drag; readout shows the signed value.');
 card(C,'N08','Thumbwheel',
-  (st,rd)=>GW.thumbwheel(st,{value:42,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.thumbwheel(st,{value:42,onChange:(v,t)=>rd(t)}),
   '<b>ribbed edge-wheel, one value.</b> A knurled wheel with a windowed number. Drag up/down to roll.');
 card(C,'N09','DIP-switch bank',
-  (st,rd)=>GW.dipBank(st,{onChange:(w,t)=>rd(t)}),
+  (st,rd)=>DUPRE.dipBank(st,{onChange:(w,t)=>rd(t)}),
   '<b>a bank of hard flags.</b> Hardware slide switches — up is on. Click each to flip; readout is the binary word.');
 card(C,'N10','Jog / shuttle wheel',
-  (st,rd)=>GW.jogWheel(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.jogWheel(st,{onChange:(v,t)=>rd(t)}),
   '<b>scrub fine, shuttle fast.</b> The edit-deck wheel. Drag to jog the inner wheel; readout shows the position.');
 card(C,'R02','Calibrated vernier dial',
-  (st,rd)=>GW.vernierDial(st,{value:42.0,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.vernierDial(st,{value:42.0,onChange:(v,t)=>rd(t)}),
   '<b>precision on a rotating disc.</b> The big lab dial — the calibrated disc turns under a fixed hairline. Drag up/down; readout reads to a tenth. After a 1950s lab-oscillator vernier.');
 card(C,'R03','Bat-handle toggle',
-  (st,rd)=>GW.batToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.batToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
   '<b>the period power switch.</b> Chrome bat lever on a hex bushing, snaps up ON / down OFF. Click to throw it. After a lab-instrument panel toggle.');
 card(C,'R04','Bakelite fluted knob',
-  (st,rd)=>GW.flutedKnob(st,{value:63,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.flutedKnob(st,{value:63,onChange:(v,t)=>rd(t)}),
   '<b>the skirted console knob.</b> Scalloped bakelite skirt, glossy dome, amber index over a printed 0-10 scale. Drag up/down to turn. After a vintage console mixer knob.');
 card(C,'R05','Filter slider bank',
-  (st,rd)=>GW.filterBank(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.filterBank(st,{onChange:(v,t)=>rd(t)}),
   '<b>a wall of band faders.</b> Twelve bands on a screwed faceplate, dB rails both sides. Drag any cap; readout names band and level. Skins split three independent axes — panel (silver hi-fi after the Pioneer SG-9500 / studio black after the Technics SH-8065), cap shape (tall block fader after the Zaxcom Oasis / short ribbed / chrome T), and cap color (black white-index / red / green / blue / amber stripes / chrome / cream). The chips below mix them freely.');
 card(C,'R06','Chicken-head selector',
-  (st,rd)=>GW.chickenHead(st,{index:2,onChange:(i,t)=>rd(t)}),
+  (st,rd)=>DUPRE.chickenHead(st,{index:2,onChange:(i,t)=>rd(t)}),
   '<b>the pointer-lever switch.</b> The tapered bakelite lever IS the indicator — it aims at the engraved position. Click to step through. After a modulator mode switch.');
 card(C,'R12','Chrome slot fader',
-  (st,rd)=>GW.slotFader(st,{value:-4,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.slotFader(st,{value:-4,onChange:(v,t)=>rd(t)}),
   '<b>the console gain slide.</b> A chrome T-handle rides a recessed slot, the dB scale engraved on the plate — gain above zero, cut below. Drag; readout shows signed dB. After a vintage channel-strip output fader.');
 card(C,'R14','Spade-pointer tuning knob',
-  (st,rd)=>GW.spadeKnob(st,{value:8.3,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.spadeKnob(st,{value:8.3,onChange:(v,t)=>rd(t)}),
   '<b>the pointer rides the knob.</b> A knurled bakelite knob carries a bright spade pointer over a scale engraved into the panel itself. Drag up/down to tune. After a 1920s radio receiver dial.');
 card(C,'R15','Multi-band dial',
-  (st,rd)=>GW.multiBandDial(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.multiBandDial(st,{onChange:(v,t)=>rd(t)}),
   '<b>four scales, one needle.</b> Nested band arcs on a cream face; the active ring reads bold. Drag the left dial to tune; click the bandspread dial to switch bands. After a shortwave receiver dial pair.');
 card(C,'R16','Entry keypad',
-  (st,rd)=>GW.entryKeypad(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.entryKeypad(st,{onChange:(v,t)=>rd(t)}),
   '<b>a composed entry instrument.</b> Worn keycaps feed the amber display; the lamp watches the buffer; the amber keys confirm and clear. Click the keys. After an industrial keypad prop.');
 card(C,'R18','Thumb-slide attenuator pair',
-  (st,rd)=>GW.thumbSlide(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.thumbSlide(st,{onChange:(v,t)=>rd(t)}),
   '<b>a lit column of numbers, a thumb tab.</b> The scale glows inside the rail; the cream tab rides beside it and the nearest figure lights. Drag either channel. After a compressor blend/mix pair.');
 card(C,'R19','Waveform region editor',
-  (st,rd)=>GW.waveRegion(st,{start:22,end:76,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.waveRegion(st,{start:22,end:76,onChange:(v,t)=>rd(t)}),
   '<b>pick a region on the wave.</b> The monochrome LCD shows the sample; drag near either flag to move START or END, and the selection draws bright. After a sampler edit screen.');
 card(C,'R20','Drum roller selector',
-  (st,rd)=>GW.drumRoller(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.drumRoller(st,{onChange:(v,t)=>rd(t)}),
   '<b>roll to the number.</b> The numbered drum shows through a tall window and the center value sits on an inverted chip. Drag either drum. After an equalizer tone selector.');
 card(C,'R21','LED program row',
-  (st,rd)=>GW.ledRow(st,{index:5,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.ledRow(st,{index:5,onChange:(v,t)=>rd(t)}),
   '<b>identical keys, one lit dot.</b> The LED above the button carries the selection, not the key itself — the classic program-select row. Click a key; readout names the program. After a digital reverb’s program bank.');
 card(C,'R22','Three-position slide',
-  (st,rd)=>GW.pillSlide(st,{index:1,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.pillSlide(st,{index:1,onChange:(v,t)=>rd(t)}),
   '<b>a detented pill, three stops.</b> The chrome pill parks at A, AB, or B, and the LED pair below tells the truth — both light on AB. Click a position. After a drum machine variation switch.');
 card(C,'R23','Spun-aluminum knob',
-  (st,rd)=>GW.spunKnob(st,{value:62,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.spunKnob(st,{value:62,onChange:(v,t)=>rd(t)}),
   '<b>bright metal, machined rings.</b> A spun face with concentric tooling marks in a knurled grip ring, red index over dot ticks. Drag up/down. After a boutique pedal knob, confirmed by an avionics cluster.');
 card(C,'R24','Stomp switch + jewel',
-  (st,rd)=>GW.stompSwitch(st,{on:false,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.stompSwitch(st,{on:false,onChange:(v,t)=>rd(t)}),
   '<b>the engage pair.</b> A chrome dome stomp and the faceted jewel that reports it — press to engage, the jewel lights; press again to bypass. Click it. After a tremolo pedal footswitch.');
 card(C,'R27','Winged gain selector',
-  (st,rd)=>GW.wingSelector(st,{index:7,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.wingSelector(st,{index:7,onChange:(v,t)=>rd(t)}),
   '<b>the red T-bar, stepped.</b> A bar-grip handle over a dot ring, snapping between labeled gain detents. Drag up/down to step it. After a classic mic-preamp gain switch.');
 card(C,'R28','Rotary disc switch',
-  (st,rd)=>GW.discSwitch(st,{index:1,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.discSwitch(st,{index:1,onChange:(v,t)=>rd(t)}),
   '<b>the master power disc.</b> The whole red disc turns, grip bar molded in — a heavy three-position selector for OFF, ON, and COMBINE. Click to step. After a marine battery switch.');
 card(C,'R29','Guarded toggle',
-  (st,rd)=>GW.guardedToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.guardedToggle(st,{on:true,onChange:(v,t)=>rd(t)}),
   '<b>friction sized to consequence.</b> Guard posts flank the lever and a red collar marks it critical — the avionics way to prevent an accidental throw. Click to throw it deliberately. After a flight-deck switch panel.');
 card(C,'R32','Mechanical timer dial',
-  (st,rd)=>GW.timerDial(st,{minutes:0,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.timerDial(st,{minutes:0,onChange:(v,t)=>rd(t)}),
   '<b>turn to start, push to stop.</b> Drag the knurled dial to wind minutes onto the fixed red index; it winds back down to OFF on its own (demo runs a minute per second). Click the red knob to stop it dead. After a mechanical interval timer.');
 card(C,'R33','Four-way rocker',
-  (st,rd)=>GW.rockerPad(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.rockerPad(st,{onChange:(v,t)=>rd(t)}),
   '<b>discrete direction, one press at a time.</b> Click an arrow (the whole quadrant is the target) to step that way; the readout tracks the cursor position it drives. After a remote-control navigation pad.');
 card(C,'R34','Four-way toggle selector',
-  (st,rd)=>GW.fourWayToggle(st,{position:'C',onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.fourWayToggle(st,{position:'C',onChange:(v,t)=>rd(t)}),
   '<b>a lever that lives in one of four states.</b> Click a quadrant and the ball lever throws to A, B, C or D; the matching corner lamp takes the light. The rocker steps — this one selects. After a test-panel quadrant switch.');
 card(C,'R37','Pin routing matrix',
-  (st,rd)=>GW.pinMatrix(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.pinMatrix(st,{onChange:(v,t)=>rd(t)}),
   '<b>many-to-many routing you can read.</b> Sources are rows, destinations are columns; click an intersection to seat a pin and the route exists. Every simultaneous route stays visible. After the EMS VCS3 pin matrix.');
 card(C,'R38','Dead-man button',
-  (st,rd)=>GW.deadMan(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.deadMan(st,{onChange:(v,t)=>rd(t)}),
   '<b>active only while held.</b> Press and hold — the ring arms, the lamp runs, the dwell clock counts. Let go anywhere and it drops to SAFE. The kit has toggles and momentaries; this is the only control whose state IS your grip.');
 card(C,'R39','Rotary telephone dial',
-  (st,rd)=>GW.telephoneDial(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.telephoneDial(st,{onChange:(v,t)=>rd(t)}),
   '<b>numeric entry embodied as time.</b> Click a hole: the finger wheel winds to the stop and spins back, and the digit lands in the number. Bigger digits take longer, exactly like the pulses did. After a Western Electric dial.');
 card(C,'R40','Circuit breaker panel',
-  (st,rd)=>GW.breakerPanel(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.breakerPanel(st,{onChange:(v,t)=>rd(t)}),
   '<b>the first control the system can throw.</b> Click a breaker to close or open it; hit TRIP and a fault pops one out to the tripped mid-position, amber collar showing. A tripped breaker must be pulled to reset before it closes again. After an aircraft breaker row.');
 card(C,'R41','DSKY verb-noun panel',
-  (st,rd)=>GW.dsky(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.dsky(st,{onChange:(v,t)=>rd(t)}),
   '<b>a command grammar, not a button per command.</b> VERB is the action, NOUN is the operand: press VERB 3 5 ENTR for the lamp test. Wrong grammar lights OPR ERR. Two keys plus digits reach every function — the Apollo answer to a panel with too few buttons.');
 card(C,'R42','Cam-timer program drum',
-  (st,rd)=>GW.camTimer(st,{position:0,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.camTimer(st,{position:0,onChange:(v,t)=>rd(t)}),
   '<b>a procedure as a rotating position.</b> The ring is the whole program — fill, wash, rinse, spin — and the pointer is where you are in it. Click to advance (or start from OFF); it then walks itself through the steps. After a washing-machine cam timer.');
 card(C,'R48','Knife switch',
-  (st,rd)=>GW.knifeSwitch(st,{closed:true,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.knifeSwitch(st,{closed:true,onChange:(v,t)=>rd(t)}),
   '<b>the visible disconnect.</b> Copper blades either sit in their jaws or hang open in the air — you can SEE the circuit is broken, which is the entire safety argument. Click the handle to throw it. After early power-station switchboards.');
 card(C,'R49','Decade switch box',
-  (st,rd)=>GW.decadeBox(st,{digits:[3,5,0,0],onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.decadeBox(st,{digits:[3,5,0,0],onChange:(v,t)=>rd(t)}),
   '<b>a number composed a digit at a time.</b> Four skirted knobs, one per decade — drag each to its digit and the total just IS their sum. The thumbwheel does one digit; this is how a lab built a precise value. After a General Radio decade resistance box.');
 card(C,'R50','Two-hand safety control',
-  (st,rd)=>GW.twoHandSafety(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.twoHandSafety(st,{onChange:(v,t)=>rd(t)}),
   '<b>both hands, deliberately.</b> Click one palm button to arm the window, the other within half a second to cycle the press. Too slow — TIE-DOWN fault, start over. The hardware keeps hands out of the die; the grammar survives on screen. After OSHA press controls.');
 card(C,'R51','Voice-loop keyset',
-  (st,rd)=>GW.voiceLoop(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.voiceLoop(st,{onChange:(v,t)=>rd(t)}),
   '<b>attention management, not selection.</b> Each loop is independent: click to monitor (green bar, flickering with activity), again to talk (amber, exclusive — one voice out), again to drop. Flight controllers ran a dozen of these at once. After a mission-control comm keyset.');
 card(C,'R57','ABC entry keypad',
-  (st,rd)=>GW.abcKeypad(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.abcKeypad(st,{onChange:(v,t)=>rd(t)}),
   '<b>letters on a faceplate.</b> A-Z laid out alphabetically, not QWERTY — the industrial convention wherever the operator is not assumed to touch-type. Click the keys, or click the plate and type: it takes the keyboard once focused, and every key routes through the same handle a click does. DEL takes back one character, CLR wipes the lot, ENT commits. R16 enters digits; this is its alphanumeric sibling, and the only card in the kit that takes free text. After fleet and kiosk keypads: the membrane plate\'s colour-coded CLR / ENT, the stainless plate\'s letters-left arrangement and its backspace. Its CANCEL is dropped — that plate is a whole terminal with a transaction to abandon, where this is one control in a panel that owns its own dismiss.');
 
 card(C,'R58','Index typewriter',
-  (st,rd)=>GW.indexPlate(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.indexPlate(st,{onChange:(v,t)=>rd(t)}),
   '<b>type without a keyboard.</b> One hand walks the stylus over a printed plate, the other pulls the lever, and only the lever prints — hunt as long as you like and nothing happens until the second hand moves. Select and commit on two separate controls, which no other card in the kit does. The plate is the AEG Mignon Model 4\'s own (1924), transcribed from the reference: both full cases so there is no shift key, the accents and fractions a keyboard skips, and two economies worth noticing. There is <b>no 1 and no 0</b> — you type them with lowercase l and capital O. And the inversion is positional, not by case: the capitals block is dark discs on a light panel and the lowercase block is its photographic negative, but J and j sit out on the halftone ring, un-inverted, with the punctuation.');
 
 /* ============ METERS & GAUGES ============ */
 const M=$('meters');
 card(M,'10','Needle gauge',
-  (st,rd)=>GW.needleGauge(st,{value:50,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.needleGauge(st,{value:50,onChange:(v,t)=>rd(t)}),
   '<b>analog dial.</b> Throughput, battery, volume. Drag up/down to sweep the needle; readout tracks. <b>Smooth sweep wants a Cairo/GTK area.</b>');
 card(M,'11','Stereo VU (LED bar)',
-  (st,rd)=>GW.vuPair(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.vuPair(st,{onChange:(v,t)=>rd(t)}),
   '<b>live signal level.</b> The sound panel meter row, peak-hold outline. Runs a live signal; readout shows L/R.');
 card(M,'12','Mini signal (4-bar)',
-  (st,rd)=>GW.miniSig(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.miniSig(st,{onChange:(v,t)=>rd(t)}),
   '<b>compact activity.</b> Per-row "is this device playing". Live signal; readout shows activity %.');
 card(M,'13','Signal ladder',
-  (st,rd)=>GW.signalLadder(st,{value:3,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.signalLadder(st,{value:3,onChange:(v,t)=>rd(t)}),
   '<b>discrete strength.</b> Wifi bars, bt RSSI — a stepped 0-4. Click to cycle strength; readout shows bars.');
 card(M,'14','Linear fuel bar',
-  (st,rd)=>{const a=GW.fuelBar(st,{value:72,onChange:(v,t)=>rd(t)});
-    const b=GW.fuelBar(st,{value:40,onChange:(v,t)=>rd(t)});
+  (st,rd)=>{const a=DUPRE.fuelBar(st,{value:72,onChange:(v,t)=>rd(t)});
+    const b=DUPRE.fuelBar(st,{value:40,onChange:(v,t)=>rd(t)});
     a.set(72);return {a,b};},
   '<b>a single 0-100.</b> Battery, disk, download. Drag either bar; warn tint under threshold; readout tracks.');
 card(M,'15','Radial ring',
-  (st,rd)=>GW.radialRing(st,{value:68,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.radialRing(st,{value:68,onChange:(v,t)=>rd(t)}),
   '<b>percentage as a donut.</b> CPU, battery. Drag up/down to set; conic-gradient tracks the readout.');
 card(M,'16','Sparkline',
-  (st,rd)=>GW.sparkline(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.sparkline(st,{onChange:(v,t)=>rd(t)}),
   '<b>recent history.</b> Throughput/CPU over the last minute. Live trace; readout shows the current value.');
 card(M,'17','Waveform strip',
-  (st,rd)=>GW.waveStrip(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.waveStrip(st,{onChange:(v,t)=>rd(t)}),
   '<b>audio waveform / scope.</b> A richer signal view. Live trace; readout shows amplitude. <b>Needs a drawing surface.</b>');
 card(M,'N11','Oscilloscope',
-  (st,rd)=>GW.scope(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.scope(st,{onChange:(v,t)=>rd(t)}),
   '<b>a live phosphor trace.</b> A waveform swept over a graticule. Live; readout shows Vpp. <b>Needs a Cairo/GTK area for a smooth trace.</b>');
 card(M,'N12','Spectrum / EQ bars',
-  (st,rd)=>GW.eqBars(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.eqBars(st,{onChange:(v,t)=>rd(t)}),
   '<b>level across bands.</b> A live multi-band bar graph — spectrum, per-core CPU. Live; readout shows the peak band.');
 card(M,'N13','Crossed-needle meter',
-  (st,rd)=>GW.crossNeedle(st,{value:55,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.crossNeedle(st,{value:55,onChange:(v,t)=>rd(t)}),
   '<b>two readings, one face.</b> Forward + reflected needles cross. Drag up/down to drive power; readout shows both. <b>Round build wants a drawing surface.</b>');
 card(M,'N14','Thermometer column',
-  (st,rd)=>GW.thermometer(st,{value:58,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.thermometer(st,{value:58,onChange:(v,t)=>rd(t)}),
   '<b>a rising column.</b> The classic mercury tube — temperature, a climbing load. Drag up/down; readout shows the value.');
 card(M,'N15','Bourdon pressure gauge',
-  (st,rd)=>GW.bourdon(st,{value:45,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.bourdon(st,{value:45,onChange:(v,t)=>rd(t)}),
   '<b>a round dial with a red zone.</b> Needle over a printed arc, redline in terracotta. Drag to set PSI; readout tracks. <b>Round sweep is a drawing-area job.</b>');
 card(M,'N16','Strip-chart recorder',
-  (st,rd)=>GW.stripChart(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.stripChart(st,{onChange:(v,t)=>rd(t)}),
   '<b>a scrolling pen trace.</b> History scrolls left, the pen writes at the right edge. Live; readout shows the current value. <b>Real trace wants a drawing surface.</b>');
 card(M,'N17','Correlation meter (±)',
-  (st,rd)=>GW.corrMeter(st,{value:58,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.corrMeter(st,{value:58,onChange:(v,t)=>rd(t)}),
   '<b>deviation from center.</b> The needle rests at 0 and swings ±. Drag left/right; readout shows the signed value.');
 card(M,'N18','Battery-cell gauge',
-  (st,rd)=>GW.battCells(st,{value:62,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.battCells(st,{value:62,onChange:(v,t)=>rd(t)}),
   '<b>charge as discrete cells.</b> Filled cells count up, the last warn in terracotta. Drag left/right to set; readout shows %.');
 card(M,'R01','Moving-coil VU meter',
-  (st,rd)=>GW.mcVu(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.mcVu(st,{onChange:(v,t)=>rd(t)}),
   '<b>the classic cream-faced VU.</b> Printed dB arc, red zone past 0, ballistic needle. Runs the live signal; readout shows VU. After a vintage console meter pair.');
 card(M,'R07','Round panel meter',
-  (st,rd)=>GW.roundMeter(st,{value:50,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.roundMeter(st,{value:50,onChange:(v,t)=>rd(t)}),
   '<b>the porthole lab meter.</b> Cream dial in a round black bezel, printed dB arc, black needle. Drag up/down to drive it; readout shows dB. After a modulator front meter.');
 card(M,'R08','Chrome MIN/MAX indicator',
-  (st,rd)=>GW.chromeMinMax(st,{value:50,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.chromeMinMax(st,{value:50,onChange:(v,t)=>rd(t)}),
   '<b>the hi-fi trim window.</b> Polished chrome ring, brushed dome, a dark pointer sweeping MIN to MAX over the metal. Drag up/down; readout shows the position. After a hi-fi amplifier level window.');
 card(M,'R09','Black-face aviation gauge',
-  (st,rd)=>GW.aviationGauge(st,{value:52,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.aviationGauge(st,{value:52,onChange:(v,t)=>rd(t)}),
   '<b>amber on black, zone-marked.</b> The cockpit round: amber ticks and numerals on a black face, painted caution and limit sectors, amber needle. Drag up/down; readout tracks. After a flight-instrument cluster.');
 card(M,'R13','Edgewise strip meter',
-  (st,rd)=>GW.edgeMeter(st,{value:.62,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.edgeMeter(st,{value:.62,onChange:(v,t)=>rd(t)}),
   '<b>a needle on a vertical scale.</b> The parchment strip reads attenuation down a compressed log scale; the bar rides its edge. Drag up/down; readout shows dB. After a channel-strip gain-reduction meter.');
 card(M,'R43','Attitude indicator',
-  (st,rd)=>GW.attitudeIndicator(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.attitudeIndicator(st,{onChange:(v,t)=>rd(t)}),
   '<b>orientation, not a number.</b> The horizon rolls and shifts behind the fixed amber airplane — two axes in one read. Drag it: left/right banks, up/down pitches. The first two-axis instrument in the kit. After a cockpit artificial horizon.');
 card(M,'R44','Heading bug + servo needle',
-  (st,rd)=>GW.headingBug(st,{value:90,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.headingBug(st,{value:90,onChange:(v,t)=>rd(t)}),
   '<b>commanded versus actual on one dial.</b> Drag to park the amber bug where you want to go; the needle chases it with honest servo lag. The gap between them IS the information. After an HSI heading bug and synchro repeaters.');
 card(M,'R54','Vertical tape instrument',
-  (st,rd)=>GW.verticalTape(st,{value:24,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.verticalTape(st,{value:24,onChange:(v,t)=>rd(t)}),
   '<b>the scale moves, the index does not.</b> A scrolling tape behind a fixed amber index — your value is always at eye level and the neighborhood above and below stays visible. Drag to spin the tape. After the Ki-57 remote tachometer; modern cockpits tape everything.');
 card(M,'R55','Twin-needle gauge',
-  (st,rd)=>GW.twinNeedle(st,{fuel:2.4,oil:3.1,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.twinNeedle(st,{fuel:2.4,oil:3.1,onChange:(v,t)=>rd(t)}),
   '<b>two values, one housing, mirrored scales.</b> Fuel presses up the left arc, oil up the right, each with its own needle from the shared hub. Drag either half to set that side. Not the crossed-needle (N13) — these are read separately, not at their intersection. After the Ki-57 fuel/oil pressure gauge.');
 card(M,'R56','Comfort-zone crossed needles',
-  (st,rd)=>GW.comfortMeter(st,{temp:72,humidity:45,onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.comfortMeter(st,{temp:72,humidity:45,onChange:(v,t)=>rd(t)}),
   '<b>two values, one verdict.</b> Temperature and humidity needles cross over a face printed with judgments — the crossing point lands in TOO WARM, TOO DRY, or JUST RIGHT. N13 derives a number from the crossing; this one derives an opinion. Drag each half. After a brass weather-station comfort meter.');
 card(M,'R53','Circular chart recorder',
-  (st,rd)=>GW.chartRecorder(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.chartRecorder(st,{onChange:(v,t)=>rd(t)}),
   '<b>cyclic time on round paper.</b> The pen sweeps a full day per revolution, so "same time yesterday" is the same angle and daily rhythm draws itself as a flower. Click for fresh paper. The strip chart shows a window; this shows the cycle. After a Partlow round-chart recorder.');
 card(M,'R17','Round CRT scope',
-  (st,rd)=>GW.roundCrt(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.roundCrt(st,{onChange:(v,t)=>rd(t)}),
   '<b>the round-tube scope.</b> Pale phosphor face in a screwed porthole bezel, dark graticule, a bright live trace. Runs live; readout shows Vpp. After a 1950s bench oscilloscope.');
 
 /* ============ INDICATORS & READOUTS ============ */
 const I=$('indicators');
 card(I,'18','Status lamp',
-  (st,rd)=>GW.statusLamps(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.statusLamps(st,{onChange:(v,t)=>rd(t)}),
   '<b>one-glance health.</b> Green ok · gold engaged · red fail · dim off · pulsing busy. Click any lamp to cycle its state.');
 card(I,'19','Badge / tag',
-  (st,rd)=>GW.badges(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.badges(st,{onChange:(v,t)=>rd(t)}),
   '<b>a labelled flag.</b> MUTED, AIRPLANE, a band tag. Click a badge to cycle its variant.');
 card(I,'20','Tabular readout',
-  (st,rd)=>GW.tabularReadout(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.tabularReadout(st,{onChange:(v,t)=>rd(t)}),
   '<b>a precise number.</b> Clock, countdown, volume %. Runs a live countdown; click to pause/resume.');
 card(I,'21','Engraved label',
-  (st,rd)=>GW.engravedLabel(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.engravedLabel(st,{onChange:(v,t)=>rd(t)}),
   '<b>section divider.</b> The hairline-flanked caps label with a count. Click to bump the count.');
 card(I,'22','Output well',
-  (st,rd)=>GW.outputWell(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.outputWell(st,{onChange:(v,t)=>rd(t)}),
   '<b>streaming step log.</b> Lamp-per-step with evidence. Click to stream the next step.');
 card(I,'23','Toast / status line',
-  (st,rd)=>GW.toast(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.toast(st,{onChange:(v,t)=>rd(t)}),
   '<b>transient confirmation.</b> The one-line result after an action. Click to fire the next toast.');
 card(I,'26','Nixie tube',
-  (st,rd)=>GW.nixie(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.nixie(st,{onChange:(v,t)=>rd(t)}),
   '<b>a single warm-glowing numeral.</b> One lit digit per tube, leading zeros dark. Click to increment the count.');
 card(I,'N20','Split-flap display',
-  (st)=>GW.splitFlap(st,{rows:3,cells:6,words:['SYSTEM','VOLUME','SIGNAL','RECORD','ONLINE','STEREO','STATUS','FILTER','TUNING','NEEDLE','SWITCH','TOGGLE','DIMMER','CHROME','MODULE','OUTPUT','SCREEN','COPPER','DYNAMO','PISTON','MAGNET','BEACON','RADIAL','BRIDGE'],animate:!reduced,skin:'paper',font:'helv'}),
+  (st)=>DUPRE.splitFlap(st,{rows:3,cells:6,words:['SYSTEM','VOLUME','SIGNAL','RECORD','ONLINE','STEREO','STATUS','FILTER','TUNING','NEEDLE','SWITCH','TOGGLE','DIMMER','CHROME','MODULE','OUTPUT','SCREEN','COPPER','DYNAMO','PISTON','MAGNET','BEACON','RADIAL','BRIDGE'],animate:!reduced,skin:'paper',font:'helv'}),
   '<b>flips to the new value.</b> A three-row, six-cell board; every advance sends each row to a different random word from the pool, and each cell runs at its own mechanical rate, so letters and whole words finish at different times. After settling it dwells two seconds, then advances. Click to advance now. Skins: white cards with dark lettering (default), white ink on black, the kit cream, or the ivory board; face in Helvetica (default) or Berkeley Mono. The slider sets the flap rate.');
 card(I,'N21','Seven-segment display',
-  (st,rd)=>GW.sevenSeg(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.sevenSeg(st,{onChange:(v,t)=>rd(t)}),
   '<b>a lit-segment number.</b> Green segments, distinct from the nixie glow. Live countdown; click to add a minute.');
 card(I,'N22','VFD marquee',
-  (st,rd)=>GW.vfdMarquee(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.vfdMarquee(st,{onChange:(v,t)=>rd(t)}),
   '<b>scrolling status line.</b> Teal glow, dot-matrix mesh, text tracks across. Scrolls live; click to change the message.');
 card(I,'N23','Annunciator panel',
-  (st,rd)=>GW.annunciator(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.annunciator(st,{onChange:(v,t)=>rd(t)}),
   '<b>a grid of named alarms with the alarm lifecycle.</b> Cells light amber to warn, red to fault; any active alarm flashes MSTR CAUTION until ACK steadies it, a new alarm re-flashes it, RESET clears the board, TEST proves the bulbs. Click cells to raise alarms.');
 card(I,'N24','Jewel pilot lamps',
-  (st,rd)=>GW.jewels(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.jewels(st,{onChange:(v,t)=>rd(t)}),
   '<b>a faceted glass indicator.</b> The chunky bezel pilot lamp with a real bloom. Click a jewel to cycle red · amber · green · dark.');
 card(I,'N25','Tape counter',
-  (st,rd)=>GW.tapeCounter(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.tapeCounter(st,{onChange:(v,t)=>rd(t)}),
   '<b>rolling odometer digits.</b> Numbered wheels roll to the next figure. Rolls live; readout shows the total.');
 card(I,'N26','Analog clock',
-  (st,rd)=>GW.analogClock(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.analogClock(st,{onChange:(v,t)=>rd(t)}),
   '<b>time on a real face.</b> Engraved ticks, three hands, live seconds sweep. Runs live; readout shows the time.');
 card(I,'N27','Frequency-dial scale',
-  (st,rd)=>GW.freqScale(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.freqScale(st,{onChange:(v,t)=>rd(t)}),
   '<b>a printed log scale.</b> Marks crowd low, spread high — a real logarithmic axis. Drag the pointer; readout shows the frequency.');
 card(I,'N28','Patch-bay jack field',
-  (st,rd)=>GW.patchBay(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.patchBay(st,{onChange:(v,t)=>rd(t)}),
   '<b>routing shown as patches.</b> A grid of jacks with cables between connected pairs. Click one jack then another to add/remove a cable.');
 card(I,'R10','Data matrix readout',
-  (st,rd)=>GW.dataMatrix(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.dataMatrix(st,{onChange:(v,t)=>rd(t)}),
   '<b>a page of amber fields.</b> The console data block — several labeled values on one lit matrix. Click to cycle pages; readout names the page. After a cockpit data readout.');
 card(I,'R11','Warning flag window',
-  (st,rd)=>GW.warningFlag(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.warningFlag(st,{onChange:(v,t)=>rd(t)}),
   '<b>the mechanical alarm flag.</b> A striped barber-pole slides into a window when the condition trips — not a lamp, a flag. Click to trip and clear it. After the VIB flag on an altimeter.');
 card(I,'R25','Fourteen-segment display',
-  (st,rd)=>GW.seg14(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.seg14(st,{onChange:(v,t)=>rd(t)}),
   '<b>segments that spell.</b> The starburst alphanumeric — diagonals and split bars let it write words, not just digits. Click to cycle the word. After a pedal preset display.');
 card(I,'R26','Response graph',
-  (st,rd)=>GW.responseGraph(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.responseGraph(st,{onChange:(v,t)=>rd(t)}),
   '<b>a curve on labeled axes.</b> Log frequency across, dB up the side, and the amber peak is yours to place — drag it anywhere on the plot. After the response display of a mastering processor.');
 card(I,'R30','Telegraph indicator',
-  (st,rd)=>GW.telegraphIndicator(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.telegraphIndicator(st,{onChange:(v,t)=>rd(t)}),
   '<b>state on a pie of sectors.</b> The pointer and its little flag name the active state, engine-telegraph style. Click to step the state. After an electric indicator dial.');
 card(I,'R31','Radar sweep',
-  (st,rd)=>GW.radarSweep(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.radarSweep(st,{onChange:(v,t)=>rd(t)}),
   '<b>the rotating scan.</b> A sweep beam circles the bearing ring, contacts bloom as it passes and fade after. Click to mark the current bearing. After a radar PPI scope.');
 card(I,'R35','Day-date disc calendar',
-  (st,rd)=>GW.dayDateCal(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.dayDateCal(st,{onChange:(v,t)=>rd(t)}),
   '<b>two coaxial discs, one index.</b> The outer ring carries the date, the inner disc the weekday; both read where the yellow hand points. Starts on today; click to roll midnight forward and watch the discs step. After a watch day-date movement.');
 card(I,'R36','LED dot matrix',
-  (st,rd)=>GW.dotMatrix(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.dotMatrix(st,{onChange:(v,t)=>rd(t)}),
   '<b>a bitmap, one red dot at a time.</b> 64 discrete LEDs behind a tinted window — segments draw digits, but a matrix draws anything. Click dots to paint the pattern; the readout counts what is lit. After the K4816 pattern generator faceplate.');
 card(I,'R45','Flip-disc tile array',
-  (st,rd)=>GW.flipDisc(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.flipDisc(st,{onChange:(v,t)=>rd(t)}),
   '<b>the mechanical pixel.</b> Each disc flips between its yellow face and its black back and then STAYS — no power, no glow, state that persists. Click a disc and watch it flip. The dot matrix glows; this one clacks. After transit flip-dot signs.');
 card(I,'R46','Dekatron counting ring',
-  (st,rd)=>GW.dekatron(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.dekatron(st,{onChange:(v,t)=>rd(t)}),
   '<b>a count as a position, and the counting is visible.</b> Each click is a pulse; the neon glow steps one cathode around the ring and carries on wrap. Nixies show the digit — the Dekatron shows the arithmetic. After glow-transfer counter tubes.');
 card(I,'R47','Landing gear indicator',
-  (st,rd)=>GW.gearIndicator(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.gearIndicator(st,{onChange:(v,t)=>rd(t)}),
   '<b>three greens or nothing.</b> A spatial lamp panel: nose and mains each get a light, green only when down and locked; the amber transit pulse means neither state. Click the wheel lever to cycle the gear. After a cockpit gear panel.');
 card(I,'R52','Blinkenlights front panel',
-  (st,rd)=>GW.blinkenlights(st,{onChange:(v,t)=>rd(t)}),
+  (st,rd)=>DUPRE.blinkenlights(st,{onChange:(v,t)=>rd(t)}),
   '<b>the machine thinking, out loud.</b> Address and data lamps ripple with the live computation; the switch register below is yours — flip bits and watch the pattern change. DIP switches hold config; this shows work happening. After a PDP-11/70 front panel.');
 
 /* ============ CONTROL WIRING ============ */
 /* 01 toggle */
-/* 01-09, 24, 25, N01-N10 extracted to widgets.js (GW.*) — wired at their card records */
+/* 01-09, 24, 25, N01-N10 extracted to widgets.js (DUPRE.*) — wired at their card records */
 
 /* ============ METER WIRING (drag-driven) ============ */
-/* 10-17, N11-N18 extracted to widgets.js (GW.*) — wired at their card records */
+/* 10-17, N11-N18 extracted to widgets.js (DUPRE.*) — wired at their card records */
 
 /* ============ INDICATOR WIRING ============ */
-/* 18-23, 26 extracted to widgets.js (GW.*) — wired at their card records */
-/* N20-N28 extracted to widgets.js (GW.*) — wired at their card records */
+/* 18-23, 26 extracted to widgets.js (DUPRE.*) — wired at their card records */
+/* N20-N28 extracted to widgets.js (DUPRE.*) — wired at their card records */
 
-/* ============ REFERENCE-BATCH (R) WIDGETS — SVG builders ============ */
-/* svgEl, polar, VUDB live in widgets.js (GW) */
+/* ============ REFERENCE-BATCH (R) INSTRUMENTS — SVG builders ============ */
+/* svgEl, polar, VUDB live in widgets.js (DUPRE) */
 
 /* R01 ballistics: the page owns the signal chase; the meter just takes set(t) */
 function tickMcVu(){const a=lvl();const target=Math.min(1.02,a*1.12);
   const t=MH.mcvu.get();MH.mcvu.set(t+(target-t)*(target>t?0.32:0.10));}
 
-/* R02-R06, R12, R14, R15 extracted to widgets.js (GW.*) */
+/* R02-R06, R12, R14, R15 extracted to widgets.js (DUPRE.*) */
 
 
 
@@ -1669,26 +1669,26 @@ function tickMcVu(){const a=lvl();const target=Math.min(1.02,a*1.12);
 
 
 
-/* R07-R09 extracted to widgets.js (GW.*) */
+/* R07-R09 extracted to widgets.js (DUPRE.*) */
 
-/* R10, R11 extracted to widgets.js (GW.*) */
+/* R10, R11 extracted to widgets.js (DUPRE.*) */
 
 
 
 
-/* R13, R17 extracted to widgets.js (GW.*) */
+/* R13, R17 extracted to widgets.js (DUPRE.*) */
 
-/* R25, R26, R30, R31 extracted to widgets.js (GW.*) */
+/* R25, R26, R30, R31 extracted to widgets.js (DUPRE.*) */
 
 
 
 
 /* ============ LIVE SIGNAL LOOPS ============ */
 /* extracted meters: the page keeps the clock + demo signal, drives card handles */
-const MH={vu:$('card-11').gw,mini:$('card-12').gw,spark:$('card-16').gw,wave:$('card-17').gw,
-  scope:$('card-N11').gw,eq:$('card-N12').gw,strip:$('card-N16').gw,mcvu:$('card-R01').gw};
-const IH={flap:$('card-N20').gw,seven:$('card-N21').gw,vfd:$('card-N22').gw,
-  counter:$('card-N25').gw,clock:$('card-N26').gw};
+const MH={vu:$('card-11').dupre,mini:$('card-12').dupre,spark:$('card-16').dupre,wave:$('card-17').dupre,
+  scope:$('card-N11').dupre,eq:$('card-N12').dupre,strip:$('card-N16').dupre,mcvu:$('card-R01').dupre};
+const IH={flap:$('card-N20').dupre,seven:$('card-N21').dupre,vfd:$('card-N22').dupre,
+  counter:$('card-N25').dupre,clock:$('card-N26').dupre};
 
 let ph=0;
 const eqBands=Array.from({length:11},(_,i)=>({v:0.4,ph:i*0.6}));
@@ -1716,7 +1716,7 @@ const FLAP_DWELL_MS=2000; let flapTimer;
 // a fixed interval would retarget mid-cascade and the panel would never rest.
 if(!reduced)IH.flap.onSettle(()=>{clearTimeout(flapTimer);flapTimer=setTimeout(()=>IH.flap.next(),FLAP_DWELL_MS);});
 function tickSeven(){IH.seven.tick();}
-function tickT(){$('card-20').gw.tick();}
+function tickT(){$('card-20').dupre.tick();}
 function tickVfd(){IH.vfd.tick();}
 function tickCounter(){IH.counter.set(IH.counter.get()+137);}
 
@@ -1748,29 +1748,29 @@ if(!reduced){
   document.querySelectorAll('.reel.spin').forEach(r=>r.style.animationPlayState='paused');
 }
 
-/* R35, R36 extracted to widgets.js (GW.*) */
+/* R35, R36 extracted to widgets.js (DUPRE.*) */
 
 
-/* R43, R44 extracted to widgets.js (GW.*) */
+/* R43, R44 extracted to widgets.js (DUPRE.*) */
 
-/* R45-R47, R52 extracted to widgets.js (GW.*) */
+/* R45-R47, R52 extracted to widgets.js (DUPRE.*) */
 
 
 
 
-/* R53-R56 extracted to widgets.js (GW.*) */
+/* R53-R56 extracted to widgets.js (DUPRE.*) */
 
-/* ---- screen-family chips: first round, the clearly-screen widgets ----
-   Defaults match each widget's shipped color (var fallbacks), so no family is applied until a chip is clicked.
+/* ---- screen-family chips: first round, the clearly-screen instruments ----
+   Defaults match each instrument's shipped color (var fallbacks), so no family is applied until a chip is clicked.
    The nixie stays chipless on purpose: neon is only ever orange, so alternates would be historically false. */
-screenChips('R10',$('card-R10').gw.el,['amber','green','red','blue','vfd'],'amber');
-screenChips('R17',$('card-R17').gw.el,['green','amber','red','blue','vfd'],'green');
-screenChips('R19',$('card-R19').gw.el,['white','green','amber','blue','vfd'],'white');
-screenChips('R31',$('card-R31').gw.el,['amber','green','red','blue','vfd'],'amber');
-screenChips('N11',$('card-N11').gw.el,['green','amber','red','blue','vfd'],'green');
+screenChips('R10',$('card-R10').dupre.el,['amber','green','red','blue','vfd'],'amber');
+screenChips('R17',$('card-R17').dupre.el,['green','amber','red','blue','vfd'],'green');
+screenChips('R19',$('card-R19').dupre.el,['white','green','amber','blue','vfd'],'white');
+screenChips('R31',$('card-R31').dupre.el,['amber','green','red','blue','vfd'],'amber');
+screenChips('N11',$('card-N11').dupre.el,['green','amber','red','blue','vfd'],'green');
 /* all six, where its siblings each carry five: a passphrase window has no reason
    to prefer one phosphor, so it offers the whole set including the marquee cyan */
-screenChips('R57',$('card-R57').gw.el,['amber','green','red','blue','vfd','white'],'amber');
+screenChips('R57',$('card-R57').dupre.el,['amber','green','red','blue','vfd','white'],'amber');
 BOOST.forEach(no=>{const rd=document.getElementById('rd-'+no);
   if(rd)rd.closest('.card').querySelector('.stagew').classList.add('boost');});
 
@@ -1786,16 +1786,16 @@ BOOST.forEach(no=>{const rd=document.getElementById('rd-'+no);
    PRESETS (optional) adds a leading group of named combinations: a preset chip
    applies all axes at once and resyncs the axis chips beneath it, and changing
    any axis afterwards clears the preset — the chips must never claim a preset
-   the widget has since diverged from. */
+   the instrument has since diverged from. */
 function styleChips(no,STYLES,AXES,PRESETS,defPreset){
-  const h=$('card-'+no)?.gw; if(!h)return;
+  const h=$('card-'+no)?.dupre; if(!h)return;
   const cardEl=h.el.closest('.card');
   const row=document.createElement('div'); row.className='famchips';
   const sel={}, sync={}, groups=[]; let clearPreset=()=>{};
   /* Re-apply every axis on any change rather than just the one clicked: axes are
      not independent (onText overrides the ink `on` sets), so a lone setStyle can
      drop a selection the chips still show as lit — the card would then display a
-     combination the widget isn't in. Applying all of them in AXES order makes
+     combination the instrument isn't in. Applying all of them in AXES order makes
      the outcome independent of click order. */
   const applyAll=()=>{for(const [,axis] of AXES) if(sel[axis]) h.setStyle(axis,sel[axis]);};
   for(const [label,axis,def] of AXES){
@@ -1829,21 +1829,21 @@ function styleChips(no,STYLES,AXES,PRESETS,defPreset){
   groups.forEach(g=>row.appendChild(g));
   cardEl.querySelector('.opts').appendChild(row);
 }
-styleChips('N20',GW.splitFlap.STYLES,[['skin','skin','paper'],['font','font','helv']]);
-(()=>{const h=$('card-N20').gw,row=document.querySelector('#card-N20 .famchips');if(!h||!row)return;
+styleChips('N20',DUPRE.splitFlap.STYLES,[['skin','skin','paper'],['font','font','helv']]);
+(()=>{const h=$('card-N20').dupre,row=document.querySelector('#card-N20 .famchips');if(!h||!row)return;
   const gr=document.createElement('span');gr.className='fgroup';
   gr.innerHTML='<span class="lab">flap</span><input type="range" min="30" max="160" value="100" style="width:70px;accent-color:var(--gold);vertical-align:middle"><span class="lab fms">100ms</span>';
   const sl=gr.querySelector('input'),ms=gr.querySelector('.fms');
   sl.addEventListener('input',()=>{h.setFlapMs(+sl.value);ms.textContent=sl.value+'ms';});
   row.appendChild(gr);})();
-styleChips('01',GW.slideToggle.STYLES,
+styleChips('01',DUPRE.slideToggle.STYLES,
   [['on','on','amber'],['on text','onText','panel'],['off','off','dark'],
    ['off text','offText','white'],['thumb','thumb','light']],
-  GW.slideToggle.PRESETS,'panel');
-styleChips('R05',GW.filterBank.STYLES,[['panel','panel','silver'],['shape','caps','block'],['color','capColor','black']]);
-styleChips('06',GW.segmented.STYLES,[['accent','accent','amber']]);
-styleChips('07',GW.chipToggle.STYLES,[['accent','accent','amber']]);
-styleChips('25',GW.slideRule.STYLES,[['face','skin','warm']]);
+  DUPRE.slideToggle.PRESETS,'panel');
+styleChips('R05',DUPRE.filterBank.STYLES,[['panel','panel','silver'],['shape','caps','block'],['color','capColor','black']]);
+styleChips('06',DUPRE.segmented.STYLES,[['accent','accent','amber']]);
+styleChips('07',DUPRE.chipToggle.STYLES,[['accent','accent','amber']]);
+styleChips('25',DUPRE.slideRule.STYLES,[['face','skin','warm']]);
 
 /* final tally pass: setV fires per card during build, but each card is still
    detached at that moment, so the running counts lag by one — recount now */
diff --git a/docs/prototypes/widgets.js b/docs/prototypes/widgets.js
index 8af2666..2766353 100644
--- a/docs/prototypes/widgets.js
+++ b/docs/prototypes/widgets.js
@@ -1,12 +1,12 @@
-/* widgets.js — retro-instrument widget library (GW namespace).
+/* widgets.js — The Dupre Kit: retro-instrument component library (DUPRE namespace).
    Classic script: load after the token :root block (tokens.json → gen_tokens.py),
-   before any GW.* call. Works from file:// — no modules, no build step.
+   before any DUPRE.* call. Works from file:// — no modules, no build step.
    Contract: each gallery card in panel-widget-gallery.html is the visual +
    behavioral spec its builder is judged against.
    Spec: docs/specs/2026-07-12-component-generation-spec.org */
 (function () {
 'use strict';
-const GW = {};
+const DUPRE = {};
 
 /* ================= shared engine ================= */
 
@@ -107,19 +107,19 @@ const SCREEN_FAMS = {
     '--crt-face1': '#d0d2d0', '--crt-face2': '#a8aaa8', '--crt-glow': '#f7f7f7' },
 };
 
-/* ================= widget builders =================
-   Every builder: GW.name(host, opts) → handle. host is an empty element the
-   widget renders into. opts.onChange(value, text) fires on every state change,
-   including the initial paint; text is the widget's canonical readout string. */
+/* ================= instrument builders =================
+   Every builder: DUPRE.name(host, opts) → handle. host is an empty element the
+   instrument renders into. opts.onChange(value, text) fires on every state change,
+   including the initial paint; text is the instrument's canonical readout string. */
 
 const noop = () => {};
 
 /* ---- the accent family ----
-   One named set of lit colours for the widgets whose colour IS their claim: a
+   One named set of lit colours for the instruments whose colour IS their claim: a
    chip, a lamp, a badge, a status line. "On" is good in one panel, a warning in
    the next and a fault in the one after, so the colour belongs to the consumer
    rather than the builder.
-   Deliberately NOT applied to widgets whose colour is the object rather than a
+   Deliberately NOT applied to instruments whose colour is the object rather than a
    state — the nixie (the palette is explicit that neon is only ever orange), the
    flip-disc's yellow, the dekatron's glow, a red needle — nor to the ones where
    the colour is a standard rather than a preference: three greens on the landing
@@ -134,60 +134,60 @@ const ACCENTS = {
   white: 'var(--cream)',
   vfd: 'var(--vfd)',
 };
-GW.accentStyles = varName => Object.fromEntries(
+DUPRE.accentStyles = varName => Object.fromEntries(
   Object.entries(ACCENTS).map(([name, colour]) => [name, { dot: colour, vars: { [varName]: colour } }]));
 
 /* ---- policy ----
-   Every widget's colour is either the consumer's to pick or locked for a reason,
-   and the reason is one of these six kinds. Declared per builder (GW.<name>.POLICY)
+   Every instrument's colour is either the consumer's to pick or locked for a reason,
+   and the reason is one of these six kinds. Declared per builder (DUPRE.<name>.POLICY)
    so it's a checked property rather than something the next person recalls — the
    colour pass kept turning up cards where "is this one a standard?" was answered
    from memory and answered wrong. The two FREE kinds get chips; the four LOCKED
    ones must not, and the probe enforces the split.
-   Policy is a property of the WIDGET, not the colour: the same vfd cyan is a free
+   Policy is a property of the INSTRUMENT, not the colour: the same vfd cyan is a free
    accent on a chip and a locked emissive identity on the marquee. A few cards are
    mixed (a free display with a coded red-line) and declare per element in time.
    Each builder's POLICY is a record { kind, why, authentic }:
      kind      — one of the six below.
-     why       — why THIS widget is bound that way, in its own terms.
+     why       — why THIS instrument is bound that way, in its own terms.
      authentic — what may change and still be true to the reference (the range
                  that actually existed), or 'nothing' when the colour is fixed. */
-GW.POLICIES = {
+DUPRE.POLICIES = {
   accent:     { free: true,  gist: 'A lit state whose meaning varies by panel; the consumer picks from the accent family.' },
   screen:     { free: true,  gist: 'A display whose phosphor was made in several real colours; the consumer picks from the screen family.' },
   coded:      { free: false, gist: 'Colour is meaning fixed by an external standard; a recolour misleads a trained operator (landing-gear three-greens, breaker trip).' },
   emissive:   { free: false, gist: 'Colour is what the physical source emits and no other was made; unrecognisable otherwise (nixie neon, dekatron glow).' },
-  relational: { free: false, gist: 'Colour means what it does only by contrast with another on the same widget; the set is a scale or legend (VU zones, crossed needles).' },
+  relational: { free: false, gist: 'Colour means what it does only by contrast with another on the same instrument; the set is a scale or legend (VU zones, crossed needles).' },
   material:   { free: false, gist: 'Colour of a static physical part, not a state — nothing to parameterise as a signal (needle, brass bezel, knife blade).' },
 };
 
 /* 01 slide toggle — on/off pill. State colors ride CSS vars (--sw-*).
    opts.onStyle / offStyle / offText / thumb pick a named style per axis from
-   GW.slideToggle.STYLES; defaults match the stylesheet fallbacks. The handle's
+   DUPRE.slideToggle.STYLES; defaults match the stylesheet fallbacks. The handle's
    setStyle(axis, name) restyles a live instance (the gallery chips use it). */
-GW.slideToggle = function (host, opts = {}) {
+DUPRE.slideToggle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const sw = document.createElement('span'); sw.className = 'switch'; host.appendChild(sw);
   const setStyle = (axis, name) => {
-    const o = (GW.slideToggle.STYLES[axis] || {})[name];
+    const o = (DUPRE.slideToggle.STYLES[axis] || {})[name];
     if (!o) return;
     for (const [k, v] of Object.entries(o.vars)) sw.style.setProperty(k, v);
   };
   /* opts.preset names an intent; per-axis opts still win over it, so a caller can
      take 'armed' and swap only the thumb. setPreset re-applies all four axes at
      once and returns the axis map so a host UI can resync its own controls. */
-  const preset = GW.slideToggle.PRESETS[opts.preset] || GW.slideToggle.PRESETS.panel;
+  const preset = DUPRE.slideToggle.PRESETS[opts.preset] || DUPRE.slideToggle.PRESETS.panel;
   /* AXIS_ORDER is load-bearing, not cosmetic: onText overrides the ink that the
      `on` style sets, so applying the axes in any other order silently drops it. */
   const setPreset = name => {
-    const p = GW.slideToggle.PRESETS[name];
+    const p = DUPRE.slideToggle.PRESETS[name];
     if (!p) return null;
-    for (const axis of GW.slideToggle.AXIS_ORDER) if (p[axis]) setStyle(axis, p[axis]);
+    for (const axis of DUPRE.slideToggle.AXIS_ORDER) if (p[axis]) setStyle(axis, p[axis]);
     return p;
   };
   const pick = { on: opts.onStyle, onText: opts.onText, off: opts.offStyle,
     offText: opts.offText, thumb: opts.thumb };
-  for (const axis of GW.slideToggle.AXIS_ORDER) setStyle(axis, pick[axis] || preset[axis]);
+  for (const axis of DUPRE.slideToggle.AXIS_ORDER) setStyle(axis, pick[axis] || preset[axis]);
   let on;
   const set = v => { on = !!v; sw.classList.toggle('on', on); onChange(on, on ? 'ON' : 'OFF'); };
   sw.addEventListener('click', () => set(!on));
@@ -198,8 +198,8 @@ GW.slideToggle = function (host, opts = {}) {
    actually reaches for; the STYLES axes below are how one is built. The `on`
    tone does the semantic work and the thumb material backs it: a touchscreen
    pill wears plastic, a run or armed switch wears metal. */
-GW.slideToggle.AXIS_ORDER = ['on', 'onText', 'off', 'offText', 'thumb'];
-GW.slideToggle.PRESETS = {
+DUPRE.slideToggle.AXIS_ORDER = ['on', 'onText', 'off', 'offText', 'thumb'];
+DUPRE.slideToggle.PRESETS = {
   panel: { on: 'amber', onText: 'panel', off: 'dark', offText: 'white', thumb: 'light' },
   run: { on: 'green', onText: 'panel', off: 'dark', offText: 'dim', thumb: 'chrome' },
   armed: { on: 'red', onText: 'cream', off: 'dark', offText: 'white', thumb: 'chrome' },
@@ -210,7 +210,7 @@ GW.slideToggle.PRESETS = {
   dark: { on: 'dark', onText: 'green', off: 'dark', offText: 'red', thumb: 'chrome' },
 };
 /* named styles per axis: dot = swatch color for pickers, vars = --sw-* overrides */
-GW.slideToggle.STYLES = {
+DUPRE.slideToggle.STYLES = {
   on: {
     amber: { dot: 'var(--gold-hi)', vars: { '--sw-on-bg': 'linear-gradient(180deg,var(--amber-grad-top),var(--gold))', '--sw-on-brd': 'var(--gold-hi)', '--sw-on-ink': 'var(--panel)' } },
     green: { dot: '#8fb944', vars: { '--sw-on-bg': 'linear-gradient(180deg,#a9c95f,var(--pass))', '--sw-on-brd': '#a9c95f', '--sw-on-ink': 'var(--panel)' } },
@@ -259,9 +259,9 @@ GW.slideToggle.STYLES = {
    run green, 'red' = terracotta. Reading order runs safe -> live -> muted, and
    LIVE takes green because that is what --pass means everywhere else in the kit
    (the palette names it "run lamps, gear greens, monitor bars, LIVE lamps"). */
-GW.consoleKeys = function (host, opts = {}) {
+DUPRE.consoleKeys = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
-  const keys = opts.keys || GW.consoleKeys.DEFAULT_KEYS;
+  const keys = opts.keys || DUPRE.consoleKeys.DEFAULT_KEYS;
   const wrap = document.createElement('span'); host.appendChild(wrap);
   const btns = keys.map(k => {
     const b = document.createElement('button'); b.className = 'key'; b.textContent = k.label;
@@ -281,10 +281,10 @@ GW.consoleKeys = function (host, opts = {}) {
      resting state for a console and it shows the green. A caller supplying its
      own keys gets the first one unless it says otherwise. */
   set(opts.active !== undefined ? opts.active
-    : (keys === GW.consoleKeys.DEFAULT_KEYS ? 1 : 0));
+    : (keys === DUPRE.consoleKeys.DEFAULT_KEYS ? 1 : 0));
   return { el: wrap, get: () => idx, set };
 };
-GW.consoleKeys.DEFAULT_KEYS = [
+DUPRE.consoleKeys.DEFAULT_KEYS = [
   { label: 'SCAN' }, { label: 'LIVE', tone: 'green' }, { label: 'MUTED', tone: 'red' },
 ];
 
@@ -303,7 +303,7 @@ GW.consoleKeys.DEFAULT_KEYS = [
        already --fail and --pass.
      - Letters left, digits right (the stainless reference's arrangement).
      - DEL added, CANCEL dropped. See the layout block below for both. */
-GW.abcKeypad = function (host, opts = {}) {
+DUPRE.abcKeypad = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const MAX = opts.max || 16;
   const s = stageSvg(host, 'rsvg', 232, 226);
@@ -342,7 +342,7 @@ GW.abcKeypad = function (host, opts = {}) {
      Gated on ACTIONS rather than on KEYS because they are different sets — CLR
      is a real key on the plate that no keystroke maps to. */
   const press = k => {
-    if (!GW.abcKeypad.ACTIONS.has(k)) return;
+    if (!DUPRE.abcKeypad.ACTIONS.has(k)) return;
     if (k === 'ENT') { onChange(buf, buf ? 'ENTER · ' + buf : 'empty'); return; }
     if (k === 'DEL') { buf = buf.slice(0, -1); render(); onChange(buf, buf || 'empty'); return; }
     if (k === 'CLR') { buf = ''; render(); onChange(buf, 'cleared'); return; }
@@ -408,14 +408,14 @@ GW.abcKeypad = function (host, opts = {}) {
   /* Keyboard, per the README's keyboard contract. The listener is bound to the
      pad's own focusable element, never to the document: a global binding would
      type into this card from anywhere on a 110-card page and fight the gallery's
-     own Escape handler. GW.slideRule is the precedent. */
+     own Escape handler. DUPRE.slideRule is the precedent. */
   s.setAttribute('class', 'rsvg kp-pad');
   s.setAttribute('tabindex', '0');
   s.addEventListener('click', () => s.focus());
   s.addEventListener('keydown', e => {
     if (e.ctrlKey || e.metaKey || e.altKey) return;         /* leave shortcuts alone */
     const name = e.key === ' ' ? 'Space' : (e.key.length === 1 ? e.key.toUpperCase() : e.key);
-    const k = GW.abcKeypad.KEYS[name];
+    const k = DUPRE.abcKeypad.KEYS[name];
     if (!k) return;                                          /* not on the plate: let it bubble */
     /* Spend preventDefault only where there is a default worth killing — Space
        scrolls the page, Backspace can navigate back. Tab and Escape are never
@@ -430,10 +430,10 @@ GW.abcKeypad = function (host, opts = {}) {
 /* The plate's keys, declared as a table so every target reads the same intent.
    Deliberately not a function over a DOM event: the Emacs port installs this
    into a keymap and never sees a keydown, so a function would force it to
-   re-derive what the widget accepts and the two bindings would drift apart.
+   re-derive what the instrument accepts and the two bindings would drift apart.
    This is also press()'s allowlist — press appends whatever it is handed, so
    without the table a stray 'F1' would land in the buffer as text. */
-GW.abcKeypad.KEYS = (() => {
+DUPRE.abcKeypad.KEYS = (() => {
   const m = {};
   for (const c of 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') m[c] = c;
   m.Space = 'SPC'; m.Backspace = 'DEL'; m.Enter = 'ENT';
@@ -442,7 +442,7 @@ GW.abcKeypad.KEYS = (() => {
 /* The plate's whole vocabulary — every argument press accepts, from any caller.
    A superset of the KEYS values: CLR is on the plate but no keystroke reaches it
    (Escape is the obvious candidate and belongs to the gallery's audit stepper). */
-GW.abcKeypad.ACTIONS = new Set([
+DUPRE.abcKeypad.ACTIONS = new Set([
   ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 'SPC', 'DEL', 'ENT', 'CLR',
 ]);
 
@@ -463,10 +463,10 @@ GW.abcKeypad.ACTIONS = new Set([
    same column offset: find the letter, then pick the case.
    The layout is a table rather than drawing, because Craig has already said the
    keys will be revisited and a layout welded into the geometry never is. */
-GW.indexPlate = function (host, opts = {}) {
+DUPRE.indexPlate = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const MAX = opts.max || 22;
-  const L = GW.indexPlate.LAYOUT;
+  const L = DUPRE.indexPlate.LAYOUT;
   const COLS = Math.max(...L.map(r => r.length)), ROWS = L.length;
   /* Width is driven by the plate, not guessed: the lever and CLR live in a gutter
      to its right. Sized from the layout table so a wider plate can't slide them
@@ -495,7 +495,7 @@ GW.indexPlate = function (host, opts = {}) {
      The ring area carries a halftone screen, which is what the real plate prints
      its outer characters onto. */
   if (!document.getElementById('ixHalf')) {
-    const defs = s.ownerDocument.querySelector('#gw-defs') || svgEl(s, 'defs', {});
+    const defs = s.ownerDocument.querySelector('#dupre-defs') || svgEl(s, 'defs', {});
     const pat = svgEl(defs, 'pattern', { id: 'ixHalf', width: 4, height: 4, patternUnits: 'userSpaceOnUse' });
     svgEl(pat, 'rect', { width: 4, height: 4, fill: 'url(#ixPlate)' });
     svgEl(pat, 'circle', { cx: 1, cy: 1, r: 1.05, fill: '#2b2318', 'fill-opacity': .55 });
@@ -507,11 +507,11 @@ GW.indexPlate = function (host, opts = {}) {
      a dark one for the lowercase — the plate's photographic-negative trick */
   const ZFILL = { caps: '#e9e0bb', lower: '#231d13' };
   const zoneAt = (r, c) => {
-    const z = GW.indexPlate.ZONES.find(z =>
+    const z = DUPRE.indexPlate.ZONES.find(z =>
       r >= z.rows[0] && r <= z.rows[1] && c >= z.cols[0] && c <= z.cols[1]);
     return z ? z.zone : 'ring';
   };
-  GW.indexPlate.ZONES.forEach(z => {
+  DUPRE.indexPlate.ZONES.forEach(z => {
     svgEl(s, 'rect', {
       x: PX + z.cols[0] * CW - 1, y: PY + z.rows[0] * CH - 1,
       width: (z.cols[1] - z.cols[0] + 1) * CW + 2, height: (z.rows[1] - z.rows[0] + 1) * CH + 2,
@@ -527,7 +527,7 @@ GW.indexPlate = function (host, opts = {}) {
   /* The stylus: a cone on a short shaft, hovering over the selected cell. The
      Mignon's arm reaches back to a pivot, but a full arm drawn here crosses the
      plate and hides the characters the operator is trying to read — the one thing
-     this widget must not do. A tip is enough to say "the pointer is here". */
+     this instrument must not do. A tip is enough to say "the pointer is here". */
   const arm = svgEl(s, 'g', {}); arm.setAttribute('class', 'ix-stylus');
   svgEl(arm, 'line', { x1: 0, y1: -9, x2: 0, y2: -20, stroke: 'url(#ixSteel)', 'stroke-width': 2.6 });
   svgEl(arm, 'circle', { cx: 0, cy: -21, r: 3.4, fill: 'url(#ixSteel)', stroke: '#5c626e', 'stroke-width': .6 });
@@ -601,7 +601,7 @@ GW.indexPlate = function (host, opts = {}) {
      primary input on this card would skip it and every probe would stay green.
      Gated on ACTIONS, so it selects nothing it has no cell for. */
   const press = k => {
-    if (!GW.indexPlate.ACTIONS.has(k)) return;
+    if (!DUPRE.indexPlate.ACTIONS.has(k)) return;
     if (k === 'PRINT') return print();
     if (k === 'CLR') return fresh();
     select(k);
@@ -617,7 +617,7 @@ GW.indexPlate = function (host, opts = {}) {
   s.addEventListener('click', () => s.focus());
   s.addEventListener('keydown', e => {
     if (e.ctrlKey || e.metaKey || e.altKey) return;
-    const k = GW.indexPlate.KEYS[e.key];
+    const k = DUPRE.indexPlate.KEYS[e.key];
     if (!k) return;
     e.preventDefault();          /* Enter would submit a form; a cell key has no default worth keeping */
     press(k);
@@ -639,7 +639,7 @@ GW.indexPlate = function (host, opts = {}) {
      - J and j live out on the ring, not in the case blocks, which is why the
        inversion below is positional and not "capitals are dark".
    The two dashes differ: a long one top-right, a hyphen bottom-right. */
-GW.indexPlate.LAYOUT = [
+DUPRE.indexPlate.LAYOUT = [
   ['&','(',')',':','"','!', '?',"'",'ä','ö','ü','—'],
   ['§','P','F','U','G','Q', 'p','f','u','g','q',';'],
   ['J','V','I','N','A','B', 'v','i','n','a','b','j'],
@@ -654,7 +654,7 @@ GW.indexPlate.LAYOUT = [
    the outer ring stays light-on-halftone — including the capital J, which is why
    no case-based rule can describe this. Move a block, move its rectangle.
    rows and cols are inclusive [start, end] indices into LAYOUT. */
-GW.indexPlate.ZONES = [
+DUPRE.indexPlate.ZONES = [
   { rows: [1, 5], cols: [1, 5], zone: 'caps' },
   { rows: [1, 5], cols: [6, 10], zone: 'lower' },
 ];
@@ -663,18 +663,18 @@ GW.indexPlate.ZONES = [
    Every plate character maps to itself (no case folding — the plate has both, so
    Shift does the work a shift key would), and Enter is the lever. Space is
    deliberately absent: there's no space cell yet, so Space isn't ours to claim. */
-GW.indexPlate.KEYS = (() => {
+DUPRE.indexPlate.KEYS = (() => {
   const m = {};
-  for (const c of GW.indexPlate.LAYOUT.flat()) if (c) m[c] = c;
+  for (const c of DUPRE.indexPlate.LAYOUT.flat()) if (c) m[c] = c;
   m.Enter = 'PRINT';
   return m;
 })();
 /* Every argument press accepts. A superset of the KEYS values: CLR is a real
    control that no keystroke reaches, the same shape as the keypad's. */
-GW.indexPlate.ACTIONS = new Set([...GW.indexPlate.LAYOUT.flat().filter(Boolean), 'PRINT', 'CLR']);
+DUPRE.indexPlate.ACTIONS = new Set([...DUPRE.indexPlate.LAYOUT.flat().filter(Boolean), 'PRINT', 'CLR']);
 
 /* 03 horizontal fader — continuous 0-100 */
-GW.faderH = function (host, opts = {}) {
+DUPRE.faderH = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const f = document.createElement('div'); f.className = 'fader';
   f.innerHTML = '<div class="slot"><div class="fill"></div></div><div class="cap"></div>';
@@ -692,7 +692,7 @@ GW.faderH = function (host, opts = {}) {
 };
 
 /* 04 vertical fader — one channel-strip fader; compose per channel */
-GW.faderV = function (host, opts = {}) {
+DUPRE.faderV = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const f = document.createElement('div'); f.className = 'vfader';
   f.innerHTML = '<div class="slot"><div class="fill"></div></div><div class="cap"></div>';
@@ -710,7 +710,7 @@ GW.faderV = function (host, opts = {}) {
 };
 
 /* 05 rotary knob — drag up/down to turn, -150°..+150° sweep */
-GW.knob = function (host, opts = {}) {
+DUPRE.knob = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const min = opts.min !== undefined ? opts.min : 0, max = opts.max !== undefined ? opts.max : 100;
   const k = document.createElement('span'); k.className = 'knob';
@@ -728,14 +728,14 @@ GW.knob = function (host, opts = {}) {
 };
 
 /* 06 segmented selector — pick one of a few. opts.accent picks the lit-segment
-   color from GW.segmented.STYLES (amber / green / red); defaults match the
+   color from DUPRE.segmented.STYLES (amber / green / red); defaults match the
    stylesheet fallbacks. setStyle(axis, name) restyles a live instance. */
-GW.segmented = function (host, opts = {}) {
+DUPRE.segmented = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const items = opts.items || ['TIMER', 'ALARM', 'POMO'];
   const seg = document.createElement('div'); seg.className = 'seg'; host.appendChild(seg);
   const setStyle = (axis, name) => {
-    const o = (GW.segmented.STYLES[axis] || {})[name];
+    const o = (DUPRE.segmented.STYLES[axis] || {})[name];
     if (!o) return;
     for (const [k, v] of Object.entries(o.vars)) seg.style.setProperty(k, v);
   };
@@ -748,7 +748,7 @@ GW.segmented = function (host, opts = {}) {
   return { el: seg, get: () => idx, set, setStyle };
 };
 /* named styles per axis: dot = swatch color for pickers, vars = --seg-* overrides */
-GW.segmented.STYLES = {
+DUPRE.segmented.STYLES = {
   accent: {
     amber: { dot: 'var(--gold-hi)', vars: { '--seg-on-bg': 'linear-gradient(180deg,var(--amber-grad-top),var(--gold))', '--seg-on-ink': 'var(--panel)' } },
     green: { dot: '#8fb944', vars: { '--seg-on-bg': 'linear-gradient(180deg,#a9c95f,var(--pass))', '--seg-on-ink': 'var(--panel)' } },
@@ -757,13 +757,13 @@ GW.segmented.STYLES = {
 };
 
 /* 07 chip toggle — inline binary inside a line of text */
-GW.chipToggle = function (host, opts = {}) {
+DUPRE.chipToggle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const chip = document.createElement('span'); chip.className = 'chip';
   chip.textContent = opts.label || 'discoverable on';
   host.appendChild(chip);
   const setStyle = (axis, name) => {
-    const o = (GW.chipToggle.STYLES[axis] || {})[name];
+    const o = (DUPRE.chipToggle.STYLES[axis] || {})[name];
     if (!o) return;
     for (const [k, v] of Object.entries(o.vars)) chip.style.setProperty(k, v);
   };
@@ -778,10 +778,10 @@ GW.chipToggle = function (host, opts = {}) {
    let the chip say exactly one thing — but "on" is good in one panel, a warning in
    the next, and a fault in the one after. The colour is the claim, so it belongs
    to the consumer. */
-GW.chipToggle.STYLES = { accent: GW.accentStyles('--chip-on') };
+DUPRE.chipToggle.STYLES = { accent: DUPRE.accentStyles('--chip-on') };
 
 /* 08 arm-to-fire — two-stage confirm for destructive actions */
-GW.armButton = function (host, opts = {}) {
+DUPRE.armButton = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const label = opts.label || 'forget', armLabel = opts.armLabel || label + '? again';
   const a = document.createElement('button'); a.className = 'arm'; a.textContent = label;
@@ -796,7 +796,7 @@ GW.armButton = function (host, opts = {}) {
 };
 
 /* 09 lamp row — actionable list item: lamp + name + status, click to cycle */
-GW.lampRow = function (host, opts = {}) {
+DUPRE.lampRow = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const name = opts.name || 'WH-1000XM4';
   const states = opts.states || [['gold', 'tap to connect'], ['busy', 'connecting…'], ['', 'connected']];
@@ -817,7 +817,7 @@ GW.lampRow = function (host, opts = {}) {
 };
 
 /* 24 rotary selector — pick one of five printed detents by position */
-GW.rotarySelector = function (host, opts = {}) {
+DUPRE.rotarySelector = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const values = opts.values || [4, 6, 8, 10, 12];
   const fmt = opts.fmt || (v => 'size ' + v);
@@ -846,9 +846,9 @@ GW.rotarySelector = function (host, opts = {}) {
    are the majors; the integer units between them get minor ticks and are
    selectable too. Click a numeral, a mark, or between marks; ←/→ (↑/↓) step
    one unit. set() takes a stop index; get() returns the value. opts.skin picks
-   a face from GW.slideRule.STYLES (warm backlit / chrome / 80s black glass / marantz blue);
+   a face from DUPRE.slideRule.STYLES (warm backlit / chrome / 80s black glass / marantz blue);
    setStyle(axis, name) restyles a live instance. */
-GW.slideRule = function (host, opts = {}) {
+DUPRE.slideRule = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const majors = opts.values || [4, 6, 8, 10, 12];
   const fmt = opts.fmt || (v => 'pos ' + v);
@@ -865,7 +865,7 @@ GW.slideRule = function (host, opts = {}) {
   const t = document.createElement('span'); t.className = 'tuner';
   t.tabIndex = 0; t.setAttribute('role', 'slider'); t.setAttribute('aria-label', 'slide-rule value');
   const setStyle = (axis, name) => {
-    const o = (GW.slideRule.STYLES[axis] || {})[name];
+    const o = (DUPRE.slideRule.STYLES[axis] || {})[name];
     if (!o) return;
     for (const [k, v] of Object.entries(o.vars)) t.style.setProperty(k, v);
   };
@@ -902,7 +902,7 @@ GW.slideRule = function (host, opts = {}) {
 };
 /* named faces: dot = swatch color for pickers, vars = --tn-* overrides.
    warm restates the stylesheet fallbacks so switching back is exact. */
-GW.slideRule.STYLES = {
+DUPRE.slideRule.STYLES = {
   skin: {
     warm: { dot: 'var(--gold-hi)', vars: {
       '--tn-bg': 'linear-gradient(180deg,#191510,#0b0908)', '--tn-brd': '#2a251c',
@@ -928,7 +928,7 @@ GW.slideRule.STYLES = {
 };
 
 /* N01 rocker power switch — hard on/off, lit legend */
-GW.rocker = function (host, opts = {}) {
+DUPRE.rocker = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const r = document.createElement('span'); r.className = 'rocker';
   r.innerHTML = `<span class="half top">${opts.onLabel || 'ON'}</span><span class="half bot">${opts.offLabel || 'OFF'}</span>`;
@@ -942,7 +942,7 @@ GW.rocker = function (host, opts = {}) {
 
 /* N02 transport cluster — rew/play/stop/rec, one lit; reels turn while playing.
    opts.animate: reels obey play state (default: not prefers-reduced-motion) */
-GW.transport = function (host, opts = {}) {
+DUPRE.transport = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const animate = opts.animate !== undefined ? opts.animate : !matchMedia('(prefers-reduced-motion: reduce)').matches;
   const MODES = { rew: '⏮', play: '▶', stop: '⏹', rec: '⏺' };
@@ -973,7 +973,7 @@ GW.transport = function (host, opts = {}) {
 };
 
 /* N03 radio preset bank — mechanically exclusive presets */
-GW.presetBank = function (host, opts = {}) {
+DUPRE.presetBank = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const items = opts.items || ['WIFI', 'ETH', 'CELL', 'OFF'];
   const bank = document.createElement('div'); bank.className = 'radiobank'; host.appendChild(bank);
@@ -986,7 +986,7 @@ GW.presetBank = function (host, opts = {}) {
 };
 
 /* N04 concentric dual knob — two values on one spindle, outer ring + inner cap */
-GW.dualKnob = function (host, opts = {}) {
+DUPRE.dualKnob = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const dk = document.createElement('span'); dk.className = 'dualknob';
   dk.innerHTML = `<span class="outer"><span class="tick" style="transform:rotate(-120deg)"></span><span class="tick" style="transform:rotate(120deg)"></span></span><span class="inner"><span class="ind"></span></span>`;
@@ -1007,7 +1007,7 @@ GW.dualKnob = function (host, opts = {}) {
 };
 
 /* N05 rotary encoder + LED ring — endless dial, lit arc tracks the level */
-GW.encoder = function (host, opts = {}) {
+DUPRE.encoder = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const enc = document.createElement('span'); enc.className = 'encoder'; host.appendChild(enc);
   const R = 27, cx = 33, cy = 33;
@@ -1032,7 +1032,7 @@ GW.encoder = function (host, opts = {}) {
 };
 
 /* N06 keyed mode switch — guarded three-position mode, key-bit points at the live one */
-GW.keySwitch = function (host, opts = {}) {
+DUPRE.keySwitch = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const items = opts.items || ['OFF', 'ON', 'RUN'];
   const ANG = [-70, 0, 70], POS = [[16, 64], [50, 12], [84, 64]];
@@ -1058,7 +1058,7 @@ GW.keySwitch = function (host, opts = {}) {
 };
 
 /* N07 center-detented crossfader — throw to either side of zero */
-GW.crossfader = function (host, opts = {}) {
+DUPRE.crossfader = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const xf = document.createElement('div'); xf.className = 'xfader';
   xf.innerHTML = `<div class="slot"></div><div class="detent"></div><span class="end" style="left:0">${opts.aLabel || 'A'}</span><span class="end" style="right:0">${opts.bLabel || 'B'}</span><div class="cap"></div>`;
@@ -1076,7 +1076,7 @@ GW.crossfader = function (host, opts = {}) {
 };
 
 /* N08 thumbwheel — knurled edge-wheel with a windowed two-digit value */
-GW.thumbwheel = function (host, opts = {}) {
+DUPRE.thumbwheel = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const w = document.createElement('div'); w.className = 'thumbw';
   w.innerHTML = '<span class="thumbwheel"></span><span class="win"></span>';
@@ -1094,7 +1094,7 @@ GW.thumbwheel = function (host, opts = {}) {
 };
 
 /* N09 DIP-switch bank — hard flags, up is on; readout is the binary word */
-GW.dipBank = function (host, opts = {}) {
+DUPRE.dipBank = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const bits = opts.bits || [true, false, true, true, false, false];
   const bank = document.createElement('span'); bank.className = 'dip'; host.appendChild(bank);
@@ -1110,7 +1110,7 @@ GW.dipBank = function (host, opts = {}) {
 };
 
 /* N10 jog / shuttle wheel — scrub fine; position accumulates without limit */
-GW.jogWheel = function (host, opts = {}) {
+DUPRE.jogWheel = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const j = document.createElement('span'); j.className = 'jog';
   j.innerHTML = `<span class="shuttle" style="--sh:40deg"></span><span class="inner"><span class="dimple"></span></span>`;
@@ -1127,7 +1127,7 @@ GW.jogWheel = function (host, opts = {}) {
 };
 
 /* ---- shared SVG defs: gradients/filters referenced by url(#id) are
-   document-scoped, and several are used across widgets. Builders ensure the
+   document-scoped, and several are used across instruments. Builders ensure the
    defs they use; the first caller creates it, later calls are no-ops. ---- */
 let defsRoot = null;
 const defsMade = new Set();
@@ -1161,7 +1161,7 @@ let uidN = 0;
 function uid(prefix) { return prefix + '-' + (++uidN); }
 
 /* R02 calibrated vernier dial — the disc turns under a fixed hairline */
-GW.vernierDial = function (host, opts = {}) {
+DUPRE.vernierDial = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 150, 150), cx = 75, cy = 75;
   gradDef('vernFace', 'radialGradient', { cx: '50%', cy: '45%', r: '60%' }, [['0', '#f7f2da'], ['1', '#e4dfc2']]);
@@ -1191,7 +1191,7 @@ GW.vernierDial = function (host, opts = {}) {
 };
 
 /* R03 bat-handle toggle — chrome lever throws between lit legends */
-GW.batToggle = function (host, opts = {}) {
+DUPRE.batToggle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 70, 90), cx = 35, cy = 44;
   gradDef('nutG', 'linearGradient', { x1: 0, y1: 0, x2: 0, y2: 1 }, [['0', '#8a8578'], ['1', '#4e4a42']]);
@@ -1222,7 +1222,7 @@ GW.batToggle = function (host, opts = {}) {
 };
 
 /* R04 bakelite fluted knob — scallop skirt over a printed 0-10 arc */
-GW.flutedKnob = function (host, opts = {}) {
+DUPRE.flutedKnob = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 110, 110), cx = 55, cy = 54;
   gradDef('bakeSk', 'radialGradient', { cx: '42%', cy: '36%', r: '80%' }, [['0', '#312d27'], ['1', '#050404']]);
@@ -1249,7 +1249,7 @@ GW.flutedKnob = function (host, opts = {}) {
 };
 
 /* R05 filter slider bank — a dense fader wall on a real faceplate. Period skins
-   as constructor opts backed by GW.filterBank.STYLES, three independent axes:
+   as constructor opts backed by DUPRE.filterBank.STYLES, three independent axes:
    panel (silver hi-fi aluminum / studio black), caps — the cap SHAPE
    (chrome T / short ribbed / tall block fader), and capColor — the cap
    FINISH (black white-index / color stripes / chrome / cream). opts.style
@@ -1257,13 +1257,13 @@ GW.flutedKnob = function (host, opts = {}) {
    opts.panel / opts.caps / opts.capColor override an axis; setStyle(axis, name)
    restyles live (values kept). After the Pioneer SG-9500, the Technics
    SH-8065, and the Zaxcom Oasis block faders. */
-GW.filterBank = function (host, opts = {}) {
+DUPRE.filterBank = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const freqs = opts.freqs || [78, 113, 163, 235, 339, 487, 701, 1010, 1450, 2090, 3010, 4340];
   const vals = (opts.values || [18, 30, 42, 25, 35, 55, 20, 48, 38, 26, 44, 32]).slice(0, freqs.length);
   while (vals.length < freqs.length) vals.push(30);
   const fmtHz = f => f < 1000 ? f : (f / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
-  const ST = GW.filterBank.STYLES;
+  const ST = DUPRE.filterBank.STYLES;
   const native = {
     silver: { caps: 'chrome', capColor: 'chrome' },
     studio: { caps: 'ribbed', capColor: 'red' },
@@ -1352,7 +1352,7 @@ GW.filterBank = function (host, opts = {}) {
 /* named styles per axis: dot = swatch color for pickers. caps is the cap
    shape; capColor is the cap finish (body + rib + index line), applicable to
    any shape. */
-GW.filterBank.STYLES = {
+DUPRE.filterBank.STYLES = {
   panel: {
     silver: { dot: '#c9c9c5', plate: 'url(#fbPlateSilver)', edge: '#8e8e88', bevel: 'rgba(255,255,255,.4)', ink: '#33332f', dim: '#5c5c56', screw: '#9c9c96', track: '#121210', trackW: 2.0, trackHi: null },
     studio: { dot: '#1c1a18', plate: 'url(#fbPlateStudio)', edge: '#000', bevel: 'rgba(255,255,255,.06)', ink: '#b9b4a6', dim: '#6f6a5e', screw: '#3c3832', track: '#050505', trackW: 2.2, trackHi: 'rgba(255,255,255,.05)' },
@@ -1374,7 +1374,7 @@ GW.filterBank.STYLES = {
 };
 
 /* R06 chicken-head selector — tapered lever aims at the position */
-GW.chickenHead = function (host, opts = {}) {
+DUPRE.chickenHead = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const items = opts.items || [['OFF', -60], ['LO', -20], ['MID', 20], ['HI', 60]];
   const s = stageSvg(host, 'rsvg press', 110, 96), cx = 55, cy = 58;
@@ -1405,7 +1405,7 @@ GW.chickenHead = function (host, opts = {}) {
 };
 
 /* R12 chrome slot fader — engraved dB scale, chrome T-handle in a screwed plate */
-GW.slotFader = function (host, opts = {}) {
+DUPRE.slotFader = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 90, 150), cx = 45, yTop = 30, yBot = 120;
   const yOf = db => yTop + (12 - db) / 36 * (yBot - yTop);
@@ -1442,7 +1442,7 @@ GW.slotFader = function (host, opts = {}) {
 };
 
 /* R14 spade-pointer tuning knob — engraved relief arc, knurl ring turns with it */
-GW.spadeKnob = function (host, opts = {}) {
+DUPRE.spadeKnob = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 140, 124), cx = 70, cy = 82;
   const sweep = v => -80 + v / 10 * 160;
@@ -1481,7 +1481,7 @@ GW.spadeKnob = function (host, opts = {}) {
 };
 
 /* R15 multi-band dial — nested arcs, one needle; the bandspread dial selects the ring */
-GW.multiBandDial = function (host, opts = {}) {
+DUPRE.multiBandDial = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const ranges = opts.ranges || [[0.54, 1.6], [1.6, 5.1], [5.1, 15.5], [15.5, 30.5]];
   const s = stageSvg(host, 'rsvg', 190, 110), cx = 62, cy = 62;
@@ -1532,7 +1532,7 @@ GW.multiBandDial = function (host, opts = {}) {
 };
 
 /* R16 entry keypad — worn keys feed the amber display; lamps watch state */
-GW.entryKeypad = function (host, opts = {}) {
+DUPRE.entryKeypad = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 150, 190);
   gradDef('kpKey', 'linearGradient', { x1: 0, y1: 0, x2: 0, y2: 1 }, [['0', '#dbd8cf'], ['1', '#a29d92']]);
@@ -1570,7 +1570,7 @@ GW.entryKeypad = function (host, opts = {}) {
 };
 
 /* R18 thumb-slide attenuator pair — lit numeral strip, cream side tab */
-GW.thumbSlide = function (host, opts = {}) {
+DUPRE.thumbSlide = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const chans = (opts.channels || [{ name: 'BLEND', v: 74 }, { name: 'MIX', v: 92 }]).map(c => ({ name: c.name, v: c.v }));
   const s = stageSvg(host, 'rsvg', 130, 150), y0 = 22, y1 = 122;
@@ -1616,7 +1616,7 @@ GW.thumbSlide = function (host, opts = {}) {
 };
 
 /* R19 waveform region editor — monochrome LCD, draggable S/E flags */
-GW.waveRegion = function (host, opts = {}) {
+DUPRE.waveRegion = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 190, 100), x0 = 10, x1 = 180, yMid = 48, N = 85;
   svgEl(s, 'rect', { x: 1, y: 1, width: 188, height: 98, rx: 6, fill: 'var(--scr-bg1,#0b0c0b)', stroke: 'var(--scr-brd,#2a2c2a)', 'stroke-width': 2 });
@@ -1667,7 +1667,7 @@ GW.waveRegion = function (host, opts = {}) {
 };
 
 /* R20 drum roller selector — numbered paper drum in a window, center chip reads it */
-GW.drumRoller = function (host, opts = {}) {
+DUPRE.drumRoller = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const chans = (opts.channels || [{ name: 'HIGH', v: 6 }, { name: 'LOW', v: 8 }]).map(c => ({ name: c.name, v: c.v }));
   const s = stageSvg(host, 'rsvg', 130, 140), cy = 76, step = 17;
@@ -1710,7 +1710,7 @@ GW.drumRoller = function (host, opts = {}) {
 };
 
 /* R21 LED program row — exclusive select, the LED above the key carries the state */
-GW.ledRow = function (host, opts = {}) {
+DUPRE.ledRow = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const items = opts.items || ['Sm Hall B', 'VocPlate', 'Lg Hall B', 'Chamber', 'ParcPlate', 'Sm Hall A', 'Room A', 'Const Plate'];
   const s = stageSvg(host, 'rsvg', 190, 58);
@@ -1741,7 +1741,7 @@ GW.ledRow = function (host, opts = {}) {
 };
 
 /* R22 three-position slide — chrome pill between detents, honest LED pair */
-GW.pillSlide = function (host, opts = {}) {
+DUPRE.pillSlide = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const positions = opts.positions || ['A', 'AB', 'B'];
   const s = stageSvg(host, 'rsvg press', 110, 64), detX = [34, 55, 76];
@@ -1776,7 +1776,7 @@ GW.pillSlide = function (host, opts = {}) {
 };
 
 /* R23 spun-aluminum knob — machined rings in a knurled grip, red index */
-GW.spunKnob = function (host, opts = {}) {
+DUPRE.spunKnob = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 110, 110), cx = 55, cy = 52;
   gradDef('spunFace', 'radialGradient', { cx: '42%', cy: '34%', r: '85%' }, [['0', '#e8e6e0'], ['.7', '#b3b0a8'], ['1', '#8a877e']]);
@@ -1801,7 +1801,7 @@ GW.spunKnob = function (host, opts = {}) {
 };
 
 /* R24 stomp switch + jewel — press to engage, the jewel reports */
-GW.stompSwitch = function (host, opts = {}) {
+DUPRE.stompSwitch = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 110, 110), cx = 55;
   gradDef('stompDome', 'radialGradient', { cx: '40%', cy: '30%', r: '80%' }, [['0', '#f4f2ec'], ['.55', '#b9b6ae'], ['1', '#6e6b63']]);
@@ -1835,7 +1835,7 @@ GW.stompSwitch = function (host, opts = {}) {
 };
 
 /* R27 winged gain selector — red T-bar over a dot ring, stepped detents */
-GW.wingSelector = function (host, opts = {}) {
+DUPRE.wingSelector = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const steps = opts.steps || [-80, -70, -60, -50, -40, -30, -20, -10, -5, 0, 5, 10];
   const s = stageSvg(host, 'rsvg drag', 110, 110), cx = 55, cy = 52;
@@ -1868,7 +1868,7 @@ GW.wingSelector = function (host, opts = {}) {
 };
 
 /* R28 rotary disc switch — the whole disc turns between heavy positions */
-GW.discSwitch = function (host, opts = {}) {
+DUPRE.discSwitch = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const positions = opts.positions || [['OFF', -45], ['ON', 45], ['COMBINE', 135]];
   const s = stageSvg(host, 'rsvg press', 110, 116), cx = 55, cy = 58;
@@ -1903,7 +1903,7 @@ GW.discSwitch = function (host, opts = {}) {
 };
 
 /* R29 guarded toggle — guard posts + red collar mark the critical throw */
-GW.guardedToggle = function (host, opts = {}) {
+DUPRE.guardedToggle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 90, 100), cx = 45, cy = 52;
   gradDef('discRed', 'radialGradient', { cx: '42%', cy: '34%', r: '85%' }, [['0', '#d98a6f'], ['.65', 'var(--fail)'], ['1', '#7a2a1a']]);
@@ -1942,7 +1942,7 @@ GW.guardedToggle = function (host, opts = {}) {
 
 /* R32 mechanical timer dial — dial rotates under a fixed index; wind by drag, stop by the red knob.
    Runs its own 1 Hz wind-down (a demo minute per second) unless reduced motion is set. */
-GW.timerDial = function (host, opts = {}) {
+DUPRE.timerDial = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 158, 132), cx = 62, cy = 58;
   gradDef('mtFace', 'radialGradient', { cx: '50%', cy: '42%', r: '75%' }, [['0', '#282320'], ['1', '#14110e']]);
@@ -2003,7 +2003,7 @@ GW.timerDial = function (host, opts = {}) {
 };
 
 /* R33 four-way rocker — quadrant clicks step a tracked cursor; arrows flash on press */
-GW.rockerPad = function (host, opts = {}) {
+DUPRE.rockerPad = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 110, 110), cx = 55, cy = 55;
   gradDef('rk4Pad', 'radialGradient', { cx: '42%', cy: '34%', r: '85%' }, [['0', '#33302b'], ['1', '#141210']]);
@@ -2042,7 +2042,7 @@ GW.rockerPad = function (host, opts = {}) {
 };
 
 /* R34 four-way toggle selector — ball lever throws to a diagonal; corner lamps show the state */
-GW.fourWayToggle = function (host, opts = {}) {
+DUPRE.fourWayToggle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 130, 130), cx = 65, cy = 65;
   gradDef('fw4Chrome', 'linearGradient', { x1: 0, y1: 0, x2: 1, y2: 1 }, [['0', '#e8e6e0'], ['.5', '#9a968c'], ['1', '#55524a']]);
@@ -2100,7 +2100,7 @@ GW.fourWayToggle = function (host, opts = {}) {
 };
 
 /* R37 pin routing matrix — click an intersection to seat/pull a pin; many-to-many */
-GW.pinMatrix = function (host, opts = {}) {
+DUPRE.pinMatrix = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const ROWS = opts.rows || ['OSC1', 'OSC2', 'LFO', 'NOIS', 'ENV'];
   const COLS = opts.cols || ['VCF', 'VCA', 'PAN', 'DLY', 'OUT', 'MOD'];
@@ -2128,7 +2128,7 @@ GW.pinMatrix = function (host, opts = {}) {
 };
 
 /* R38 dead-man button — state exists only while the pointer holds it down */
-GW.deadMan = function (host, opts = {}) {
+DUPRE.deadMan = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 120, 110), cx = 60, cy = 58;
   gradDef('dmBtn', 'radialGradient', { cx: '40%', cy: '32%', r: '85%' }, [['0', '#3a3631'], ['1', '#16130f']]);
@@ -2168,7 +2168,7 @@ GW.deadMan = function (host, opts = {}) {
 };
 
 /* R39 rotary telephone dial — click a hole; the wheel winds to the stop and returns */
-GW.telephoneDial = function (host, opts = {}) {
+DUPRE.telephoneDial = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 130, 130), cx = 65, cy = 63;
   const DIGITS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'];
@@ -2220,7 +2220,7 @@ GW.telephoneDial = function (host, opts = {}) {
 };
 
 /* R40 circuit breaker panel — on/off by click, TRIP pops one to the amber mid-state, reset is two-step */
-GW.breakerPanel = function (host, opts = {}) {
+DUPRE.breakerPanel = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const NAMES = opts.names || ['MAIN', 'PUMP', 'LAMP', 'AUX'];
   const s = stageSvg(host, 'rsvg press', 160, 110);
@@ -2260,7 +2260,7 @@ GW.breakerPanel = function (host, opts = {}) {
 };
 
 /* R41 DSKY — verb/noun command grammar with status lamps and a lamp-test verb */
-GW.dsky = function (host, opts = {}) {
+DUPRE.dsky = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const LAMPS = ['UPLINK', 'TEMP', 'GIMBAL', 'PROG', 'RESTART', 'OPR ERR'];
   const el = document.createElement('div'); el.className = 'dsky'; host.appendChild(el);
@@ -2312,7 +2312,7 @@ GW.dsky = function (host, opts = {}) {
 
 /* R42 cam-timer program drum — the program is a ring; the pointer self-advances through it.
    Runs its own reduced-motion-gated 2 s step interval once started. */
-GW.camTimer = function (host, opts = {}) {
+DUPRE.camTimer = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const STEPS = opts.steps || ['OFF', 'FILL', 'WASH', 'WASH', 'WASH', 'RINSE', 'RINSE', 'DRAIN', 'SPIN', 'SPIN', 'FLUFF', 'COOL'];
   const COLS = opts.colors || { OFF: '#3a3426', FILL: '#54677d', WASH: '#d29638', RINSE: '#46b89e', DRAIN: '#969385', SPIN: '#cb6b4d', FLUFF: '#c9b98a', COOL: '#7c99b0' };
@@ -2348,7 +2348,7 @@ GW.camTimer = function (host, opts = {}) {
 };
 
 /* R48 knife switch (side view) — the blade hinges at the left post and lands in the right jaw */
-GW.knifeSwitch = function (host, opts = {}) {
+DUPRE.knifeSwitch = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 130, 110);
   gradDef('ksCu', 'linearGradient', { x1: 0, y1: 0, x2: 0, y2: 1 }, [['0', '#d09a5c'], ['1', '#8a5a2a']]);
@@ -2383,7 +2383,7 @@ GW.knifeSwitch = function (host, opts = {}) {
 };
 
 /* R49 decade box — four skirted knobs, one digit each; the value is their sum */
-GW.decadeBox = function (host, opts = {}) {
+DUPRE.decadeBox = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const MUL = [1000, 100, 10, 1], LBL = ['x1000', 'x100', 'x10', 'x1'];
   const digs = (opts.digits || [3, 5, 0, 0]).slice();
@@ -2419,7 +2419,7 @@ GW.decadeBox = function (host, opts = {}) {
 };
 
 /* R50 two-hand safety — one palm button arms a 500ms window; the other completes the cycle */
-GW.twoHandSafety = function (host, opts = {}) {
+DUPRE.twoHandSafety = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 160, 100);
   svgEl(s, 'rect', { x: 2, y: 2, width: 156, height: 96, rx: 8, fill: '#1c1916', stroke: '#060505', 'stroke-width': 1.5 });
@@ -2462,7 +2462,7 @@ GW.twoHandSafety = function (host, opts = {}) {
 };
 
 /* R51 voice-loop keyset — independent monitor states, exclusive talk, activity flicker */
-GW.voiceLoop = function (host, opts = {}) {
+DUPRE.voiceLoop = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const LOOPS = opts.loops || ['FD', 'GNC', 'ECOM', 'SURG', 'A/G', 'NET1', 'NET2', 'PAO'];
   const el = document.createElement('div'); el.className = 'vloop'; host.appendChild(el);
@@ -2508,7 +2508,7 @@ GW.voiceLoop = function (host, opts = {}) {
    belongs to the instrument (peak-hold, history buffers) lives in here. */
 
 /* 10 needle gauge — drag up/down sweeps the needle over a 120° arc */
-GW.needleGauge = function (host, opts = {}) {
+DUPRE.needleGauge = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let v = opts.value ?? 50;
   const el = document.createElement('div'); el.className = 'gauge';
@@ -2529,7 +2529,7 @@ GW.needleGauge = function (host, opts = {}) {
 };
 
 /* 11 stereo VU — two LED bars with peak-hold; set(l, r) drives both */
-GW.vuPair = function (host, opts = {}) {
+DUPRE.vuPair = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const n = opts.bars || 16;
   const el = document.createElement('div'); el.className = 'vu';
@@ -2558,7 +2558,7 @@ GW.vuPair = function (host, opts = {}) {
 };
 
 /* 12 mini 4-bar signal — compact activity meter; set(level) */
-GW.miniSig = function (host, opts = {}) {
+DUPRE.miniSig = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const el = document.createElement('span'); el.className = 'sig';
   el.innerHTML = '<i></i><i></i><i></i><i></i>';
@@ -2574,7 +2574,7 @@ GW.miniSig = function (host, opts = {}) {
 };
 
 /* 13 signal ladder — stepped 0-4 strength; click cycles */
-GW.signalLadder = function (host, opts = {}) {
+DUPRE.signalLadder = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let v = opts.value ?? 3;
   const el = document.createElement('span'); el.className = 'ladder';
@@ -2592,7 +2592,7 @@ GW.signalLadder = function (host, opts = {}) {
 };
 
 /* 14 linear fuel bar — one 0-100 bar, warn tint under the threshold; drag to set */
-GW.fuelBar = function (host, opts = {}) {
+DUPRE.fuelBar = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const warnAt = opts.warnAt ?? 20;
   let v = opts.value ?? 50;
@@ -2612,7 +2612,7 @@ GW.fuelBar = function (host, opts = {}) {
 };
 
 /* 15 radial ring — percentage donut; drag up/down to set */
-GW.radialRing = function (host, opts = {}) {
+DUPRE.radialRing = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let v = opts.value ?? 68;
   const el = document.createElement('span'); el.className = 'ring';
@@ -2631,7 +2631,7 @@ GW.radialRing = function (host, opts = {}) {
 };
 
 /* 16 sparkline — rolling history trace; push(v) appends a sample, fill(v) levels it */
-GW.sparkline = function (host, opts = {}) {
+DUPRE.sparkline = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const n = opts.samples || 40;
   const hist = Array.from({ length: n }, () => opts.value ?? 0.5);
@@ -2650,7 +2650,7 @@ GW.sparkline = function (host, opts = {}) {
 };
 
 /* 17 waveform strip — sampled trace; set(samples, amp) with samples in -1..1 */
-GW.waveStrip = function (host, opts = {}) {
+DUPRE.waveStrip = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const el = document.createElement('span'); el.className = 'wave';
   el.innerHTML = '<svg viewBox="0 0 170 38" preserveAspectRatio="none"><path fill="none" stroke="var(--gold)" stroke-width="1.2"/></svg>';
@@ -2671,7 +2671,7 @@ GW.waveStrip = function (host, opts = {}) {
 };
 
 /* N11 oscilloscope — sampled phosphor trace; set(samples, vpp) with samples in -1..1 */
-GW.scope = function (host, opts = {}) {
+DUPRE.scope = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const el = document.createElement('span'); el.className = 'scope';
   el.innerHTML = '<span class="grat"></span><svg viewBox="0 0 176 78" preserveAspectRatio="none"><polyline/></svg>';
@@ -2688,7 +2688,7 @@ GW.scope = function (host, opts = {}) {
 };
 
 /* N12 spectrum / EQ bars — set(values) paints one column per band */
-GW.eqBars = function (host, opts = {}) {
+DUPRE.eqBars = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const bands = opts.bands || 11, cells = opts.cells || 9;
   const el = document.createElement('span'); el.className = 'eq';
@@ -2717,7 +2717,7 @@ GW.eqBars = function (host, opts = {}) {
 };
 
 /* N13 crossed-needle meter — one drive value, FWD and RFL needles cross */
-GW.crossNeedle = function (host, opts = {}) {
+DUPRE.crossNeedle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let v = opts.value ?? 55;
   const el = document.createElement('div'); el.className = 'crossm';
@@ -2738,7 +2738,7 @@ GW.crossNeedle = function (host, opts = {}) {
 };
 
 /* N14 thermometer column — mercury rises with the value */
-GW.thermometer = function (host, opts = {}) {
+DUPRE.thermometer = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let v = opts.value ?? 58;
   const el = document.createElement('div'); el.className = 'thermo';
@@ -2757,7 +2757,7 @@ GW.thermometer = function (host, opts = {}) {
 };
 
 /* N15 bourdon pressure gauge — needle over a printed arc with a redline */
-GW.bourdon = function (host, opts = {}) {
+DUPRE.bourdon = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let v = opts.value ?? 45;
   const el = document.createElement('div'); el.className = 'bourdon';
@@ -2778,7 +2778,7 @@ GW.bourdon = function (host, opts = {}) {
 
 /* N16 strip-chart recorder — scrolling history, pen rides the newest value;
    push(v) appends, set(samples, current) replaces the trace (values 0..1) */
-GW.stripChart = function (host, opts = {}) {
+DUPRE.stripChart = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const n = opts.samples || 60;
   const hist = Array.from({ length: n }, () => opts.value ?? 0.5);
@@ -2802,7 +2802,7 @@ GW.stripChart = function (host, opts = {}) {
 };
 
 /* N17 correlation meter — needle rests at 0 and swings ±; drag left/right */
-GW.corrMeter = function (host, opts = {}) {
+DUPRE.corrMeter = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   let p = opts.value ?? 58;
   const el = document.createElement('div'); el.className = 'corr';
@@ -2822,7 +2822,7 @@ GW.corrMeter = function (host, opts = {}) {
 };
 
 /* N18 battery-cell gauge — charge as discrete cells, the low end warns */
-GW.battCells = function (host, opts = {}) {
+DUPRE.battCells = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const cells = opts.cells || 8, warnAt = opts.warnAt ?? 25;
   let p = opts.value ?? 62;
@@ -2844,7 +2844,7 @@ GW.battCells = function (host, opts = {}) {
 
 /* R01 moving-coil VU — pivot below the face, authentic nonlinear dB scale;
    set(t) positions instantly (0..1.02); ballistics belong to the signal owner */
-GW.mcVu = function (host, opts = {}) {
+DUPRE.mcVu = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 150, 96);
   const cx = 75, cy = 112, sweep = t => -43 + t * 86;
@@ -2896,7 +2896,7 @@ GW.mcVu = function (host, opts = {}) {
 };
 
 /* R07 round panel meter — porthole bezel, same VU law as R01; drag up/down */
-GW.roundMeter = function (host, opts = {}) {
+DUPRE.roundMeter = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 110, 104);
   const cx = 55, fy = 54, py = 74, sweep = t => -40 + t * 80;
@@ -2948,7 +2948,7 @@ GW.roundMeter = function (host, opts = {}) {
 };
 
 /* R08 chrome MIN/MAX indicator — dark pointer over a brushed dome */
-GW.chromeMinMax = function (host, opts = {}) {
+DUPRE.chromeMinMax = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 110, 104);
   const cx = 55, cy = 58;
@@ -2991,7 +2991,7 @@ GW.chromeMinMax = function (host, opts = {}) {
 };
 
 /* R09 black-face aviation gauge — zone arcs per the airspeed-indicator scheme */
-GW.aviationGauge = function (host, opts = {}) {
+DUPRE.aviationGauge = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg drag', 110, 104);
   const cx = 55, cy = 52, sweep = t => -135 + t * 270;
@@ -3045,7 +3045,7 @@ GW.aviationGauge = function (host, opts = {}) {
 };
 
 /* R13 edgewise strip meter — compressed log scale, the bar rides the edge */
-GW.edgeMeter = function (host, opts = {}) {
+DUPRE.edgeMeter = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const SCALE = [[0, .08], [3, .26], [6, .44], [12, .62], [20, .78], [40, .94]];
   const s = stageSvg(host, 'rsvg drag', 70, 130);
@@ -3086,9 +3086,9 @@ GW.edgeMeter = function (host, opts = {}) {
   return { el: s, get: () => frac, set };
 };
 
-/* R17 round CRT scope — pale phosphor face; the trace is the widget's own
+/* R17 round CRT scope — pale phosphor face; the trace is the instrument's own
    animation, so it lives here with its reduced-motion gate */
-GW.roundCrt = function (host, opts = {}) {
+DUPRE.roundCrt = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 110, 104);
   const cx = 55, cy = 52;
@@ -3098,7 +3098,7 @@ GW.roundCrt = function (host, opts = {}) {
     const fl = svgEl(d, 'filter', { id: 'avGlow', x: '-60%', y: '-60%', width: '220%', height: '220%' });
     svgEl(fl, 'feGaussianBlur', { in: 'SourceGraphic', stdDeviation: 1.4 });
   });
-  /* the face gradient reads screen-family vars from this widget's subtree,
+  /* the face gradient reads screen-family vars from this instrument's subtree,
      so it must live in the local defs, not the shared def sink */
   const defs = svgEl(s, 'defs', {});
   const ph = svgEl(defs, 'radialGradient', { id: faceId, cx: '50%', cy: '44%', r: '70%' });
@@ -3139,7 +3139,7 @@ GW.roundCrt = function (host, opts = {}) {
 };
 
 /* R43 attitude indicator — sky/ground roll+shift behind a fixed miniature aircraft; 2D drag */
-GW.attitudeIndicator = function (host, opts = {}) {
+DUPRE.attitudeIndicator = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 130, 130);
   const cx = 65, cy = 65;
@@ -3194,8 +3194,8 @@ GW.attitudeIndicator = function (host, opts = {}) {
 };
 
 /* R44 heading bug + servo needle — drag parks the command; the needle chases
-   with honest servo lag (widget-owned animation, reduced-motion gated) */
-GW.headingBug = function (host, opts = {}) {
+   with honest servo lag (instrument-owned animation, reduced-motion gated) */
+DUPRE.headingBug = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 130, 130);
   const cx = 65, cy = 65;
@@ -3245,8 +3245,8 @@ GW.headingBug = function (host, opts = {}) {
 };
 
 /* R53 circular chart recorder — a day per revolution; the pen draws the cycle
-   (widget-owned clock, reduced-motion paints the full day once); click for fresh paper */
-GW.chartRecorder = function (host, opts = {}) {
+   (instrument-owned clock, reduced-motion paints the full day once); click for fresh paper */
+DUPRE.chartRecorder = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 130, 130);
   const cx = 65, cy = 65;
@@ -3296,7 +3296,7 @@ GW.chartRecorder = function (host, opts = {}) {
 };
 
 /* R54 vertical tape instrument — the scale scrolls behind a fixed index; drag to drive */
-GW.verticalTape = function (host, opts = {}) {
+DUPRE.verticalTape = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 70, 130);
   const CX = 38, CY = 65;
@@ -3338,7 +3338,7 @@ GW.verticalTape = function (host, opts = {}) {
 };
 
 /* R55 twin-needle gauge — mirrored half-scales, one hub, two independent needles */
-GW.twinNeedle = function (host, opts = {}) {
+DUPRE.twinNeedle = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 120, 110);
   const cx = 60, cy = 62, R = 44;
@@ -3406,7 +3406,7 @@ GW.twinNeedle = function (host, opts = {}) {
 };
 
 /* R56 comfort-zone crossed needles — temp and humidity cross over printed verdicts */
-GW.comfortMeter = function (host, opts = {}) {
+DUPRE.comfortMeter = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 130, 122);
   const cx = 65, cy = 60;
@@ -3502,7 +3502,7 @@ GW.comfortMeter = function (host, opts = {}) {
 /* ================= indicators & readouts ================= */
 
 /* 18 status lamps — one lamp per health state; click any lamp to cycle it */
-GW.statusLamps = function (host, opts = {}) {
+DUPRE.statusLamps = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const CLS = ['lamp', 'lamp gold', 'lamp red', 'lamp off', 'lamp busy'];
   const NAMES = ['ok', 'engaged', 'fault', 'off', 'busy'];
@@ -3525,7 +3525,7 @@ GW.statusLamps = function (host, opts = {}) {
 };
 
 /* 19 badges — labelled flags; click a badge to cycle its variant */
-GW.badges = function (host, opts = {}) {
+DUPRE.badges = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const CLS = ['badge', 'badge red', 'badge ghost'];
   const items = opts.items || [['TUNNEL', 0], ['LOW BATT', 1], ['2.4G', 2]];
@@ -3550,7 +3550,7 @@ GW.badges = function (host, opts = {}) {
 
 /* 20 tabular readout — mm:ss countdown; builder owns the state, the page
    drives tick() on its own clock (tick contract); click pauses/resumes */
-GW.tabularReadout = function (host, opts = {}) {
+DUPRE.tabularReadout = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const wrap = document.createElement('div'); wrap.style.textAlign = 'center';
   wrap.innerHTML = '<div class="readout"></div><span class="u"></span>';
@@ -3569,7 +3569,7 @@ GW.tabularReadout = function (host, opts = {}) {
 };
 
 /* 21 engraved label — hairline-flanked caps label with a count; click bumps 1-9 */
-GW.engravedLabel = function (host, opts = {}) {
+DUPRE.engravedLabel = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const e = document.createElement('span'); e.className = 'engrave';
   e.append(opts.label || 'outputs');
@@ -3584,7 +3584,7 @@ GW.engravedLabel = function (host, opts = {}) {
 
 /* 22 output well — streaming step log, lamp per step; click streams the next
    demo step; push([lampCls, name, evidence]) appends programmatically */
-GW.outputWell = function (host, opts = {}) {
+DUPRE.outputWell = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const seed = opts.seed || [['', 'Link', 'wlp170s0 · @Hyatt'], ['gold', 'DNS', 'resolving…']];
   const steps = opts.steps || [['gold', 'Probe', '8.8.8.8 …'], ['', 'Gateway', '10.0.0.1 ok'], ['', 'DNS', '1.1.1.1 ok'], ['red', 'Retry', 'timeout']];
@@ -3605,7 +3605,7 @@ GW.outputWell = function (host, opts = {}) {
 
 /* 23 toast — one-line transient confirmation; click fires the next demo
    message; fire(msg) shows any message with the fade-in */
-GW.toast = function (host, opts = {}) {
+DUPRE.toast = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const msgs = opts.msgs || ['link up · 300 Mbps', 'bt paired — WH-1000XM4', 'profile switched', 'joined @Hyatt_WiFi — saved'];
   const t = document.createElement('span'); t.className = 'toastw';
@@ -3622,7 +3622,7 @@ GW.toast = function (host, opts = {}) {
 };
 
 /* 26 nixie tubes — one lit numeral per tube, leading zeros dark; click increments */
-GW.nixie = function (host, opts = {}) {
+DUPRE.nixie = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const digits = opts.digits || 2;
   const max = Math.pow(10, digits);
@@ -3671,8 +3671,8 @@ GW.nixie = function (host, opts = {}) {
              setStyle(axis, name), chars, flapMs()/setFlapMs(ms) (base flap
              rate, clamped 20-400), onSettle(cb) — cb(reading) fires once per
              command when every cell has arrived (dwell hook).
-   CSS lives in the "split-flap" block of GW_CSS; no other styles involved. */
-GW.splitFlap = function (host, opts = {}) {
+   CSS lives in the "split-flap" block of DUPRE_CSS; no other styles involved. */
+DUPRE.splitFlap = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const words = opts.words || ['DNS ', 'LINK', 'SYNC', 'WIFI', 'SCAN'];
   const animate = opts.animate !== undefined ? !!opts.animate : true;
@@ -3802,7 +3802,7 @@ GW.splitFlap = function (host, opts = {}) {
   // construction axes (skin, font): swap this axis's classes per STYLES.
   // Polarity and typeface are construction, not accent — no colour policy.
   const setStyle = (axis, name) => {
-    const ax = GW.splitFlap.STYLES[axis]; const o = ax && ax[name];
+    const ax = DUPRE.splitFlap.STYLES[axis]; const o = ax && ax[name];
     if (!o) return;
     Object.values(ax).forEach(v => { if (v.cls) f.classList.remove(v.cls); });
     if (o.cls) f.classList.add(o.cls);
@@ -3818,7 +3818,7 @@ GW.splitFlap = function (host, opts = {}) {
     flapMs: () => flapMs, setFlapMs: ms => { flapMs = clampMs(ms); },
   };
 };
-GW.splitFlap.STYLES = {
+DUPRE.splitFlap.STYLES = {
   // board polarity + ink: dark board with the kit's cream ink (default),
   // dark board with true-white ink, or the inverse ivory board
   // dot: the board colour; the gallery card letters each chip in the skin's
@@ -3838,7 +3838,7 @@ GW.splitFlap.STYLES = {
 
 /* N21 seven-segment countdown — mm:ss in lit segments; the page drives tick();
    click adds a minute */
-GW.sevenSeg = function (host, opts = {}) {
+DUPRE.sevenSeg = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const sv = document.createElement('span'); sv.className = 'seven'; host.appendChild(sv);
   let secs;
@@ -3854,7 +3854,7 @@ GW.sevenSeg = function (host, opts = {}) {
 };
 
 /* N22 VFD marquee — teal dot-matrix scroll; the page drives tick(); click cycles the message */
-GW.vfdMarquee = function (host, opts = {}) {
+DUPRE.vfdMarquee = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const msgs = opts.msgs || ['ARCHSETUP · NET OK · BT 2 · SND 62%', 'WIFI @Hyatt · 300 Mbps · VPN UP', 'BATTERY 84% · DISK 61% · TEMP 47C'];
   const W = opts.width || 176;
@@ -3876,7 +3876,7 @@ GW.vfdMarquee = function (host, opts = {}) {
 
 /* N23 annunciator — named alarm grid with the raise → MSTR CAUTION → ACK → RESET
    lifecycle; TEST proves the bulbs then restores the board */
-GW.annunciator = function (host, opts = {}) {
+DUPRE.annunciator = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const CLS = ['acell', 'acell warn', 'acell fault'];
   const NAMES = ['ok', 'warn', 'fault'];
@@ -3923,7 +3923,7 @@ GW.annunciator = function (host, opts = {}) {
 };
 
 /* N24 jewel pilot lamps — faceted bezel indicators; click cycles red · amber · green · dark */
-GW.jewels = function (host, opts = {}) {
+DUPRE.jewels = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const cols = ['var(--jewel-r)', 'var(--jewel-a)', 'var(--jewel-g)'];
   const NAMES = ['red', 'amber', 'green'];
@@ -3947,7 +3947,7 @@ GW.jewels = function (host, opts = {}) {
 };
 
 /* N25 tape counter — odometer wheels; set(total) rolls each wheel to its digit */
-GW.tapeCounter = function (host, opts = {}) {
+DUPRE.tapeCounter = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const wheels = opts.wheels || 6, redFrom = opts.redFrom !== undefined ? opts.redFrom : 4;
   const ct = document.createElement('span'); ct.className = 'counter'; host.appendChild(ct);
@@ -3971,7 +3971,7 @@ GW.tapeCounter = function (host, opts = {}) {
 
 /* N26 analog clock — engraved ticks + three hands; the page owns the time source
    and drives set(h, m, s); silent until the first set, like the live original */
-GW.analogClock = function (host, opts = {}) {
+DUPRE.analogClock = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const cl = document.createElement('span'); cl.className = 'clock';
   for (let i = 0; i < 12; i++) { const t = document.createElement('span'); t.className = 'tk'; t.style.transform = `rotate(${i * 30}deg)`; cl.appendChild(t); }
@@ -3989,7 +3989,7 @@ GW.analogClock = function (host, opts = {}) {
 
 /* N27 frequency-dial scale — printed log axis, marks crowd low and spread high;
    drag the pointer to tune */
-GW.freqScale = function (host, opts = {}) {
+DUPRE.freqScale = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const W = opts.width || 184;
   const marks = opts.marks || [0.5, 1, 2, 3, 5, 7, 10, 14, 20];
@@ -4021,7 +4021,7 @@ GW.freqScale = function (host, opts = {}) {
 
 /* N28 patch bay — jack grid with SVG cables; click one jack then another to
    patch or unpatch the pair; redraws itself on window resize */
-GW.patchBay = function (host, opts = {}) {
+DUPRE.patchBay = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const rows = opts.rows || 2, cols = opts.cols || 4;
   const patch = document.createElement('div'); patch.className = 'patch';
@@ -4065,7 +4065,7 @@ GW.patchBay = function (host, opts = {}) {
 
 /* R10 data matrix readout — a page of labeled amber fields; click cycles pages;
    a page marked live re-renders on the builder's own 1s clock (reduced-motion gated) */
-GW.dataMatrix = function (host, opts = {}) {
+DUPRE.dataMatrix = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const pages = opts.pages || [
     ['SYS', () => ['CPU 42   MEM 61', 'DSK 58   TMP 47C', 'ARCH 6.18 LTS']],
@@ -4081,7 +4081,7 @@ GW.dataMatrix = function (host, opts = {}) {
     const fl = svgEl(d, 'filter', { id: 'dmxGlow', x: '-30%', y: '-30%', width: '160%', height: '160%' });
     svgEl(fl, 'feGaussianBlur', { in: 'SourceGraphic', stdDeviation: 1.1 });
   });
-  /* the background gradient reads screen-family vars from this widget's subtree,
+  /* the background gradient reads screen-family vars from this instrument's subtree,
      so it lives in the local defs, not the shared def sink */
   const bgId = uid('dmxBg');
   const defs = svgEl(s, 'defs', {});
@@ -4117,7 +4117,7 @@ GW.dataMatrix = function (host, opts = {}) {
 
 /* R11 warning flag window — the striped mechanical flag slides into the window
    when the condition trips; click trips and clears it */
-GW.warningFlag = function (host, opts = {}) {
+DUPRE.warningFlag = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 120, 64);
   def('barber', d => {
@@ -4146,7 +4146,7 @@ GW.warningFlag = function (host, opts = {}) {
 
 /* R25 fourteen-segment display — the starburst alphanumeric that spells words;
    click cycles the word */
-GW.seg14 = function (host, opts = {}) {
+DUPRE.seg14 = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const words = opts.words || ['ZOOM', 'ECHO', 'TAPE', 'MOOD', 'HALL', 'COMP'];
   const MAP = {
@@ -4204,7 +4204,7 @@ GW.seg14 = function (host, opts = {}) {
 
 /* R26 response graph — log-frequency axes with a draggable amber peak; 2D drag
    places the peak in both axes at once */
-GW.responseGraph = function (host, opts = {}) {
+DUPRE.responseGraph = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg', 190, 110);
   const RG = { x0: 30, x1: 182, y0: 8, y1: 86, fLo: Math.log10(32), fHi: Math.log10(16000), db: 12 };
@@ -4272,7 +4272,7 @@ GW.responseGraph = function (host, opts = {}) {
 
 /* R30 telegraph indicator — the pointer names the active state on labeled
    sectors, engine-telegraph style; click steps the state */
-GW.telegraphIndicator = function (host, opts = {}) {
+DUPRE.telegraphIndicator = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const states = opts.states || ['OK', 'TEST', 'BUSY', 'STOP', 'ATTN', 'FAULT'];
   const s = stageSvg(host, 'rsvg press', 110, 110), cx = 55, cy = 55, N = states.length;
@@ -4305,7 +4305,7 @@ GW.telegraphIndicator = function (host, opts = {}) {
 
 /* R31 radar sweep — the beam circles the bearing ring on the builder's own
    clock (reduced-motion gated), contacts bloom as it passes; click marks the bearing */
-GW.radarSweep = function (host, opts = {}) {
+DUPRE.radarSweep = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const contacts = opts.contacts || [[60, .55], [205, .7], [318, .4]];
   const s = stageSvg(host, 'rsvg press', 130, 130), cx = 65, cy = 65;
@@ -4379,7 +4379,7 @@ GW.radarSweep = function (host, opts = {}) {
 
 /* R35 day-date disc calendar — coaxial printed discs rotate so today reads
    under the fixed hand; starts on today; click rolls midnight forward */
-GW.dayDateCal = function (host, opts = {}) {
+DUPRE.dayDateCal = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const DAYS = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT'];
   const s = stageSvg(host, 'rsvg press', 130, 130), cx = 65, cy = 65, HAND = 135;
@@ -4435,7 +4435,7 @@ GW.dayDateCal = function (host, opts = {}) {
 
 /* R36 LED dot matrix — 8x8 paintable bitmap behind a tinted window; click dots
    to paint; starts on the reference K */
-GW.dotMatrix = function (host, opts = {}) {
+DUPRE.dotMatrix = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const N = 8, STEP = 11, X0 = 10.5, Y0 = 10.5;
   const glyph = opts.glyph || ['10000100', '10001000', '10010000', '11100000', '10100000', '10010000', '10001000', '10000100'];
@@ -4464,7 +4464,7 @@ GW.dotMatrix = function (host, opts = {}) {
 
 /* R45 flip-disc tile array — bistable mechanical pixels; scaleX flip with the
    color swap at the midpoint; click a disc to flip it */
-GW.flipDisc = function (host, opts = {}) {
+DUPRE.flipDisc = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const COLS = 7, ROWS = 5, STEP = 14, X0 = 13, Y0 = 13;
   const glyph = opts.glyph || ['0000100', '0000010', '1111111', '0000010', '0000100'];   /* arrow right */
@@ -4493,7 +4493,7 @@ GW.flipDisc = function (host, opts = {}) {
 
 /* R46 dekatron counting ring — each click pulses the neon glow one cathode
    around; the wrap flashes the carry dot */
-GW.dekatron = function (host, opts = {}) {
+DUPRE.dekatron = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 120, 120), cx = 60, cy = 60;
   svgEl(s, 'circle', { cx, cy, r: 52, fill: '#171310', stroke: '#060505', 'stroke-width': 2 });
@@ -4538,7 +4538,7 @@ GW.dekatron = function (host, opts = {}) {
 
 /* R47 landing gear indicator — three greens or nothing; the lever cycles
    down → transit (amber pulse) → up */
-GW.gearIndicator = function (host, opts = {}) {
+DUPRE.gearIndicator = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 140, 110);
   svgEl(s, 'rect', { x: 2, y: 2, width: 136, height: 106, rx: 9, fill: '#1c1916', stroke: '#060505', 'stroke-width': 1.5 });
@@ -4589,7 +4589,7 @@ GW.gearIndicator = function (host, opts = {}) {
 /* R52 blinkenlights front panel — address/data lamps ripple with a live
    pseudo-PC (builder-owned clock, reduced-motion gated) that folds in the
    switch register; flip the SR bits and the pattern changes */
-GW.blinkenlights = function (host, opts = {}) {
+DUPRE.blinkenlights = function (host, opts = {}) {
   const onChange = opts.onChange || noop;
   const s = stageSvg(host, 'rsvg press', 170, 100);
   svgEl(s, 'rect', { x: 2, y: 2, width: 166, height: 96, rx: 8, fill: '#3a1420', stroke: '#060505', 'stroke-width': 1.5 });
@@ -4637,9 +4637,9 @@ GW.blinkenlights = function (host, opts = {}) {
   return { el: s, get: () => sr, tick };
 };
 
-/* ---- widget CSS: injected once, grows as builders move in ---- */
-/* widget-internal CSS (moved from the gallery <style> block; gallery keeps page furniture) */
-const GW_CSS = `
+/* ---- instrument CSS: injected once, grows as builders move in ---- */
+/* instrument-internal CSS (moved from the gallery <style> block; gallery keeps page furniture) */
+const DUPRE_CSS = `
 /* ---- shared primitives ---- */
 .lamp{width:9px;height:9px;border-radius:50%;background:var(--pass);box-shadow:0 0 6px 1px rgba(116,147,47,.55)}
 .lamp.gold{background:var(--gold);box-shadow:0 0 6px 1px rgba(var(--glow-lo),.6)}
@@ -5161,7 +5161,7 @@ const GW_CSS = `
 .patch svg{position:absolute;inset:0;pointer-events:none;width:100%;height:100%}
 .patch svg path{fill:none;stroke:var(--gold);stroke-width:2.4;opacity:.85;stroke-linecap:round}
 
-/* ===== reference-batch (R) widgets — SVG-first, after period hardware ===== */
+/* ===== reference-batch (R) instruments — SVG-first, after period hardware ===== */
 .rsvg{display:block}
 .rsvg.drag{cursor:ns-resize;touch-action:none}
 .rsvg.press{cursor:pointer}
@@ -5171,44 +5171,44 @@ const GW_CSS = `
 .reel.spin{animation:reelspin 2.6s linear infinite}
 `;
 function ensureCss() {
-  if (document.getElementById('gw-css') || !GW_CSS) return;
-  const st = document.createElement('style'); st.id = 'gw-css'; st.textContent = GW_CSS;
+  if (document.getElementById('dupre-css') || !DUPRE_CSS) return;
+  const st = document.createElement('style'); st.id = 'dupre-css'; st.textContent = DUPRE_CSS;
   document.head.appendChild(st);
 }
 if (document.head) ensureCss();
 else document.addEventListener('DOMContentLoaded', ensureCss);
 
-/* Policy classification (see GW.POLICIES). This is the colour pass's worklist made
+/* Policy classification (see DUPRE.POLICIES). This is the colour pass's worklist made
    explicit: every card gets a record here as we review it — the kind it's bound
    by, why in its own terms, and the range it may vary and stay authentic. This
    round covers the cards already touched; the rest are unclassified on purpose,
    the review still to do card by card, not a memory dump to fill now. Assigned
    after the builders exist, in one place, so it reads as a catalogue. */
-GW.slideToggle.POLICY = { kind: 'accent',
-  why: 'On means good in one panel and a fault in the next, so the lit colour is the consumer’s claim, not the widget’s.',
+DUPRE.slideToggle.POLICY = { kind: 'accent',
+  why: 'On means good in one panel and a fault in the next, so the lit colour is the consumer’s claim, not the instrument’s.',
   authentic: 'The on-colour from the accent family (red, amber, green, white, vfd), plus the pill and thumb finishes. The switch form stays.' };
-GW.segmented.POLICY = { kind: 'accent',
+DUPRE.segmented.POLICY = { kind: 'accent',
   why: 'The active segment signals a mode whose meaning depends on the panel it sits in.',
   authentic: 'The accent colour of the active segment. The segment count and labels are the deployment’s, not a colour choice.' };
-GW.chipToggle.POLICY = { kind: 'accent',
+DUPRE.chipToggle.POLICY = { kind: 'accent',
   why: 'A filter chip’s on-state reads as good, warning or fault entirely by where it is used.',
   authentic: 'The lit colour from the accent family. The chip keeps its inline weight and dotted underline.' };
-GW.dataMatrix.POLICY = { kind: 'screen',
+DUPRE.dataMatrix.POLICY = { kind: 'screen',
   why: 'LED and LCD dot-matrix modules were sold in several emitter colours, so no one colour is definitive.',
   authentic: 'The screen family (amber, green, red, blue, vfd, white) — each a panel that was actually built. Not an arbitrary hue.' };
-GW.roundCrt.POLICY = { kind: 'screen',
+DUPRE.roundCrt.POLICY = { kind: 'screen',
   why: 'CRT phosphors were manufactured in more than one colour (P1 green, P3 amber, white), so the trace colour is a real choice.',
   authentic: 'The screen family, limited to phosphors that existed. The face tint follows the phosphor.' };
-GW.waveRegion.POLICY = { kind: 'screen',
+DUPRE.waveRegion.POLICY = { kind: 'screen',
   why: 'A backlit editor LCD was made in several tints; the ink colour is the panel’s, not fixed.',
   authentic: 'The screen family. The waveform and region handles recolour with the screen, staying legible on it.' };
-GW.radarSweep.POLICY = { kind: 'screen',
+DUPRE.radarSweep.POLICY = { kind: 'screen',
   why: 'PPI radar scopes ran amber and green phosphors both; neither is the one true colour.',
   authentic: 'The screen family, phosphors that shipped. The sweep and afterglow track the chosen screen.' };
-GW.abcKeypad.POLICY = { kind: 'screen',
+DUPRE.abcKeypad.POLICY = { kind: 'screen',
   why: 'The entry window is a screen like any other; its phosphor was made in several colours. (Mixed card: the keys are fixed-function and not a colour choice.)',
   authentic: 'The window’s screen family. The keycap colours are functional and stay put.' };
 
-Object.assign(GW, { SVGNS, svgEl, polar, dragX, dragY, dragDelta, SEG, seg7, buildBars, VUDB, vuDb, SCREEN_FAMS });
-window.GW = GW;
+Object.assign(DUPRE, { SVGNS, svgEl, polar, dragX, dragY, dragDelta, SEG, seg7, buildBars, VUDB, vuDb, SCREEN_FAMS });
+window.DUPRE = DUPRE;
 })();
diff --git a/docs/specs/2026-07-12-component-generation-spec.org b/docs/specs/2026-07-12-component-generation-spec.org
index 8998585..09d0fce 100644
--- a/docs/specs/2026-07-12-component-generation-spec.org
+++ b/docs/specs/2026-07-12-component-generation-spec.org
@@ -8,7 +8,7 @@
 :PROPERTIES:
 :ID:       3ac0d42c-db1a-4d21-bce4-e63785fef0ba
 :END:
-- 2026-07-12 Sun @ 22:56:40 -0500 — Phase 1 complete (still DOING): all 109 builders extracted into =widgets.js=, cards are declarative records, widget CSS moved into =GW_CSS= (pixel-diff identical), slide toggle carries the first constructor-opts style axes, README consumers section written. Commits acee657 → 7b3bc47 on main; probes + 239-check suite green throughout. Remaining: Phases 2–5.
+- 2026-07-12 Sun @ 22:56:40 -0500 — Phase 1 complete (still DOING): all 109 builders extracted into =widgets.js=, cards are declarative records, widget CSS moved into =DUPRE_CSS= (pixel-diff identical), slide toggle carries the first constructor-opts style axes, README consumers section written. Commits acee657 → 7b3bc47 on main; probes + 239-check suite green throughout. Remaining: Phases 2–5.
 - 2026-07-12 Sun @ 20:57:50 -0500 — READY → DOING: phases decomposed into todo.org tasks under "Retro widget catalogue" (=:SPEC_ID:= stamped); Phase 1 extraction starts now per the option-1 approval.
 - 2026-07-12 Sun @ 20:57:50 -0500 — DRAFT → READY: spec-review passed (Ready; 3 findings — the option-1 supersession, the card-record refactor, stale counts — all accepted and folded same pass).
 - 2026-07-12 Sun @ 10:12:06 -0500 — drafted.
@@ -53,12 +53,12 @@ The groundwork is already laid. Tokens are single-sourced in [[file:../prototype
 
 ** Scope tiers
 - v1: full web library extraction (with the card-record refactor), demand inventory for the scripted targets, Emacs ports of the demanded widgets, one waybar pilot panel, the Level-2 generator go/no-go.
-- Out of scope: new widget collection as part of this work (the catalogue keeps growing on its own track — new cards land as =GW.*= calls once extracted), shared cross-target rendering code, interaction parity beyond each target's native idiom.
+- Out of scope: new widget collection as part of this work (the catalogue keeps growing on its own track — new cards land as =DUPRE.*= calls once extracted), shared cross-target rendering code, interaction parity beyond each target's native idiom.
 - vNext (log to todo.org at hand-off): React/framework wrappers, Level-2/3 codegen if Phase 5 says go, ports beyond the demand matrix as consumers appear.
 
 * Design
 ** For a consumer
-Web: include =widgets.js= (classic script) after the token =:root= block; call a builder — e.g. =GW.vuMeter(el, {value: 0.6})= — and get back a handle with setters. Widget-internal CSS ships inside =widgets.js= (the =GW_CSS= block, self-injected at load), so the consumer supplies only the tokens. The gallery page itself becomes a grid of exactly these calls, so the demo and the library cannot drift.
+Web: include =widgets.js= (classic script) after the token =:root= block; call a builder — e.g. =DUPRE.vuMeter(el, {value: 0.6})= — and get back a handle with setters. Widget-internal CSS ships inside =widgets.js= (the =DUPRE_CSS= block, self-injected at load), so the consumer supplies only the tokens. The gallery page itself becomes a grid of exactly these calls, so the demo and the library cannot drift.
 
 Emacs: =(require 'gallery-widgets)= (the =gallery-widget.el= pattern, one file per widget family or one shared file — Phase 3 sizes this); each widget is a function from parameters to an svg.el object, tokens resolved through =gallery-tokens.el=. Interaction (keymap, click regions) is per-widget Emacs idiom, not a translation of pointer drags.
 
@@ -130,7 +130,7 @@ Extraction order inside Phase 1: the card builders already share =svgEl=/=polar=
 
 ** DONE Web library packaging
 - Context: the gallery is a single self-contained =file://= HTML page; ES modules don't load over =file://=, and a React consumer doesn't exist yet.
-- Decision: =widgets.js= ships as a classic script exposing one namespace object (working name =GW=), loaded by the gallery via a relative =<script src>=; the shared helpers (=svgEl=, =polar=, =vuDb=, scale tables) move inside it. Framework wrappers are vNext, demand-gated.
+- Decision: =widgets.js= ships as a classic script exposing one namespace object (working name =DUPRE=), loaded by the gallery via a relative =<script src>=; the shared helpers (=svgEl=, =polar=, =vuDb=, scale tables) move inside it. Framework wrappers are vNext, demand-gated.
 - Consequences: easier — gallery keeps working from =file://=, zero build tooling; harder — no tree-shaking or import isolation (acceptable at this scale).
 - Approved by Craig 2026-07-12 (componentization go-ahead, option 1). The extraction itself is ungated — a lossless transform verified by the CDP probes; Craig's per-card validation pass (the status lamps) gates only the per-widget Emacs ports and the final blessing.
 
@@ -139,7 +139,7 @@ Extraction order inside Phase 1: the card builders already share =svgEl=/=polar=
 The spec's Phase 1 → Phase 2 order gates the web extraction on the demand matrix, and the Web-library-packaging decision says the build is "gated on his per-card validation pass." Craig's componentization go-ahead (option 1, 2026-07-12 ~21:30) superseded both: the web extraction covers the *full* catalogue as a lossless transform and starts immediately; the demand matrix and the validation lamps gate only the per-widget Emacs ports and the final blessing. An implementer reading the spec as written would follow the retired order. Recommended change: re-scope the Demand-driven-porting decision to the Emacs/waybar targets, drop the extraction gate from the packaging decision, and reorder/reword Phases 1-2.
 Disposition: accepted — pre-agreed by Craig (recorded in todo.org and the 2026-07-12 session log). Folded into Decisions 4 and 8 and Phases 1-2.
 ** DONE Card-as-component refactor absent from Phase 2
-The approved build includes restructuring each gallery card into a declarative record (no/title/stage builder/options/readout/note/spec-sheet incl. reference link/validation lamp) so the page becomes data plus =GW.*= calls, but Phase 2 as written only covers lifting builders into =widgets.js=. Without it the "gallery becomes calls into the library" claim leaves the card chrome hand-rolled per card. Recommended change: name the card-record refactor as part of Phase 2's deliverable.
+The approved build includes restructuring each gallery card into a declarative record (no/title/stage builder/options/readout/note/spec-sheet incl. reference link/validation lamp) so the page becomes data plus =DUPRE.*= calls, but Phase 2 as written only covers lifting builders into =widgets.js=. Without it the "gallery becomes calls into the library" claim leaves the card chrome hand-rolled per card. Recommended change: name the card-record refactor as part of Phase 2's deliverable.
 Disposition: accepted — folded into the Design section and Phase 2.
 ** DONE Stale gallery facts
 The spec states 84 cards, a 2258-line file, the R-series closed at R31, and 52a43ec as the final SHA. The gallery has since grown to 109 cards (R-series through R56, ~4300 lines) across the gallery-upgrades merge and the takuzu-survey builds. Not a design problem, but stale numbers in the contract mislead the implementer sizing the extraction. Recommended change: refresh the counts and phrase them as of the review date, since the catalogue still grows.
@@ -147,7 +147,7 @@ Disposition: accepted — counts refreshed and dated throughout.
 
 * Implementation phases
 ** Phase 1 — Web library extraction
-Lift *all* card builders into =docs/prototypes/widgets.js= behind parameter objects (classic script, =GW= namespace, shared helpers inside), and restructure each gallery card as a declarative record (no / title / stage builder / options / readout / note / spec sheet incl. reference link / validation lamp) so the page becomes data plus =GW.*= calls. Batched (roughly 10-15 widgets per batch); a green re-run of the CDP behavioral probes (=tests/gallery-probes/=) is the per-batch no-regression gate, and each batch leaves the gallery fully working from =file://=. Ungated by the validation lamps (option-1 approval — lossless transform).
+Lift *all* card builders into =docs/prototypes/widgets.js= behind parameter objects (classic script, =DUPRE= namespace, shared helpers inside), and restructure each gallery card as a declarative record (no / title / stage builder / options / readout / note / spec sheet incl. reference link / validation lamp) so the page becomes data plus =DUPRE.*= calls. Batched (roughly 10-15 widgets per batch); a green re-run of the CDP behavioral probes (=tests/gallery-probes/=) is the per-batch no-regression gate, and each batch leaves the gallery fully working from =file://=. Ungated by the validation lamps (option-1 approval — lossless transform).
 
 ** Phase 2 — Demand inventory (Emacs / waybar)
 Build the widget-to-target matrix for the *scripted-port* targets: walk the live waybar panels (net/bt/audio/maint) and the Emacs surfaces Craig names (games, dashboards), and record which gallery cards each actually wants. Deliverable: a short matrix table in this spec's appendix, approved by Craig. Tree untouched. Runs in parallel with or after Phase 1 — the extraction does not wait on it.
@@ -163,7 +163,7 @@ After ~5 hand ports, revisit Level-2 codegen with evidence: how much of each por
 
 * Acceptance criteria
 - [ ] Demand matrix exists in the appendix and Craig has approved it.
-- [X] Every gallery card is a declarative record calling into =widgets.js=; CDP probes green; gallery renders unchanged from =file://=. (Done 2026-07-12: 109/109 builders, widget CSS in =GW_CSS=, pixel-diff verified under forced reduced motion.)
+- [X] Every gallery card is a declarative record calling into =widgets.js=; CDP probes green; gallery renders unchanged from =file://=. (Done 2026-07-12: 109/109 builders, widget CSS in =DUPRE_CSS=, pixel-diff verified under forced reduced motion.)
 - [ ] Every demanded Emacs widget has ERT coverage and an rsvg side-by-side render matching its card; =make test-unit= green.
 - [ ] The audio panel reads its palette from =tokens-waybar.css=; panel suite green; manual-testing checklist entry filed.
 - [ ] Phase 5 go/no-go recorded as a dated decision.
diff --git a/tests/gallery-probes/probe-fams.mjs b/tests/gallery-probes/probe-fams.mjs
index 7aa2c4b..993d22d 100644
--- a/tests/gallery-probes/probe-fams.mjs
+++ b/tests/gallery-probes/probe-fams.mjs
@@ -42,7 +42,7 @@ try {
   const line1 = await evl(`getComputedStyle(document.querySelectorAll('#card-R31 svg line')[0]).stroke`);
   ok('R31 green chip recolors furniture', line0 !== line1 && line1 === 'rgb(88, 184, 126)', `${line0} -> ${line1}`);
 
-  // scope (CSS widget): trace stroke changes on amber chip
+  // scope (CSS instrument): trace stroke changes on amber chip
   const tr0 = await evl(`getComputedStyle(document.querySelector('.scope polyline')).stroke`);
   await evl(`document.querySelector('.scope').closest('.card').querySelector('.fc[title="amber"]').click()`);
   const tr1 = await evl(`getComputedStyle(document.querySelector('.scope polyline')).stroke`);
@@ -50,7 +50,7 @@ try {
 
   // R19: drag still works after family switch (click vfd, then check the handle's set() writes var-based fills)
   await evl(`document.querySelector('#card-R19 .fc[title="vfd"]').click()`);
-  await evl(`document.getElementById('card-R19').gw.set(30,70)`);
+  await evl(`document.getElementById('card-R19').dupre.set(30,70)`);
   const barFill = await evl(`(()=>{const b=document.querySelectorAll('#card-R19 svg rect')[10];return b.getAttribute('fill');})()`);
   ok('R19 dynamic fills use vars', barFill.startsWith('var(--scr-'), barFill);
 
diff --git a/tests/gallery-probes/probe.mjs b/tests/gallery-probes/probe.mjs
index e394316..d9ba22f 100644
--- a/tests/gallery-probes/probe.mjs
+++ b/tests/gallery-probes/probe.mjs
@@ -1,4 +1,4 @@
-// CDP probe for the widget gallery — no playwright, Node global WebSocket/fetch.
+// CDP probe for the instrument gallery — no playwright, Node global WebSocket/fetch.
 // Usage: node probe.mjs [--shot out.png] [--size N]
 import { spawn } from 'node:child_process';
 import { writeFileSync } from 'node:fs';
@@ -65,7 +65,7 @@ try {
   const errs = events.filter(e => e.method === 'Runtime.exceptionThrown');
   ok('no exceptions on load', errs.length === 0, errs.map(e => e.params.exceptionDetails?.exception?.description).join('; ').slice(0, 200));
 
-  // 1. card count (the widgets/row default is checked in 1h)
+  // 1. card count (the instruments/row default is checked in 1h)
   const cards = await evl(`document.querySelectorAll('.card').length`);
   ok('111 cards', cards === 111, `got ${cards}`);
 
@@ -89,7 +89,7 @@ try {
     const chips = [...document.querySelectorAll('#card-07 .fc')].map(c => c.title);
     const missing = want.filter(w => !chips.includes(w));
     if (missing.length) return 'card 07 missing accents: ' + missing.join(' ');
-    const built = Object.keys(GW.accentStyles('--x'));
+    const built = Object.keys(DUPRE.accentStyles('--x'));
     return JSON.stringify(built) === JSON.stringify(want) ? 'ok' : 'family is ' + JSON.stringify(built);
   })()`);
   ok('card 07 offers the shared accent family', accents === 'ok', accents);
@@ -107,7 +107,7 @@ try {
   })()`);
   ok('card 07 defaults to gold and recolours on click', chipInk === 'ok', chipInk);
 
-  // 1e. The colour-policy backbone. Every widget's colour is either free (the
+  // 1e. The colour-policy backbone. Every instrument's colour is either free (the
   //     consumer picks) or locked for a stated reason, and the colour pass kept
   //     finding cards where "is this one a standard?" was answered from memory and
   //     wrong. So policy is declared on the builder and checked here. The invariant
@@ -116,10 +116,10 @@ try {
   //     an accent card can't forget to say so. Coverage grows card by card; this
   //     round classifies the touched set, and the count is reported not gated.
   const policy = await evl(`(()=>{
-    const KINDS = GW.POLICIES;
+    const KINDS = DUPRE.POLICIES;
     if (!KINDS) return 'no POLICIES vocabulary';
     const valid = new Set(Object.keys(KINDS));
-    const fns = Object.entries(GW).filter(([,v]) => typeof v === 'function');
+    const fns = Object.entries(DUPRE).filter(([,v]) => typeof v === 'function');
     const declared = fns.filter(([,v]) => v.POLICY);
     // each POLICY record is complete: a valid kind, a why, an authentic range
     const shape = declared.filter(([,v]) => !valid.has(v.POLICY.kind) || !v.POLICY.why || !v.POLICY.authentic)
@@ -177,10 +177,10 @@ try {
   })()`);
   ok('colour policy tally sums to the card total', ptally.startsWith('ok'), ptally);
 
-  // 1h. widgets/row: the control sets an explicit column count and the cards
+  // 1h. instruments/row: the control sets an explicit column count and the cards
   //     resize to match. One-per-row cards must be much wider than four-per-row,
   //     and the count actually reaches the grid.
-  ok('default is 3 widgets/row', await evl(`document.body.dataset.cols`) === '3');
+  ok('default is 3 instruments/row', await evl(`document.body.dataset.cols`) === '3');
   await evl(`document.querySelector('.szbar .key[data-cols="1"]').click()`);
   const w1col = await evl(`document.querySelector('.card').getBoundingClientRect().width`);
   const cols1 = await evl(`getComputedStyle(document.querySelector('.grid')).gridTemplateColumns.split(' ').length`);
@@ -189,7 +189,7 @@ try {
   const cols4 = await evl(`getComputedStyle(document.querySelector('.grid')).gridTemplateColumns.split(' ').length`);
   ok('1/row is much wider than 4/row', w1col > w4col * 2.5, `w1=${Math.round(w1col)} w4=${Math.round(w4col)}`);
   ok('the grid renders the chosen column count', cols1 === 1 && cols4 === 4, `1->${cols1} 4->${cols4}`);
-  ok('widgets/row chip flips state', await evl(`document.body.dataset.cols`) === '4');
+  ok('instruments/row chip flips state', await evl(`document.body.dataset.cols`) === '4');
 
   // 3. behavioral, zoomed: fader drag on card 03 changes readout. Run at 2/row,
   //    not 1/row: at one-per-row the card is wide enough that its controls fall
@@ -245,7 +245,7 @@ try {
   //    disengaged state instead. dim offText lets an off toggle recede in a dense
   //    panel. Craig's call, 2026-07-16.
   const atoms = await evl(`(()=>{
-    const S = GW.slideToggle.STYLES;
+    const S = DUPRE.slideToggle.STYLES;
     const want = { on: ['amber','green','dark','red','warn'], onText: ['panel','cream','green'],
                    off: ['dark','red'], offText: ['white','red','black','dim'],
                    thumb: ['light','dark','chrome','brass'] };
@@ -260,9 +260,9 @@ try {
   //    must resolve in STYLES — a typo here would silently fall through to the
   //    stylesheet default and look "nearly right", which is the worst outcome.
   const presets = await evl(`(()=>{
-    const P = GW.slideToggle.PRESETS, S = GW.slideToggle.STYLES;
+    const P = DUPRE.slideToggle.PRESETS, S = DUPRE.slideToggle.STYLES;
     if (!P) return 'no PRESETS';
-    const AX = GW.slideToggle.AXIS_ORDER;
+    const AX = DUPRE.slideToggle.AXIS_ORDER;
     const bad = [];
     for (const [name, p] of Object.entries(P)) {
       for (const ax of AX) {
@@ -279,7 +279,7 @@ try {
   //     the only thing carrying state. Both backgrounds must stay dark while the
   //     inks diverge — if either pill lights, the preset has lost its point.
   const dark = await evl(`(()=>{
-    const P = GW.slideToggle.PRESETS.dark, S = GW.slideToggle.STYLES;
+    const P = DUPRE.slideToggle.PRESETS.dark, S = DUPRE.slideToggle.STYLES;
     const onBg = S.on[P.on].vars['--sw-on-bg'], offBg = S.off[P.off].vars['--sw-off-bg'];
     const onInk = S.onText[P.onText].vars['--sw-on-ink'], offInk = S.offText[P.offText].vars['--sw-off-ink'];
     if (onBg !== offBg) return 'pills differ: on=' + onBg + ' off=' + offBg;
@@ -288,7 +288,7 @@ try {
   })()`);
   ok('dark preset keeps both pills dark and the inks distinct', dark === 'ok', dark);
 
-  // 7b. the card claims the preset it is actually in. The widget defaults to
+  // 7b. the card claims the preset it is actually in. The instrument defaults to
   //     `panel`, so a preset group with nothing lit would assert "no preset
   //     active" — false, and exactly the kind of quiet mislabel this walk exists
   //     to catch. Nothing above this point touches card 01's chips (checks 2-4
@@ -304,8 +304,8 @@ try {
   })()`);
   ok('card 01 defaults to the panel preset', defaultPreset === 'panel', defaultPreset);
 
-  // 8. a preset chip drives the widget AND re-syncs the axis chips, so the card
-  //    never shows a combination the widget isn't in.
+  // 8. a preset chip drives the instrument AND re-syncs the axis chips, so the card
+  //    never shows a combination the instrument isn't in.
   const applied = await evl(`(()=>{
     const card = document.getElementById('card-01');
     const groups = [...card.querySelectorAll('.fgroup')];
@@ -319,7 +319,7 @@ try {
     const brd = card.querySelector('.switch').style.getPropertyValue('--sw-on-brd');
     return (lit.length === 1 ? lit[0].title : 'lit=' + lit.length) + '|' + brd;
   })()`);
-  ok('armed preset drives widget and syncs the on chip', applied === 'red|var(--fail)', applied);
+  ok('armed preset drives instrument and syncs the on chip', applied === 'red|var(--fail)', applied);
 
   // 8b. axes are not independent: onText overrides the ink `on` sets, so changing
   //     `on` after picking an onText must not silently revert the legend while its
@@ -505,10 +505,10 @@ try {
 
   // 13. KEYS is a declarative TABLE, not a function over a DOM event. The Emacs
   //     port installs this same table into a keymap — it never sees a keydown —
-  //     so a function here would force it to re-derive the widget's intent and
+  //     so a function here would force it to re-derive the instrument's intent and
   //     the two bindings would drift. (README, keyboard contract.)
   const keysTable = await evl(`(()=>{
-    const K = GW.abcKeypad.KEYS;
+    const K = DUPRE.abcKeypad.KEYS;
     if (!K) return 'no KEYS';
     if (typeof K !== 'object' || Array.isArray(K)) return 'KEYS is not a plain table: ' + typeof K;
     const missing = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'].filter(c => K[c] !== c);
@@ -519,7 +519,7 @@ try {
   })()`);
   ok('R57 KEYS is a declarative table covering the plate', keysTable === 'ok', keysTable);
 
-  // 13b. THE contract's first rule: no document-level listener. A widget that
+  // 13b. THE contract's first rule: no document-level listener. An instrument that
   //      binds globally types into itself from anywhere on a 110-card page.
   //      Typing at the body with the card unfocused must do nothing at all.
   const unfocused = await evl(`(()=>{
@@ -560,12 +560,12 @@ try {
     const seq = ['A','B','SPC','7'];
     key('CLR').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     seq.forEach(k => key(k).dispatchEvent(new MouseEvent('click', {bubbles:true})));
-    const byClick = rd() + '/' + document.getElementById('card-R57').gw.get();
+    const byClick = rd() + '/' + document.getElementById('card-R57').dupre.get();
     key('CLR').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     pad.focus();
     ['A','B',' ','7'].forEach(k =>
       pad.dispatchEvent(new KeyboardEvent('keydown', { key: k, bubbles: true, cancelable: true })));
-    const byKey = rd() + '/' + document.getElementById('card-R57').gw.get();
+    const byKey = rd() + '/' + document.getElementById('card-R57').dupre.get();
     return byClick === byKey ? 'ok' : 'drift: click=' + byClick + ' key=' + byKey;
   })()`);
   ok('R57 click and key land in the same place', drift === 'ok', drift);
@@ -576,7 +576,7 @@ try {
   //        caller is a hole in exactly the target the table exists for.
   const pressGuard = await evl(`(()=>{
     const card = document.getElementById('card-R57');
-    const h = card.gw;
+    const h = card.dupre;
     if (!h || !h.press) return 'no handle';
     const key = k => [...card.querySelectorAll('.kp-key')].find(e => e.dataset.k === k);
     key('CLR').dispatchEvent(new MouseEvent('click', {bubbles:true}));
@@ -590,7 +590,7 @@ try {
   // 13c-4. Every key the table maps must be a real plate action, or the Emacs
   //        port installs a binding that silently does nothing.
   const keysSubset = await evl(`(()=>{
-    const bad = Object.entries(GW.abcKeypad.KEYS).filter(([,v]) => !GW.abcKeypad.ACTIONS.has(v));
+    const bad = Object.entries(DUPRE.abcKeypad.KEYS).filter(([,v]) => !DUPRE.abcKeypad.ACTIONS.has(v));
     return bad.length ? 'KEYS maps to non-actions: ' + JSON.stringify(bad) : 'ok';
   })()`);
   ok('R57 every KEYS value is a real plate action', keysSubset === 'ok', keysSubset);
@@ -598,7 +598,7 @@ try {
   // 13d. preventDefault is spent only where there is a default worth killing.
   //      Space scrolls and Backspace navigates back, so those are claimed; Tab is
   //      how the page is navigable and Escape belongs to the audit stepper, so a
-  //      widget that swallows either breaks something it cannot see.
+  //      instrument that swallows either breaks something it cannot see.
   const defaults = await evl(`(()=>{
     const pad = document.querySelector('#card-R57 .kp-pad');
     pad.focus();
@@ -637,11 +637,11 @@ try {
   //     click ever prints, the card has silently become a keypad with extra steps.
   //     Reads the BUFFER, not the card readout: the readout is supposed to change
   //     while hunting ("stylus over g"), and asserting on it would fail a correct
-  //     widget for showing the operator where the pointer is.
+  //     instrument for showing the operator where the pointer is.
   const grammar = await evl(`(()=>{
     const cell = c => document.querySelector('#card-R58 .ix-cell[data-c="' + c + '"]');
     const lever = document.querySelector('#card-R58 .ix-lever');
-    const buf = () => document.getElementById('card-R58').gw.get();
+    const buf = () => document.getElementById('card-R58').dupre.get();
     document.querySelector('#card-R58 .ix-clear').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     const empty = buf();
     ['M','i','g'].forEach(c => cell(c).dispatchEvent(new MouseEvent('click', {bubbles:true})));
@@ -674,7 +674,7 @@ try {
     cell('s').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     lever.dispatchEvent(new MouseEvent('click', {bubbles:true}));
     lever.dispatchEvent(new MouseEvent('click', {bubbles:true}));
-    return document.getElementById('card-R58').gw.get();
+    return document.getElementById('card-R58').dupre.get();
   })()`);
   /* Exact, on the buffer. /ss$/ on the readout also matched 'sss', so it passed
      even if selecting printed — unable to fail on the one bug this card is about. */
@@ -722,7 +722,7 @@ try {
   //      redraw. Craig has already said the keys will change; a layout welded into
   //      the drawing is one that never does.
   const layoutData = await evl(`(()=>{
-    const L = GW.indexPlate && GW.indexPlate.LAYOUT;
+    const L = DUPRE.indexPlate && DUPRE.indexPlate.LAYOUT;
     if (!L) return 'no LAYOUT';
     if (!Array.isArray(L) || !L.every(Array.isArray)) return 'LAYOUT is not a grid';
     const cells = document.querySelectorAll('#card-R58 .ix-cell').length;
@@ -778,7 +778,7 @@ try {
   //      jump the stylus across the plate to the second. 14e can't see it — a
   //      duplicate inflates the drawn count and the declared count equally.
   const dupes = await evl(`(()=>{
-    const flat = GW.indexPlate.LAYOUT.flat().filter(Boolean);
+    const flat = DUPRE.indexPlate.LAYOUT.flat().filter(Boolean);
     const seen = new Set(), dup = new Set();
     for (const c of flat) (seen.has(c) ? dup : seen).add(c);
     return dup.size ? 'duplicated on the plate: ' + [...dup].join(' ') : 'ok';
@@ -788,7 +788,7 @@ try {
   // 14i. press() is the allowlist for R58 too. R57 has this check; without it,
   //      press('F1') reaching select() unfiltered would ship green.
   const ixPress = await evl(`(()=>{
-    const h = document.getElementById('card-R58').gw;
+    const h = document.getElementById('card-R58').dupre;
     h.press('CLR');
     ['F1', 'PRINT ', '', 'constructor', 'ZZ'].forEach(k => h.press(k));
     return JSON.stringify([h.get(), h.selected()]);
@@ -799,7 +799,7 @@ try {
   //     relaying the plate can't leave a keybinding pointing at a character the
   //     plate no longer carries. Enter is the lever.
   const ixKeys = await evl(`(()=>{
-    const K = GW.indexPlate.KEYS, L = GW.indexPlate.LAYOUT;
+    const K = DUPRE.indexPlate.KEYS, L = DUPRE.indexPlate.LAYOUT;
     if (!K) return 'no KEYS';
     const chars = L.flat().filter(Boolean);
     const missing = chars.filter(c => K[c] !== c);
@@ -816,7 +816,7 @@ try {
   //      demonstrate is gone.
   const ixType = await evl(`(()=>{
     const pad = document.querySelector('#card-R58 .ix-pad');
-    const h = document.getElementById('card-R58').gw;
+    const h = document.getElementById('card-R58').dupre;
     const send = k => pad.dispatchEvent(new KeyboardEvent('keydown', { key: k, bubbles: true, cancelable: true }));
     document.querySelector('#card-R58 .ix-clear').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     pad.focus();
@@ -834,7 +834,7 @@ try {
   //      argument for having no shift key.
   const ixCase = await evl(`(()=>{
     const pad = document.querySelector('#card-R58 .ix-pad');
-    const h = document.getElementById('card-R58').gw;
+    const h = document.getElementById('card-R58').dupre;
     const send = k => pad.dispatchEvent(new KeyboardEvent('keydown', { key: k, bubbles: true, cancelable: true }));
     document.querySelector('#card-R58 .ix-clear').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     pad.focus();
@@ -857,12 +857,12 @@ try {
   ok('R58 leaves Space alone (not on the plate)', ixSpace === 'ok', ixSpace);
 
   // 15e. Unfocused, it hears nothing — the contract's first rule, on the second
-  //      widget to take keys.
+  //      instrument to take keys.
   //      Asserts nothing CHANGED, rather than expecting a cleared selection: CLR
   //      is fresh paper, and fresh paper doesn't move the operator's hand, so the
   //      stylus legitimately stays where the previous check left it.
   const ixBlur = await evl(`(()=>{
-    const h = document.getElementById('card-R58').gw;
+    const h = document.getElementById('card-R58').dupre;
     document.querySelector('#card-R58 .ix-clear').dispatchEvent(new MouseEvent('click', {bubbles:true}));
     document.activeElement.blur();
     const before = JSON.stringify([h.get(), h.selected()]);
@@ -877,7 +877,7 @@ try {
   // through the declared charset one flap at a time, retarget cleanly, and
   // animate:false jumps straight to the target.
   const flapApi = await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     return { reading: typeof h.reading, chars: typeof h.chars, set: typeof h.set };
   })()`);
   ok('N20 handle exposes reading() and chars', flapApi.reading === 'function' && flapApi.chars === 'string',
@@ -889,12 +889,12 @@ try {
   // Let the board settle on a known grid first — the demo ticker left it
   // anywhere, and every command cascades (there is deliberately no teleport
   // path). setText is the deterministic seam; next() is random by design.
-  await evl(`document.querySelector('#card-N20').gw.setText('SYSTEM\\nVOLUME\\nSIGNAL')`);
+  await evl(`document.querySelector('#card-N20').dupre.setText('SYSTEM\\nVOLUME\\nSIGNAL')`);
   await sleep(6500);
 
   // Start a cascade and sample the displayed reading every 15ms until stable.
   await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     window.__n20 = { samples: [], anims: 0 };
     h.setText('VOLUME\\nSIGNAL\\nRECORD'); // multi-step distances on several cells
     window.__n20.n = 0;
@@ -911,7 +911,7 @@ try {
   await sleep(6500);
   const n20 = await evl(`(() => {
     clearInterval(window.__n20.timer);
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     return { samples: [...new Set(window.__n20.samples)], final: h.reading(), anims: window.__n20.anims,
              chars: h.chars };
   })()`);
@@ -933,7 +933,7 @@ try {
 
   // Retarget mid-cascade: aim at word 2, then word 3 while still spinning; must land on 3.
   await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     window.__n20r = { samples: [] };
     window.__n20r.timer = setInterval(() => window.__n20r.samples.push(h.reading()), 15);
     h.setText('SIGNAL\\nRECORD\\nONLINE'); setTimeout(() => h.setText('RECORD\\nONLINE\\nSTEREO'), 180);
@@ -941,7 +941,7 @@ try {
   await sleep(7000);
   const n20b = await evl(`(() => {
     clearInterval(window.__n20r.timer);
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     return { final: h.reading().split('\\n')[0], target: 'RECORD',
              sawSync: window.__n20r.samples.some(s => s.split('\\n')[0] === 'SIGNAL'),
              anims: document.querySelector('#card-N20').getAnimations({ subtree: true }).length };
@@ -955,7 +955,7 @@ try {
   const n20s = await evl(`(() => {
     const el = document.createElement('div'); document.body.appendChild(el);
     const pool = ['SYSTEM','VOLUME','SIGNAL','RECORD','ONLINE','STEREO','FILTER','OUTPUT'];
-    const h = GW.splitFlap(el, { rows: 3, cells: 6, words: pool, animate: false });
+    const h = DUPRE.splitFlap(el, { rows: 3, cells: 6, words: pool, animate: false });
     const grids = [h.reading().split('\\n')];
     h.next(); grids.push(h.reading().split('\\n'));
     h.next(); grids.push(h.reading().split('\\n'));
@@ -975,7 +975,7 @@ try {
   const n20c = await evl(`(() => {
     const el = document.createElement('div'); document.body.appendChild(el);
     const settles = [];
-    const h = GW.splitFlap(el, { animate: false, onSettle: r => settles.push(r) });
+    const h = DUPRE.splitFlap(el, { animate: false, onSettle: r => settles.push(r) });
     h.set(1);
     const r = h.reading(); el.remove();
     return { r, settles };
@@ -986,7 +986,7 @@ try {
 
   // The card is a three-row six-letter board; the demo draws random pool words.
   const n20d = await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     return { cells: document.querySelectorAll('#card-N20 .flapd').length,
              lines: document.querySelectorAll('#card-N20 .flapline').length,
              readLines: h.reading().split('\\n').length };
@@ -997,9 +997,9 @@ try {
   // Skin axis: dark (cream on black) and the inverse light (black on cream),
   // switched by the chip rig via setStyle, computed ink actually inverting.
   const n20e = await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
-    if (typeof h.setStyle !== 'function' || !GW.splitFlap.STYLES || !GW.splitFlap.STYLES.skin) return 'no skin axis';
-    const skins = Object.keys(GW.splitFlap.STYLES.skin);
+    const h = document.querySelector('#card-N20').dupre;
+    if (typeof h.setStyle !== 'function' || !DUPRE.splitFlap.STYLES || !DUPRE.splitFlap.STYLES.skin) return 'no skin axis';
+    const skins = Object.keys(DUPRE.splitFlap.STYLES.skin);
     if (skins[0] !== 'paper') return 'paper must list first, got: ' + skins.join(',');
     if (!['dark','white','light','paper'].every(k => skins.includes(k))) return 'skins are: ' + skins.join(',');
     const ink = () => getComputedStyle(document.querySelector('#card-N20 .fh')).color;
@@ -1025,8 +1025,8 @@ try {
   ok('N20 skins: paper default first, white ink, cream, ivory — all switch and restore', n20e === 'ok', n20e);
 
   const n20fnt = await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
-    if (!GW.splitFlap.STYLES.font) return 'no font axis';
+    const h = document.querySelector('#card-N20').dupre;
+    if (!DUPRE.splitFlap.STYLES.font) return 'no font axis';
     const fam = () => getComputedStyle(document.querySelector('#card-N20 .fh')).fontFamily;
     const helv = fam(); // the card's default face is Helvetica
     if (!/helvetica/i.test(helv)) return 'default face is not helvetica: ' + helv;
@@ -1056,7 +1056,7 @@ try {
 
   // Flap speed: the handle takes setFlapMs and the card's slider drives it.
   const n20v = await evl(`(() => {
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     if (typeof h.setFlapMs !== 'function' || typeof h.flapMs !== 'function') return 'no speed api';
     const before = h.flapMs();
     if (before !== 100) return 'default flap rate is ' + before + ', want 100';
@@ -1075,7 +1075,7 @@ try {
   // board must settle, hold the reading ~2s, and only then take the next update.
   await evl(`(() => {
     IH.flap = window.__realFlap;
-    const h = document.querySelector('#card-N20').gw;
+    const h = document.querySelector('#card-N20').dupre;
     window.__n20dwell = { settleAt: 0, changeAt: 0, settled: '' };
     h.onSettle(r => { if (!window.__n20dwell.settleAt) { window.__n20dwell.settleAt = performance.now(); window.__n20dwell.settled = r; } });
     window.__n20dwell.timer = setInterval(() => {
@@ -1114,9 +1114,9 @@ try {
   await send('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-reduced-motion', value: 'reduce' }] });
   await send('Page.reload');
   await sleep(2500);
-  const rm1 = await evl(`document.querySelector('#card-N20').gw.reading()`);
+  const rm1 = await evl(`document.querySelector('#card-N20').dupre.reading()`);
   await sleep(5200);
-  const rm2 = await evl(`(() => ({ r: document.querySelector('#card-N20').gw.reading(), anims: document.getAnimations().length }))()`);
+  const rm2 = await evl(`(() => ({ r: document.querySelector('#card-N20').dupre.reading(), anims: document.getAnimations().length }))()`);
   ok('N20 rests under reduced motion (no self-advancing dwell chain)',
      rm1 === rm2.r && rm2.anims === 0, JSON.stringify({ before: rm1, after: rm2.r, anims: rm2.anims }));
 
diff --git a/todo.org b/todo.org
index d656788..2486adf 100644
--- a/todo.org
+++ b/todo.org
@@ -82,7 +82,7 @@ Scrolling the date module used to cycle its text format (=date-cycle= over full/
 :END:
 Usability + documentation pass over the [[file:docs/prototypes/panel-widget-gallery.html][panel widget gallery]], orthogonal to the component-generation spec work, so it runs on the =gallery-upgrades= branch (squash merge to main after Craig's UI confirmation + tweaks). Items 1-4 run as a no-approvals speedrun (Craig authorized 2026-07-12); item 5 is a joint brainstorm after the merge.
 *** TODO Extraction-readiness bar for every gallery component :refactor:design:
-Craig's standing directive (2026-07-18, set while finishing the split-flap): every =GW.*= builder should meet the bar the split-flap now sets, since these become regular components. The bar: a contract comment documenting every opt and the full handle surface; no page globals touched (page owns cadence via handles/callbacks, e.g. =onSettle=); all component CSS in one named =GW_CSS= block; refactored until no opportunity worth doing remains (small named helpers, no duplication); construction axes declared via =STYLES= where the component has them. Sweep the existing builders against that list, fix the gaps, and make the bar a stated convention in the widgets.js header or README so new builders inherit it. Overlaps the component-generation spec's extraction phase — reconcile there rather than doing the work twice.
+Craig's standing directive (2026-07-18, set while finishing the split-flap): every =DUPRE.*= builder should meet the bar the split-flap now sets, since these become regular components. The bar: a contract comment documenting every opt and the full handle surface; no page globals touched (page owns cadence via handles/callbacks, e.g. =onSettle=); all component CSS in one named =DUPRE_CSS= block; refactored until no opportunity worth doing remains (small named helpers, no duplication); construction axes declared via =STYLES= where the component has them. Sweep the existing builders against that list, fix the gaps, and make the bar a stated convention in the widgets.js header or README so new builders inherit it. Overlaps the component-generation spec's extraction phase — reconcile there rather than doing the work twice.
 
 *** 2026-07-18 Sat @ 04:32:20 -0500 Made the N20 split-flap an honest Solari mechanism
 =GW.splitFlap= rebuilt from the drop-fade fake: charset-as-drum stepping (=opts.chars= is the flap order, one flip at a time through intermediates, staggered arrival), re-aim-not-queue retargeting, and the real two-half-panel fold (WAAPI, backfaces hidden), with =animate:false= collapsing to instant jump for reduced motion. Handle grew =setText=/=chars=/=reading()=; default width 3 → 4 cells. Nine probe checks written red-first (arrival, intermediates, one-flap stepping, re-aim discriminator, instant path); technique studied from HotFX and re-derived — no license on their repo, nothing copied (reference filed in =working/retro-stereo-widgets/references/=). Review: sound; its two test-strength notes addressed in the same change.
-- 
cgit v1.2.3