Audit fixes + gameplay/UX rounds + World Richness + Material Identity passes

[LundstedtAdam]

Implements the prioritized action plan from the full code audit, plus eight follow-up rounds.

Round 1 — audit fixes

Bug fixes

• Cargo capacity lost on reload: setShipUpgrades now derives backpackCapacity from the cargo tier.
• Resource duplication: upgradeShip and craft persist inventory/items immediately.
• Ground drops lost on reload: backpack-overflow drops now persist per body.
• Stuck input after Alt-Tab: keyboard/mouse state clears on window blur and pointer-lock loss.
• Player embedded in terrain on long falls: vertical collision is swept in sub-voxel steps.

Performance

• Ship telemetry moved out of per-frame zustand writes into a non-reactive shipTelemetry object.
• Crosshair aim raycast capped to digging reach and the 3×3×3 chunk neighbourhood.
• VoxelHUD compass and DiscoveryPanel sensor polls only setState when the visible reading changed.

UX & tests

• First-time control-hints overlay per mode; renderer-init-failure overlay instead of a black screen.
• vitest + jsdom test suite; findNearby* scanners collapsed into one generic helper; eslint underscore convention.

Round 2 — gameplay & UX improvements

• Settings everywhere + FOV: gear button in every HUD (flight/landed/on-foot), plus a persisted FOV slider (60–100°).
• Minecraft-style water: non-solid, swimmable, translucent double-sided surface mesh separate from opaque terrain, placeable-into, underwater tint overlay.

Round 3 — Settings panel: unreachable rows, dead taps, and settings that silently did nothing

• No scroll container anywhere in the panel's chain — rows past the viewport were unreachable on small screens. Fixed by splitting into a fixed header + scrolling .settings-body.
• A global touchend double-tap-zoom guard suppressed the native click on any second tap within 300ms anywhere on the page. Now scoped to taps that also land within ~40px of each other.
• "Mouse/touch sensitivity" only affected the on-foot look, never the ship's mouse-drag orbit or virtual joystick — now scales both, relative to the default value.
• "Invert pitch" was applied in every flight input path but not to the on-foot look.
• The FOV setting was silently overridden every frame during descent/ascent and reset to a fixed 70 on the legacy pre-disembark surface view — all three now use the player's FOV as their base, preserving the existing cinematic curves.

Round 4 — hardcoded body names leaking through in English mode

Three HUD components rendered sceneMode.planet/sceneMode.target directly instead of translating it, so the raw internal canonical id (the Swedish name used throughout the data layer, e.g. "Jorden") was shown as-is regardless of the active language — SurfaceHUD.tsx, VoxelHUD.tsx, DescentOverlay.tsx. All three now go through useT()'s name() helper. Also filled a related gap: BODY_NAMES was missing Pluto/Charon, plus a completeness test that fails loudly if a future body is added without a matching translation entry.

Round 5 — scan range was gated by distance to a POI's anchor point, not its footprint

A modular POI (structures.ts) can span up to POI_MAX_HALF_EXTENT (32 voxels) from its cell-hash anchor, assembled from 4–6 jigsaw-connected 8×8 modules — but the scanner's proximity check (findNearbyPOI/findNearbyWarLorePOI) only ever measured distance to that anchor point, never the structure's actual generated extent. SCAN_RANGE is 14, so a player standing in a peripheral module of a large ruin (or anywhere the anchor itself happened to fall inside solid terrain) could be physically on/inside the structure and still never get close enough to the anchor to trigger a scan.

• findNearbyPOI/findNearbyWarLorePOI now correct the raw anchor-distance into a distance-to-footprint (0 once the player is standing anywhere inside it), reusing the same memoized generatePOI() result the terrain stamper already built for that cell — a guaranteed cache hit by scan time, no measurable added cost.
• findNearbyDeepSite (Layer 2 chambers) had the same class of bug at a smaller scale (chamber radii 8–18 can exceed SCAN_RANGE from the center point alone) — distance is now clamped to the actual carved cylinder shape instead.
• Both corrections only ever reduce the reported distance versus the old formula, so nothing previously scannable becomes unscannable — this can only newly enable scans that previously failed near a structure's edges.
• 5 new regression tests cover both corrections against the real generated footprint/chamber shape, not hardcoded magic numbers.

Round 6 — Minecraft-style grid inventory + passive extractor/condenser production with offline progression

