@genex-ai/cli-demo 0.71.0-dev.186 → 0.71.0

package/templates/skills/genex-threejs-shadow-systems/references/shadow-systems.md

@@ -2,7 +2,7 @@
 
 Use this reference for stable directional shadows across a large procedural scene using committed light-space centers, texel snapping, bounded refresh budgets, cross-level blending, and targeted invalidation.
 
-> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project. Either way the effect obeys the device tier (`$genex-threejs-adaptive-quality`): expensive passes are desktop-tier, and on WebGPU the per-target MSAA sample count is a runtime knob the governor may drive.
+> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project.
 
 ## Contents
 

package/templates/skills/genex-threejs-skill-router/SKILL.md

@@ -15,12 +15,11 @@ map, execution order, and acceptance gate.
 
 | Work needed | Load |
 | --- | --- |
-| shot composition, chase/side/orbit rigs, camera handoffs, projection ownership, pointer look, mouse-aimed action (shooter, FPS/first-person, sniper, turret, crosshair/reticle), mouse-look, hand-rolled steering/pan/look input signs (screen-direction contract), floating origins | `$genex-threejs-camera-direction` |
+| shot composition, chase/side/orbit rigs, camera handoffs, projection ownership, pointer look, mouse-aimed action (shooter, FPS/first-person, sniper, turret, crosshair/reticle), mouse-look, floating origins | `$genex-threejs-camera-direction` |
 | on-foot player movement: walk/run/jump/crouch, third-person character, slopes, stairs, moving platforms, personal VRM animation, directional locomotion, transitions, action motion | `$genex-threejs-character-controller` |
 | a custom generated playable humanoid or Meshy animation coverage beyond UAL: reference-informed A-pose concepts, explicit candidate + 10k-remesh approvals, exact action IDs, same-rig adapter | `$genex-ai-character` + `$genex-threejs-character-controller` |
 | the player drives or flies something: cars, drones, vehicle physics, gearbox, enter/exit between character and vehicle | `$genex-threejs-vehicle-controllers` |
 | playable on phones: touch/mobile input for any game — joystick, virtual buttons, drag zones, per-genre touch recipes, rotate-device overlay — wired by default for every NEW game when a recipe fits (skip with a one-line reason) | `$genex-threejs-touch-controls` |
-| phone-survivable rendering — device tiers, DPR/shadow/post budgets, the runtime quality governor, per-tier asset rungs for generated skyboxes/textures, the Quality picker, dispose-on-swap discipline — **mandatory for every game at boot wiring** | `$genex-threejs-adaptive-quality` |
 | anything falls, collides, gets pushed, or needs physics: Rapier world setup, colliders for meshes and GLBs, collision events | `$genex-threejs-physics-rapier` |
 | launch and docking timelines, procedural transform phases, springs, staging, rotating-frame alignment, debris motion | `$genex-threejs-procedural-animation` |
 | reusable scalar/vector fields, domain warping, causal masks, procedural normals | `$genex-threejs-procedural-fields` |
@@ -59,14 +58,6 @@ map, execution order, and acceptance gate.
 mentions sign-in, saves, progress, per-player state, a persistent world, or
 leaderboards. Multiplayer auth (`getColyseusAuth`) comes from it too.
 
-**Adaptive quality is mandatory routing:** every game wires the device tier at
-boot — `$genex-threejs-adaptive-quality` (three lines: `detectTier()` before the
-renderer, tier-capped `setPixelRatio`, the governor in the loop; generated
-skyboxes/textures load through their rungs). Phones enforce a hard GPU-memory
-kill desktops never show you; the tier is what keeps a phone boot alive while
-desktop keeps the full look. This is a completion gate like the post stack —
-cheap to wire, not a new testing burden (desktop-only verification stands).
-
 **Character-animation routing:** use the existing VRM + UAL character
 controller by default. Use `npx genex character` when the game needs a custom
 generated humanoid or an action unavailable in UAL. Before generating a Meshy
@@ -131,11 +122,7 @@ stack this game ships — read off the concept frame's OWN look (the grade, bloo
 level, haze, grain it already shows) and which post the 2–3 AAA references lean
 on, not a default single bloom; ONE built render-pass effect is the FLOOR
 against no-post for EVERY game, never the target — ship the richness the concept
