World-scale import and popularity skew
Native Parquet import of the REAL world dataset (not samples), the combined POI+geocode index it produces, and the popularity-skew feature built and iterated on top of it. Formula details: ranking.md. On-disk format: persistence.md.
Full world import (crates/farnsworth-importer)
Native Rust Parquet reader (the parquet crate directly) - replaces the duckdb-to-JSON export step used throughout the earlier spikes. No external duckdb dependency, reads real files directly.
Run against the REAL world dataset, not samples: all of pois.parquet plus all 24 address parquet files across all 11 countries.
| Count | Time | |
|---|---|---|
| POIs imported | 13,914,016 | 110.2s |
| POI index persisted | - | 55.5s |
| Locality records imported (4 files) | 8,822,831 | 103.3s |
| Localities index persisted | - | 159.2s |
| Street records imported (24 files) | 9,332,001 | 126.6s |
| Geocode index persisted | - | 163.4s |
Total run: 747s (~12.5 min) on the current farnsworth-cli build, real full 32M-record world dataset, peak build-time RSS 52.7GB (build cost, not steady-state - see text-engine.md's memory decomposition; build and serving are different budgets). Down from an original 998s (~16.6 min) - see import was effectively single-threaded below for what changed and why the POI/locality import numbers above look noisy rather than strictly improved.
World-coverage queries against the combined index - not a single-country sample:
- Cross-country geocode works automatically, no country parameter: "Route de Nantes" (FR), "Oxford Street" (UK), "Via Roma" (IT), "Calle Mayor" (ES) all correctly resolved from the SAME 9.3M-street index, purely via text matching.
- Reverse geocode gives genuinely correct real answers: near Paris -> "Place de l'Hôtel de Ville-esplanade de la Libération" 0.02km away (Paris City Hall Square). Near London -> "Charing Cross" 0.04km away.
- Plain POI text queries with no bias (cafe/school/hotel) returned Portuguese results - expected, not a bug: consistent with the ranking finding, raw text score has no geographic intelligence by itself.
This directly answers whether autocomplete/details/geocode/reverse-geocode work at real world scale: they do, against the real full dataset, not samples or assumptions.
farnsworth-cli build <export-dir> <index-dir> runs this import once and persists it (see persistence.md for the file layout); farnsworth-cli serve <index-dir> opens the persisted index in ~20s (not the ~9.5min rebuild) and answers real queries interactively in tens of ms.
Self-feedback loop: does the built index actually find real things (farnsworth-cli verify)
Every finding up to this point was proven with hand-picked queries ("paris", "stonehenge") - useful for demonstrating a specific bug or fix, but not a standing check that the index as a whole still works. farnsworth-cli verify <export-dir> <index-dir> [sample-size] closes that gap: it re-reads a real sample straight from the source parquet (the actual ground truth, not the index's own idea of itself) and confirms the already-built persisted index can still find each one, by its own exact name (search()) and by details() on its own public_id.
Sampling is cheap and real, not a guess - new import_pois_sample/import_localities_sample/import_addresses_sample functions cap the row iterator with .take(limit), so reading a 200-record sample from the 13.9M-row pois.parquet costs nothing like a full import; RowIter simply stops decoding once satisfied.
Prints per-kind recall (POI: search recall 198/200 (99.0%), details recall 200/200 (100.0%)) and up to 5 real miss examples (name + public_id) for debugging when recall isn't 100%. Catches a real class of regression a unit test can't: a schema change that silently drops a field, an index gone stale versus the export it was built from, a tokenizer edge case that only shows up on real names.
Popularity skew (crates/farnsworth-core/src/lib.rs)
Requirement: an input like "Par" should be able to surface "Paris, France" over other same-prefix results because Paris is selected far more often - independent of any location bias point (a plain autocomplete box has no bias point at all). Precise formula, worked examples, and how it compares to the real DistanceFeature/RankFeatureSaturation production math: ranking.md.
First attempt was wrong: folded popularity into the same formula as the geo distance skew, so it only ever applied alongside a bias point. Corrected by reading the real production code directly (localities/elasticsearch/builders/poi_query_builder.py, dsl.py) instead of guessing, then splitting the two into fully independent parameters of search(): distance_skew (needs a bias point to mean anything) and popularity_skew (works with none).
The popularity term matches OpenSearch's real RankFeatureSaturation clause exactly (saturation(value, pivot) = value / (value + pivot), boost = 1 / max(1, token_count), pivot defaulting to the corpus mean popularity - not a guessed constant). PoiRecord carries popularity: Option<f32>, sourced from the real popularity parquet column via the importer (a rank_feature-typed field on the production POI mapping - confirmed present on all 13.9M real POIs, mean 2.43, max 140).
4 tests prove the independence requirement and the real corpus-mean pivot - see ranking.md's worked examples for the exact numbers.
Second pass - ranking during collection, not after
First version kept per-record popularity in a HashMap<String, f32> and resorted the candidate pool search() already had after tantivy's own TopDocs::with_limit(overfetch) (limit * 10, floor 50). Real-world test at full scale exposed the gap: "buckingham" matches 150 real POIs; Buckingham Palace (popularity 140, corpus mean 2.43) never appeared even with popularity_skew = 1.0, because tantivy's own text-score tie-breaking never put it inside the first 50 candidates - popularity got no vote on which 50 those were.
Fixed by making popularity a tantivy FAST field (fields.popularity, f64, on the schema shared by PoiSearchIndex and GeocodeIndex - unused/defaults to 0.0 on the geocode side) and applying it inside the collector itself via TopDocs::tweak_score: the combined text+popularity score decides which candidates tantivy selects in the first place, not just their order afterward. search()'s own overfetch is now only there for the geo radius filter (still a post-hoc exclusion, since lat/lon aren't fast fields yet) - popularity no longer needs it. Missing popularity defaults to 0.0 in the fast field, matching production's own behavior when the rank_feature clause has nothing to score (no contribution, not an error or a default boost). See ranking.md's real-scale worked example for the Buckingham Palace numbers.
Explicitly deferred, same category of feature: capital_boost/type_boost/kind_weight-style scoring also present in real production ranking, and extending any of this to GeocodeIndex (addresses/streets currently have no popularity dimension). Also deferred: giving distance the same in-collector treatment (would need lat/lon as fast fields too) - not done since geo bias only needs to be good enough for recall in production too, per the ranking finding.
Merging POIs and localities into one ranked search (crates/farnsworth-core/src/merged.rs)
type_boost/kind_weight-style cross-kind ranking (see localities.md) only means anything when candidates of different kinds actually compete for the same result slots - before this, every search() call only ever saw one kind, so type_boost couldn't discriminate a POI from a locality at all.
Resolved the item's own open question first, not guessed: does tantivy support querying multiple Index instances as one collector? No - checked tantivy's own source directly, Searcher/IndexReader are always scoped to a single Index's own segments, no federated/multi-index query type exists. This isn't a Farnsworth-specific limitation to work around either: real production does the exact same thing architecturally - a client-side _msearch fan-out across separate per-kind ES indices, merged client-side, not one federated index. search_merged() does that: queries PoiSearchIndex and LocalitiesIndex independently, tags each hit with a kind_priority (POI gets 2.0, production's real kind_weight for POINT_OF_INTEREST from suggestion.py - the one kind weight reproducible exactly with no extra data; a locality gets its own real type_boost, 5-100), and merges by (text_score, kind_priority) lexicographically - text relevance decides first, kind only breaks a genuine tie, same pattern type_boost already proved inside LocalitiesIndex alone.
Real-data result (13.9M POIs + 8.8M localities, merged): "paris"/"bristol"/"georgia" all correctly surface the locality first when it's a genuine exact match (kind_priority 90-100 vs a POI's 2) - "georgia" returns the country "Georgia" (kind_priority=100) ahead of a POI also named "Georgia" (kind_priority=2).
Real limitation found, not silently accepted: text_score is not perfectly comparable across the two indices. "georgia" scored 83.79 as a locality but only 68.15 as a POI, despite both being genuine exact matches - real per-corpus BM25/IDF statistics differ between a 13.9M-doc and an 8.8M-doc index, leaking through underneath the exact-match boost that otherwise dominates. kind_priority's large real gap (100 vs 2) mostly compensates in practice, but a rigorous fix needs a shared, corpus-independent scoring basis across indices - not attempted here, documented as an open gap rather than assumed away.
3 tests: candidates merge from both indices; a genuine text-score tie is broken by the real kind_priority values; a more textually-relevant POI still beats a less-relevant locality with a much higher kind_priority (mirrors the exact-match-vs-prefix lesson, verified empirically against the actual scoring behavior rather than assumed - the first version of this test was wrong about what counts as an "exact match" and was corrected after running it).
Second pass - the "real limitation" above turned out to be worse than documented, found via real REST API testing. A plain sort-then-truncate by (text_score, kind_priority) didn't just make cross-index scores imperfectly comparable - it silently starved POI results outright whenever any locality candidate existed at all. kind_priority's real magnitude gap (locality up to 100 vs POI's flat 2) isn't a gentle tie-break at that spread, it's a near-total override: querying "stonehenge" against the real dataset returned a 30-result pool of US neighbourhoods and ZERO of the real Stonehenge POI, even though that POI genuinely matched (confirmed independently via /details) and would have outscored the localities on text relevance alone. "tour eiffel" biased to Paris showed the same shape - a pool of unrelated localities, no tower anywhere.
Fixed with reserved_slot_split(poi_available, locality_available, limit): each kind reserves at least half of limit (POI gets the extra slot on an odd limit, since it's queried first); a kind with fewer real candidates than its floor frees its unused slots for the other kind, up to what that kind actually has. Membership in the result set is now decided by this split, not the global sort - (text_score, kind_priority) only decides display order within the already-guaranteed-representative selection. Real result: "stonehenge" (no bias) now returns 22 POI + 8 locality out of 30, "tour eiffel" (biased to Paris) returns an even 15/15 split with real Eiffel-named POIs present.
Found and fixed a related, separate real bug in the same testing pass: a bias point (lat/lon) given to search() without an explicit radius_km silently excluded every single candidate - radius_km defaulted to 0.0, and d > 0.0 is true for any real distance. "boulangerie" near Montpellier returned zero hits with no error. Fixed: radius_km <= 0.0 now means "no hard cutoff" (a bias point alone is a valid, common request shape - rank by proximity context, don't require an exact radius), only radius_km > 0.0 triggers the exclusion. Same query now returns 30 real hits.
9 tests total for this pair of fixes (3 original + 6 new): reserved_slot_split's even-split and backfill behavior tested directly; a real-shape regression (1 POI vs 10 same-prefix localities) proving the POI survives being outnumbered; a radius-footgun regression proving radius_km=0.0 with a bias point returns real candidates, not zero.
Third pass - addresses merged in too. GeocodeIndex gained a real multi-hit search(query, limit), alongside the existing single-best-answer geocode() (still used by the dedicated /geocode endpoint). Both share a new resolve_location() helper (extracted from geocode()) so the number-parsing/interpolation logic isn't duplicated between the two. search_merged() now fans out to all three indices; the reserved-slot allocator (reserved_slot_split -> generalized to reserved_slots(available: &[usize], limit)) works for any number of kinds, not just two - each kind gets an even floor of limit, unused capacity backfills round-robin to whichever kinds still have real candidates.
Address kind_priority uses production's real kind_weight value for ADDRESS (1, from suggestion.py's match arms - same reasoning as POI's 2: the one value reproducible exactly with no extra per-record data). Real ordering on a three-way exact-match tie: LOCALITY (70+) > POI (2) > ADDRESS (1), tested directly.
Real-data result: "route de nantes" (no bias, limit=15) now returns an even 5 POI / 5 locality / 5 address split, with real resolved street coordinates on the address side (e.g. 47.277485, -1.776531 for the FR Route de Nantes) - previously address results didn't exist in /autocomplete at all, only reachable via the separate /geocode endpoint.
One real, quiet fix landed alongside this: resolve_location()'s fallback for a street with no location data at all now returns None, not the old silent (0.0, 0.0) (a real point off the coast of Africa) - geocode() still unwraps to that same (0.0, 0.0) at its own call site to avoid changing its existing return type, but the new StreetHit/search() path exposes the honest Option<LatLon>.
Real recall/ranking gaps found via live testing and the self-feedback tool
Four real, separate findings, each verified live against the full world-scale index (world-index-v3), not synthetic queries.
A popularity floor for bias-less POI search
farnsworth-cli verify's recall check flagged real POI misses ("Europcar", "Bar Granja") that turned out to be genuine but generic, low-popularity business names competing undisambiguated for a bare top-20/30 window - 1,248 real POIs are literally named "Europcar" worldwide. Confirmed via duckdb against the real corpus: p50=1, p90=5, p99=9, max=140. PoiSearchIndex::search() now requires popularity > 5 (the real p90 value) for a POI to be reachable at all when no bias point is given - ~1.08M POIs (7.8% of the corpus) stay globally reachable, generic chain storefronts don't. Implemented as a real recall-affecting RangeQuery on the popularity FAST field, Occur::Must, not a ranking-only tweak - the low-popularity ones are excluded from the pool entirely, not just ranked lower. Only applies when bias.is_none() - any bias point (even a loose one) already narrows by location, so a low-popularity POI within radius is still fully reachable.
Extended later to the biased case too, with a real, higher, separate threshold - see popular POIs bypass the radius cap below. > 5 (real p90) is NOT reused for that case: it's too permissive for real chain businesses (real Europcar branches go up to popularity 9), so reusing it there let ordinary branches worldwide bypass the radius cap - the exact noise problem this floor exists to prevent, through a different door. That case uses RADIUS_BYPASS_POPULARITY_FLOOR = 22 (real p99.99) instead - a deliberately much higher, independently-justified bar.
A radius cap, even when a bias point is given
Real follow-up: a bias point with an effectively worldwide radius_km defeats the floor above's purpose (the same low-popularity noise floods back in). MAX_BIAS_RADIUS_KM = 50.0 now applies whenever a bias point is given, regardless of what the caller asks for - independently confirmed as the right real number twice: production's own /nearby endpoint caps at 50000m, and Google Places' Nearby Search API's own documented radius max is also 50000m.
A real, deep architectural bug: geo filtering had the exact same over-fetch-pool flaw popularity did
Testing the floor+radius fix live surfaced a genuine regression risk: ?q=europcar&lat=42.5&lon=1.5&radius_km=20 (real bias near Andorra, a real nearby Europcar genuinely exists ~2km away) returned nothing. Root cause, confirmed via isolated reproduction: search()'s geo radius filter was only ever applied as a post-hoc exclusion AFTER TopDocs::with_limit picked its candidate pool by text score alone - the exact "Buckingham Palace" class of bug popularity's fix solved months ago in this session, just never extended to the geo axis. At world scale, a common query term (1,248 tied-score "Europcar" POIs) means the collector's arbitrary tie-order essentially never happens to include the one specific candidate actually near the bias point among the ~50 overfetched slots.
Fixed the same way popularity was: lat/lon became real FAST fields (previously only readable post-collection via the locations HashMap), and search() originally added a coarse bounding-box pre-filter (radius_km / 111.0 degree-radius, the same approximation already proven in farnsworth-geo-spike's own rstar prune step) as real Occur::Must RangeQuery clauses on lat/lon before collection - not just the existing post-collection exact-haversine exclusion, which still runs afterward for precision. A scaled reproduction test (2,000 tied-score decoys worldwide + 1 real nearby match) proved the fix; verified live against the real rebuilt POI index (?q=europcar&lat=42.5&lon=1.5&radius_km=20 now correctly returns the real Andorra Europcar, confirmed with text_score and location matching /details). That bounding box was later replaced with H3 disc bucketing - see the next section.
A real, purpose-built replacement for the lat/lon bounding box: H3 disc bucketing
The degree-radius bounding box above worked, but was a genuinely wrong shape: a degree of longitude shrinks toward the poles, so radius_km / 111.0 produces a box too wide near the equator and too narrow at high latitude, and even at the equator a circle inscribed in a square is only ~78% of it - ~22% of every scored candidate pool sat in the box's corners, geographically outside the real radius, wasted work the exact haversine post-filter then had to throw away.
This is exactly the kind of purpose-built structure a generic library can't give you for free: tantivy has no geo primitive at all. Fixed with H3 (h3o crate) instead: a new h3_cell field (u64, INDEXED, not FAST - it's an exact-match filter, not a range) stores each POI's H3 cell id at a fixed resolution (H3_RESOLUTION = 6, ~3.23km average hexagon edge - fine enough granularity for real bias radii up to MAX_BIAS_RADIUS_KM = 50.0 without either over- or under-indexing). At query time, h3_disk_terms(bias_lat, bias_lon, radius_km) computes a grid_disk ring of cells covering the requested radius (k = ceil(radius_km / H3_EDGE_KM) + 1, deliberately generous - over-inclusion near the ring's edge just costs candidate-pool size, the exact haversine post-filter still corrects it) and turns it into a TermSetQuery, replacing the two RangeQuery bbox clauses. H3 cells are roughly equal-area worldwide, so this is a real disc, correct at any latitude, not a lat/lon-skewed rectangle. Same full test suite (including the 2,000-decoy reproduction and the real Andorra Europcar case) passes unchanged; verified live against the rebuilt index (poi europcar near 42.5,1.5 20 correctly finds the real Andorra Europcar, 2.07km away).
Real process mistake caught along the way, twice: after implementing this fix, the first two "live verification" attempts used a stale farnsworth-server binary (rebuilt before the fix was fully written) - the exact same class of mistake documented earlier this session (fix-poi-starvation-and-radius-footgun...). Isolating the problem with a direct library call against the persisted index (bypassing the REST layer and any binary-staleness risk) proved the fix itself was correct before finding the real cause (a stale binary, confirmed via ls -la timestamps).
A real landmark should surface even with a far-away bias point, not just with none at all
Real client integration feedback, against the live server: q=tour+eiffel with no bias correctly returns the real Eiffel Tower first, but biased to Montpellier (a real client sends the map's current center on every keystroke) returned no Eiffel Tower at all - two POI-only address/locality noise instead. Root cause: the 50km MAX_BIAS_RADIUS_KM cap (above) applies unconditionally once a bias point is given, and Montpellier is genuinely ~750km from Paris - correct per the cap's own logic, but not what a real landmark search should do. The client's own proposed workaround was two parallel calls (biased + unbiased) merged client-side; fixed server-side instead, so one call does both jobs.
Fix: the H3 disc filter's Occur::Must clause became a real OR, via BooleanQuery::with_minimum_required_clauses(vec![(Should, nearby), (Should, popular_anywhere)], 1) - a POI now only needs to be EITHER within the H3 disc OR popular enough to ignore distance entirely, still gated by the actual text query matching (this doesn't flood a biased search with unrelated famous POIs, only ones that also match the query text). The post-collection exact-haversine exclusion got the same exemption, or the query would correctly admit a popular-but-far POI into the pool only for that later check to silently drop it right back out.
First attempt reused NO_BIAS_POPULARITY_FLOOR (> 5, real p90) for the bypass - live testing against the real server caught a real regression before it shipped: q=europcar&lat=42.5&lon=1.5&radius_km=20 (the exact "europcar near Andorra" case the H3 fix above solved) started returning Europcar branches 124km, 1010km, 1276km away again - real Europcar branches go up to popularity=9 (confirmed via duckdb: 41 of 1,251 real branches exceed 5), so the same floor that correctly lets the Eiffel Tower through also let ordinary chain branches worldwide bypass the radius, reproducing the exact noise problem the cap exists to prevent, through a different door.
Real fix: a separate, deliberately much higher floor for this specific case - RADIUS_BYPASS_POPULARITY_FLOOR = 22, the real p99.99 across the full corpus (measured via duckdb, not guessed): only 1,338 POIs worldwide (0.0096%) clear it, and spot-checking the actual names confirms it's genuinely landmark-tier, not just "moderately popular" - Stonehenge (119), Buckingham Palace (103), Westminster Abbey (94), Iguazú Falls (91), the real Eiffel Tower (72) comfortably inside it. Verified live against the real index: tour eiffel biased to Montpellier now returns the real Eiffel Tower (596km away) as the top result; europcar near 42.5,1.5 20 is back to only the genuinely nearby Andorra branch (2.07km). Two new tests added (popular_poi_bypasses_the_radius_cap_even_with_a_far_bias_point, unpopular_poi_stays_excluded_by_the_radius_cap_with_a_bias_point); three existing geo tests updated to use below-floor fixture popularity so they keep testing distance exclusion specifically, not accidentally testing the new bypass too. Full workspace test suite green.
A real ranking bug, root-caused and fixed: multi-token phrase matches didn't outrank shorter partial matches at world scale
Direct user testing (a live client, not a synthetic query) found "tour eiffel" never surfaced the real Eiffel Tower (verified via /details, popularity=72) in the visible results - crowded out by shorter matches ("Eiffel Flats", plain "Eiffel") scoring higher despite matching fewer query clauses. First attempt, PHRASE_MATCH_BOOST boosting the PhrasePrefixQuery clause itself, measurably did NOT move the real ranking - "Tour Eiffel"'s text_score was byte-identical (71.69220733642578) whether the boost was 5.0 or 500.0.
Root-caused via Weight::explain() dumped clause-by-clause against the real persisted index (a small debug binary opening world-index-v3/poi directly, reconstructing the exact query, and calling explain() on each sub-clause for the real Eiffel Tower doc). The cause is a genuine tantivy limitation (confirmed present at 0.24.2 and unchanged after bumping to 0.26.2, tantivy's latest release as of this writing - checked the PhraseKind::SinglePrefix::score() source directly at both versions), not a corpus-scale IDF artifact: PhraseKind::SinglePrefix::score() (phrase_prefix_scorer.rs:84-91, tantivy's own // TODO modify score??) hardcodes a flat 1.0/0.0 for any PhrasePrefixQuery with exactly one fixed term + one prefix term - i.e. every 2-token autocomplete query, "tour eiffel" included. The stored BM25 similarity_weight is boosted and threaded all the way down but never actually read by this scoring path. explain() only looked boost-aware because BoostWeight::explain recomputes underlying.explain().value() * boost independently of the real scorer, while the real Scorer::score() used during search/collection ignores the boost entirely - so raising the constant from 5 to 500 changed the explained value but not the real one.
Fix: don't rely on PhrasePrefixQuery's own (broken) score for ranking - keep it only for prefix/recall matching, and add a separate all-tokens-Must BooleanQuery of exact TermQuery clauses (PHRASE_MATCH_BOOST-boosted) for the real BM25 signal: every token has to match, same recall shape as the phrase clause, no adjacency requirement, but scored by real, working TermQuery BM25. Verified directly against the real index: "Tour Eiffel" (Paris) now ranks #1 for "tour eiffel", tied only with other genuinely-named "Tour Eiffel" POIs elsewhere in the world (which the existing popularity tie-break correctly resolves, popularity=72 vs tiny local businesses). Full workspace test suite green, no regressions.
Import was effectively single-threaded: parallelizing record parsing across files
Real, measured (not assumed): during a live full-world farnsworth-cli build, ps/top showed the process sitting at ~90% CPU (~1 core) the entire run, on an 18-core machine. tantivy's own IndexWriter already asks for multiple indexing threads (index.writer(200_000_000) sizes them off available_parallelism), but they were starving - the producer loop feeding them (index_records() in PoiSearchIndex/LocalitiesIndex/GeocodeIndex) parsed/normalized every record serially on one thread before calling add_document().
First attempt didn't help. Parallelized record→Document construction inside index_records() with rayon (par_iter building each Document independently, then a serial loop just for add_document/commit, since IndexWriter isn't Sync for concurrent calls) - CPU usage went up (252% average across the run) but total wall time barely moved (16:38 -> 15:11, ~9%), and some phases got outright worse (POI persist: 33s -> 54s). Reported honestly rather than claimed as a win - the real bottleneck wasn't where the fix assumed it was.
Profiled properly before trying again. crates/farnsworth-importer/src/lib.rs reads parquet via parquet::record::reader::RowIter - the dynamic row API, not the columnar Arrow batch API - and field() does a linear scan over every column per named field lookup, called multiple times per row. import_addresses/import_localities were each called once per parquet file, in a plain serial for loop over 24 country files (addresses) or 4 files (localities) in farnsworth-cli.rs's cmd_build - real, independent, file-level parallelism that was simply never used, no shared state between files at all.
Real fix: rayon::par_iter across files instead of across records within one file - address_files.par_iter().filter_map(|file| import_addresses(file).ok()).flatten().collect(), same shape for the 4 locality files. Real result, 18 real cores: address import 324.6s -> 126.6s (~2.6x, the biggest single win in this pass), locality import 126.4s -> 103.3s (only 4 files, smaller parallelism ceiling). POI import is a single file - this fix doesn't touch it (110.2s, noisy run-to-run, no parallelism opportunity without splitting the file's own row groups, not attempted). Total: 998s -> 747s (~25% faster than the original serial baseline). Full workspace test suite green; verified live end-to-end (real rebuild, europcar near 42.5,1.5 and tour eiffel both correct against the freshly-built index).