Grid inventory: the backpack sheet now renders a Minecraft-style grid of item slots (ItemSlot.tsx) — a coloured icon swatch reusing the existing RESOURCE_COLOR/CRAFTED_COLOR tables, badged with the stack count — instead of a scrolling text list. Tapping a slot selects it and reveals a Drop action for that stack; the underlying Partial> data model is unchanged (it already was a stack map, just rendered as text before).

Passive production: two new placeable structures, extractor and condenser, accumulate a resource over time while powered:

• An extractor is assigned the ore vein the player was aiming at when placed (falling back to the same direction-scan the orbital-scanner UI already uses to find the nearest vein); a condenser draws atmospheric volatiles and is gated to zero output on airless bodies via the existing hasAtmosphere check, so it never draws power there either.
• planetPower allocation is now priority-ordered — refinery, then extractor, then condenser — each consuming from whatever generation is left after the previous kind, so refining (the later stage of the chain) isn't starved by earlier stages.
• Production ticks once a second alongside the existing refineTick, depositing into the structure's own capacity-limited storage and spilling overflow to the ground exactly like mining overflow does. Extractors/condensers reuse the silo sheet UI (walk up, open, withdraw) rather than requiring the player to mine the block to collect their yield.
• Extractors cost one Mining Drill (the previously-unused 11.2 crafted item), giving it a purpose in the crafting chain.

Offline progression: each body now persists a lastActive wall-clock timestamp (localforage, same pattern as existing per-body keys). When a body's structures are loaded, the elapsed real-world time since lastActive is applied as a single production catch-up (applyOfflineProduction), capped at 72h and clamped to zero if the elapsed time is negative (clock wound backward).

• Known tradeoff: there is no trusted clock available client-side, so this cannot be made fully tamper-proof. The 72h cap bounds a single "jump" to a plausible away-from-the-game absence, but a determined player could still repeat the exploit by winding the device clock forward repeatedly and reloading. The residual risk is bounded (not eliminated) by each producer's own storage capacity acting as a ceiling, and by offline catch-up never spilling excess to the ground (unlike the online tick) — it's silently capped instead, so there's nothing to gain by maximizing overflow.
• 8 new tests cover fractional-progress accumulation, power gating (including the atmosphere gate), ground-drop overflow on the online tick, and the offline-catch-up cap/clamp/negative-elapsed behavior.

Verified: npm run build (tsc strict + vite), npm run lint, npm test (52 tests) — all green.

Round 7 — World Richness: procedural environmental density across the voxel walking layer (8 phases)

A large content/systems pass increasing exploration density and per-planet identity on foot, built entirely by extending existing systems (no parallel architecture, no redesign of the chunk/mesh/streaming pipeline). Every phase reuses the codebase's own established primitives: cell-hash deterministic placement (findNearestCellSpec/craters/POIs), the VoxelScatter.tsx instancing pattern, and fbm2/valueNoise2/valueNoise3.

Phase 1 — per-planet terrain identity from already-authored data. BiomeProfile had detailFreq/detailAmp, microFreq/microAmp, and cellNoiseFreq/cellNoiseAmp fields authored per body but only ever consumed by the GPU orbital shader — voxel worldgen ignored them, so every body sharing an archetype had an identical height-field shape. Wired into columnHeight as extra octaves and into layerBlock's subsoil/rock threshold (a lateral perturbation so strata bands wave across cliffs instead of forming a flat plane).

Phase 2 — ground decoration density (VoxelScatter.tsx). Two new scatter kinds (blade, a hand-built crossed-quad billboard; branch, a pre-rotated cylinder). Every body now layers: fine abiotic grit (always), a universal "ore tell" fleck only where a vein actually surfaces (reuses oreAt directly, never lies about what's below), the existing per-archetype feature layer, and any authored accents — additive instead of the old either/or selection, so curated bodies (Mars, Europa, …) gain density rather than losing their archetype baseline. The 12 bodies with no authored props got one distinguishing accent each.

Phase 3 — POI structural variety + micro-discovery channel (structures.ts). Two new module kinds (bridge, an elevated gangway; collapsed, a room whose walls/roof have already failed) and a new outpost POI type. A new cache POI type (budget [1,1], 4-6 voxels) is the micro-discovery channel — a universal MICRO_DISCOVERY spec concatenated onto every body's POIs (same "universal + per-body" composition resourceProfiles.ts's FUNDAMENTALS already uses), giving frequent small cosmetic finds without any per-instance authoring.

