Fix all remaining open issues (#100, #160–#167, #169)

scripts/smoke.mjs

@@ -353,7 +353,10 @@ assert(
 )
 await page.getByLabel('Add to favourites').click()
 await page.waitForTimeout(300)
-const stored = await page.evaluate(() => localStorage.getItem('playa-map.favorites.v1'))
+const stored = await page.evaluate(
+  (year) => localStorage.getItem(`playa-map.favorites.v1.${year}`),
+  DATA_YEAR,
+)
 assert(Boolean(stored) && stored !== '[]', `favourite persisted (${stored})`)
 
 // Walk and bike estimates should both be present in the drawer.

src/App.tsx

@@ -88,7 +88,7 @@ import {
   type DirectionsReadResult,
   type DirectionsMode,
 } from './data/directions'
-import { resolveDirectionsRoute } from './data/directionsRuntime'
+import { resolveDirectionsEndpoint, resolveDirectionsRoute } from './data/directionsRuntime'
 import { shareRouteCard } from './ui/routeCard'
 
 type Filter = PoiKind | 'toilets' | 'services' | 'favorites'
@@ -914,6 +914,15 @@ export default function App() {
   // a standalone answer to "where am I".
   const liveAddressLabel = usableFix && data ? reverseGeocode(usableFix, data.layout).label : undefined
 
+  const directionsDestinationResolved = useMemo(() => {
+    if (!data || !directionsTo) return false
+    return Boolean(resolveDirectionsEndpoint(directionsTo, {
+      layout: data.layout,
+      pois: data.pois,
+      livePosition: usableFix,
+    }))
+  }, [data, directionsTo, usableFix])
+
   const directionsPreview = useMemo(() => {
     if (!data || !directionsTo) return undefined
     const resolved = resolveDirectionsRoute(directionsFrom, directionsTo, {
@@ -1187,14 +1196,17 @@ export default function App() {
   ])
 
   const shareDirections = useCallback(async () => {
-    if (!directionsTo) return
+    if (!directionsTo || !directionsDestinationResolved) {
+      if (directionsTo) setProbe('This destination is no longer available to share')
+      return
+    }
     const result = await shareLink(
       directionsUrl({ version: 1, from: directionsFrom, to: directionsTo, mode: directionsMode }),
       'Dust Compass directions',
     )
     if (result === 'copied') setProbe('Route link copied')
     else if (result === 'unavailable') setProbe('Could not copy the route link')
-  }, [directionsFrom, directionsMode, directionsTo])
+  }, [directionsDestinationResolved, directionsFrom, directionsMode, directionsTo])
 
   const shareDirectionsImage = useCallback(async () => {
     if (!directionsPreview || !data) return
@@ -2328,6 +2340,7 @@ export default function App() {
           mode={directionsMode}
           hasUsableLiveFix={Boolean(usableFix)}
           findingLocation={location.status === 'locating'}
+          destinationResolved={directionsDestinationResolved}
           preview={directionsPreview ? {
             fromLabel: directionsPreview.resolved.from.label,
             toLabel: directionsPreview.resolved.to.label,

src/data/__tests__/navigationLifecycleRegressions.test.tsx

@@ -0,0 +1,95 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { useCompassHeading } from '../useCompassHeading'
+import { useWakeLock } from '../useWakeLock'
+
+function dispatchOrientation(alpha: number) {
+  window.dispatchEvent(Object.assign(new Event('deviceorientation'), { alpha, absolute: true }))
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((done) => { resolve = done })
+  return { promise, resolve }
+}
+
+describe('compass sample lifecycle (#165)', () => {
+  afterEach(() => vi.unstubAllGlobals())
+
+  it('keeps permission but hides the old sample until a fresh event arrives after restart', async () => {
+    class NoGateDeviceOrientationEvent {}
+    vi.stubGlobal('DeviceOrientationEvent', NoGateDeviceOrientationEvent)
+    const { result, rerender } = renderHook(({ active }) => useCompassHeading(active), {
+      initialProps: { active: true },
+    })
+
+    await act(async () => result.current.requestPermission())
+    act(() => dispatchOrientation(10))
+    expect(result.current.support).toBe('active')
+    expect(result.current.heading).toBe(350)
+
+    rerender({ active: false })
+    await act(async () => {})
+    expect(result.current.support).toBe('active')
+    expect(result.current.heading).toBeUndefined()
+    expect(result.current.accuracy).toBeUndefined()
+
+    // Device movement while inactive is not observed.
+    act(() => dispatchOrientation(180))
+    rerender({ active: true })
+    await act(async () => {})
+    expect(result.current.heading).toBeUndefined()
+
+    act(() => dispatchOrientation(90))
+    expect(result.current.heading).toBe(270)
+  })
+})
+
+describe('wake-lock acquisition ownership (#166)', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    // @ts-expect-error test-only API cleanup
+    delete navigator.wakeLock
+  })
+
+  it('does not start a second request while the first acquisition is pending', async () => {
+    const pending = deferred<WakeLockSentinel>()
+    const release = vi.fn(() => Promise.resolve())
+    const sentinel = { release, addEventListener: vi.fn() } as unknown as WakeLockSentinel
+    const request = vi.fn(() => pending.promise)
+    Object.defineProperty(navigator, 'wakeLock', { value: { request }, configurable: true })
+    Object.defineProperty(document, 'visibilityState', { value: 'visible', configurable: true })
+
+    const { rerender } = renderHook(({ active }) => useWakeLock(active), {
+      initialProps: { active: true },
+    })
+    expect(request).toHaveBeenCalledTimes(1)
+
+    act(() => document.dispatchEvent(new Event('visibilitychange')))
+    act(() => document.dispatchEvent(new Event('visibilitychange')))
+    expect(request).toHaveBeenCalledTimes(1)
+
+    await act(async () => pending.resolve(sentinel))
+    rerender({ active: false })
+    await act(async () => {})
+    expect(release).toHaveBeenCalledTimes(1)
+  })
+
+  it('releases a sentinel that resolves after navigation already stopped', async () => {
+    const pending = deferred<WakeLockSentinel>()
+    const release = vi.fn(() => Promise.resolve())
+    const sentinel = { release, addEventListener: vi.fn() } as unknown as WakeLockSentinel
+    const request = vi.fn(() => pending.promise)
+    Object.defineProperty(navigator, 'wakeLock', { value: { request }, configurable: true })
+
+    const { rerender } = renderHook(({ active }) => useWakeLock(active), {
+      initialProps: { active: true },
+    })
+    rerender({ active: false })
+    await act(async () => pending.resolve(sentinel))
+    expect(release).toHaveBeenCalledTimes(1)
+  })
+})

src/data/__tests__/persistenceInvariants.test.tsx

@@ -0,0 +1,121 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, renderHook } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MAX_SAVED_PLACE_NAME_LENGTH,
+  normalizeSavedPlaceName,
+  parsePlaces,
+  useSavedPlaces,
+  type SavedPlace,
+} from '../useSavedPlaces'
+import {
+  parseSavedEvents,
+  savedEventMatches,
+  useSavedEvents,
+} from '../useSavedEvents'
+import { parseFavorites } from '../useFavorites'
+import type { EventItem } from '../types'
+
+const makeEvent = (title: string, eventId = 42): EventItem => ({
+  uid: 'evt-boundary',
+  title,
+  event_id: eventId,
+  year: 2026,
+  occurrence_set: [{ start_time: '2026-08-30T12:00:00-07:00', end_time: '2026-08-30T13:00:00-07:00' }],
+})
+
+function findStorageKey(prefix: string): string {
+  const key = Array.from({ length: localStorage.length }, (_, index) => localStorage.key(index))
+    .find((candidate) => candidate?.startsWith(prefix))
+  if (!key) throw new Error(`missing storage key ${prefix}`)
+  return key
+}
+
+describe('saved-place write/read invariant (#161)', () => {
+  beforeEach(() => localStorage.clear())
+
+  it.each([199, 200, 201])('round-trips a %i-character requested name safely', (length) => {
+    const requested = 'x'.repeat(length)
+    const { result } = renderHook(() => useSavedPlaces())
+    let created: SavedPlace | undefined
+    act(() => {
+      created = result.current.save(requested, [-119.2, 40.78], '6:00 & A').place
+    })
+    if (!created) throw new Error('save did not create a place')
+    expect(created.name.length).toBe(Math.min(length, MAX_SAVED_PLACE_NAME_LENGTH))
+    expect(created.name).toBe(normalizeSavedPlaceName(requested))
+    expect(parsePlaces(localStorage.getItem(findStorageKey('playa-map.places.v1.')))).toContainEqual(created)
+  })
+})
+
+describe('saved-event write/read and identity invariants (#162/#164)', () => {
+  beforeEach(() => localStorage.clear())
+
+  it.each([299, 300, 301, 1000])('keeps a valid %i-character event title durable', (length) => {
+    const event = makeEvent('t'.repeat(length))
+    const { result } = renderHook(() => useSavedEvents())
+    act(() => {
+      expect(result.current.save(event)).toBe(true)
+    })
+    const saved = result.current.savedEvents[0]
+    if (!saved) throw new Error('event did not save')
+    expect(saved.title).toBe(event.title)
+    expect(saved.eventId).toBe(event.event_id)
+    expect(parseSavedEvents(localStorage.getItem(findStorageKey('playa-map.saved-events.v1.')))).toContainEqual(saved)
+  })
+
+  it('accepts a normal update to the same event identity and rejects uid reuse', () => {
+    const saved = { uid: 'evt-boundary', title: 'Original title', savedAt: 1, eventId: 42 }
+    expect(savedEventMatches(saved, makeEvent('Updated title', 42))).toBe(true)
+    expect(savedEventMatches(saved, makeEvent('Unrelated replacement', 99))).toBe(false)
+  })
+
+  it('keeps legacy bookmarks conservative when only uid and title are available', () => {
+    const legacy = { uid: 'evt-boundary', title: 'Original title', savedAt: 1 }
+    expect(savedEventMatches(legacy, makeEvent('Original title', 99))).toBe(true)
+    expect(savedEventMatches(legacy, makeEvent('Different title', 99))).toBe(false)
+  })
+})
+
+describe('favorites annual isolation and storage validation (#163)', () => {
+  beforeEach(() => {
+    localStorage.clear()
+    vi.resetModules()
+  })
+
+  it('accepts only non-empty string uids', () => {
+    expect(parseFavorites(JSON.stringify(['camp-1', '', '  ', 42, null, 'art-2']))).toEqual(
+      new Set(['camp-1', 'art-2']),
+    )
+  })
+
+  it('rejects malformed and non-array storage', () => {
+    expect(parseFavorites('not json')).toEqual(new Set())
+    expect(parseFavorites('{"uid":"camp-1"}')).toEqual(new Set())
+  })
+
+  it('does not apply a year-A favorite to year B even when the uid is reused, and restores it on return to year A', async () => {
+    vi.doMock('../../config', () => ({ DATA_YEAR: '2025' }))
+    const { useFavorites: useFavorites2025 } = await import('../useFavorites')
+    const first = renderHook(() => useFavorites2025())
+    act(() => first.result.current.toggle('same-uid'))
+    expect(first.result.current.isFavorite('same-uid')).toBe(true)
+    first.unmount()
+
+    vi.resetModules()
+    vi.doMock('../../config', () => ({ DATA_YEAR: '2026' }))
+    const { useFavorites: useFavorites2026 } = await import('../useFavorites')
+    const second = renderHook(() => useFavorites2026())
+    expect(second.result.current.isFavorite('same-uid')).toBe(false)
+    second.unmount()
+
+    vi.resetModules()
+    vi.doMock('../../config', () => ({ DATA_YEAR: '2025' }))
+    const { useFavorites: useFavorites2025Again } = await import('../useFavorites')
+    const returned = renderHook(() => useFavorites2025Again())
+    expect(returned.result.current.isFavorite('same-uid')).toBe(true)
+    returned.unmount()
+  })
+})