-implies. The floor is TIER-AWARE (`$genex-threejs-adaptive-quality`): on phone
-tiers it is satisfied by the built tone-mapping/output pass with the light
-additions the tier allows (FXAA/vignette), while the full named stack remains
-the desktop floor — never ship the heavy stack undropped to phones (the UI
-vignette div or a CSS canvas filter does not count on any tier;
+implies (the UI vignette div or a CSS canvas filter does not count;
 `$genex-threejs-image-pipeline` owns ordering when 2+ compose), a decision for
 **every primitive surface** the game builds — walls, barriers, kerbs and
 platforms each get a real texture or a **shader** where that surface wants motion
@@ -217,16 +204,8 @@ concept-driven — a richer first build beats a grey-box one.
   drag-orbit (`pointerLockAim: false`) only with a stated reason (e.g. a
   cursor-heavy UI core). **Never** — cursor-core games (click-to-move, tower
   defense, builder, card/puzzle), orbit showcases, touch-only; these MUST pass
-  `pointerLockAim: false`. Keyboard-only games (racer, platformer) lock too —
-  the cursor is either a gameplay tool or locked away during play. The mechanism
-  and the full aim contract live in `$genex-threejs-camera-direction`.
-- Input direction (always — every game that moves with keys or pointer):
-  D/ArrowRight must move or turn the player screen-RIGHT, mouse-right must turn
-  the view right, drag-pan axes share one convention. The screen-direction
-  contract and verified copy-paste bases live in
-  `$genex-threejs-camera-direction` — hand-rolled steering/pan/look math copies
-  one instead of deriving signs, and the smoke check's input-direction pass
-  verifies it.
+  `pointerLockAim: false`. The mechanism and the full aim contract live in
+  `$genex-threejs-camera-direction`.
 - Art direction follows THIS game's concept. The style examples inside skills
   are examples, not defaults — never default to neon/cyberpunk/synthwave (or any
   other single register) unless the concept calls for it.
@@ -243,7 +222,7 @@ concept-driven — a richer first build beats a grey-box one.
 - Use `$genex-threejs-visual-validation` before declaring graphics/procedural-system
   work done. **Game fast path:** for game tasks that loaded no procedural/visual-system
   skill, done = a screenshot plus an interaction smoke check (load the page, press each
-  control, see the visible response in its labeled direction) — don't run the full diagnostic gate — PLUS the
+  control, see the visible response) — don't run the full diagnostic gate — PLUS the
   floors from the routing-map's acceptance gate: the generated sprite HUD wired in
   (not the CSS placeholder), pause on Escape, the branded loader with its key-art
   background, the brief's fonts actually loaded, the renderer baseline + at least one

package/templates/skills/genex-threejs-skill-router/references/routing-map.md

@@ -52,10 +52,8 @@ Three.js release or branch, and do not blindly copy demo architecture.
    while you build the game. FIRST of all art: the gate's **concept frame** —
    a playable-moment shot (verb + threat + objective in frame, per the
    game-ui gate), shown to the user for a keep-or-change answer the moment
-   it lands — the answer is advisory, never a gate: the art pipeline starts
-   against the frame as-is, and the game-ui skill owns the re-anchor loop
-   when notes arrive; later `--edit`-able generations anchor to it for STYLE
-   while the game contract owns content. Then the `$genex-ai-hud` Stage-1 mockup, enqueued
+   it lands; later `--edit`-able generations anchor to it for STYLE while
+   the game contract owns content. Then the `$genex-ai-hud` Stage-1 mockup, enqueued
    here for EVERY game; and the `$genex-ai-menu` video whenever the menu
    decision is yes (the default for every game — "it's only a draft" is not a
    reason to decide no). Skipping this enqueue is
@@ -182,10 +180,7 @@ Three.js release or branch, and do not blindly copy demo architecture.
    (`$genex-threejs-visual-validation` owns the capture discipline).
 7. Add camera direction when framing, controls, transitions, or scale perception
    affect play — or the game aims with the mouse (shooter/FPS/turret): the
-   step-4 bucket decision executes here. And before ANY hand-rolled
-   steering/pan/look math: the screen-direction contract (D → screen-right,
-   mouse-right → view right, drag axes one convention) with verified copy-paste
-   bases lives there — signs are copied, never derived.
+   step-4 bucket decision executes here.
 8. Add procedural animation when object motion needs authored phases,
    convergence, looping, or deterministic timelines.
 9. Add shared fields before writing multiple independent noise layers.
