@geolibre/core 3.2.0 → 3.3.0

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { Color, createExpression, featureFilter, latest, normalizePropertyExpression } from "@maplibre/maplibre-gl-style-spec";
+import { A as unescapePolyline, B as PLANET_SWITCHER_OPTIONS, C as invertSelection, D as encodePolyline, E as decodePolylineDetailed, F as EARTH_MEAN_RADIUS_METERS, G as getActiveEllipsoid, H as earthAreaToBody, I as ELLIPSOIDS, J as getEllipsoid, K as getActiveMeanRadiusMeters, L as PLANETARY_BASEMAPS, M as horizontalBbox, N as transformGeojsonElevation, O as geoJSONToPolylineStr, P as DEFAULT_ELLIPSOID_ID, Q as setActiveEllipsoidId, R as PLANETARY_BASEMAP_GROUPS, S as featureSelectionId, T as decodePolyline, U as earthLengthToBody, V as bodyLengthToEarth, W as getActiveBodyRadiusRatio, X as getPlanetaryBasemapByStyleUrl, Y as getPlanetaryBasemapById, Z as meanRadiusMeters, _ as removeTrailingJsonCommas, a as layerJoinKey, b as SELECTION_MODES, c as applyLayerVirtualFields, d as compileFeatureExpression, f as evaluateMapExpression, g as matchFeaturesByExpression, h as isStyleSpecColor, i as collectTransitiveJoinSourceIds, j as geojsonHasZCoordinates, k as polylineStrToGeoJSON, l as stripVirtualFieldColumns, m as inferFieldTypes, n as applyLayerJoins, o as reapplyLayerJoins, p as formatExpressionPreviewValue, q as getActiveSemiMajorAxisMeters, r as cascadeLayerJoinRefresh, s as stripJoinFields, t as applyJoinsToLayer, u as EXPRESSION_FUNCTION_CATEGORIES, v as substituteExpressionVariables, w as batchDecodePolylines, x as applySelectionMode, y as validateMapExpression, z as PLANETARY_BASEMAP_SENTINEL_PREFIX } from "./joins-CGcRoTpc.mjs";
+import { Color, featureFilter, latest, normalizePropertyExpression } from "@maplibre/maplibre-gl-style-spec";
 import { create } from "zustand";
 import { temporal } from "zundo";
 import { v4 } from "uuid";
@@ -345,6 +346,7 @@ const DEFAULT_PROJECT_PREFERENCES = {
 		showPointerElevation: false,
 		terrainEnabled: false,
 		coordinateFormat: "dd",
+		zoomToNewLayers: true,
 		mapboxStyleUrl: "mapbox://styles/mapbox/standard",
 		arcgisBasemap: "arcgis/streets",
 		cesiumBasemap: "bing-aerial"
@@ -823,500 +825,6 @@ const PHOTO_PROPERTY = "photo";
 */
 const PHOTO_FULL_PROPERTY = "photo_full";
 //#endregion
-//#region src/ellipsoids.ts
-/**
-* Built-in ellipsoids. Earth is WGS 84; every other body uses IAU-adopted
-* figures. Only Earth and Mars are appreciably oblate; the rest are modelled as
-* spheres (`inverseFlattening: 0`), which is how the IAU/USGS simple-cylindrical
-* products treat them and is well within the accuracy MapLibre's unit-sphere
-* rendering can represent anyway.
-*/
-const ELLIPSOIDS = [
-	{
-		id: "earth",
-		name: "Earth (WGS 84)",
-		semiMajorAxisMeters: 6378137,
-		inverseFlattening: 298.257223563
-	},
-	{
-		id: "moon",
-		name: "Moon",
-		semiMajorAxisMeters: 1737400,
-		inverseFlattening: 0
-	},
-	{
-		id: "mars",
-		name: "Mars (IAU 2000)",
-		semiMajorAxisMeters: 3396190,
-		inverseFlattening: 169.894447
-	},
-	{
-		id: "mercury",
-		name: "Mercury",
-		semiMajorAxisMeters: 2439400,
-		inverseFlattening: 0
-	},
-	{
-		id: "venus",
-		name: "Venus",
-		semiMajorAxisMeters: 6051800,
-		inverseFlattening: 0
-	},
-	{
-		id: "io",
-		name: "Io",
-		semiMajorAxisMeters: 1821600,
-		inverseFlattening: 0
-	},
-	{
-		id: "europa",
-		name: "Europa",
-		semiMajorAxisMeters: 1560800,
-		inverseFlattening: 0
-	},
-	{
-		id: "ganymede",
-		name: "Ganymede",
-		semiMajorAxisMeters: 2631200,
-		inverseFlattening: 0
-	},
-	{
-		id: "callisto",
-		name: "Callisto",
-		semiMajorAxisMeters: 2410300,
-		inverseFlattening: 0
-	},
-	{
-		id: "titan",
-		name: "Titan",
-		semiMajorAxisMeters: 2574730,
-		inverseFlattening: 0
-	},
-	{
-		id: "pluto",
-		name: "Pluto",
-		semiMajorAxisMeters: 1188300,
-		inverseFlattening: 0
-	},
-	{
-		id: "charon",
-		name: "Charon",
-		semiMajorAxisMeters: 606e3,
-		inverseFlattening: 0
-	}
-];
-const DEFAULT_ELLIPSOID_ID = "earth";
-/** Look an ellipsoid up by id, falling back to Earth for unknown ids. */
-function getEllipsoid(id) {
-	return ELLIPSOIDS.find((e) => e.id === id) ?? ELLIPSOIDS.find((e) => e.id === "earth");
-}
-/**
-* Mean radius `R = (2a + b) / 3` in metres, where `b` is the polar radius
-* derived from the inverse flattening. This is the radius used for spherical
-* (haversine) distance and area math.
-*/
-function meanRadiusMeters(ellipsoid) {
-	const a = ellipsoid.semiMajorAxisMeters;
-	if (!ellipsoid.inverseFlattening) return a;
-	const b = a * (1 - 1 / ellipsoid.inverseFlattening);
-	return (2 * a + b) / 3;
-}
-/** Earth's mean radius in metres — the radius Turf.js and MapLibre bake in. */
-const EARTH_MEAN_RADIUS_METERS = meanRadiusMeters(ELLIPSOIDS.find((e) => e.id === "earth"));
-let activeEllipsoidId = DEFAULT_ELLIPSOID_ID;
-/**
-* Point the measurement helpers at a body. Unknown ids fall back to Earth so a
-* malformed project can never break measurements. Safe to call on every
-* preferences change; it is a cheap assignment.
-*/
-function setActiveEllipsoidId(id) {
-	activeEllipsoidId = getEllipsoid(id).id;
-}
-function getActiveEllipsoid() {
-	return getEllipsoid(activeEllipsoidId);
-}
-/** Mean radius (metres) of the active body — for haversine distance/area. */
-function getActiveMeanRadiusMeters() {
-	return meanRadiusMeters(getActiveEllipsoid());
-}
-/** Semi-major axis (metres) of the active body — for its Web-Mercator scale. */
-function getActiveSemiMajorAxisMeters() {
-	return getActiveEllipsoid().semiMajorAxisMeters;
-}
-/**
-* The active body's mean radius as a fraction of Earth's — `R_body / R_earth`,
-* and exactly `1` on Earth.
-*
-* Everything GeoLibre measures ultimately comes from lon/lat *angles*, and the
-* only thing that turns an angle into a ground distance is the radius it is
-* multiplied by. Turf.js hardcodes Earth's, with no per-call override (that is
-* the "Turf is Earth-locked" half of GeoLibre#1128), so rather than patch or
-* replace Turf we post-scale what it returns and pre-scale what we hand it. The
-* result is exact for a sphere, which is how every non-Earth body GeoLibre
-* offers is modelled anyway, and within Mars' 0.6% flattening at worst.
-*
-* Suggested by @thareUSGS (USGS Astrogeology) on GeoLibre#1128 as the practical
-* workaround planetary web maps have long used on Earth-locked engines.
-*/
-function getActiveBodyRadiusRatio() {
-	return getActiveMeanRadiusMeters() / EARTH_MEAN_RADIUS_METERS;
-}
-/**
-* Convert a length Turf.js measured on Earth into the active body's true ground
-* length. A no-op on Earth.
-*
-* Use on anything Turf *returns* — a distance, a length, a perimeter.
-*
-* The correction is a dimensionless ratio, so it is unit-agnostic: pass the
-* length in whatever unit Turf gave it back (metres, kilometres, miles) and the
-* result is in that same unit. There is no hidden unit conversion here.
-*/
-function earthLengthToBody(length) {
-	return length * getActiveBodyRadiusRatio();
-}
-/**
-* Convert a true ground length on the active body into the Earth-equivalent
-* length to hand Turf.js. A no-op on Earth.
-*
-* Use on anything passed *into* Turf as a distance — a buffer width, a circle
-* or sector radius, a search threshold — so the resulting geometry spans that
-* distance on this body rather than on Earth.
-*
-* Unit-agnostic like {@link earthLengthToBody}: pass the length in whatever
-* unit you are about to hand Turf alongside it, and the result is in that unit.
-*/
-function bodyLengthToEarth(length) {
-	return length / getActiveBodyRadiusRatio();
-}
-/**
-* Convert an area Turf.js measured on Earth into the active body's true ground
-* area. A no-op on Earth.
-*
-* Areas scale with the *square* of the radius ratio, so this is not the same
-* correction as {@link earthLengthToBody}. Unit-agnostic in the same way, for
-* whatever squared unit the area is expressed in.
-*/
-function earthAreaToBody(area) {
-	const ratio = getActiveBodyRadiusRatio();
-	return area * ratio * ratio;
-}
-const PLANETARY_BASEMAP_SENTINEL_PREFIX = "geolibre://basemap/";
-const OPM_ATTRIBUTION = "<a href=\"https://www.openplanetary.org/opm\">OpenPlanetaryMap</a>";
-/** Data-source credit joined with the OpenPlanetaryMap attribution. */
-const opmCredit = (source) => `${source} · ${OPM_ATTRIBUTION}`;
-const TILE_PROXY_BASE = "https://tiles.geolibre.app/opm";
-const WMS_PROXY_BASE = "https://tiles.geolibre.app/wms";
-const USGS_ASTRO_ATTRIBUTION = "<a href=\"https://astrogeology.usgs.gov/\">USGS Astrogeology</a>";
-/** Data-source credit joined with the USGS Astrogeology attribution. */
-const usgsCredit = (source) => `${source} · ${USGS_ASTRO_ATTRIBUTION}`;
-const PLANETARY_BASEMAPS = [
-	{
-		id: "mars-colour-mola-elevation",
-		name: "Colour MOLA Elevation",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-colour-mola-elevation`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-mola-color-noshade/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-viking-mdim21",
-		name: "Viking MDIM2.1",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-viking-mdim21`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-viking-mdim21/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 7,
-		attribution: opmCredit("NASA / Viking / USGS"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-hillshade",
-		name: "Hillshade",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-hillshade`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-hillshade/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-basemap-v0-2",
-		name: "OPM Basemap v0.2",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-basemap-v0-2`,
-		tileUrl: "https://cartocdn-gusc.global.ssl.fastly.net/opmbuilder/api/v1/map/named/opm-mars-basemap-v0-2/all/{z}/{x}/{y}.png",
-		maxZoom: 6,
-		attribution: OPM_ATTRIBUTION,
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-shaded-colour-mola-elevation",
-		name: "Shaded Colour MOLA Elevation",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-shaded-colour-mola-elevation`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-mola-color/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-shaded-grayscale-mola-elevation",
-		name: "Shaded Grayscale MOLA Elevation",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-shaded-grayscale-mola-elevation`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-mola-gray/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 9,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "moon-hillshaded-albedo",
-		name: "Hillshaded Albedo",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}moon-hillshaded-albedo`,
-		tileUrl: `${TILE_PROXY_BASE}/moon-hillshaded-albedo/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / LOLA / USGS"),
-		ellipsoidId: "moon"
-	},
-	{
-		id: "moon-basemap-v0-1",
-		name: "OPM Basemap v0.1",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}moon-basemap-v0-1`,
-		tileUrl: "https://cartocdn-gusc.global.ssl.fastly.net/opmbuilder/api/v1/map/named/opm-moon-basemap-v0-1/all/{z}/{x}/{y}.png",
-		maxZoom: 6,
-		attribution: OPM_ATTRIBUTION,
-		ellipsoidId: "moon"
-	},
-	{
-		id: "mercury-messenger-color",
-		name: "MESSENGER Colour Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mercury-messenger-color`,
-		tileUrl: `${WMS_PROXY_BASE}/mercury-messenger-color/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL / CIW"),
-		ellipsoidId: "mercury"
-	},
-	{
-		id: "mercury-messenger",
-		name: "MESSENGER Basemap",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mercury-messenger`,
-		tileUrl: `${WMS_PROXY_BASE}/mercury-messenger/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL"),
-		ellipsoidId: "mercury"
-	},
-	{
-		id: "venus-magellan",
-		name: "Magellan FMAP",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}venus-magellan`,
-		tileUrl: `${WMS_PROXY_BASE}/venus-magellan/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "venus"
-	},
-	{
-		id: "venus-magellan-color",
-		name: "Magellan C3-MDIR Colour",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}venus-magellan-color`,
-		tileUrl: `${WMS_PROXY_BASE}/venus-magellan-color/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "venus"
-	},
-	{
-		id: "io-galileo-color",
-		name: "Galileo SSI Colour",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}io-galileo-color`,
-		tileUrl: `${WMS_PROXY_BASE}/io-galileo-color/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "io"
-	},
-	{
-		id: "europa-galileo-voyager",
-		name: "Galileo / Voyager",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}europa-galileo-voyager`,
-		tileUrl: `${WMS_PROXY_BASE}/europa-galileo-voyager/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "europa"
-	},
-	{
-		id: "ganymede-galileo-voyager",
-		name: "Galileo / Voyager",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}ganymede-galileo-voyager`,
-		tileUrl: `${WMS_PROXY_BASE}/ganymede-galileo-voyager/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "ganymede"
-	},
-	{
-		id: "callisto-galileo-voyager",
-		name: "Galileo / Voyager",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}callisto-galileo-voyager`,
-		tileUrl: `${WMS_PROXY_BASE}/callisto-galileo-voyager/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "callisto"
-	},
-	{
-		id: "titan-cassini",
-		name: "Cassini ISS Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}titan-cassini`,
-		tileUrl: `${WMS_PROXY_BASE}/titan-cassini/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL / SSI"),
-		ellipsoidId: "titan"
-	},
-	{
-		id: "titan-hisar",
-		name: "Cassini HiSAR Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}titan-hisar`,
-		tileUrl: `${WMS_PROXY_BASE}/titan-hisar/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL / USGS"),
-		ellipsoidId: "titan"
-	},
-	{
-		id: "pluto-mosaic",
-		name: "New Horizons Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}pluto-mosaic`,
-		tileUrl: `${WMS_PROXY_BASE}/pluto-mosaic/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL / SwRI"),
-		ellipsoidId: "pluto"
-	},
-	{
-		id: "pluto-color",
-		name: "New Horizons Colour Shaded Relief",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}pluto-color`,
-		tileUrl: `${WMS_PROXY_BASE}/pluto-color/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL / SwRI"),
-		ellipsoidId: "pluto"
-	},
-	{
-		id: "charon-mosaic",
-		name: "New Horizons Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}charon-mosaic`,
-		tileUrl: `${WMS_PROXY_BASE}/charon-mosaic/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JHU APL / SwRI"),
-		ellipsoidId: "charon"
-	},
-	{
-		id: "earth-usgs-imagery",
-		name: "USGS Imagery",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}earth-usgs-imagery`,
-		tileUrl: "https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}",
-		maxZoom: 16,
-		attribution: "<a href=\"https://www.usgs.gov/programs/national-geospatial-program/national-map\">USGS The National Map</a>",
-		ellipsoidId: "earth"
-	}
-];
-const DEDICATED_SECTION_BODIES = ["moon", "mars"];
-/**
-* {@link PLANETARY_BASEMAPS} grouped for the pickers: one section each for the
-* Moon and Mars, then a single "Other celestial bodies" section for the rest,
-* in {@link PLANETARY_BASEMAPS} order (grouped by body). Empty sections are
-* dropped.
-*/
-const PLANETARY_BASEMAP_GROUPS = [
-	{
-		id: "moon",
-		ellipsoidId: "moon"
-	},
-	{
-		id: "mars",
-		ellipsoidId: "mars"
-	},
-	{
-		id: "other",
-		ellipsoidId: null
-	}
-].map(({ id, ellipsoidId }) => {
-	const basemaps = PLANETARY_BASEMAPS.filter((b) => ellipsoidId ? b.ellipsoidId === ellipsoidId : b.ellipsoidId !== "earth" && !DEDICATED_SECTION_BODIES.includes(b.ellipsoidId));
-	return {
-		id,
-		basemaps: id === "other" ? [...basemaps].sort((a, b) => getEllipsoid(a.ellipsoidId).name.localeCompare(getEllipsoid(b.ellipsoidId).name)) : basemaps
-	};
-}).filter((group) => group.basemaps.length > 0);
-const LEGACY_PLANETARY_BASEMAP_IDS = {
-	"mars-opm": "mars-basemap-v0-2",
-	"moon-opm": "moon-basemap-v0-1",
-	"mars-viking": "mars-viking-mdim21",
-	"moon-lroc": "moon-basemap-v0-1"
-};
-/** Resolve a `geolibre://basemap/<id>` sentinel to its planetary basemap. */
-function getPlanetaryBasemapByStyleUrl(styleUrl) {
-	if (!styleUrl?.startsWith("geolibre://basemap/")) return void 0;
-	const id = styleUrl.slice(19);
-	const resolvedId = Object.prototype.hasOwnProperty.call(LEGACY_PLANETARY_BASEMAP_IDS, id) ? LEGACY_PLANETARY_BASEMAP_IDS[id] : id;
-	return PLANETARY_BASEMAPS.find((b) => b.id === resolvedId);
-}
-/** Look a planetary basemap up by its stable id. */
-function getPlanetaryBasemapById(id) {
-	return PLANETARY_BASEMAPS.find((b) => b.id === id);
-}
-/**
-* The celestial bodies offered by the Layers-panel planet switcher, in menu
-* order (like Google Earth's planet dropdown). Each body is paired with the
-* basemap the switcher applies for it — USGS satellite imagery for Earth, the
-* OpenPlanetaryMap Hillshaded Albedo mosaic for the Moon, and the OpenPlanetaryMap
-* Viking mosaic for Mars.
-*/
-const PLANET_SWITCHER_OPTIONS = [
-	{
-		ellipsoidId: "earth",
-		basemapId: "earth-usgs-imagery"
-	},
-	{
-		ellipsoidId: "moon",
-		basemapId: "moon-hillshaded-albedo"
-	},
-	{
-		ellipsoidId: "mars",
-		basemapId: "mars-viking-mdim21"
-	},
-	{
-		ellipsoidId: "callisto",
-		basemapId: "callisto-galileo-voyager"
-	},
-	{
-		ellipsoidId: "charon",
-		basemapId: "charon-mosaic"
-	},
-	{
-		ellipsoidId: "europa",
-		basemapId: "europa-galileo-voyager"
-	},
-	{
-		ellipsoidId: "ganymede",
-		basemapId: "ganymede-galileo-voyager"
-	},
-	{
-		ellipsoidId: "io",
-		basemapId: "io-galileo-color"
-	},
-	{
-		ellipsoidId: "mercury",
-		basemapId: "mercury-messenger-color"
-	},
-	{
-		ellipsoidId: "pluto",
-		basemapId: "pluto-mosaic"
-	},
-	{
-		ellipsoidId: "titan",
-		basemapId: "titan-cassini"
-	},
-	{
-		ellipsoidId: "venus",
-		basemapId: "venus-magellan-color"
-	}
-];
-//#endregion
 //#region src/regional-basemaps.ts
 const REGIONAL_BASEMAP_SENTINEL_PREFIX = "geolibre://regional-basemap/";
 const AMAP_ATTRIBUTION = "&copy; <a href=\"https://www.amap.com\">高德地图 Amap</a>";
@@ -1729,146 +1237,6 @@ function basemapToCesiumImagery(styleUrl, cesiumBasemap = "project") {
 	return analogue ? toImagery(analogue) : { kind: "default" };
 }
 //#endregion