Phase 4 — cave/terrain 3D richness. New fbm3 noise primitive. A worm-tunnel carve (two independent fbm3 fields intersected near their midpoint) is additive to the existing blobby-cavern test, giving winding tunnels alongside caverns. A rarer, cliff-gated overhang carve (4-sample slope probe) allows shallow undercuts on steep faces only. The rock-layering jitter from Phase 1 is the same mechanism used here.

Phase 5 — latitude-based biome transitions. A flat-world latitude proxy (latitudeOf, pure function of world-Z distance from the equator) drives two things: a shader-side blend toward each body's own (previously unused) colorPolar near the "poles" — a pure TSL addition to voxelMaterial.ts, never touching the per-block palette or the mesher/worker transfer contract — and a density falloff on Earth's grass/flora scatter layers.

Phase 6 — hydrology: lakes, rivers, wetlands, waterfalls. Procedural LakeSpec (cell-hash basins, gated by archetype — ordinary lakes on Earth, sparser methane lakes tinted differently on Titan/dune) and a new river LandmarkSpec kind (a short polyline, canyon-style trench per segment). A new localWaterCeilingAt computes the higher of the global sea and any active lake/river's own natural rim height per column, used for the fill decision, for surfaceHeightAt's spawn-safety check, and for VoxelScatter's underwater/shoreline checks. Shoreline dressing reuses the waterAdjacent filter (abiotic everywhere water exists; Earth-only reeds). Waterfalls are never cell-hash scattered like other emitters — RiverWaterfalls.tsx derives them automatically from a river's own polyline wherever consecutive points' natural height drops enough, so they can't drift out of sync with the river geometry.

Phase 7 — procedural trees (cosmetic, superseded on Earth by Round 8). A parameterized (not full L-system) prefab — tapered trunk + optional canopy sphere, both InstancedMesh — placed with the same cell-hash/ring-shell/LOD pattern as VoxelScatter, in a new sibling VoxelTrees.tsx. A low-frequency forest-coverage mask clusters trees into groves instead of a uniform carpet. Dead trees skip the canopy; fallen trees reuse the trunk geometry reoriented.

Phase 8 — ambient wildlife. Small instanced creatures (birds, ground critters, ambiguous "drifters") with simple procedural circling/bobbing motion, modeled on Emitters.tsx's existing column-emitter pattern. A new AudioManager.playWildlifeCall synthesizes two calls (no sample assets — same oscillator/noise-buffer technique as the existing playSurfaceTexture), scheduled by a parallel driver in VoxelAudio.tsx alongside (never replacing) the existing texture scheduler.

Narrative-integrity decision (confirmed with the user before implementation): the game already has a rule that no body has "confirmed" life (LifeStatus has no such value; a validator enforces this over all lore text). Phases 2/7/8's flora/fauna-like content is gated by a single shared lifeAmbiguous() (moved into contentProfiles.ts, the canonical narrative-data module, so all three phases read the same source of truth): real biology only on Earth; sparse, deliberately ambiguous life-like content only on the handful of bodies already flagged theoretical/inconclusive in their science notes (Mars, Titan, Venus, Europa, Ganymede); every other body stays abiotic-only.