@@ -196,11 +191,7 @@ Three.js release or branch, and do not blindly copy demo architecture.
     step-4 post plan, not inventing one now. This is a completion gate: the
     named post stack must be BUILT before the game is called done, published,
     or handed off — a game rendering on stock three.js defaults is not done,
-    and the gate does not wait for the word "done" to be said. The stack is
-    tier-gated (`$genex-threejs-adaptive-quality`): full on desktop, the built
-    tone-mapping pass + the tier's light additions on phones — wire the
-    governor's post toggle so phone tiers drop the heavy passes, never ship
-    them undropped.
+    and the gate does not wait for the word "done" to be said.
 12. Once the loop is playable, build the planned interface states via
     `$genex-threejs-game-ui` (HUD, pause on Escape, fail/retry, win, and the
     full loading state grown from the step-6 loader), then `npx genex wait`
@@ -259,7 +250,7 @@ module — a corrupted entry point costs more than the minutes saved.
 
 **Game fast path:** for a game task that loaded no procedural/visual-system skill,
 done = a screenshot plus an interaction smoke check (load the page, press each
-control, assert a visible response in its labeled direction — `$genex-threejs-visual-validation` has the
+control, assert a visible response — `$genex-threejs-visual-validation` has the
 procedure), **plus the UI floor from `$genex-threejs-game-ui` (the generated
 sprite HUD wired in — not the CSS placeholder — pause on Escape, the branded
 loader with its key-art background, the brief's font pair actually loaded)
@@ -286,11 +277,7 @@ A routed Genex scene is incomplete until it exposes:
 - named perceptual parameters for the important visual systems;
 - debug views for generated fields, masks, or passes;
 - a no-post baseline that still communicates the subject;
-- a clear quality tier or render-budget knob when the effect is expensive —
-  and for every GAME, the adaptive-quality tier wired at boot
-  (`$genex-threejs-adaptive-quality`): tier-capped pixel ratio, tier shadow
-  budget, the runtime governor in the loop, and generated skybox/texture
-  loads routed through their rungs;
+- a clear quality tier or render-budget knob when the effect is expensive;
 - when physics or controllers are in play, a fixed-timestep loop: per-frame
   work (platforms, enter/exit, controller updates) runs inside the physics
   world's before-step hook, then the world steps — never in the render loop;
@@ -300,12 +287,9 @@ A routed Genex scene is incomplete until it exposes:
 
 **Publishing IS calling it done.** Before `npx genex publish`, every completion
 gate above must pass — sprite HUD wired, Escape pause working, branded loader
-with its key art, fonts loaded, renderer baseline + one built post effect
-(tier-aware), the adaptive-quality tier wired at boot, world dressing placed
-or validly waived, and the content contract's countables present or
-explicitly re-scoped by the user. `genex preview`/`publish` print a mobile
-preflight (estimated phone GPU memory vs budget) — treat a warning there as a
-gate item too. If any is still
+with its key art, fonts loaded, renderer baseline + one built post effect,
+world dressing placed or validly waived, and the content contract's
+countables present or explicitly re-scoped by the user. If any is still
 pending, say which and publish only after an explicit go-ahead.
 
 Do not invent unavailable Genex service APIs. When preparing a game for Genex

package/templates/skills/genex-threejs-spectral-ocean/references/spectral-ocean.md

@@ -2,7 +2,7 @@
 
 Use this reference for a large, unbounded-looking ocean whose identity comes from directional spectral synthesis, staged inverse FFTs, derivative maps, Jacobian whitecaps, and coherent optical shading.
 
-> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project. Either way the effect obeys the device tier (`$genex-threejs-adaptive-quality`): expensive passes are desktop-tier, and on WebGPU the per-target MSAA sample count is a runtime knob the governor may drive.
+> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project.
 
 ## Contents
 

package/templates/skills/genex-threejs-touch-controls/SKILL.md

@@ -75,10 +75,6 @@ Pick what matches the game; most games need exactly one or two of these.
   lives on the stick; the static circle is fine for slower games. On the
   bundled character controller, pass it through instead — see
   `$genex-threejs-character-controller` (`joystick: { x: joy.x, y: joy.y }`).
-  Touch axes obey the same screen-direction contract as WASD and the mouse
-  (`$genex-threejs-camera-direction`): stick-right must move the player
-  screen-right, drag-right must turn the view right — a flipped feel is a sign
-  bug in the mapping, never a device quirk.
 - **Camera look → drag zone on the right half.** Default `DragZone()` is
   exactly that; per frame `const { dx, dy } = look.consumeDelta()` then apply
   to yaw/pitch with the same sensitivity scale as the mouse path. Games on the
@@ -153,13 +149,6 @@ z-order stays: drag zone (5) under joystick/buttons (10) under pause menus.
   canvas. If the game also needs taps there (tap to shoot), read them from the
   zone (`onChange` + a small-movement threshold) or shrink the zone.
 
-## Input is half of phone-playable
-
-This skill is INPUT only. A phone that can steer a game that then runs out of
-GPU memory still loses the player — the rendering half (device tiers, DPR and
-shadow budgets, the runtime governor, per-tier asset rungs) lives in
-`$genex-threejs-adaptive-quality` and is wired at boot for every game.
-
 ## When you skip
 
 Say it in one plain line — *"skipped touch controls: the game is

package/templates/skills/genex-threejs-visual-validation/SKILL.md

@@ -72,17 +72,9 @@ everything twice.
    skill's "Self-testing a draft" section) — so you see the game, not the
    sign-in gate.
 2. Press each documented control once (keys, pointer); assert a **visible
-   response in its labeled direction** — this is the input-direction pass, and
-   it is part of THIS check, not an extra testing loop. Hold `KeyD`/ArrowRight
-   ~0.5s and screenshot-diff: the controlled thing moves or turns toward
-   screen-RIGHT (for a pan camera the viewport slides right — the terrain
-   streams LEFT); `KeyA`/ArrowLeft mirrors it. Keyboard synthesis needs no
-   pointer lock, so this works headless. For drag rigs, drag right AND drag up:
-   both axes must follow the one stated convention (grab-the-world or
-   move-the-camera — never one each). A response in the WRONG direction is a
-   fail, not a note: two shipped games passed "controls respond" while D
-   steered screen-left. For an animated character, capture idle, walk, run,
-   crouch-idle, crouch-move, and jump. Inspect shoulders, elbows, wrists, and hands as well
+   response** to every one — the player moves, the camera turns, the button
+   fires. For an animated character, capture idle, walk, run, crouch-idle,
+   crouch-move, and jump. Inspect shoulders, elbows, wrists, and hands as well
    as the feet: a fully bound non-T-pose can still be stylistically broken.
    Reject shrugging palms-up poses, permanently raised elbows, or a gait whose
    upper-body style contradicts the requested character. “No T-pose” is not
@@ -112,19 +104,16 @@ everything twice.
    floating above detached wheels means the model was box-fit against the
    preset's wheelbase (the vehicle skill's "Custom generated bodies" rules
    fix it).
