diff --git a/src/app/actualites/page.tsx b/src/app/actualites/page.tsx
index 261e7d6..f2439fc 100644
--- a/src/app/actualites/page.tsx
+++ b/src/app/actualites/page.tsx
@@ -15,7 +15,8 @@ const CATEGORY_COLORS: Record<string, string> = {
   Sciences: '#38bdf8',
 }
 
-function formatDate(date: string) {
+function formatDate(date: string | null) {
+  if (!date) return 'Date inconnue'
   return new Date(date).toLocaleDateString('fr-FR', {
     day: 'numeric',
     month: 'short',
@@ -174,7 +175,7 @@ export default function ActualitesPage() {
                   <span style={{ color, background: `${color}12`, border: `1px solid ${color}30`, borderRadius: 999, padding: '0.2rem 0.65rem', fontSize: '0.64rem', fontWeight: 800 }}>
                     {article.category}
                   </span>
-                  <time dateTime={article.date} style={{ color: 'var(--text-muted)', fontSize: '0.65rem' }}>{formatDate(article.date)}</time>
+                  <time dateTime={article.date ?? undefined} style={{ color: 'var(--text-muted)', fontSize: '0.65rem' }}>{formatDate(article.date)}</time>
                 </div>
                 <h2 style={{ margin: '1rem 0 0.6rem', color: 'var(--text)', font: "750 1rem/1.45 'Outfit', sans-serif" }}>{article.title}</h2>
                 <p style={{ color: 'var(--text-muted)', fontSize: '0.77rem', lineHeight: 1.65, display: '-webkit-box', WebkitLineClamp: 3, WebkitBoxOrient: 'vertical', overflow: 'hidden' }}>
diff --git a/src/app/api/geocode/route.ts b/src/app/api/geocode/route.ts
index e53f6e8..67f4e2d 100644
--- a/src/app/api/geocode/route.ts
+++ b/src/app/api/geocode/route.ts
@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server'
+import { checkDistributedRateLimit } from '@/lib/security/rate-limit'
 
 const FALLBACK_CITY = 'Votre position'
 
@@ -8,6 +9,21 @@ function parseCoordinate(value: string | null, min: number, max: number) {
   return Number(parsed.toFixed(2))
 }
 
+function firstHeaderValue(request: NextRequest, names: string[]): string | null {
+  for (const name of names) {
+    const value = request.headers.get(name)?.split(',')[0]?.trim()
+    if (value) return value
+  }
+  return null
+}
+
+function clientIdentifier(request: NextRequest): string | null {
+  const headerNames = process.env.VERCEL === '1'
+    ? ['x-vercel-forwarded-for', 'x-forwarded-for', 'x-real-ip']
+    : ['x-forwarded-for', 'x-real-ip']
+  return firstHeaderValue(request, headerNames)
+}
+
 export async function GET(request: NextRequest) {
   const latitude = parseCoordinate(request.nextUrl.searchParams.get('lat'), -90, 90)
   const longitude = parseCoordinate(request.nextUrl.searchParams.get('lon'), -180, 180)
@@ -16,6 +32,38 @@ export async function GET(request: NextRequest) {
     return NextResponse.json({ error: 'Coordonnées invalides.' }, { status: 400 })
   }
 
+  const identifier = clientIdentifier(request)
+  if (process.env.VERCEL === '1' && !identifier) {
+    return NextResponse.json(
+      { error: 'Service de localisation temporairement protégé.' },
+      { status: 503, headers: { 'Cache-Control': 'no-store' } },
+    )
+  }
+
+  const rateLimit = await checkDistributedRateLimit(`geocode:${identifier || 'local-anonymous'}`, {
+    namespace: 'geocode',
+    limit: 20,
+    windowSeconds: 60,
+  })
+  if (rateLimit.unavailable) {
+    return NextResponse.json(
+      { error: 'Service de localisation temporairement protégé.' },
+      { status: 503, headers: { 'Cache-Control': 'no-store' } },
+    )
+  }
+  if (!rateLimit.allowed) {
+    return NextResponse.json(
+      { error: 'Trop de demandes de localisation. Réessaie dans un instant.' },
+      {
+        status: 429,
+        headers: {
+          'Cache-Control': 'no-store',
+          'Retry-After': String(rateLimit.retryAfter),
+        },
+      },
+    )
+  }
+
   const url = new URL('https://nominatim.openstreetmap.org/reverse')
   url.search = new URLSearchParams({
     lat: String(latitude),
diff --git a/src/app/confidentialite/page.tsx b/src/app/confidentialite/page.tsx
index e31d59f..7bc589b 100644
--- a/src/app/confidentialite/page.tsx
+++ b/src/app/confidentialite/page.tsx
@@ -36,9 +36,15 @@ export default function PrivacyPage() {
 
         <h2>Stockage local et intelligence artificielle</h2>
         <p>
-          Le thème clair ou sombre est mémorisé uniquement dans votre navigateur. Les questions adressées à
-          SolarBot sont envoyées au service Gemini de Google pour produire une réponse, sans être conservées
-          dans une base de données SolarScope.
+          SolarScope ne crée pas de compte. Le navigateur peut conserver la langue choisie, le public ou niveau
+          sélectionné, la progression du passeport, l’étape ouverte dans une fiche pédagogique et un cache local
+          temporaire de météo spatiale. Ces informations restent sur l’appareil et ne sont pas envoyées à SolarScope.
+        </p>
+        <p>
+          Le passeport peut être effacé depuis la page « Passeport spatial ». Les autres préférences et le cache
+          peuvent être supprimés depuis les réglages de stockage du navigateur ; le cache météo expire également
+          automatiquement. Les questions adressées à SolarBot sont envoyées au service Gemini de Google lorsque
+          Gemini est activé, sans être conservées dans une base de données SolarScope.
         </p>
 
         <p><Link href="/">← Retour à l’accueil</Link></p>
diff --git a/src/components/layout/Navbar.tsx b/src/components/layout/Navbar.tsx
index 704f7cb..feb36b2 100644
--- a/src/components/layout/Navbar.tsx
+++ b/src/components/layout/Navbar.tsx
@@ -382,10 +382,14 @@ export default function Navbar() {
                             {navGroups.map(group => {
                                 const isGroupOpen = mobileGroup === group.id
                                 const isActive = activeGroup === group.id
+                                const mobileGroupPanelId = `mobile-navigation-group-${group.id}`
                                 return (
                                     <div key={group.id} style={{ marginBottom: '0.375rem' }}>
                                         <button
+                                            type="button"
                                             onClick={() => setMobileGroup(isGroupOpen ? null : group.id)}
+                                            aria-expanded={isGroupOpen}
+                                            aria-controls={mobileGroupPanelId}
                                             style={{
                                                 width: '100%', display: 'flex', alignItems: 'center', justifyContent: 'space-between',
                                                 padding: '0.7rem 0.875rem', borderRadius: '10px', cursor: 'pointer',
@@ -402,6 +406,7 @@ export default function Navbar() {
                                             {isGroupOpen && (
                                                 <motion.div initial={{ height: 0, opacity: 0 }} animate={{ height: 'auto', opacity: 1 }}
                                                     exit={{ height: 0, opacity: 0 }} transition={{ duration: 0.2 }}
+                                                    id={mobileGroupPanelId}
                                                     style={{ overflow: 'hidden', paddingLeft: '0.5rem', marginTop: '0.25rem' }}>
                                                     {group.pages.map(page => {
                                                         const active = pathname === page.href
diff --git a/src/components/space/ISSGlobe.tsx b/src/components/space/ISSGlobe.tsx
index f0a34fa..9641269 100644
--- a/src/components/space/ISSGlobe.tsx
+++ b/src/components/space/ISSGlobe.tsx
@@ -30,7 +30,6 @@ export default function ISSGlobe({ issPos }: { issPos: ISSPos | null }) {
         issMarker: THREE.Group
         trail: THREE.Line
         trailPositions: THREE.Vector3[]
-        animId: number
         isDragging: boolean
         previousMousePosition: { x: number; y: number }
     } | null>(null)
@@ -57,7 +56,8 @@ export default function ISSGlobe({ issPos }: { issPos: ISSPos | null }) {
         const starPositions = new Float32Array(starCount * 3)
         for (let i = 0; i < starCount * 3; i++) starPositions[i] = (Math.random() - 0.5) * 400
         starGeo.setAttribute('position', new THREE.BufferAttribute(starPositions, 3))
-        scene.add(new THREE.Points(starGeo, new THREE.PointsMaterial({ color: '#ffffff', size: 0.3, transparent: true, opacity: 0.7 })))
+        const starMaterial = new THREE.PointsMaterial({ color: '#ffffff', size: 0.3, transparent: true, opacity: 0.7 })
+        scene.add(new THREE.Points(starGeo, starMaterial))
 
         // Lights
         scene.add(new THREE.AmbientLight(0x222233, 0.8))
@@ -71,9 +71,10 @@ export default function ISSGlobe({ issPos }: { issPos: ISSPos | null }) {
 
         // Earth
         const loader = new THREE.TextureLoader()
+        const earthTexture = loader.load('/textures/earth.jpg')
         const earthGeo = new THREE.SphereGeometry(1, 64, 64)
         const earthMat = new THREE.MeshPhongMaterial({
-            map: loader.load('/textures/earth.jpg'),
+            map: earthTexture,
             specular: new THREE.Color(0x226699),
             shininess: 18,
         })
@@ -116,9 +117,14 @@ export default function ISSGlobe({ issPos }: { issPos: ISSPos | null }) {
         let isDragging = false
         let previousMousePosition = { x: 0, y: 0 }
         let autoRotate = true
+        let resumeTimeout: ReturnType<typeof setTimeout> | null = null
 
         const onMouseDown = (e: MouseEvent) => { isDragging = true; autoRotate = false; previousMousePosition = { x: e.clientX, y: e.clientY } }
-        const onMouseUp = () => { isDragging = false; setTimeout(() => { autoRotate = true }, 3000) }
+        const onMouseUp = () => {
+            isDragging = false
+            if (resumeTimeout) clearTimeout(resumeTimeout)
+            resumeTimeout = setTimeout(() => { autoRotate = true }, 3000)
+        }
         const onMouseMove = (e: MouseEvent) => {
             if (!isDragging) return
             const dx = e.clientX - previousMousePosition.x
@@ -133,7 +139,10 @@ export default function ISSGlobe({ issPos }: { issPos: ISSPos | null }) {
         window.addEventListener('mousemove', onMouseMove)
 
         let t = 0
-        const animId = requestAnimationFrame(function loop() {
+        let frameId: number | null = null
+        let disposed = false
+        const loop = () => {
+            if (disposed) return
             t += 0.005
             if (autoRotate) earthGroup.rotation.y += 0.0015
             // Ring pulse
@@ -141,18 +150,37 @@ export default function ISSGlobe({ issPos }: { issPos: ISSPos | null }) {
             ring.scale.setScalar(scale)
             ring.material.opacity = 0.7 - 0.4 * Math.abs(Math.sin(t * 3))
             renderer.render(scene, camera)
-            requestAnimationFrame(loop)
-        })
+            frameId = requestAnimationFrame(loop)
+        }
+        frameId = requestAnimationFrame(loop)
 
-        sceneRef.current = { renderer, scene, camera, issMarker, trail, trailPositions, animId, isDragging, previousMousePosition }
+        sceneRef.current = { renderer, scene, camera, issMarker, trail, trailPositions, isDragging, previousMousePosition }
 
         return () => {
-            cancelAnimationFrame(animId)
+            disposed = true
+            if (frameId !== null) cancelAnimationFrame(frameId)
+            if (resumeTimeout) clearTimeout(resumeTimeout)
             renderer.domElement.removeEventListener('mousedown', onMouseDown)
             window.removeEventListener('mouseup', onMouseUp)
             window.removeEventListener('mousemove', onMouseMove)
+            earthTexture.dispose()
+            starGeo.dispose()
+            starMaterial.dispose()
+            earthGeo.dispose()
+            earthMat.dispose()
+            atmGeo.dispose()
+            atmMat.dispose()
+            gridGeo.dispose()
+            gridMat.dispose()
+            issDot.geometry.dispose()
+            issDot.material.dispose()
+            ringGeo.dispose()
+            ringMat.dispose()
+            trail.geometry.dispose()
+            trailMat.dispose()
             renderer.dispose()
             if (el.contains(renderer.domElement)) el.removeChild(renderer.domElement)
+            sceneRef.current = null
         }
     }, [])
 
diff --git a/src/lib/data/space-data.ts b/src/lib/data/space-data.ts
index d43e293..077f7df 100644
--- a/src/lib/data/space-data.ts
+++ b/src/lib/data/space-data.ts
@@ -91,7 +91,7 @@ export interface NewsArticle {
   title: string
   source: string
   url: string
-  date: string
+  date: string | null
   summary: string
   category: string
 }
@@ -507,38 +507,40 @@ function classifyArticle(text: string): string {
   return 'Sciences'
 }
 
-export async function getNasaNews(): Promise<{ articles: NewsArticle[]; updatedAt: string }> {
-  const response = await fetchWithTimeout(
-    'https://www.nasa.gov/feed/',
-    1_800,
-    'space-news',
-    'application/rss+xml, application/xml, text/xml',
-  )
-  const xml = await response.text()
+export function parseNasaNewsFeed(xml: string): NewsArticle[] {
   const items = xml.match(/<item>[\s\S]*?<\/item>/gi) || []
 
-  const articles = items
+  return items
     .map((item): NewsArticle | null => {
       const title = xmlTag(item, 'title')
       const url = xmlTag(item, 'link')
       const summary = xmlTag(item, 'description')
       const published = xmlTag(item, 'pubDate')
       if (!title || !url) return null
-      const parsedDate = published ? new Date(published) : new Date()
 
+      const parsedDate = published ? new Date(published) : null
       return {
         title,
         source: 'NASA',
         url,
-        date: Number.isNaN(parsedDate.getTime()) ? new Date().toISOString() : parsedDate.toISOString(),
+        date: parsedDate && !Number.isNaN(parsedDate.getTime()) ? parsedDate.toISOString() : null,
         summary: summary || 'Consultez l’article complet sur le site officiel de la NASA.',
         category: classifyArticle(`${title} ${summary}`),
       }
     })
     .filter((article): article is NewsArticle => article !== null)
     .slice(0, 18)
+}
 
-  return { articles, updatedAt: new Date().toISOString() }
+export async function getNasaNews(): Promise<{ articles: NewsArticle[]; updatedAt: string }> {
+  const response = await fetchWithTimeout(
+    'https://www.nasa.gov/feed/',
+    1_800,
+    'space-news',
+    'application/rss+xml, application/xml, text/xml',
+  )
+  const xml = await response.text()
+  return { articles: parseNasaNewsFeed(xml), updatedAt: new Date().toISOString() }
 }
 
 export function getNasaApiKey(): string {
diff --git a/tests/e2e/device-compatibility.spec.ts b/tests/e2e/device-compatibility.spec.ts
index da98b87..46d2e5a 100644
--- a/tests/e2e/device-compatibility.spec.ts
+++ b/tests/e2e/device-compatibility.spec.ts
@@ -57,9 +57,17 @@ test('the mobile menu remains usable', async ({ page }, testInfo) => {
   const viewport = page.viewportSize()
   test.skip(testInfo.project.name === 'desktop' || !viewport || viewport.width >= 768, 'This viewport uses the expanded navigation')
   await page.goto('/')
-  await page.getByRole('button', { name: 'Ouvrir le menu' }).click()
+  const menuButton = page.getByRole('button', { name: 'Ouvrir le menu' })
+  await menuButton.click()
   await expect(page.locator('#mobile-navigation')).toBeVisible()
   await expect(page.locator('#mobile-navigation').getByRole('link', { name: /Accueil/ })).toBeVisible()
+
+  const solarSystemButton = page.getByRole('button', { name: /Système Solaire/ })
+  await expect(solarSystemButton).toHaveAttribute('aria-expanded', 'false')
+  await expect(solarSystemButton).toHaveAttribute('aria-controls', 'mobile-navigation-group-systeme')
+  await solarSystemButton.click()
+  await expect(solarSystemButton).toHaveAttribute('aria-expanded', 'true')
+  await expect(page.locator('#mobile-navigation-group-systeme')).toBeVisible()
 })
 
 test('the rover remains interactive in Safari-compatible WebKit', async ({ page }, testInfo) => {
diff --git a/tests/unit/geocode-route.test.ts b/tests/unit/geocode-route.test.ts
new file mode 100644
index 0000000..96e29f5
--- /dev/null
+++ b/tests/unit/geocode-route.test.ts
@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { NextRequest } from 'next/server'
+import { checkDistributedRateLimit } from '@/lib/security/rate-limit'
+import { GET } from '../../src/app/api/geocode/route'
+
+vi.mock('@/lib/security/rate-limit', () => ({
+  checkDistributedRateLimit: vi.fn(),
+}))
+
+const mockedRateLimit = vi.mocked(checkDistributedRateLimit)
+
+function request(headers?: HeadersInit) {
+  return new NextRequest('https://example.test/api/geocode?lat=48.86&lon=2.35', { headers })
+}
+
+describe('geocode route rate limiting', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    delete process.env.VERCEL
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ address: { city: 'Paris' } }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    })))
+  })
+
+  it('fails closed when the distributed limiter is unavailable', async () => {
+    mockedRateLimit.mockResolvedValue({ allowed: false, remaining: 0, retryAfter: 60, provider: 'upstash', unavailable: true })
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(503)
+    expect(fetch).not.toHaveBeenCalled()
+  })
+
+  it('prioritizes the Vercel client header over other forwarding headers', async () => {
+    process.env.VERCEL = '1'
+    mockedRateLimit.mockResolvedValue({ allowed: true, remaining: 19, retryAfter: 0, provider: 'upstash', unavailable: false })
+
+    const response = await GET(request({
+      'x-vercel-forwarded-for': '203.0.113.10',
+      'x-forwarded-for': '198.51.100.20',
+      'x-real-ip': '192.0.2.30',
+    }))
+
+    expect(response.status).toBe(200)
+    expect(mockedRateLimit).toHaveBeenCalledWith('geocode:203.0.113.10', {
+      namespace: 'geocode',
+      limit: 20,
+      windowSeconds: 60,
+    })
+  })
+
+  it('normalizes a forwarded IP list to its first entry', async () => {
+    process.env.VERCEL = '1'
+    mockedRateLimit.mockResolvedValue({ allowed: true, remaining: 19, retryAfter: 0, provider: 'upstash', unavailable: false })
+
+    await GET(request({ 'x-vercel-forwarded-for': ' 203.0.113.11, 198.51.100.21 ' }))
+
+    expect(mockedRateLimit).toHaveBeenCalledWith('geocode:203.0.113.11', expect.any(Object))
+  })
+
+  it('uses x-forwarded-for on Vercel when the Vercel-specific header is absent', async () => {
+    process.env.VERCEL = '1'
+    mockedRateLimit.mockResolvedValue({ allowed: true, remaining: 19, retryAfter: 0, provider: 'upstash', unavailable: false })
+
+    await GET(request({ 'x-forwarded-for': '203.0.113.12, 198.51.100.22' }))
+
+    expect(mockedRateLimit).toHaveBeenCalledWith('geocode:203.0.113.12', expect.any(Object))
+  })
+
+  it('fails closed on Vercel when no network identifier is available', async () => {
+    process.env.VERCEL = '1'
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(503)
+    expect(mockedRateLimit).not.toHaveBeenCalled()
+    expect(fetch).not.toHaveBeenCalled()
+  })
+
+  it('uses the explicit local fallback outside Vercel', async () => {
+    mockedRateLimit.mockResolvedValue({ allowed: true, remaining: 19, retryAfter: 0, provider: 'local', unavailable: false })
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(200)
+    expect(mockedRateLimit).toHaveBeenCalledWith('geocode:local-anonymous', {
+      namespace: 'geocode',
+      limit: 20,
+      windowSeconds: 60,
+    })
+  })
+
+  it('returns 429 when the geocode quota is exhausted', async () => {
+    mockedRateLimit.mockResolvedValue({ allowed: false, remaining: 0, retryAfter: 17, provider: 'upstash', unavailable: false })
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(429)
+    expect(response.headers.get('retry-after')).toBe('17')
+    expect(fetch).not.toHaveBeenCalled()
+  })
+
+  it('keeps valid requests working under the configured quota', async () => {
+    mockedRateLimit.mockResolvedValue({ allowed: true, remaining: 19, retryAfter: 0, provider: 'local', unavailable: false })
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toMatchObject({ city: 'Paris', latitude: 48.86, longitude: 2.35 })
+    expect(mockedRateLimit).toHaveBeenCalledWith(expect.any(String), {
+      namespace: 'geocode',
+      limit: 20,
+      windowSeconds: 60,
+    })
+  })
+})
\ No newline at end of file
diff --git a/tests/unit/space-data.test.ts b/tests/unit/space-data.test.ts
index 74dd0f0..39165c7 100644
--- a/tests/unit/space-data.test.ts
+++ b/tests/unit/space-data.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import {
   parseCrew,
   parseLaunches,
+  parseNasaNewsFeed,
   parseSolarWindPayload,
   parseXrayPayload,
   stationForCraft,
@@ -78,4 +79,15 @@ describe('space data normalization', () => {
     expect(parsed.history).toEqual([2e-7, 3e-7])
     expect(parsed.observedAt).toBe('2026-07-22T19:01:00Z')
   })
+
+  it('does not invent a publication date when NASA RSS omits or corrupts it', () => {
+    const articles = parseNasaNewsFeed(`
+      <rss><channel>
+        <item><title>No date</title><link>https://www.nasa.gov/no-date</link><description>Summary</description></item>
+        <item><title>Bad date</title><link>https://www.nasa.gov/bad-date</link><description>Summary</description><pubDate>not-a-date</pubDate></item>
+      </channel></rss>
+    `)
+
+    expect(articles.map(article => article.date)).toEqual([null, null])
+  })
 })