Visualize and restore LGND AOI searches on the map

app/actions.tsx

@@ -32,6 +32,7 @@ import RetrieveSection from '@/components/retrieve-section'
 import { VideoSearchSection } from '@/components/video-search-section'
 import { MapQueryHandler } from '@/components/map/map-query-handler'
 import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user'
+import { buildPersistedAnalysisContext } from '@/lib/utils/persisted-analysis-context'
 import { createClient } from '@/lib/supabase/client'
 import { db } from '@/lib/db'
 import { documents, documentChunks } from '@/lib/db/schema'
@@ -104,6 +105,8 @@ async function submit(formData?: FormData, skip?: boolean) {
       const mapboxBuffer = isFile(file_mapbox) ? await file_mapbox.arrayBuffer() : null;
       const mapboxDataUrl = mapboxBuffer ? `data:${(file_mapbox as File).type};base64,${Buffer.from(mapboxBuffer).toString('base64')}` : null;
 
+      const persistedSearchContext = buildPersistedAnalysisContext(aiState.get().messages)
+
       const googleBuffer = isFile(file_google) ? await file_google.arrayBuffer() : null;
       const googleDataUrl = googleBuffer ? `data:${(file_google as File).type};base64,${Buffer.from(googleBuffer).toString('base64')}` : null;
 
@@ -139,7 +142,13 @@ async function submit(formData?: FormData, skip?: boolean) {
 
       const processResolutionSearch = async () => {
         try {
-          const streamResult = await resolutionSearch(messages, timezone, drawnFeatures, location);
+          const streamResult = await resolutionSearch(
+            messages,
+            timezone,
+            drawnFeatures,
+            location,
+            persistedSearchContext
+          );
 
           let fullSummary = '';
           for await (const partialObject of streamResult.partialObjectStream) {
@@ -493,10 +502,9 @@ async function submit(formData?: FormData, skip?: boolean) {
 
   const currentSystemPrompt = await getSystemPrompt()
   const maxMessages = 10
-  // Only send conversational content to the researcher. Resolution result
-  // blobs, related-query payloads, and UI markers are presentation state, not
-  // model messages; including them makes OpenAI follow-ups intermittently
-  // fail or exceed the context budget.
+  const persistedSearchContext = buildPersistedAnalysisContext(aiState.get().messages)
+  // Keep bulky structured result blobs out of the conversational window; a
+  // compact cross-turn summary is supplied separately to the researcher.
   const messages = aiState.get().messages
     .filter(message => !['related', 'followup', 'end', 'resolution_search_result'].includes(message.type || ''))
     .map(message => ({
@@ -569,7 +577,8 @@ async function submit(formData?: FormData, skip?: boolean) {
         latestMessages,
         'mapbox', // default provider
         false,
-        drawnFeatures
+        drawnFeatures,
+        persistedSearchContext
       )
 
       if (!errorOccurred) {

components/chat.tsx

@@ -214,7 +214,7 @@ export function Chat({ id }: ChatProps) {
   // Mobile layout
   if (isMobile) {
     return (
-      <MapDataProvider> {/* Add Provider */}
+      <MapDataProvider key={id}> {/* Add Provider */}
         <HeaderSearchButton />
         {renderHeaderShare()}
         <div className="mobile-layout-container">
@@ -261,7 +261,7 @@ export function Chat({ id }: ChatProps) {
 
   // Desktop layout
   return (
-    <MapDataProvider> {/* Add Provider */}
+    <MapDataProvider key={id}> {/* Add Provider */}
       <HeaderSearchButton />
       {renderHeaderShare()}
       <div className="flex justify-start items-start">

components/location-embeddings-section.tsx

@@ -9,24 +9,30 @@ import rehypeExternalLinks from 'rehype-external-links'
 import remarkGfm from 'remark-gfm'
 import { StreamableValue, useStreamableValue } from 'ai/rsc'
 import { cn } from '@/lib/utils'
+import { useEffect } from 'react'
+import { useMapData } from '@/components/map/map-data-context'
+import { buildLocationEmbeddingsMapUpdate } from '@/lib/utils/location-embeddings-map'
 
 export type LocationEmbeddingsSectionProps = {
   result?: StreamableValue<string>
 }
 
 export function LocationEmbeddingsSection({ result }: LocationEmbeddingsSectionProps) {
   const [data, error, pending] = useStreamableValue(result)
+  const { setMapData } = useMapData()
 
   let latitude: number | undefined
   let longitude: number | undefined
   let images: string[] = []
   let rawResultText = ''
   let hasError = false
   let parsedResultsList: any[] = []
+  let parsedPayload: any
 
   if (data) {
     try {
       const parsedJson = JSON.parse(data)
+      parsedPayload = parsedJson
       latitude = parsedJson.latitude
       longitude = parsedJson.longitude
       if (Array.isArray(parsedJson.images)) {
@@ -79,6 +85,41 @@ export function LocationEmbeddingsSection({ result }: LocationEmbeddingsSectionP
     }
   }
 
+  useEffect(() => {
+    if (!data) return
+    try {
+      const update = buildLocationEmbeddingsMapUpdate(JSON.parse(data))
+      if (!update) return
+      setMapData(previous => {
+        const mergedMarkers = new Map((previous.markers || []).map(marker => [marker.id, marker]))
+        update.markers.forEach(marker => mergedMarkers.set(marker.id, marker))
+        const mergedFeatures = new Map((previous.geoJsonFeatures || []).map(feature => [feature.id, feature]))
+        update.features.forEach(feature => mergedFeatures.set(feature.id, feature))
+        return {
+          ...previous,
+          ...(update.targetPosition ? { targetPosition: update.targetPosition } : {}),
+          targetGeometry: update.targetGeometry || null,
+          markers: Array.from(mergedMarkers.values()),
+          geoJsonFeatures: Array.from(mergedFeatures.values())
+        }
+      })
+    } catch {
+      // Non-JSON stream updates are rendered as text but do not drive map state.
+    }
+  }, [data, setMapData])
+
+  const flyToResult = (chipId: string) => {
+    const update = buildLocationEmbeddingsMapUpdate(parsedPayload)
+    const marker = update?.markers.find(item => item.id === `lgnd:chip:${chipId}`)
+    if (!marker) return
+    const feature = update?.features.find(item => item.id === marker.id)
+    setMapData(previous => ({
+      ...previous,
+      targetPosition: { lat: marker.latitude, lng: marker.longitude },
+      targetGeometry: feature?.geometry || null
+    }))
+  }
+
   if (error) {
     return (
       <div>
@@ -117,6 +158,26 @@ export function LocationEmbeddingsSection({ result }: LocationEmbeddingsSectionP
           )}
 
           <Section title="Embeddings Results">
+            {parsedResultsList.length > 0 && (
+              <div className="mb-3 flex flex-wrap gap-2">
+                {parsedResultsList.slice(0, 3).map((item: any, idx: number) => {
+                  const chipId = String(item.chip_id || item.chipId || item.id || `result-${idx + 1}`)
+                  const hasLocation = buildLocationEmbeddingsMapUpdate(parsedPayload)?.markers.some(marker => marker.id === `lgnd:chip:${chipId}`)
+                  if (!hasLocation) return null
+                  return (
+                    <button
+                      key={chipId}
+                      type="button"
+                      onClick={() => flyToResult(chipId)}
+                      className="rounded-md border px-2 py-1 text-xs font-medium hover:bg-muted"
+                      aria-label={`Fly to LGND image ${chipId} on map`}
+                    >
+                      Fly to image {idx + 1}
+                    </button>
+                  )
+                })}
+              </div>
+            )}
             <div
               className={cn(
                 'overflow-x-auto',

components/map/google-map.tsx

@@ -52,6 +52,9 @@ export function GoogleMapComponent() {
   }, [mapData.drawnFeatures]);
 
   const cameraOptions = useMemo(() => {
+    if (mapData.targetPosition) {
+      return { center: mapData.targetPosition, range: 1000, tilt: 60, heading: 0 };
+    }
     if (mapData.cameraState) {
       const { center, zoom, pitch, bearing } = mapData.cameraState;
       // Convert Mapbox zoom to Google Maps range (approximate)
@@ -63,9 +66,6 @@ export function GoogleMapComponent() {
         heading: bearing || 0,
       };
     }
-    if (mapData.targetPosition) {
-      return { center: mapData.targetPosition, range: 1000, tilt: 60, heading: 0 };
-    }
     return { center: { lat: 37.7749, lng: -122.4194 }, range: 1000, tilt: 60, heading: 0 };
   }, [mapData.cameraState, mapData.targetPosition]);
 

components/map/map-3d-types.ts

@@ -8,6 +8,7 @@ declare global {
     // so we define it here.
     export interface Maps3DLibrary {
       Map3DElement: typeof Map3DElement;
+      Marker3DElement: typeof Marker3DElement;
     }
 
     export namespace maps3d {
@@ -28,6 +29,17 @@ declare global {
         roll: number;
         tilt: number;
       }
+
+      export class Marker3DElement extends HTMLElement {
+        constructor(options: {
+          position: { lat: number; lng: number; altitude?: number };
+          altitudeMode?: 'CLAMP_TO_GROUND' | 'RELATIVE_TO_GROUND' | 'ABSOLUTE';
+          label?: string;
+          extruded?: boolean;
+        });
+        position: { lat: number; lng: number; altitude?: number };
+        label: string;
+      }
     }
   }
 }

components/map/map-3d.tsx

@@ -4,6 +4,7 @@ import React, {
   forwardRef,
   useEffect,
   useImperativeHandle,
+  useRef,
   useState,
   type ForwardedRef
 } from 'react';
@@ -20,11 +21,38 @@ export const Map3D = forwardRef(
     props: Map3DProps,
     forwardedRef: ForwardedRef<google.maps.maps3d.Map3DElement | null>
   ) => {
-    useMapsLibrary('maps3d');
-    const { setMapData } = useMapData();
+    const maps3d = useMapsLibrary('maps3d');
+    const { mapData, setMapData } = useMapData();
 
     const [map3DElement, map3dRef] =
       useCallbackRef<google.maps.maps3d.Map3DElement>();
+    const markersRef = useRef<google.maps.maps3d.Marker3DElement[]>([]);
+
+    useEffect(() => {
+      if (!map3DElement || !maps3d) return;
+      markersRef.current.forEach(marker => marker.remove());
+      markersRef.current = [];
+      for (const markerData of mapData.markers || []) {
+        if (!Number.isFinite(markerData.latitude) || !Number.isFinite(markerData.longitude)) continue;
+        const marker = new maps3d.Marker3DElement({
+          position: { lat: markerData.latitude, lng: markerData.longitude, altitude: 0 },
+          altitudeMode: 'CLAMP_TO_GROUND',
+          label: markerData.title || 'LGND location'
+        });
+        marker.setAttribute('title', [markerData.title, markerData.details].filter(Boolean).join(' · '));
+        marker.addEventListener('gmp-click', () => setMapData(previous => ({
+          ...previous,
+          targetPosition: { lat: markerData.latitude, lng: markerData.longitude },
+          targetGeometry: markerData.geometry || null
+        })));
+        map3DElement.append(marker);
+        markersRef.current.push(marker);
+      }
+      return () => {
+        markersRef.current.forEach(marker => marker.remove());
+        markersRef.current = [];
+      };
+    }, [map3DElement, maps3d, mapData.markers, setMapData]);
 
     useMap3DCameraEvents(map3DElement, p => {
       const { center, range, heading, tilt } = p.detail;

components/map/map-data-context.tsx

@@ -12,8 +12,19 @@ export interface CameraState {
   heading?: number;
 }
 
+export interface MapMarker {
+  id: string;
+  latitude: number;
+  longitude: number;
+  title?: string;
+  details?: string;
+  source?: string;
+  geometry?: GeoJSON.Geometry;
+}
+
 export interface MapData {
   targetPosition?: { lat: number; lng: number } | null; // For flying to a location
+  targetGeometry?: GeoJSON.Geometry | null; // Area to fit and visualize on the map
   cameraState?: CameraState; // For saving camera state
   currentTimezone?: string; // Current timezone identifier
   // TODO: Add other relevant map data types later (e.g., routeGeoJSON, poiList)
@@ -24,10 +35,12 @@ export interface MapData {
     measurement: string;
     geometry: any;
   }>;
-  markers?: Array<{
-    latitude: number;
-    longitude: number;
+  markers?: MapMarker[];
+  geoJsonFeatures?: Array<{
+    id: string;
+    geometry: GeoJSON.Geometry;
     title?: string;
+    source?: string;
   }>;
 }
 
@@ -39,7 +52,7 @@ interface MapDataContextType {
 const MapDataContext = createContext<MapDataContextType | undefined>(undefined);
 
 export const MapDataProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
-  const [mapData, setMapData] = useState<MapData>({ drawnFeatures: [], markers: [] });
+  const [mapData, setMapData] = useState<MapData>({ drawnFeatures: [], markers: [], geoJsonFeatures: [] });
 
   return (
     <MapDataContext.Provider value={{ mapData, setMapData }}>