-6. The cursor pass — every game, per the lock-or-tool rule: during play the OS
-   cursor is either the gameplay tool (cursor-core — confirm the explicit
-   `pointerLockAim: false` opt-out, cursor stays) or it is LOCKED away; a
-   non-cursor-core game with the arrow parked over the action is a defect, even
-   a keyboard-only racer. Aim games additionally: click the canvas and assert
-   the pointer locks (cursor gone, mouse-RIGHT turns the view RIGHT and
-   mouse-UP looks UP — name BOTH axes; yaw-only evidence has let inverted pitch
-   ship); press Esc and assert the "click to aim/resume" cue appears. The cue
-   should be the bundled `createAimCue` helper (or an equivalent
+6. Aim games get one extra pass (MANDATORY bucket — first-person or mouse-aimed):
+   state which pointer bucket the game chose; click the canvas and assert the
+   pointer locks (cursor gone, mouse-RIGHT turns the view RIGHT — check the axis,
+   not just that it moves); press Esc and assert the "click to aim/resume" cue
+   appears. The cue should be the bundled `createAimCue` helper (or an equivalent
    `onAimChange`-driven overlay) — a MANDATORY-bucket game with no unlocked cue
-   fails. Headless caveat: `requestPointerLock` throws in headless Chromium —
-   assert the wiring and the unlocked cue in a screenshot, and say plainly that
-   the lock itself needs one manual click (do the both-axes look check there).
+   fails. Also confirm a cursor-core game opted OUT (`pointerLockAim: false`) so it
+   isn't grabbing the cursor. Headless caveat: `requestPointerLock` throws in
+   headless Chromium — assert the wiring and the unlocked cue in a screenshot, and
+   say plainly that the lock itself needs one manual click.
 7. **Ask the scene the three things the screenshot cannot answer** (below). Run it
    once, in the same browser you already have open.
 
@@ -290,12 +279,6 @@ visual-system work — the sequence above.
 
 - a MANDATORY-bucket aim game never requests pointer lock, or locks with no
   visible unlocked cue;
-- a movement key or look axis whose on-screen direction contradicts its label
-  (D turning the vehicle screen-left, mouse-up looking down with no invert
-  option);
-- drag-pan axes that mix conventions (one axis grab-the-world, the other
-  move-the-camera);
-- a non-cursor-core game that leaves the OS cursor visible during play;
 - approval relies on a single frame;
 - post-processing cannot be disabled per pass;
 - random seeds are not reproducible;

package/templates/skills/genex-threejs-water-optics/references/water-optics.md

@@ -2,7 +2,7 @@
 
 Use this reference for bounded or analytic water with shared displacement and normals, derivative-filtered detail, analytic reflection, heuristic refraction, absorption, and crest foam. Use `$genex-threejs-spectral-ocean` for stochastic FFT seas.
 
-> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project. Either way the effect obeys the device tier (`$genex-threejs-adaptive-quality`): expensive passes are desktop-tier, and on WebGPU the per-target MSAA sample count is a runtime knob the governor may drive.
+> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project.
 
 ## Contents
 

package/templates/skills/genex-updates/SKILL.md

@@ -38,7 +38,7 @@ update, so update immediately.)
 Run exactly the command the nudge printed, from the game project root:
 
 ```bash
-npm i -D @genex-ai/cli-demo@dev   # the genex CLI (a dev dependency)
+npm i -D @genex-ai/cli-demo@latest   # the genex CLI (a dev dependency)
 npm i @genex-ai/embed-sdk@latest     # identity/saves SDK (ships inside the game)
 npm i @genex-ai/multiplayer@latest   # multiplayer SDK (only if the game uses it)
 ```