Explicitly out of scope, with rationale: the orbital/pre-landing GPU terrain shader (different rendering path, not the "voxel world" the objective named); full connected river-network hydraulic simulation (bounded 2-4 point polylines only); visible tree branch geometry/exposed roots/hollow trunks (a canopy sphere already reads as "tree" at voxel-game distances; a third instanced part wasn't judged worth the complexity this round).

64 new tests across 6 new/extended test files cover the deterministic logic in every phase (noise primitives, height-field perturbation, cave carving, lake/river carving and water fill, POI generation, narrative gating for scatter/trees/wildlife).

Manual in-game playtesting has not been done for this round — this environment cannot run the WebGPU renderer interactively, so no phase's visual result, frame time, or exact placement (the one demonstration river added to Earth in particular) has been inspected live. Recommended before considering Round 7 fully closed.

Round 8 — Material Identity: procedural texture atlas + choppable voxel trees

Every voxel previously carried a single flat vertex color as its only material signal. This round gives every block a real, texture-based material identity — extending the existing chunk/mesh/worldgen pipeline, not replacing it — and turns Earth's forest from cosmetic scenery into a real, choppable part of the terrain.

Texture atlas (textureAtlas.ts, new). A small (128×128) atlas is generated once as a deterministic raw pixel buffer — seeded procedural math (reusing the existing valueNoise2 primitive), not Canvas2D/OffscreenCanvas, so it builds correctly under the vitest/jsdom test environment and stays importable inside the mesher worker without pulling three's DataTexture code into that bundle (confirmed via the worker chunk's build output size). 17 material tiles (grass top/side, dirt, stone, sand, ice, ice-glow, lava, sulphur, bark top/side, leaves, metal, panel, glass, ore-fleck, build) each get their own procedural pattern — fleck noise, high-frequency crack lines for stone, vertical streaks for bark, clustered noise for leaves. getBlockFaceTiles(id) maps every block id to a {top, side, bottom} tile triple — grass gets a distinct green top / dirt-blended side / dirt bottom, wood gets bark sides vs. end-grain caps, everything else is uniform.

Pipeline threading. greedyMesh.ts's emitQuad — which already computes face direction right where it reads the palette — now also emits a materialUV vertex attribute (raw, unwrapped per-quad-corner coordinates, not normalized 0-1), so a greedy-merged multi-voxel quad repeats the texture once per voxel instead of stretching one tile across it. The attribute threads through the existing MeshResult/worker transfer contract (voxelTypes.ts, mesher.worker.ts, mesher.ts) exactly like positions/normals/colors already do. voxelMaterial.ts samples the atlas via a new TSL texture() node and multiplies it against the existing per-vertex biome-tint/AO color — texture is now the primary material signal, biome color is a diluted (TINT_STRENGTH = 0.4) overlay on natural terrain/tree blocks only; ore veins and player-built structures keep their existing full-strength tint unchanged (that saturation was already deliberate, so built things read as artificial).

Choppable voxel trees. Two new block ids, WOOD_LOG and LEAVES. A new trees.ts generates a deterministic trunk-plus-canopy voxel assembly (reusing structures.ts's SVoxel/BuiltStructure contract and seeded PRNG — not routed through the POI room-jigsaw machinery, which doesn't fit a tree), and a new stampTrees() in worldGen.ts places them on Earth using the same cell-hash/forest-coverage-mask tuning the old cosmetic forest used. Mining a trunk voxel (ChunkManager.tsx's mineTick) now cascades upward through the whole log column, yielding one 'wood' resource per log via the existing mining pipeline; afterward a new treeDecay.ts scans the felled column's own bounding box for any LEAVES voxel left with no WOOD_LOG within a small radius and silently removes it — bounded to that tree's own footprint, so no general voxel-grid flood-fill was needed. Earth's old purely-cosmetic, non-interactic InstancedMesh forest (treeProfiles.ts/VoxelTrees.tsx) is retired; the separate "ambiguous alien growth" decorative variant on theoretical/inconclusive bodies is untouched, since those are deliberately non-interactive by narrative design.

Explicitly out of scope, with rationale: per-archetype texture variants (a "dirt" tile looks the same on every body today; only the biome tint overlay varies) — not requested and would meaningfully grow the atlas/authoring surface for a cosmetic-only gain; a general voxel-grid BFS for leaf decay — the bounded per-tree scan is provably sufficient since a chop can only ever disconnect leaves belonging to that same tree.

26 new tests across 3 new test files (textureAtlas.test.ts, trees.test.ts, treeDecay.test.ts) plus extensions to greedyMesh.test.ts, worldGen.test.ts, and treeProfiles.test.ts cover tile-mapping correctness, per-voxel-unit UV tiling under greedy merging, tree-generation determinism and bounds, and leaf-decay adjacency logic.

Manual in-game/visual playtesting has not been done for this round — this environment cannot render WebGPU live, so the atlas's on-screen appearance, whether materials actually read as distinct at a glance, chop/felling game feel, and any frame-rate impact from the added texture sample have not been inspected on a real device. Recommended before considering Round 8 fully closed.

Round 8 fix 1 — grass/weed scatter renders as solid quads, not cut-out foliage

Reported after Round 8: VoxelScatter.tsx's crossedQuadGeometry (the blade prop kind — grass tufts/weeds/reeds, layered onto most bodies' ground clutter) had no UV attribute and its material had no alpha texture, so the billboard rendered as a flat solid colored rectangle instead of a foliage silhouette. Three other rendering issues were reported alongside this one (UV stretching on terrain, missing ambient occlusion, floating scatter/wildlife) — each was checked directly against the code before touching anything, and none were actually present: the per-voxel-unit UV tiling and AO baking added earlier in Round 8 are intact and already covered by passing regression tests, and the height-sampling functions (landHeightAt/columnHeight) are pure functions of world position with zero dependency on chunk-mesh generation state, so the hypothesized race condition can't exist in this codebase. Per the user's decision, only the confirmed scatter issue was fixed, to avoid risking regressions in already-correct, already-tested code.