-//#region src/geojson-z.ts
-/**
-* Helpers for vector data whose coordinates carry a Z value (elevation), e.g.
-* GPX tracks with `<ele>` readings or LineStringZ/PointZ geometries. MapLibre's
-* 2D style layers ignore the third coordinate, so layers that want to render
-* their Z values use these helpers to detect and rescale elevations before
-* handing the data to a deck.gl overlay. The same data can carry its elevation
-* in a `bbox` member too, which `horizontalBbox` trims back to two dimensions.
-*/
-/**
-* Reduces a bounding box to its horizontal extent, `[west, south, east, north]`.
-*
-* RFC 7946 §5 lets a `bbox` member carry elevation, in which case it holds six
-* values — `[west, south, minAltitude, east, north, maxAltitude]` — and
-* `@turf/bbox` returns a collection's own member verbatim rather than
-* recomputing it. A consumer reading such a box as four values takes the
-* altitude for a longitude and the east edge for a latitude; that is how a 3D
-* feed reached MapLibre as an out-of-range latitude (#2358).
-*
-* Returns null when there is no usable horizontal extent: a box of any other
-* length, or one carrying a non-finite value anywhere — an empty collection, or
-* one whose features all have a null geometry, bboxes to ±Infinity, and a box
-* whose altitudes are not finite is not one to trust the rest of.
-*
-* @param box - A GeoJSON or Turf bounding box, of four or six values.
-*/
-function horizontalBbox(box) {
-	if (!box) return null;
-	if (box.length !== 4 && box.length !== 6) return null;
-	if (!box.every((value) => Number.isFinite(value))) return null;
-	return box.length === 6 ? [
-		box[0],
-		box[1],
-		box[3],
-		box[4]
-	] : [
-		box[0],
-		box[1],
-		box[2],
-		box[3]
-	];
-}
-const hasZCache = /* @__PURE__ */ new WeakMap();
-const hasFiniteZCache = /* @__PURE__ */ new WeakMap();
-/**
-* Returns true when any coordinate in the GeoJSON carries a finite, non-zero
-* Z value. All-zero Z arrays are treated as flat data because rendering them
-* "in 3D" would be indistinguishable from the 2D result. The result is
-* cached per GeoJSON object, so repeated calls on the same data are free.
-*
-* @param geojson - Any GeoJSON object (geometry, feature, or collection).
-* @param includeZero - Accept zero elevations when explicit absolute-height placement matters.
-*/
-function geojsonHasZCoordinates(geojson, includeZero = false) {
-	if (!geojson) return false;
-	const cache = includeZero ? hasFiniteZCache : hasZCache;
-	const cached = cache.get(geojson);
-	if (cached !== void 0) return cached;
-	const result = someGeometry(geojson, (geometry) => somePosition(geometry, (position) => {
-		const z = position[2];
-		return typeof z === "number" && Number.isFinite(z) && (includeZero || z !== 0);
-	}));
-	cache.set(geojson, result);
-	return result;
-}
-/**
-* Returns a copy of the GeoJSON with every coordinate's Z value mapped to
-* `z * verticalScale + offset` (missing or non-finite Z treated as 0). Used
-* to apply vertical exaggeration and a constant altitude offset before 3D
-* rendering. The identity transform (`verticalScale === 1 && offset === 0`)
-* still produces a copy so the non-finite-Z sanitization applies on every
-* path — WebGL does not handle NaN positions gracefully.
-*
-* @param geojson - The feature collection to transform.
-* @param verticalScale - Multiplier applied to each Z value.
-* @param offset - Constant altitude in meters added after scaling.
-*/
-function transformGeojsonElevation(geojson, verticalScale, offset) {
-	const mapPosition = (position) => [
-		position[0],
-		position[1],
-		(typeof position[2] === "number" && Number.isFinite(position[2]) ? position[2] : 0) * verticalScale + offset
-	];
-	return {
-		...geojson,
-		features: geojson.features.map((feature) => ({
-			...feature,
-			geometry: mapGeometryPositions(feature.geometry, mapPosition)
-		}))
-	};
-}
-function someGeometry(geojson, predicate) {
-	switch (geojson.type) {
-		case "FeatureCollection": return geojson.features.some((feature) => feature.geometry ? someGeometry(feature.geometry, predicate) : false);
-		case "Feature": return geojson.geometry ? someGeometry(geojson.geometry, predicate) : false;
-		case "GeometryCollection": return geojson.geometries.some((geometry) => someGeometry(geometry, predicate));
-		default: return predicate(geojson);
-	}
-}
-function somePosition(geometry, predicate) {
-	switch (geometry.type) {
-		case "Point": return predicate(geometry.coordinates);
-		case "MultiPoint":
-		case "LineString": return geometry.coordinates.some(predicate);
-		case "MultiLineString":
-		case "Polygon": return geometry.coordinates.some((ring) => ring.some(predicate));
-		case "MultiPolygon": return geometry.coordinates.some((polygon) => polygon.some((ring) => ring.some(predicate)));
-		case "GeometryCollection": return geometry.geometries.some((child) => somePosition(child, predicate));
-		default: return false;
-	}
-}
-function mapGeometryPositions(geometry, mapPosition) {
-	if (!geometry) return geometry;
-	switch (geometry.type) {
-		case "Point": return {
-			...geometry,
-			coordinates: mapPosition(geometry.coordinates)
-		};
-		case "MultiPoint":
-		case "LineString": return {
-			...geometry,
-			coordinates: geometry.coordinates.map(mapPosition)
-		};
-		case "MultiLineString":
-		case "Polygon": return {
-			...geometry,
-			coordinates: geometry.coordinates.map((ring) => ring.map(mapPosition))
-		};
-		case "MultiPolygon": return {
-			...geometry,
-			coordinates: geometry.coordinates.map((polygon) => polygon.map((ring) => ring.map(mapPosition)))
-		};
-		case "GeometryCollection": return {
-			...geometry,
-			geometries: geometry.geometries.map((child) => mapGeometryPositions(child, mapPosition))
-		};
-		default: return geometry;
-	}
-}
-//#endregion
 //#region src/color-ramp.ts
 /** The built-in color ramps offered by the style panels. */
 const VECTOR_COLOR_RAMPS = [
@@ -2372,269 +1740,6 @@ function isAbsoluteFilesystemPath(path) {
 	return path.startsWith("/") || /^[a-z]:[\\/]/i.test(path);
 }
 //#endregion
-//#region src/polyline.ts
-/**
-* Pure TypeScript Google Encoded Polyline algorithm codec.
-*
-* Supports arbitrary precision:
-* - precision = 5: Google Maps standard, OSRM, HERE (factor 1e5, ~1.1m precision)
-* - precision = 6: Valhalla, Mapbox, Open Source Routing Machine 6 (factor 1e6, ~0.11m precision)
-*
-* Coordinates are represented as `[lon, lat]` pairs in GeoJSON format.
-*/
-/**
-* Unescapes backslashes in a polyline string.
-*
-* When polyline strings are copied from JSON payloads, log files, or source code,
-* backslashes are frequently double-escaped as `\\` or formatted with escape sequences.
-*
-* @param str - Input string with potentially escaped backslashes.
-* @returns Cleaned polyline string.
-*/
-function unescapePolyline(str) {
-	if (!str || typeof str !== "string") return "";
-	return str.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\'/g, "'");
-}
-/**
-* Decodes an encoded polyline string into an array of `[lon, lat]` coordinates,
-* along with a `complete` flag indicating whether the entire string was consumed
-* as complete coordinate pairs without truncation or malformed characters.
-*
-* @param encoded - The ASCII-encoded polyline string.
-* @param precision - Number of decimal digits (default: 5).
-* @param unescape - Whether to unescape double-escaped backslashes before decoding (default: false).
-* @returns Object with decoded `coordinates` and `complete` boolean status.
-*/
-function decodePolylineDetailed(encoded, precision = 5, unescape = false) {
-	if (!encoded || typeof encoded !== "string") return {
-		coordinates: [],
-		complete: true
-	};
-	const cleanEncoded = unescape ? unescapePolyline(encoded) : encoded;
-	const factor = 10 ** precision;
-	const len = cleanEncoded.length;
-	const coordinates = [];
-	let index = 0;
-	let lat = 0;
-	let lon = 0;
-	while (index < len) {
-		let shift = 0;
-		let result = 0;
-		let byte;
-		let latComplete = false;
-		do {
-			if (index >= len) return {
-				coordinates,
-				complete: false
-			};
-			byte = cleanEncoded.charCodeAt(index++) - 63;
-			if (byte < 0 || byte > 63) return {
-				coordinates,
-				complete: false
-			};
-			if (shift > 30 || shift === 30 && (byte & 31) > 3) return {
-				coordinates,
-				complete: false
-			};
-			result |= (byte & 31) << shift;
-			shift += 5;
-			if (byte < 32) {
-				latComplete = true;
-				break;
-			}
-		} while (byte >= 32);
-		if (!latComplete) return {
-			coordinates,
-			complete: false
-		};
-		lat += result & 1 ? ~(result >>> 1) : result >>> 1;
-		shift = 0;
-		result = 0;
-		let lonComplete = false;
-		do {
-			if (index >= len) return {
-				coordinates,
-				complete: false
-			};
-			byte = cleanEncoded.charCodeAt(index++) - 63;
-			if (byte < 0 || byte > 63) return {
-				coordinates,
-				complete: false
-			};
-			if (shift > 30 || shift === 30 && (byte & 31) > 3) return {
-				coordinates,
-				complete: false
-			};
-			result |= (byte & 31) << shift;
-			shift += 5;
-			if (byte < 32) {
-				lonComplete = true;
-				break;
-			}
-		} while (byte >= 32);
-		if (!lonComplete) return {
-			coordinates,
-			complete: false
-		};
-		lon += result & 1 ? ~(result >>> 1) : result >>> 1;
-		coordinates.push([lon / factor, lat / factor]);
-	}
-	return {
-		coordinates,
-		complete: true
-	};
-}
-/**
-* Decodes an encoded polyline string into an array of `[lon, lat]` coordinates.
-*
-* @param encoded - The ASCII-encoded polyline string.
-* @param precision - Number of decimal digits (default: 5).
-* @param unescape - Whether to unescape double-escaped backslashes before decoding (default: false).
-* @returns Array of `[lon, lat]` coordinate pairs in GeoJSON order.
-*/
-function decodePolyline(encoded, precision = 5, unescape = false) {
-	return decodePolylineDetailed(encoded, precision, unescape).coordinates;
-}
-/**
-* Encodes a single integer delta value into polyline character chunks.
-*/
-function encodeSignedNumber(num) {
-	let sgnNum = num < 0 ? ~(num << 1) : num << 1;
-	let out = "";
-	while (sgnNum >= 32) {
-		out += String.fromCharCode((32 | sgnNum & 31) + 63);
-		sgnNum >>>= 5;
-	}
-	out += String.fromCharCode(sgnNum + 63);
-	return out;
-}
-/**
-* Encodes an array of `[lon, lat]` coordinates into a Google Encoded Polyline string.
-*
-* @param coordinates - Array of `[lon, lat]` coordinate pairs.
-* @param precision - Number of decimal digits (default: 5).
-* @returns The encoded polyline string.
-*/
-function encodePolyline(coordinates, precision = 5) {
-	if (!Array.isArray(coordinates) || coordinates.length === 0) return "";
-	const factor = 10 ** precision;
-	let output = "";
-	let prevLat = 0;
-	let prevLon = 0;
-	for (const [lon, lat] of coordinates) {
-		if (!Number.isFinite(lon) || !Number.isFinite(lat)) continue;
-		const roundLat = Math.round(lat * factor);
-		const roundLon = Math.round(lon * factor);
-		const deltaLat = roundLat - prevLat;
-		const deltaLon = roundLon - prevLon;
-		output += encodeSignedNumber(deltaLat);
-		output += encodeSignedNumber(deltaLon);
-		prevLat = roundLat;
-		prevLon = roundLon;
-	}
-	return output;
-}
-/**
-* Decodes an encoded polyline string into a GeoJSON `Feature<LineString>`.
-*
-* @param encoded - The polyline string.
-* @param precision - Coordinate precision (default: 5).
-* @param properties - Optional feature properties.
-* @returns A GeoJSON LineString Feature.
-*/
-function polylineStrToGeoJSON(encoded, precision = 5, properties = {}) {
-	return {
-		type: "Feature",
-		properties: { ...properties },
-		geometry: {
-			type: "LineString",
-			coordinates: decodePolyline(encoded, precision)
-		}
-	};
-}
-/**
-* Encodes a GeoJSON LineString, MultiLineString, Feature, or FeatureCollection into encoded polyline string(s).
-*
-* @param geojson - The GeoJSON input geometry or feature.
-* @param precision - Coordinate precision (default: 5).
-* @returns An encoded polyline string for LineString, or an array of strings for MultiLineString / FeatureCollection.
-*/
-function geoJSONToPolylineStr(geojson, precision = 5) {
-	if (!geojson) return "";
-	if (geojson.type === "Feature") return geoJSONToPolylineStr(geojson.geometry, precision);
-	if (geojson.type === "FeatureCollection") {
-		const results = [];
-		for (const feature of geojson.features) {
-			const res = geoJSONToPolylineStr(feature.geometry, precision);
-			if (Array.isArray(res)) results.push(...res);
-			else if (res) results.push(res);
-		}
-		return results;
-	}
-	if (geojson.type === "LineString") return encodePolyline(geojson.coordinates, precision);
-	if (geojson.type === "MultiLineString") return geojson.coordinates.map((lineCoords) => encodePolyline(lineCoords, precision));
-	return "";
-}
-/**
-* Parses and batch-decodes multiple polylines from a text block or file content.
-*
-* @param input - Multiline string or delimited text containing encoded polylines.
-* @param options - Decoding and parsing configuration.
-* @returns A FeatureCollection containing LineString (or MultiLineString) features.
-*/
-function batchDecodePolylines(input, options = {}) {
-	if (!input || typeof input !== "string") return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const { precision = 5, unescape = true, delimiter = /\r?\n/, asMultiLine = false, baseProperties = {} } = options;
-	const rawChunks = input.split(delimiter);
-	const validLineCoords = [];
-	const features = [];
-	for (let i = 0; i < rawChunks.length; i++) {
-		const raw = rawChunks[i].trim();
-		if (!raw) continue;
-		const cleaned = raw.replace(/^["']|["']$/g, "").trim();
-		if (!cleaned) continue;
-		const decodeResult = decodePolylineDetailed(cleaned, precision, unescape);
-		if (decodeResult.complete && decodeResult.coordinates.length >= 2) {
-			const coords = decodeResult.coordinates;
-			validLineCoords.push(coords);
-			features.push({
-				type: "Feature",
-				properties: {
-					...baseProperties,
-					line_index: features.length + 1,
-					point_count: coords.length
-				},
-				geometry: {
-					type: "LineString",
-					coordinates: coords
-				}
-			});
-		}
-	}
-	if (asMultiLine && validLineCoords.length > 0) return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {
-				...baseProperties,
-				line_count: validLineCoords.length,
-				point_count: validLineCoords.reduce((acc, c) => acc + c.length, 0)
-			},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: validLineCoords
-			}
-		}]
-	};
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-//#endregion
 //#region src/runtime-env.ts
 const buildEnv = typeof __GEOLIBRE_BUILD_ENV__ === "undefined" ? {} : __GEOLIBRE_BUILD_ENV__;
 /**
@@ -3057,511 +2162,63 @@ function toComparableNumber(value) {
 		const parsed = Date.parse(trimmed);
 		if (Number.isFinite(parsed)) return parsed;
 	}
-	return null;
-}
-/**
-* Error thrown when a Valhalla request returns a non-2xx response. Carries the
-* HTTP status so callers can branch on it (e.g. a 4xx rejection) without
-* pattern-matching the message string.
-*/
-var RoutingRequestError = class extends Error {
-	status;
-	constructor(status, statusText) {
-		super(`Routing request failed (${status} ${statusText})`);
-		this.name = "RoutingRequestError";
-		this.status = status;
-	}
-};
-async function postJson(url, body, signal) {
-	const response = await fetch(url, {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify(body),
-		signal
-	});
-	if (!response.ok) throw new RoutingRequestError(response.status, response.statusText);
-	return response.json();
-}
-/**
-* Requests an isochrone from the Valhalla server.
-*
-* @param endpoint - The Valhalla base URL.
-* @param body - The request body from {@link buildIsochroneRequest}.
-* @param signal - Optional abort signal.
-* @returns The Valhalla GeoJSON response.
-*/
-function requestIsochrone(endpoint, body, signal) {
-	return postJson(`${stripTrailingSlash(endpoint)}/isochrone`, body, signal);
-}
-/**
-* Requests an OD cost matrix from the Valhalla server.
-*
-* @param endpoint - The Valhalla base URL.
-* @param body - The request body from {@link buildMatrixRequest}.
-* @param signal - Optional abort signal.
-* @returns The Valhalla matrix response.
-*/
-function requestMatrix(endpoint, body, signal) {
-	return postJson(`${stripTrailingSlash(endpoint)}/sources_to_targets`, body, signal);
-}
-/**
-* Requests a route through ordered waypoints from the Valhalla server.
-*
-* @param endpoint - The Valhalla base URL.
-* @param body - The request body from {@link buildRouteRequest}.
-* @param signal - Optional abort signal.
-* @returns The Valhalla `/route` response.
-*/
-function requestRoute(endpoint, body, signal) {
-	return postJson(`${stripTrailingSlash(endpoint)}/route`, body, signal);
-}
-//#endregion
-//#region src/selection.ts
-/** Selection modes in display order. */
-const SELECTION_MODES = [
-	"new",
-	"add",
-	"remove",
-	"intersect"
-];
-/**
-* The id under which a feature participates in the selection model. Mirrors
-* the convention shared by the attribute table and the map highlight
-* (`String(feature.id ?? index)`): the feature's own `id` when present,
-* otherwise its index in the layer's feature array.
-*/
-function featureSelectionId(feature, index) {
-	return String(feature.id ?? index);
-}
-/**
-* Combines the current selection with a freshly matched id set according to
-* `mode`. The result is deduplicated and order-stable: "new" follows the
-* matched order, "add" appends unseen matches after the current ids, and
-* "remove"/"intersect" preserve the current selection's order.
-*/
-function applySelectionMode(current, matched, mode) {
-	const matchedSet = new Set(matched);
-	switch (mode) {
-		case "new": return Array.from(matchedSet);
-		case "add": {
-			const merged = new Set(current);
-			for (const id of matched) merged.add(id);
-			return Array.from(merged);
-		}
-		case "remove": return Array.from(new Set(current.filter((id) => !matchedSet.has(id))));
-		case "intersect": return Array.from(new Set(current.filter((id) => matchedSet.has(id))));
-	}
-}
-/**
-* The complement of `current` within `allIds` (QGIS "Invert selection"):
-* every feature id not currently selected, in layer order. With an empty
-* selection this selects everything.
-*/
-function invertSelection(allIds, current) {
-	const selected = new Set(current);
-	return allIds.filter((id) => !selected.has(id));
-}
-//#endregion
-//#region src/expressions.ts
-const fn = (name, snippet, docKey) => ({
-	name,
-	snippet,
-	docKey
-});
-/**
-* The curated function reference, grouped by category. Snippets are valid,
-* standalone-compilable MapLibre expressions (enforced by tests) so inserting
-* one into an empty editor always yields a working starting point.
-*/
-const EXPRESSION_FUNCTION_CATEGORIES = [
-	{
-		key: "data",
-		functions: [
-			fn("get", "[\"get\", \"field\"]", "get"),
-			fn("has", "[\"has\", \"field\"]", "has"),
-			fn("id", "[\"id\"]", "id"),
-			fn("properties", "[\"properties\"]", "properties"),
-			fn("geometry-type", "[\"geometry-type\"]", "geometryType"),
-			fn("at", "[\"at\", 0, [\"literal\", [1, 2, 3]]]", "at"),
-			fn("in", "[\"in\", \"value\", [\"get\", \"field\"]]", "in"),
-			fn("index-of", "[\"index-of\", \"value\", [\"get\", \"field\"]]", "indexOf"),
-			fn("length", "[\"length\", [\"get\", \"field\"]]", "length"),
-			fn("literal", "[\"literal\", [\"a\", \"b\"]]", "literal"),
-			fn("typeof", "[\"typeof\", [\"get\", \"field\"]]", "typeofOp")
-		]
-	},
-	{
-		key: "decision",
-		functions: [
-			fn("case", "[\"case\", [\"==\", [\"get\", \"field\"], \"value\"], \"#ff0000\", \"#cccccc\"]", "caseOp"),
-			fn("match", "[\"match\", [\"get\", \"field\"], \"a\", \"#2563eb\", \"b\", \"#16a34a\", \"#94a3b8\"]", "match"),
-			fn("coalesce", "[\"coalesce\", [\"get\", \"field\"], \"fallback\"]", "coalesce"),
-			fn("==", "[\"==\", [\"get\", \"field\"], \"value\"]", "eq"),
-			fn("!=", "[\"!=\", [\"get\", \"field\"], \"value\"]", "neq"),
-			fn(">", "[\">\", [\"get\", \"field\"], 0]", "gt"),
-			fn(">=", "[\">=\", [\"get\", \"field\"], 0]", "gte"),
-			fn("<", "[\"<\", [\"get\", \"field\"], 0]", "lt"),
-			fn("<=", "[\"<=\", [\"get\", \"field\"], 0]", "lte"),
-			fn("all", "[\"all\", [\">\", [\"get\", \"field\"], 0], [\"<\", [\"get\", \"field\"], 100]]", "all"),
-			fn("any", "[\"any\", [\"==\", [\"get\", \"field\"], \"a\"], [\"==\", [\"get\", \"field\"], \"b\"]]", "any"),
-			fn("!", "[\"!\", [\"has\", \"field\"]]", "not")
-		]
-	},
-	{
-		key: "math",
-		functions: [
-			fn("+", "[\"+\", [\"get\", \"field\"], 1]", "add"),
-			fn("-", "[\"-\", [\"get\", \"field\"], 1]", "subtract"),
-			fn("*", "[\"*\", [\"get\", \"field\"], 2]", "multiply"),
-			fn("/", "[\"/\", [\"get\", \"field\"], 2]", "divide"),
-			fn("%", "[\"%\", [\"get\", \"field\"], 2]", "modulo"),
-			fn("^", "[\"^\", [\"get\", \"field\"], 2]", "power"),
-			fn("abs", "[\"abs\", [\"get\", \"field\"]]", "abs"),
-			fn("ceil", "[\"ceil\", [\"get\", \"field\"]]", "ceil"),
-			fn("floor", "[\"floor\", [\"get\", \"field\"]]", "floor"),
-			fn("round", "[\"round\", [\"get\", \"field\"]]", "round"),
-			fn("sqrt", "[\"sqrt\", [\"get\", \"field\"]]", "sqrt"),
-			fn("ln", "[\"ln\", [\"get\", \"field\"]]", "ln"),
-			fn("log10", "[\"log10\", [\"get\", \"field\"]]", "log10"),
-			fn("min", "[\"min\", [\"get\", \"field\"], 0]", "min"),
-			fn("max", "[\"max\", [\"get\", \"field\"], 0]", "max")
-		]
-	},
-	{
-		key: "string",
-		functions: [
-			fn("concat", "[\"concat\", [\"get\", \"field\"], \" suffix\"]", "concat"),
-			fn("upcase", "[\"upcase\", [\"get\", \"field\"]]", "upcase"),
-			fn("downcase", "[\"downcase\", [\"get\", \"field\"]]", "downcase"),
-			fn("slice", "[\"slice\", [\"get\", \"field\"], 0, 3]", "slice"),
-			fn("number-format", "[\"number-format\", [\"get\", \"field\"], {\"locale\": \"en-US\", \"max-fraction-digits\": 2}]", "numberFormat")
-		]
-	},
-	{
-		key: "conversion",
-		functions: [
-			fn("to-number", "[\"to-number\", [\"get\", \"field\"]]", "toNumber"),
-			fn("to-string", "[\"to-string\", [\"get\", \"field\"]]", "toString"),
-			fn("to-boolean", "[\"to-boolean\", [\"get\", \"field\"]]", "toBoolean"),
-			fn("to-color", "[\"to-color\", \"#2563eb\"]", "toColor")
-		]
-	},
-	{
-		key: "camera",
-		functions: [
-			fn("zoom", "[\"zoom\"]", "zoom"),
-			fn("interpolate", "[\"interpolate\", [\"linear\"], [\"zoom\"], 5, [\"to-color\", \"#2563eb\"], 12, [\"to-color\", \"#dc2626\"]]", "interpolate"),
-			fn("step", "[\"step\", [\"zoom\"], \"#2563eb\", 10, \"#dc2626\"]", "step"),
-			fn("rgb", "[\"rgb\", 37, 99, 235]", "rgb"),
-			fn("rgba", "[\"rgba\", 37, 99, 235, 0.5]", "rgba")
-		]
-	}
-];
-/**
-* Strips commas that directly precede a closing bracket/brace outside of
-* strings, so user-typed expressions with trailing commas still parse.
-* Shared by {@link parseJsonExpression} (vector-color) and the builder.
-*/
-function removeTrailingJsonCommas(value) {
-	let result = "";
-	let inString = false;
-	let escaped = false;
-	for (let index = 0; index < value.length; index += 1) {
-		const char = value[index];
-		if (inString) {
-			result += char;
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === "\"") inString = false;
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			result += char;
-			continue;
-		}
-		if (char === ",") {
-			const nextSignificant = value.slice(index + 1).match(/\S/)?.[0];
-			if (nextSignificant === "]" || nextSignificant === "}") continue;
-		}
-		result += char;
-	}
-	return result;
-}
-/**
-* The `rootKey` `createExpression` (style-spec v26+) requires as its second
-* argument — a location label it only surfaces when attaching a runtime
-* warning to `console.warn` during evaluation. These expressions come from the
-* Expression Builder dialog, not a style JSON layer, so a generic label is the
-* honest value; it never appears in the parsing errors we report.
-*/
-const EXPRESSION_ROOT_KEY = "expression";
-/**
-* Builds the minimal property spec that makes `createExpression` enforce a
-* result type while still allowing zoom- and feature-dependent input.
-*
-* This mirrors the (unexported) `StylePropertySpecification` shape that
-* `@maplibre/maplibre-gl-style-spec` expects — the cast below means the
-* compiler cannot catch a change to that contract, so whenever the
-* style-spec package is bumped (including Dependabot PRs) re-check that
-* expected-type enforcement still works, and that the property spec is still
-* `createExpression`'s third parameter (v26 inserted a `rootKey` at index 1,
-* shifting it from `[1]` to `[2]`). The "enforces an expected result type"
-* test in `tests/expressions.test.ts` fails if this shape stops being honored.
-*/
-function propertySpecFor(expectedType) {
-	return {
-		type: expectedType,
-		"property-type": "data-driven",
-		expression: { parameters: ["zoom", "feature"] }
-	};
-}
-/**
-* Validates a user-entered MapLibre expression: tolerant JSON parse, shape
-* checks, then a real compile through the MapLibre style spec so operator
-* misuse (wrong arity, unknown operator, type mismatch) is caught in the
-* dialog instead of silently failing on the map. Variables are substituted
-* before compiling (so tokens type-check as their values), and
-* `expectedType` additionally enforces the destination's result type. The
-* returned `parsed` array is the raw, unsubstituted parse. An empty/blank
-* source is valid (surfaces treat it as "no expression").
-*/
-function validateMapExpression(source, options = {}) {
-	return compileMapExpression(source, options).validation;
-}
-/**
-* The single parse + substitute + compile pass shared by validation and
-* preview evaluation, so a preview never compiles the same source twice.
-* `expression` is set only when the validation succeeded on a non-empty
-* source.
-*/
-function compileMapExpression(source, options) {
-	const trimmed = source.trim();
-	if (!trimmed) return { validation: {
-		ok: true,
-		errors: []
-	} };
-	let parsed;
-	try {
-		parsed = JSON.parse(removeTrailingJsonCommas(trimmed));
-	} catch (error) {
-		return { validation: {
-			ok: false,
-			code: "not-json",
-			errors: [error instanceof Error ? error.message : "Invalid JSON"]
-		} };
-	}
-	if (!Array.isArray(parsed)) return { validation: {
-		ok: false,
-		code: "not-array",
-		errors: []
-	} };
-	if (typeof parsed[0] !== "string") return { validation: {
-		ok: false,
-		code: "not-operator",
-		errors: [],
-		parsed
-	} };
-	const substituted = substituteExpressionVariables(parsed, options.variables ?? []);
-	const compiled = createExpression(substituted, EXPRESSION_ROOT_KEY, options.expectedType ? propertySpecFor(options.expectedType) : void 0);
-	if (compiled.result === "error") return { validation: {
-		ok: false,
-		code: "compile",
-		errors: compiled.value.map((issue) => issue.key ? `${issue.key}: ${issue.message}` : issue.message),
-		parsed
-	} };
-	return {
-		validation: {
-			ok: true,
-			errors: [],
-			parsed
-		},
-		expression: compiled.value
-	};
-}
-/**
-* Replaces every string node that exactly matches a known `@token` with that
-* variable's value, returning a new structure (the input is not mutated).
-* Unknown `@` strings are left untouched so field values that happen to start
-* with `@` never get mangled.
-*/
-function substituteExpressionVariables(node, variables) {
-	if (typeof node === "string" && node.startsWith("@")) {
-		const match = variables.find((variable) => variable.token === node);
-		return match ? match.value : node;
-	}
-	if (Array.isArray(node)) return node.map((entry) => substituteExpressionVariables(entry, variables));
-	if (node && typeof node === "object") return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, substituteExpressionVariables(value, variables)]));
-	return node;
-}
-/**
-* Evaluates an expression source against a sample feature for the builder's
-* live preview. Variables are substituted first, then the expression is
-* compiled with the MapLibre style spec and evaluated with the given zoom.
-* Runtime failures (e.g. `to-color` on garbage) come back as errors instead
-* of throwing.
-*/
-function evaluateMapExpression(source, options = {}) {
-	const trimmed = source.trim();
-	if (!trimmed) return { kind: "empty" };
-	const { validation, expression } = compileMapExpression(trimmed, {
-		variables: options.variables,
-		expectedType: options.expectedType
-	});
-	if (!validation.ok || !expression) return {
-		kind: "error",
-		errors: validation.errors
-	};
-	const feature = options.feature ?? null;
-	const geometryType = feature?.geometry?.type ?? "Unknown";
-	try {
-		return {
-			kind: "value",
-			value: expression.evaluateWithoutErrorHandling({ zoom: options.zoom ?? 0 }, {
-				type: geometryType,
-				properties: feature?.properties ?? {},
-				...feature?.id !== void 0 ? { id: feature.id } : {},
-				geometry: feature?.geometry
-			})
-		};
-	} catch (error) {
-		return {
-			kind: "error",
-			errors: [error instanceof Error ? error.message : String(error)]
-		};
-	}
-}
-/**
-* Compiles an expression source once for bulk per-feature evaluation (virtual
-* fields, and any other caller that runs one expression over a whole layer).
-* Unlike {@link evaluateMapExpression} the compile cost is paid once, not per
-* feature. An empty source is reported as a failure with no errors — there is
-* nothing to evaluate.
-*/
-function compileFeatureExpression(source, options = {}) {
-	const trimmed = source.trim();
-	if (!trimmed) return {
-		ok: false,
-		errors: []
-	};
-	const { validation, expression } = compileMapExpression(trimmed, {
-		variables: options.variables,
-		expectedType: options.expectedType
-	});
-	if (!validation.ok || !expression) return {
-		ok: false,
-		errors: validation.errors
-	};
-	const compiledZoom = options.zoom ?? 0;
-	return {
-		ok: true,
-		errors: [],
-		evaluate: (feature, zoom = compiledZoom) => expression.evaluateWithoutErrorHandling({ zoom }, {
-			type: feature.geometry?.type ?? "Unknown",
-			properties: feature.properties ?? {},
-			...feature.id !== void 0 ? { id: feature.id } : {},
-			geometry: feature.geometry
-		})
-	};
-}
-/**
-* Evaluates a boolean expression against every feature and returns the
-* selection ids of the matches (Select by Expression). Unlike
-* {@link evaluateMapExpression} this compiles the source once and reuses the
-* compiled expression across the whole array, so it stays fast on large
-* layers. An empty source is reported as `ok: false` with no errors — there
-* is nothing to select by.
-*/
-function matchFeaturesByExpression(features, source, options = {}) {
-	const trimmed = source.trim();
-	if (!trimmed) return {
-		ok: false,
-		errors: [],
-		ids: [],
-		errorCount: 0
-	};
-	const { validation, expression } = compileMapExpression(trimmed, {
-		variables: options.variables,
-		expectedType: "boolean"
-	});
-	if (!validation.ok || !expression) return {
-		ok: false,
-		errors: validation.errors,
-		ids: [],
-		errorCount: 0
-	};
-	const ids = [];
-	let errorCount = 0;
-	features.forEach((feature, index) => {
-		try {
-			if (expression.evaluateWithoutErrorHandling({ zoom: options.zoom ?? 0 }, {
-				type: feature.geometry?.type ?? "Unknown",
-				properties: feature.properties ?? {},
-				...feature.id !== void 0 ? { id: feature.id } : {},
-				geometry: feature.geometry
-			}) === true) ids.push(featureSelectionId(feature, index));
-		} catch {
-			errorCount += 1;
-		}
+	return null;
+}
+/**
+* Error thrown when a Valhalla request returns a non-2xx response. Carries the
+* HTTP status so callers can branch on it (e.g. a 4xx rejection) without
+* pattern-matching the message string.
+*/
+var RoutingRequestError = class extends Error {
+	status;
+	constructor(status, statusText) {
+		super(`Routing request failed (${status} ${statusText})`);
+		this.name = "RoutingRequestError";
+		this.status = status;
+	}
+};
+async function postJson(url, body, signal) {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+		signal
 	});
-	return {
-		ok: true,
-		errors: [],
-		ids,
-		errorCount
-	};
+	if (!response.ok) throw new RoutingRequestError(response.status, response.statusText);
+	return response.json();
 }
 /**
-* True when a preview value is a real style-spec `Color` instance (its
-* evaluated color representation: premultiplied r/g/b/a floats). Shared by
-* the preview formatter and the dialog's color-swatch rendering so the two
-* checks cannot drift apart. An instanceof check (not duck typing) so user
-* attribute data that happens to carry numeric r/g/b/a fields (e.g. via
-* `["properties"]`) is never misclassified as a color.
+* Requests an isochrone from the Valhalla server.
+*
+* @param endpoint - The Valhalla base URL.
+* @param body - The request body from {@link buildIsochroneRequest}.
+* @param signal - Optional abort signal.
+* @returns The Valhalla GeoJSON response.
 */