package/templates/controllers/quality/governor.ts

@@ -1,147 +0,0 @@
-// Genex adaptive-quality: the runtime governor (mobile-readiness program).
-// Tiers pick the START; the governor owns the RUNTIME knobs forever — phones
-// thermally throttle after minutes, so a game that benched fine at 0:30
-// degrades at 8:00. Feed it a frame time every frame; wire the callbacks to
-// the runtime-changeable knobs only (DPR, post passes, draw distance, frame
-// cap — NEVER context-creation flags like antialias, those are fixed).
-//
-// Step-down ladder on sustained slowness: DPR ×0.8 → post off → draw distance
-// down → 30fps cap. Step-up is slow (hysteresis) and a step that failed twice
-// is never re-attempted. It also self-reports renderer.info counts to
-// window.__GENEX_QUALITY__ — the crash watchdog attaches them to its beacons,
-// which is how the field data that calibrates the whole program gets its
-// memory signal.
-import type { QualityTier } from './tier.ts';
-
-export interface GovernorCallbacks {
-  /** Apply a DPR multiplier (1 = tier cap). E.g. renderer.setPixelRatio(Math.min(realDpr, tier.dprCap * m)). */
-  setDprScale?: (multiplier: number) => void;
-  /** Toggle the post stack between the tier's level and 'off'. */
-  setPostEnabled?: (enabled: boolean) => void;
-  /** Apply a draw-distance multiplier (1 = tier scale). */
-  setDrawDistanceScale?: (multiplier: number) => void;
-  /** Apply a frame cap (0 = uncapped). Pace to a STABLE 30 over a stuttery 45. */
-  setFrameCap?: (fps: number) => void;
-}
-
-interface RendererInfoLike {
-  info?: { memory?: { textures?: number; geometries?: number } };
-}
-
-const SLOW_WINDOW_MS = 4000; // sustained, not spikes — shader compiles must not trigger steps
-const RECOVER_WINDOW_MS = 20000; // step up slowly (hysteresis)
-const MEM_REPORT_MS = 5000;
-
-export class QualityGovernor {
-  private tier: QualityTier;
-  private steps: Array<{ apply: () => void; revert: () => void; failures: number; pendingRecovery?: boolean }>;
-  private applied = 0;
-  private slowSince: number | null = null;
-  private goodSince: number | null = null;
-  private lastMemReport = 0;
-  private paused = false;
-
-  constructor(tier: QualityTier, callbacks: GovernorCallbacks, renderer?: RendererInfoLike) {
-    this.tier = tier;
-    this.rendererRef = renderer;
-    const c = callbacks;
-    this.steps = [
-      {
-        apply: () => c.setDprScale?.(0.8),
-        revert: () => c.setDprScale?.(1),
-        failures: 0,
-      },
-      {
-        apply: () => c.setPostEnabled?.(false),
-        revert: () => c.setPostEnabled?.(true),
-        failures: 0,
-      },
-      {
-        apply: () => c.setDrawDistanceScale?.(0.6),
-        revert: () => c.setDrawDistanceScale?.(1),
-        failures: 0,
-      },
-      {
-        apply: () => c.setFrameCap?.(30),
-        revert: () => c.setFrameCap?.(this.tier.frameCap),
-        failures: 0,
-      },
-    ];
-    // Visibility lifecycle: a backgrounded game must stop burning GPU/audio on
-    // exactly the thermally-constrained device class. The game's loop should
-    // also pause itself; the governor at minimum stops judging frames.
-    try {
-      document.addEventListener('visibilitychange', () => {
-        this.paused = document.visibilityState !== 'visible';
-        this.slowSince = null;
-        this.goodSince = null;
-      });
-    } catch {
-      /* non-DOM context */
-    }
-  }
-
-  private rendererRef?: RendererInfoLike;
-
-  /** Call once per frame with the frame delta in ms (performance.now() based). */
-  frame(deltaMs: number): void {
-    if (this.paused) return;
-    const now = performance.now();
-    const budgetMs = 1000 / Math.min(this.tier.frameCap, 60) + 8; // ~24ms at 30, ~25ms at 60
-
-    if (deltaMs > budgetMs) {
-      this.goodSince = null;
-      if (this.slowSince == null) this.slowSince = now;
-      else if (now - this.slowSince > SLOW_WINDOW_MS) {
-        this.stepDown();
-        this.slowSince = null;
-      }
-    } else {
-      this.slowSince = null;
-      if (this.goodSince == null) this.goodSince = now;
-      else if (now - this.goodSince > RECOVER_WINDOW_MS) {
-        this.stepUp();
-        this.goodSince = null;
-      }
-    }
-
-    // Memory self-report for the crash watchdog's beacons (field calibration).
-    if (now - this.lastMemReport > MEM_REPORT_MS) {
-      this.lastMemReport = now;
-      try {
-        const mem = this.rendererRef?.info?.memory;
-        if (mem) {
-          (window as Window & { __GENEX_QUALITY__?: { tex?: number; geo?: number } }).__GENEX_QUALITY__ =
-            { tex: mem.textures ?? 0, geo: mem.geometries ?? 0 };
-        }
-      } catch {
-        /* observational only */
-      }
-    }
-  }
-
-  private stepDown(): void {
-    if (this.applied >= this.steps.length) return;
-    const step = this.steps[this.applied]!;
-    // A re-application of a rung whose recovery is still pending means the
-    // revert did NOT hold — that's the failure being counted, never the
-    // successful revert itself.
-    if (step.pendingRecovery) {
-      step.pendingRecovery = false;
-      step.failures++;
-    }
-    step.apply();
-    this.applied++;
-  }
-
-  private stepUp(): void {
-    if (this.applied === 0) return;
-    const step = this.steps[this.applied - 1]!;
-    // Never re-attempt a knob whose recovery failed twice (reverting it put
-    // the game back over budget both times) — it stays applied for the session.
-    if (step.failures >= 2) return;
-    step.pendingRecovery = true;
-    step.revert();
-    this.applied--;
-  }
-}