Fix: a new deterministic alpha-cutout grass-blade texture (textureAtlas.ts's getBladeAlphaTexture — three tapered strands narrowing root-to-tip, same raw-pixel-buffer generation pattern as the material atlas, no Canvas/DOM), a standard UV attribute on the crossed-quad geometry (extracted to a new scatterGeometry.ts for unit-testability, mirroring the existing Emitters.tsx/emitterPoints.ts split), and alphaTest-based cutout wired onto the blade material only — every other scatter kind (crystal/spire/fungus/slab/branch) is intentionally solid 3D geometry, not a billboard, and is untouched.

6 new tests (textureAtlas.test.ts, scatterGeometry.test.ts) cover the texture's determinism, its cutout (non-uniform alpha) and root-to-tip taper, and the geometry's UV mapping. Not visually verified on a live WebGPU device.

Round 8 fix 2 — sun light silently dropped by the WebGPU node renderer (the real cause of a flat, dark, textureless surface)

A live screenshot from an actual device (iOS Safari) showed the on-foot Earth surface rendering as one flat, dark, textureless wash — no visible grass/dirt/stone material variation anywhere, even in open areas. Investigated two hypotheses purely by reading code:

• Silent WebGPU→WebGL2 fallback on that device — ruled out. Three.js's hybrid renderer runs the identical shared node-graph machinery (custom attributes, DataTexture, texture() sampling) under both backends; this wouldn't by itself produce a flat/dark result, and this codebase's only renderer-failure path is a full-screen takeover, clearly not engaged since the game is fully playable.
• A real texture-pipeline bug — ruled out on inspection: DataTexture colorSpace/mipmap defaults and the materialUV/atlas-tile UV math all check out correct.

Actual root cause: SolarSystem.tsx registers each classic-three light class it uses with the WebGPU renderer's node library (library.addLight(NodeClass, LightClass) — the node system looks up a light's shader-node handler by light.constructor, and an unregistered class is dropped with a console warning, every frame). AmbientLight and PointLight were registered; DirectionalLight — VoxelScene.tsx's SunLight, the voxel surface's only directional key light, and the sole source of directional shading, the normal-jitter effect, and shadows — never was. This is a pre-existing gap dating to the original Phase 9.2 voxel pass, not something this session's texture-atlas work introduced; nothing caught it before because no prior round's commit was ever checked against a live device.

With only flat ambient light reaching the terrain, the newly-added texture atlas and baked AO are both still present in the mesh data, but with zero directional falloff or specular response to give them contrast, everything reads as one flat, dim wash — exactly matching the screenshot.

Fix: one-line addition to the existing registration block in SolarSystem.tsx —

library.addLight(DirectionalLightNode, DirectionalLight);

DirectionalLightNode is a named export from three/webgpu, same import path as the two already-registered light-node classes. DirectionalLight is used nowhere else in the codebase, so this has no other call sites to affect.

Round 8 fix 3 — settings highlight, sun/bloom green glow + crash on quality change, grass texture orientation

Reported next, together with a Minecraft screenshot as a visual-clarity reference:

• Settings panel never highlights the active option. src/ui/SettingsPanel.tsx's quality/language/game-mode pickers correctly apply an active class, and styles.css defines a distinct look for it — but a later, equal-specificity rule (.settings-panel .setting-row button) always won the cascade tie and painted every pill button identically. Fixed by scoping the active rule under .settings-panel to raise its specificity so it always wins regardless of declaration order.
• Changing quality settings washed the screen green, then crashed. Two independent bugs: (1) the sun's deliberately-HDR core material used an extreme, unevenly-scaled multiplier (3.5/2.8/2.0, "so the bloom pass makes it glow") — bloom is off on Low (invisible) and turns on at Medium+, at which point ACES filmic tonemapping's well-known hue-shift-toward-green artifact on very bright, unevenly-scaled highlights kicks in (this exact bug class was already hit and fixed for the ship model's emissive glow elsewhere in this repo); retuned to a lower-magnitude warm-white value matching this codebase's own established sunlight color. (2) Effects.tsx rebuilt its entire postprocessing GPU pipeline (PostProcessing + PassNode +, when bloom is on, BloomNode's ~11 render targets) from scratch on every quality change without ever disposing the previous instance — a leak that eventually hits a WebGPU resource-exhaustion crash. Now the pipeline only rebuilds (with proper disposal) when bloom/chromatic-aberration structurally turn on or off; ordinary quality-tier tuning updates the existing reactive GPU uniforms in place instead (bloom's strength/radius/threshold are already uniform()-wrapped internally; added an equivalent uniform for chromatic aberration, mirroring this file's existing heatUniform pattern).
• Grass block side faces were misoriented — found while checking the texture atlas against the Minecraft reference. Two real, provable-by-tracing-the-code bugs, not subjective tuning: textureAtlas.ts's grass/dirt row mapping was backwards relative to how DataTexture's flipY=false and the UV emission actually place texture-space v=0/v=1 on a rendered voxel face, so grass showed at the bottom and dirt at the top; and east/west faces (d===0 in greedyMesh.ts) use the opposite sweep-axis pairing from north/south faces (d===2), so the gradient ran horizontally instead of vertically on two of every grass block's four side faces. Fixed both, and narrowed the transition band for a crisper grass/dirt edge closer to the reference image.

1 new regression test (greedyMesh.test.ts) proves the east/west UV-axis fix by isolating vertices with a nonzero X normal and asserting the vertical texture axis — not the horizontal one — scales with a vertical voxel merge.

Round 8 fix 4 — green glow persisted on High/Ultra (two more HDR sources)

Fix 3's sun-core retune was real but incomplete — the user confirmed the glow was still present specifically on High/Ultra. Two more uncapped/extreme HDR "sun glow" sources were found, both untouched by fix 3:

• VoxelSky.tsx/Sky.tsx's sky-dome sun disc (identical code in both files, deliberately kept separate per this project's voxel/orbital rendering split): peaked at 8.6× magnitude — over 4× higher than the already-fixed sun mesh, and covering a full-screen sky dome rather than a small sphere. Reduced to 2.6× peak in both.
• Sun.tsx's corona inner ring: an even more extreme, unevenly-scaled ratio (1:0.55:0.2) than the original problematic sun-core value, at 2.4× magnitude — left untouched in fix 3 as "not the primary source," which undersold its contribution. Reduced to 1.6× at a much less extreme 1:0.8:0.6 ratio.

This explains the High/Ultra-specific symptom: quality.ts's bloomThreshold drops (0.85 → 0.75 → 0.65) and bloomStrength rises (0.25 → 0.3 → 0.35) from medium to ultra, so higher tiers admit more of this previously-unfixed HDR into bloom and amplify it harder. No other extreme/uncapped HDR source was found elsewhere in the scene (terrainMaterial.ts, Clouds.tsx, AsteroidBelt.tsx, and the planet materials in materials.ts are all non-HDR or already texture-bounded to ≤1).

Pure numeric constant changes, no logic/test impact.

---

Attempted a live visual check via Playwright + the pre-installed Chromium against a local preview build for fixes 2-4 — real WebGPU is active in this sandbox (three.js's own "WebGPU is experimental on this platform" log confirms it engaged, not a WebGL fallback), but its software GPU implementation fails outright on this app's buffer sizes (createBuffer failed... too large for the implementation), so the canvas never renders anything here — an environment limitation, not a code issue, unrelated to any of these fixes. All four fixes still need confirmation on real hardware. If the glow persists after fix 4, the most useful next report is exactly which object still shows it (sky vs. sun disc vs. corona) rather than another blind sweep.

Verified (all fixes): npx tsc --noEmit, npm run lint, npx vite build, npm test (119 tests) — all green.

🤖 Generated with Claude Code

https://claude.ai/code/session_01WGDzMFuEEA5rqcHcgTHXid