-function isStyleSpecColor(value) {
-	return value instanceof Color;
+function requestIsochrone(endpoint, body, signal) {
+	return postJson(`${stripTrailingSlash(endpoint)}/isochrone`, body, signal);
 }
 /**
-* Renders a preview value as a short display string: style-spec Color
-* instances become rgba() strings, plain values render as JSON, and
-* `null`/`undefined` render as "null".
+* Requests an OD cost matrix from the Valhalla server.
+*
+* @param endpoint - The Valhalla base URL.
+* @param body - The request body from {@link buildMatrixRequest}.
+* @param signal - Optional abort signal.
+* @returns The Valhalla matrix response.
 */
-function formatExpressionPreviewValue(value) {
-	if (value === null || value === void 0) return "null";
-	if (isStyleSpecColor(value)) {
-		const color = value;
-		const alpha = color.a;
-		const channel = (component) => Math.round((alpha === 0 ? 0 : component / alpha) * 255);
-		return `rgba(${channel(color.r)}, ${channel(color.g)}, ${channel(color.b)}, ${Number(alpha.toFixed(3))})`;
-	}
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
+function requestMatrix(endpoint, body, signal) {
+	return postJson(`${stripTrailingSlash(endpoint)}/sources_to_targets`, body, signal);
 }
 /**
-* Infers a display type for each named field by scanning feature properties:
-* a single consistent primitive type wins, disagreements become "mixed", and
-* fields with no non-null values are "unknown".
+* Requests a route through ordered waypoints from the Valhalla server.
+*
+* @param endpoint - The Valhalla base URL.
+* @param body - The request body from {@link buildRouteRequest}.
+* @param signal - Optional abort signal.
+* @returns The Valhalla `/route` response.
 */
-function inferFieldTypes(features, names) {
-	const result = {};
-	for (const name of names) result[name] = "unknown";
-	for (const feature of features) {
-		const properties = feature.properties;
-		if (!properties) continue;
-		for (const name of names) {
-			const value = properties[name];
-			if (value === null || value === void 0) continue;
-			const valueType = typeof value;
-			const fieldType = valueType === "string" || valueType === "number" || valueType === "boolean" ? valueType : "mixed";
-			if (result[name] === "unknown") result[name] = fieldType;
-			else if (result[name] !== fieldType) result[name] = "mixed";
-		}
-	}
-	return result;
+function requestRoute(endpoint, body, signal) {
+	return postJson(`${stripTrailingSlash(endpoint)}/route`, body, signal);
 }
 //#endregion
 //#region src/vector-color.ts
@@ -4895,6 +3552,429 @@ function featureForEvaluation(properties, feature) {
 	};
 }
 //#endregion
+//#region src/layer-descriptive-metadata.ts
+/** STAC specification version the Item export targets. */
+const STAC_VERSION = "1.0.0";
+/** Schema URL of the STAC processing extension, declared for `processing:lineage`. */
+const STAC_PROCESSING_EXTENSION = "https://stac-extensions.github.io/processing/v1.1.0/schema.json";
+/** URL schemes a metadata link (or asset) may use. */
+const ALLOWED_LINK_PROTOCOLS = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"ftp:",
+	"s3:",
+	"gs:",
+	"mailto:"
+]);
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DATE_TIME_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?$/i;
+/** The STAC 1.0 `license` pattern (an SPDX identifier, `various` or `proprietary`). */
+const STAC_LICENSE_PATTERN = /^[\w\-.+]+$/;
+/**
+* Trim a value to a non-empty string, or `undefined`.
+*
+* @param value - Any value.
+* @returns The trimmed string, or `undefined` for a non-string or blank value.
+*/
+function cleanString(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+/**
+* Split comma-separated keyword text into a clean keyword list.
+*
+* @param text - Text such as `"roads, transport,  osm"`.
+* @returns The trimmed, non-empty keywords with case-insensitive duplicates removed.
+*/
+function parseMetadataKeywords(text) {
+	return normalizeKeywords(text.split(","));
+}
+function normalizeKeywords(value) {
+	if (!Array.isArray(value)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const keywords = [];
+	for (const entry of value) {
+		const keyword = cleanString(entry);
+		if (!keyword) continue;
+		const key = keyword.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		keywords.push(keyword);
+	}
+	return keywords;
+}
+function normalizeContact(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const raw = value;
+	const contact = {};
+	const name = cleanString(raw.name);
+	const email = cleanString(raw.email);
+	const organization = cleanString(raw.organization);
+	if (name) contact.name = name;
+	if (email) contact.email = email;
+	if (organization) contact.organization = organization;
+	return Object.keys(contact).length > 0 ? contact : void 0;
+}
+function normalizeTemporalExtent(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const raw = value;
+	const extent = {};
+	const start = cleanString(raw.start);
+	const end = cleanString(raw.end);
+	if (start) extent.start = start;
+	if (end) extent.end = end;
+	return Object.keys(extent).length > 0 ? extent : void 0;
+}
+function normalizeLinks(value) {
+	if (!Array.isArray(value)) return [];
+	const links = [];
+	for (const entry of value) {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+		const raw = entry;
+		const href = cleanString(raw.href);
+		if (!href) continue;
+		const link = { href };
+		const rel = cleanString(raw.rel);
+		const title = cleanString(raw.title);
+		if (rel) link.rel = rel;
+		if (title) link.title = title;
+		links.push(link);
+	}
+	return links;
+}
+/**
+* Normalize a raw descriptive-metadata value (from a project file, a plugin or
+* the Metadata dialog): keep only string fields, trim them, and drop empty
+* fields, empty keywords and links without an address.
+*
+* Values are not validated here — a malformed email or date in a hand-edited
+* file is kept so the dialog can show and fix it rather than silently lose it.
+*
+* @param value - Any value.
+* @returns The cleaned record, or `undefined` when nothing is left, so an
+*   empty record is never written to a project.
+*/
+function normalizeLayerDescriptiveMetadata(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const raw = value;
+	const metadata = {};
+	for (const key of [
+		"title",
+		"abstract",
+		"license",
+		"attribution",
+		"lineage"
+	]) {
+		const text = cleanString(raw[key]);
+		if (text) metadata[key] = text;
+	}
+	const keywords = normalizeKeywords(raw.keywords);
+	if (keywords.length > 0) metadata.keywords = keywords;
+	const contact = normalizeContact(raw.contact);
+	if (contact) metadata.contact = contact;
+	const temporalExtent = normalizeTemporalExtent(raw.temporalExtent);
+	if (temporalExtent) metadata.temporalExtent = temporalExtent;
+	const links = normalizeLinks(raw.links);
+	if (links.length > 0) metadata.links = links;
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+/**
+* Whether a string is a plausible email address (`local@domain.tld`).
+*
+* @param value - The candidate address.
+* @returns `true` when it has the shape of an email address.
+*/
+function isValidMetadataEmail(value) {
+	return EMAIL_PATTERN.test(value.trim());
+}
+/**
+* Whether a string is an absolute URL with a scheme a metadata link may use
+* (http, https, ftp, s3, gs, mailto). Script and data URLs are rejected.
+*
+* @param value - The candidate URL.
+* @returns `true` when it parses as an allowed absolute URL.
+*/
+function isValidMetadataUrl(value) {
+	try {
+		const url = new URL(value.trim());
+		return ALLOWED_LINK_PROTOCOLS.has(url.protocol);
+	} catch {
+		return false;
+	}
+}
+/**
+* Whether the calendar fields name a real day (rejecting e.g. February 30).
+*
+* @param year - Four-digit year.
+* @param month - Month, 1-12.
+* @param day - Day of month.
+* @returns `true` when the date exists.
+*/
+function isRealDate(year, month, day) {
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(year, month - 1, day);
+	return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+/**
+* Whether a string is an ISO 8601 date (`YYYY-MM-DD`) or date-time
+* (`YYYY-MM-DDTHH:MM[:SS[.fff]][Z|±HH:MM]`) naming a real instant.
+*
+* @param value - The candidate date.
+* @returns `true` when it is a valid ISO 8601 date or date-time.
+*/
+function isValidMetadataDate(value) {
+	const text = value.trim();
+	const dateOnly = DATE_ONLY_PATTERN.exec(text);
+	if (dateOnly) return isRealDate(Number(dateOnly[1]), Number(dateOnly[2]), Number(dateOnly[3]));
+	const dateTime = DATE_TIME_PATTERN.exec(text);
+	if (!dateTime) return false;
+	if (!isRealDate(Number(dateTime[1]), Number(dateTime[2]), Number(dateTime[3]))) return false;
+	const hours = Number(dateTime[4]);
+	const minutes = Number(dateTime[5]);
+	const seconds = dateTime[6] === void 0 ? 0 : Number(dateTime[6]);
+	return hours < 24 && minutes < 60 && seconds < 60;
+}
+/**
+* Convert a validated metadata date to an RFC 3339 UTC date-time, as STAC
+* requires. A date-only bound covers its whole day: a start becomes the first
+* second of the day, an end the last. A date-time without an offset is read
+* as UTC so the export does not depend on the exporting machine's time zone.
+*
+* @param value - A date accepted by {@link isValidMetadataDate}.
+* @param bound - Whether the value starts or ends an interval.
+* @returns The RFC 3339 date-time, or `null` for an invalid date.
+*/
+function metadataDateToRfc3339(value, bound) {
+	const text = value.trim();
+	if (!isValidMetadataDate(text)) return null;
+	if (DATE_ONLY_PATTERN.test(text)) return `${text}T${bound === "start" ? "00:00:00" : "23:59:59"}Z`;
+	const normalized = text.toUpperCase().replace(" ", "T").replace(/([+-]\d{2})(\d{2})$/, "$1:$2");
+	const hasOffset = /(Z|[+-]\d{2}:\d{2})$/.test(normalized);
+	const parsed = new Date(hasOffset ? normalized : `${normalized}Z`);
+	return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+/**
+* Validate the fields of a descriptive-metadata record that have a format:
+* the contact email, the temporal-extent dates (and their order), and the
+* link URLs. Free-text fields are not checked.
+*
+* @param metadata - The record to check (normalized or a dialog draft).
+* @returns Every failure found; empty when the record is valid.
+*/
+function validateLayerDescriptiveMetadata(metadata) {
+	const issues = [];
+	if (!metadata) return issues;
+	const email = cleanString(metadata.contact?.email);
+	if (email && !isValidMetadataEmail(email)) issues.push({
+		field: "contact.email",
+		code: "email"
+	});
+	const start = cleanString(metadata.temporalExtent?.start);
+	const end = cleanString(metadata.temporalExtent?.end);
+	const startValid = start ? isValidMetadataDate(start) : true;
+	const endValid = end ? isValidMetadataDate(end) : true;
+	if (!startValid) issues.push({
+		field: "temporalExtent.start",
+		code: "date"
+	});
+	if (!endValid) issues.push({
+		field: "temporalExtent.end",
+		code: "date"
+	});
+	if (start && end && startValid && endValid) {
+		if (Date.parse(metadataDateToRfc3339(start, "start") ?? "") > Date.parse(metadataDateToRfc3339(end, "end") ?? "")) issues.push({
+			field: "temporalExtent.end",
+			code: "dateOrder"
+		});
+	}
+	(metadata.links ?? []).forEach((link, index) => {
+		const href = cleanString(link?.href);
+		if (href && !isValidMetadataUrl(href)) issues.push({
+			field: `links.${index}.href`,
+			code: "url"
+		});
+	});
+	return issues;
+}
+/**
+* Validate a WGS84 bounding box.
+*
+* @param bbox - Candidate `[west, south, east, north]`.
+* @returns The box, or `null` when it is not four finite in-range numbers.
+*/
+function validBbox(bbox) {
+	if (!bbox || bbox.length !== 4) return null;
+	if (!bbox.every((value) => typeof value === "number" && Number.isFinite(value))) return null;
+	const [west, south, east, north] = bbox;
+	if (south < -90 || north > 90 || south > north) return null;
+	if (west < -180 || west > 180 || east < -180 || east > 180) return null;
+	return [
+		west,
+		south,
+		east,
+		north
+	];
+}
+/**
+* The GeoJSON geometry covering a bounding box: a Point for a degenerate box,
+* a MultiPolygon split at the antimeridian when `west > east` (the STAC
+* convention for a box crossing it), otherwise a Polygon.
+*
+* @param bbox - A box accepted by {@link validBbox}.
+* @returns The footprint geometry.
+*/
+function bboxGeometry([west, south, east, north]) {
+	if (west === east && south === north) return {
+		type: "Point",
+		coordinates: [west, south]
+	};
+	if (west === east || south === north) return {
+		type: "LineString",
+		coordinates: [[west, south], [east, north]]
+	};
+	const ring = (w, e) => [
+		[w, south],
+		[e, south],
+		[e, north],
+		[w, north],
+		[w, south]
+	];
+	if (west > east) return {
+		type: "MultiPolygon",
+		coordinates: [[ring(west, 180)], [ring(-180, east)]]
+	};
+	return {
+		type: "Polygon",
+		coordinates: [ring(west, east)]
+	};
+}
+/** Media types by data-file extension, for the Item's data asset. */
+const ASSET_MEDIA_TYPES = {
+	geojson: "application/geo+json",
+	json: "application/json",
+	tif: "image/tiff; application=geotiff",
+	tiff: "image/tiff; application=geotiff",
+	parquet: "application/vnd.apache.parquet",
+	geoparquet: "application/vnd.apache.parquet",
+	fgb: "application/vnd.flatgeobuf",
+	pmtiles: "application/vnd.pmtiles",
+	gpkg: "application/geopackage+sqlite3",
+	kml: "application/vnd.google-earth.kml+xml",
+	kmz: "application/vnd.google-earth.kmz",
+	csv: "text/csv",
+	zip: "application/zip",
+	las: "application/vnd.las",
+	laz: "application/vnd.laszip",
+	zarr: "application/vnd+zarr"
+};
+/**
+* Guess the media type of a layer's data asset from the URL's extension, or
+* the layer type when the URL has none (a COG is flagged cloud-optimized).
+*
+* @param href - The asset URL.
+* @param layerType - The layer's type.
+* @returns The media type, or `undefined` when it cannot be told.
+*/
+function stacAssetMediaType(href, layerType) {
+	let path = href;
+	try {
+		path = new URL(href).pathname;
+	} catch {}
+	const extension = /\.([a-z0-9]+)$/i.exec(path.replace(/\/+$/, ""))?.[1]?.toLowerCase();
+	if (layerType === "cog" && (extension === "tif" || extension === "tiff" || !extension)) return "image/tiff; application=geotiff; profile=cloud-optimized";
+	if (extension && ASSET_MEDIA_TYPES[extension]) return ASSET_MEDIA_TYPES[extension];
+	if (layerType === "geojson" && !extension) return "application/geo+json";
+}
+/**
+* Build a STAC 1.0 Item describing a layer from its descriptive metadata.
+*
+* Mapping: `id` is the layer id; `geometry`/`bbox` come from the WGS84 extent
+* (a `null` geometry, as STAC allows, when the extent is unknown); `title`
+* falls back to the layer name; `abstract` becomes `description`; the contact
+* becomes a `producer` provider; `lineage` becomes `processing:lineage` (with
+* the processing extension declared); the temporal extent becomes `datetime`
+* or `start_datetime`/`end_datetime` (with `datetime` set to the export time
+* when none is recorded, since STAC requires one); links keep their `rel`
+* (default `related`); and a source URL becomes the `data` asset.
+*
+* A license that is not an SPDX-style identifier (STAC 1.0's pattern) is
+* exported as `proprietary`, with the original text kept in
+* `geolibre:license`; the attribution is kept in `geolibre:attribution`.
+*
+* @param layer - The layer to describe.
+* @param options - Extent, asset URL and clock; see {@link LayerStacItemOptions}.
+* @returns The STAC Item, ready to `JSON.stringify`.
+*/
+function buildLayerStacItem(layer, options = {}) {
+	const metadata = normalizeLayerDescriptiveMetadata(layer.descriptiveMetadata) ?? {};
+	const now = options.now ?? /* @__PURE__ */ new Date();
+	const properties = { datetime: null };
+	properties.title = metadata.title ?? layer.name;
+	if (metadata.abstract) properties.description = metadata.abstract;
+	if (metadata.keywords?.length) properties.keywords = [...metadata.keywords];
+	const start = metadata.temporalExtent?.start ? metadataDateToRfc3339(metadata.temporalExtent.start, "start") : null;
+	const end = metadata.temporalExtent?.end ? metadataDateToRfc3339(metadata.temporalExtent.end, "end") : null;
+	if (start && end && Date.parse(start) !== Date.parse(end)) {
+		properties.start_datetime = start;
+		properties.end_datetime = end;
+	} else properties.datetime = start ?? end ?? now.toISOString();
+	if (metadata.license) {
+		if (STAC_LICENSE_PATTERN.test(metadata.license)) properties.license = metadata.license;
+		else {
+			properties.license = "proprietary";
+			properties["geolibre:license"] = metadata.license;
+		}
+	}
+	const contact = metadata.contact;
+	const providerName = contact?.organization ?? contact?.name ?? contact?.email;
+	if (contact && providerName) {
+		const person = [contact.organization && contact.name ? contact.name : void 0, contact.email].filter(Boolean);
+		const provider = {
+			name: providerName,
+			roles: ["producer"]
+		};
+		if (person.length > 0) provider.description = `Contact: ${person.join(", ")}`;
+		properties.providers = [provider];
+	}
+	if (metadata.attribution) properties["geolibre:attribution"] = metadata.attribution;
+	const extensions = [];
+	if (metadata.lineage) {
+		properties["processing:lineage"] = metadata.lineage;
+		extensions.push(STAC_PROCESSING_EXTENSION);
+	}
+	const links = (metadata.links ?? []).filter((link) => isValidMetadataUrl(link.href)).map((link) => ({
+		href: link.href,
+		rel: link.rel ?? "related",
+		...link.title ? { title: link.title } : {}
+	}));
+	const assets = {};
+	const assetHref = cleanString(options.assetHref);
+	if (assetHref) {
+		const templated = /\{[a-z]+\}/i.test(assetHref);
+		const type = templated ? void 0 : stacAssetMediaType(assetHref, layer.type);
+		assets[templated ? "tiles" : "data"] = {
+			href: assetHref,
+			...type ? { type } : {},
+			title: properties.title,
+			roles: [templated ? "tiles" : "data"]
+		};
+	}
+	const bbox = validBbox(options.bbox);
+	return {
+		type: "Feature",
+		stac_version: STAC_VERSION,
+		stac_extensions: extensions,
+		id: layer.id,
+		geometry: bbox ? bboxGeometry(bbox) : null,
+		...bbox ? { bbox } : {},
+		properties,
+		links,
+		assets
+	};
+}
+//#endregion
 //#region src/popup.ts
 /** Match an inline base64 raster image (excludes SVG, which can carry scripts). */
 const INLINE_IMAGE_DATA_URL = /^data:image\/(?!svg)[\w.+-]+;base64,/i;
@@ -5201,515 +4281,42 @@ function resolveConfiguredPopupTitle(properties, popup, options = {}) {
 		const text = stringifyPopupValue(evaluatePopupExpression(source, properties, options)).trim();
 		if (text) return text;
 	}
-	const field = trimmedString(popup?.titleField);
-	if (field && !options.fieldVisibility?.[field] && !isInternalPopupField(field)) {
-		const text = stringifyPopupValue(properties[field]).trim();
-		if (text) return text;
-	}
-	return null;
-}
-/**
-* The popup body text when the author supplied a body expression, or `null`
-* when there is none (or it failed) and the field rows should render instead.
-*/
-function resolvePopupBody(properties, popup, options = {}) {
-	const source = trimmedString(popup?.bodyExpression);
-	if (!source) return null;
-	const preview = evaluatePopupExpression(source, properties, options);
-	if (preview === void 0) return null;
-	const text = stringifyPopupValue(preview);
-	return text.trim() ? text : null;
-}
-/**
-* Whether a value should render as an inline image thumbnail under `"auto"`.
-* Kept here so the renderer and the designer's preview agree on what counts.
-*/
-function isInlineImageValue(value) {
-	return typeof value === "string" && INLINE_IMAGE_DATA_URL.test(value);
-}
-/**
-* Whether a URL is safe to put in a popup `href`/`src`. Only http(s) and
-* inline raster data URLs: a `javascript:` or `data:text/html` value coming
-* from an untrusted GeoJSON must never become a live link.
-*/
-function isSafePopupUrl(value, allowDataImage = false) {
-	if (typeof value !== "string") return false;
-	const trimmed = value.trim();
-	if (/^https?:\/\//i.test(trimmed)) return true;
-	return allowDataImage && INLINE_IMAGE_DATA_URL.test(trimmed);
-}
-//#endregion
-//#region src/virtual-fields.ts
-/**
-* Virtual fields (QGIS Field Calculator → "Create virtual field", issue
-* #1321): expression-backed columns that recompute live instead of being
-* written once as static values.
-*
-* The engine mirrors the persistent-joins engine (`joins.ts`): computed
-* values are materialized into feature properties, so every consumer of
-* attributes — the attribute table, Expression Builder, data-driven styling,
-* labels, selection, export — sees the column with no further wiring.
-* Idempotency uses the same bookkeeping: each applied field records the
-* column it actually added (`addedField`), applying always strips those
-* first, and an existing column always wins a name collision (the virtual
-* field is skipped entirely), so stripping exactly restores the pre-apply
-* properties.
-*
-* Expressions are declarative MapLibre expressions compiled through the
-* style spec — never arbitrary code — so persisting them in `.geolibre.json`
-* and re-evaluating them on project load is safe (unlike the attribute
-* table's Field Calculator, whose JavaScript evaluator must never run
-* persisted expressions). Fields apply in list order and each sees the
-* columns materialized by earlier fields, so a virtual field can build on
-* another. Zoom-dependent expressions evaluate at zoom 0 and `@` variables
-* are not substituted: a virtual field is a property of the data, not of the
-* current view.
-*
-* Known trade-off, shared with the joins engine (see `joins.ts`): when a
-* layer's data is replaced wholesale, the replacement is stripped with the
-* *previous* bookkeeping. That is required because a replacement can also be
-* a write-back of the derived output (the attribute table round-trips
-* `layer.geojson`), which must not freeze a stale computed value into base
-* data — but it means a replacement dataset's own column whose name matches a
-* previously-materialized virtual column is replaced by the expression's
-* value for that column. Renaming or removing the virtual field first keeps
-* such collisions from arising.
-*/
-/**
-* Remove every column previously added by `fields` (per their `addedField`
-* bookkeeping) from a copy of `features`, restoring the pre-apply properties.
-* Features without any tracked column are returned unchanged (same
-* reference).
-*/
-function stripVirtualFieldColumns(features, fields) {
-	const tracked = /* @__PURE__ */ new Set();
-	for (const field of fields ?? []) if (field.addedField) tracked.add(field.addedField);
-	if (tracked.size === 0) return features;
-	return features.map((feature) => {
-		const props = feature.properties;
-		if (!props) return feature;
-		let hasTracked = false;
-		for (const key of tracked) if (key in props) {
-			hasTracked = true;
-			break;
-		}
-		if (!hasTracked) return feature;
-		const next = {};
-		for (const [key, value] of Object.entries(props)) if (!tracked.has(key)) next[key] = value;
-		return {
-			...feature,
-			properties: next
-		};
-	});
-}
-/**
-* Normalize an evaluated expression value into a property value: `undefined`
-* and non-finite numbers become null (a clean empty cell), style-spec Color
-* instances become their rgba() string (a Color object would neither
-* serialize nor display usefully), everything else passes through.
-*/
-function normalizeComputedValue(value) {
-	if (value === void 0) return null;
-	if (typeof value === "number" && !Number.isFinite(value)) return null;
-	if (isStyleSpecColor(value)) return formatExpressionPreviewValue(value);
-	return value;
-}
-/**
-* Apply `fields` in order to base (already-stripped) `features`, returning
-* new feature objects with each computed column merged into their properties.
-*
-* Semantics per field: a disabled field, an empty/colliding output name, or
-* an expression that fails to compile contributes nothing (with the compile
-* error recorded on the field); a runtime evaluation failure nulls that one
-* feature's cell and increments the field's `errorCount` instead of aborting
-* the column. Fields evaluate sequentially, so a later field's expression
-* can `["get", ...]` an earlier field's column.
-*/
-function applyLayerVirtualFields(features, fields) {
-	const fieldList = fields ?? [];
-	const clearBookkeeping = (field) => ({
-		...field,
-		addedField: void 0,
-		error: void 0,
-		errorCount: void 0
-	});
-	if (fieldList.filter((field) => field.enabled !== false).length === 0) return {
-		features,
-		fields: fieldList.map(clearBookkeeping)
-	};
-	const usedNames = /* @__PURE__ */ new Set();
-	for (const feature of features) for (const key of Object.keys(feature.properties ?? {})) usedNames.add(key);
-	const out = features.map((feature) => ({
-		...feature,
-		properties: { ...feature.properties ?? {} }
-	}));
-	return {
-		features: out,
-		fields: fieldList.map((field) => {
-			if (field.enabled === false) return clearBookkeeping(field);
-			const name = field.name.trim();
-			if (!name || usedNames.has(name)) return clearBookkeeping(field);
-			const compiled = compileFeatureExpression(field.expression);
-			if (!compiled.ok || !compiled.evaluate) return {
-				...clearBookkeeping(field),
-				error: compiled.errors[0] ?? "Invalid expression"
-			};
-			usedNames.add(name);
-			let errorCount = 0;
-			for (const feature of out) {
-				let value = null;
-				try {
-					value = normalizeComputedValue(compiled.evaluate(feature));
-				} catch {
-					errorCount += 1;
-				}
-				feature.properties[name] = value;
-			}
-			return {
-				...clearBookkeeping(field),
-				addedField: name,
-				...errorCount > 0 ? { errorCount } : {}
-			};
-		})
-	};
-}
-//#endregion
-//#region src/joins.ts
-/**
-* Persistent attribute joins (QGIS Layer Properties → Joins), issue #1315.
-*
-* A layer's `joins` are live left joins that materialize columns from another
-* layer's attribute table into this layer's feature properties. Materializing
-* (rather than resolving lazily) means every consumer of attributes — the
-* attribute table, Expression Builder, data-driven styling, labels, diagrams,
-* export — sees the joined columns with no further wiring.
-*
-* Idempotency without a duplicate base copy: each applied join records the
-* output column names it added (`addedFields`), and applying joins always
-* strips those first. Base columns win every name collision (a joined column
-* whose output name already exists is skipped entirely), so stripping the
-* added columns exactly restores the pre-join properties.
-*
-* Known trade-off of that bookkeeping: when a layer's data is replaced
-* wholesale (file reload), the replacement is stripped with the *previous*
-* `addedFields`. That is required because a replacement can also be a
-* write-back of the joined output (the attribute table round-trips
-* `layer.geojson`), which must not freeze stale joined values into base data —
-* but it means a reloaded base column whose name collides with a
-* previously-joined output column is replaced by the join's value for that
-* column. A field-name prefix (the QGIS convention the UI suggests) keeps
-* such collisions from arising.
-*
-* The data is already in memory as JS feature objects, so the join is a plain
-* hash join here rather than the DuckDB-WASM SQL statement sketched in the
-* issue — the result is identical for equality keys and the engine stays
-* synchronous and dependency-free. Key semantics deliberately mirror the
-* Processing → Vector attribute join (and the sidecar's `_attribute_join_key`):
-* empty values never match, and non-empty values compare stringified.
-*/
-/** Canonical JSON for object values (sorted keys), matching the processing engine. */
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (value !== null && typeof value === "object") return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-	return JSON.stringify(value) ?? "null";
-}
-function valueToString(value) {
-	if (typeof value === "boolean") return value ? "true" : "false";
-	if (value !== null && typeof value === "object") return stableStringify(value);
-	return String(value);
-}
-/**
-* Match key for a persistent join: empty values (null/undefined/NaN/empty
-* string) never match a row, mirroring a SQL/pandas NaN join key. Non-empty
-* values are keyed by their string form, so a numeric `5` and the string `"5"`
-* join while a zero-padded code like `"01001"` only matches another `"01001"`.
-* Kept in sync with the Processing attribute join's `attributeJoinKey`.
-*/
-function layerJoinKey(value) {
-	return value === null || value === void 0 || typeof value === "number" && Number.isNaN(value) || valueToString(value) === "" ? null : valueToString(value);
-}
-/** GeoJSON columns are own properties; inherited object members are not data. */
-function fieldValue(properties, field) {
-	return properties && Object.hasOwn(properties, field) ? properties[field] : void 0;
-}
-/**
-* Remove every column previously added by `joins` (per their `addedFields`
-* bookkeeping) from a copy of `features`, restoring the pre-join properties.
-* Features without any tracked column are returned unchanged (same reference).
-*/
-function stripJoinFields(features, joins) {
-	const tracked = /* @__PURE__ */ new Set();
-	for (const join of joins ?? []) for (const field of join.addedFields ?? []) tracked.add(field);
-	if (tracked.size === 0) return features;
-	return features.map((feature) => {
-		const props = feature.properties;
-		if (!props) return feature;
-		let hasTracked = false;
-		for (const key of tracked) if (key in props) {
-			hasTracked = true;
-			break;
-		}
-		if (!hasTracked) return feature;
-		const next = {};
-		for (const [key, value] of Object.entries(props)) if (!tracked.has(key)) next[key] = value;
-		return {
-			...feature,
-			properties: next
-		};
-	});
-}
-/**
-* Apply `joins` in order to base (already-stripped) `features`, returning new
-* feature objects with the joined columns merged into their properties.
-*
-* Semantics per join: left join, first matching join row wins, and joined
-* columns are null-filled on unmatched features so the schema stays
-* consistent. An output name (prefix + field) that collides with an existing
-* column — from the base data or an earlier join — drops that one column;
-* the join's other columns still apply. A disabled join, or one whose source
-* cannot be resolved, contributes nothing and gets empty `addedFields` and no
-* stats.
-*
-* @param features - The layer's base features (strip previous joins first).
-* @param joins - Join definitions in application order.
-* @param resolveSource - Maps a join's `joinLayerId` to that layer's current
-*   feature collection, or `undefined` when the layer is gone (or is the
-*   target itself; self-joins are refused by the caller).
-*/
-function applyLayerJoins(features, joins, resolveSource) {
-	const joinList = joins ?? [];
-	const resolved = /* @__PURE__ */ new Map();
-	const resolveOnce = (joinLayerId) => {
-		if (!resolved.has(joinLayerId)) resolved.set(joinLayerId, resolveSource(joinLayerId));
-		return resolved.get(joinLayerId);
-	};
-	if (joinList.filter((join) => join.enabled !== false && resolveOnce(join.joinLayerId)).length === 0) return {
-		features,
-		joins: joinList.map((join) => ({
-			...join,
-			addedFields: [],
-			stats: void 0
-		}))
-	};
-	const out = features.map((feature) => ({
-		...feature,
-		properties: { ...feature.properties ?? {} }
-	}));
-	const usedNames = /* @__PURE__ */ new Set();
-	for (const feature of features) for (const key of Object.keys(feature.properties ?? {})) usedNames.add(key);
-	return {
-		features: out,
-		joins: joinList.map((join) => {
-			const source = join.enabled === false ? void 0 : resolveOnce(join.joinLayerId);
-			if (!source) return {
-				...join,
-				addedFields: [],
-				stats: void 0
-			};
-			const joinFeatures = (source.features ?? []).filter(Boolean);
-			const joinKeysOrder = [];
-			const joinKeySet = /* @__PURE__ */ new Set();
-			for (const jf of joinFeatures) for (const key of Object.keys(jf.properties ?? {})) if (!joinKeySet.has(key)) {
-				joinKeySet.add(key);
-				joinKeysOrder.push(key);
-			}
-			const requested = join.fields !== void 0 ? join.fields.filter((field) => joinKeySet.has(field)) : joinKeysOrder.filter((key) => key !== join.joinField);
-			const prefix = join.prefix ?? "";
-			const fieldPairs = [];
-			for (const field of requested) {
-				const outputName = prefix + field;
-				if (usedNames.has(outputName)) continue;
-				usedNames.add(outputName);
-				fieldPairs.push([field, outputName]);
-			}
-			const lookup = /* @__PURE__ */ new Map();
-			for (const jf of joinFeatures) {
-				const key = layerJoinKey(fieldValue(jf.properties, join.joinField));
-				if (key === null || lookup.has(key)) continue;
-				lookup.set(key, jf.properties ?? {});
-			}
-			let matched = 0;
-			const targetKeys = /* @__PURE__ */ new Set();
-			for (const feature of out) {
-				const props = feature.properties;
-				const key = layerJoinKey(fieldValue(props, join.targetField));
-				if (key !== null) targetKeys.add(key);
-				const row = key === null ? void 0 : lookup.get(key);
-				if (row) {
-					matched += 1;
-					for (const [field, outputName] of fieldPairs) props[outputName] = fieldValue(row, field) ?? null;
-				} else for (const [, outputName] of fieldPairs) props[outputName] = null;
-			}
-			let unmatchedJoin = 0;
-			for (const jf of joinFeatures) {
-				const key = layerJoinKey(fieldValue(jf.properties, join.joinField));
-				if (key !== null && !targetKeys.has(key)) unmatchedJoin += 1;
-			}
-			return {
-				...join,
-				addedFields: fieldPairs.map(([, outputName]) => outputName),
-				stats: {
-					matchedCount: matched,
-					unmatchedTargetCount: out.length - matched,
-					unmatchedJoinCount: unmatchedJoin
-				}
-			};
-		})
-	};
+	const field = trimmedString(popup?.titleField);
+	if (field && !options.fieldVisibility?.[field] && !isInternalPopupField(field)) {
+		const text = stringifyPopupValue(properties[field]).trim();
+		if (text) return text;
+	}
+	return null;
 }
 /**
-* Strip-and-reapply this layer's derived columns — persistent joins, then
-* virtual fields (so an expression can read joined columns) — resolving join
-* sources from `allLayers`. Pass `nextJoins`/`nextVirtualFields` to replace
-* the definitions (the layer's current bookkeeping still drives the strip, so
-* removed definitions clean up after themselves); omit them to refresh the
-* existing definitions against current data. Layers without a feature
-* collection are returned unchanged.
+* The popup body text when the author supplied a body expression, or `null`
+* when there is none (or it failed) and the field rows should render instead.
 */
-function applyJoinsToLayer(layer, allLayers, nextJoins, nextVirtualFields) {
-	const geojson = layer.geojson;
-	const joins = nextJoins ?? layer.joins ?? [];
-	const virtualFields = nextVirtualFields ?? layer.virtualFields ?? [];
-	if (!geojson) return {
-		...layer,
-		joins: joins.length > 0 ? joins : void 0,
-		virtualFields: virtualFields.length > 0 ? virtualFields : void 0
-	};
-	const applied = applyLayerJoins(stripJoinFields(stripVirtualFieldColumns(geojson.features ?? [], layer.virtualFields), layer.joins), joins, (joinLayerId) => {
-		if (joinLayerId === layer.id) return void 0;
-		return allLayers.find((candidate) => candidate.id === joinLayerId)?.geojson;
-	});
-	const withVirtual = applyLayerVirtualFields(applied.features, virtualFields);
-	return {
-		...layer,
-		geojson: {
-			...geojson,
-			features: withVirtual.features
-		},
-		joins: applied.joins.length > 0 ? applied.joins : void 0,
-		virtualFields: withVirtual.fields.length > 0 ? withVirtual.fields : void 0
-	};
+function resolvePopupBody(properties, popup, options = {}) {
+	const source = trimmedString(popup?.bodyExpression);
+	if (!source) return null;
+	const preview = evaluatePopupExpression(source, properties, options);
+	if (preview === void 0) return null;
+	const text = stringifyPopupValue(preview);
+	return text.trim() ? text : null;
 }
 /**
-* Ids of every layer whose data (directly or transitively) feeds `layerId`'s
-* joins, following `joinLayerId` edges through each source's own joins.
-* Disabled joins count too: re-enabling one must not spring a cycle. The Joins
-* UI uses this to keep a layer that already consumes the target — however
-* indirectly — out of the join-source picker, so circular joins cannot be
-* authored (the refresh cascade still breaks them defensively for hand-edited
-* projects).
+* Whether a value should render as an inline image thumbnail under `"auto"`.
+* Kept here so the renderer and the designer's preview agree on what counts.
 */
-function collectTransitiveJoinSourceIds(layers, layerId) {
-	const byId = new Map(layers.map((layer) => [layer.id, layer]));
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [layerId];
-	while (queue.length > 0) {
-		const current = byId.get(queue.shift());
-		for (const join of current?.joins ?? []) {
-			if (visited.has(join.joinLayerId)) continue;
-			visited.add(join.joinLayerId);
-			queue.push(join.joinLayerId);
-		}
-	}
-	return visited;
-}
-/**
-* Order `candidates` (layers with joins) so every layer comes after the
-* candidates its joins consume — Kahn's algorithm over "join source → join
-* target" edges within the candidate set. When a cycle blocks progress
-* (possible only in hand-edited projects; the UI refuses circular joins), an
-* actual cycle member is forced through — found by walking unmet-source edges
-* until a node repeats — so consumers *downstream* of the cycle still order
-* after it rather than falling back ahead of it.
-*/
-function topologicalJoinOrder(candidates) {
-	const candidateIds = new Set(candidates.map((layer) => layer.id));
-	const indegree = /* @__PURE__ */ new Map();
-	const dependents = /* @__PURE__ */ new Map();
-	const sourcesOf = /* @__PURE__ */ new Map();
-	for (const layer of candidates) indegree.set(layer.id, 0);
-	for (const layer of candidates) for (const join of layer.joins ?? []) {
-		if (join.enabled === false || join.joinLayerId === layer.id || !candidateIds.has(join.joinLayerId)) continue;
-		indegree.set(layer.id, (indegree.get(layer.id) ?? 0) + 1);
-		const list = dependents.get(join.joinLayerId) ?? [];
-		list.push(layer.id);
-		dependents.set(join.joinLayerId, list);
-		const sources = sourcesOf.get(layer.id) ?? [];
-		sources.push(join.joinLayerId);
-		sourcesOf.set(layer.id, sources);
-	}
-	const order = [];
-	const orderedSet = /* @__PURE__ */ new Set();
-	const queue = candidates.filter((layer) => indegree.get(layer.id) === 0).map((layer) => layer.id);
-	while (order.length < candidates.length) {
-		if (queue.length === 0) {
-			const start = candidates.find((layer) => !orderedSet.has(layer.id));
-			if (!start) break;
-			let cursor = start.id;
-			const walked = /* @__PURE__ */ new Set();
-			while (!walked.has(cursor)) {
-				walked.add(cursor);
-				const next = (sourcesOf.get(cursor) ?? []).find((source) => !orderedSet.has(source));
-				if (next === void 0) break;
-				cursor = next;
-			}
-			queue.push(cursor);
-		}
-		const id = queue.shift();
-		if (orderedSet.has(id)) continue;
-		orderedSet.add(id);
-		order.push(id);
-		for (const dependent of dependents.get(id) ?? []) {
-			const remaining = (indegree.get(dependent) ?? 1) - 1;
-			indegree.set(dependent, remaining);
-			if (remaining === 0 && !orderedSet.has(dependent)) queue.push(dependent);
-		}
-	}
-	return order;
-}
-/**
-* Refresh every layer whose joins (directly or transitively) consume the
-* layer identified by `seedId`, after that layer's data changed — or after it
-* was removed (a gone source resolves to nothing, so its frozen columns strip
-* away). The affected layers re-derive in topological dependency order, so a
-* layer joining two other affected layers sees both of them fresh regardless
-* of their positions in the layer panel. The seed itself is not touched.
-*/
-function cascadeLayerJoinRefresh(layers, seedId) {
-	const affected = /* @__PURE__ */ new Set();
-	const queue = [seedId];
-	while (queue.length > 0) {
-		const sourceId = queue.shift();
-		for (const layer of layers) {
-			if (layer.id === seedId || affected.has(layer.id)) continue;
-			if (layer.joins?.some((join) => join.enabled !== false && join.joinLayerId === sourceId)) {
-				affected.add(layer.id);
-				queue.push(layer.id);
-			}
-		}
-	}
-	if (affected.size === 0) return layers;
-	let current = layers;
-	const order = topologicalJoinOrder(layers.filter((layer) => affected.has(layer.id)));
-	for (const id of order) current = current.map((layer) => layer.id === id ? applyJoinsToLayer(layer, current) : layer);
-	return current;
+function isInlineImageValue(value) {
+	return typeof value === "string" && INLINE_IMAGE_DATA_URL.test(value);
 }
 /**
-* Re-resolve every layer's persistent joins against the freshly loaded layer
-* set (project open). Layers re-derive in topological order of their join
-* dependencies, so a chain (`C joins A, A joins B`) resolves A before C; a
-* hand-edited cycle is broken by forcing one of its members through first
-* (see {@link topologicalJoinOrder}), so consumers downstream of the cycle
-* still re-derive after it. Layers with virtual fields but no joins re-derive
-* too (their expressions run against the freshly loaded features). Layer sets
-* without joins or virtual fields pass through by reference.
+* Whether a URL is safe to put in a popup `href`/`src`. Only http(s) and
+* inline raster data URLs: a `javascript:` or `data:text/html` value coming
+* from an untrusted GeoJSON must never become a live link.
 */
-function reapplyLayerJoins(layers) {
-	const joined = layers.filter((layer) => layer.joins?.length || layer.virtualFields?.length);
-	if (joined.length === 0) return layers;
-	let current = layers;
-	for (const id of topologicalJoinOrder(joined)) current = current.map((layer) => layer.id === id ? applyJoinsToLayer(layer, current) : layer);
-	return current;
+function isSafePopupUrl(value, allowDataImage = false) {
+	if (typeof value !== "string") return false;
+	const trimmed = value.trim();
+	if (/^https?:\/\//i.test(trimmed)) return true;
+	return allowDataImage && INLINE_IMAGE_DATA_URL.test(trimmed);
 }
 //#endregion
 //#region src/quick-filters.ts
@@ -8567,7 +7174,7 @@ const RASTER_APPEARANCE_STATE_KEYS = [
 	"stretch",
 	"gamma"
 ];
-function isPlainObject$3(value) {
+function isPlainObject$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -8604,11 +7211,11 @@ function extractCopiedLayerStyle(layer) {
 	};
 	const rasterState = layer.metadata.rasterState;
 	const rasterSymbology = layer.metadata.rasterSymbology;
-	const hasRasterSymbology = isPlainObject$3(rasterSymbology);
+	const hasRasterSymbology = isPlainObject$4(rasterSymbology);
 	return {
 		kind,
 		sourceName: layer.name,
-		rasterState: isPlainObject$3(rasterState) ? structuredClone(rasterState) : void 0,
+		rasterState: isPlainObject$4(rasterState) ? structuredClone(rasterState) : void 0,
 		hasRasterSymbology,
 		...hasRasterSymbology ? { rasterSymbology: structuredClone(rasterSymbology) } : {}
 	};
@@ -8625,7 +7232,7 @@ function extractCopiedLayerStyle(layer) {
 function applyCopiedLayerStyle(target, copied) {
 	if (copyableLayerStyleKind(target) !== copied.kind) return null;
 	if (copied.kind === "vector") return { style: structuredClone(copied.style) };
-	const targetState = isPlainObject$3(target.metadata.rasterState) ? target.metadata.rasterState : {};
+	const targetState = isPlainObject$4(target.metadata.rasterState) ? target.metadata.rasterState : {};
 	const source = copied.rasterState ?? {};
 	const expectedRescaleLength = rescaleEntryCount(targetState);
 	const mergedState = { ...targetState };
@@ -8657,7 +7264,7 @@ function rescaleEntryCount(state) {
 const LAYER_STYLES_FILE_TYPE = "geolibre-layer-styles";
 /** Format version written by {@link serializeLayerStylesFile}. */
 const LAYER_STYLES_FILE_VERSION = 1;
-function isPlainObject$2(value) {
+function isPlainObject$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -8683,7 +7290,7 @@ function extractLayerStyleEntries(layers) {
 			layerName: layer.name,
 			kind: "raster",
 			...copied.rasterState ? { rasterState: copied.rasterState } : {},
-			...isPlainObject$2(copied.rasterSymbology) ? { rasterSymbology: copied.rasterSymbology } : {}
+			...isPlainObject$3(copied.rasterSymbology) ? { rasterSymbology: copied.rasterSymbology } : {}
 		});
 	}
 	return entries;
@@ -8747,11 +7354,11 @@ function normalizeLayerStyleEntries(value) {
 	if (!Array.isArray(value)) return [];
 	const entries = [];
 	for (const item of value) {
-		if (!isPlainObject$2(item)) continue;
+		if (!isPlainObject$3(item)) continue;
 		const layerName = typeof item.layerName === "string" ? item.layerName : "";
 		if (!layerName.trim()) continue;
 		if (item.kind === "vector") {
-			if (!isPlainObject$2(item.style)) continue;
+			if (!isPlainObject$3(item.style)) continue;
 			entries.push({
 				layerName,
 				kind: "vector",
@@ -8763,8 +7370,8 @@ function normalizeLayerStyleEntries(value) {
 		} else if (item.kind === "raster") entries.push({
 			layerName,
 			kind: "raster",
-			...isPlainObject$2(item.rasterState) ? { rasterState: sanitizeRasterAppearanceState(item.rasterState) } : {},
-			...isPlainObject$2(item.rasterSymbology) ? { rasterSymbology: structuredClone(item.rasterSymbology) } : {}
+			...isPlainObject$3(item.rasterState) ? { rasterState: sanitizeRasterAppearanceState(item.rasterState) } : {},
+			...isPlainObject$3(item.rasterSymbology) ? { rasterSymbology: structuredClone(item.rasterSymbology) } : {}
 		});
 	}
 	return entries;
@@ -8784,7 +7391,7 @@ function parseLayerStylesFile(json) {
 	} catch {
 		throw new Error("Not a valid layer styles file (invalid JSON).");
 	}
-	if (!isPlainObject$2(parsed) || parsed.type !== "geolibre-layer-styles") throw new Error("Not a valid layer styles file.");
+	if (!isPlainObject$3(parsed) || parsed.type !== "geolibre-layer-styles") throw new Error("Not a valid layer styles file.");
 	if (parsed.version !== 1) throw new Error("Unsupported layer styles file version.");
 	const entries = normalizeLayerStyleEntries(parsed.styles);
 	if (entries.length === 0) throw new Error("The layer styles file holds no usable styles.");
@@ -8930,6 +7537,7 @@ const createLayersSlice = (set, get) => ({
 	}),
 	setLayerAttributeForm: (id, attributeForm) => get().updateLayer(id, { attributeForm }),
 	setLayerPopup: (id, popup) => get().updateLayer(id, { popup }),
+	setLayerDescriptiveMetadata: (id, metadata) => get().updateLayer(id, { descriptiveMetadata: normalizeLayerDescriptiveMetadata(metadata) }),
 	setLayerEditorTracking: (id, editorTracking) => get().updateLayer(id, { editorTracking }),
 	setLayerVirtualFields: (id, fields) => set((s) => {
 		let layers = s.layers.map((l) => l.id === id ? applyJoinsToLayer(l, s.layers, void 0, fields) : l);
@@ -9707,6 +8315,16 @@ function isCredentialParam(name) {
 	const lowered = decoded.toLowerCase();
 	return URL_CREDENTIAL_PARAMS.has(normalizeCredentialName(lowered)) || lowered.startsWith("x-amz-");
 }
+/**
+* Whether a URL query-parameter name carries a credential. This is the wider of
+* the two registries (see `URL_CREDENTIAL_PARAMS`). Exported so a caller that
+* must leave the parameter in place — the native diagnostics log rewrites its
+* value to `[redacted]` rather than dropping the pair — shares this registry
+* instead of keeping a second, narrower list that can drift from it.
+*/
+function isCredentialUrlParam(name) {
+	return isCredentialParam(name);
+}
 function redactParameterString(value) {
 	return value.split("&").filter((pair) => pair !== "" && !isCredentialParam(pair.split("=", 1)[0])).join("&");
 }
@@ -9733,7 +8351,7 @@ function redactUrlCredentials(value) {
 	const keptFragment = fragment === void 0 || !fragment.includes("=") ? fragment : redactParameterString(fragment);
 	return base + (keptQuery ? `?${keptQuery}` : "") + (keptFragment ? `#${keptFragment}` : "");
 }
-function isPlainObject$1(value) {
+function isPlainObject$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isGeoJsonPayload$1(value) {
@@ -9750,13 +8368,13 @@ function redactConfigurationValue(value, path, accumulator, depth = 0) {
 		return redacted;
 	}
 	if (Array.isArray(value)) return value.map((item, index) => redactConfigurationValue(item, `${path}[${index}]`, accumulator, depth + 1));
-	if (!isPlainObject$1(value)) return value;
+	if (!isPlainObject$2(value)) return value;
 	if (isGeoJsonPayload$1(value)) return structuredClone(value);
 	const result = {};
 	for (const [key, nested] of Object.entries(value)) {
 		const nestedPath = path ? `${path}.${key}` : key;
 		const normalizedKey = normalizeCredentialName(key);
-		if ((normalizedKey === "requestheaders" || normalizedKey === "headers") && isPlainObject$1(nested)) {
+		if ((normalizedKey === "requestheaders" || normalizedKey === "headers") && isPlainObject$2(nested)) {
 			const kept = {};
 			const removed = {};
 			for (const [name, headerValue] of Object.entries(nested)) if (typeof headerValue === "string" && isHeaderReferenceOnly(headerValue)) kept[name] = headerValue;
@@ -9775,10 +8393,46 @@ function redactConfigurationValue(value, path, accumulator, depth = 0) {
 }
 function countLeafValues(value) {
 	if (Array.isArray(value)) return value.reduce((count, item) => count + countLeafValues(item), 0);
-	if (isPlainObject$1(value)) return Object.values(value).reduce((count, nested) => count + countLeafValues(nested), 0);
+	if (isPlainObject$2(value)) return Object.values(value).reduce((count, nested) => count + countLeafValues(nested), 0);
 	return 1;
 }
 /**
+* Settings keys that registry-listed external plugins declared publishable,
+* keyed by plugin id. `null` keeps the whole blob. Populated at runtime by the
+* host from the curated plugin registry, never from the project file itself,
+* so a project cannot vouch for its own state. The Python mirror in
+* `python/src/geolibre/project.py` only knows the static built-in list, so a
+* project redacted there still drops these plugins' state.
+*/
+const registryPublishableSettings = /* @__PURE__ */ new Map();
+/**
+* Replace the registry-declared publishable plugin settings.
+*
+* Built-in ids in {@link PUBLISHABLE_PLUGIN_SETTINGS} always win, so a registry
+* entry cannot widen a first-party plugin's allowlist.
+*
+* @param entries Plugin ids mapped to the settings keys to keep, or `null` to
+*   keep the whole blob. Ids that declare nothing should be omitted.
+*/
+function setRegistryPublishableSettings(entries) {
+	registryPublishableSettings.clear();
+	for (const [id, keys] of entries) {
+		if (Object.prototype.hasOwnProperty.call(PUBLISHABLE_PLUGIN_SETTINGS, id)) continue;
+		registryPublishableSettings.set(id, keys);
+	}
+}
+/**
+* Look up the publishable settings for a plugin id.
+*
+* @param id Plugin id.
+* @returns `undefined` when nothing is publishable, `null` to keep the whole
+*   blob, otherwise the list of keys to keep.
+*/
+function publishableSettingsFor(id) {
+	if (Object.prototype.hasOwnProperty.call(PUBLISHABLE_PLUGIN_SETTINGS, id)) return PUBLISHABLE_PLUGIN_SETTINGS[id];
+	return registryPublishableSettings.get(id);
+}
+/**
 * Return a detached project safe for any external egress.
 *
 * Environment variables and geocoder keys are always removed. Layer
@@ -9790,7 +8444,9 @@ function countLeafValues(value) {
 * and carries no credentials, and dropping it stripped the legend, colorbar,
 * and swipe from the exported map. Manifest URLs, activation, and control
 * positions stay intact so recipients can still load and configure the plugin
-* themselves.
+* themselves. A registry-listed external plugin can opt in through the
+* `publishableSettings` field of its registry entry (see
+* {@link setRegistryPublishableSettings}); what it keeps is still swept below.
 */
 function redactProjectCredentials(project) {
 	const accumulator = {
@@ -9854,7 +8510,7 @@ function redactProjectCredentials(project) {
 		const kept = {};
 		const dropped = {};
 		for (const [id, value] of Object.entries(settings)) {
-			const allowed = Object.prototype.hasOwnProperty.call(PUBLISHABLE_PLUGIN_SETTINGS, id) ? PUBLISHABLE_PLUGIN_SETTINGS[id] : void 0;
+			const allowed = publishableSettingsFor(id);
 			if (allowed === void 0) {
 				dropped[id] = value;
 				continue;
@@ -9896,6 +8552,24 @@ function redactProjectCredentials(project) {
 		redactedCount: accumulator.count
 	};
 }
+/**
+* Remove credentials from a single configuration value (a layer `source`,
+* `metadata`, or `sourcePath`) with the same rules the project redaction pass
+* applies to layer configuration: credential-named fields and non-reference
+* header values are dropped, and credential URL parameters are stripped from
+* every URL-shaped string.
+*
+* @param value - The configuration value to scrub. Not mutated.
+* @returns A detached, redacted copy.
+*/
+function redactConfigurationCredentials(value) {
+	return redactConfigurationValue(value, "", {
+		paths: [],
+		fingerprints: [],
+		count: 0,
+		unfingerprintable: false
+	});
+}
 /** Convenience wrapper for callers that only need the safe project. */
 function redactCredentials(project) {
 	return redactProjectCredentials(project).project;
@@ -10145,7 +8819,8 @@ function captureLayerLibraryEntry(layer, options) {
 		...layer.joins?.length ? { joins: structuredClone(layer.joins) } : {},
 		...layer.virtualFields?.length ? { virtualFields: structuredClone(layer.virtualFields) } : {},
 		...layer.attributeForm ? { attributeForm: structuredClone(layer.attributeForm) } : {},
-		...layer.popup ? { popup: structuredClone(layer.popup) } : {}
+		...layer.popup ? { popup: structuredClone(layer.popup) } : {},
+		...layer.descriptiveMetadata ? { descriptiveMetadata: structuredClone(layer.descriptiveMetadata) } : {}
 	};
 	const withFeatures = embed && !controlPainted ? {
 		...base,
@@ -10202,7 +8877,8 @@ function planLayerLibraryAdd(entry, options) {
 			...entry.joins ? { joins: structuredClone(entry.joins) } : {},
 			...entry.virtualFields ? { virtualFields: structuredClone(entry.virtualFields) } : {},
 			...entry.attributeForm ? { attributeForm: structuredClone(entry.attributeForm) } : {},
-			...entry.popup ? { popup: structuredClone(entry.popup) } : {}
+			...entry.popup ? { popup: structuredClone(entry.popup) } : {},
+			...entry.descriptiveMetadata ? { descriptiveMetadata: structuredClone(entry.descriptiveMetadata) } : {}
 		}
 	};
 }
@@ -10221,7 +8897,8 @@ function layerLibraryConfigPatch(entry) {
 		...entry.joins ? { joins: structuredClone(entry.joins) } : {},
 		...entry.virtualFields ? { virtualFields: structuredClone(entry.virtualFields) } : {},
 		...entry.attributeForm ? { attributeForm: structuredClone(entry.attributeForm) } : {},
-		...entry.popup ? { popup: structuredClone(entry.popup) } : {}
+		...entry.popup ? { popup: structuredClone(entry.popup) } : {},
+		...entry.descriptiveMetadata ? { descriptiveMetadata: structuredClone(entry.descriptiveMetadata) } : {}
 	};
 }
 /**
@@ -10391,11 +9068,13 @@ function normalizeLayerLibraryEntries(value) {
 				const virtualFields = validVirtualFields(candidate.virtualFields);
 				const attributeForm = validAttributeForm(candidate.attributeForm);
 				const popup = validPopup(candidate.popup);
+				const descriptiveMetadata = normalizeLayerDescriptiveMetadata(candidate.descriptiveMetadata);
 				return {
 					...joins ? { joins } : {},
 					...virtualFields ? { virtualFields } : {},
 					...attributeForm ? { attributeForm } : {},
-					...popup ? { popup } : {}
+					...popup ? { popup } : {},
+					...descriptiveMetadata ? { descriptiveMetadata } : {}
 				};
 			})(),
 			...geojson ? { geojson: structuredClone(geojson) } : {},
@@ -10771,11 +9450,58 @@ function createProjectLayerSerializationCache() {
 * @returns The same text {@link serializeProject} returns for `project`.
 */
 function serializeProjectWithLayerCache(project, layerSources, cache) {
+	const steps = serializeProjectWithLayerCacheSteps(project, layerSources, cache);
+	for (;;) {
+		const step = steps.next();
+		if (step.done) return step.value;
+	}
+}
+/** Time a main-thread serialization slice may run before it yields (ms). */
+const SERIALIZE_SLICE_MS = 8;
+/** Resolve on a macrotask, letting input and paint run in between slices. */
+function yieldToMainThread() {
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+* {@link serializeProjectWithLayerCache} that hands the main thread back
+* between layers, so autosave on a project with several large layers is many
+* short tasks instead of one 300-400 ms freeze (GeoLibre#2869).
+*
+* The cache makes a camera move free, so the cost lands on the first autosave
+* and on edits to a big layer: each layer that misses the cache is serialized
+* in its own slice, and the thread is released once a slice has run longer than
+* a few milliseconds. A single huge layer is still one slice. The result is
+* identical to the synchronous call. `project` and `layerSources` must not be
+* mutated while this runs; the store replaces records rather than editing them,
+* so a snapshot taken from it stays valid.
+*
+* @param project Project to serialize, as built from `layerSources`.
+* @param layerSources Immutable source record for each entry of
+*   `project.layers`, in the same order, used as the cache key.
+* @param cache Cache shared between calls.
+* @param yieldFn Hands the thread back; replaced in tests.
+* @returns The same text {@link serializeProject} returns for `project`.
+*/
+async function serializeProjectWithLayerCacheAsync(project, layerSources, cache, yieldFn = yieldToMainThread) {
+	const steps = serializeProjectWithLayerCacheSteps(project, layerSources, cache);
+	let sliceStart = Date.now();
+	for (;;) {
+		const step = steps.next();
+		if (step.done) return step.value;
+		if (Date.now() - sliceStart >= SERIALIZE_SLICE_MS) {
+			await yieldFn();
+			sliceStart = Date.now();
+		}
+	}
+}
+/** Shared body of the sync and async serializers; yields once per layer text built. */
+function* serializeProjectWithLayerCacheSteps(project, layerSources, cache) {
 	if (layerSources.length !== project.layers.length) return serializeProject(project);
 	const layers = project.layers.map(portableLayer);
 	if (new Set(layers).size !== layers.length) return serializeProject(project);
 	const presets = /* @__PURE__ */ new Map();
-	layers.forEach((layer, index) => {
+	for (let index = 0; index < layers.length; index += 1) {
+		const layer = layers[index];
 		const source = layerSources[index];
 		const cached = cache.get(source);
 		let text = cached?.index === index ? cached.text : void 0;
@@ -10785,9 +9511,10 @@ function serializeProjectWithLayerCache(project, layerSources, cache) {
 				index,
 				text
 			});
+			yield;
 		}
 		presets.set(layer, text);
-	});
+	}
 	return serializeProjectValue({
 		...project,
 		layers
@@ -11551,12 +10278,26 @@ function normalizeProjectPreferences(preferences) {
 			arcgisBasemap: normalizeString(map.arcgisBasemap) || void 0,
 			cesiumBasemap: normalizeCesiumBasemap(map.cesiumBasemap),
 			terrainEnabled: normalizeBoolean(map.terrainEnabled, DEFAULT_PROJECT_PREFERENCES.map.terrainEnabled),
-			coordinateFormat: typeof map.coordinateFormat === "string" ? map.coordinateFormat : DEFAULT_PROJECT_PREFERENCES.map.coordinateFormat
+			coordinateFormat: typeof map.coordinateFormat === "string" ? map.coordinateFormat : DEFAULT_PROJECT_PREFERENCES.map.coordinateFormat,
+			coordinateEpsgCode: normalizeEpsgCode(map.coordinateEpsgCode),
+			zoomToNewLayers: normalizeBoolean(map.zoomToNewLayers, DEFAULT_PROJECT_PREFERENCES.map.zoomToNewLayers)
 		},
 		environmentVariables: Array.isArray(candidate.environmentVariables) ? candidate.environmentVariables.map(normalizeEnvironmentVariable).filter((variable) => Boolean(variable)) : [],
 		geocoding: normalizeGeocodingPreferences(candidate.geocoding)
 	};
 }
+/**
+* Keep a stored EPSG code only when it is a positive integer.
+*
+* Args:
+*   value: The stored value, of unknown shape.
+*
+* Returns:
+*   The code, or undefined for anything else.
+*/
+function normalizeEpsgCode(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
 function normalizeGeocodingPreferences(geocoding) {
 	if (!geocoding || typeof geocoding !== "object") return {
 		...DEFAULT_PROJECT_PREFERENCES.geocoding,
@@ -11678,12 +10419,12 @@ function isJsonCompatible(value) {
 		case "number": return Number.isFinite(value);
 		case "object":
 			if (Array.isArray(value)) return value.every(isJsonCompatible);
-			if (!isPlainObject(value)) return false;
+			if (!isPlainObject$1(value)) return false;
 			return Object.values(value).every(isJsonCompatible);
 		default: return false;
 	}
 }
-function isPlainObject(value) {
+function isPlainObject$1(value) {
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === Object.prototype || prototype === null;
 }
@@ -11728,8 +10469,9 @@ function portableLayer(layer) {
 }
 function normalizeLayer(layer) {
 	layer = withoutLocalRasterBytes(layer);
-	const { capabilities: rawCapabilities, filterExpression: rawFilterExpression, ...rest } = layer;
+	const { capabilities: rawCapabilities, filterExpression: rawFilterExpression, descriptiveMetadata: rawDescriptiveMetadata, ...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;
 	return {
 		...rest,
@@ -11742,7 +10484,8 @@ function normalizeLayer(layer) {
 		metadata: layer.metadata ?? {},
 		source: layer.source ?? {},
 		...capabilities ? { capabilities } : {},
-		...filterExpression ? { filterExpression } : {}
+		...filterExpression ? { filterExpression } : {},
+		...descriptiveMetadata ? { descriptiveMetadata } : {}
 	};
 }
 function normalizeProjectComments(rawComments) {
@@ -11859,7 +10602,29 @@ function hasRestorableSourceUrl(layer) {
 	return typeof sourceUrl === "string" && sourceUrl.trim() !== "" || typeof originalUrl === "string" && originalUrl.trim() !== "";
 }
 function prepareLayerForSave(layer) {
+	const hasGeometryEdits = layer.metadata.geometryEdited === true;
 	layer = portableLayer(layer);
+	let wfsCredentialsRedacted = layer.metadata.wfsCredentialsRedacted === true;
+	if (layer.metadata.sourceKind === "wfs-getfeature") {
+		const sourceUrl = typeof layer.source.url === "string" ? redactUrlCredentials(layer.source.url) : layer.source.url;
+		const sourcePath = typeof layer.sourcePath === "string" ? redactUrlCredentials(layer.sourcePath) : layer.sourcePath;
+		const originalUrl = typeof layer.metadata.originalUrl === "string" ? redactUrlCredentials(layer.metadata.originalUrl) : layer.metadata.originalUrl;
+		const stripped = sourceUrl !== layer.source.url || sourcePath !== layer.sourcePath || originalUrl !== layer.metadata.originalUrl;
+		wfsCredentialsRedacted ||= stripped;
+		if (stripped) layer = {
+			...layer,
+			source: sourceUrl === layer.source.url ? layer.source : {
+				...layer.source,
+				url: sourceUrl
+			},
+			sourcePath,
+			metadata: {
+				...layer.metadata,
+				...originalUrl === layer.metadata.originalUrl ? {} : { originalUrl },
+				wfsCredentialsRedacted: true
+			}
+		};
+	}
 	if (layer.metadata.geometryEdited !== void 0) {
 		const { geometryEdited: _geometryEdited, ...metadata } = layer.metadata;
 		layer = {
@@ -11875,6 +10640,14 @@ function prepareLayerForSave(layer) {
 		const { embedFilter: _embedFilter, ...rest } = layer;
 		layer = rest;
 	}
+	if (layer.descriptiveMetadata !== void 0) {
+		const { descriptiveMetadata: rawDescriptiveMetadata, ...rest } = layer;
+		const descriptiveMetadata = normalizeLayerDescriptiveMetadata(rawDescriptiveMetadata);
+		layer = descriptiveMetadata ? {
+			...rest,
+			descriptiveMetadata
+		} : rest;
+	}
 	if (layer.geojson && layer.metadata.transientGeojson === true) {
 		const { geojson: _geojson, ...rest } = layer;
 		layer = rest;
@@ -11891,6 +10664,26 @@ function prepareLayerForSave(layer) {
 		const { geojson: _geojson, ...rest } = layer;
 		layer = rest;
 	}
+	const wfsSourceUrl = layer.source.url;
+	let hasHttpWfsSource = false;
+	if (typeof wfsSourceUrl === "string") try {
+		const url = new URL(wfsSourceUrl);
+		hasHttpWfsSource = url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		hasHttpWfsSource = false;
+	}
+	if (layer.type === "geojson" && layer.metadata.sourceKind === "wfs-getfeature" && layer.geojson && hasHttpWfsSource) {
+		if (hasGeometryEdits) {
+			const { url: _url, ...source } = layer.source;
+			layer = {
+				...layer,
+				source
+			};
+		} else if (!wfsCredentialsRedacted) {
+			const { geojson: _geojson, ...rest } = layer;
+			layer = rest;
+		}
+	}
 	if (layer.geojson && layer.metadata.sourceKind === "maplibre-gl-vector-adopted" && hasRestorableSourceUrl(layer)) {
 		const { geojson: _geojson, ...rest } = layer;
 		layer = rest;
@@ -11947,18 +10740,35 @@ function portableWmsTileUrl(tile) {
 		return tile;
 	}
 }
-function applyProjectToStore(project) {
-	const layers = project.layers.map((layer) => ({
+/**
+* The store form of one project layer: its style completed from
+* {@link DEFAULT_LAYER_STYLE} and the project's top-level `styles` entry.
+*
+* Legacy and externally-authored projects can carry a partial top-level style
+* alongside newer fields on the layer itself. Those layer fields are kept,
+* while the top-level copy stays authoritative where it explicitly supplies a
+* value.
+*
+* @param project - The project the layer belongs to (for its `styles` map).
+* @param layer - One of `project.layers`.
+* @returns A new layer record ready for the store.
+*/
+function hydrateProjectLayer(project, layer) {
+	const topLevel = project.styles?.[layer.id];
+	return {
 		...layer,
-		style: project.styles[layer.id] ? {
+		style: topLevel ? {
 			...DEFAULT_LAYER_STYLE,
 			...layer.style,
-			...project.styles[layer.id]
+			...topLevel
 		} : {
 			...DEFAULT_LAYER_STYLE,
 			...layer.style
 		}
-	}));
+	};
+}
+function applyProjectToStore(project) {
+	const layers = project.layers.map((layer) => hydrateProjectLayer(project, layer));
 	const layerGroups = normalizeLayerGroups(project.layerGroups);
 	const validGroupIds = new Set(layerGroups.map((g) => g.id));
 	const normalizedLayers = normalizeGroupContiguity(layers.map((layer) => layer.groupId && !validGroupIds.has(layer.groupId) ? {
@@ -13035,6 +11845,7 @@ const createUiSlice = (set) => ({
 		notebookOpen: false,
 		assistantOpen: false,
 		attributeTableOpen: false,
+		attributeTableEditLayerId: null,
 		rasterAttributeTableOpen: false,
 		dashboardOpen: false,
 		storymapPanelOpen: false,
@@ -13124,6 +11935,11 @@ const createUiSlice = (set) => ({
 		...s.ui,
 		attributeTableOpen: open
 	} })),
+	requestAttributeTableEdit: (layerId) => set((s) => ({ ui: {
+		...s.ui,
+		attributeTableEditLayerId: layerId,
+		attributeTableOpen: layerId === null ? s.ui.attributeTableOpen : true
+	} })),
 	setRasterAttributeTableOpen: (open) => set((s) => ({ ui: {
 		...s.ui,
 		rasterAttributeTableOpen: open
@@ -13241,6 +12057,16 @@ useAppStore.subscribe((state) => {
 	setActiveEllipsoidId(id);
 });
 /**
+* Whether the map should fit to data the user just added, per the project's
+* Map Preferences. Add-data paths consult this before an automatic fit; an
+* explicit "Zoom to layer" request ignores it.
+*
+* @returns `true` unless the user turned off zooming to new layers.
+*/
+function shouldZoomToNewLayers() {
+	return useAppStore.getState().preferences.map.zoomToNewLayers !== false;
+}
+/**
 * React hook for consuming application capability state for a specific privilege.
 *
 * @param privilege - The privilege to check.
@@ -13276,7 +12102,8 @@ function useAppCapability(privilege) {
 */
 function applyMatchedSelection(targetLayerId, matchedIds, mode) {
 	const store = useAppStore.getState();
-	const next = applySelectionMode(store.selectedLayerId === targetLayerId ? store.selectedFeatureIds : [], matchedIds, mode);
+	const current = store.selectedLayerId === targetLayerId ? store.selectedFeatureIds : [];
+	const next = applySelectionMode(current, matchedIds, mode);
 	if (store.selectedLayerId !== targetLayerId) store.selectLayer(targetLayerId);
 	store.selectFeatures(next);
 	return next.length;
@@ -13594,6 +12421,638 @@ function formatCameraAltitude(meters, unit) {
 	})} ${label}`;
 }
 //#endregion
+//#region src/project-diff.ts
+const DEFAULT_PREVIEW_LENGTH = 80;
+const CAMERA_EPSILON = 1e-6;
+/** Layer fields reported in their own group, never under `other`. */
+const LAYER_GROUPED_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"name",
+	"type",
+	"visible",
+	"opacity",
+	"style",
+	"geojson",
+	"filterExpression",
+	"quickFilters",
+	"source",
+	"sourcePath",
+	"beforeId"
+]);
+/** Top-level project fields reported in their own group, never as a section. */
+const PROJECT_GROUPED_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"version",
+	"name",
+	"mapView",
+	"basemapStyleUrl",
+	"basemapVisible",
+	"basemapOpacity",
+	"blankBackgroundColor",
+	"primaryRenderer",
+	"layers",
+	"styles",
+	"preferences",
+	"plugins",
+	"metadata",
+	"selectedLayerId"
+]);
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Deep structural equality for JSON-like values. A key whose value is
+* `undefined` is treated as absent, so an in-memory record compares equal to
+* its JSON round trip.
+*
+* @param a - First value.
+* @param b - Second value.
+* @returns True when the two values are structurally equal.
+*/
+function jsonValuesEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a === "number" && typeof b === "number") return Number.isNaN(a) && Number.isNaN(b);
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!jsonValuesEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (isPlainObject(a)) {
+		if (!isPlainObject(b)) return false;
+		for (const key of Object.keys(a)) {
+			if (a[key] === void 0) continue;
+			if (!jsonValuesEqual(a[key], b[key])) return false;
+		}
+		for (const key of Object.keys(b)) if (b[key] !== void 0 && a[key] === void 0) return false;
+		return true;
+	}
+	return false;
+}
+function isBlank(value) {
+	if (value === void 0 || value === null) return true;
+	if (Array.isArray(value)) return value.length === 0;
+	return isPlainObject(value) && Object.values(value).every((item) => item === void 0);
+}
+/**
+* Equality for reporting: like {@link jsonValuesEqual}, but an empty array,
+* an empty object, `null` and an absent value are interchangeable, since the
+* save path omits empty sections that an in-memory project still carries.
+*/
+function sameForReport(a, b) {
+	return jsonValuesEqual(a, b) || isBlank(a) && isBlank(b);
+}
+/**
+* Render a bounded JSON-ish preview of a value without serializing more of it
+* than the preview can show, so a large array or object costs no more than
+* `maxLength` characters of work.
+*
+* @param value - The value to preview.
+* @param maxLength - Maximum preview length; longer output ends with `…`.
+* @returns The preview, or `undefined` for `undefined`.
+*/
+function previewValue(value, maxLength = DEFAULT_PREVIEW_LENGTH) {
+	if (value === void 0) return void 0;
+	if (typeof value === "string") return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength - 1))}…` : value;
+	let out = "";
+	let truncated = false;
+	const emit = (text) => {
+		if (out.length + text.length > maxLength) {
+			out += text.slice(0, Math.max(0, maxLength - out.length));
+			truncated = true;
+			return false;
+		}
+		out += text;
+		return true;
+	};
+	const walk = (v) => {
+		if (v === null || typeof v !== "object") {
+			if (typeof v === "number" && !Number.isFinite(v)) return emit("null");
+			if (typeof v === "string" && v.length > maxLength) return emit(JSON.stringify(v.slice(0, maxLength)));
+			const text = typeof v === "bigint" ? v.toString() : JSON.stringify(v);
+			return emit(text ?? "null");
+		}
+		if (Array.isArray(v)) {
+			if (!emit("[")) return false;
+			for (let i = 0; i < v.length; i++) {
+				if (i > 0 && !emit(",")) return false;
+				if (!walk(v[i] === void 0 ? null : v[i])) return false;
+			}
+			return emit("]");
+		}
+		if (!emit("{")) return false;
+		let first = true;
+		for (const [key, item] of Object.entries(v)) {
+			if (item === void 0) continue;
+			if (!first && !emit(",")) return false;
+			first = false;
+			if (!emit(`${JSON.stringify(key)}:`)) return false;
+			if (!walk(item)) return false;
+		}
+		return emit("}");
+	};
+	walk(value);
+	if (truncated) out = `${out.slice(0, Math.max(0, maxLength - 1))}…`;
+	return out;
+}
+/**
+* Diff two records key by key. Nested plain objects are descended into up to
+* `depth` levels (paths joined with `.`); arrays and deeper values are
+* compared whole.
+*/
+function diffRecords(before, after, options, out) {
+	const a = before ?? {};
+	const b = after ?? {};
+	const prefix = options.prefix ?? "";
+	const depth = options.depth ?? 1;
+	const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+	for (const key of keys) {
+		if (options.skip?.has(key)) continue;
+		const x = a[key];
+		const y = b[key];
+		if (sameForReport(x, y)) continue;
+		if (depth > 0 && isPlainObject(x) && isPlainObject(y)) {
+			diffRecords(x, y, {
+				prefix: `${prefix}${key}.`,
+				depth: depth - 1,
+				maxLength: options.maxLength
+			}, out);
+			continue;
+		}
+		out.push({
+			path: `${prefix}${key}`,
+			before: previewValue(x, options.maxLength),
+			after: previewValue(y, options.maxLength)
+		});
+	}
+}
+const featureHashCache = /* @__PURE__ */ new WeakMap();
+/** cyrb53: a fast, well-distributed 53-bit string hash. */
+function hashString(text, seed = 0) {
+	let h1 = 3735928559 ^ seed;
+	let h2 = 1103547991 ^ seed;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+	h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+	h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+function hashFeature(feature) {
+	if (typeof feature !== "object" || feature === null) {
+		const h = hashString(JSON.stringify(feature ?? null));
+		return {
+			geometry: h,
+			full: h
+		};
+	}
+	const cached = featureHashCache.get(feature);
+	if (cached) return cached;
+	const { geometry, properties, id: _id, ...rest } = feature;
+	const geometryHash = hashString(JSON.stringify(geometry ?? null));
+	const result = {
+		geometry: geometryHash,
+		full: `${geometryHash}:${hashString(JSON.stringify(properties ?? null), 1)}:${Object.keys(rest).filter((key) => key !== "type" && rest[key] !== void 0).length > 0 ? hashString(JSON.stringify(rest), 2) : ""}`
+	};
+	featureHashCache.set(feature, result);
+	return result;
+}
+function featureKey(feature) {
+	if (typeof feature !== "object" || feature === null) return null;
+	const id = feature.id;
+	if (typeof id === "string") return `s:${id}`;
+	if (typeof id === "number" && Number.isFinite(id)) return `n:${id}`;
+	return null;
+}
+function indexFeatures(features) {
+	const byId = /* @__PURE__ */ new Map();
+	const byGeometry = /* @__PURE__ */ new Map();
+	let keyed = 0;
+	let unkeyed = 0;
+	for (const feature of features) {
+		const hash = hashFeature(feature);
+		const key = featureKey(feature);
+		if (key !== null && !byId.has(key)) {
+			byId.set(key, hash.full);
+			keyed++;
+			continue;
+		}
+		const list = byGeometry.get(hash.geometry);
+		if (list) list.push(hash.full);
+		else byGeometry.set(hash.geometry, [hash.full]);
+		unkeyed++;
+	}
+	return {
+		byId,
+		byGeometry,
+		keyed,
+		unkeyed
+	};
+}
+/**
+* Count the features added, removed and modified between two feature
+* collections. Features are matched by `id` when they carry one; id-less
+* features are matched by geometry hash, so a feature whose properties
+* changed but whose geometry did not counts as modified, while a moved
+* id-less feature counts as one removal plus one addition.
+*
+* @param before - Earlier collection (absent counts as empty).
+* @param after - Later collection (absent counts as empty).
+* @returns The change counts.
+*/
+function diffFeatureCollections(before, after) {
+	const a = indexFeatures(Array.isArray(before?.features) ? before.features : []);
+	const b = indexFeatures(Array.isArray(after?.features) ? after.features : []);
+	let added = 0;
+	let removed = 0;
+	let modified = 0;
+	let unchanged = 0;
+	for (const [key, hash] of a.byId) {
+		const other = b.byId.get(key);
+		if (other === void 0) removed++;
+		else if (other === hash) unchanged++;
+		else modified++;
+	}
+	for (const key of b.byId.keys()) if (!a.byId.has(key)) added++;
+	const geometryKeys = /* @__PURE__ */ new Set([...a.byGeometry.keys(), ...b.byGeometry.keys()]);
+	for (const geometry of geometryKeys) {
+		const left = a.byGeometry.get(geometry) ?? [];
+		const right = b.byGeometry.get(geometry) ?? [];
+		const counts = /* @__PURE__ */ new Map();
+		for (const full of left) counts.set(full, (counts.get(full) ?? 0) + 1);
+		let same = 0;
+		for (const full of right) {
+			const n = counts.get(full) ?? 0;
+			if (n > 0) {
+				counts.set(full, n - 1);
+				same++;
+			}
+		}
+		const leftRest = left.length - same;
+		const rightRest = right.length - same;
+		const paired = Math.min(leftRest, rightRest);
+		unchanged += same;
+		modified += paired;
+		removed += leftRest - paired;
+		added += rightRest - paired;
+	}
+	const keyed = a.keyed + b.keyed;
+	const matchedBy = a.unkeyed + b.unkeyed === 0 ? "id" : keyed === 0 ? "geometry" : "mixed";
+	return {
+		added,
+		removed,
+		modified,
+		unchanged,
+		matchedBy
+	};
+}
+function effectiveStyle(project, layer) {
+	const top = project.styles?.[layer.id];
+	if (!top) return layer.style;
+	return {
+		...layer.style ?? {},
+		...top
+	};
+}
+function featureCountOf(layer) {
+	return Array.isArray(layer.geojson?.features) ? layer.geojson.features.length : void 0;
+}
+function emptyLayerDiff(layer, status) {
+	return {
+		id: layer.id,
+		name: layer.name,
+		type: layer.type,
+		status,
+		style: [],
+		labels: [],
+		filter: [],
+		source: [],
+		other: []
+	};
+}
+/**
+* Ids (of layers present in both orders) that moved: everything outside a
+* longest increasing subsequence of their later positions, so dragging one
+* layer reports that layer rather than every layer it passed.
+*/
+function movedLayerIds(beforeIds, afterIndex) {
+	const common = beforeIds.filter((id) => afterIndex.has(id));
+	const seq = common.map((id) => afterIndex.get(id));
+	const tails = [];
+	const prev = new Array(seq.length).fill(-1);
+	for (let i = 0; i < seq.length; i++) {
+		let lo = 0;
+		let hi = tails.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (seq[tails[mid]] < seq[i]) lo = mid + 1;
+			else hi = mid;
+		}
+		if (lo > 0) prev[i] = tails[lo - 1];
+		tails[lo] = i;
+	}
+	const stable = /* @__PURE__ */ new Set();
+	for (let i = tails.length ? tails[tails.length - 1] : -1; i >= 0; i = prev[i]) stable.add(common[i]);
+	return new Set(common.filter((id) => !stable.has(id)));
+}
+function diffLayer(beforeProject, afterProject, a, b, maxLength) {
+	const diff = emptyLayerDiff(b, "changed");
+	if (a.name !== b.name) diff.renamed = {
+		before: a.name,
+		after: b.name
+	};
+	if (Boolean(a.visible) !== Boolean(b.visible)) diff.visibility = {
+		before: Boolean(a.visible),
+		after: Boolean(b.visible)
+	};
+	if (!jsonValuesEqual(a.opacity, b.opacity)) diff.opacity = {
+		before: a.opacity,
+		after: b.opacity
+	};
+	const styleA = effectiveStyle(beforeProject, a);
+	const styleB = effectiveStyle(afterProject, b);
+	if (!jsonValuesEqual(styleA, styleB)) {
+		diffRecords(styleA, styleB, {
+			skip: /* @__PURE__ */ new Set(["labels"]),
+			maxLength
+		}, diff.style);
+		const labelsA = styleA?.labels;
+		const labelsB = styleB?.labels;
+		if (!jsonValuesEqual(labelsA, labelsB)) diffRecords(isPlainObject(labelsA) ? labelsA : void 0, isPlainObject(labelsB) ? labelsB : void 0, { maxLength }, diff.labels);
+	}
+	diffRecords({
+		filterExpression: a.filterExpression,
+		quickFilters: a.quickFilters
+	}, {
+		filterExpression: b.filterExpression,
+		quickFilters: b.quickFilters
+	}, {
+		depth: 0,
+		maxLength
+	}, diff.filter);
+	if (a.type !== b.type) diff.source.push({
+		path: "type",
+		before: a.type,
+		after: b.type
+	});
+	if (!jsonValuesEqual(a.source, b.source)) diffRecords(a.source, b.source, {
+		prefix: "source.",
+		depth: 0,
+		maxLength
+	}, diff.source);
+	if (a.sourcePath !== b.sourcePath) diff.source.push({
+		path: "sourcePath",
+		before: previewValue(a.sourcePath, maxLength),
+		after: previewValue(b.sourcePath, maxLength)
+	});
+	diffRecords(a, b, {
+		skip: LAYER_GROUPED_KEYS,
+		depth: 1,
+		maxLength
+	}, diff.other);
+	if (a.geojson !== b.geojson && (a.geojson || b.geojson)) {
+		const features = diffFeatureCollections(a.geojson, b.geojson);
+		if (features.added || features.removed || features.modified) diff.features = features;
+	}
+	return diff;
+}
+function layerHasChanges(diff) {
+	return Boolean(diff.renamed || diff.moved || diff.visibility || diff.opacity || diff.features || diff.style.length || diff.labels.length || diff.filter.length || diff.source.length || diff.other.length);
+}
+function layerChangeCount(diff) {
+	return (diff.renamed ? 1 : 0) + (diff.moved ? 1 : 0) + (diff.visibility ? 1 : 0) + (diff.opacity ? 1 : 0) + (diff.features ? 1 : 0) + diff.style.length + diff.labels.length + diff.filter.length + diff.source.length + diff.other.length;
+}
+function diffPlugins(before, after, maxLength) {
+	const activeA = new Set(before?.activePluginIds ?? []);
+	const activeB = new Set(after?.activePluginIds ?? []);
+	const settingsA = before?.settings ?? {};
+	const settingsB = after?.settings ?? {};
+	const positionsA = before?.mapControlPositions ?? {};
+	const positionsB = after?.mapControlPositions ?? {};
+	const ids = /* @__PURE__ */ new Set([
+		...activeA,
+		...activeB,
+		...Object.keys(settingsA),
+		...Object.keys(settingsB),
+		...Object.keys(positionsA),
+		...Object.keys(positionsB)
+	]);
+	const plugins = [];
+	for (const id of [...ids].sort()) {
+		const changes = [];
+		const wasActive = activeA.has(id);
+		const isActive = activeB.has(id);
+		if (!jsonValuesEqual(positionsA[id], positionsB[id])) changes.push({
+			path: "position",
+			before: previewValue(positionsA[id], maxLength),
+			after: previewValue(positionsB[id], maxLength)
+		});
+		const sa = settingsA[id];
+		const sb = settingsB[id];
+		if (!jsonValuesEqual(sa, sb)) {
+			if (isPlainObject(sa) || isPlainObject(sb)) diffRecords(isPlainObject(sa) ? sa : void 0, isPlainObject(sb) ? sb : void 0, {
+				prefix: "settings.",
+				depth: 0,
+				maxLength
+			}, changes);
+			else changes.push({
+				path: "settings",
+				before: previewValue(sa, maxLength),
+				after: previewValue(sb, maxLength)
+			});
+		}
+		if (wasActive !== isActive) plugins.push({
+			id,
+			status: isActive ? "added" : "removed",
+			changes
+		});
+		else if (changes.length > 0) plugins.push({
+			id,
+			status: "changed",
+			changes
+		});
+	}
+	const urlsA = new Set(before?.manifestUrls ?? []);
+	const urlsB = new Set(after?.manifestUrls ?? []);
+	return {
+		plugins,
+		manifests: {
+			added: [...urlsB].filter((url) => !urlsA.has(url)),
+			removed: [...urlsA].filter((url) => !urlsB.has(url))
+		}
+	};
+}
+function numbersDiffer(a, b) {
+	if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) > CAMERA_EPSILON;
+	return !jsonValuesEqual(a, b);
+}
+/**
+* Compute a structured summary of what changed from `before` to `after`.
+*
+* Layers are matched by id. Embedded GeoJSON is compared per feature (by id,
+* falling back to geometry hash) and each feature is hashed once per object,
+* so diffing the same parsed project against several others reuses its
+* hashes; callers keep and pass the same parsed project objects to benefit.
+*
+* @param before - The earlier project (e.g. an autosave snapshot).
+* @param after - The later project (e.g. the current project).
+* @param options - Preview length and other tuning.
+* @returns The grouped change summary.
+*/
+function diffProjects(before, after, options = {}) {
+	const maxLength = options.maxPreviewLength ?? DEFAULT_PREVIEW_LENGTH;
+	const layersA = Array.isArray(before.layers) ? before.layers : [];
+	const layersB = Array.isArray(after.layers) ? after.layers : [];
+	const byIdA = new Map(layersA.map((layer) => [layer.id, layer]));
+	const byIdB = new Map(layersB.map((layer) => [layer.id, layer]));
+	const indexA = new Map(layersA.map((layer, i) => [layer.id, i]));
+	const indexB = new Map(layersB.map((layer, i) => [layer.id, i]));
+	const moved = movedLayerIds(layersA.map((layer) => layer.id), indexB);
+	const added = [];
+	const removed = [];
+	const changed = [];
+	for (const layer of layersB) {
+		if (byIdA.has(layer.id)) continue;
+		const diff = emptyLayerDiff(layer, "added");
+		const count = featureCountOf(layer);
+		if (count !== void 0) diff.featureCount = count;
+		added.push(diff);
+	}
+	for (const layer of layersA) {
+		if (byIdB.has(layer.id)) continue;
+		const diff = emptyLayerDiff(layer, "removed");
+		const count = featureCountOf(layer);
+		if (count !== void 0) diff.featureCount = count;
+		removed.push(diff);
+	}
+	for (let i = layersB.length - 1; i >= 0; i--) {
+		const b = layersB[i];
+		const a = byIdA.get(b.id);
+		if (!a) continue;
+		const diff = a === b && before.styles?.[b.id] === after.styles?.[b.id] ? emptyLayerDiff(b, "changed") : diffLayer(before, after, a, b, maxLength);
+		if (moved.has(b.id)) diff.moved = {
+			before: indexA.get(b.id),
+			after: indexB.get(b.id)
+		};
+		if (layerHasChanges(diff)) changed.push(diff);
+	}
+	const camera = [];
+	const viewA = before.mapView ?? {};
+	const viewB = after.mapView ?? {};
+	const centerA = viewA.center ?? [];
+	const centerB = viewB.center ?? [];
+	if (numbersDiffer(centerA[0], centerB[0]) || numbersDiffer(centerA[1], centerB[1])) {
+		const fmt = (c) => c.length === 2 && c.every((n) => typeof n === "number") ? `${c[0].toFixed(5)}, ${c[1].toFixed(5)}` : void 0;
+		camera.push({
+			path: "center",
+			before: fmt(centerA),
+			after: fmt(centerB)
+		});
+	}
+	for (const key of [
+		"zoom",
+		"bearing",
+		"pitch"
+	]) if (numbersDiffer(viewA[key], viewB[key])) {
+		const fmt = (n) => typeof n === "number" ? String(Math.round(n * 100) / 100) : previewValue(n, maxLength);
+		camera.push({
+			path: key,
+			before: fmt(viewA[key]),
+			after: fmt(viewB[key])
+		});
+	}
+	const basemap = [];
+	diffRecords({
+		basemapStyleUrl: before.basemapStyleUrl,
+		basemapVisible: before.basemapVisible,
+		basemapOpacity: before.basemapOpacity,
+		blankBackgroundColor: before.blankBackgroundColor ?? void 0,
+		primaryRenderer: before.primaryRenderer
+	}, {
+		basemapStyleUrl: after.basemapStyleUrl,
+		basemapVisible: after.basemapVisible,
+		basemapOpacity: after.basemapOpacity,
+		blankBackgroundColor: after.blankBackgroundColor ?? void 0,
+		primaryRenderer: after.primaryRenderer
+	}, {
+		depth: 0,
+		maxLength: Math.max(maxLength, 160)
+	}, basemap);
+	const projection = [];
+	const prefsA = before.preferences ?? {};
+	const prefsB = after.preferences ?? {};
+	const mapA = isPlainObject(prefsA.map) ? prefsA.map : {};
+	const mapB = isPlainObject(prefsB.map) ? prefsB.map : {};
+	if (!jsonValuesEqual(mapA.projection, mapB.projection)) projection.push({
+		path: "projection",
+		before: previewValue(mapA.projection, maxLength),
+		after: previewValue(mapB.projection, maxLength)
+	});
+	const preferences = [];
+	if (!jsonValuesEqual(prefsA, prefsB)) diffRecords({
+		...prefsA,
+		map: {
+			...mapA,
+			projection: void 0
+		}
+	}, {
+		...prefsB,
+		map: {
+			...mapB,
+			projection: void 0
+		}
+	}, {
+		depth: 1,
+		maxLength
+	}, preferences);
+	const { plugins, manifests } = diffPlugins(before.plugins, after.plugins, maxLength);
+	const metadata = [];
+	if (before.name !== after.name) metadata.push({
+		path: "name",
+		before: previewValue(before.name, maxLength),
+		after: previewValue(after.name, maxLength)
+	});
+	diffRecords(before.metadata, after.metadata, {
+		depth: 0,
+		maxLength
+	}, metadata);
+	metadata.sort((x, y) => metadataRank(x.path) - metadataRank(y.path));
+	const sections = [];
+	const projectA = before;
+	const projectB = after;
+	for (const key of /* @__PURE__ */ new Set([...Object.keys(projectA), ...Object.keys(projectB)])) {
+		if (PROJECT_GROUPED_KEYS.has(key)) continue;
+		if (!sameForReport(projectA[key], projectB[key])) sections.push(key);
+	}
+	sections.sort();
+	const changeCount = added.length + removed.length + changed.reduce((sum, diff) => sum + layerChangeCount(diff), 0) + camera.length + basemap.length + projection.length + preferences.length + plugins.reduce((sum, plugin) => sum + Math.max(1, plugin.changes.length), 0) + manifests.added.length + manifests.removed.length + metadata.length + sections.length;
+	return {
+		layers: {
+			added,
+			removed,
+			changed,
+			reordered: moved.size > 0
+		},
+		camera,
+		basemap,
+		projection,
+		preferences,
+		plugins,
+		pluginManifests: manifests,
+		metadata,
+		sections,
+		changeCount
+	};
+}
+function metadataRank(path) {
+	if (path === "name") return 0;
+	if (path === "description") return 1;
+	return 2;
+}
+//#endregion
 //#region src/pixel-format.ts
 /**
 * Trim a float sample to something readable. A 32-bit raster value decoded to a
@@ -14198,6 +13657,27 @@ function storyVisibleLayers(layers, presenting, opacities) {
 	if (!layers.some((layer) => isStoryHiddenLayer(opacities, layer.id))) return layers;
 	return layers.filter((layer) => !isStoryHiddenLayer(opacities, layer.id));
 }
+/**
+* Resolve a story chapter location to a full camera view.
+*
+* A location's `pitch` and `bearing` are optional in memory (a project file
+* fills them with 0 on load). An absent value keeps the camera's current one,
+* the same as MapLibre's camera methods do for an omitted option, so engines
+* whose camera API needs every field (Cesium, `MapEngine.applyView`) behave
+* like the MapLibre map.
+*
+* @param location The chapter's camera target.
+* @param current The camera's current view, used for an absent pitch/bearing.
+* @returns The location with `pitch` and `bearing` filled in.
+*/
+function storyLocationView(location, current) {
+	return {
+		center: location.center,
+		zoom: location.zoom,
+		pitch: location.pitch ?? current.pitch,
+		bearing: location.bearing ?? current.bearing
+	};
+}
 //#endregion
 //#region src/storymap-io.ts
 /**
@@ -14264,8 +13744,8 @@ function serializeStoryMapCsv(storymap) {
 		String(c.location.center[0]),
 		String(c.location.center[1]),
 		String(c.location.zoom),
-		String(c.location.pitch),
-		String(c.location.bearing),
+		String(c.location.pitch ?? ""),
+		String(c.location.bearing ?? ""),
 		c.mapAnimation,
 		String(c.rotateAnimation),
 		JSON.stringify(c.onChapterEnter),
@@ -15876,6 +15356,6 @@ function currentEditorIdentity() {
 	return pickEditorIdentity(isActive ? selfName : void 0, readStoredAuthorName());
 }
 //#endregion
-export { ALL_APP_PRIVILEGES, ALL_DEPLOYMENT_CAPABILITIES, BLANK_BASEMAP, BLEND_MODES, BUILT_IN_STYLE_PRESETS, CARTOCIUDAD_MIN_INTERVAL_MS, CARTOCIUDAD_PUBLIC_HOST, CESIUM_BASEMAPS, CESIUM_BING_AERIAL_ASSET_ID, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID, CESIUM_ION_QUICK_PICKS, CESIUM_ION_SOURCE_KIND, CESIUM_KML_SOURCE_KIND, CESIUM_OSM_BUILDINGS_ASSET_ID, CHINA_BASEMAPS, CZML_QUICK_PICKS, CZML_SOURCE_KIND, DEFAULT_BASEMAP, DEFAULT_BLEND_MODE, DEFAULT_COLLABORATION_STATE, DEFAULT_DASHBOARD_COLUMNS, DEFAULT_EDITOR_IDENTITY, DEFAULT_EDITOR_TRACKING_CONFIG, DEFAULT_ELLIPSOID_ID, DEFAULT_FORWARD_GEOCODE_ENDPOINT, DEFAULT_GEOCODING_PROVIDER_ID, DEFAULT_LAYER_GROUP_OPACITY, DEFAULT_LAYER_STYLE, DEFAULT_LEGEND_CONFIG, DEFAULT_MAP_GRID_LAYOUT, DEFAULT_PRIMARY_RENDERER, DEFAULT_PRINT_LAYOUT, DEFAULT_PROJECT_NAME, DEFAULT_PROJECT_PREFERENCES, DEFAULT_REVERSE_GEOCODE_ENDPOINT, DEFAULT_ROUTING_ENDPOINT, DEFAULT_STORY_MAP, DEPLOYMENT_CAPABILITIES, DUCKDB_VECTOR_FEATURE_WARN_COUNT, DUCKDB_VECTOR_ROUTE_BYTES, EARTH_MEAN_RADIUS_METERS, EDITOR_IDENTITY_STORAGE_KEY, ELEVATION_REQUEST_TIMEOUT_MS, ELLIPSOIDS, EXPRESSION_FUNCTION_CATEGORIES, ElevationFetchError, FEET_PER_METER, FEET_PER_MILE, GEOCODE_DISPLAY_NAME_KEY, GEOCODE_LAT_KEY, GEOCODE_LON_KEY, GEOCODE_PROVIDER_KEY, GEOCODE_SCORE_KEY, GEOCODE_STATUS_KEY, GEOCODING_PROVIDERS, GOOGLE_MAPS_API_KEY_HEADER, IDENTIFY_ALL_LAYERS_ID, LABEL_NUMBER_LOCALES, LABEL_NUMBER_SAMPLE, LARGE_VECTOR_FEATURE_THRESHOLD, LAYER_LIBRARY_BUNDLE_TYPE, LAYER_LIBRARY_BUNDLE_VERSION, LAYER_PALETTE, LAYER_STYLES_FILE_TYPE, LAYER_STYLES_FILE_VERSION, LAYER_TYPES, MAX_DASHBOARD_COLUMNS, MAX_DIAGRAM_FEATURES, MAX_DIAGRAM_SCAN_FEATURES, MAX_LAYER_LIBRARY_ENTRIES, MAX_LAYER_LIBRARY_ENTRY_BYTES, MAX_MAP_GRID_DIM, MAX_POINTS_PER_REQUEST, MAX_PROCESSING_HISTORY, MAX_REDACT_DEPTH, MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0, METERS_PER_FOOT, METERS_PER_MILE, METERS_PER_NAUTICAL_MILE, MIN_DASHBOARD_COLUMNS, MIN_DIAGRAM_SIZE, NETCDF_IMAGE_SOURCE_KIND, NOMINATIM_MIN_INTERVAL_MS, NOMINATIM_PUBLIC_HOST, NO_DEPLOYMENT_CAPABILITIES, NO_LAYERS, OPENFREEMAP_BASEMAPS, PHOTO_FULL_PROPERTY, PHOTO_PROPERTY, PLANETARY_BASEMAPS, PLANETARY_BASEMAP_GROUPS, PLANETARY_BASEMAP_SENTINEL_PREFIX, PLANET_SWITCHER_OPTIONS, POINTER_ELEVATION_CACHE_LIMIT, POINTER_ELEVATION_DEBOUNCE_MS, POPUP_IMAGE_HEIGHT_RANGE, POPUP_MAX_WIDTH_RANGE, PROJECT_CREDENTIAL_FIELDS, PROJECT_VERSION, PROTOMAPS_BASEMAPS, PUBLIC_GEOCODE_ROW_CAP, PUBLISHABLE_PLUGIN_SETTINGS, RAMP_STYLE_KEYS, RASTER_APPEARANCE_STATE_KEYS, REGIONAL_BASEMAPS, REGIONAL_BASEMAP_GROUPS, REGIONAL_BASEMAP_SENTINEL_PREFIX, ROLE_PRIVILEGES, RoutingRequestError, S3CorsError, S3_MAX_PRESIGN_SECONDS, SELECTION_MODES, SQL_QUERY_SOURCE_KIND, STYLE_LIBRARY_BUNDLE_TYPE, STYLE_LIBRARY_BUNDLE_VERSION, SYMBOL_STYLE_KEYS, VECTOR_COLOR_RAMPS, activeLayerFilterExpression, activeQuickFilters, allowsCredentialHeaders, appPrivilegeReason, applyCopiedLayerStyle, applyGroupEffects, applyJoinsToLayer, applyLayerJoins, applyLayerVirtualFields, applyMatchedSelection, applyProjectToStore, applySelectionMode, applyStoryLayerOpacity, attributeFormFieldLabel, attributeLinkUrl, availableCesiumBasemap, basemapToCesiumImagery, batchDecodePolylines, bodyLengthToEarth, buildForwardGeocodeUrl, buildIsochroneRequest, buildLayerPanelUnits, buildLayerTree, buildMatrixRequest, buildReverseGeocodeUrl, buildRouteRequest, canRedoProjectRestore, canSaveLayerToLibrary, canUndoProjectRestore, captureLayerLibraryEntry, cascadeLayerJoinRefresh, cesiumIonAssetId, cesiumIonAssetKind, cesiumKmlSource, changedPreferenceCredentials, circleRadiusValue, clampLabelDecimals, clampLatitude, clearExternalNativePaintBridge, clearHistory, clearQuickFilterValues, coerceAttributeFormValue, collectDiagramData, collectTransitiveJoinSourceIds, compareSequenceValues, compileFeatureExpression, compileLayerFilters, compileQuickFilter, compileQuickFilters, controlRendersLayer, copyableLayerStyleKind, createCesiumIonLayer, createCesiumKmlLayer, createCzmlLayer, createDefaultAppCapabilities, createDefaultMapView, createDefaultPrintLayout, createEmptyProject, createEqualIntervalBreaks, createGraduatedClassBreaks, createLayerLibraryEntryId, createPointerElevationResolver, createProjectLayerSerializationCache, createProjectTemplate, createQuantileBreaks, createSampleStoryMap, createStyleLayerEvaluator, createStyleLibraryEntryId, csvRowsToGeocodeRequests, currentEditorIdentity, czmlSource, darkenHex, decodePolyline, decodePolylineDetailed, detachProjectCopy, detectNonGeographicCoordinates, diagramAnchor, diagramPixelSize, diagramsSuppressedByPointRenderer, documentLocale, dominantGeometry, drawMarkerPath, earthAreaToBody, earthLengthToBody, editorTrackingFieldNames, effectiveLayerRenderState, effectiveVectorRules, encodePolyline, encodeS3Key, ensureEditorTrackingFields, environmentVariableAccount, evaluateMapExpression, excludeHiddenFieldsFromGeojson, excludeHiddenFieldsFromProject, explainS3ReadError, extractCopiedLayerStyle, extractLayerStyleEntries, extractStyleLibraryStyle, extrusionColorValue, extrusionHeightValue, featureSelectionId, fetchElevations, findLayerStyleEntryIndex, formatCameraAltitude, formatExpressionPreviewValue, formatLabelNumber, formatLabelNumberSample, formatPixelValue, formatPopupValue, formatRoundNum, formatS3Uri, generatorCircleRadiusValue, generatorSizeRange, geoJSONToPolylineStr, geocodeForward, geocodeMatchToFeature, geocodeReverse, geocoderMinIntervalMs, geocoderNeedsApiKey, geocodingApiKeyAccount, geojsonHasZCoordinates, getActiveBodyRadiusRatio, getActiveEllipsoid, getActiveMeanRadiusMeters, getActiveSemiMajorAxisMeters, getArcgisApiKey, getAttributeFormField, getBuildEnvironment, getCesiumIonToken, getEllipsoid, getExternalNativePaintBridge, getGeocoderConfig, getGeocodingProvider, getGoogleMapsApiKey, getHistoryCoalesceMs, getMapboxAccessToken, getMaxHistoryFeatureCount, getPlanetaryBasemapById, getPlanetaryBasemapByStyleUrl, getProtomapsApiKey, getProtomapsStyleUrl, getRegionalBasemapById, getRegionalBasemapByStyleUrl, getRoundNum, getRoutingConfig, getRuntimeEnvironment, getS3UrlSigner, getSpatialExtensionPath, getVectorColorRamp, googleMapsApiKeyHeaderValue, groupMemberIndices, hasActiveLayerFilter, hasActiveQuickFilter, hasAppPrivilege, hasHeaderReferences, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, heatmapRampColors, horizontalBbox, identifyAllIncludes, identifyStateWithoutLayers, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, intersectPrivileges, invertSelection, isAbsoluteFilesystemPath, isAdoptedVectorAwaitingFeatures, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCesiumIonLayer, isCesiumKmlLayer, isCesiumOnlyLayer, isCredentialFieldName, isCredentialedS3Url, isCzmlLayer, isDefaultPrintLayout, isDeploymentCapability, isDiagramStyleEnabled, isDuckDBQueryLayer, isExternalNativeLayerRecord, isGooglePhotorealisticTilesetUrl, isHeaderReferenceOnly, isHexColor, isInitialLayerStyle, isInlineImageValue, isInternalPopupField, isIpadDesktopUserAgent, isMaintainedEditorTrackingField, isPopupClickEnabled, isPopupHoverEnabled, isRegionalBasemapSentinel, isS3Uri, isSafePopupUrl, isSecretEnvironmentVariable, isStoryHiddenLayer, isStyleLibraryTargetLayer, isStyleSpecColor, isVectorColorExpression, isochroneResponseToFeatures, labelFieldTextField, layerGroupDepth, layerGroupMoveability, layerGroupSortability, layerJoinKey, layerLibraryConfigPatch, layerLibraryEntryNeedsLocalFile, layerPanelGroupHeaders, lineWidthValue, localFileName, lookupProjectCredential, mapZoomStepOutputs, matchFeaturesByExpression, matchLayerStyleEntry, matrixResponseToFeatures, meanRadiusMeters, mercatorMetersPerPixelAtZoom0, metersWidthExpression, nextDelayMs, nextLayerPaletteColor, nominatimResultToFeature, nominatimReverseResultToDisplay, nonEmptyRecord, normalizeAppPrivileges, normalizeBlankBackgroundColor, normalizeCesiumBasemap, normalizeDashboardColumns, normalizeGeocodingProviderId, normalizeGroupContiguity, normalizeHexColor, normalizeLayerCapabilities, normalizeLayerLibraryEntries, normalizeLayerStyleEntries, normalizeLongitude, normalizeMapLayout, normalizeMapViewState, normalizeModelGraph, normalizeModels, normalizePrimaryRenderer, normalizePrintLayoutConfig, normalizeProcessingHistory, normalizeProjectComments, normalizeProjectInteraction, normalizeSecondaryMapViews, normalizeStoryMap, normalizeStyleLibraryEntries, normalizeWidgets, overlayStoredEnvironmentVariables, overlayStoredGeocodingApiKeys, overlayStoredPreferenceCredentials, parseCesiumIonAssetId, parseContours, parseCzml, parseDeploymentCapabilities, parseHexColor, parseHexColorList, parseJsonExpression, parseLayerLibrary, parseLayerStylesFile, parseProject, parseS3BucketList, parseS3Error, parseS3ListObjects, parseS3Url, parseStoryMapCsv, parseStoryMapJson, parseStyleLibrary, parseValueMapText, persistedThreeDTilesRequestHeaders, pickEditorIdentity, planLayerLibraryAdd, pluginOwnsPaint, polylineStrToGeoJSON, popupFieldLabel, portableWmsTileUrl, presignS3Url, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, registerS3UrlSigner, removeTrailingJsonCommas, rendererAppliesOpacity, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveConfiguredPopupTitle, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveHeaderReferences, resolveIdentifyTarget, resolveLabelNumberLocale, resolveLayerCapabilities, resolveMapGrid, resolvePopupBody, resolvePopupImageHeight, resolvePopupMaxWidth, resolvePopupRows, resolvePopupTitle, resolveProjectHeaderReferences, resolveReadableUrl, resolveRolePrivileges, resolveSvgSource, resolveThreeDTilesRequestHeaders, rgbToHex, routeResponseToFeatures, rowCap, ruleBasedColorExpression, ruleBasedVisibilityFilter, s3ObjectHttpsUrl, sameCesiumImagery, sampleMapTerrain, sampleMapTerrainPoint, sampleRemoteElevations, sanitizeLayerStylePatch, scaleAltitudeToActiveBody, scaleDenomination, scaleSpan, scrubCommentsForRemovedLayers, scrubLegendForRemovedLayers, scrubPrintLayoutForLayers, scrubPrintLayoutForRemovedLayers, scrubWidgetsForRemovedLayers, selectLayerById, selectLayerIds, selectLayerSummaries, selectLayersWhen, serializeLayerLibrary, serializeLayerStylesFile, serializeProject, serializeProjectWithLayerCache, serializeStoryMapCsv, serializeStoryMapJson, serializeStyleLibrary, setActiveEllipsoidId, setExternalNativePaintBridge, setGeocodingFetch, setHistoryCoalesceMs, setMaxHistoryFeatureCount, setProjectCredentialLookup, setStoredAuthorName, shouldThrottle, shouldUseTiledRendering, simpleStyleNumberValue, sortLayerGroupInPanel, splitProjectCredentials, stampFeatureCollectionEditorTracking, stampFeatureEditorTracking, stampFeaturePropertiesEditorTracking, storyLayerOpacityFactor, storyMapHasContent, storyVisibleLayers, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, uniqueImportedLayerName, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, unsignedSourceUrl, useAppCapability, useAppStore, useLayer, useLayerIds, useLayerSummaries, useLayersWhen, validateAttributeFormField, validateAttributeFormValues, validateMapExpression, valueMapLabelFor, valueMapToText, vectorCircleColorValue, vectorColorExpression, vectorFillColorValue, vectorFillOpacityValue, vectorLineColorValue, vectorOutlineColorValue, vectorStrokeWidthValue, visiblePopupFields, visiblePopupProperties };
+export { ALL_APP_PRIVILEGES, ALL_DEPLOYMENT_CAPABILITIES, BLANK_BASEMAP, BLEND_MODES, BUILT_IN_STYLE_PRESETS, CARTOCIUDAD_MIN_INTERVAL_MS, CARTOCIUDAD_PUBLIC_HOST, CESIUM_BASEMAPS, CESIUM_BING_AERIAL_ASSET_ID, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID, CESIUM_ION_QUICK_PICKS, CESIUM_ION_SOURCE_KIND, CESIUM_KML_SOURCE_KIND, CESIUM_OSM_BUILDINGS_ASSET_ID, CHINA_BASEMAPS, CZML_QUICK_PICKS, CZML_SOURCE_KIND, DEFAULT_BASEMAP, DEFAULT_BLEND_MODE, DEFAULT_COLLABORATION_STATE, DEFAULT_DASHBOARD_COLUMNS, DEFAULT_EDITOR_IDENTITY, DEFAULT_EDITOR_TRACKING_CONFIG, DEFAULT_ELLIPSOID_ID, DEFAULT_FORWARD_GEOCODE_ENDPOINT, DEFAULT_GEOCODING_PROVIDER_ID, DEFAULT_LAYER_GROUP_OPACITY, DEFAULT_LAYER_STYLE, DEFAULT_LEGEND_CONFIG, DEFAULT_MAP_GRID_LAYOUT, DEFAULT_PRIMARY_RENDERER, DEFAULT_PRINT_LAYOUT, DEFAULT_PROJECT_NAME, DEFAULT_PROJECT_PREFERENCES, DEFAULT_REVERSE_GEOCODE_ENDPOINT, DEFAULT_ROUTING_ENDPOINT, DEFAULT_STORY_MAP, DEPLOYMENT_CAPABILITIES, DUCKDB_VECTOR_FEATURE_WARN_COUNT, DUCKDB_VECTOR_ROUTE_BYTES, EARTH_MEAN_RADIUS_METERS, EDITOR_IDENTITY_STORAGE_KEY, ELEVATION_REQUEST_TIMEOUT_MS, ELLIPSOIDS, EXPRESSION_FUNCTION_CATEGORIES, ElevationFetchError, FEET_PER_METER, FEET_PER_MILE, GEOCODE_DISPLAY_NAME_KEY, GEOCODE_LAT_KEY, GEOCODE_LON_KEY, GEOCODE_PROVIDER_KEY, GEOCODE_SCORE_KEY, GEOCODE_STATUS_KEY, GEOCODING_PROVIDERS, GOOGLE_MAPS_API_KEY_HEADER, IDENTIFY_ALL_LAYERS_ID, LABEL_NUMBER_LOCALES, LABEL_NUMBER_SAMPLE, LARGE_VECTOR_FEATURE_THRESHOLD, LAYER_LIBRARY_BUNDLE_TYPE, LAYER_LIBRARY_BUNDLE_VERSION, LAYER_PALETTE, LAYER_STYLES_FILE_TYPE, LAYER_STYLES_FILE_VERSION, LAYER_TYPES, MAX_DASHBOARD_COLUMNS, MAX_DIAGRAM_FEATURES, MAX_DIAGRAM_SCAN_FEATURES, MAX_LAYER_LIBRARY_ENTRIES, MAX_LAYER_LIBRARY_ENTRY_BYTES, MAX_MAP_GRID_DIM, MAX_POINTS_PER_REQUEST, MAX_PROCESSING_HISTORY, MAX_REDACT_DEPTH, MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0, METERS_PER_FOOT, METERS_PER_MILE, METERS_PER_NAUTICAL_MILE, MIN_DASHBOARD_COLUMNS, MIN_DIAGRAM_SIZE, NETCDF_IMAGE_SOURCE_KIND, NOMINATIM_MIN_INTERVAL_MS, NOMINATIM_PUBLIC_HOST, NO_DEPLOYMENT_CAPABILITIES, NO_LAYERS, OPENFREEMAP_BASEMAPS, PHOTO_FULL_PROPERTY, PHOTO_PROPERTY, PLANETARY_BASEMAPS, PLANETARY_BASEMAP_GROUPS, PLANETARY_BASEMAP_SENTINEL_PREFIX, PLANET_SWITCHER_OPTIONS, POINTER_ELEVATION_CACHE_LIMIT, POINTER_ELEVATION_DEBOUNCE_MS, POPUP_IMAGE_HEIGHT_RANGE, POPUP_MAX_WIDTH_RANGE, PROJECT_CREDENTIAL_FIELDS, PROJECT_VERSION, PROTOMAPS_BASEMAPS, PUBLIC_GEOCODE_ROW_CAP, PUBLISHABLE_PLUGIN_SETTINGS, RAMP_STYLE_KEYS, RASTER_APPEARANCE_STATE_KEYS, REGIONAL_BASEMAPS, REGIONAL_BASEMAP_GROUPS, REGIONAL_BASEMAP_SENTINEL_PREFIX, ROLE_PRIVILEGES, RoutingRequestError, S3CorsError, S3_MAX_PRESIGN_SECONDS, SELECTION_MODES, SQL_QUERY_SOURCE_KIND, STAC_PROCESSING_EXTENSION, STAC_VERSION, STYLE_LIBRARY_BUNDLE_TYPE, STYLE_LIBRARY_BUNDLE_VERSION, SYMBOL_STYLE_KEYS, VECTOR_COLOR_RAMPS, activeLayerFilterExpression, activeQuickFilters, allowsCredentialHeaders, appPrivilegeReason, applyCopiedLayerStyle, applyGroupEffects, applyJoinsToLayer, applyLayerJoins, applyLayerVirtualFields, applyMatchedSelection, applyProjectToStore, applySelectionMode, applyStoryLayerOpacity, attributeFormFieldLabel, attributeLinkUrl, availableCesiumBasemap, basemapToCesiumImagery, batchDecodePolylines, bodyLengthToEarth, buildForwardGeocodeUrl, buildIsochroneRequest, buildLayerPanelUnits, buildLayerStacItem, buildLayerTree, buildMatrixRequest, buildReverseGeocodeUrl, buildRouteRequest, canRedoProjectRestore, canSaveLayerToLibrary, canUndoProjectRestore, captureLayerLibraryEntry, cascadeLayerJoinRefresh, cesiumIonAssetId, cesiumIonAssetKind, cesiumKmlSource, changedPreferenceCredentials, circleRadiusValue, clampLabelDecimals, clampLatitude, clearExternalNativePaintBridge, clearHistory, clearQuickFilterValues, coerceAttributeFormValue, collectDiagramData, collectTransitiveJoinSourceIds, compareSequenceValues, compileFeatureExpression, compileLayerFilters, compileQuickFilter, compileQuickFilters, controlRendersLayer, copyableLayerStyleKind, createCesiumIonLayer, createCesiumKmlLayer, createCzmlLayer, createDefaultAppCapabilities, createDefaultMapView, createDefaultPrintLayout, createEmptyProject, createEqualIntervalBreaks, createGraduatedClassBreaks, createLayerLibraryEntryId, createPointerElevationResolver, createProjectLayerSerializationCache, createProjectTemplate, createQuantileBreaks, createSampleStoryMap, createStyleLayerEvaluator, createStyleLibraryEntryId, csvRowsToGeocodeRequests, currentEditorIdentity, czmlSource, darkenHex, decodePolyline, decodePolylineDetailed, detachProjectCopy, detectNonGeographicCoordinates, diagramAnchor, diagramPixelSize, diagramsSuppressedByPointRenderer, diffFeatureCollections, diffProjects, documentLocale, dominantGeometry, drawMarkerPath, earthAreaToBody, earthLengthToBody, editorTrackingFieldNames, effectiveLayerRenderState, effectiveVectorRules, encodePolyline, encodeS3Key, ensureEditorTrackingFields, environmentVariableAccount, evaluateMapExpression, excludeHiddenFieldsFromGeojson, excludeHiddenFieldsFromProject, explainS3ReadError, extractCopiedLayerStyle, extractLayerStyleEntries, extractStyleLibraryStyle, extrusionColorValue, extrusionHeightValue, featureSelectionId, fetchElevations, findLayerStyleEntryIndex, formatCameraAltitude, formatExpressionPreviewValue, formatLabelNumber, formatLabelNumberSample, formatPixelValue, formatPopupValue, formatRoundNum, formatS3Uri, generatorCircleRadiusValue, generatorSizeRange, geoJSONToPolylineStr, geocodeForward, geocodeMatchToFeature, geocodeReverse, geocoderMinIntervalMs, geocoderNeedsApiKey, geocodingApiKeyAccount, geojsonHasZCoordinates, getActiveBodyRadiusRatio, getActiveEllipsoid, getActiveMeanRadiusMeters, getActiveSemiMajorAxisMeters, getArcgisApiKey, getAttributeFormField, getBuildEnvironment, getCesiumIonToken, getEllipsoid, getExternalNativePaintBridge, getGeocoderConfig, getGeocodingProvider, getGoogleMapsApiKey, getHistoryCoalesceMs, getMapboxAccessToken, getMaxHistoryFeatureCount, getPlanetaryBasemapById, getPlanetaryBasemapByStyleUrl, getProtomapsApiKey, getProtomapsStyleUrl, getRegionalBasemapById, getRegionalBasemapByStyleUrl, getRoundNum, getRoutingConfig, getRuntimeEnvironment, getS3UrlSigner, getSpatialExtensionPath, getVectorColorRamp, googleMapsApiKeyHeaderValue, groupMemberIndices, hasActiveLayerFilter, hasActiveQuickFilter, hasAppPrivilege, hasHeaderReferences, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, heatmapRampColors, horizontalBbox, hydrateProjectLayer, identifyAllIncludes, identifyStateWithoutLayers, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, intersectPrivileges, invertSelection, isAbsoluteFilesystemPath, isAdoptedVectorAwaitingFeatures, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCesiumIonLayer, isCesiumKmlLayer, isCesiumOnlyLayer, isCredentialFieldName, isCredentialUrlParam, isCredentialedS3Url, isCzmlLayer, isDefaultPrintLayout, isDeploymentCapability, isDiagramStyleEnabled, isDuckDBQueryLayer, isExternalNativeLayerRecord, isGooglePhotorealisticTilesetUrl, isHeaderReferenceOnly, isHexColor, isInitialLayerStyle, isInlineImageValue, isInternalPopupField, isIpadDesktopUserAgent, isMaintainedEditorTrackingField, isPopupClickEnabled, isPopupHoverEnabled, isRegionalBasemapSentinel, isS3Uri, isSafePopupUrl, isSecretEnvironmentVariable, isStoryHiddenLayer, isStyleLibraryTargetLayer, isStyleSpecColor, isValidMetadataDate, isValidMetadataEmail, isValidMetadataUrl, isVectorColorExpression, isochroneResponseToFeatures, jsonValuesEqual, labelFieldTextField, layerGroupDepth, layerGroupMoveability, layerGroupSortability, layerJoinKey, layerLibraryConfigPatch, layerLibraryEntryNeedsLocalFile, layerPanelGroupHeaders, lineWidthValue, localFileName, lookupProjectCredential, mapZoomStepOutputs, matchFeaturesByExpression, matchLayerStyleEntry, matrixResponseToFeatures, meanRadiusMeters, mercatorMetersPerPixelAtZoom0, metadataDateToRfc3339, metersWidthExpression, nextDelayMs, nextLayerPaletteColor, nominatimResultToFeature, nominatimReverseResultToDisplay, nonEmptyRecord, normalizeAppPrivileges, normalizeBlankBackgroundColor, normalizeCesiumBasemap, normalizeDashboardColumns, normalizeGeocodingProviderId, normalizeGroupContiguity, normalizeHexColor, normalizeLayerCapabilities, normalizeLayerDescriptiveMetadata, normalizeLayerLibraryEntries, normalizeLayerStyleEntries, normalizeLongitude, normalizeMapLayout, normalizeMapViewState, normalizeModelGraph, normalizeModels, normalizePrimaryRenderer, normalizePrintLayoutConfig, normalizeProcessingHistory, normalizeProjectComments, normalizeProjectInteraction, normalizeSecondaryMapViews, normalizeStoryMap, normalizeStyleLibraryEntries, normalizeWidgets, overlayStoredEnvironmentVariables, overlayStoredGeocodingApiKeys, overlayStoredPreferenceCredentials, parseCesiumIonAssetId, parseContours, parseCzml, parseDeploymentCapabilities, parseHexColor, parseHexColorList, parseJsonExpression, parseLayerLibrary, parseLayerStylesFile, parseMetadataKeywords, parseProject, parseS3BucketList, parseS3Error, parseS3ListObjects, parseS3Url, parseStoryMapCsv, parseStoryMapJson, parseStyleLibrary, parseValueMapText, persistedThreeDTilesRequestHeaders, pickEditorIdentity, planLayerLibraryAdd, pluginOwnsPaint, polylineStrToGeoJSON, popupFieldLabel, portableWmsTileUrl, presignS3Url, previewValue, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactConfigurationCredentials, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, registerS3UrlSigner, removeTrailingJsonCommas, rendererAppliesOpacity, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveConfiguredPopupTitle, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveHeaderReferences, resolveIdentifyTarget, resolveLabelNumberLocale, resolveLayerCapabilities, resolveMapGrid, resolvePopupBody, resolvePopupImageHeight, resolvePopupMaxWidth, resolvePopupRows, resolvePopupTitle, resolveProjectHeaderReferences, resolveReadableUrl, resolveRolePrivileges, resolveSvgSource, resolveThreeDTilesRequestHeaders, rgbToHex, routeResponseToFeatures, rowCap, ruleBasedColorExpression, ruleBasedVisibilityFilter, s3ObjectHttpsUrl, sameCesiumImagery, sampleMapTerrain, sampleMapTerrainPoint, sampleRemoteElevations, sanitizeLayerStylePatch, scaleAltitudeToActiveBody, scaleDenomination, scaleSpan, scrubCommentsForRemovedLayers, scrubLegendForRemovedLayers, scrubPrintLayoutForLayers, scrubPrintLayoutForRemovedLayers, scrubWidgetsForRemovedLayers, selectLayerById, selectLayerIds, selectLayerSummaries, selectLayersWhen, serializeLayerLibrary, serializeLayerStylesFile, serializeProject, serializeProjectWithLayerCache, serializeProjectWithLayerCacheAsync, serializeStoryMapCsv, serializeStoryMapJson, serializeStyleLibrary, setActiveEllipsoidId, setExternalNativePaintBridge, setGeocodingFetch, setHistoryCoalesceMs, setMaxHistoryFeatureCount, setProjectCredentialLookup, setRegistryPublishableSettings, setStoredAuthorName, shouldThrottle, shouldUseTiledRendering, shouldZoomToNewLayers, simpleStyleNumberValue, sortLayerGroupInPanel, splitProjectCredentials, stacAssetMediaType, stampFeatureCollectionEditorTracking, stampFeatureEditorTracking, stampFeaturePropertiesEditorTracking, storyLayerOpacityFactor, storyLocationView, storyMapHasContent, storyVisibleLayers, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, uniqueImportedLayerName, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, unsignedSourceUrl, useAppCapability, useAppStore, useLayer, useLayerIds, useLayerSummaries, useLayersWhen, validateAttributeFormField, validateAttributeFormValues, validateLayerDescriptiveMetadata, validateMapExpression, valueMapLabelFor, valueMapToText, vectorCircleColorValue, vectorColorExpression, vectorFillColorValue, vectorFillOpacityValue, vectorLineColorValue, vectorOutlineColorValue, vectorStrokeWidthValue, visiblePopupFields, visiblePopupProperties };
 
 //# sourceMappingURL=index.mjs.map