package/templates/controllers/quality/pick-asset.ts

@@ -1,57 +0,0 @@
-// Genex adaptive-quality: per-tier asset variant selection (mobile-readiness
-// program, Option A+D). Generated assets ship with GUARANTEED downscale rungs
-// in R2 — sibling roles like "skybox-equirect@2048" — so phones can load a
-// ~11 MB sky instead of the 8192x4096 original (~178 MB decoded). Desktop
-// always loads the bare URL: the ladder exists so phones stop dying, never to
-// make desktops uglier.
-//
-// FALLBACK CONTRACT: a rung can be missing (remixed old URLs, an environment
-// whose backfill hasn't run). loadTextureWithFallback retries the bare URL on
-// a rung failure, so the worst case is today's behavior — never a broken boot.
-import type { QualityTier } from './tier.ts';
-
-const GENEX_GENERATIONS_RE = /^https:\/\/assets\.genex\.technology\/generations\/[^/]+\/[^/@]+$/;
-
-/** Rung widths by role family — mirrors the server's ladder (store.ts MOBILE_RUNGS). */
-function rungWidthFor(url: string, tier: QualityTier): number | null {
-  if (tier.name !== 'phone' && tier.name !== 'phone-low') return null;
-  const role = url.split('/').pop() ?? '';
-  if (role === 'skybox-equirect') return tier.name === 'phone-low' ? 2048 : 4096;
-  if (role === 'texture-basecolor' || role === 'image-main' || /^image-alt-\d+$/.test(role)) {
-    return tier.name === 'phone-low' ? 1024 : 2048;
-  }
-  return null;
-}
-
-/**
- * Resolve the URL a THIS-tier device should load. Non-generated URLs and
- * desktop tiers pass through untouched; phone tiers get the rung sibling.
- */
-export function pickAsset(url: string, tier: QualityTier): string {
-  if (!GENEX_GENERATIONS_RE.test(url)) return url;
-  const width = rungWidthFor(url, tier);
-  return width ? `${url}@${width}` : url;
-}
-
-/**
- * Load an image URL through the ladder with the bare-URL fallback. Use it for
- * generated skyboxes/textures instead of raw TextureLoader.loadAsync:
- *
- *   const texture = await loadTextureWithFallback(
- *     SKYBOX_URL, tier, (u) => new THREE.TextureLoader().loadAsync(u),
- *   );
- */
-export async function loadTextureWithFallback<T>(
-  url: string,
-  tier: QualityTier,
-  load: (resolvedUrl: string) => Promise<T>,
-): Promise<T> {
-  const picked = pickAsset(url, tier);
-  if (picked === url) return load(url);
-  try {
-    return await load(picked);
-  } catch {
-    // Missing rung (old asset, un-backfilled env) — degrade to the original.
-    return load(url);
-  }
-}

