From 12da3134a04af046655a6be57071eb9a0c35b1a0 Mon Sep 17 00:00:00 2001
From: "Al @h0lybyte" <5599058+h0lybyte@users.noreply.github.com>
Date: Sun, 8 Mar 2026 07:05:45 -0400
Subject: [PATCH 1/3] fix(dashboard): session detection in ArgoCD and Home
 dashboards (#7787)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(dashboard): use initSupa/getSupa for session detection in ArgoCD and Home dashboards

useAuthBridge() does not return session or isLoading — those properties are undefined, causing both dashboards to always show "Sign in required". Switched to the same initSupa()/getSupa().getSession() pattern used by the working Grafana dashboard.

* fix(dashboard): remove unused useAuthBridge import from ArgoCD dashboard
---
 .../dashboard/ReactArgoDashboard.tsx          | 59 ++++++++++++++-----
 .../dashboard/ReactDashboardHome.tsx          | 58 +++++++++++++-----
 2 files changed, 89 insertions(+), 28 deletions(-)

diff --git a/apps/kbve/astro-kbve/src/components/dashboard/ReactArgoDashboard.tsx b/apps/kbve/astro-kbve/src/components/dashboard/ReactArgoDashboard.tsx
index 93dc3eb62..f9281b5ef 100644
--- a/apps/kbve/astro-kbve/src/components/dashboard/ReactArgoDashboard.tsx
+++ b/apps/kbve/astro-kbve/src/components/dashboard/ReactArgoDashboard.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useState, useCallback } from 'react';
-import { useAuthBridge } from '@/components/auth';
+import { initSupa, getSupa } from '@/lib/supa';
 import {
 	Activity,
 	RefreshCw,
@@ -514,7 +514,10 @@ function ApplicationRow({
 // ---------------------------------------------------------------------------
 
 export default function ReactArgoDashboard() {
-	const { session, isLoading: authLoading } = useAuthBridge();
+	const [authState, setAuthState] = useState<
+		'loading' | 'authenticated' | 'unauthenticated'
+	>('loading');
+	const [accessToken, setAccessToken] = useState<string | null>(null);
 
 	const [applications, setApplications] = useState<ArgoApplication[]>([]);
 	const [loading, setLoading] = useState(true);
@@ -523,8 +526,6 @@ export default function ReactArgoDashboard() {
 	const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
 	const [expandedApp, setExpandedApp] = useState<string | null>(null);
 
-	const token = session?.access_token;
-
 	const fetchData = useCallback(async (tkn: string) => {
 		try {
 			setError(null);
@@ -543,9 +544,39 @@ export default function ReactArgoDashboard() {
 		}
 	}, []);
 
-	// Initial load + auto-refresh
+	// Auth init — same pattern as Grafana dashboard
+	useEffect(() => {
+		let cancelled = false;
+
+		(async () => {
+			try {
+				await initSupa();
+				const supa = getSupa();
+				const sessionResult = await supa.getSession().catch(() => null);
+				const session = sessionResult?.session ?? null;
+
+				if (cancelled) return;
+
+				if (!session?.access_token) {
+					setAuthState('unauthenticated');
+					return;
+				}
+
+				setAccessToken(session.access_token as string);
+				setAuthState('authenticated');
+			} catch {
+				if (!cancelled) setAuthState('unauthenticated');
+			}
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	// Data load + auto-refresh
 	useEffect(() => {
-		if (!token) return;
+		if (!accessToken) return;
 
 		// Try cache first
 		const cached = loadCache();
@@ -555,20 +586,20 @@ export default function ReactArgoDashboard() {
 			setLoading(false);
 		}
 
-		fetchData(token);
+		fetchData(accessToken);
 
 		const interval = setInterval(
-			() => fetchData(token),
+			() => fetchData(accessToken),
 			REFRESH_INTERVAL_MS,
 		);
 		return () => clearInterval(interval);
-	}, [token, fetchData]);
+	}, [accessToken, fetchData]);
 
 	// -----------------------------------------------------------------------
 	// Auth states
 	// -----------------------------------------------------------------------
 
-	if (authLoading) {
+	if (authState === 'loading') {
 		return (
 			<div style={fullCenter}>
 				<Loader2
@@ -583,7 +614,7 @@ export default function ReactArgoDashboard() {
 		);
 	}
 
-	if (!session || !token) {
+	if (authState === 'unauthenticated' || !accessToken) {
 		return (
 			<div style={fullCenter}>
 				<LogIn
@@ -685,9 +716,9 @@ export default function ReactArgoDashboard() {
 				</div>
 				<button
 					onClick={() => {
-						if (token) {
+						if (accessToken) {
 							setLoading(true);
-							fetchData(token);
+							fetchData(accessToken);
 						}
 					}}
 					disabled={loading}
@@ -834,7 +865,7 @@ export default function ReactArgoDashboard() {
 						<ApplicationRow
 							key={app.metadata.name}
 							app={app}
-							token={token}
+							token={accessToken}
 							expanded={expandedApp === app.metadata.name}
 							onToggle={() =>
 								setExpandedApp(
diff --git a/apps/kbve/astro-kbve/src/components/dashboard/ReactDashboardHome.tsx b/apps/kbve/astro-kbve/src/components/dashboard/ReactDashboardHome.tsx
index 6c6860209..719e705f2 100644
--- a/apps/kbve/astro-kbve/src/components/dashboard/ReactDashboardHome.tsx
+++ b/apps/kbve/astro-kbve/src/components/dashboard/ReactDashboardHome.tsx
@@ -6,14 +6,13 @@ import React, {
 	useMemo,
 	Suspense,
 } from 'react';
-import { useAuthBridge } from '@/components/auth';
+import { initSupa, getSupa } from '@/lib/supa';
 import {
 	BarChart3,
 	GitBranch,
 	Zap,
 	Loader2,
 	LogIn,
-	ShieldOff,
 	ArrowRight,
 	Activity,
 } from 'lucide-react';
@@ -351,23 +350,54 @@ function StatItem({
 // ---------------------------------------------------------------------------
 
 export default function ReactDashboardHome() {
-	const { session, isLoading: authLoading } = useAuthBridge();
+	const [authState, setAuthState] = useState<
+		'loading' | 'authenticated' | 'unauthenticated'
+	>('loading');
+	const [accessToken, setAccessToken] = useState<string | null>(null);
 	const [grafana, setGrafana] = useState<GrafanaSummary | null>(null);
 	const [argo, setArgo] = useState<ArgoSummary | null>(null);
 	const [edge, setEdge] = useState<EdgeSummary | null>(null);
 	const [loading, setLoading] = useState(true);
 	const containerRef = useRef<HTMLDivElement>(null);
 
-	const token = session?.access_token;
+	// Auth init — same pattern as Grafana dashboard
+	useEffect(() => {
+		let cancelled = false;
+
+		(async () => {
+			try {
+				await initSupa();
+				const supa = getSupa();
+				const sessionResult = await supa.getSession().catch(() => null);
+				const session = sessionResult?.session ?? null;
+
+				if (cancelled) return;
+
+				if (!session?.access_token) {
+					setAuthState('unauthenticated');
+					return;
+				}
+
+				setAccessToken(session.access_token as string);
+				setAuthState('authenticated');
+			} catch {
+				if (!cancelled) setAuthState('unauthenticated');
+			}
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, []);
 
 	const fetchAll = useCallback(async () => {
 		setLoading(true);
 		const edgePromise = fetchEdgeSummary();
 
-		if (token) {
+		if (accessToken) {
 			const [g, a, e] = await Promise.all([
-				fetchGrafanaSummary(token),
-				fetchArgoSummary(token),
+				fetchGrafanaSummary(accessToken),
+				fetchArgoSummary(accessToken),
 				edgePromise,
 			]);
 			setGrafana(g);
@@ -378,16 +408,16 @@ export default function ReactDashboardHome() {
 			setEdge(e);
 		}
 		setLoading(false);
-	}, [token]);
+	}, [accessToken]);
 
 	useEffect(() => {
-		if (!authLoading) fetchAll();
-	}, [authLoading, fetchAll]);
+		if (authState === 'authenticated') fetchAll();
+	}, [authState, fetchAll]);
 
 	// GSAP entrance animation
 	useGSAP(
 		() => {
-			if (authLoading || !containerRef.current) return;
+			if (authState !== 'authenticated' || !containerRef.current) return;
 
 			const header =
 				containerRef.current.querySelector('.dashboard-header');
@@ -414,14 +444,14 @@ export default function ReactDashboardHome() {
 				});
 			}
 		},
-		{ scope: containerRef, dependencies: [authLoading, loading] },
+		{ scope: containerRef, dependencies: [authState, loading] },
 	);
 
 	// -----------------------------------------------------------------------
 	// Auth states
 	// -----------------------------------------------------------------------
 
-	if (authLoading) {
+	if (authState === 'loading') {
 		return (
 			<div className="not-content" style={styles.centeredMessage}>
 				<Loader2
@@ -434,7 +464,7 @@ export default function ReactDashboardHome() {
 		);
 	}
 
-	if (!session) {
+	if (authState === 'unauthenticated') {
 		return (
 			<div className="not-content" style={styles.centeredMessage}>
 				<LogIn

From 0e84b638182d6619e22a8f739b6d5e561d395bbd Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 8 Mar 2026 15:53:02 -0400
Subject: [PATCH 2/3] chore(kube): update axum-kbve to v1.0.35 (#7789)

Co-authored-by: Al @h0lybyte <5599058+h0lybyte@users.noreply.github.com>
---
 apps/kbve/axum-kbve/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/kbve/axum-kbve/Cargo.toml b/apps/kbve/axum-kbve/Cargo.toml
index 61e9300a9..e270b0982 100644
--- a/apps/kbve/axum-kbve/Cargo.toml
+++ b/apps/kbve/axum-kbve/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "axum-kbve"
 authors = ["kbve", "h0lybyte"]
-version = "1.0.34"
+version = "1.0.35"
 edition = "2021"
 publish = false
 

From 26f062b0884483fa23f03e3664339778c18f0bc7 Mon Sep 17 00:00:00 2001
From: "Al @h0lybyte" <5599058+h0lybyte@users.noreply.github.com>
Date: Sun, 8 Mar 2026 16:12:42 -0400
Subject: [PATCH 3/3] feat(isometric): expanded grass variation with blade mesh
 and wildflowers (#7790)

- Expand grass cap shades from 8 to 12 for richer tile color variation
- Add tapered blade grass mesh for individual grass blade look
- Add 4 flower materials (white daisy, pink, rose, yellow)
- Expand spawn slots from 3 to 5 (tuft, tall, blade, flower)
- Flowers spawn at ~8% density, slightly raised on stems
---
 Cargo.lock                                    |   2 +-
 .../isometric/src-tauri/src/game/tilemap.rs   | 129 +++++++++++++-----
 2 files changed, 97 insertions(+), 34 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e71c7e950..53677300b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1064,7 +1064,7 @@ dependencies = [
 
 [[package]]
 name = "axum-kbve"
-version = "1.0.33"
+version = "1.0.34"
 dependencies = [
  "anyhow",
  "askama",
diff --git a/apps/kbve/isometric/src-tauri/src/game/tilemap.rs b/apps/kbve/isometric/src-tauri/src/game/tilemap.rs
index 402e36f4a..2c80a4c7a 100644
--- a/apps/kbve/isometric/src-tauri/src/game/tilemap.rs
+++ b/apps/kbve/isometric/src-tauri/src/game/tilemap.rs
@@ -26,11 +26,15 @@ pub struct Tile {
 struct TileMaterials {
     cap: [[Handle<StandardMaterial>; 2]; 4],
     body: [Handle<StandardMaterial>; 4],
-    grass_caps: [Handle<StandardMaterial>; 8],
+    grass_caps: [Handle<StandardMaterial>; 12],
     grass_tuft_mat: Handle<StandardMaterial>,
     grass_tall_mat: Handle<StandardMaterial>,
+    grass_blade_mat: Handle<StandardMaterial>,
     grass_tuft_mesh: Handle<Mesh>,
     grass_tall_mesh: Handle<Mesh>,
+    grass_blade_mesh: Handle<Mesh>,
+    flower_mats: [Handle<StandardMaterial>; 4],
+    flower_mesh: Handle<Mesh>,
 }
 
 pub struct TilemapPlugin;
@@ -119,6 +123,34 @@ fn make_grass_mesh(hw: f32, h: f32) -> Mesh {
     .with_inserted_indices(Indices::U32(indices))
 }
 
+/// Build a single tapered blade (one quad, narrower at top).
+fn make_blade_mesh(hw: f32, h: f32) -> Mesh {
+    let taper = 0.6;
+    #[rustfmt::skip]
+    let positions: Vec<[f32; 3]> = vec![
+        [-hw, 0.0, 0.0], [hw, 0.0, 0.0],
+        [hw * taper, h, 0.0], [-hw * taper, h, 0.0],
+    ];
+    #[rustfmt::skip]
+    let normals: Vec<[f32; 3]> = vec![
+        [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0],
+    ];
+    #[rustfmt::skip]
+    let uvs: Vec<[f32; 2]> = vec![
+        [0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [0.0, 0.0],
+    ];
+    let indices: Vec<u32> = vec![0, 1, 2, 0, 2, 3];
+
+    Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    )
+    .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
+    .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
+    .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, uvs)
+    .with_inserted_indices(Indices::U32(indices))
+}
+
 fn setup_tile_materials(
     mut commands: Commands,
     mut materials: ResMut<Assets<StandardMaterial>>,
@@ -132,8 +164,8 @@ fn setup_tile_materials(
         (0.9, 0.9, 0.95),
     ];
 
-    // 8 noise-varied grass shades (dark forest → dry/yellow)
-    let grass_shades: [(f32, f32, f32); 8] = [
+    // 12 noise-varied grass shades (dark forest → dry/yellow)
+    let grass_shades: [(f32, f32, f32); 12] = [
         (0.22, 0.50, 0.15),
         (0.28, 0.55, 0.18),
         (0.30, 0.60, 0.20),
@@ -142,31 +174,44 @@ fn setup_tile_materials(
         (0.42, 0.58, 0.20),
         (0.35, 0.52, 0.18),
         (0.45, 0.55, 0.25),
+        (0.26, 0.48, 0.16), // mossy dark
+        (0.40, 0.60, 0.18), // warm meadow
+        (0.32, 0.58, 0.24), // lush green
+        (0.48, 0.52, 0.22), // dry patch
     ];
 
-    let grass_caps: [Handle<StandardMaterial>; 8] = grass_shades.map(|(r, g, b)| {
+    let grass_caps: [Handle<StandardMaterial>; 12] = grass_shades.map(|(r, g, b)| {
         materials.add(StandardMaterial {
             base_color: Color::srgb(r, g, b),
             ..default()
         })
     });
 
-    let grass_tuft_mat = materials.add(StandardMaterial {
-        base_color: Color::srgb(0.25, 0.55, 0.15),
-        cull_mode: None,
-        double_sided: true,
-        ..default()
-    });
-
-    let grass_tall_mat = materials.add(StandardMaterial {
-        base_color: Color::srgb(0.20, 0.50, 0.12),
-        cull_mode: None,
-        double_sided: true,
-        ..default()
-    });
+    let make_vegetation_mat =
+        |mats: &mut Assets<StandardMaterial>, r: f32, g: f32, b: f32| -> Handle<StandardMaterial> {
+            mats.add(StandardMaterial {
+                base_color: Color::srgb(r, g, b),
+                cull_mode: None,
+                double_sided: true,
+                ..default()
+            })
+        };
+
+    let grass_tuft_mat = make_vegetation_mat(&mut materials, 0.25, 0.55, 0.15);
+    let grass_tall_mat = make_vegetation_mat(&mut materials, 0.20, 0.50, 0.12);
+    let grass_blade_mat = make_vegetation_mat(&mut materials, 0.22, 0.48, 0.14);
+
+    let flower_mats: [Handle<StandardMaterial>; 4] = [
+        make_vegetation_mat(&mut materials, 0.95, 0.95, 0.90), // white daisy
+        make_vegetation_mat(&mut materials, 0.90, 0.55, 0.65), // pink
+        make_vegetation_mat(&mut materials, 0.85, 0.35, 0.45), // rose
+        make_vegetation_mat(&mut materials, 0.95, 0.85, 0.30), // yellow
+    ];
 
     let grass_tuft_mesh = meshes.add(make_grass_mesh(0.15, 0.25));
     let grass_tall_mesh = meshes.add(make_grass_mesh(0.10, 0.45));
+    let grass_blade_mesh = meshes.add(make_blade_mesh(0.08, 0.35));
+    let flower_mesh = meshes.add(make_grass_mesh(0.08, 0.12));
 
     commands.insert_resource(TileMaterials {
         cap: [
@@ -184,8 +229,12 @@ fn setup_tile_materials(
         grass_caps,
         grass_tuft_mat,
         grass_tall_mat,
+        grass_blade_mat,
         grass_tuft_mesh,
         grass_tall_mesh,
+        grass_blade_mesh,
+        flower_mats,
+        flower_mesh,
     });
 }
 
@@ -293,7 +342,7 @@ fn process_chunk_spawns_and_despawns(
 
                 // Grass band: use noise-varied shade; others: checkerboard
                 let cap_material = if band == 0 {
-                    let shade_idx = (hash2d(tx + 1337, tz) * 8.0) as usize % 8;
+                    let shade_idx = (hash2d(tx + 1337, tz) * 12.0) as usize % 12;
                     tile_materials.grass_caps[shade_idx].clone()
                 } else {
                     let checker = ((tx + tz) & 1) as usize;
@@ -320,25 +369,25 @@ fn process_chunk_spawns_and_despawns(
                 entities.push(cap_entity);
 
                 // --- Grass pieces (multiple per tile with variety) ---
+                // kind: 0=tuft, 1=tall, 2=blade, 3=flower
                 if band == 0 {
-                    // Each slot uses different noise seeds for independent placement
-                    let grass_slots: [(i32, i32, f32, bool); 3] = [
-                        (7919, 3571, 0.45, false), // short tuft, ~45%
-                        (2131, 8461, 0.20, true),  // tall blade, ~20%
-                        (4253, 6173, 0.30, false), // short tuft, ~30%
+                    let grass_slots: [(i32, i32, f32, u8); 5] = [
+                        (7919, 3571, 0.40, 0), // short tuft ~40%
+                        (2131, 8461, 0.18, 1), // tall grass ~18%
+                        (4253, 6173, 0.25, 0), // short tuft ~25%
+                        (6091, 1429, 0.30, 2), // blade grass ~30%
+                        (9371, 2749, 0.08, 3), // flower ~8%
                     ];
 
-                    for (seed_x, seed_z, density, tall) in grass_slots {
+                    for (seed_x, seed_z, density, kind) in grass_slots {
                         let noise = hash2d(tx + seed_x, tz + seed_z);
                         if noise >= density {
                             continue;
                         }
 
-                        // Full-tile jitter with unique seeds per slot
                         let jx = (hash2d(tx + seed_x + 100, tz + seed_z) - 0.5) * 0.85;
                         let jz = (hash2d(tx + seed_x, tz + seed_z + 100) - 0.5) * 0.85;
 
-                        // Per-instance scale variation (0.7 to 1.4)
                         let scale_noise = hash2d(tx + seed_x + 200, tz + seed_z + 200);
                         let scale = 0.7 + scale_noise * 0.7;
 
@@ -346,16 +395,30 @@ fn process_chunk_spawns_and_despawns(
                         let rot_y =
                             hash2d(tx + seed_x + 300, tz + seed_z + 300) * std::f32::consts::TAU;
 
-                        let (mesh, mat) = if tall {
-                            (
+                        let (mesh, mat, y_offset) = match kind {
+                            1 => (
                                 tile_materials.grass_tall_mesh.clone(),
                                 tile_materials.grass_tall_mat.clone(),
-                            )
-                        } else {
-                            (
+                                0.0,
+                            ),
+                            2 => (
+                                tile_materials.grass_blade_mesh.clone(),
+                                tile_materials.grass_blade_mat.clone(),
+                                0.0,
+                            ),
+                            3 => {
+                                let flower_idx = (hash2d(tx + seed_x + 400, tz) * 4.0) as usize % 4;
+                                (
+                                    tile_materials.flower_mesh.clone(),
+                                    tile_materials.flower_mats[flower_idx].clone(),
+                                    0.15, // raised on a stem
+                                )
+                            }
+                            _ => (
                                 tile_materials.grass_tuft_mesh.clone(),
                                 tile_materials.grass_tuft_mat.clone(),
-                            )
+                                0.0,
+                            ),
                         };
 
                         let tuft = commands
@@ -364,7 +427,7 @@ fn process_chunk_spawns_and_despawns(
                                 MeshMaterial3d(mat),
                                 Transform::from_xyz(
                                     tx as f32 * TILE_SIZE + jx,
-                                    body_h + CAP_HEIGHT,
+                                    body_h + CAP_HEIGHT + y_offset,
                                     tz as f32 * TILE_SIZE + jz,
                                 )
                                 .with_rotation(Quat::from_rotation_y(rot_y))