@geolibre/core 3.4.0 → 3.5.0

package/dist/{project-diff-Bua7fBME.mjs → project-diff-CPb5ZXb_.mjs}

@@ -273,15 +273,18 @@ function styleValue(style, key) {
 */
 const LARGE_VECTOR_FEATURE_THRESHOLD = 5e4;
 /**
-* Decide whether a GeoJSON layer should use the tiled rendering path.
+* Decide whether a vector layer should use the tiled rendering path.
 *
-* @param geojson - The layer's feature collection (may be undefined for
+* @param data - The layer's feature collection or GeoArrow batch (may be undefined for
 *   non-vector layers).
-* @returns `true` when the collection exceeds
-*   {@link LARGE_VECTOR_FEATURE_THRESHOLD} features.
+* @returns `true` when the feature count exceeds
+*   {@link LARGE_VECTOR_FEATURE_THRESHOLD}.
 */
-function shouldUseTiledRendering(geojson) {
-	return (geojson?.features.length ?? 0) > LARGE_VECTOR_FEATURE_THRESHOLD;
+function shouldUseTiledRendering(data) {
+	if (!data) return false;
+	if ("featureCount" in data && typeof data.featureCount === "number") return data.featureCount > LARGE_VECTOR_FEATURE_THRESHOLD;
+	if ("features" in data && Array.isArray(data.features)) return data.features.length > LARGE_VECTOR_FEATURE_THRESHOLD;
+	return false;
 }
 /**
 * Metadata `sourceKind` marking a live SQL query layer: a GeoJSON-backed layer
@@ -1360,7 +1363,7 @@ function basemapToCesiumImagery(styleUrl, cesiumBasemap = "project") {
 //#endregion
 //#region src/arcgis-projection.ts
 /** WKIDs that are Web Mercator, i.e. the default map. */
-const WEB_MERCATOR_WKIDS = /* @__PURE__ */ new Set([
+const WEB_MERCATOR_WKIDS$1 = /* @__PURE__ */ new Set([
 	3857,
 	102100,
 	102113,
@@ -1422,9 +1425,394 @@ const ARCGIS_PROJECTION_PRESETS = [
 function normalizeArcgisWkid(value) {
 	const wkid = typeof value === "string" ? /^\s*\d+\s*$/.test(value) ? Number(value) : void 0 : value;
 	if (typeof wkid !== "number" || !Number.isSafeInteger(wkid) || wkid <= 0) return void 0;
-	return WEB_MERCATOR_WKIDS.has(wkid) ? void 0 : wkid;
+	return WEB_MERCATOR_WKIDS$1.has(wkid) ? void 0 : wkid;
 }
 //#endregion
+//#region src/map-crs.ts
+/** Codes that are the default Web Mercator map rather than a custom CRS. */
+const WEB_MERCATOR_CODES = /* @__PURE__ */ new Set([
+	3857,
+	900913,
+	102100,
+	102113
+]);
+const USGS_WMS = "https://planetarymaps.usgs.gov/cgi-bin/mapserv";
+const USGS_ATTRIBUTION = "<a href=\"https://astrogeology.usgs.gov/\">USGS Astrogeology</a>";
+const GIBS_ATTRIBUTION = "Imagery: <a href=\"https://earthdata.nasa.gov/gibs\">NASA GIBS</a> / Blue Marble";
+/**
+* A WMS 1.1.1 GetMap template. 1.1.1 because its BBOX is always x,y (east,
+* north) order, which is what `{bbox}` fills in; 1.3.0 flips it for
+* geographic CRSs.
+*/
+function getMapTemplate(base, srs, layer, format) {
+	return `${base}${base.includes("?") ? "&" : "?"}SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&SRS=${srs}&STYLES=&LAYERS=${layer}&WIDTH=512&HEIGHT=512&FORMAT=${format}&TRANSPARENT=TRUE&BBOX={bbox}`;
+}
+/** A USGS Astrogeology MapServer layer in the CRS of its `.map` file. */
+function usgsBasemap(mapFile, srs, layer, maxZoom) {
+	return {
+		tiles: getMapTemplate(`${USGS_WMS}?map=${mapFile}`, srs, layer, "image/png"),
+		attribution: USGS_ATTRIBUTION,
+		maxZoom
+	};
+}
+/** A NASA GIBS Blue Marble layer from the WMS endpoint of one of its grids. */
+function gibsBasemap(epsg) {
+	return {
+		tiles: getMapTemplate(`https://gibs.earthdata.nasa.gov/wms/epsg${epsg}/best/wms.cgi`, `EPSG:${epsg}`, "BlueMarble_ShadedRelief_Bathymetry", "image/jpeg"),
+		attribution: GIBS_ATTRIBUTION,
+		maxZoom: 7
+	};
+}
+/** Lng/lat degrees on the whole world, centered so MapLibre can find its edges. */
+const GEOGRAPHIC_GRID = {
+	origin: [-180, 180],
+	extentAtZoom0: 360
+};
+/** A square centered on a pole, `halfWidth` CRS units to each side. */
+function polarGrid(halfWidth) {
+	return {
+		origin: [-halfWidth, halfWidth],
+		extentAtZoom0: 2 * halfWidth
+	};
+}
+const sphere = (radius) => `+R=${radius}`;
+const longlat = (radius) => `+proj=longlat ${sphere(radius)} +no_defs`;
+const polarStereographic = (north, radius) => `+proj=stere +lat_0=${north ? 90 : -90} +lon_0=0 +k=1 +x_0=0 +y_0=0 ${sphere(radius)} +units=m +no_defs`;
+const MOON_RADIUS = 1737400;
+const MARS_RADIUS = 3396190;
+/**
+* A simple-cylindrical (lng/lat degrees) preset for one body's USGS map file.
+*
+* Args:
+*   body: The body, which is also the ellipsoid id.
+*   name: English name of the preset.
+*   naifCode: The body's IAU 2015 code (NAIF id × 100), e.g. `49900` for Mars.
+*   radius: Sphere radius in metres.
+*   mapFile: The USGS `.map` file path.
+*   layer: The WMS layer drawn as the basemap.
+*
+* Returns:
+*   The preset.
+*/
+function cylindrical(body, name, naifCode, radius, mapFile, layer) {
+	return {
+		id: `${body}-cylindrical`,
+		name,
+		code: `IAU_2015:${naifCode}`,
+		wmsSrs: "EPSG:4326",
+		definition: longlat(radius),
+		ellipsoidId: body,
+		tileMatrixSet: GEOGRAPHIC_GRID,
+		bounds: [
+			-180,
+			-90,
+			180,
+			90
+		],
+		basemap: usgsBasemap(mapFile, "EPSG:4326", layer, 7)
+	};
+}
+/**
+* Presets verified to render against their WMS on 2026-10-19.
+*
+* The USGS polar map files serve their native polar stereographic grid under
+* `EPSG:32661`/`EPSG:32761` (MapServer's PROJ rejects the IAU codes they also
+* list), centred on the pole with no false origin, so those labels are used for
+* the basemap requests while the map registers the body's IAU code.
+*/
+const MAP_CRS_PRESETS = [
+	{
+		id: "earth-arctic",
+		name: "Arctic Polar Stereographic",
+		code: "EPSG:3413",
+		definition: "+proj=stere +lat_0=90 +lat_ts=70 +lon_0=-45 +k=1 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs",
+		ellipsoidId: "earth",
+		tileMatrixSet: polarGrid(4194304),
+		bounds: [
+			-180,
+			60,
+			180,
+			90
+		],
+		basemap: gibsBasemap(3413)
+	},
+	{
+		id: "earth-antarctic",
+		name: "Antarctic Polar Stereographic",
+		code: "EPSG:3031",
+		definition: "+proj=stere +lat_0=-90 +lat_ts=-71 +lon_0=0 +k=1 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs",
+		ellipsoidId: "earth",
+		tileMatrixSet: polarGrid(4194304),
+		bounds: [
+			-180,
+			-90,
+			180,
+			-60
+		],
+		basemap: gibsBasemap(3031)
+	},
+	{
+		id: "earth-cylindrical",
+		name: "Plate Carrée (WGS 84)",
+		code: "EPSG:4326",
+		definition: "+proj=longlat +datum=WGS84 +no_defs",
+		ellipsoidId: "earth",
+		tileMatrixSet: GEOGRAPHIC_GRID,
+		bounds: [
+			-180,
+			-90,
+			180,
+			90
+		],
+		basemap: gibsBasemap(4326)
+	},
+	cylindrical("moon", "Moon Simple Cylindrical", 30100, MOON_RADIUS, "/maps/earth/moon_simp_cyl.map", "LROC_WAC"),
+	{
+		id: "moon-north-polar",
+		name: "Moon North Polar Stereographic",
+		code: "IAU_2015:30118",
+		wmsSrs: "EPSG:32661",
+		definition: polarStereographic(true, MOON_RADIUS),
+		ellipsoidId: "moon",
+		tileMatrixSet: polarGrid(931e3),
+		bounds: [
+			-180,
+			70,
+			180,
+			90
+		],
+		basemap: usgsBasemap("/maps/earth/moon_npole.map", "EPSG:32661", "LRO_WAC_north", 8)
+	},
+	{
+		id: "moon-south-polar",
+		name: "Moon South Polar Stereographic",
+		code: "IAU_2015:30120",
+		wmsSrs: "EPSG:32761",
+		definition: polarStereographic(false, MOON_RADIUS),
+		ellipsoidId: "moon",
+		tileMatrixSet: polarGrid(931e3),
+		bounds: [
+			-180,
+			-90,
+			180,
+			-70
+		],
+		basemap: usgsBasemap("/maps/earth/moon_spole.map", "EPSG:32761", "LRO_WAC_south", 8)
+	},
+	cylindrical("mars", "Mars Simple Cylindrical", 49900, MARS_RADIUS, "/maps/mars/mars_simp_cyl.map", "MOLA_color"),
+	{
+		id: "mars-north-polar",
+		name: "Mars North Polar Stereographic",
+		code: "IAU_2015:49918",
+		wmsSrs: "EPSG:32661",
+		definition: polarStereographic(true, MARS_RADIUS),
+		ellipsoidId: "mars",
+		tileMatrixSet: polarGrid(2357030),
+		bounds: [
+			-180,
+			65,
+			180,
+			90
+		],
+		basemap: usgsBasemap("/maps/mars/mars_npole.map", "EPSG:32661", "MOLA_color_north", 7)
+	},
+	{
+		id: "mars-south-polar",
+		name: "Mars South Polar Stereographic",
+		code: "IAU_2015:49920",
+		wmsSrs: "EPSG:32761",
+		definition: polarStereographic(false, MARS_RADIUS),
+		ellipsoidId: "mars",
+		tileMatrixSet: polarGrid(2357030),
+		bounds: [
+			-180,
+			-90,
+			180,
+			-65
+		],
+		basemap: usgsBasemap("/maps/mars/mars_spole.map", "EPSG:32761", "MOLA_color_south", 7)
+	},
+	cylindrical("mercury", "Mercury Simple Cylindrical", 19900, 2439400, "/maps/mercury/mercury_simp_cyl.map", "MESSENGER"),
+	cylindrical("venus", "Venus Simple Cylindrical", 29900, 6051800, "/maps/venus/venus_simp_cyl.map", "MAGELLAN"),
+	cylindrical("io", "Io Simple Cylindrical", 50100, 1821600, "/maps/jupiter/io_simp_cyl.map", "SSI_color"),
+	cylindrical("europa", "Europa Simple Cylindrical", 50200, 1560800, "/maps/jupiter/europa_simp_cyl.map", "GALILEO_VOYAGER"),
+	cylindrical("ganymede", "Ganymede Simple Cylindrical", 50300, 2631200, "/maps/jupiter/ganymede_simp_cyl.map", "GALILEO_VOYAGER"),
+	cylindrical("callisto", "Callisto Simple Cylindrical", 50400, 2410300, "/maps/jupiter/callisto_simp_cyl.map", "GALILEO_VOYAGER"),
+	cylindrical("titan", "Titan Simple Cylindrical", 60600, 2574730, "/maps/saturn/titan_simp_cyl.map", "Titan_ISS_Controlled_Mosaic"),
+	cylindrical("pluto", "Pluto Simple Cylindrical", 99900, 1188300, "/maps/pluto/pluto_simp_cyl.map", "NEWHORIZONS_PLUTO_MOSAIC"),
+	cylindrical("charon", "Charon Simple Cylindrical", 90100, 606e3, "/maps/pluto/charon_simp_cyl.map", "NEWHORIZONS_CHARON_MOSAIC")
+];
+/**
+* Look a preset up by its id.
+*
+* Args:
+*   id: A `preferences.map.mapCrs` value.
+*
+* Returns:
+*   The preset, or `undefined` when `id` is not a preset id.
+*/
+function getMapCrsPreset(id) {
+	return id === void 0 ? void 0 : MAP_CRS_PRESETS.find((preset) => preset.id === id);
+}
+/**
+* Read an `EPSG:<code>` map CRS value.
+*
+* Args:
+*   value: A `preferences.map.mapCrs` value.
+*
+* Returns:
+*   The numeric EPSG code, or `null` when the value is not an EPSG CRS.
+*/
+function parseMapCrsEpsgCode(value) {
+	const match = /^\s*EPSG:(\d+)\s*$/i.exec(value ?? "");
+	if (!match) return null;
+	const code = Number(match[1]);
+	return Number.isSafeInteger(code) && code > 0 ? code : null;
+}
+/**
+* Normalize a stored map CRS.
+*
+* Args:
+*   value: The raw `preferences.map.mapCrs` value.
+*
+* Returns:
+*   A preset id, `"EPSG:<code>"`, or `undefined` for the default Web Mercator
+*   map (absent, malformed or a Web Mercator code).
+*/
+function normalizeMapCrs(value) {
+	if (typeof value !== "string") return void 0;
+	if (getMapCrsPreset(value)) return value;
+	const code = parseMapCrsEpsgCode(value);
+	if (code === null || WEB_MERCATOR_CODES.has(code)) return void 0;
+	const epsg = `EPSG:${code}`;
+	return MAP_CRS_PRESETS.find((preset) => preset.code === epsg)?.id ?? epsg;
+}
+/**
+* Point a Web Mercator WMS or ArcGIS export template at a map CRS.
+*
+* GeoLibre's WMS layers request `BBOX={bbox-epsg-3857}` in `EPSG:3857`. On a
+* map in another CRS each tile is a box in that CRS instead, which MapLibre
+* writes into the `{bbox}` token, so the template asks for `{bbox}` in `code`.
+* WMS requests move to version 1.1.1, whose `SRS` BBOX is east, north for every
+* CRS (1.3.0 swaps the axes of geographic ones), and an ArcGIS `export`
+* template has its `bboxSR`/`imageSR` set to the EPSG number.
+*
+* Args:
+*   template: A raster tile template.
+*   code: The map CRS's authority code, e.g. `EPSG:3031` or `IAU_2015:49918`.
+*
+* Returns:
+*   The template for the CRS, the template unchanged when it already uses
+*   `{bbox}`, or `null` for a template with no bounding box (an XYZ or TMS
+*   template), which cannot be drawn in another CRS.
+*/
+function adaptBboxTemplateToCrs(template, code) {
+	if (template.includes("{bbox}")) return template;
+	if (!template.includes("{bbox-epsg-3857}")) return null;
+	let url = template.replace(/\{bbox-epsg-3857\}/g, "{bbox}");
+	const epsg = /^EPSG:(\d+)$/i.exec(code)?.[1];
+	const setParam = (name, value) => {
+		const pattern = new RegExp(`([?&])${name}=[^&]*`, "i");
+		url = pattern.test(url) ? url.replace(pattern, `$1${name}=${value}`) : `${url}${url.includes("?") ? "&" : "?"}${name}=${value}`;
+	};
+	const removeParam = (name) => {
+		url = url.replace(new RegExp(`([?&])${name}=[^&]*(&?)`, "i"), (_, lead, trail) => trail ? lead : "");
+	};
+	if (/[?&]bboxSR=/i.test(url)) {
+		if (!epsg) return null;
+		setParam("bboxSR", epsg);
+		setParam("imageSR", epsg);
+		return url;
+	}
+	removeParam("CRS");
+	setParam("SRS", code);
+	setParam("VERSION", "1.1.1");
+	return url;
+}
+/**
+* The smallest centered square grid over the part of a CRS worth mapping, for
+* an EPSG code without a published tile grid.
+*
+* Samples a 2° lng/lat lattice and keeps the points `projection` takes forward
+* and back to where they started (a transverse Mercator's far side does not)
+* whose local scale is at most {@link MAX_RELATIVE_SCALE} times the CRS's
+* smallest. A polar stereographic map round-trips almost to the other pole,
+* but out there a kilometre spans thousands of CRS units, and a grid that wide
+* leaves the CRS's own area a speck at every useful zoom. The extent of the
+* kept points is padded by 4%. MapLibre finds the edge of a world projection
+* by walking out from the grid's center, so the grid is centered on them.
+*
+* Args:
+*   projection: Lng/lat to CRS and back, the shape of a proj4 converter.
+*   geographic: Whether the CRS is in degrees, which gets the whole-world grid.
+*
+* Returns:
+*   The grid, or `null` when no sampled point survives the round trip.
+*/
+function deriveTileMatrixSet(projection, geographic) {
+	if (geographic) return GEOGRAPHIC_GRID;
+	const forward = (lng, lat) => {
+		try {
+			const [x, y] = projection.forward([lng, lat]) ?? [];
+			return Number.isFinite(x) && Number.isFinite(y) && Math.abs(x) <= 1e9 && Math.abs(y) <= 1e9 ? [x, y] : null;
+		} catch {
+			return null;
+		}
+	};
+	const roundTrips = (point, lng, lat) => {
+		let back;
+		try {
+			back = projection.inverse(point);
+		} catch {
+			return false;
+		}
+		if (!back || !Number.isFinite(back[0]) || !Number.isFinite(back[1])) return false;
+		const dLng = Math.abs(((back[0] - lng) % 360 + 540) % 360 - 180);
+		return Math.abs(back[1] - lat) <= 1e-4 && dLng <= 1e-4;
+	};
+	const STEP = .01;
+	const radians = STEP * Math.PI / 180;
+	const samples = [];
+	for (let lng = -180; lng <= 180; lng += 2) for (let lat = -88; lat <= 88; lat += 2) {
+		const point = forward(lng, lat);
+		if (!point || !roundTrips(point, lng, lat)) continue;
+		const north = forward(lng, lat + STEP);
+		const east = forward(lng + STEP, lat);
+		if (!north || !east) continue;
+		const scale = Math.max(Math.hypot(north[0] - point[0], north[1] - point[1]) / radians, Math.hypot(east[0] - point[0], east[1] - point[1]) / (radians * Math.cos(lat * Math.PI / 180)));
+		if (scale > 0 && Number.isFinite(scale)) samples.push({
+			x: point[0],
+			y: point[1],
+			scale
+		});
+	}
+	if (samples.length === 0) return null;
+	const limit = MAX_RELATIVE_SCALE * Math.min(...samples.map((sample) => sample.scale));
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const { x, y, scale } of samples) {
+		if (scale > limit) continue;
+		minX = Math.min(minX, x);
+		minY = Math.min(minY, y);
+		maxX = Math.max(maxX, x);
+		maxY = Math.max(maxY, y);
+	}
+	const side = Math.max(maxX - minX, maxY - minY) * 1.04;
+	if (!(side > 0)) return null;
+	return {
+		origin: [(minX + maxX - side) / 2, (minY + maxY + side) / 2],
+		extentAtZoom0: side
+	};
+}
+/**
+* How much more a derived grid's edge may stretch distances than the CRS's
+* least distorted place: about 11°N for an Antarctic polar stereographic map,
+* and some 65° either side of a transverse Mercator's central meridian.
+*/
+const MAX_RELATIVE_SCALE = 2.5;
+//#endregion
 //#region src/geojson-z.ts
 /**
 * Helpers for vector data whose coordinates carry a Z value (elevation), e.g.
@@ -1828,6 +2216,176 @@ function batchDecodePolylines(input, options = {}) {
 	};
 }
 //#endregion
+//#region src/runtime-env.ts
+const buildEnv = typeof __GEOLIBRE_BUILD_ENV__ === "undefined" ? {} : __GEOLIBRE_BUILD_ENV__;
+/**
+* The allowlisted build-time environment, with no runtime overlay.
+*
+* For settings that must be fixed by the build and NOT overridable by a
+* `.geolibre.json` a user opened — the auth gate, the deployment profile, the
+* embed origin allowlist. Routing those through {@link getRuntimeEnvironment}
+* would let project-supplied `__GEOLIBRE_RUNTIME_ENV__` values relax them.
+*
+* Callers should prefer this over reading `import.meta.env` directly: a
+* whole-object read defeats Vite's per-key replacement and inlines every
+* `VITE_` var on the build machine into the chunk.
+*
+* @returns The build-time environment record.
+*/
+function getBuildEnvironment() {
+	return buildEnv;
+}
+/**
+* Merges build-time env with project runtime env (the latter wins). Falls back
+* to build-time env alone outside a browser (e.g. in tests).
+*
+* @returns The resolved environment variables.
+*/
+function getRuntimeEnvironment() {
+	if (typeof window === "undefined") return buildEnv;
+	return {
+		...buildEnv,
+		...window.__GEOLIBRE_RUNTIME_ENV__ ?? {}
+	};
+}
+/**
+* Resolves a local DuckDB spatial extension path from the runtime environment.
+*
+* When `VITE_DUCKDB_SPATIAL_EXTENSION_PATH` is set, DuckDB consumers (the
+* desktop app's own loader and the Add Vector panel's maplibre-gl-vector
+* control) load the spatial extension from this path with `LOAD '<path>'`
+* instead of installing it from the remote repository, which hangs in
+* sandboxed or firewalled environments. Lives in `@geolibre/core` so every
+* consumer shares one implementation.
+*
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The trimmed extension path, or undefined when unset.
+*/
+function getSpatialExtensionPath(env) {
+	return (env ?? getRuntimeEnvironment()).VITE_DUCKDB_SPATIAL_EXTENSION_PATH?.trim() || void 0;
+}
+/**
+* Resolves the Protomaps API key from the runtime environment.
+*
+* Protomaps' hosted styles require an API key embedded in the style URL. The
+* key is supplied via `VITE_PROTOMAPS_API_KEY` (baked in at build time for the
+* web demo; see the deploy workflow). When unset, the Protomaps basemaps are
+* unavailable and should be hidden from the UI.
+*
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The trimmed API key, or undefined when unset.
+*/
+function getProtomapsApiKey(env) {
+	return (env ?? getRuntimeEnvironment()).VITE_PROTOMAPS_API_KEY?.trim() || void 0;
+}
+/**
+* Resolves the Google Maps API key from the runtime environment.
+*
+* GeoLibre's browser-facing builds normally use `VITE_GOOGLE_MAPS_API_KEY`.
+* The bare `GOOGLE_MAPS_API_KEY` fallback is reached two ways: (1) the desktop
+* Vite config copies it to `VITE_GOOGLE_MAPS_API_KEY` at build time for local
+* shell testing (`vite.config.ts`'s `envPrefix` does not include the bare
+* name), and (2) a project's own runtime environment variables
+* (`window.__GEOLIBRE_RUNTIME_ENV__`), which are not subject to Vite's
+* envPrefix allowlist at all.
+*
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The trimmed API key, or undefined when unset.
+*/
+function getGoogleMapsApiKey(env) {
+	const runtimeEnv = env ?? getRuntimeEnvironment();
+	return runtimeEnv.VITE_GOOGLE_MAPS_API_KEY?.trim() || runtimeEnv.GOOGLE_MAPS_API_KEY?.trim() || void 0;
+}
+/**
+* Resolves the Mapbox access token from the runtime environment.
+*
+* The basemap control's Mapbox styles authenticate with the user's own token.
+* It is supplied via `VITE_MAPBOX_ACCESS_TOKEN` (baked in at build time from the
+* bare `MAPBOX_TOKEN` env var, which `vite.config.ts` copies into the prefixed
+* name — the spelling Mapbox's own tooling uses) or set at runtime through
+* Settings → Environment variables (`window.__GEOLIBRE_RUNTIME_ENV__`, which
+* bypasses Vite's envPrefix allowlist, so a bare `MAPBOX_TOKEN` entry works
+* there too). When unset, the Mapbox basemaps prompt for a token in the basemap
+* panel's API keys view instead.
+*
+* Note the precedence, shared with {@link getGoogleMapsApiKey} and
+* {@link getCesiumIonToken}: the prefixed name always wins over the bare one,
+* and `getRuntimeEnvironment` merges build-time and runtime vars into one
+* record. So a build that baked in `VITE_MAPBOX_ACCESS_TOKEN` is overridden at
+* runtime by a Settings entry under that *same* prefixed name; a bare
+* `MAPBOX_TOKEN` entry is a fallback for when nothing was baked in, not a way
+* to override a baked token.
+*
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The trimmed token, or undefined when unset.
+*/
+function getMapboxAccessToken(env) {
+	const runtimeEnv = env ?? getRuntimeEnvironment();
+	return runtimeEnv.VITE_MAPBOX_ACCESS_TOKEN?.trim() || runtimeEnv.MAPBOX_TOKEN?.trim() || void 0;
+}
+/**
+* Resolves the ArcGIS API key from the runtime environment.
+*
+* The ArcGIS renderer draws the translated project basemap and non-Esri layers
+* without a key; Esri's basemap styles and location services require one
+* (an ArcGIS Location Platform or ArcGIS Online API key credential). It is
+* supplied via `VITE_ARCGIS_API_KEY` (baked in at build time from the bare
+* `ARCGIS_API_KEY` env var, which `vite.config.ts` copies into the prefixed
+* name) or set at runtime through Settings → Environment variables
+* (`window.__GEOLIBRE_RUNTIME_ENV__`, so a bare `ARCGIS_API_KEY` entry works
+* there too). Same precedence as {@link getMapboxAccessToken}.
+*
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The trimmed key, or undefined when unset.
+*/
+function getArcgisApiKey(env) {
+	const runtimeEnv = env ?? getRuntimeEnvironment();
+	return runtimeEnv.VITE_ARCGIS_API_KEY?.trim() || runtimeEnv.ARCGIS_API_KEY?.trim() || void 0;
+}
+/**
+* Resolves the Cesium Ion access token from the runtime environment.
+*
+* Cesium World Terrain and Ion World Imagery need a Cesium Ion token. It is
+* supplied via `VITE_CESIUM_TOKEN` (baked in at build time from the bare
+* `CESIUM_TOKEN` env var, which `vite.config.ts` copies into the prefixed name)
+* or set at runtime through Settings → Environment variables
+* (`window.__GEOLIBRE_RUNTIME_ENV__`, which bypasses Vite's envPrefix allowlist,
+* so a bare `CESIUM_TOKEN` entry works there too).
+*
+* The 3D-globe view itself does **not** need one: it draws the project basemap
+* as its base imagery whenever that basemap has a raster form (see
+* {@link basemapToCesiumImagery}), and falls back to Ion World Imagery — or, with
+* no token, to OpenStreetMap — for the ones that do not. So an absent token
+* costs terrain and the quality of that fallback, not the view.
+*
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The trimmed token, or undefined when unset.
+*/
+function getCesiumIonToken(env) {
+	const runtimeEnv = env ?? getRuntimeEnvironment();
+	return runtimeEnv.VITE_CESIUM_TOKEN?.trim() || runtimeEnv.CESIUM_TOKEN?.trim() || void 0;
+}
+/**
+* Builds a full Protomaps v5 style URL for a flavor, injecting the API key.
+*
+* @param flavor - The Protomaps flavor name (e.g. `light`, `dark`, `white`,
+*   `grayscale`, `black`).
+* @param env - Environment record (defaults to the runtime environment);
+*   injectable for testing.
+* @returns The resolved style URL, or undefined when no API key is configured.
+*/
+function getProtomapsStyleUrl(flavor, env) {
+	const key = getProtomapsApiKey(env);
+	if (!key) return void 0;
+	return `https://api.protomaps.com/styles/v5/${encodeURIComponent(flavor)}/en.json?key=${encodeURIComponent(key)}`;
+}
+//#endregion
 //#region src/selection.ts
 /** Selection modes in display order. */
 const SELECTION_MODES = [
@@ -3040,8 +3598,9 @@ function applyJoinsToLayer(layer, allLayers, nextJoins, nextVirtualFields) {
 		return allLayers.find((candidate) => candidate.id === joinLayerId)?.geojson;
 	});
 	const withVirtual = applyLayerVirtualFields(applied.features, virtualFields);
+	const { geoarrow: _staleGeoarrow, ...rest } = layer;
 	return {
-		...layer,
+		...rest,
 		geojson: {
 			...geojson,
 			features: withVirtual.features
@@ -4942,6 +5501,406 @@ const BUILT_IN_STYLE_PRESETS = [
 	}
 ];
 //#endregion
+//#region src/raster-source-defaults.ts
+/**
+* Older projects and manually added Wayback templates may omit the native
+* zoom limit. Cap their requests at level 19 so renderers overzoom available
+* imagery instead of requesting missing higher-level tiles (issue #3116).
+* Explicit numeric limits remain authoritative, including lower regional limits.
+* Renderers ignore string limits, so only numeric minzoom can constrain this default.
+*/
+function withRasterSourceDefaults(layer) {
+	if (![
+		"raster",
+		"xyz",
+		"wmts"
+	].includes(layer.type) || !layer.source || typeof layer.source.maxzoom === "number" && Number.isFinite(layer.source.maxzoom) || typeof layer.source.minzoom === "number" && layer.source.minzoom > 19) return layer;
+	if (!(Array.isArray(layer.source.tiles) && layer.source.tiles.length ? layer.source.tiles : [layer.source.url]).every(isWaybackTileUrl)) return layer;
+	return {
+		...layer,
+		source: {
+			...layer.source,
+			maxzoom: 19
+		}
+	};
+}
+function isWaybackTileUrl(value) {
+	if (typeof value !== "string") return false;
+	try {
+		const url = new URL(value);
+		return (url.protocol === "https:" || url.protocol === "http:") && /^wayback(?:-[a-z])?\.maptiles\.arcgis\.com$/i.test(url.hostname) && /^\/arcgis\/rest\/services\/World_Imagery\/(?:WMTS\/1\.0\.0\/[^/]+\/)?MapServer\/tile\/\d+\//i.test(url.pathname);
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/geoarrow.ts
+/**
+* Type guard for {@link GeoArrowBatch}.
+* Validates structure and basic buffer invariants without deep scanning.
+*/
+function isGeoArrowBatch(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	if (![
+		"Point",
+		"MultiPoint",
+		"LineString",
+		"MultiLineString",
+		"Polygon",
+		"MultiPolygon"
+	].includes(candidate.geometryType ?? "")) return false;
+	if (!(candidate.coordinates instanceof Float64Array)) return false;
+	if (candidate.coordDimensions !== 2 && candidate.coordDimensions !== 3) return false;
+	if (!Number.isSafeInteger(candidate.featureCount) || candidate.featureCount < 0) return false;
+	if (candidate.coordinates.length % candidate.coordDimensions !== 0) return false;
+	if (candidate.geomOffsets !== void 0 && !(candidate.geomOffsets instanceof Int32Array)) return false;
+	if (candidate.ringOffsets !== void 0 && !(candidate.ringOffsets instanceof Int32Array)) return false;
+	if (candidate.polygonOffsets !== void 0 && !(candidate.polygonOffsets instanceof Int32Array)) return false;
+	const vertexCount = candidate.coordinates.length / candidate.coordDimensions;
+	const validOffsets = (offsets, length, end) => {
+		if (!offsets || offsets.length !== length || offsets[0] !== 0) return false;
+		for (let i = 1; i < offsets.length; i++) if (offsets[i] < offsets[i - 1] || offsets[i] > end) return false;
+		return offsets[offsets.length - 1] === end;
+	};
+	const count = candidate.featureCount;
+	if (candidate.geometryType === "Point") {
+		if (vertexCount !== count) return false;
+	} else if (candidate.geometryType === "LineString" || candidate.geometryType === "MultiPoint") {
+		if (!validOffsets(candidate.geomOffsets, count + 1, vertexCount)) return false;
+	} else {
+		const rings = (candidate.ringOffsets?.length ?? 0) - 1;
+		if (!validOffsets(candidate.ringOffsets, rings + 1, vertexCount)) return false;
+		if (candidate.geometryType === "MultiPolygon") {
+			const polygons = (candidate.geomOffsets?.length ?? 0) - 1;
+			if (!validOffsets(candidate.geomOffsets, polygons + 1, rings)) return false;
+			if (!validOffsets(candidate.polygonOffsets, count + 1, polygons)) return false;
+		} else if (!validOffsets(candidate.geomOffsets, count + 1, rings)) return false;
+	}
+	if (candidate.properties !== void 0 && (!Array.isArray(candidate.properties) || candidate.properties.length !== count)) return false;
+	if (candidate.featureIds !== void 0 && (!Array.isArray(candidate.featureIds) || candidate.featureIds.length !== count)) return false;
+	return true;
+}
+/**
+* Computes a 2D bounding box [minX, minY, maxX, maxY] for a {@link GeoArrowBatch}
+* in a single fast, vectorized pass over the flat coordinates buffer.
+* Returns null if the batch contains no finite coordinates.
+*/
+function computeGeoArrowBBox(batch) {
+	if (batch.bbox) return [...batch.bbox];
+	const { coordinates, coordDimensions } = batch;
+	if (coordinates.length === 0) return null;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const step = coordDimensions;
+	for (let i = 0; i < coordinates.length; i += step) {
+		const x = coordinates[i];
+		const y = coordinates[i + 1];
+		if (Number.isFinite(x) && Number.isFinite(y)) {
+			if (x < minX) minX = x;
+			if (y < minY) minY = y;
+			if (x > maxX) maxX = x;
+			if (y > maxY) maxY = y;
+		}
+	}
+	return minX === Infinity ? null : [
+		minX,
+		minY,
+		maxX,
+		maxY
+	];
+}
+/**
+* Convert a {@link GeoArrowBatch} to a standard GeoJSON {@link FeatureCollection}.
+* Lossless round-trip converter for renderers or components (Cesium, Attribute Table, Turf)
+* that expect standard GeoJSON objects.
+*/
+function geoArrowToFeatureCollection(batch) {
+	const { geometryType, coordinates, coordDimensions: dim, geomOffsets, ringOffsets, polygonOffsets, featureCount, properties, featureIds } = batch;
+	const features = new Array(featureCount);
+	function readPosition(vertexIdx) {
+		const o = vertexIdx * dim;
+		return dim === 3 ? [
+			coordinates[o],
+			coordinates[o + 1],
+			coordinates[o + 2]
+		] : [coordinates[o], coordinates[o + 1]];
+	}
+	function readLine(startVertex, endVertex) {
+		const count = endVertex - startVertex;
+		const line = new Array(count);
+		for (let i = 0; i < count; i++) line[i] = readPosition(startVertex + i);
+		return line;
+	}
+	for (let i = 0; i < featureCount; i++) {
+		const props = properties ? { ...properties[i] } : {};
+		const id = featureIds ? featureIds[i] : void 0;
+		let geometry = null;
+		switch (geometryType) {
+			case "Point": {
+				const o = i * dim;
+				if (o + 1 < coordinates.length && Number.isFinite(coordinates[o]) && Number.isFinite(coordinates[o + 1])) geometry = {
+					type: "Point",
+					coordinates: readPosition(i)
+				};
+				break;
+			}
+			case "MultiPoint":
+				if (geomOffsets) {
+					const start = geomOffsets[i];
+					const end = geomOffsets[i + 1];
+					if (end > start) geometry = {
+						type: "MultiPoint",
+						coordinates: readLine(start, end)
+					};
+				}
+				break;
+			case "LineString":
+				if (geomOffsets) {
+					const start = geomOffsets[i];
+					const end = geomOffsets[i + 1];
+					if (end > start) geometry = {
+						type: "LineString",
+						coordinates: readLine(start, end)
+					};
+				}
+				break;
+			case "MultiLineString":
+				if (geomOffsets && ringOffsets) {
+					const startLine = geomOffsets[i];
+					const endLine = geomOffsets[i + 1];
+					const lines = [];
+					for (let l = startLine; l < endLine; l++) {
+						const vStart = ringOffsets[l];
+						const vEnd = ringOffsets[l + 1];
+						if (vEnd > vStart) lines.push(readLine(vStart, vEnd));
+					}
+					if (lines.length > 0) geometry = {
+						type: "MultiLineString",
+						coordinates: lines
+					};
+				}
+				break;
+			case "Polygon":
+				if (geomOffsets && ringOffsets) {
+					const startRing = geomOffsets[i];
+					const endRing = geomOffsets[i + 1];
+					const rings = [];
+					for (let r = startRing; r < endRing; r++) {
+						const vStart = ringOffsets[r];
+						const vEnd = ringOffsets[r + 1];
+						if (vEnd > vStart) rings.push(readLine(vStart, vEnd));
+					}
+					if (rings.length > 0) geometry = {
+						type: "Polygon",
+						coordinates: rings
+					};
+				}
+				break;
+			case "MultiPolygon": if (polygonOffsets && geomOffsets && ringOffsets) {
+				const startPoly = polygonOffsets[i];
+				const endPoly = polygonOffsets[i + 1];
+				const polys = [];
+				for (let p = startPoly; p < endPoly; p++) {
+					const startRing = geomOffsets[p];
+					const endRing = geomOffsets[p + 1];
+					const rings = [];
+					for (let r = startRing; r < endRing; r++) {
+						const vStart = ringOffsets[r];
+						const vEnd = ringOffsets[r + 1];
+						if (vEnd > vStart) rings.push(readLine(vStart, vEnd));
+					}
+					if (rings.length > 0) polys.push(rings);
+				}
+				if (polys.length > 0) geometry = {
+					type: "MultiPolygon",
+					coordinates: polys
+				};
+			}
+		}
+		features[i] = {
+			type: "Feature",
+			id,
+			properties: props,
+			geometry
+		};
+	}
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+function extractVerticesForLineOrMultiPoint(geometry, primaryType) {
+	if (!geometry) return null;
+	if (primaryType === "LineString") {
+		if (geometry.type === "LineString" && Array.isArray(geometry.coordinates)) return geometry.coordinates;
+		return null;
+	}
+	if (primaryType === "MultiPoint") {
+		if (geometry.type === "MultiPoint" && Array.isArray(geometry.coordinates)) return geometry.coordinates;
+		if (geometry.type === "Point" && Array.isArray(geometry.coordinates)) return [geometry.coordinates];
+		return null;
+	}
+	return null;
+}
+/**
+* Flatten supported Point, MultiPoint, LineString and Polygon collections.
+* Empty collections produce an empty Point batch; unsupported geometries return null.
+*/
+function featureCollectionToGeoArrow(collection) {
+	const { features } = collection;
+	if (!features || features.length === 0) return {
+		geometryType: "Point",
+		coordinates: /* @__PURE__ */ new Float64Array(0),
+		coordDimensions: 2,
+		featureCount: 0,
+		properties: []
+	};
+	let primaryType = null;
+	let hasZ = false;
+	for (const f of features) {
+		const g = f.geometry;
+		if (!g) continue;
+		if (primaryType === null) {
+			if (g.type === "Point" || g.type === "MultiPoint" || g.type === "LineString" || g.type === "Polygon") primaryType = g.type;
+			else return null;
+		} else if (g.type !== primaryType) {
+			if (primaryType === "Point" && g.type === "MultiPoint" || primaryType === "MultiPoint" && g.type === "Point") primaryType = "MultiPoint";
+			else return null;
+		}
+		if (!hasZ) {
+			const positionHasZ = (position) => position.length > 2 && Number.isFinite(position[2]);
+			if (g.type === "Point") hasZ = positionHasZ(g.coordinates);
+			else if (g.type === "Polygon") hasZ = g.coordinates.some((ring) => ring.some(positionHasZ));
+			else if (g.type === "LineString" || g.type === "MultiPoint") hasZ = g.coordinates.some(positionHasZ);
+		}
+	}
+	if (!primaryType) primaryType = "Point";
+	const dim = hasZ ? 3 : 2;
+	const featureCount = features.length;
+	const properties = new Array(featureCount);
+	const featureIds = new Array(featureCount);
+	for (let i = 0; i < featureCount; i++) {
+		properties[i] = features[i].properties ?? {};
+		featureIds[i] = features[i].id;
+	}
+	if (primaryType === "Point") {
+		const coordinates = new Float64Array(featureCount * dim);
+		for (let i = 0; i < featureCount; i++) {
+			const g = features[i].geometry;
+			const o = i * dim;
+			if (g && g.type === "Point" && Array.isArray(g.coordinates)) {
+				coordinates[o] = Number(g.coordinates[0] ?? NaN);
+				coordinates[o + 1] = Number(g.coordinates[1] ?? NaN);
+				if (dim === 3) coordinates[o + 2] = Number(g.coordinates[2] ?? 0);
+			} else {
+				coordinates[o] = NaN;
+				coordinates[o + 1] = NaN;
+				if (dim === 3) coordinates[o + 2] = NaN;
+			}
+		}
+		const batch = {
+			geometryType: "Point",
+			coordinates,
+			coordDimensions: dim,
+			featureCount,
+			properties,
+			featureIds
+		};
+		const bbox = computeGeoArrowBBox(batch);
+		return bbox ? {
+			...batch,
+			bbox
+		} : batch;
+	}
+	if (primaryType === "LineString" || primaryType === "MultiPoint") {
+		const geomOffsets = new Int32Array(featureCount + 1);
+		let totalVertices = 0;
+		for (let i = 0; i < featureCount; i++) {
+			geomOffsets[i] = totalVertices;
+			const vertices = extractVerticesForLineOrMultiPoint(features[i].geometry, primaryType);
+			if (vertices) totalVertices += vertices.length;
+		}
+		geomOffsets[featureCount] = totalVertices;
+		const coordinates = new Float64Array(totalVertices * dim);
+		let vIdx = 0;
+		for (let i = 0; i < featureCount; i++) {
+			const vertices = extractVerticesForLineOrMultiPoint(features[i].geometry, primaryType);
+			if (vertices) for (const coord of vertices) {
+				const o = vIdx * dim;
+				coordinates[o] = Number(coord[0] ?? NaN);
+				coordinates[o + 1] = Number(coord[1] ?? NaN);
+				if (dim === 3) coordinates[o + 2] = Number(coord[2] ?? 0);
+				vIdx++;
+			}
+		}
+		const batch = {
+			geometryType: primaryType,
+			coordinates,
+			coordDimensions: dim,
+			geomOffsets,
+			featureCount,
+			properties,
+			featureIds
+		};
+		const bbox = computeGeoArrowBBox(batch);
+		return bbox ? {
+			...batch,
+			bbox
+		} : batch;
+	}
+	if (primaryType === "Polygon") {
+		const geomOffsets = new Int32Array(featureCount + 1);
+		let totalRings = 0;
+		let totalVertices = 0;
+		for (let i = 0; i < featureCount; i++) {
+			geomOffsets[i] = totalRings;
+			const g = features[i].geometry;
+			if (g && g.type === "Polygon" && Array.isArray(g.coordinates)) {
+				totalRings += g.coordinates.length;
+				for (const ring of g.coordinates) totalVertices += ring.length;
+			}
+		}
+		geomOffsets[featureCount] = totalRings;
+		const ringOffsets = new Int32Array(totalRings + 1);
+		const coordinates = new Float64Array(totalVertices * dim);
+		let rIdx = 0;
+		let vIdx = 0;
+		for (let i = 0; i < featureCount; i++) {
+			const g = features[i].geometry;
+			if (g && g.type === "Polygon" && Array.isArray(g.coordinates)) for (const ring of g.coordinates) {
+				ringOffsets[rIdx++] = vIdx;
+				for (const coord of ring) {
+					const o = vIdx * dim;
+					coordinates[o] = Number(coord[0] ?? NaN);
+					coordinates[o + 1] = Number(coord[1] ?? NaN);
+					if (dim === 3) coordinates[o + 2] = Number(coord[2] ?? 0);
+					vIdx++;
+				}
+			}
+		}
+		ringOffsets[totalRings] = vIdx;
+		const batch = {
+			geometryType: "Polygon",
+			coordinates,
+			coordDimensions: dim,
+			geomOffsets,
+			ringOffsets,
+			featureCount,
+			properties,
+			featureIds
+		};
+		const bbox = computeGeoArrowBBox(batch);
+		return bbox ? {
+			...batch,
+			bbox
+		} : batch;
+	}
+	return null;
+}
+//#endregion
 //#region src/czml.ts
 /**
 * CZML (Cesium Language) domain models and layer authoring (issue #2290).
@@ -5436,7 +6395,12 @@ const PUBLISHABLE_PLUGIN_SETTINGS = {
 	"maplibre-gl-components": ["legend", "colorbar"],
 	"maplibre-gl-time-slider": null,
 	"gods-eye-view": null,
-	"geolibre-point-cloud-annotation": null
+	"geolibre-point-cloud-annotation": null,
+	"maplibre-gl-geolens": [
+		"serverUrl",
+		"mapKey",
+		"layerKeys"
+	]
 };
 /**
 * Hash a credential value to a short, stable 64-bit token: two independent
@@ -5787,6 +6751,1289 @@ function redactCredentials(project) {
 	return redactProjectCredentials(project).project;
 }
 //#endregion
+//#region src/storymap-duration.ts
+/** Default chapter dwell time after the camera arrives, in seconds. */
+const DEFAULT_STORY_CHAPTER_DURATION_SECONDS = 15;
+const MIN_STORY_CHAPTER_DURATION_SECONDS = 1;
+const MAX_STORY_CHAPTER_DURATION_SECONDS = 3600;
+/** Resolve old or hand-authored chapter timings to a safe autoplay duration. */
+function normalizeStoryChapterDurationSeconds(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 15;
+	return Math.min(MAX_STORY_CHAPTER_DURATION_SECONDS, Math.max(1, value));
+}
+//#endregion
+//#region src/geocoding.ts
+/**
+* Geocoding client and pure helpers shared by the batch-geocode dialog and the
+* reverse-geocode plugin.
+*
+* This module lives in `@geolibre/core` rather than `@geolibre/processing`
+* because `@geolibre/plugins` depends on core but not on processing, and the
+* reverse-geocode plugin needs the same client. The pure helpers (URL builders,
+* result mappers, pacing) carry no React or MapLibre dependency so they can be
+* unit-tested without a browser or network.
+*
+* Providers: geocoding is dispatched through a small {@link GeocodingProvider}
+* registry so alternatives to Nominatim (ArcGIS World Geocoder, CartoCiudad, Mapbox,
+* Pelias, Google, organization-hosted ArcGIS GeocodeServer locators) can be
+* selected per project. Each provider builds its own request
+* URLs and normalizes its response into a {@link GeocodeMatch} (forward) or a
+* {@link ReverseGeocodeDisplay} (reverse), so the dialog and plugin stay
+* provider-agnostic. Nominatim is the default.
+*
+* The 1 request/second throttle and the row cap are part of Nominatim's public
+* usage policy and are therefore applied ONLY to the default public host; a
+* self-hosted endpoint relaxes both, and keyed providers (Mapbox/ArcGIS/Google)
+* are paced by their own quotas, not by us.
+*
+* Browser fetch cannot set `User-Agent`/`Referer`, so the app is identified to
+* Nominatim via the optional `email` query parameter plus the automatically
+* sent `Referer`. The desktop build overrides this with a native (Tauri) fetch
+* via {@link setGeocodingFetch} — see the note there. See
+* docs/user-guide/data-integrations.md#geocoding.
+*/
+const DEFAULT_FORWARD_GEOCODE_ENDPOINT = "https://nominatim.openstreetmap.org/search";
+const DEFAULT_REVERSE_GEOCODE_ENDPOINT = "https://nominatim.openstreetmap.org/reverse";
+/** Host whose public usage policy (1 req/sec, bulk limits) we must respect. */
+const NOMINATIM_PUBLIC_HOST = "nominatim.openstreetmap.org";
+/** Minimum spacing between requests to the public Nominatim endpoint. */
+const NOMINATIM_MIN_INTERVAL_MS = 1100;
+/** Host of the free, unkeyed public CartoCiudad geocoder (IGN/CNIG). */
+const CARTOCIUDAD_PUBLIC_HOST = "cartociudad.es";
+/**
+* Courtesy spacing (~5 req/sec) between requests to the public CartoCiudad
+* endpoint. Unlike {@link NOMINATIM_MIN_INTERVAL_MS} this is not a published
+* policy — IGN documents no rate limit — it is our own conservative default so
+* a large batch does not burst at a free public government service. See
+* {@link geocoderMinIntervalMs}.
+*/
+const CARTOCIUDAD_MIN_INTERVAL_MS = 200;
+/** Max rows a single batch run will geocode against the public endpoint. */
+const PUBLIC_GEOCODE_ROW_CAP = 1e3;
+/** Property keys added to each geocoded feature. */
+const GEOCODE_LAT_KEY = "geocode_lat";
+const GEOCODE_LON_KEY = "geocode_lon";
+const GEOCODE_DISPLAY_NAME_KEY = "geocode_display_name";
+const GEOCODE_SCORE_KEY = "geocode_importance";
+/** Provider id that produced (or failed to produce) a match, when stamped. */
+const GEOCODE_PROVIDER_KEY = "geocode_provider";
+/** Whether a row matched, when stamped. See {@link GeocodeStatus}. */
+const GEOCODE_STATUS_KEY = "geocode_status";
+/** Prefix of a matched candidate's own attributes, when they are kept. */
+const GEOCODE_ATTRIBUTE_PREFIX = "geocode_attr_";
+/** The provider used when none is configured. */
+const DEFAULT_GEOCODING_PROVIDER_ID = "nominatim";
+/**
+* An error the geocoding service reported about the request itself, as opposed
+* to a network failure or a search with no matches. ArcGIS answers failures with
+* HTTP 200 and an `error` envelope, so `response.ok` alone would turn them into
+* an empty result. `code` is the service's own code (498/499 for a missing or
+* invalid token, 403 for insufficient permission).
+*/
+var GeocoderServiceError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "GeocoderServiceError";
+		this.code = code;
+	}
+	/** Whether the service asked for a token or rejected the one it got. */
+	get isAuthError() {
+		return this.code === 401 || this.code === 403 || this.code === 498 || this.code === 499;
+	}
+};
+/** The configured geocoder does not support the requested operation. */
+var GeocoderUnsupportedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GeocoderUnsupportedError";
+	}
+};
+function coerceScore(value) {
+	if (value === void 0 || value === null || value === "") return null;
+	const num = Number(value);
+	return Number.isFinite(num) ? num : null;
+}
+/** Append `base` to `existing`, suffixing `_2`, `_3`, ... if the key collides. */
+function uniqueKey(base, existing) {
+	if (!(base in existing)) return base;
+	let suffix = 2;
+	while (`${base}_${suffix}` in existing) suffix += 1;
+	return `${base}_${suffix}`;
+}
+/**
+* Coerce an address-parts record to `Record<string, string>`. Provider address
+* objects can carry numbers (ArcGIS `Score`/`X`/`Y`, Pelias coordinates), so
+* values are stringified rather than unsafely cast; null/undefined are dropped.
+*/
+function stringifyParts(obj) {
+	const parts = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (value === null || value === void 0) continue;
+		parts[key] = typeof value === "string" ? value : String(value);
+	}
+	return parts;
+}
+/** Read a string property off an unknown object, or undefined. */
+function readString(obj, key) {
+	if (obj && typeof obj === "object" && key in obj) {
+		const value = obj[key];
+		if (typeof value === "string") return value;
+		if (typeof value === "number") return String(value);
+	}
+}
+/** Build a Nominatim forward-geocoding URL (jsonv2, address details on). */
+function buildForwardGeocodeUrl(endpoint, query, options = {}) {
+	const url = new URL(endpoint);
+	url.searchParams.set("q", query);
+	url.searchParams.set("format", "jsonv2");
+	url.searchParams.set("addressdetails", "1");
+	url.searchParams.set("limit", String(options.limit ?? 1));
+	if (options.email) url.searchParams.set("email", options.email);
+	return url.toString();
+}
+/** Build a Nominatim reverse-geocoding URL (jsonv2, address details on). */
+function buildReverseGeocodeUrl(endpoint, lon, lat, options = {}) {
+	const url = new URL(endpoint);
+	url.searchParams.set("lat", String(lat));
+	url.searchParams.set("lon", String(lon));
+	url.searchParams.set("format", "jsonv2");
+	url.searchParams.set("addressdetails", "1");
+	if (options.zoom !== void 0) url.searchParams.set("zoom", String(options.zoom));
+	if (options.email) url.searchParams.set("email", options.email);
+	return url.toString();
+}
+/** Map one Nominatim forward result onto a normalized match, or null. */
+function nominatimForwardResultToMatch(result) {
+	const lat = Number(result.lat);
+	const lon = Number(result.lon);
+	if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+	return {
+		lat,
+		lon,
+		displayName: result.display_name ?? "",
+		score: coerceScore(result.importance)
+	};
+}
+/**
+* Convert a normalized {@link GeocodeMatch} into a point Feature whose
+* properties carry the original CSV row plus `geocode_lat`/`geocode_lon`/
+* `geocode_display_name`/`geocode_importance`. The added keys are de-duplicated
+* against the original columns so an existing `geocode_lat` is not clobbered.
+* Geometry coordinates are `[lon, lat]`. Returns null when the match has no
+* finite coordinates.
+*
+* `extra.providerId`, when passed, also stamps `geocode_provider` and
+* `geocode_status: "matched"` (dropped when omitted, so the existing
+* `GeocodeDialog` call site keeps its current output unchanged).
+* `extra.attributes` also adds the candidate's own attributes, each under
+* {@link GEOCODE_ATTRIBUTE_PREFIX} plus its name.
+*/
+function geocodeMatchToFeature(match, originalRow = {}, extra) {
+	if (!Number.isFinite(match.lat) || !Number.isFinite(match.lon)) return null;
+	const properties = { ...originalRow };
+	const added = {
+		[GEOCODE_LAT_KEY]: match.lat,
+		[GEOCODE_LON_KEY]: match.lon,
+		[GEOCODE_DISPLAY_NAME_KEY]: match.displayName ?? "",
+		[GEOCODE_SCORE_KEY]: match.score
+	};
+	if (extra?.providerId) {
+		added[GEOCODE_PROVIDER_KEY] = extra.providerId;
+		added[GEOCODE_STATUS_KEY] = "matched";
+	}
+	if (extra?.attributes) for (const [key, value] of Object.entries(match.attributes ?? {})) added[`${GEOCODE_ATTRIBUTE_PREFIX}${key}`] = value;
+	for (const [key, value] of Object.entries(added)) properties[uniqueKey(key, properties)] = value;
+	return {
+		type: "Feature",
+		geometry: {
+			type: "Point",
+			coordinates: [match.lon, match.lat]
+		},
+		properties
+	};
+}
+/**
+* Build a null-geometry Feature for a CSV row that could not be geocoded, so
+* it is kept (not silently dropped) alongside the matched point features.
+* Mirrors the null-geometry shape {@link parseDelimitedTextLayer} already uses
+* for a non-spatial attribute table. Stamps `geocode_status: "unmatched"` and
+* `geocode_provider`, de-duplicated against the original columns the same way
+* {@link geocodeMatchToFeature} does.
+*/
+function unmatchedGeocodeFeature(originalRow, providerId) {
+	const properties = { ...originalRow };
+	const added = {
+		[GEOCODE_STATUS_KEY]: "unmatched",
+		[GEOCODE_PROVIDER_KEY]: providerId
+	};
+	for (const [key, value] of Object.entries(added)) properties[uniqueKey(key, properties)] = value;
+	return {
+		type: "Feature",
+		geometry: null,
+		properties
+	};
+}
+/**
+* Convert a Nominatim forward result into a point Feature. Retained as a thin
+* wrapper over {@link geocodeMatchToFeature} for callers and tests that work
+* directly with Nominatim results. Returns null when the result has no finite
+* coordinates.
+*/
+function nominatimResultToFeature(result, originalRow = {}) {
+	const match = nominatimForwardResultToMatch(result);
+	return match ? geocodeMatchToFeature(match, originalRow) : null;
+}
+/**
+* Resolve a Nominatim reverse result to a display string and address parts, or
+* null when the point could not be reverse-geocoded.
+*/
+function nominatimReverseResultToDisplay(result) {
+	if (!result || result.error) return null;
+	const displayName = result.display_name?.trim();
+	if (!displayName) return null;
+	return {
+		displayName,
+		parts: result.address ?? {}
+	};
+}
+const nominatimProvider = {
+	id: "nominatim",
+	label: "Nominatim (OpenStreetMap)",
+	forward: true,
+	reverse: true,
+	requiresApiKey: false,
+	acceptsApiKey: false,
+	defaultForwardEndpoint: DEFAULT_FORWARD_GEOCODE_ENDPOINT,
+	defaultReverseEndpoint: DEFAULT_REVERSE_GEOCODE_ENDPOINT,
+	buildForwardUrl: (config, query, options) => buildForwardGeocodeUrl(config.forwardEndpoint, query, {
+		email: options.email,
+		limit: options.limit
+	}),
+	parseForward: (data) => Array.isArray(data) ? data.map(nominatimForwardResultToMatch).filter((m) => m !== null) : [],
+	buildReverseUrl: (config, lon, lat, options) => buildReverseGeocodeUrl(config.reverseEndpoint, lon, lat, {
+		email: options.email,
+		zoom: options.zoom
+	}),
+	parseReverse: (data) => nominatimReverseResultToDisplay(data && typeof data === "object" ? data : null)
+};
+/** Read a GeoJSON FeatureCollection's features array, or []. */
+function geojsonFeatures(data) {
+	if (data && typeof data === "object" && Array.isArray(data.features)) return data.features.filter((f) => !!f && typeof f === "object");
+	return [];
+}
+/** Pull `[lon, lat]` from a GeoJSON Point geometry, or null. */
+function pointCoords(feature) {
+	const coords = feature.geometry?.coordinates;
+	if (Array.isArray(coords) && coords.length >= 2) {
+		const lon = Number(coords[0]);
+		const lat = Number(coords[1]);
+		if (Number.isFinite(lon) && Number.isFinite(lat)) return [lon, lat];
+	}
+	return null;
+}
+const peliasProvider = {
+	id: "pelias",
+	label: "Pelias",
+	forward: true,
+	reverse: true,
+	requiresApiKey: false,
+	acceptsApiKey: true,
+	defaultForwardEndpoint: "https://api.geocode.earth/v1/search",
+	defaultReverseEndpoint: "https://api.geocode.earth/v1/reverse",
+	buildForwardUrl: (config, query, options) => {
+		const url = new URL(config.forwardEndpoint);
+		url.searchParams.set("text", query);
+		if (options.limit) url.searchParams.set("size", String(options.limit));
+		if (config.apiKey) url.searchParams.set("api_key", config.apiKey);
+		return url.toString();
+	},
+	parseForward: (data) => geojsonFeatures(data).map((feature) => {
+		const coords = pointCoords(feature);
+		if (!coords) return null;
+		const props = feature.properties ?? {};
+		return {
+			lon: coords[0],
+			lat: coords[1],
+			displayName: readString(props, "label") ?? "",
+			score: coerceScore(props.confidence)
+		};
+	}).filter((m) => m !== null),
+	buildReverseUrl: (config, lon, lat) => {
+		const url = new URL(config.reverseEndpoint);
+		url.searchParams.set("point.lat", String(lat));
+		url.searchParams.set("point.lon", String(lon));
+		if (config.apiKey) url.searchParams.set("api_key", config.apiKey);
+		return url.toString();
+	},
+	parseReverse: (data) => {
+		const feature = geojsonFeatures(data)[0];
+		if (!feature) return null;
+		const props = feature.properties ?? {};
+		const displayName = readString(props, "label")?.trim();
+		return displayName ? {
+			displayName,
+			parts: stringifyParts(props)
+		} : null;
+	}
+};
+const arcgisProvider = {
+	id: "arcgis",
+	label: "ArcGIS World Geocoder",
+	forward: true,
+	reverse: true,
+	requiresApiKey: true,
+	acceptsApiKey: true,
+	defaultForwardEndpoint: "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates",
+	defaultReverseEndpoint: "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/reverseGeocode",
+	buildForwardUrl: (config, query, options) => {
+		const url = new URL(config.forwardEndpoint);
+		url.searchParams.set("SingleLine", query);
+		url.searchParams.set("f", "json");
+		url.searchParams.set("outFields", "Match_addr");
+		if (options.limit) url.searchParams.set("maxLocations", String(options.limit));
+		if (config.apiKey) url.searchParams.set("token", config.apiKey);
+		return url.toString();
+	},
+	parseForward: parseArcGISCandidates,
+	buildReverseUrl: (config, lon, lat) => {
+		const url = new URL(config.reverseEndpoint);
+		url.searchParams.set("location", `${lon},${lat}`);
+		url.searchParams.set("f", "json");
+		if (config.apiKey) url.searchParams.set("token", config.apiKey);
+		return url.toString();
+	},
+	parseReverse: parseArcGISReverse
+};
+/** Spatial references ArcGIS reports for Web Mercator. */
+const WEB_MERCATOR_WKIDS = /* @__PURE__ */ new Set([
+	102100,
+	102113,
+	3857,
+	900913
+]);
+/** Earth radius of the Web Mercator sphere, in meters. */
+const WEB_MERCATOR_RADIUS = 6378137;
+/** The operations a pasted GeocodeServer URL may already end in. */
+const LOCATOR_OPERATION = /\/(findAddressCandidates|reverseGeocode|suggest|geocodeAddresses)$/i;
+/** The ArcGIS `error` envelope in a response body, as a {@link GeocoderServiceError}. */
+function arcgisServiceError(data) {
+	const error = data && typeof data === "object" ? data.error : void 0;
+	if (!error || typeof error !== "object") return null;
+	const code = Number(error.code);
+	return new GeocoderServiceError(readString(error, "message") ?? "ArcGIS geocoding service error", Number.isFinite(code) ? code : void 0);
+}
+/** The well-known ID of an ArcGIS `spatialReference`, preferring `latestWkid`. */
+function spatialReferenceWkid(spatialReference) {
+	if (!spatialReference || typeof spatialReference !== "object") return null;
+	const sr = spatialReference;
+	const wkid = Number(sr.latestWkid ?? sr.wkid);
+	return Number.isFinite(wkid) ? wkid : null;
+}
+/**
+* A candidate's position as longitude/latitude. Organization-hosted locators
+* often work in a projected system, and ArcGIS ignores an `outSR` it cannot
+* honor, so the reported spatial reference decides: geographic WGS 84 (or none,
+* the World Geocoder's default) is read as is, Web Mercator is unprojected, and
+* anything else is refused rather than plotted in the wrong place.
+*
+* @param x - The candidate's x coordinate.
+* @param y - The candidate's y coordinate.
+* @param wkid - The response's spatial reference, or null when it reports none.
+* @returns The position, or null when the coordinates are not finite or not on Earth.
+* @throws GeocoderServiceError When the coordinates are in an unsupported spatial reference.
+*/
+function arcgisCandidatePosition(x, y, wkid) {
+	if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+	let lon = x;
+	let lat = y;
+	if (wkid !== null && WEB_MERCATOR_WKIDS.has(wkid)) {
+		lon = x / WEB_MERCATOR_RADIUS * (180 / Math.PI);
+		lat = (2 * Math.atan(Math.exp(y / WEB_MERCATOR_RADIUS)) - Math.PI / 2) * (180 / Math.PI);
+	} else if (wkid !== null && wkid !== 4326) throw new GeocoderServiceError(`The geocoder returned coordinates in spatial reference ${wkid}, which GeoLibre cannot place on the map.`);
+	if (lon < -180 || lon > 180 || lat < -90 || lat > 90) return null;
+	return {
+		lon,
+		lat
+	};
+}
+/**
+* A candidate's attributes worth keeping: plain values that are not empty.
+* The shape and the location fields the match already carries are dropped.
+*/
+function candidateAttributes(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const kept = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (/^(shape|x|y|displayx|displayy|xmin|xmax|ymin|ymax)$/i.test(key)) continue;
+		if (typeof entry === "string" ? entry.trim() === "" : typeof entry !== "number" && typeof entry !== "boolean") continue;
+		if (typeof entry === "number" && !Number.isFinite(entry)) continue;
+		kept[key] = entry;
+	}
+	return Object.keys(kept).length ? kept : void 0;
+}
+/**
+* Normalize an ArcGIS `findAddressCandidates` response. Throws the service's
+* error envelope instead of reporting it as "no matches".
+*
+* @param data - The parsed response body.
+* @returns The candidates as normalized matches.
+*/
+function parseArcGISCandidates(data) {
+	const error = arcgisServiceError(data);
+	if (error) throw error;
+	if (!data || typeof data !== "object") return [];
+	const body = data;
+	if (!Array.isArray(body.candidates)) return [];
+	const wkid = spatialReferenceWkid(body.spatialReference);
+	return body.candidates.map((candidate) => {
+		const location = candidate.location;
+		const position = arcgisCandidatePosition(Number(location?.x), Number(location?.y), wkid);
+		if (!position) return null;
+		const attributes = candidateAttributes(candidate.attributes);
+		return {
+			...position,
+			displayName: readString(candidate, "address") ?? "",
+			score: coerceScore(candidate.score),
+			...attributes ? { attributes } : {}
+		};
+	}).filter((m) => m !== null);
+}
+/**
+* Whether an ArcGIS error envelope is the "Unable to find address" answer:
+* code 400 with that text in its message or (Enterprise) its details. Other
+* 400s, such as malformed parameters, are real failures.
+*/
+function isNoAddressError(data, error) {
+	if (error.code !== 400) return false;
+	const envelope = data.error;
+	const details = Array.isArray(envelope?.details) ? envelope.details.join(" ") : "";
+	return /unable to find address/i.test(`${error.message} ${details}`);
+}
+/**
+* Normalize an ArcGIS `reverseGeocode` response. "Unable to find address" comes
+* back as an `error` envelope with code 400, which is a valid empty answer
+* rather than a failure.
+*
+* @param data - The parsed response body.
+* @returns The address, or null when there is none.
+*/
+function parseArcGISReverse(data) {
+	const error = arcgisServiceError(data);
+	if (error && !isNoAddressError(data, error)) throw error;
+	const address = data && typeof data === "object" ? data.address : void 0;
+	if (!address || typeof address !== "object") return null;
+	const displayName = (readString(address, "LongLabel") ?? readString(address, "Match_addr") ?? readString(address, "Address"))?.trim();
+	return displayName ? {
+		displayName,
+		parts: stringifyParts(address)
+	} : null;
+}
+/**
+* The GeocodeServer base URL of a pasted locator URL: an operation suffix
+* (`/findAddressCandidates`, ...), the query string and any credentials are
+* dropped, so a token in a pasted URL is never stored.
+*
+* @param input - The URL as typed.
+* @returns The base URL ending in `/GeocodeServer`, or null when it is not one.
+*/
+function normalizeArcGISLocatorUrl(input) {
+	let url;
+	try {
+		url = new URL((input ?? "").trim());
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+	const path = url.pathname.replace(/\/+$/, "").replace(LOCATOR_OPERATION, "");
+	if (!/\/GeocodeServer$/i.test(path)) return null;
+	url.pathname = path;
+	url.search = "";
+	url.hash = "";
+	url.username = "";
+	url.password = "";
+	return url.toString();
+}
+/**
+* Coerce a stored locator to a {@link GeocodingLocator}, or null when it has no
+* usable id or GeocodeServer URL. Used for project files and runtime env, so
+* anything unexpected is dropped rather than trusted.
+*
+* @param value - The stored value.
+* @returns The locator, or null.
+*/
+function normalizeGeocodingLocator(value) {
+	if (!value || typeof value !== "object") return null;
+	const candidate = value;
+	const id = typeof candidate.id === "string" ? candidate.id.trim() : "";
+	const url = normalizeArcGISLocatorUrl(typeof candidate.url === "string" ? candidate.url : void 0);
+	if (!id || !url) return null;
+	const text = (key) => typeof candidate[key] === "string" && candidate[key].trim() ? candidate[key].trim() : void 0;
+	const flag = (key) => typeof candidate[key] === "boolean" ? candidate[key] : void 0;
+	const addressFields = Array.isArray(candidate.addressFields) ? candidate.addressFields.filter((field) => typeof field === "string" && field.trim() !== "") : void 0;
+	const locator = {
+		id,
+		name: text("name") ?? id,
+		url
+	};
+	const portalUrl = text("portalUrl");
+	if (portalUrl) locator.portalUrl = portalUrl;
+	const singleLineField = text("singleLineField");
+	if (singleLineField) locator.singleLineField = singleLineField;
+	if (addressFields?.length) locator.addressFields = addressFields;
+	const reverse = flag("reverse");
+	if (reverse !== void 0) locator.reverse = reverse;
+	const suggest = flag("suggest");
+	if (suggest !== void 0) locator.suggest = suggest;
+	const searchField = text("searchField");
+	if (searchField) locator.searchField = searchField;
+	return locator;
+}
+/**
+* Read a GeocodeServer's capabilities from its `?f=json` metadata. A service
+* that lists no `capabilities` (older ArcGIS Server) is taken to support
+* geocoding and reverse geocoding but not suggestions.
+*
+* @param data - The parsed metadata.
+* @returns The capabilities.
+* @throws GeocoderServiceError For an error envelope, or metadata that is not a
+*   GeocodeServer's.
+* @throws GeocoderUnsupportedError When the service does not geocode.
+*/
+function parseArcGISLocatorInfo(data) {
+	const error = arcgisServiceError(data);
+	if (error) throw error;
+	if (!data || typeof data !== "object") throw new GeocoderServiceError("The service did not return GeocodeServer metadata.");
+	const info = data;
+	const fieldName = (field) => field && typeof field === "object" ? readString(field, "name")?.trim() || void 0 : void 0;
+	const addressFields = Array.isArray(info.addressFields) ? info.addressFields.map(fieldName).filter((name) => !!name) : [];
+	const singleLineField = fieldName(info.singleLineAddressField);
+	if (!singleLineField && !addressFields.length) throw new GeocoderServiceError("The service did not return GeocodeServer metadata.");
+	const listed = typeof info.capabilities === "string" ? new Set(info.capabilities.split(",").map((entry) => entry.trim().toLowerCase())) : null;
+	if (listed && !listed.has("geocode")) throw new GeocoderUnsupportedError("This locator does not support geocoding.");
+	return {
+		singleLineField,
+		addressFields: addressFields.length ? addressFields : void 0,
+		reverse: listed ? listed.has("reversegeocode") : true,
+		suggest: listed ? listed.has("suggest") : false
+	};
+}
+/**
+* The input field a single search string is sent in: the published field the
+* user chose for it, else the locator's single-line field, else its only
+* structured field (an asset ID locator often publishes just one), else
+* ArcGIS's conventional `SingleLine`.
+*
+* @param locator - The locator.
+* @returns The input field name.
+*/
+function arcgisLocatorInputField(locator) {
+	const published = [locator.singleLineField, ...locator.addressFields ?? []];
+	if (locator.searchField && published.includes(locator.searchField)) return locator.searchField;
+	if (locator.singleLineField) return locator.singleLineField;
+	if (locator.addressFields?.length === 1) return locator.addressFields[0];
+	return "SingleLine";
+}
+/** The config's locator, or an error naming what is missing. */
+function requireLocator(config) {
+	if (!config.locator) throw new GeocoderUnsupportedError("No ArcGIS GeocodeServer locator is selected.");
+	return config.locator;
+}
+const arcgisLocatorProvider = {
+	id: "arcgis-locator",
+	label: "ArcGIS GeocodeServer (organization)",
+	forward: true,
+	reverse: true,
+	requiresApiKey: false,
+	acceptsApiKey: false,
+	defaultForwardEndpoint: "",
+	defaultReverseEndpoint: "",
+	buildForwardUrl: (config, query, options) => {
+		const locator = requireLocator(config);
+		const url = new URL(config.forwardEndpoint || `${locator.url}/findAddressCandidates`);
+		url.searchParams.set(arcgisLocatorInputField(locator), query);
+		url.searchParams.set("f", "json");
+		url.searchParams.set("outSR", "4326");
+		if (options.attributes) url.searchParams.set("outFields", "*");
+		if (options.magicKey) url.searchParams.set("magicKey", options.magicKey);
+		if (options.limit) url.searchParams.set("maxLocations", String(options.limit));
+		return url.toString();
+	},
+	parseForward: parseArcGISCandidates,
+	buildReverseUrl: (config, lon, lat) => {
+		const locator = requireLocator(config);
+		const url = new URL(config.reverseEndpoint || `${locator.url}/reverseGeocode`);
+		url.searchParams.set("location", JSON.stringify({
+			x: lon,
+			y: lat,
+			spatialReference: { wkid: 4326 }
+		}));
+		url.searchParams.set("outSR", "4326");
+		url.searchParams.set("f", "json");
+		return url.toString();
+	},
+	parseReverse: parseArcGISReverse
+};
+const mapboxProvider = {
+	id: "mapbox",
+	label: "Mapbox",
+	forward: true,
+	reverse: true,
+	requiresApiKey: true,
+	acceptsApiKey: true,
+	defaultForwardEndpoint: "https://api.mapbox.com/geocoding/v5/mapbox.places",
+	defaultReverseEndpoint: "https://api.mapbox.com/geocoding/v5/mapbox.places",
+	buildForwardUrl: (config, query, options) => {
+		const base = config.forwardEndpoint.replace(/\/+$/, "");
+		const url = new URL(`${base}/${encodeURIComponent(query)}.json`);
+		if (options.limit) url.searchParams.set("limit", String(options.limit));
+		if (config.apiKey) url.searchParams.set("access_token", config.apiKey);
+		return url.toString();
+	},
+	parseForward: (data) => geojsonFeatures(data).map((feature) => {
+		const center = feature.center;
+		let coords = null;
+		if (Array.isArray(center) && center.length >= 2) {
+			const lon = Number(center[0]);
+			const lat = Number(center[1]);
+			if (Number.isFinite(lon) && Number.isFinite(lat)) coords = [lon, lat];
+		}
+		coords ??= pointCoords(feature);
+		if (!coords) return null;
+		return {
+			lon: coords[0],
+			lat: coords[1],
+			displayName: readString(feature, "place_name") ?? "",
+			score: coerceScore(feature.relevance)
+		};
+	}).filter((m) => m !== null),
+	buildReverseUrl: (config, lon, lat) => {
+		const base = config.reverseEndpoint.replace(/\/+$/, "");
+		const url = new URL(`${base}/${lon},${lat}.json`);
+		if (config.apiKey) url.searchParams.set("access_token", config.apiKey);
+		return url.toString();
+	},
+	parseReverse: (data) => {
+		const feature = geojsonFeatures(data)[0];
+		if (!feature) return null;
+		const displayName = readString(feature, "place_name")?.trim();
+		return displayName ? {
+			displayName,
+			parts: stringifyParts(feature.properties ?? {})
+		} : null;
+	}
+};
+/**
+* Detect a Google Geocoding API error embedded in an HTTP 200 body. Google v3
+* returns REQUEST_DENIED / OVER_QUERY_LIMIT / INVALID_REQUEST and friends with
+* a 200 status and the failure only in the `status` field, so `response.ok`
+* alone would silently turn those into empty results. Returns null for OK and
+* ZERO_RESULTS (a successful empty match).
+*/
+function googleErrorMessage(data) {
+	const status = readString(data, "status");
+	if (!status || status === "OK" || status === "ZERO_RESULTS") return null;
+	const detail = readString(data, "error_message");
+	return detail ? `Google geocoder error: ${status} - ${detail}` : `Google geocoder error: ${status}`;
+}
+const googleProvider = {
+	id: "google",
+	label: "Google",
+	forward: true,
+	reverse: true,
+	requiresApiKey: true,
+	acceptsApiKey: true,
+	browserCorsRestricted: true,
+	defaultForwardEndpoint: "https://maps.googleapis.com/maps/api/geocode/json",
+	defaultReverseEndpoint: "https://maps.googleapis.com/maps/api/geocode/json",
+	buildForwardUrl: (config, query) => {
+		const url = new URL(config.forwardEndpoint);
+		url.searchParams.set("address", query);
+		if (config.apiKey) url.searchParams.set("key", config.apiKey);
+		return url.toString();
+	},
+	parseForward: (data) => {
+		const error = googleErrorMessage(data);
+		if (error) throw new Error(error);
+		return parseGoogleResults(data);
+	},
+	buildReverseUrl: (config, lon, lat) => {
+		const url = new URL(config.reverseEndpoint);
+		url.searchParams.set("latlng", `${lat},${lon}`);
+		if (config.apiKey) url.searchParams.set("key", config.apiKey);
+		return url.toString();
+	},
+	parseReverse: (data) => {
+		const error = googleErrorMessage(data);
+		if (error) throw new Error(error);
+		const displayName = readString((data && typeof data === "object" && Array.isArray(data.results) ? data.results : [])[0], "formatted_address")?.trim();
+		return displayName ? {
+			displayName,
+			parts: {}
+		} : null;
+	}
+};
+/** Map a Google Geocoding API `results` array onto normalized matches. */
+function parseGoogleResults(data) {
+	return (data && typeof data === "object" && Array.isArray(data.results) ? data.results : []).map((result) => {
+		const location = result.geometry?.location;
+		const lat = Number(location?.lat);
+		const lon = Number(location?.lng);
+		if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+		return {
+			lat,
+			lon,
+			displayName: readString(result, "formatted_address") ?? "",
+			score: null
+		};
+	}).filter((m) => m !== null);
+}
+/**
+* Read a CartoCiudad `lat`/`lng` field as a finite number, or null when the
+* field is absent, blank, or not numeric (`"NaN"` and `"invalid"` included).
+* Guarding the raw value matters because `Number(null)` is 0, which would turn
+* a coordinate-less response into a match in the Gulf of Guinea.
+*/
+function cartociudadCoordinate(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value !== "string" || !value.trim()) return null;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+/** Validated WGS84 position for a result, or null when it carries none. */
+function cartociudadCoords(r) {
+	const lat = cartociudadCoordinate(r.lat);
+	const lon = cartociudadCoordinate(r.lng);
+	if (lat === null || lon === null) return null;
+	if (lat < -90 || lat > 90 || lon < -180 || lon > 180) return null;
+	return {
+		lat,
+		lon
+	};
+}
+/** Default endpoints for the public CartoCiudad REST API (no auth required). */
+const CARTOCIUDAD_FORWARD_ENDPOINT = "https://www.cartociudad.es/geocoder/api/geocoder/find";
+const CARTOCIUDAD_REVERSE_ENDPOINT = "https://www.cartociudad.es/geocoder/api/geocoder/reverseGeocode";
+/**
+* Build a human-readable display name from CartoCiudad address fields.
+* Format: "Tip Via Address Num, CP Poblacion (Province)"
+*/
+function cartociudadDisplayName(r) {
+	const parts = [];
+	const streetParts = [r.tip_via, r.address].filter((s) => s && String(s).trim()).map((s) => String(s).trim());
+	if (streetParts.length) {
+		let street = streetParts.join(" ");
+		const portalNumber = r.portalNumber === void 0 || r.portalNumber === null ? "" : String(r.portalNumber).trim();
+		if (portalNumber) street += ` ${portalNumber}`;
+		parts.push(street);
+	}
+	const localityName = [r.poblacion, r.muni].find((s) => s && String(s).trim());
+	const locality = [r.postalCode, localityName].filter((s) => s && String(s).trim()).map((s) => String(s).trim()).join(" ");
+	if (locality) parts.push(locality);
+	const province = r.province ? String(r.province).trim() : "";
+	if (province) parts.push(`(${province})`);
+	return parts.join(", ") || r.address || r.poblacion || r.muni || "";
+}
+/** All selectable geocoding providers, Nominatim first (the default). */
+const GEOCODING_PROVIDERS = [
+	nominatimProvider,
+	peliasProvider,
+	arcgisProvider,
+	arcgisLocatorProvider,
+	mapboxProvider,
+	googleProvider,
+	{
+		id: "cartociudad",
+		label: "CartoCiudad (IGN España)",
+		forward: true,
+		reverse: true,
+		requiresApiKey: false,
+		acceptsApiKey: false,
+		defaultForwardEndpoint: CARTOCIUDAD_FORWARD_ENDPOINT,
+		defaultReverseEndpoint: CARTOCIUDAD_REVERSE_ENDPOINT,
+		buildForwardUrl: (config, query) => {
+			const url = new URL(config.forwardEndpoint);
+			url.searchParams.set("q", query);
+			return url.toString();
+		},
+		parseForward: (data) => {
+			if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+			const r = data;
+			const coords = cartociudadCoords(r);
+			if (!coords) return [];
+			const displayName = cartociudadDisplayName(r).trim();
+			if (!displayName) return [];
+			return [{
+				lat: coords.lat,
+				lon: coords.lon,
+				displayName,
+				score: null
+			}];
+		},
+		buildReverseUrl: (config, lon, lat) => {
+			const url = new URL(config.reverseEndpoint);
+			url.searchParams.set("lat", String(lat));
+			url.searchParams.set("lon", String(lon));
+			return url.toString();
+		},
+		parseReverse: (data) => {
+			if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+			const r = data;
+			if (!cartociudadCoords(r)) return null;
+			const displayName = cartociudadDisplayName(r).trim();
+			if (!displayName) return null;
+			const parts = {};
+			for (const [key, value] of Object.entries({
+				type: r.type,
+				tip_via: r.tip_via,
+				address: r.address,
+				portalNumber: r.portalNumber,
+				postalCode: r.postalCode,
+				poblacion: r.poblacion,
+				muni: r.muni,
+				province: r.province,
+				comunidadAutonoma: r.comunidadAutonoma,
+				refCatastral: r.refCatastral
+			})) if (value !== void 0 && value !== null && value !== "") parts[key] = String(value);
+			return {
+				displayName,
+				parts
+			};
+		}
+	}
+];
+const PROVIDERS_BY_ID = new Map(GEOCODING_PROVIDERS.map((provider) => [provider.id, provider]));
+/** Coerce an arbitrary string to a known provider id, defaulting to Nominatim. */
+function normalizeGeocodingProviderId(value) {
+	const id = value?.trim();
+	return id && PROVIDERS_BY_ID.has(id) ? id : DEFAULT_GEOCODING_PROVIDER_ID;
+}
+/** Look up a provider by id, falling back to Nominatim for unknown ids. */
+function getGeocodingProvider(id) {
+	return PROVIDERS_BY_ID.get(normalizeGeocodingProviderId(id)) ?? nominatimProvider;
+}
+/**
+* Resolve the geocoder configuration from runtime env, falling back to the
+* selected provider's default endpoints. `VITE_GEOCODER_PROVIDER` selects the
+* backend; `VITE_GEOCODER_ENDPOINT`/`VITE_GEOCODER_REVERSE_ENDPOINT` override
+* the endpoints (except for `arcgis-locator`, whose endpoints always come from
+* `VITE_GEOCODER_LOCATOR`); `VITE_GEOCODER_EMAIL` supplies the contact email; and
+* `VITE_GEOCODER_API_KEY` supplies the API key for keyed providers.
+*/
+function getGeocoderConfig() {
+	const env = getRuntimeEnvironment();
+	const provider = getGeocodingProvider(env.VITE_GEOCODER_PROVIDER);
+	let locator;
+	if (provider.id === "arcgis-locator" && env.VITE_GEOCODER_LOCATOR) try {
+		locator = normalizeGeocodingLocator(JSON.parse(env.VITE_GEOCODER_LOCATOR)) ?? void 0;
+	} catch {
+		locator = void 0;
+	}
+	const endpoints = locator ? locatorEndpoints(locator) : provider;
+	const overrides = provider.id === "arcgis-locator" ? {} : env;
+	return {
+		providerId: provider.id,
+		forwardEndpoint: overrides.VITE_GEOCODER_ENDPOINT?.trim() || endpoints.defaultForwardEndpoint,
+		reverseEndpoint: overrides.VITE_GEOCODER_REVERSE_ENDPOINT?.trim() || endpoints.defaultReverseEndpoint,
+		email: env.VITE_GEOCODER_EMAIL?.trim() || void 0,
+		apiKey: env.VITE_GEOCODER_API_KEY?.trim() || void 0,
+		...locator ? { locator } : {}
+	};
+}
+/** A locator's operation URLs, derived from its base GeocodeServer URL. */
+function locatorEndpoints(locator) {
+	return {
+		defaultForwardEndpoint: `${locator.url}/findAddressCandidates`,
+		defaultReverseEndpoint: `${locator.url}/reverseGeocode`
+	};
+}
+/**
+* The locator the `arcgis-locator` provider uses: the one `locatorId` names,
+* else the first configured.
+*
+* @param input - The geocoding preference.
+* @returns The locator, or undefined when none is configured.
+*/
+function selectedGeocodingLocator(input) {
+	const locators = input.locators ?? [];
+	return locators.find((locator) => locator.id === input.locatorId) ?? locators[0];
+}
+/**
+* Build a {@link GeocoderConfig} from structured project preferences. Used by
+* the geocode dialog so a per-run provider choice resolves the right endpoints
+* and API key without round-tripping through runtime env.
+*/
+function resolveGeocoderConfig(input) {
+	const provider = getGeocodingProvider(input.providerId);
+	if (provider.id === "arcgis-locator") {
+		const locator = selectedGeocodingLocator(input);
+		const endpoints = locator ? locatorEndpoints(locator) : provider;
+		return {
+			providerId: provider.id,
+			forwardEndpoint: endpoints.defaultForwardEndpoint,
+			reverseEndpoint: endpoints.defaultReverseEndpoint,
+			email: input.email?.trim() || void 0,
+			...locator ? { locator } : {}
+		};
+	}
+	return {
+		providerId: provider.id,
+		forwardEndpoint: input.forwardEndpoint?.trim() || provider.defaultForwardEndpoint,
+		reverseEndpoint: input.reverseEndpoint?.trim() || provider.defaultReverseEndpoint,
+		email: input.email?.trim() || void 0,
+		apiKey: input.apiKeys?.[provider.id]?.trim() || void 0
+	};
+}
+/** Hostname of `endpoint`, or null when it does not parse as a URL. */
+function geocoderHostname(endpoint) {
+	try {
+		return new URL(endpoint).hostname;
+	} catch {
+		return null;
+	}
+}
+/** Whether `hostname` is the public CartoCiudad service or a subdomain of it. */
+function isCartociudadHost(hostname) {
+	if (hostname === null) return false;
+	return hostname === "cartociudad.es" || hostname.endsWith(`.cartociudad.es`);
+}
+/**
+* Whether requests to `endpoint` must be throttled AND row-capped. True for the
+* public Nominatim host (its usage policy applies) and, defensively, for any
+* endpoint that does not parse as a URL. Every other host (a self-hosted
+* Nominatim or a keyed provider) returns false.
+*
+* Note this is the *Nominatim policy* gate, not "is this host paced at all" —
+* see {@link geocoderMinIntervalMs}, which paces CartoCiudad more gently
+* without capping its row count.
+*/
+function shouldThrottle(endpoint) {
+	const hostname = geocoderHostname(endpoint);
+	return hostname === null || hostname === "nominatim.openstreetmap.org";
+}
+/**
+* The row cap to apply for `endpoint`: a finite cap for the public Nominatim
+* host, else Infinity. CartoCiudad is uncapped — IGN publishes no row limit and
+* its own bulk address geocoder processes up to 60,000 records per run, so a
+* cap here would be an invented constraint. It is still paced; see
+* {@link geocoderMinIntervalMs}.
+*/
+function rowCap(endpoint) {
+	return shouldThrottle(endpoint) ? PUBLIC_GEOCODE_ROW_CAP : Number.POSITIVE_INFINITY;
+}
+/**
+* Minimum spacing (ms) between requests for `endpoint`. Gated on the hostname,
+* not the selected provider, so pointing any provider at the public Nominatim
+* host still honors its 1 req/sec policy.
+*
+* CartoCiudad gets a gentler pace of its own. IGN documents no rate limit for
+* the single-lookup `find`/`reverseGeocode` endpoints either way, so the honest
+* position is that unbounded bursting is unverified rather than sanctioned:
+* a large CSV run against a free public government service with zero spacing
+* risks getting the caller's IP throttled and degrading the service for
+* everyone. Nominatim's 1 req/sec is that provider's published policy and is
+* not borrowed here. Keyed providers and self-hosted endpoints are paced by
+* their own quotas, not by us.
+*/
+function geocoderMinIntervalMs(endpoint) {
+	if (shouldThrottle(endpoint)) return NOMINATIM_MIN_INTERVAL_MS;
+	return isCartociudadHost(geocoderHostname(endpoint)) ? 200 : 0;
+}
+/** Hosted Pelias service that rejects keyless requests. */
+const GEOCODE_EARTH_HOST_SUFFIX = "geocode.earth";
+/**
+* Whether `config` cannot geocode without an API key. True for the keyed
+* providers (ArcGIS, Mapbox, Google) and for Pelias only when it targets the
+* hosted geocode.earth endpoint (a self-hosted Pelias needs no key). Drives the
+* batch dialog's "missing key" warning and disabled run.
+*/
+function geocoderNeedsApiKey(config) {
+	const provider = getGeocodingProvider(config.providerId);
+	if (provider.requiresApiKey) return true;
+	if (provider.id === "pelias") try {
+		const host = new URL(config.forwardEndpoint).hostname;
+		return host === GEOCODE_EARTH_HOST_SUFFIX || host.endsWith(`.${GEOCODE_EARTH_HOST_SUFFIX}`);
+	} catch {
+		return false;
+	}
+	return false;
+}
+/**
+* Milliseconds to wait before starting the next request so consecutive
+* requests are spaced at least `intervalMs` apart, measured from the previous
+* request's start time (not its completion) so a slow network does not double
+* the wait. Returns 0 for the first request or when enough time has elapsed.
+*/
+function nextDelayMs(lastStartedAt, now, intervalMs) {
+	if (lastStartedAt === null) return 0;
+	return Math.max(0, intervalMs - (now - lastStartedAt));
+}
+/**
+* Build geocoding requests from parsed CSV rows. The address for each row is
+* the selected columns trimmed and joined with ", " (so multi-part addresses
+* like street/city/country can be combined). Rows whose composed address is
+* empty are skipped.
+*/
+function csvRowsToGeocodeRequests(rows, addressColumns) {
+	const requests = [];
+	rows.forEach((row, index) => {
+		const address = addressColumns.map((column) => (row[column] ?? "").trim()).filter(Boolean).join(", ").trim();
+		if (!address) return;
+		requests.push({
+			index,
+			address,
+			row
+		});
+	});
+	return requests;
+}
+/**
+* The fetch implementation used by {@link geocodeForward}/{@link geocodeReverse}.
+* Null means "use the global browser `fetch`" (the default for the web and
+* embedded builds).
+*/
+let geocodingFetch = null;
+/**
+* Override the fetch used for geocoding requests, or pass null to restore the
+* global browser `fetch`.
+*
+* The desktop shell sets this to Tauri's native HTTP fetch so geocoding requests
+* are made from the Rust side, which:
+*   - bypasses the WebView's CORS enforcement. Public Nominatim's CDN
+*     intermittently omits the `Access-Control-Allow-Origin` header on cached
+*     responses, which the browser then rejects — surfacing to the user as
+*     "Search failed. Try again." (the symptom that failed Microsoft Store
+*     certification); and
+*   - can send a `User-Agent` identifying the app, as Nominatim's usage policy
+*     requires (browser fetch cannot set that header).
+*
+* Safe to call multiple times; only the most recent implementation is used.
+*/
+function setGeocodingFetch(fetchImpl) {
+	geocodingFetch = fetchImpl;
+}
+let geocodingTokenProvider = null;
+/**
+* Register how a secured locator gets its token, or pass null to remove it.
+*
+* Core has no sign-in of its own: the app installs a provider that reuses its
+* ArcGIS portal sessions. It is only consulted for a locator that names a
+* `portalUrl`, and the provider decides whether that portal's token may be sent
+* to the locator's host, so a token is never forwarded to an unrelated server.
+*
+* @param provider - The token provider, or null.
+*/
+function setGeocodingTokenProvider(provider) {
+	geocodingTokenProvider = provider;
+}
+/** The token to send with a request for `config`, when its locator is secured. */
+async function locatorToken(config) {
+	const locator = config.providerId === "arcgis-locator" ? config.locator : void 0;
+	if (!locator?.portalUrl || !geocodingTokenProvider) return void 0;
+	return geocodingTokenProvider(locator);
+}
+/**
+* `url` with the locator's token added, when there is one. The token is only
+* attached to a request under the locator's own GeocodeServer URL, whatever
+* endpoint the config carries.
+*
+* @returns The URL, and whether a token was attached (such a request must not
+*   follow redirects, which could replay the token to another host).
+*/
+async function withLocatorToken(url, config) {
+	const token = await locatorToken(config);
+	if (!token) return {
+		url,
+		token: false
+	};
+	const withToken = new URL(url);
+	const base = `${config.locator?.url}/`;
+	if (!`${withToken.origin}${withToken.pathname}`.startsWith(base)) throw new GeocoderServiceError("The geocoding request does not go to the locator's own server, so its sign-in is not sent.");
+	withToken.searchParams.set("token", token);
+	return {
+		url: withToken.toString(),
+		token: true
+	};
+}
+/**
+* Whether `config` can reverse-geocode: a locator only when its metadata
+* advertises `reverseGeocode` (unchecked locators are assumed to).
+*
+* @param config - The geocoder configuration.
+* @returns Whether reverse geocoding is available.
+*/
+function geocoderSupportsReverse(config) {
+	const provider = getGeocodingProvider(config.providerId);
+	if (!provider.reverse) return false;
+	return provider.id !== "arcgis-locator" || config.locator?.reverse !== false;
+}
+/**
+* Whether `config` offers suggestions while typing: a locator whose metadata
+* advertises `suggest`, searched through its single-line field (a suggestion
+* is a whole address, so it does not fit a structured field the user chose).
+*
+* @param config - The geocoder configuration.
+* @returns Whether {@link geocodeSuggest} can be used.
+*/
+function geocoderSupportsSuggest(config) {
+	const locator = config.providerId === "arcgis-locator" ? config.locator : void 0;
+	if (!locator?.suggest || !locator.singleLineField) return false;
+	return arcgisLocatorInputField(locator) === locator.singleLineField;
+}
+/**
+* Normalize an ArcGIS `suggest` response. Collection suggestions (a category
+* such as "Coffee shop") are dropped: they name many places, not one.
+*
+* @param data - The parsed response body.
+* @returns The suggestions.
+*/
+function parseArcGISSuggestions(data) {
+	const error = arcgisServiceError(data);
+	if (error) throw error;
+	const suggestions = data && typeof data === "object" ? data.suggestions : void 0;
+	if (!Array.isArray(suggestions)) return [];
+	return suggestions.flatMap((entry) => {
+		const text = readString(entry, "text")?.trim();
+		const magicKey = readString(entry, "magicKey");
+		const collection = entry?.isCollection === true;
+		return text && magicKey && !collection ? [{
+			text,
+			magicKey
+		}] : [];
+	});
+}
+/**
+* Ask the selected locator for suggestions that complete `text`. Resolve one
+* with {@link geocodeForward} and its `magicKey`.
+*
+* @param text - What the user has typed so far.
+* @param options - Abort signal, configuration and the most suggestions wanted.
+* @returns The suggestions.
+* @throws GeocoderUnsupportedError When the geocoder does not suggest.
+* @throws GeocoderServiceError For an HTTP or service error.
+*/
+async function geocodeSuggest(text, options = {}) {
+	const config = options.config ?? getGeocoderConfig();
+	if (!geocoderSupportsSuggest(config)) throw new GeocoderUnsupportedError("The selected geocoder does not offer suggestions.");
+	const url = new URL(`${requireLocator(config).url}/suggest`);
+	url.searchParams.set("text", text);
+	url.searchParams.set("f", "json");
+	if (options.limit) url.searchParams.set("maxSuggestions", String(options.limit));
+	const request = await withLocatorToken(url.toString(), config);
+	const response = await geocodeFetch()(request.url, {
+		signal: options.signal,
+		headers: { Accept: "application/json" },
+		...request.token ? { redirect: "error" } : {}
+	});
+	if (!response.ok) throw new GeocoderServiceError(`Geocoder returned HTTP ${response.status}`, response.status);
+	return parseArcGISSuggestions(await readGeocodeJson(response));
+}
+/**
+* Fetch and read a GeocodeServer's capabilities. A secured service is asked
+* with `token`.
+*
+* @param url - The locator's GeocodeServer URL (normalized first).
+* @param options - An abort signal and an optional token.
+* @returns The capabilities.
+* @throws GeocoderServiceError For an HTTP or service error.
+*/
+async function fetchArcGISLocatorInfo(url, options = {}) {
+	const base = normalizeArcGISLocatorUrl(url);
+	if (!base) throw new GeocoderServiceError("Not an ArcGIS GeocodeServer URL.");
+	const request = new URL(base);
+	request.searchParams.set("f", "json");
+	if (options.token) request.searchParams.set("token", options.token);
+	const response = await geocodeFetch()(request.toString(), {
+		signal: options.signal,
+		headers: { Accept: "application/json" },
+		...options.token ? { redirect: "error" } : {}
+	});
+	if (!response.ok) throw new GeocoderServiceError(`Geocoder returned HTTP ${response.status}`, response.status);
+	return parseArcGISLocatorInfo(await readGeocodeJson(response));
+}
+/** The active geocoding fetch: the injected override, else the global fetch. */
+function geocodeFetch() {
+	return geocodingFetch ?? fetch;
+}
+/**
+* Read a geocoder response body as JSON, treating an empty one as "no results".
+*
+* CartoCiudad answers an unmatched query with HTTP 204 and an empty body rather
+* than a JSON null (verified against the live `find` and `reverseGeocode`
+* endpoints). `response.ok` is true for 204, so parsing unconditionally would
+* throw a JSON syntax error and surface a nonsense address as "Search failed"
+* instead of "no match". Returning undefined lets each provider's parser report
+* no results the way it already does for a null body.
+*/
+async function readGeocodeJson(response) {
+	if (response.status === 204) return void 0;
+	const text = await response.text();
+	if (!text.trim()) return void 0;
+	return JSON.parse(text);
+}
+/**
+* Normalize a longitude into [-180, 180], or null when it is not finite.
+*
+* MapLibre reports `lngLat.lng` unwrapped once the map is zoomed out far enough
+* to show repeated world copies, so a click on a non-primary copy arrives as
+* e.g. 210 rather than -150. Rejecting those outright would silently drop a
+* legitimate reverse-geocode click for every provider, so wrap instead.
+*
+* An in-range longitude returns untouched: the modulo round-trip is not exact
+* in floating point (-3.7 comes back as -3.7000000000000455), and the common
+* case should not be perturbed to handle the rare one.
+*/
+function wrapLongitude(lon) {
+	if (!Number.isFinite(lon)) return null;
+	if (lon >= -180 && lon <= 180) return lon;
+	return ((lon + 180) % 360 + 360) % 360 - 180;
+}
+/**
+* Forward-geocode a single query through the configured provider, returning
+* normalized matches.
+*/
+async function geocodeForward(query, options = {}) {
+	const config = options.config ?? getGeocoderConfig();
+	const provider = getGeocodingProvider(config.providerId);
+	const request = await withLocatorToken(provider.buildForwardUrl(config, query, {
+		email: config.email,
+		limit: options.limit,
+		magicKey: options.magicKey,
+		attributes: options.attributes
+	}), config);
+	const response = await geocodeFetch()(request.url, {
+		signal: options.signal,
+		headers: { Accept: "application/json" },
+		...request.token ? { redirect: "error" } : {}
+	});
+	if (!response.ok) throw new GeocoderServiceError(`Geocoder returned HTTP ${response.status}`, response.status);
+	const data = await readGeocodeJson(response);
+	return provider.parseForward(data);
+}
+/**
+* Reverse-geocode a single point ([lon, lat]) through the configured provider,
+* returning a normalized display result or null when no address was found.
+*/
+async function geocodeReverse(lon, lat, options = {}) {
+	const wrappedLon = wrapLongitude(lon);
+	if (wrappedLon === null || !Number.isFinite(lat) || lat < -90 || lat > 90) return null;
+	const config = options.config ?? getGeocoderConfig();
+	const provider = getGeocodingProvider(config.providerId);
+	if (!geocoderSupportsReverse(config)) throw new GeocoderUnsupportedError("The selected geocoder does not support reverse geocoding.");
+	const request = await withLocatorToken(provider.buildReverseUrl(config, wrappedLon, lat, {
+		email: config.email,
+		zoom: options.zoom
+	}), config);
+	const response = await geocodeFetch()(request.url, {
+		signal: options.signal,
+		headers: { Accept: "application/json" },
+		...request.token ? { redirect: "error" } : {}
+	});
+	if (!response.ok) throw new GeocoderServiceError(`Geocoder returned HTTP ${response.status}`, response.status);
+	const data = await readGeocodeJson(response);
+	return provider.parseReverse(data);
+}
+//#endregion
 //#region src/project.ts
 /** Placeholder name a project carries before the user names it. */
 const DEFAULT_PROJECT_NAME = "Untitled Project";
@@ -6276,6 +8523,7 @@ function normalizeStoryChapter(chapter) {
 		},
 		mapAnimation: STORY_ANIMATIONS.has(candidate.mapAnimation) ? candidate.mapAnimation : "flyTo",
 		rotateAnimation: normalizeBoolean(candidate.rotateAnimation, false),
+		...typeof candidate.durationSeconds === "number" && Number.isFinite(candidate.durationSeconds) ? { durationSeconds: normalizeStoryChapterDurationSeconds(candidate.durationSeconds) } : {},
 		onChapterEnter: normalizeOpacityChanges(candidate.onChapterEnter),
 		onChapterExit: normalizeOpacityChanges(candidate.onChapterExit)
 	};
@@ -6891,6 +9139,7 @@ function normalizeProjectPreferences(preferences) {
 			mapboxStyleUrl: normalizeString(map.mapboxStyleUrl) || void 0,
 			arcgisBasemap: normalizeString(map.arcgisBasemap) || void 0,
 			arcgisWkid: normalizeArcgisWkid(map.arcgisWkid),
+			mapCrs: normalizeMapCrs(map.mapCrs),
 			cesiumBasemap: normalizeCesiumBasemap(map.cesiumBasemap),
 			terrainEnabled: normalizeBoolean(map.terrainEnabled, DEFAULT_PROJECT_PREFERENCES.map.terrainEnabled),
 			terrainIonAssetId: parseCesiumIonAssetId(map.terrainIonAssetId) ?? void 0,
@@ -6930,9 +9179,29 @@ function normalizeGeocodingPreferences(geocoding) {
 		apiKeys,
 		forwardEndpoint: typeof candidate.forwardEndpoint === "string" && candidate.forwardEndpoint.trim() ? candidate.forwardEndpoint.trim() : void 0,
 		reverseEndpoint: typeof candidate.reverseEndpoint === "string" && candidate.reverseEndpoint.trim() ? candidate.reverseEndpoint.trim() : void 0,
-		email: typeof candidate.email === "string" && candidate.email.trim() ? candidate.email.trim() : void 0
+		email: typeof candidate.email === "string" && candidate.email.trim() ? candidate.email.trim() : void 0,
+		...normalizeGeocodingLocators(candidate.locators, candidate.locatorId)
 	};
 }
+/**
+* The project's ArcGIS GeocodeServer locators, dropping malformed entries and
+* duplicate ids, plus the selected locator id when it still names one. Both are
+* omitted when there are none, so older projects round-trip unchanged.
+*/
+function normalizeGeocodingLocators(locators, locatorId) {
+	if (!Array.isArray(locators)) return {};
+	const seen = /* @__PURE__ */ new Set();
+	const result = locators.map(normalizeGeocodingLocator).filter((locator) => {
+		if (!locator || seen.has(locator.id)) return false;
+		seen.add(locator.id);
+		return true;
+	});
+	if (!result.length) return {};
+	return typeof locatorId === "string" && seen.has(locatorId) ? {
+		locators: result,
+		locatorId
+	} : { locators: result };
+}
 /** Coerce an unknown value to a supported scale unit, defaulting to metric. */
 function normalizeScaleUnit(value) {
 	return value === "imperial" || value === "nautical" ? value : "metric";
@@ -7073,6 +9342,11 @@ function withoutZarrHeaders(layer) {
 		source
 	};
 }
+function withoutRuntimeGeoArrow(layer) {
+	if (layer.geoarrow === void 0) return layer;
+	const { geoarrow: _geoarrow, ...rest } = layer;
+	return rest;
+}
 /**
 * Strip the session-only state every serializer must leave out, whether or not
 * the project came through `projectFromStore`.
@@ -7081,11 +9355,11 @@ function withoutZarrHeaders(layer) {
 * @returns The layer as it may be written to a project file.
 */
 function portableLayer(layer) {
-	return withoutZarrHeaders(withoutLocalRasterBytes(layer));
+	return withoutRuntimeGeoArrow(withoutZarrHeaders(withoutLocalRasterBytes(layer)));
 }
 function normalizeLayer(layer) {
-	layer = withoutLocalRasterBytes(layer);
-	const { capabilities: rawCapabilities, filterExpression: rawFilterExpression, descriptiveMetadata: rawDescriptiveMetadata, ...rest } = layer;
+	layer = withRasterSourceDefaults(withoutLocalRasterBytes(layer));
+	const { capabilities: rawCapabilities, filterExpression: rawFilterExpression, descriptiveMetadata: rawDescriptiveMetadata, geoarrow: _rawGeoarrow, ...rest } = layer;
 	const capabilities = normalizeLayerCapabilities(rawCapabilities);
 	const descriptiveMetadata = normalizeLayerDescriptiveMetadata(rawDescriptiveMetadata);
 	const filterExpression = Array.isArray(rawFilterExpression) && rawFilterExpression.length > 0 && validateMapExpression(JSON.stringify(rawFilterExpression), { expectedType: "boolean" }).ok ? rawFilterExpression : void 0;
@@ -7387,6 +9661,7 @@ function portableWmsTileUrl(tile) {
 * @returns A new layer record ready for the store.
 */
 function hydrateProjectLayer(project, layer) {
+	layer = withRasterSourceDefaults(layer);
 	const topLevel = project.styles?.[layer.id];
 	return {
 		...layer,
@@ -8135,6 +10410,6 @@ function metadataRank(path) {
 	return 2;
 }
 //#endregion
-export { isHeaderReferenceOnly as $, geoJSONToPolylineStr as $n, MAX_DASHBOARD_COLUMNS as $r, layerGroupSortability as $t, normalizeSecondaryMapViews as A, metadataDateToRfc3339 as An, getActiveEllipsoid as Ar, normalizeStyleLibraryEntries as At, storyMapHasContent as B, isStyleSpecColor as Bn, DEFAULT_BASEMAP as Br, scrubPrintLayoutForRemovedLayers as Bt, normalizeModelGraph as C, stripVirtualFieldColumns as Cn, PLANETARY_BASEMAP_GROUPS as Cr, RAMP_STYLE_KEYS as Ct, normalizeProcessingHistory as D, isValidMetadataDate as Dn, earthAreaToBody as Dr, createStyleLibraryEntryId as Dt, normalizePrimaryRenderer as E, buildLayerStacItem as En, bodyLengthToEarth as Er, SYMBOL_STYLE_KEYS as Et, projectFromStore as F, EXPRESSION_FUNCTION_CATEGORIES as Fn, getPlanetaryBasemapByStyleUrl as Fr, createDefaultPrintLayout as Ft, isCredentialUrlParam as G, SELECTION_MODES as Gn, DEFAULT_MAP_GRID_LAYOUT as Gr, DEFAULT_LAYER_GROUP_OPACITY as Gt, PROJECT_CREDENTIAL_FIELDS as H, removeTrailingJsonCommas as Hn, DEFAULT_DASHBOARD_COLUMNS as Hr, scrubCommentsForRemovedLayers as Ht, resolveMapGrid as I, compileFeatureExpression as In, meanRadiusMeters as Ir, isDefaultPrintLayout as It, redactProjectCredentials as J, invertSelection as Jn, DEFAULT_STORY_MAP as Jr, buildLayerTree as Jt, redactConfigurationCredentials as K, applySelectionMode as Kn, DEFAULT_PRIMARY_RENDERER as Kr, applyGroupEffects as Kt, serializeProject as L, evaluateMapExpression as Ln, setActiveEllipsoidId as Lr, normalizePrintLayoutConfig as Lt, normalizeWidgets as M, parseMetadataKeywords as Mn, getActiveSemiMajorAxisMeters as Mr, sanitizeLayerStylePatch as Mt, parseProject as N, stacAssetMediaType as Nn, getEllipsoid as Nr, serializeStyleLibrary as Nt, normalizeProjectComments as O, isValidMetadataEmail as On, earthLengthToBody as Or, extractStyleLibraryStyle as Ot, portableWmsTileUrl as P, validateLayerDescriptiveMetadata as Pn, getPlanetaryBasemapById as Pr, DEFAULT_PRINT_LAYOUT as Pt, hasHeaderReferences as Q, encodePolyline as Qn, LAYER_TYPES as Qr, layerGroupMoveability as Qt, serializeProjectWithLayerCache as R, formatExpressionPreviewValue as Rn, BLANK_BASEMAP as Rr, printLayoutConfigsEqual as Rt, normalizeMapViewState as S, applyLayerVirtualFields as Sn, PLANETARY_BASEMAPS as Sr, BUILT_IN_STYLE_PRESETS as St, normalizeObiaWorkbench as T, STAC_VERSION as Tn, PLANET_SWITCHER_OPTIONS as Tr, STYLE_LIBRARY_BUNDLE_VERSION as Tt, PUBLISHABLE_PLUGIN_SETTINGS as U, substituteExpressionVariables as Un, DEFAULT_LAYER_STYLE as Ur, scrubLegendForRemovedLayers as Ut, MAX_REDACT_DEPTH as V, matchFeaturesByExpression as Vn, DEFAULT_BLEND_MODE as Vr, removedLayerIdSet as Vt, isCredentialFieldName as W, validateMapExpression as Wn, DEFAULT_LEGEND_CONFIG as Wr, scrubWidgetsForRemovedLayers as Wt, setRegistryPublishableSettings as X, decodePolyline as Xn, DUCKDB_VECTOR_ROUTE_BYTES as Xr, groupMemberIndices as Xt, redactUrlCredentials as Y, batchDecodePolylines as Yn, DUCKDB_VECTOR_FEATURE_WARN_COUNT as Yr, effectiveLayerRenderState as Yt, allowsCredentialHeaders as Z, decodePolylineDetailed as Zn, LARGE_VECTOR_FEATURE_THRESHOLD as Zr, layerGroupDepth as Zt, normalizeBookmarkGroups as _, cascadeLayerJoinRefresh as _n, getRegionalBasemapByStyleUrl as _r, CZML_SOURCE_KIND as _t, DEFAULT_PROJECT_NAME as a, PROJECT_VERSION as ai, ROLE_PRIVILEGES as an, ARCGIS_PROJECTION_PRESETS as ar, CESIUM_OSM_BUILDINGS_ASSET_ID as at, normalizeLegendConfig as b, reapplyLayerJoins as bn, EARTH_MEAN_RADIUS_METERS as br, isCzmlLayer as bt, createDefaultMapView as c, detectNonGeographicCoordinates as ci, hasAppPrivilege as cn, availableCesiumBasemap as cr, createCesiumIonLayer as ct, createProjectTemplate as d, styleValue as di, normalizeAppPrivileges as dn, sameCesiumImagery as dr, parseCesiumIonAssetId as dt, MAX_MAP_GRID_DIM as ei, layerPanelGroupHeaders as en, polylineStrToGeoJSON as er, resolveHeaderReferences as et, detachProjectCopy as f, normalizeLayerCapabilities as fn, CHINA_BASEMAPS as fr, CESIUM_KML_SOURCE_KIND as ft, normalizeBlankBackgroundColor as g, applyLayerJoins as gn, getRegionalBasemapById as gr, CZML_QUICK_PICKS as gt, isSessionOnlyLayer as h, applyJoinsToLayer as hn, REGIONAL_BASEMAP_SENTINEL_PREFIX as hr, isCesiumKmlLayer as ht, previewValue as i, OPENFREEMAP_BASEMAPS as ii, ALL_APP_PRIVILEGES as in, transformGeojsonElevation as ir, CESIUM_ION_SOURCE_KIND as it, normalizeStoryMap as j, normalizeLayerDescriptiveMetadata as jn, getActiveMeanRadiusMeters as jr, parseStyleLibrary as jt, normalizeProjectInteraction as k, isValidMetadataUrl as kn, getActiveBodyRadiusRatio as kr, isStyleLibraryTargetLayer as kt, createEmptyProject as l, isDuckDBQueryLayer as li, inferLayerCapabilities as ln, basemapToCesiumImagery as lr, isCesiumIonLayer as lt, isAllowedPluginManifestUrl as m, resolveRolePrivileges as mn, REGIONAL_BASEMAP_GROUPS as mr, createCesiumKmlLayer as mt, diffProjects as n, MIN_DASHBOARD_COLUMNS as ni, reorderLayerGroupInPanel as nn, geojsonHasZCoordinates as nr, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID as nt, MAX_PROJECT_BOOKMARKS as o, PROTOMAPS_BASEMAPS as oi, appPrivilegeReason as on, normalizeArcgisWkid as or, cesiumIonAssetId as ot, hydrateProjectLayer as p, resolveLayerCapabilities as pn, REGIONAL_BASEMAPS as pr, cesiumKmlSource as pt, redactCredentials as q, featureSelectionId as qn, DEFAULT_PROJECT_PREFERENCES as qr, buildLayerPanelUnits as qt, jsonValuesEqual as r, NETCDF_IMAGE_SOURCE_KIND as ri, sortLayerGroupInPanel as rn, horizontalBbox as rr, CESIUM_ION_QUICK_PICKS as rt, applyProjectToStore as s, SQL_QUERY_SOURCE_KIND as si, createDefaultAppCapabilities as sn, CESIUM_BASEMAPS as sr, cesiumIonAssetKind as st, diffFeatureCollections as t, MAX_PROCESSING_HISTORY as ti, normalizeGroupContiguity as tn, unescapePolyline as tr, CESIUM_BING_AERIAL_ASSET_ID as tt, createProjectLayerSerializationCache as u, shouldUseTiledRendering as ui, intersectPrivileges as un, normalizeCesiumBasemap as ur, isCesiumOnlyLayer as ut, normalizeBookmarks as v, collectTransitiveJoinSourceIds as vn, isRegionalBasemapSentinel as vr, createCzmlLayer as vt, normalizeModels as w, STAC_PROCESSING_EXTENSION as wn, PLANETARY_BASEMAP_SENTINEL_PREFIX as wr, STYLE_LIBRARY_BUNDLE_TYPE as wt, normalizeMapLayout as x, stripJoinFields as xn, ELLIPSOIDS as xr, parseCzml as xt, normalizeDashboardColumns as y, layerJoinKey as yn, DEFAULT_ELLIPSOID_ID as yr, czmlSource as yt, serializeProjectWithLayerCacheAsync as z, inferFieldTypes as zn, BLEND_MODES as zr, scrubPrintLayoutForLayers as zt };
+export { GEOCODING_PROVIDERS as $, getPlanetaryBasemapByStyleUrl as $i, groupMemberIndices as $n, getBuildEnvironment as $r, CESIUM_BING_AERIAL_ASSET_ID as $t, normalizeSecondaryMapViews as A, CHINA_BASEMAPS as Ai, createStyleLibraryEntryId as An, isValidMetadataDate as Ar, selectedGeocodingLocator as At, storyMapHasContent as B, PLANETARY_BASEMAPS as Bi, normalizePrintLayoutConfig as Bn, evaluateMapExpression as Br, PROJECT_CREDENTIAL_FIELDS as Bt, normalizeModelGraph as C, PROJECT_VERSION as Ca, ARCGIS_PROJECTION_PRESETS as Ci, isGeoArrowBatch as Cn, reapplyLayerJoins as Cr, normalizeArcGISLocatorUrl as Ct, normalizeProcessingHistory as D, isDuckDBQueryLayer as Da, basemapToCesiumImagery as Di, STYLE_LIBRARY_BUNDLE_TYPE as Dn, STAC_PROCESSING_EXTENSION as Dr, parseArcGISSuggestions as Dt, normalizePrimaryRenderer as E, detectNonGeographicCoordinates as Ea, availableCesiumBasemap as Ei, RAMP_STYLE_KEYS as En, stripVirtualFieldColumns as Er, parseArcGISLocatorInfo as Et, projectFromStore as F, getRegionalBasemapByStyleUrl as Fi, sanitizeLayerStylePatch as Fn, parseMetadataKeywords as Fr, DEFAULT_STORY_CHAPTER_DURATION_SECONDS as Ft, DEFAULT_REVERSE_GEOCODE_ENDPOINT as G, earthAreaToBody as Gi, scrubCommentsForRemovedLayers as Gn, removeTrailingJsonCommas as Gr, redactCredentials as Gt, CARTOCIUDAD_PUBLIC_HOST as H, PLANETARY_BASEMAP_SENTINEL_PREFIX as Hi, scrubPrintLayoutForLayers as Hn, inferFieldTypes as Hr, isCredentialFieldName as Ht, resolveMapGrid as I, isRegionalBasemapSentinel as Ii, serializeStyleLibrary as In, stacAssetMediaType as Ir, MAX_STORY_CHAPTER_DURATION_SECONDS as It, GEOCODE_LAT_KEY as J, getActiveEllipsoid as Ji, DEFAULT_LAYER_GROUP_OPACITY as Jn, SELECTION_MODES as Jr, setRegistryPublishableSettings as Jt, GEOCODE_ATTRIBUTE_PREFIX as K, earthLengthToBody as Ki, scrubLegendForRemovedLayers as Kn, substituteExpressionVariables as Kr, redactProjectCredentials as Kt, serializeProject as L, DEFAULT_ELLIPSOID_ID as Li, DEFAULT_PRINT_LAYOUT as Ln, validateLayerDescriptiveMetadata as Lr, MIN_STORY_CHAPTER_DURATION_SECONDS as Lt, normalizeWidgets as M, REGIONAL_BASEMAP_GROUPS as Mi, isStyleLibraryTargetLayer as Mn, isValidMetadataUrl as Mr, setGeocodingTokenProvider as Mt, parseProject as N, REGIONAL_BASEMAP_SENTINEL_PREFIX as Ni, normalizeStyleLibraryEntries as Nn, metadataDateToRfc3339 as Nr, shouldThrottle as Nt, normalizeProjectComments as O, shouldUseTiledRendering as Oa, normalizeCesiumBasemap as Oi, STYLE_LIBRARY_BUNDLE_VERSION as On, STAC_VERSION as Or, resolveGeocoderConfig as Ot, portableWmsTileUrl as P, getRegionalBasemapById as Pi, parseStyleLibrary as Pn, normalizeLayerDescriptiveMetadata as Pr, unmatchedGeocodeFeature as Pt, GEOCODE_STATUS_KEY as Q, getPlanetaryBasemapById as Qi, effectiveLayerRenderState as Qn, getArcgisApiKey as Qr, resolveHeaderReferences as Qt, serializeProjectWithLayerCache as R, EARTH_MEAN_RADIUS_METERS as Ri, createDefaultPrintLayout as Rn, EXPRESSION_FUNCTION_CATEGORIES as Rr, normalizeStoryChapterDurationSeconds as Rt, normalizeMapViewState as S, OPENFREEMAP_BASEMAPS as Sa, parseMapCrsEpsgCode as Si, geoArrowToFeatureCollection as Sn, layerJoinKey as Sr, nominatimReverseResultToDisplay as St, normalizeObiaWorkbench as T, SQL_QUERY_SOURCE_KIND as Ta, CESIUM_BASEMAPS as Ti, BUILT_IN_STYLE_PRESETS as Tn, applyLayerVirtualFields as Tr, normalizeGeocodingProviderId as Tt, DEFAULT_FORWARD_GEOCODE_ENDPOINT as U, PLANET_SWITCHER_OPTIONS as Ui, scrubPrintLayoutForRemovedLayers as Un, isStyleSpecColor as Ur, isCredentialUrlParam as Ut, CARTOCIUDAD_MIN_INTERVAL_MS as V, PLANETARY_BASEMAP_GROUPS as Vi, printLayoutConfigsEqual as Vn, formatExpressionPreviewValue as Vr, PUBLISHABLE_PLUGIN_SETTINGS as Vt, DEFAULT_GEOCODING_PROVIDER_ID as W, bodyLengthToEarth as Wi, removedLayerIdSet as Wn, matchFeaturesByExpression as Wr, redactConfigurationCredentials as Wt, GEOCODE_PROVIDER_KEY as X, getActiveSemiMajorAxisMeters as Xi, buildLayerPanelUnits as Xn, featureSelectionId as Xr, hasHeaderReferences as Xt, GEOCODE_LON_KEY as Y, getActiveMeanRadiusMeters as Yi, applyGroupEffects as Yn, applySelectionMode as Yr, allowsCredentialHeaders as Yt, GEOCODE_SCORE_KEY as Z, getEllipsoid as Zi, buildLayerTree as Zn, invertSelection as Zr, isHeaderReferenceOnly as Zt, normalizeBookmarkGroups as _, MAX_DASHBOARD_COLUMNS as _a, MAP_CRS_PRESETS as _i, czmlSource as _n, resolveRolePrivileges as _r, geocoderSupportsSuggest as _t, DEFAULT_PROJECT_NAME as a, DEFAULT_BLEND_MODE as aa, getRuntimeEnvironment as ai, cesiumIonAssetKind as an, reorderLayerGroupInPanel as ar, arcgisLocatorInputField as at, normalizeLegendConfig as b, MIN_DASHBOARD_COLUMNS as ba, getMapCrsPreset as bi, computeGeoArrowBBox as bn, cascadeLayerJoinRefresh as br, nextDelayMs as bt, createDefaultMapView as c, DEFAULT_LEGEND_CONFIG as ca, decodePolyline as ci, isCesiumOnlyLayer as cn, ROLE_PRIVILEGES as cr, csvRowsToGeocodeRequests as ct, createProjectTemplate as d, DEFAULT_PROJECT_PREFERENCES as da, geoJSONToPolylineStr as di, cesiumKmlSource as dn, hasAppPrivilege as dr, geocodeMatchToFeature as dt, meanRadiusMeters as ea, getCesiumIonToken as ei, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID as en, layerGroupDepth as er, GeocoderServiceError as et, detachProjectCopy as f, DEFAULT_STORY_MAP as fa, polylineStrToGeoJSON as fi, createCesiumKmlLayer as fn, inferLayerCapabilities as fr, geocodeReverse as ft, normalizeBlankBackgroundColor as g, LAYER_TYPES as ga, transformGeojsonElevation as gi, createCzmlLayer as gn, resolveLayerCapabilities as gr, geocoderSupportsReverse as gt, isSessionOnlyLayer as h, LARGE_VECTOR_FEATURE_THRESHOLD as ha, horizontalBbox as hi, CZML_SOURCE_KIND as hn, normalizeLayerCapabilities as hr, geocoderNeedsApiKey as ht, previewValue as i, DEFAULT_BASEMAP as ia, getProtomapsStyleUrl as ii, cesiumIonAssetId as in, normalizeGroupContiguity as ir, PUBLIC_GEOCODE_ROW_CAP as it, normalizeStoryMap as j, REGIONAL_BASEMAPS as ji, extractStyleLibraryStyle as jn, isValidMetadataEmail as jr, setGeocodingFetch as jt, normalizeProjectInteraction as k, styleValue as ka, sameCesiumImagery as ki, SYMBOL_STYLE_KEYS as kn, buildLayerStacItem as kr, rowCap as kt, createEmptyProject as l, DEFAULT_MAP_GRID_LAYOUT as la, decodePolylineDetailed as li, parseCesiumIonAssetId as ln, appPrivilegeReason as lr, fetchArcGISLocatorInfo as lt, isAllowedPluginManifestUrl as m, DUCKDB_VECTOR_ROUTE_BYTES as ma, geojsonHasZCoordinates as mi, CZML_QUICK_PICKS as mn, normalizeAppPrivileges as mr, geocoderMinIntervalMs as mt, diffProjects as n, BLANK_BASEMAP as na, getMapboxAccessToken as ni, CESIUM_ION_SOURCE_KIND as nn, layerGroupSortability as nr, NOMINATIM_MIN_INTERVAL_MS as nt, MAX_PROJECT_BOOKMARKS as o, DEFAULT_DASHBOARD_COLUMNS as oa, getSpatialExtensionPath as oi, createCesiumIonLayer as on, sortLayerGroupInPanel as or, buildForwardGeocodeUrl as ot, hydrateProjectLayer as p, DUCKDB_VECTOR_FEATURE_WARN_COUNT as pa, unescapePolyline as pi, isCesiumKmlLayer as pn, intersectPrivileges as pr, geocodeSuggest as pt, GEOCODE_DISPLAY_NAME_KEY as q, getActiveBodyRadiusRatio as qi, scrubWidgetsForRemovedLayers as qn, validateMapExpression as qr, redactUrlCredentials as qt, jsonValuesEqual as r, BLEND_MODES as ra, getProtomapsApiKey as ri, CESIUM_OSM_BUILDINGS_ASSET_ID as rn, layerPanelGroupHeaders as rr, NOMINATIM_PUBLIC_HOST as rt, applyProjectToStore as s, DEFAULT_LAYER_STYLE as sa, batchDecodePolylines as si, isCesiumIonLayer as sn, ALL_APP_PRIVILEGES as sr, buildReverseGeocodeUrl as st, diffFeatureCollections as t, setActiveEllipsoidId as ta, getGoogleMapsApiKey as ti, CESIUM_ION_QUICK_PICKS as tn, layerGroupMoveability as tr, GeocoderUnsupportedError as tt, createProjectLayerSerializationCache as u, DEFAULT_PRIMARY_RENDERER as ua, encodePolyline as ui, CESIUM_KML_SOURCE_KIND as un, createDefaultAppCapabilities as ur, geocodeForward as ut, normalizeBookmarks as v, MAX_MAP_GRID_DIM as va, adaptBboxTemplateToCrs as vi, isCzmlLayer as vn, applyJoinsToLayer as vr, getGeocoderConfig as vt, normalizeModels as w, PROTOMAPS_BASEMAPS as wa, normalizeArcgisWkid as wi, withRasterSourceDefaults as wn, stripJoinFields as wr, normalizeGeocodingLocator as wt, normalizeMapLayout as x, NETCDF_IMAGE_SOURCE_KIND as xa, normalizeMapCrs as xi, featureCollectionToGeoArrow as xn, collectTransitiveJoinSourceIds as xr, nominatimResultToFeature as xt, normalizeDashboardColumns as y, MAX_PROCESSING_HISTORY as ya, deriveTileMatrixSet as yi, parseCzml as yn, applyLayerJoins as yr, getGeocodingProvider as yt, serializeProjectWithLayerCacheAsync as z, ELLIPSOIDS as zi, isDefaultPrintLayout as zn, compileFeatureExpression as zr, MAX_REDACT_DEPTH as zt };
 
-//# sourceMappingURL=project-diff-Bua7fBME.mjs.map
+//# sourceMappingURL=project-diff-CPb5ZXb_.mjs.map