package/templates/controllers/quality/tier.ts

@@ -1,170 +0,0 @@
-// Genex adaptive-quality: device-tier detection (mobile-readiness program).
-// Boot-conservative by design — on phones you can recover from ugly, you
-// cannot recover from a jetsam kill, and boot is exactly when iOS kills. The
-// governor (governor.ts) steps quality UP after smooth seconds, so a
-// too-cautious start costs moments of softness, never a crash.
-//
-// Detection honesty: no single signal is trustworthy. iOS masks the WebGL
-// renderer string to "Apple GPU" (screen+DPR+OS-version is the real Apple
-// signal); Android exposes detailed renderer strings (Adreno/Mali) worth a
-// small lookup; the runtime governor measures actual frame times and corrects
-// both directions. All heuristics here only pick the STARTING tier.
-
-export type TierName = 'phone-low' | 'phone' | 'desktop' | 'desktop-high';
-
-export interface QualityTier {
-  name: TierName;
-  /** Cap for renderer.setPixelRatio(Math.min(devicePixelRatio, dprCap)). */
-  dprCap: number;
-  /** WebGL context antialias (context-creation-FIXED — cannot change live). */
-  antialias: boolean;
-  /** Directional/spot shadow map size (0 = shadows off). */
-  shadowMapSize: number;
-  /** 'off' = tone mapping only; 'light' = +FXAA/vignette; 'full' = the named stack. */
-  postLevel: 'off' | 'light' | 'full';
-  /** Multiplier for particle counts / scatter density. */
-  particleScale: number;
-  /** Multiplier for draw distance / fog far. */
-  drawDistanceScale: number;
-  /** Frame target — phones pace to a STABLE 30 over a stuttery 45. */
-  frameCap: number;
-  /** Max remote players fully animated/drawn (multiplayer); rest billboard. */
-  remoteAvatarCap: number;
-}
-
-export const TIERS: Record<TierName, QualityTier> = {
-  'phone-low': {
-    name: 'phone-low',
-    dprCap: 1,
-    antialias: false,
-    shadowMapSize: 512,
-    postLevel: 'off',
-    particleScale: 0.25,
-    drawDistanceScale: 0.5,
-    frameCap: 30,
-    remoteAvatarCap: 4,
-  },
-  phone: {
-    name: 'phone',
-    dprCap: 1.5,
-    antialias: false,
-    shadowMapSize: 1024,
-    postLevel: 'light',
-    particleScale: 0.5,
-    drawDistanceScale: 0.75,
-    frameCap: 60,
-    remoteAvatarCap: 8,
-  },
-  desktop: {
-    name: 'desktop',
-    dprCap: 2,
-    antialias: true,
-    shadowMapSize: 2048,
-    postLevel: 'full',
-    particleScale: 1,
-    drawDistanceScale: 1,
-    frameCap: 60,
-    remoteAvatarCap: 64,
-  },
-  'desktop-high': {
-    name: 'desktop-high',
-    dprCap: 2,
-    antialias: true,
-    shadowMapSize: 2048,
-    postLevel: 'full',
-    particleScale: 1,
-    drawDistanceScale: 1,
-    frameCap: 240,
-    remoteAvatarCap: 64,
-  },
-};
-
-/** Quality setting persisted PER DEVICE (localStorage) — quality is a property
- *  of the phone, not the player, so it deliberately does not ride account
- *  state. 'auto' = heuristics + governor. */
-const SETTING_KEY = 'genex:quality';
-export type QualitySetting = 'auto' | 'low' | 'medium' | 'high';
-
-export function getQualitySetting(): QualitySetting {
-  try {
-    const v = localStorage.getItem(SETTING_KEY);
-    if (v === 'low' || v === 'medium' || v === 'high') return v;
-  } catch {
-    /* storage blocked */
-  }
-  return 'auto';
-}
-
-export function setQualitySetting(v: QualitySetting): void {
-  try {
-    localStorage.setItem(SETTING_KEY, v);
-  } catch {
-    /* storage blocked */
-  }
-}
-
-function isTouchDevice(): boolean {
-  try {
-    const coarse = matchMedia('(pointer: coarse)').matches;
-    const touch = navigator.maxTouchPoints > 1;
-    const nav = navigator as Navigator & { userAgentData?: { mobile?: boolean } };
-    const mobileUA = nav.userAgentData
-      ? !!nav.userAgentData.mobile
-      : /Mobi|Android/i.test(navigator.userAgent);
-    return (touch && coarse) || mobileUA;
-  } catch {
-    return false;
-  }
-}
-
-/** Android GPU model → strong-enough-for-'phone' (vs 'phone-low'). Tiny,
- *  vendored on purpose (no detect-gpu dependency): renderer strings are only
- *  meaningful on Android/desktop anyway, and the governor corrects mistakes. */
-const STRONG_ANDROID_GPU = /Adreno \(TM\) [67]\d\d|Adreno \(TM\) 8|Mali-G7[18]|Mali-G[89]\d|Immortalis|Xclipse/i;
-
-function androidGpuLooksStrong(): boolean {
-  try {
-    const canvas = document.createElement('canvas');
-    const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
-    if (!gl) return false;
-    const info = gl.getExtension('WEBGL_debug_renderer_info');
-    const renderer = info ? String(gl.getParameter(info.UNMASKED_RENDERER_WEBGL)) : '';
-    const ext = gl.getExtension('WEBGL_lose_context');
-    if (ext) ext.loseContext(); // free the probe context immediately
-    return STRONG_ANDROID_GPU.test(renderer);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Pick the STARTING tier. Manual setting wins; 'auto' uses heuristics:
- * - non-touch → desktop
- * - touch: old OS or small memory signals → phone-low; strong/new → phone
- * The kit may have clamped devicePixelRatio — prefer its pristine stash.
- */
-export function detectTier(): QualityTier {
-  const setting = getQualitySetting();
-  if (setting === 'low') return TIERS['phone-low'];
-  if (setting === 'medium') return TIERS.phone;
-  if (setting === 'high') return TIERS.desktop;
-
-  if (!isTouchDevice()) return TIERS.desktop;
-
-  const ua = navigator.userAgent;
-  const kit = (window as Window & { __GENEX_KIT__?: { realDpr?: number } }).__GENEX_KIT__;
-  const dpr = kit?.realDpr ?? window.devicePixelRatio;
-  const isIOS = /iPhone|iPad|iPod/.test(ua) || (navigator.maxTouchPoints > 1 && /Mac/.test(ua));
-
-  if (isIOS) {
-    // iOS version floors device age (iOS 17 ⇒ XS/2018+; screen+DPR refine).
-    const m = ua.match(/OS (\d+)_/);
-    const major = m ? Number(m[1]) : 0;
-    if (major >= 17) return TIERS.phone;
-    return TIERS['phone-low'];
-  }
-  const am = ua.match(/Android (\d+)/);
-  const androidMajor = am ? Number(am[1]) : 0;
-  if (androidMajor >= 13 && (dpr >= 2.5 || androidGpuLooksStrong())) return TIERS.phone;
-  return TIERS['phone-low'];
-}