@geolibre/core 2.8.0 → 3.0.0

package/dist/index.mjs

@@ -169,6 +169,9 @@ const DEFAULT_LAYER_STYLE = {
 		rotation: 0,
 		maxWidth: 10,
 		transform: "none",
+		numberFormatEnabled: false,
+		numberDecimals: 0,
+		numberLocale: "",
 		dedupe: "off",
 		sizeExpression: "",
 		colorExpression: "",
@@ -227,6 +230,8 @@ const DEFAULT_LAYER_STYLE = {
 	pointRenderer: "single",
 	heatmapRadius: 30,
 	heatmapIntensity: 1,
+	heatmapColorRamp: "turbo",
+	heatmapWeightProperty: "",
 	clusterRadius: 50,
 	clusterMaxZoom: 14,
 	invertedFillEnabled: false,
@@ -306,6 +311,12 @@ const NETCDF_IMAGE_SOURCE_KIND = "netcdf-image";
 function isDuckDBQueryLayer(layer) {
 	return layer?.type === "duckdb-query" && layer.metadata.sourceKind === "duckdb-query" && layer.metadata.externalDeckLayer === true;
 }
+/**
+* The engine that draws the primary map area when a project says nothing. The
+* 2D map: it is the renderer every tool, plugin, and panel is wired to, so an
+* existing project (and a new one) opens exactly as it always did.
+*/
+const DEFAULT_PRIMARY_RENDERER = "maplibre";
 /** The default single-map grid (one pane, sync enabled so it turns on cleanly). */
 const DEFAULT_MAP_GRID_LAYOUT = {
 	rows: 1,
@@ -331,6 +342,7 @@ const DEFAULT_PROJECT_PREFERENCES = {
 		ellipsoidId: "earth",
 		scaleUnit: "metric",
 		showPointerElevation: false,
+		terrainEnabled: false,
 		coordinateFormat: "dd"
 	},
 	environmentVariables: [],
@@ -1400,14 +1412,393 @@ function isRegionalBasemapSentinel(styleUrl) {
 	return Boolean(styleUrl?.startsWith(REGIONAL_BASEMAP_SENTINEL_PREFIX));
 }
 //#endregion
+//#region src/cesium-imagery.ts
+/**
+* Maps the project's basemap onto imagery the Cesium globe can render.
+*
+* The 2D panes render `basemapStyleUrl` through MapLibre, which understands
+* vector GL styles and GeoLibre's `geolibre://` sentinels. Cesium understands
+* neither: it draws imagery from tile providers only. So a globe pane that
+* simply mounted the store basemap would show nothing, which is why the pane
+* used to hardcode Ion World Imagery (with a token) or OpenStreetMap (without)
+* and ignore the user's choice entirely — leaving a bright globe beside dark 2D
+* panes and breaking the "same map, different projection" promise the multi-map
+* grid makes.
+*
+* This module is the translation. It is deliberately **engine-free** — it
+* returns a plain descriptor and never imports Cesium — so it lives in
+* `@geolibre/core` beside the basemap catalogs it reads, the 2D and 3D
+* renderers share one source of truth, and the Cesium chunk boundary in
+* `vite.config.ts` stays intact.
+*
+* Three outcomes are possible, and the caller has to handle all three (see
+* {@link CesiumBasemapImagery}): tiles to draw, nothing to draw, or "no raster
+* equivalent exists — pick your own default".
+*/
+/** Stable project IDs and the corresponding Cesium bundled thumbnails / ion assets. */
+const CESIUM_BASEMAPS = [
+	{
+		id: "project",
+		name: "Project basemap",
+		icon: "naturalEarthII.png"
+	},
+	{
+		id: "natural-earth",
+		name: "Natural Earth II",
+		icon: "naturalEarthII.png"
+	},
+	{
+		id: "bing-aerial",
+		name: "Bing Maps Aerial",
+		icon: "bingAerial.png",
+		assetId: 2
+	},
+	{
+		id: "bing-labels",
+		name: "Bing Maps Aerial with Labels",
+		icon: "bingAerialLabels.png",
+		assetId: 3
+	},
+	{
+		id: "bing-roads",
+		name: "Bing Maps Roads",
+		icon: "bingRoads.png",
+		assetId: 4
+	},
+	{
+		id: "sentinel-2",
+		name: "Sentinel-2",
+		icon: "sentinel-2.png",
+		assetId: 3954
+	},
+	{
+		id: "blue-marble",
+		name: "Blue Marble",
+		icon: "blueMarble.png",
+		assetId: 3845
+	},
+	{
+		id: "earth-at-night",
+		name: "Earth at night",
+		icon: "earthAtNight.png",
+		assetId: 3812
+	},
+	{
+		id: "google-satellite",
+		name: "Google Maps Satellite",
+		icon: "googleSatellite.png",
+		assetId: 3830182
+	},
+	{
+		id: "google-labels",
+		name: "Google Maps Satellite with Labels",
+		icon: "googleSatelliteLabels.png",
+		assetId: 3830183
+	},
+	{
+		id: "google-roads",
+		name: "Google Maps Roadmap",
+		icon: "googleRoadmap.png",
+		assetId: 3830184
+	},
+	{
+		id: "google-contour",
+		name: "Google Maps Contour",
+		icon: "googleContour.png",
+		assetId: 3830186
+	},
+	{
+		id: "azure-aerial",
+		name: "Azure Maps Aerial",
+		icon: "azureAerial.png",
+		assetId: 3891168
+	},
+	{
+		id: "azure-roads",
+		name: "Azure Maps Roads",
+		icon: "azureRoads.png",
+		assetId: 3891169
+	},
+	{
+		id: "esri-imagery",
+		name: "ArcGIS World Imagery",
+		icon: "ArcGisMapServiceWorldImagery.png",
+		category: "Other",
+		service: "World_Imagery"
+	},
+	{
+		id: "esri-hillshade",
+		name: "ArcGIS World Hillshade",
+		icon: "ArcGisMapServiceWorldHillshade.png",
+		category: "Other",
+		service: "Elevation/World_Hillshade"
+	},
+	{
+		id: "esri-ocean",
+		name: "Esri World Ocean",
+		icon: "ArcGisMapServiceWorldOcean.png",
+		category: "Other",
+		service: "Ocean/World_Ocean_Base"
+	},
+	{
+		id: "osm",
+		name: "OpenStreetMap",
+		icon: "openStreetMap.png",
+		category: "Other"
+	},
+	{
+		id: "stadia-watercolor",
+		name: "Stadia x Stamen Watercolor",
+		icon: "stamenWatercolor.png",
+		category: "Other",
+		stadiaStyle: "stamen_watercolor",
+		maximumLevel: 16,
+		extension: "jpg"
+	},
+	{
+		id: "stadia-toner",
+		name: "Stadia x Stamen Toner",
+		icon: "stamenToner.png",
+		category: "Other",
+		stadiaStyle: "stamen_toner",
+		maximumLevel: 20,
+		extension: "png"
+	},
+	{
+		id: "stadia-smooth",
+		name: "Stadia Alidade Smooth",
+		icon: "stadiaAlidadeSmooth.png",
+		category: "Other",
+		stadiaStyle: "alidade_smooth",
+		maximumLevel: 20,
+		extension: "png"
+	},
+	{
+		id: "stadia-dark",
+		name: "Stadia Alidade Smooth Dark",
+		icon: "stadiaAlidadeSmoothDark.png",
+		category: "Other",
+		stadiaStyle: "alidade_smooth_dark",
+		maximumLevel: 20,
+		extension: "png"
+	}
+];
+function normalizeCesiumBasemap(value) {
+	return CESIUM_BASEMAPS.find((entry) => entry.id === value)?.id ?? "project";
+}
+/** Missing credentials fall back to the project background without changing the saved choice. */
+function availableCesiumBasemap(value, hasIonToken) {
+	const entry = CESIUM_BASEMAPS.find((entry) => entry.id === value);
+	return entry && (!("assetId" in entry) || hasIonToken) ? entry.id : "project";
+}
+const OSM_CREDIT = "© <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors";
+/** EOX Maps serves these layers keyless under CC BY-SA 4.0. */
+const EOX_CREDIT = "<a href=\"https://maps.eox.at\">EOX Maps</a> (CC BY-SA 4.0)";
+const eoxLayer = (layer, extension) => `https://tiles.maps.eox.at/wmts/1.0.0/${layer}/default/g/{z}/{y}/{x}.${extension}`;
+/** Colourful streets — the tone of Liberty and Bright. */
+const STREETS = {
+	template: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+	attribution: OSM_CREDIT,
+	maximumLevel: 19
+};
+/** Light and muted — the tone of Positron and the pale Protomaps flavors. */
+const LIGHT = {
+	template: eoxLayer("terrain-light_3857", "jpg"),
+	attribution: `Terrain Light · ${OSM_CREDIT} · ${EOX_CREDIT}`,
+	maximumLevel: 16
+};
+/**
+* Dark — the tone of Dark, Fiord, and the dark Protomaps flavors. NASA's Black
+* Marble night lights is the one keyless dark raster basemap left, and it suits
+* a globe: the point of matching here is that a dark project does not end up
+* with a glaring bright globe in the corner.
+*/
+const DARK = {
+	template: eoxLayer("blackmarble_3857", "jpg"),
+	attribution: `Black Marble © NASA Earth Observatory · ${EOX_CREDIT}`,
+	maximumLevel: 8
+};
+/** Raster analogue per OpenFreeMap style name (the last path segment). */
+const OPENFREEMAP_ANALOGUES = {
+	liberty: STREETS,
+	bright: STREETS,
+	positron: LIGHT,
+	dark: DARK,
+	fiord: DARK
+};
+/** Raster analogue per Protomaps v5 flavor. */
+const PROTOMAPS_ANALOGUES = {
+	light: LIGHT,
+	white: LIGHT,
+	grayscale: LIGHT,
+	dark: DARK,
+	black: DARK
+};
+function toImagery(analogue) {
+	return {
+		kind: "xyz",
+		template: analogue.template,
+		attribution: analogue.attribution,
+		maximumLevel: analogue.maximumLevel
+	};
+}
+/**
+* Whether two descriptors would draw the same thing.
+*
+* Descriptors are built fresh on every call, so two basemaps resolving to the
+* same analogue — OpenFreeMap `liberty` and `bright` are both the streets
+* tone — yield equal but distinct objects. A renderer that remembers the
+* descriptor it drew (to skip redundant work) must compare by value: a
+* reference check would miss that case and tear down and re-add an identical
+* tile provider, costing a flash and a round of re-requested tiles for no
+* visible change.
+*/
+function sameCesiumImagery(a, b) {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "arcgis" && b.kind === "arcgis") return a.url === b.url;
+	if (a.kind === "ion" && b.kind === "ion") return a.assetId === b.assetId;
+	if (a.kind !== "xyz" || b.kind !== "xyz") return true;
+	return a.template === b.template && a.apiKeyProvider === b.apiKeyProvider && a.attribution === b.attribution && a.maximumLevel === b.maximumLevel && a.scheme === b.scheme && a.overlayTemplate === b.overlayTemplate;
+}
+/**
+* `decodeURIComponent` that reports failure instead of throwing. A URL keeps a
+* malformed escape (`%E0%A4`) in its pathname quite happily, but decoding one
+* throws `URIError` — and this runs inside a React render, so an unhandled throw
+* would take the globe pane down instead of falling through to the default.
+*/
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return;
+	}
+}
+/**
+* The raster analogue for a vector GL style URL, or undefined when the style is
+* not one GeoLibre ships (a provider style, a user's own URL, a Mapbox style).
+* Matching on host + path rather than searching the URL for "dark"/"light"
+* keeps an unrelated style whose *key* happens to contain one of those words
+* from being mapped to the wrong tone.
+*/
+function vectorStyleAnalogue(styleUrl) {
+	let parsed;
+	try {
+		parsed = new URL(styleUrl);
+	} catch {
+		return;
+	}
+	if (parsed.hostname === "tiles.openfreemap.org") {
+		const name = parsed.pathname.split("/").filter(Boolean).at(-1);
+		return name ? OPENFREEMAP_ANALOGUES[name] : void 0;
+	}
+	if (parsed.hostname === "api.protomaps.com") {
+		const segments = parsed.pathname.split("/").filter(Boolean);
+		const flavor = segments[0] === "styles" ? segments[2] : void 0;
+		const decoded = flavor ? safeDecode(flavor) : void 0;
+		return decoded ? PROTOMAPS_ANALOGUES[decoded] : void 0;
+	}
+}
+/**
+* Translate a basemap style URL into imagery for the Cesium globe.
+*
+* Planetary and regional basemaps are already raster tile sets, so they carry
+* straight over — the globe shows the same Mars/Moon/Amap tiles the 2D panes
+* do. GeoLibre's own vector styles map to a keyless raster basemap of matching
+* tone, so switching the project to a dark basemap darkens the globe too.
+* Everything else reports `default`, leaving the choice of fallback imagery to
+* the renderer (which knows whether an Ion token is configured).
+*
+* A `geolibre://` sentinel that no longer resolves is treated as the default
+* basemap, mirroring what `resolveMapStyle` does for the 2D map rather than
+* handing the sentinel onward as if it were fetchable.
+*
+* @param styleUrl - The project's `basemapStyleUrl`.
+* @returns What the globe should draw beneath the data layers.
+*/
+function basemapToCesiumImagery(styleUrl, cesiumBasemap = "project") {
+	const entry = CESIUM_BASEMAPS.find((entry) => entry.id === cesiumBasemap);
+	if (entry && "service" in entry) return {
+		kind: "arcgis",
+		url: `https://services.arcgisonline.com/ArcGIS/rest/services/${entry.service}/MapServer`
+	};
+	if (entry && "stadiaStyle" in entry) return {
+		kind: "xyz",
+		template: `https://tiles.stadiamaps.com/tiles/${entry.stadiaStyle}/{z}/{x}/{y}.${entry.extension}`,
+		maximumLevel: entry.maximumLevel,
+		apiKeyProvider: "stadia",
+		attribution: "<a href=\"https://stadiamaps.com/\">© Stadia Maps</a> " + (entry.stadiaStyle.startsWith("stamen_") ? "<a href=\"https://stamen.com/\">© Stamen Design</a> " : "") + "<a href=\"https://openmaptiles.org/\">© OpenMapTiles</a> <a href=\"https://www.openstreetmap.org/copyright\">© OpenStreetMap contributors</a>"
+	};
+	if (entry && "assetId" in entry) return {
+		kind: "ion",
+		assetId: entry.assetId
+	};
+	if (cesiumBasemap === "natural-earth") return { kind: "natural-earth" };
+	if (cesiumBasemap === "osm") return toImagery(STREETS);
+	if (styleUrl === "") return { kind: "none" };
+	const url = styleUrl ?? "https://tiles.openfreemap.org/styles/liberty";
+	const planetary = getPlanetaryBasemapByStyleUrl(url);
+	if (planetary) return {
+		kind: "xyz",
+		template: planetary.tileUrl,
+		attribution: planetary.attribution,
+		maximumLevel: planetary.maxZoom,
+		...planetary.scheme ? { scheme: planetary.scheme } : {}
+	};
+	const regional = getRegionalBasemapByStyleUrl(url);
+	if (regional) return {
+		kind: "xyz",
+		template: regional.tileUrl,
+		attribution: regional.attribution,
+		maximumLevel: regional.maxZoom,
+		...regional.scheme ? { scheme: regional.scheme } : {},
+		...regional.overlayTileUrl ? { overlayTemplate: regional.overlayTileUrl } : {}
+	};
+	const analogue = vectorStyleAnalogue(url.startsWith("geolibre://") ? DEFAULT_BASEMAP : url);
+	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.
-*/
+* 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();
 /**
 * Returns true when any coordinate in the GeoJSON carries a finite, non-zero
@@ -2383,13 +2774,18 @@ function getMapboxAccessToken(env) {
 /**
 * Resolves the Cesium Ion access token from the runtime environment.
 *
-* The 3D-globe view's world imagery and terrain need a Cesium Ion token. It is
+* Cesium World Terrain and Ion World Imagery need a Cesium Ion token. It is
 * supplied via `VITE_CESIUM_TOKEN` (baked in at build time from the bare
 * `CESIUM_TOKEN` env var, which `vite.config.ts` copies into the prefixed name)
 * or set at runtime through Settings → Environment variables
 * (`window.__GEOLIBRE_RUNTIME_ENV__`, which bypasses Vite's envPrefix allowlist,
-* so a bare `CESIUM_TOKEN` entry works there too). When unset, the globe cannot
-* render and the 3D view is not offered.
+* so a bare `CESIUM_TOKEN` entry works there too).
+*
+* The 3D-globe view itself does **not** need one: it draws the project basemap
+* as its base imagery whenever that basemap has a raster form (see
+* {@link basemapToCesiumImagery}), and falls back to Ion World Imagery — or, with
+* no token, to OpenStreetMap — for the ones that do not. So an absent token
+* costs terrain and the quality of that fallback, not the view.
 *
 * @param env - Environment record (defaults to the runtime environment);
 *   injectable for testing.
@@ -2842,7 +3238,8 @@ const EXPRESSION_FUNCTION_CATEGORIES = [
 			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("slice", "[\"slice\", [\"get\", \"field\"], 0, 3]", "slice"),
+			fn("number-format", "[\"number-format\", [\"get\", \"field\"], {\"locale\": \"en-US\", \"max-fraction-digits\": 2}]", "numberFormat")
 		]
 	},
 	{
@@ -3060,11 +3457,11 @@ function compileFeatureExpression(source, options = {}) {
 		ok: false,
 		errors: validation.errors
 	};
-	const zoom = options.zoom ?? 0;
+	const compiledZoom = options.zoom ?? 0;
 	return {
 		ok: true,
 		errors: [],
-		evaluate: (feature) => expression.evaluateWithoutErrorHandling({ zoom }, {
+		evaluate: (feature, zoom = compiledZoom) => expression.evaluateWithoutErrorHandling({ zoom }, {
 			type: feature.geometry?.type ?? "Unknown",
 			properties: feature.properties ?? {},
 			...feature.id !== void 0 ? { id: feature.id } : {},
@@ -3698,6 +4095,23 @@ function vectorFillOpacityValue(style, fallback) {
 	return ruleOverrideValue(style, "fillOpacity", fallback);
 }
 /**
+* The color-ramp colors a density heatmap paints with.
+*
+* {@link getVectorColorRamp} falls back to the *first* ramp ("viridis") for an
+* unknown name, which is not the heatmap default ("turbo"). Both the map paint
+* (`heatmapPaint` in `@geolibre/map`) and the auto-legend gradient resolve the
+* ramp here so a stale or hand-edited `heatmapColorRamp` cannot make the legend
+* and the rendered heatmap disagree about which ramp is in use.
+*
+* @param style - The layer style.
+* @returns The ramp's colors, or the default ramp's colors for an unknown name.
+*/
+function heatmapRampColors(style) {
+	const value = styleValue(style, "heatmapColorRamp");
+	const ramp = getVectorColorRamp(value);
+	return (ramp.value === value ? ramp : getVectorColorRamp(DEFAULT_LAYER_STYLE.heatmapColorRamp)).colors;
+}
+/**
 * The proportional-size configuration, or `null` when proportional sizing
 * does not apply: disabled, no field chosen, non-finite or degenerate
 * (`maxValue <= minValue`) value range, or non-finite radii. This is the
@@ -3937,6 +4351,236 @@ function extrusionColorValue(style) {
 	return parseJsonExpression(styleValue(style, "extrusionAdvancedStyleEnabled") ? styleValue(style, "extrusionColorExpression") : "") ?? flat;
 }
 //#endregion
+//#region src/document-locale.ts
+/**
+* The document language, so formatted numbers and dates follow the UI locale.
+*
+* Shared by the Identify popup's value formatting and by label number
+* formatting, which both fall back to it when the author has not pinned an
+* explicit locale. Returns `undefined` outside a browser (tests, the headless
+* project authoring paths), which leaves `Intl` on its own default.
+*/
+function documentLocale() {
+	return (typeof document !== "undefined" ? document.documentElement.lang.trim() : "") || void 0;
+}
+//#endregion
+//#region src/label-number-format.ts
+/**
+* Locale-aware number formatting for map labels (issue #2336).
+*
+* A numeric attribute rendered straight into a label reads as `1234567.5`,
+* which is hard to compare at a glance. QGIS solves this with
+* `format_number(field, places, language)`; the equivalent here is three
+* {@link LabelStyle} fields — {@link LabelStyle.numberFormatEnabled},
+* {@link LabelStyle.numberDecimals} and {@link LabelStyle.numberLocale} —
+* whose effect this module renders two ways:
+*
+* - {@link labelFieldTextField} builds the MapLibre `text-field` expression the
+*   2D map and the Mapbox/MapLibre style export both use, so the map and the
+*   exported style agree.
+* - {@link formatLabelNumber} does the same in JavaScript for the paths that
+*   resolve label text themselves: the Cesium globe and the duplicate-label
+*   collapsing modes.
+*
+* Formatting applies to {@link LabelStyle.field} only. A label
+* {@link LabelStyle.expression} formats its own output (with `number-format`,
+* offered in the Expression Builder), so wrapping it here would fight the
+* author.
+*/
+/**
+* Locales offered for {@link LabelStyle.numberLocale}, alongside the default
+* empty value that follows the app's own language.
+*
+* Deliberately short, and every entry groups with a character the map's glyph
+* stack can draw: ASCII `,`/`.` or U+00A0. Locales whose CLDR grouping uses
+* the narrow no-break space U+202F (`fr-FR`) or non-Latin digits (`ar-EG`)
+* are left out because a missing glyph renders as a blank box on the map
+* rather than as a separator. An author who needs one of those can still
+* write `["number-format", …]` in the label expression.
+*/
+const LABEL_NUMBER_LOCALES = [
+	"en-US",
+	"de-DE",
+	"ru-RU",
+	"hi-IN"
+];
+/**
+* Magnitude at which the text-field stops treating a value as a finite number.
+*
+* JSON carries no `Infinity`, so the expression cannot test against it
+* directly; this is the largest power of ten a double holds, which doubles as
+* the `to-number` fallback so an unconvertible value fails the same test. A
+* real attribute at or above it labels as plain text instead of a formatted
+* number -- a trade worth making for values already past 1e308.
+*/
+const NON_FINITE_SENTINEL = 1e308;
+/** Sample value used to preview a locale's separators in the Style panel. */
+const LABEL_NUMBER_SAMPLE = 1234567.5;
+/**
+* Cached `Intl.NumberFormat`s, keyed by locale + decimals. `formatLabelNumber`
+* runs once per labeled feature (per Cesium entity, per deduplicated point), so
+* constructing a formatter on every call is the wrong order of magnitude.
+*
+* The key space is small: {@link LABEL_NUMBER_LOCALES} plus the app's own
+* language, times eleven decimal settings, times whatever a hand-edited project
+* pins.
+*/
+const formatterCache = /* @__PURE__ */ new Map();
+/** Locale tags already accepted or rejected, so each is tested once. */
+const localeSupport = /* @__PURE__ */ new Map();
+/**
+* A formatter for this locale/decimals pair. Grouping is always on: it is the
+* whole point of the setting. The locale must already have been vetted by
+* {@link resolveLabelNumberLocale}, so this never throws.
+*/
+function labelNumberFormatter(locale, decimals) {
+	const digits = clampLabelDecimals(decimals);
+	const key = `${locale ?? ""}\u0000${digits}`;
+	const cached = formatterCache.get(key);
+	if (cached) return cached;
+	const formatter = new Intl.NumberFormat(locale, {
+		useGrouping: true,
+		minimumFractionDigits: digits,
+		maximumFractionDigits: digits
+	});
+	formatterCache.set(key, formatter);
+	return formatter;
+}
+/**
+* Whether every character a locale's grouping produces is one the map's glyph
+* stack can draw: ASCII, or the no-break space U+00A0.
+*
+* {@link LABEL_NUMBER_LOCALES} is curated on exactly this basis, but the picker
+* is not the only way a locale reaches the renderer. A hand-edited project can
+* pin any tag, and the default (`numberLocale: ""`) follows the app's own
+* language, so a French or Arabic UI would otherwise put U+202F or Arabic-Indic
+* digits into the `text-field` and label the map with blank boxes. Testing the
+* rendered sample rather than the tag covers both routes and needs no list to
+* keep in sync.
+*/
+function glyphSafeLocale(tag) {
+	try {
+		const format = new Intl.NumberFormat(tag, {
+			useGrouping: true,
+			minimumFractionDigits: 2,
+			maximumFractionDigits: 2
+		});
+		for (const sample of [format.format(LABEL_NUMBER_SAMPLE), format.format(-1234567.5)]) for (const char of sample) {
+			const code = char.codePointAt(0) ?? 0;
+			if (code >= 128 && code !== 160) return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Clamp a decimal-places setting to the range the UI and `Intl` both accept. */
+function clampLabelDecimals(decimals) {
+	if (!Number.isFinite(decimals)) return 0;
+	return Math.max(0, Math.min(10, Math.trunc(decimals)));
+}
+/**
+* The first locale tag that both `Intl` accepts and the map can draw, or
+* `undefined` to leave `Intl` and MapLibre on the runtime default.
+*
+* Every path resolves its locale through here -- the JavaScript formatter, the
+* MapLibre expression, and the dedup cache key -- so all three agree on which
+* locale is actually in effect.
+*/
+function resolveLabelNumberLocale(...tags) {
+	for (const tag of tags) {
+		if (!tag) continue;
+		let usable = localeSupport.get(tag);
+		if (usable === void 0) {
+			usable = glyphSafeLocale(tag);
+			localeSupport.set(tag, usable);
+		}
+		if (usable) return tag;
+	}
+}
+/**
+* Format one label value as a number, or `null` when the setting is off or the
+* value is not a finite number (a text attribute keeps its own rendering).
+*
+* @param value - The raw attribute value.
+* @param labels - The layer's label configuration.
+* @param fallbackLocale - Locale used when {@link LabelStyle.numberLocale} is
+*   empty; the caller passes the app's language. Omitted means the runtime
+*   default, matching how popups format their numbers.
+*/
+function formatLabelNumber(value, labels, fallbackLocale) {
+	if (!labels.numberFormatEnabled) return null;
+	if (typeof value !== "number" || !Number.isFinite(value)) return null;
+	return labelNumberFormatter(resolveLabelNumberLocale(labels.numberLocale, fallbackLocale), labels.numberDecimals).format(value);
+}
+/**
+* The MapLibre expression that renders {@link LabelStyle.field} as text, with
+* number formatting applied when it is on. Returns `""` when no field is set,
+* which callers treat as "no label text".
+*
+* Number formatting is guarded by a `typeof` test rather than applied blindly
+* so a mixed or text column still labels normally; only real numbers take the
+* `number-format` branch.
+*/
+function labelFieldTextField(labels, fallbackLocale) {
+	const field = labels.field;
+	if (!field) return "";
+	const asText = ["to-string", [
+		"coalesce",
+		["get", field],
+		""
+	]];
+	if (!labels.numberFormatEnabled) return asText;
+	const locale = resolveLabelNumberLocale(labels.numberLocale, fallbackLocale);
+	const digits = clampLabelDecimals(labels.numberDecimals);
+	const options = {};
+	if (locale) options.locale = locale;
+	const numeric = [
+		"to-number",
+		["get", field],
+		NON_FINITE_SENTINEL
+	];
+	const number = digits > 0 ? numeric : ["round", numeric];
+	if (digits > 0) {
+		options["min-fraction-digits"] = digits;
+		options["max-fraction-digits"] = digits;
+	}
+	return [
+		"case",
+		[
+			"all",
+			[
+				"==",
+				["typeof", ["get", field]],
+				"number"
+			],
+			[
+				"<",
+				["abs", numeric],
+				NON_FINITE_SENTINEL
+			]
+		],
+		[
+			"number-format",
+			number,
+			options
+		],
+		asText
+	];
+}
+/**
+* Render {@link LABEL_NUMBER_SAMPLE} the way a locale/decimals pair would, so
+* the Style panel can name each choice by the separators it actually produces
+* ("1,234,567.50") instead of by an opaque language tag.
+*
+* A tag `Intl` rejects (or one the map cannot draw) falls back to the runtime
+* locale's formatting rather than to an unformatted number, matching what
+* {@link formatLabelNumber} and the emitted expression do with the same tag.
+*/
+function formatLabelNumberSample(locale, decimals) {
+	return labelNumberFormatter(resolveLabelNumberLocale(locale), decimals).format(LABEL_NUMBER_SAMPLE);
+}
+//#endregion
 //#region src/external-native-paint.ts
 /**
 * Whether a layer is drawn by a **custom render layer** its control created — a
@@ -4630,6 +5274,10 @@ function valueToString(value) {
 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.
@@ -4722,7 +5370,7 @@ function applyLayerJoins(features, joins, resolveSource) {
 			}
 			const lookup = /* @__PURE__ */ new Map();
 			for (const jf of joinFeatures) {
-				const key = layerJoinKey(jf.properties?.[join.joinField]);
+				const key = layerJoinKey(fieldValue(jf.properties, join.joinField));
 				if (key === null || lookup.has(key)) continue;
 				lookup.set(key, jf.properties ?? {});
 			}
@@ -4730,17 +5378,17 @@ function applyLayerJoins(features, joins, resolveSource) {
 			const targetKeys = /* @__PURE__ */ new Set();
 			for (const feature of out) {
 				const props = feature.properties;
-				const key = layerJoinKey(props[join.targetField]);
+				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] = row[field] !== void 0 ? row[field] : null;
+					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(jf.properties?.[join.joinField]);
+				const key = layerJoinKey(fieldValue(jf.properties, join.joinField));
 				if (key !== null && !targetKeys.has(key)) unmatchedJoin += 1;
 			}
 			return {
@@ -5150,6 +5798,42 @@ function clearQuickFilterValues(filters) {
 	}));
 }
 //#endregion
+//#region src/layer-filters.ts
+/**
+* Return a layer's persisted expression filter when it has a usable array
+* shape, otherwise return null.
+*
+* @param layer - The layer whose expression filter should be read.
+* @returns The active expression filter, or null when none is configured.
+*/
+function activeLayerFilterExpression(layer) {
+	const expression = layer.filterExpression;
+	return Array.isArray(expression) && expression.length > 0 ? expression : null;
+}
+/**
+* Compile all project-authored filters for a layer into one MapLibre boolean
+* expression. An explicit expression and Quick Filter controls narrow the
+* layer together.
+*
+* @param layer - The layer whose authored filters should be composed.
+* @returns A MapLibre filter expression, or null when no authored filter is active.
+*/
+function compileLayerFilters(layer) {
+	const filters = [activeLayerFilterExpression(layer), compileQuickFilters(layer.quickFilters)].filter((filter) => filter !== null);
+	if (filters.length === 0) return null;
+	return filters.length === 1 ? filters[0] : ["all", ...filters];
+}
+/**
+* Whether a project-authored expression or Quick Filter currently narrows a
+* layer. This drives the filtered indicator and clear action in the layer UI.
+*
+* @param layer - The layer to inspect.
+* @returns True when at least one persisted filter is active.
+*/
+function hasActiveLayerFilter(layer) {
+	return compileLayerFilters(layer) !== null;
+}
+//#endregion
 //#region src/capabilities.ts
 /**
 * Default inferred capabilities for a layer based on its type and metadata.
@@ -5228,6 +5912,210 @@ function normalizeLayerCapabilities(raw) {
 	}
 	return hasAny ? caps : void 0;
 }
+/**
+* All supported application privilege identifiers in GeoLibre.
+*/
+const ALL_APP_PRIVILEGES = [
+	"layers:edit",
+	"layers:add-remote",
+	"layers:add-local",
+	"processing:run",
+	"processing:sidecar",
+	"project:save",
+	"project:share",
+	"project:share-public",
+	"plugins:install",
+	"assistant:use",
+	"connections:manage",
+	"export:data",
+	"export:image",
+	"settings:manage"
+];
+/**
+* Standard privilege bundles for named application roles.
+*/
+const ROLE_PRIVILEGES = {
+	viewer: ["export:image", "export:data"],
+	editor: [
+		"export:image",
+		"export:data",
+		"layers:edit",
+		"layers:add-local",
+		"layers:add-remote",
+		"processing:run",
+		"project:save"
+	],
+	publisher: [
+		"export:image",
+		"export:data",
+		"layers:edit",
+		"layers:add-local",
+		"layers:add-remote",
+		"processing:run",
+		"project:save",
+		"project:share",
+		"project:share-public",
+		"processing:sidecar",
+		"assistant:use"
+	],
+	administrator: ALL_APP_PRIVILEGES
+};
+/**
+* Resolves the effective privilege list for a given role, applying custom overrides if specified.
+*/
+function resolveRolePrivileges(role, customPrivileges) {
+	if (role === "custom") {
+		if (!customPrivileges || customPrivileges.length === 0) return [];
+		const validSet = new Set(ALL_APP_PRIVILEGES);
+		return [...new Set(customPrivileges.filter((p) => validSet.has(p)))];
+	}
+	return [...ROLE_PRIVILEGES[role]];
+}
+/**
+* Intersects multiple sets of privileges to derive the effective permissions when multiple
+* policies (e.g. deployment, organization, and share link) apply simultaneously.
+*/
+function intersectPrivileges(...privilegeSets) {
+	if (privilegeSets.length === 0) return [];
+	if (privilegeSets.length === 1) return [...new Set(privilegeSets[0])];
+	let current = new Set(privilegeSets[0]);
+	for (let i = 1; i < privilegeSets.length; i++) {
+		const nextSet = new Set(privilegeSets[i]);
+		current = new Set([...current].filter((p) => nextSet.has(p)));
+	}
+	return [...current];
+}
+/**
+* Evaluates whether an application capability set grants a specific privilege.
+*/
+function hasAppPrivilege(capabilities, privilege) {
+	if (!capabilities) return true;
+	return capabilities.privileges.includes(privilege);
+}
+/**
+* Resolves why a privilege is withheld: its own reason if it has one, otherwise
+* the reason recorded for the capability set as a whole.
+*
+* @param capabilities - The active capability set, if any.
+* @param privilege - The privilege being explained.
+* @returns The reason, or undefined when none was recorded.
+*/
+function appPrivilegeReason(capabilities, privilege) {
+	if (!capabilities) return void 0;
+	return capabilities.privilegeReasons?.[privilege] ?? capabilities.reason;
+}
+/**
+* Creates the default unconstrained application capabilities (Administrator role).
+*/
+function createDefaultAppCapabilities() {
+	return {
+		role: "administrator",
+		privileges: [...ALL_APP_PRIVILEGES]
+	};
+}
+/**
+* Normalizes an untrusted array of privilege strings.
+*/
+function normalizeAppPrivileges(raw) {
+	if (!Array.isArray(raw)) return void 0;
+	const validSet = new Set(ALL_APP_PRIVILEGES);
+	const result = [];
+	for (const item of raw) if (typeof item === "string" && validSet.has(item)) result.push(item);
+	return result.length > 0 ? [...new Set(result)] : [];
+}
+//#endregion
+//#region src/deployment-capabilities.ts
+/** Every capability, in a stable order for docs and tests. */
+const DEPLOYMENT_CAPABILITIES = [
+	"project:edit",
+	"data:add",
+	"processing:run",
+	"export:data",
+	"plugins:install",
+	"settings:manage"
+];
+/**
+* The default grant: everything. `full` must stay the default so an existing
+* deployment that configures nothing behaves exactly as it did before.
+*/
+const ALL_DEPLOYMENT_CAPABILITIES = new Set(DEPLOYMENT_CAPABILITIES);
+/** Whether an arbitrary string names a capability we know how to enforce. */
+function isDeploymentCapability(value) {
+	return DEPLOYMENT_CAPABILITIES.includes(value);
+}
+/**
+* The reserved token that grants nothing, for a deployment that wants the map
+* and nothing else.
+*
+* Needed because a blank value cannot mean it: the deployment env reader treats
+* an empty string as unset (a `-e VAR=` produces one), and unset has to keep
+* meaning "full" so existing deployments are unchanged. Without a spelling for
+* "none", the most locked-down configuration would be the one you cannot write.
+*/
+const NO_DEPLOYMENT_CAPABILITIES = "none";
+/**
+* Parse a comma-separated capability list from deployment configuration.
+*
+* Unknown tokens are dropped rather than throwing: a newer container image may
+* be configured with a capability this build does not know about, and the safe
+* reading of an unrecognized grant is "not granted".
+*
+* Fails closed on purpose. An operator who set the variable at all meant to
+* restrict something, so a list that parses to nothing grants nothing — only an
+* absent (or blank) value falls back to the full set, which is the caller's job
+* to detect.
+*
+* @param raw - The configured value, e.g. `"data:add, export:data"`.
+* @returns The granted capabilities, with duplicates and unknown names removed.
+*/
+function parseDeploymentCapabilities(raw) {
+	const granted = /* @__PURE__ */ new Set();
+	if (raw.trim().toLowerCase() === "none") return granted;
+	for (const token of raw.split(",")) {
+		const name = token.trim();
+		if (isDeploymentCapability(name)) granted.add(name);
+	}
+	return granted;
+}
+//#endregion
+//#region src/file-name.ts
+/**
+* A bare Android SAF document ID, as the browser `File.name` carries after a
+* native import: a known volume prefix (`primary:`, `home:`, `raw:`, `msf:`, or a
+* removable `XXXX-XXXX:` volume), or any provider prefix followed by a folder
+* separator. Ordinary encoded filenames such as `Report%3AQ1.geojson` do not match.
+*/
+const SAF_DOCUMENT_ID = /^(?:(?:primary|home|raw|msf|[0-9a-f]{4}-[0-9a-f]{4})%3a|[^%/\\:]+%3a.*%2f)/i;
+/** Extract a display filename without changing the source used for file access. */
+function localFileName(path) {
+	const isUri = /^(?:content|file):\/\//i.test(path);
+	const value = isUri ? path.split(/[?#]/)[0] : path;
+	const segment = value.split(/[/\\]/).pop() ?? value;
+	if (!isUri && (!SAF_DOCUMENT_ID.test(segment) || /[/\\]/.test(path))) return segment;
+	let decoded = segment;
+	try {
+		decoded = decodeURIComponent(segment);
+	} catch {
+		return segment;
+	}
+	return decoded.replace(/^[^/\\:]+:/, "").split(/[/\\]/).pop() ?? decoded;
+}
+/**
+* Whether a layer name was derived from its local source filename (with or
+* without the extension) rather than supplied explicitly by a caller.
+*/
+function isSourceDerivedLayerName(name, sourcePath) {
+	const fileName = localFileName(sourcePath);
+	return name === fileName || name === fileName.replace(/\.[^.]+$/, "");
+}
+/** Keep imported layers distinguishable, including within a multi-file import. */
+function uniqueImportedLayerName(name, names) {
+	const existing = new Set(names);
+	let candidate = name;
+	let suffix = 2;
+	while (existing.has(candidate)) candidate = `${name}_${suffix++}`;
+	return candidate;
+}
 //#endregion
 //#region src/history.ts
 /**
@@ -6833,6 +7721,9 @@ function scrubPrintLayoutForRemovedLayers(config, layerIds) {
 //#region src/project.ts
 /** Placeholder name a project carries before the user names it. */
 const DEFAULT_PROJECT_NAME = "Untitled Project";
+function normalizeBlankBackgroundColor(value) {
+	return typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value) ? value : null;
+}
 function createDefaultMapView() {
 	return {
 		center: [-100, 40],
@@ -6849,6 +7740,7 @@ function createEmptyProject(name = DEFAULT_PROJECT_NAME, options = {}) {
 		basemapStyleUrl: options.basemapStyleUrl ?? "https://tiles.openfreemap.org/styles/liberty",
 		basemapVisible: true,
 		basemapOpacity: 1,
+		blankBackgroundColor: null,
 		layers: [],
 		layerGroups: [],
 		styles: {},
@@ -6970,6 +7862,7 @@ function parseProject(json) {
 	const basemapStyleUrl = data.basemapStyleUrl ?? "https://tiles.openfreemap.org/styles/liberty";
 	const basemapVisible = data.basemapVisible ?? true;
 	const basemapOpacity = data.basemapOpacity ?? 1;
+	const blankBackgroundColor = normalizeBlankBackgroundColor(data.blankBackgroundColor);
 	const mapView = normalizeMapViewState(data.mapView);
 	const { mapLayout, secondaryMapViews } = resolveMapGrid(normalizeMapLayout(data.mapLayout), normalizeSecondaryMapViews(data.secondaryMapViews), { mapView });
 	const styleLibrary = normalizeStyleLibraryEntries(data.styleLibrary);
@@ -6981,6 +7874,7 @@ function parseProject(json) {
 		basemapStyleUrl,
 		basemapVisible,
 		basemapOpacity,
+		blankBackgroundColor,
 		layers,
 		...selectedLayerId !== void 0 ? { selectedLayerId } : {},
 		...layerGroups.length > 0 ? { layerGroups } : {},
@@ -6999,6 +7893,7 @@ function parseProject(json) {
 			secondaryMapViews,
 			...normalizeString(data.primaryMapLabel) ? { primaryMapLabel: normalizeString(data.primaryMapLabel) } : {}
 		} : {},
+		...normalizePrimaryRenderer(data.primaryRenderer) ? { primaryRenderer: "cesium" } : {},
 		...styleLibrary.length > 0 ? { styleLibrary } : {},
 		...parsedComments.length > 0 ? { comments: parsedComments } : {},
 		metadata: data.metadata ?? {}
@@ -7464,6 +8359,18 @@ function normalizeMapLayout(value) {
 	};
 }
 /**
+* Coerce an untrusted `primaryRenderer` into a known engine id (issue #2217).
+*
+* Returns null for the default 2D map — absent, unknown, or an explicit
+* `"maplibre"` — because the field is only written when it is not the default,
+* so a MapLibre project serializes byte-identically to before this existed.
+* The return type is narrowed to `"cesium" | null` rather than the full
+* {@link MapRendererKind} for that reason: `"maplibre"` is never a result.
+*/
+function normalizePrimaryRenderer(value) {
+	return value === "cesium" ? "cesium" : null;
+}
+/**
 * Coerce an untrusted `secondaryMapViews` array into valid
 * {@link SecondaryMapView} records, dropping entries without a usable id and
 * de-duplicating by id. Returns null when none are valid.
@@ -7665,6 +8572,8 @@ function normalizeProjectPreferences(preferences) {
 			ellipsoidId: getEllipsoid(map.ellipsoidId).id,
 			scaleUnit: normalizeScaleUnit(map.scaleUnit),
 			showPointerElevation: normalizeBoolean(map.showPointerElevation, DEFAULT_PROJECT_PREFERENCES.map.showPointerElevation),
+			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
 		},
 		environmentVariables: Array.isArray(candidate.environmentVariables) ? candidate.environmentVariables.map(normalizeEnvironmentVariable).filter((variable) => Boolean(variable)) : [],
@@ -7801,8 +8710,9 @@ function isPlainObject$2(value) {
 	return prototype === Object.prototype || prototype === null;
 }
 function normalizeLayer(layer) {
-	const { capabilities: rawCapabilities, ...rest } = layer;
+	const { capabilities: rawCapabilities, filterExpression: rawFilterExpression, ...rest } = layer;
 	const capabilities = normalizeLayerCapabilities(rawCapabilities);
+	const filterExpression = Array.isArray(rawFilterExpression) && rawFilterExpression.length > 0 && validateMapExpression(JSON.stringify(rawFilterExpression), { expectedType: "boolean" }).ok ? rawFilterExpression : void 0;
 	return {
 		...rest,
 		style: {
@@ -7813,7 +8723,8 @@ function normalizeLayer(layer) {
 		opacity: layer.opacity ?? 1,
 		metadata: layer.metadata ?? {},
 		source: layer.source ?? {},
-		...capabilities ? { capabilities } : {}
+		...capabilities ? { capabilities } : {},
+		...filterExpression ? { filterExpression } : {}
 	};
 }
 function normalizeProjectComments(rawComments) {
@@ -7897,6 +8808,7 @@ function projectFromStore(state) {
 		basemapStyleUrl: state.basemapStyleUrl,
 		basemapVisible: state.basemapVisible,
 		basemapOpacity: state.basemapOpacity,
+		...state.blankBackgroundColor ? { blankBackgroundColor: state.blankBackgroundColor } : {},
 		layers: state.layers.map(prepareLayerForSave),
 		...selectedLayerId !== void 0 ? { selectedLayerId } : {},
 		...layerGroups.length > 0 ? { layerGroups } : {},
@@ -7915,6 +8827,7 @@ function projectFromStore(state) {
 			secondaryMapViews,
 			...normalizeString(state.primaryMapLabel) ? { primaryMapLabel: normalizeString(state.primaryMapLabel) } : {}
 		} : {},
+		...normalizePrimaryRenderer(state.primaryRenderer) ? { primaryRenderer: "cesium" } : {},
 		...styleLibrary.length > 0 ? { styleLibrary } : {},
 		...comments.length > 0 ? { comments } : {},
 		metadata: state.metadata
@@ -7926,6 +8839,13 @@ function hasRestorableSourceUrl(layer) {
 	return typeof sourceUrl === "string" && sourceUrl.trim() !== "" || typeof originalUrl === "string" && originalUrl.trim() !== "";
 }
 function prepareLayerForSave(layer) {
+	if (layer.metadata.geometryEdited !== void 0) {
+		const { geometryEdited: _geometryEdited, ...metadata } = layer.metadata;
+		layer = {
+			...layer,
+			metadata
+		};
+	}
 	if (layer.timeFilter !== void 0) {
 		const { timeFilter: _timeFilter, ...rest } = layer;
 		layer = rest;
@@ -7943,6 +8863,18 @@ function prepareLayerForSave(layer) {
 		const { geojson: _geojson, ...rest } = layer;
 		layer = rest;
 	}
+	if (layer.type === "wms") {
+		const tiles = layer.source.tiles;
+		if (!Array.isArray(tiles)) return layer;
+		const portableTiles = tiles.map((tile) => portableWmsTileUrl(tile));
+		return portableTiles.some((tile, index) => tile !== tiles[index]) ? {
+			...layer,
+			source: {
+				...layer.source,
+				tiles: portableTiles
+			}
+		} : layer;
+	}
 	if (layer.type !== "xyz") return layer;
 	const originalUrl = typeof layer.metadata.originalUrl === "string" && layer.metadata.originalUrl.trim() ? layer.metadata.originalUrl : typeof layer.source.url === "string" && layer.source.url.trim() ? layer.source.url : null;
 	if (!originalUrl) return layer;
@@ -7958,11 +8890,23 @@ function prepareLayerForSave(layer) {
 		metadata
 	};
 }
+function portableWmsTileUrl(tile) {
+	if (typeof tile !== "string" || !tile.startsWith("geolibre-wms://")) return tile;
+	try {
+		const url = new URL(tile).searchParams.get("url");
+		if (!url) return tile;
+		const parsed = new URL(url);
+		return parsed.protocol === "http:" || parsed.protocol === "https:" ? url : tile;
+	} catch {
+		return tile;
+	}
+}
 function applyProjectToStore(project) {
 	const layers = project.layers.map((layer) => ({
 		...layer,
 		style: project.styles[layer.id] ? {
 			...DEFAULT_LAYER_STYLE,
+			...layer.style,
 			...project.styles[layer.id]
 		} : {
 			...DEFAULT_LAYER_STYLE,
@@ -7978,6 +8922,7 @@ function applyProjectToStore(project) {
 	const basemapStyleUrl = project.basemapStyleUrl;
 	const basemapVisible = project.basemapVisible ?? true;
 	const basemapOpacity = project.basemapOpacity ?? 1;
+	const blankBackgroundColor = normalizeBlankBackgroundColor(project.blankBackgroundColor);
 	const mapView = normalizeMapViewState(project.mapView);
 	const { mapLayout, secondaryMapViews } = resolveMapGrid(normalizeMapLayout(project.mapLayout), normalizeSecondaryMapViews(project.secondaryMapViews), { mapView });
 	const existingLayerIds = new Set(normalizedLayers.map((l) => l.id));
@@ -8006,6 +8951,7 @@ function applyProjectToStore(project) {
 		basemapStyleUrl,
 		basemapVisible,
 		basemapOpacity,
+		blankBackgroundColor,
 		layers: normalizedLayers,
 		layerGroups,
 		preferences: normalizeProjectPreferences(project.preferences),
@@ -8020,6 +8966,7 @@ function applyProjectToStore(project) {
 		mapLayout,
 		secondaryMapViews,
 		primaryMapLabel: normalizeString(project.primaryMapLabel),
+		primaryRenderer: normalizePrimaryRenderer(project.primaryRenderer) ?? "maplibre",
 		projectStyleLibrary: normalizeStyleLibraryEntries(project.styleLibrary),
 		comments: scrubbedComments,
 		metadata: project.metadata
@@ -8364,6 +9311,313 @@ function rescaleEntryCount(state) {
 	return 1;
 }
 //#endregion
+//#region src/czml.ts
+/**
+* CZML (Cesium Language) domain models and layer authoring (issue #2290).
+*
+* CZML is a JSON-based format for describing dynamic, time-varying 3D geospatial
+* scenes on the Cesium globe (trajectories, satellites, vehicles, sensor
+* networks, moving entities with orientations and paths). The globe loads CZML
+* natively through `CzmlDataSource`; the 2D map has no equivalent, so CZML
+* layers are badged "3D only" there.
+*/
+/** `metadata.sourceKind` of a layer that carries or references CZML data. */
+const CZML_SOURCE_KIND = "czml";
+/** One-click CZML samples offered in the Add Data dialog. */
+const CZML_QUICK_PICKS = [{
+	name: "CZML Point",
+	data: [{
+		id: "document",
+		name: "CZML Point Sample",
+		version: "1.0"
+	}, {
+		id: "point 1",
+		name: "Extruded Point",
+		position: { cartographicDegrees: [
+			-75.59777,
+			40.03883,
+			1e3
+		] },
+		point: {
+			color: { rgba: [
+				255,
+				128,
+				0,
+				255
+			] },
+			pixelSize: 14,
+			outlineColor: { rgba: [
+				255,
+				255,
+				255,
+				255
+			] },
+			outlineWidth: 2
+		}
+	}]
+}, {
+	name: "CZML Dynamic Trajectory",
+	data: [{
+		id: "document",
+		name: "CZML Trajectory Sample",
+		version: "1.0",
+		clock: {
+			interval: "2026-09-09T00:00:00Z/2026-09-09T02:00:00Z",
+			currentTime: "2026-09-09T00:00:00Z",
+			multiplier: 60,
+			range: "LOOP_STOP"
+		}
+	}, {
+		id: "satellite",
+		name: "Satellite Track",
+		availability: "2026-09-09T00:00:00Z/2026-09-09T02:00:00Z",
+		path: {
+			material: { solidColor: { color: { rgba: [
+				0,
+				200,
+				255,
+				255
+			] } } },
+			width: 2,
+			leadTime: 1800,
+			trailTime: 1800
+		},
+		position: {
+			epoch: "2026-09-09T00:00:00Z",
+			cartographicDegrees: [
+				0,
+				-75,
+				40,
+				25e4,
+				1800,
+				-30,
+				20,
+				25e4,
+				3600,
+				20,
+				0,
+				25e4,
+				5400,
+				70,
+				-20,
+				25e4,
+				7200,
+				120,
+				-40,
+				25e4
+			]
+		},
+		point: {
+			color: { rgba: [
+				255,
+				255,
+				255,
+				255
+			] },
+			pixelSize: 10
+		}
+	}]
+}];
+/**
+* Parse and validate a CZML payload from a JSON string or raw object.
+* Returns an array of CZML packets or null when the input is malformed.
+*/
+function parseCzml(value) {
+	if (!value) return null;
+	let parsed = value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) return null;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			return null;
+		}
+	}
+	if (Array.isArray(parsed)) return parsed.length > 0 && parsed.every((item) => item && typeof item === "object") ? parsed : null;
+	if (parsed && typeof parsed === "object") return [parsed];
+	return null;
+}
+/**
+* Whether `layer` represents a CZML dynamic 3D scene.
+*/
+function isCzmlLayer(layer) {
+	return layer.metadata?.sourceKind === CZML_SOURCE_KIND;
+}
+/**
+* Extract the CZML content and/or URL from a layer, or null if not a CZML layer.
+*/
+function czmlSource(layer) {
+	if (!isCzmlLayer(layer)) return null;
+	const raw = layer.source?.czmlData;
+	const data = Array.isArray(raw) ? raw.length > 0 ? raw : void 0 : raw && typeof raw === "object" ? [raw] : raw || void 0;
+	const rawUrl = layer.source?.url;
+	const url = typeof rawUrl === "string" && rawUrl.trim() ? rawUrl.trim() : void 0;
+	if (!data && !url) return null;
+	return {
+		url,
+		data
+	};
+}
+/** Generate a unique identifier for a newly created layer. */
+function newLayerId$1() {
+	return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+/**
+* Build a typed GeoLibreLayer representing a CZML dynamic scene on the Cesium globe.
+*/
+function createCzmlLayer(options) {
+	const id = options.id ?? newLayerId$1();
+	const data = options.data;
+	const url = options.url?.trim() || void 0;
+	const sourcePath = options.sourcePath?.trim() || void 0;
+	return {
+		id,
+		name: options.name,
+		type: "3d-tiles",
+		...sourcePath ? { sourcePath } : {},
+		source: {
+			type: "3d-tiles",
+			sourceId: id,
+			...data !== void 0 ? { czmlData: data } : {},
+			...url ? { url } : {},
+			...sourcePath ? { sourcePath } : {}
+		},
+		visible: true,
+		opacity: 1,
+		style: { ...DEFAULT_LAYER_STYLE },
+		metadata: {
+			sourceKind: CZML_SOURCE_KIND,
+			externalNativeLayer: true,
+			identifiable: false,
+			sourceId: id,
+			nativeLayerIds: [id]
+		}
+	};
+}
+//#endregion
+//#region src/cesium-kml.ts
+/** Native KML/KMZ documents retain their own styling on the globe. */
+const CESIUM_KML_SOURCE_KIND = "cesium-kml";
+function isCesiumKmlLayer(layer) {
+	return layer.metadata?.sourceKind === CESIUM_KML_SOURCE_KIND;
+}
+function cesiumKmlSource(layer) {
+	if (!isCesiumKmlLayer(layer)) return null;
+	for (const value of [layer.source.kmlData, layer.source.url]) if (typeof value === "string" && value.trim()) return value.trim();
+	return null;
+}
+function createCesiumKmlLayer(options) {
+	const data = options.data?.trim();
+	const url = options.url?.trim();
+	if (!data && !url) throw new Error("Provide a KML/KMZ document or URL.");
+	const id = options.id ?? crypto.randomUUID();
+	return {
+		id,
+		name: options.name,
+		type: "3d-tiles",
+		...options.sourcePath ? { sourcePath: options.sourcePath } : {},
+		source: {
+			type: "3d-tiles",
+			sourceId: id,
+			...data ? { kmlData: data } : { url }
+		},
+		visible: true,
+		opacity: 1,
+		style: { ...DEFAULT_LAYER_STYLE },
+		metadata: {
+			sourceKind: CESIUM_KML_SOURCE_KIND,
+			externalNativeLayer: true,
+			identifiable: false
+		}
+	};
+}
+//#endregion
+//#region src/cesium-ion.ts
+/** `metadata.sourceKind` of a layer that references a Cesium Ion asset. */
+const CESIUM_ION_SOURCE_KIND = "cesium-ion";
+/** Cesium OSM Buildings, the one-click 3D Tiles asset every Ion account can use. */
+const CESIUM_OSM_BUILDINGS_ASSET_ID = 96188;
+/** Bing Maps Aerial through Ion, the imagery asset every Ion account can use. */
+const CESIUM_BING_AERIAL_ASSET_ID = 2;
+/** Ion assets offered as one-click picks in the Add Data dialog. */
+const CESIUM_ION_QUICK_PICKS = [{
+	assetId: CESIUM_OSM_BUILDINGS_ASSET_ID,
+	kind: "3d-tiles",
+	name: "Cesium OSM Buildings"
+}, {
+	assetId: 2,
+	kind: "imagery",
+	name: "Bing Maps Aerial (Ion)"
+}];
+/** Parse an Ion asset id the way the Add Data form and the project file carry it. */
+function parseCesiumIonAssetId(value) {
+	const id = typeof value === "string" ? Number(value.trim()) : value;
+	return typeof id === "number" && Number.isInteger(id) && id > 0 ? id : null;
+}
+/**
+* The Ion asset id a layer references, or null when the layer is not an Ion
+* asset layer (or carries no usable id).
+*/
+function cesiumIonAssetId(layer) {
+	if (layer.metadata?.sourceKind !== "cesium-ion") return null;
+	return parseCesiumIonAssetId(layer.source?.ionAssetId);
+}
+/** Whether `layer` references a Cesium Ion asset. */
+function isCesiumIonLayer(layer) {
+	return cesiumIonAssetId(layer) !== null;
+}
+/** What the Ion asset draws as: a tileset primitive or an imagery layer. */
+function cesiumIonAssetKind(layer) {
+	return layer.type === "3d-tiles" ? "3d-tiles" : "imagery";
+}
+/**
+* Whether only the 3D globe can render `layer`: the mirror of the globe's
+* `isCesiumSupportedLayerType`, for the Layers panel to badge on the 2D map.
+*/
+function isCesiumOnlyLayer(layer) {
+	return isCesiumIonLayer(layer) || isCzmlLayer(layer) || isCesiumKmlLayer(layer);
+}
+function newLayerId() {
+	return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+/**
+* Build the store layer for a Cesium Ion asset. A tileset is a `3d-tiles`
+* layer whose `sourceKind` keeps it out of the 2D deck.gl control; imagery is
+* a `raster` layer with no tiles, marked external so the 2D sync leaves it
+* alone. Both persist only the asset id: the token is runtime configuration.
+*/
+function createCesiumIonLayer(options) {
+	const id = options.id ?? newLayerId();
+	const isTileset = options.kind === "3d-tiles";
+	const altitudeOffset = Number.isFinite(options.altitudeOffset) ? options.altitudeOffset : 0;
+	return {
+		id,
+		name: options.name,
+		type: isTileset ? "3d-tiles" : "raster",
+		source: {
+			type: isTileset ? "3d-tiles" : "raster",
+			ionAssetId: options.assetId,
+			sourceId: id,
+			...isTileset ? { altitudeOffset } : {}
+		},
+		visible: true,
+		opacity: 1,
+		style: { ...DEFAULT_LAYER_STYLE },
+		metadata: {
+			sourceKind: CESIUM_ION_SOURCE_KIND,
+			externalNativeLayer: true,
+			identifiable: false,
+			sourceId: id,
+			nativeLayerIds: [id],
+			...isTileset ? {
+				customLayerType: "3d-tiles",
+				altitudeOffset
+			} : {}
+		}
+	};
+}
+//#endregion
 //#region src/credentials.ts
 /**
 * Project fields whose values are credentials. Keep this registry as the
@@ -8414,7 +9668,8 @@ const PROJECT_CREDENTIAL_FIELDS = {
 */
 const PUBLISHABLE_PLUGIN_SETTINGS = {
 	"maplibre-gl-swipe": null,
-	"maplibre-gl-components": ["legend", "colorbar"]
+	"maplibre-gl-components": ["legend", "colorbar"],
+	"maplibre-gl-time-slider": null
 };
 /**
 * Hash a credential value to a short, stable 64-bit token: two independent
@@ -8709,8 +9964,9 @@ const MAX_LAYER_LIBRARY_ENTRIES = 500;
 * Metadata keys dropped when capturing an entry. `resolvedUrl` is the dev-server
 * proxy rewrite of an XYZ template — a per-session artifact that must not be
 * baked into a saved source (the same reason `prepareLayerForSave` strips it).
+* `geometryEdited` tracks changes to the live layer, not a library source.
 */
-const TRANSIENT_METADATA_KEYS = ["resolvedUrl"];
+const TRANSIENT_METADATA_KEYS = ["resolvedUrl", "geometryEdited"];
 function nonEmptyString(value) {
 	return typeof value === "string" && value.trim() !== "";
 }
@@ -8729,6 +9985,7 @@ function hasRestorableLayerSource(layer) {
 	if (nonEmptyString(source.url)) return true;
 	if (nonEmptyString(source.data)) return true;
 	if (Array.isArray(source.tiles) && source.tiles.some(nonEmptyString)) return true;
+	if (cesiumIonAssetId(layer) !== null) return true;
 	return nonEmptyString((layer.metadata ?? {}).originalUrl);
 }
 /**
@@ -9333,6 +10590,8 @@ function createLayerLibraryEntryId() {
 }
 //#endregion
 //#region src/store.ts
+/** Reserved Identify target for querying every visible queryable layer at once. */
+const IDENTIFY_ALL_LAYERS_ID = "__geolibre_identify_all_layers__";
 const MAX_RECENT_PROJECTS = 10;
 /**
 * A fresh, inactive collaboration slice (no live session). Frozen (like
@@ -9571,6 +10830,7 @@ const useAppStore = create()(temporal((set, get) => ({
 	basemapStyleUrl: DEFAULT_BASEMAP,
 	basemapVisible: true,
 	basemapOpacity: 1,
+	blankBackgroundColor: null,
 	layers: [],
 	layerGroups: [],
 	preferences: DEFAULT_PROJECT_PREFERENCES,
@@ -9589,6 +10849,7 @@ const useAppStore = create()(temporal((set, get) => ({
 	mapLayout: { ...DEFAULT_MAP_GRID_LAYOUT },
 	secondaryMapViews: [],
 	primaryMapLabel: "",
+	primaryRenderer: DEFAULT_PRIMARY_RENDERER,
 	copiedLayerStyle: null,
 	selectedLayerId: null,
 	selectedFeatureId: null,
@@ -9602,7 +10863,9 @@ const useAppStore = create()(temporal((set, get) => ({
 	metadata: {},
 	recentProjects: [],
 	attributeFilter: "",
+	deploymentCapabilities: ALL_DEPLOYMENT_CAPABILITIES,
 	collaboration: DEFAULT_COLLABORATION_STATE,
+	capabilities: createDefaultAppCapabilities(),
 	ui: {
 		processingOpen: false,
 		processingInitialTool: null,
@@ -9627,6 +10890,7 @@ const useAppStore = create()(temporal((set, get) => ({
 		storymapPanelOpen: false,
 		storymapPresenting: false,
 		storymapReturnToEditor: false,
+		storymapLayerOpacity: {},
 		storymapComposingId: null,
 		batchToolsOpen: false,
 		modelBuilderOpen: false,
@@ -9799,6 +11063,10 @@ const useAppStore = create()(temporal((set, get) => ({
 		primaryMapLabel: label,
 		isDirty: true
 	}),
+	setPrimaryRenderer: (renderer) => set((s) => s.primaryRenderer === renderer ? s : {
+		primaryRenderer: renderer,
+		isDirty: true
+	}),
 	setSecondaryMapLabel: (id, label) => set((s) => {
 		let changed = false;
 		const secondaryMapViews = s.secondaryMapViews.map((pane) => {
@@ -9880,6 +11148,10 @@ const useAppStore = create()(temporal((set, get) => ({
 		basemapOpacity: opacity,
 		isDirty: true
 	}),
+	setBlankBackgroundColor: (color) => set({
+		blankBackgroundColor: normalizeBlankBackgroundColor(color),
+		isDirty: true
+	}),
 	setPreferences: (preferences) => set({
 		preferences,
 		isDirty: true
@@ -9996,8 +11268,23 @@ const useAppStore = create()(temporal((set, get) => ({
 	setStorymapPresenting: (presenting, returnToEditor = false) => set((s) => ({ ui: {
 		...s.ui,
 		storymapPresenting: presenting,
-		storymapReturnToEditor: presenting ? returnToEditor : false
+		storymapReturnToEditor: presenting ? returnToEditor : false,
+		storymapLayerOpacity: {}
 	} })),
+	setStorymapLayerOpacity: (changes) => set((s) => {
+		const next = { ...s.ui.storymapLayerOpacity };
+		let changed = false;
+		for (const [layerId, opacity] of Object.entries(changes)) {
+			const clamped = Math.min(1, Math.max(0, opacity));
+			if (next[layerId] === clamped) continue;
+			next[layerId] = clamped;
+			changed = true;
+		}
+		return changed ? { ui: {
+			...s.ui,
+			storymapLayerOpacity: next
+		} } : s;
+	}),
 	setStorymapComposing: (chapterId) => set((s) => ({ ui: {
 		...s.ui,
 		storymapComposingId: chapterId
@@ -10229,6 +11516,7 @@ const useAppStore = create()(temporal((set, get) => ({
 		projectName: name,
 		isDirty: true
 	}),
+	setDeploymentCapabilities: (capabilities) => set({ deploymentCapabilities: new Set(capabilities) }),
 	setRecentProjects: (projects) => set({ recentProjects: normalizeRecentProjects(projects) }),
 	rememberRecentProject: (entry) => set((s) => ({ recentProjects: normalizeRecentProjects([entry, ...s.recentProjects]) })),
 	forgetRecentProject: (path) => {
@@ -10239,6 +11527,11 @@ const useAppStore = create()(temporal((set, get) => ({
 	markSaved: () => set({ isDirty: false }),
 	addLayer: (layer, beforeLayerId = null) => set((s) => {
 		const layers = [...s.layers];
+		const { sourcePath } = layer;
+		if (sourcePath && (!/^[a-z][a-z0-9+.-]*:\/\//i.test(sourcePath) || /^(content|file):\/\//i.test(sourcePath)) && isSourceDerivedLayerName(layer.name, sourcePath)) layer = {
+			...layer,
+			name: uniqueImportedLayerName(layer.name, layers.map((item) => item.name))
+		};
 		const beforeIndex = beforeLayerId ? layers.findIndex((l) => l.id === beforeLayerId) : -1;
 		const layerWithBeforeId = beforeLayerId && beforeIndex < 0 ? {
 			...layer,
@@ -10309,6 +11602,7 @@ const useAppStore = create()(temporal((set, get) => ({
 		};
 	}),
 	setLayerQuickFilters: (id, filters) => get().updateLayer(id, { quickFilters: filters.length > 0 ? filters : void 0 }),
+	setLayerFilterExpression: (id, expression) => get().updateLayer(id, { filterExpression: expression ?? void 0 }),
 	setLayerVisibility: (id, visible) => get().updateLayer(id, { visible }),
 	setLayerOpacity: (id, opacity) => get().updateLayer(id, { opacity }),
 	setLayerStyle: (id, style) => set((s) => ({
@@ -10641,6 +11935,7 @@ const useAppStore = create()(temporal((set, get) => ({
 				...s.ui,
 				storymapPresenting: false,
 				storymapReturnToEditor: false,
+				storymapLayerOpacity: {},
 				storymapPanelOpen: false,
 				storymapComposingId: null,
 				selectByExpressionOpen: false,
@@ -10676,6 +11971,7 @@ const useAppStore = create()(temporal((set, get) => ({
 				...s.ui,
 				storymapPresenting: presentStory,
 				storymapReturnToEditor: false,
+				storymapLayerOpacity: {},
 				storymapPanelOpen: false,
 				storymapComposingId: null,
 				selectByExpressionOpen: false,
@@ -10693,6 +11989,51 @@ const useAppStore = create()(temporal((set, get) => ({
 			name: project.name,
 			openedAt: (/* @__PURE__ */ new Date()).toISOString()
 		});
+	},
+	setAppRole: (role, options) => {
+		set({ capabilities: {
+			role,
+			privileges: resolveRolePrivileges(role, options?.customPrivileges),
+			reason: options?.reason
+		} });
+	},
+	setAppPrivileges: (privileges, reason) => {
+		set({ capabilities: {
+			role: "custom",
+			privileges: normalizeAppPrivileges(privileges) ?? [],
+			reason
+		} });
+	},
+	grantAppPrivilege: (privilege) => {
+		const current = get().capabilities;
+		if (current.privileges.includes(privilege)) return;
+		const { [privilege]: _granted, ...privilegeReasons } = current.privilegeReasons ?? {};
+		set({ capabilities: {
+			...current,
+			role: "custom",
+			privileges: [...current.privileges, privilege],
+			privilegeReasons
+		} });
+	},
+	revokeAppPrivilege: (privilege, reason) => {
+		const current = get().capabilities;
+		const held = current.privileges.includes(privilege);
+		if (!held && !reason) return;
+		set({ capabilities: {
+			...current,
+			role: held ? "custom" : current.role,
+			privileges: held ? current.privileges.filter((p) => p !== privilege) : current.privileges,
+			privilegeReasons: reason ? {
+				...current.privilegeReasons,
+				[privilege]: reason
+			} : current.privilegeReasons
+		} });
+	},
+	resetAppCapabilities: () => {
+		set({ capabilities: createDefaultAppCapabilities() });
+	},
+	hasAppPrivilege: (privilege) => {
+		return hasAppPrivilege(get().capabilities, privilege);
 	}
 }), {
 	partialize: (s) => ({
@@ -10701,10 +12042,11 @@ const useAppStore = create()(temporal((set, get) => ({
 		basemapStyleUrl: s.basemapStyleUrl,
 		basemapVisible: s.basemapVisible,
 		basemapOpacity: s.basemapOpacity,
+		blankBackgroundColor: s.blankBackgroundColor,
 		storymap: s.storymap,
 		comments: s.comments
 	}),
-	equality: (a, b) => a.basemapStyleUrl === b.basemapStyleUrl && a.basemapVisible === b.basemapVisible && a.basemapOpacity === b.basemapOpacity && a.storymap === b.storymap && shallow(a.layers, b.layers) && shallow(a.comments, b.comments) && layerGroupsEqualForHistory(a.layerGroups, b.layerGroups),
+	equality: (a, b) => a.basemapStyleUrl === b.basemapStyleUrl && a.basemapVisible === b.basemapVisible && a.basemapOpacity === b.basemapOpacity && a.blankBackgroundColor === b.blankBackgroundColor && a.storymap === b.storymap && shallow(a.layers, b.layers) && shallow(a.comments, b.comments) && layerGroupsEqualForHistory(a.layerGroups, b.layerGroups),
 	limit: 100,
 	handleSet: (baseHandleSet) => {
 		const debounced = leadingDebounce(baseHandleSet, getHistoryCoalesceMs);
@@ -10829,6 +12171,19 @@ function clearHistory() {
 		notifyProjectRestoreHistory();
 	}
 }
+/**
+* React hook for consuming application capability state for a specific privilege.
+*
+* @param privilege - The privilege to check.
+* @returns `{ granted: boolean, reason?: string }`
+*/
+function useAppCapability(privilege) {
+	const capabilities = useAppStore((state) => state.capabilities);
+	return {
+		granted: capabilities.privileges.includes(privilege),
+		reason: appPrivilegeReason(capabilities, privilege)
+	};
+}
 //#endregion
 //#region src/selection-actions.ts
 /**
@@ -11154,6 +12509,23 @@ function formatCameraAltitude(meters, unit) {
 	})} ${label}`;
 }
 //#endregion
+//#region src/pixel-format.ts
+/**
+* Trim a float sample to something readable. A 32-bit raster value decoded to a
+* JS double prints all 17 digits of its binary representation
+* (`48.11851119995117`), which is noise past the sensor's precision — six
+* significant digits is more than any COG carries. Integers are left alone so a
+* classification code is never shown in exponential form.
+*
+* @param value A decoded raster sample.
+* @returns The sample rendered for display.
+*/
+function formatPixelValue(value) {
+	if (!Number.isFinite(value)) return String(value);
+	if (Number.isInteger(value)) return String(value);
+	return String(Number(value.toPrecision(6)));
+}
+//#endregion
 //#region src/storymap-sample.ts
 const SAMPLE_ASSET_BASE = "https://opengeos.org/maplibre-gl-storymaps/assets";
 /**
@@ -11274,6 +12646,72 @@ function createSampleStoryMap() {
 	};
 }
 //#endregion
+//#region src/storymap-playback.ts
+/** The clamped opacity recorded for a layer, or undefined when untouched. */
+function recordedStoryOpacity(opacities, layerId) {
+	const value = opacities?.[layerId];
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	return Math.min(1, Math.max(0, value));
+}
+/**
+* The opacity a story presentation has applied to a layer.
+*
+* @param opacities The store's `ui.storymapLayerOpacity` record.
+* @param layerId Store layer id.
+* @returns The recorded opacity in `[0, 1]`, or `1` when the presentation has
+*   not touched the layer (or nothing is presenting).
+*/
+function storyLayerOpacityFactor(opacities, layerId) {
+	return recordedStoryOpacity(opacities, layerId) ?? 1;
+}
+/**
+* A layer whose opacity reflects the story presentation's fade.
+*
+* A chapter's opacity *replaces* the layer's own opacity rather than scaling
+* it, matching `MapController.setStoryLayerOpacity`, which writes the chapter
+* value as the absolute paint opacity; otherwise a layer set to 0.7 in the
+* Layers panel and faded to 0.4 by a chapter would draw its diagrams at 0.28
+* while its MapLibre layers draw at 0.4.
+*
+* Returns the same object when the presentation has not touched the layer (or
+* recorded the opacity it already has), so identity-keyed caches downstream
+* keep hitting.
+*
+* @param layer Store layer.
+* @param opacities The store's `ui.storymapLayerOpacity` record.
+*/
+function applyStoryLayerOpacity(layer, opacities) {
+	const opacity = recordedStoryOpacity(opacities, layer.id);
+	if (opacity === void 0 || opacity === layer.opacity) return layer;
+	return {
+		...layer,
+		opacity
+	};
+}
+/**
+* Whether a story presentation has faded a layer fully out.
+*
+* @param opacities The store's `ui.storymapLayerOpacity` record.
+* @param layerId Store layer id.
+*/
+function isStoryHiddenLayer(opacities, layerId) {
+	return storyLayerOpacityFactor(opacities, layerId) === 0;
+}
+/**
+* The layers a reader can currently see during a story presentation: the
+* input minus those the active chapter has faded fully out. Outside a
+* presentation the input is returned as-is (same array identity).
+*
+* @param layers Store layers in panel order.
+* @param presenting The store's `ui.storymapPresenting` flag.
+* @param opacities The store's `ui.storymapLayerOpacity` record.
+*/
+function storyVisibleLayers(layers, presenting, opacities) {
+	if (!presenting) return layers;
+	if (!layers.some((layer) => isStoryHiddenLayer(opacities, layer.id))) return layers;
+	return layers.filter((layer) => !isStoryHiddenLayer(opacities, layer.id));
+}
+//#endregion
 //#region src/storymap-io.ts
 /**
 * Serialize a story map to pretty-printed JSON for export.
@@ -12631,6 +14069,6 @@ function currentEditorIdentity() {
 	return pickEditorIdentity(isActive ? selfName : void 0, readStoredAuthorName());
 }
 //#endregion
-export { BLANK_BASEMAP, BLEND_MODES, BUILT_IN_STYLE_PRESETS, CARTOCIUDAD_MIN_INTERVAL_MS, CARTOCIUDAD_PUBLIC_HOST, CHINA_BASEMAPS, 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_PRINT_LAYOUT, DEFAULT_PROJECT_NAME, DEFAULT_PROJECT_PREFERENCES, DEFAULT_REVERSE_GEOCODE_ENDPOINT, DEFAULT_ROUTING_ENDPOINT, DEFAULT_STORY_MAP, 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, LARGE_VECTOR_FEATURE_THRESHOLD, LAYER_LIBRARY_BUNDLE_TYPE, LAYER_LIBRARY_BUNDLE_VERSION, LAYER_PALETTE, 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, 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, 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, RoutingRequestError, SELECTION_MODES, SQL_QUERY_SOURCE_KIND, STYLE_LIBRARY_BUNDLE_TYPE, STYLE_LIBRARY_BUNDLE_VERSION, SYMBOL_STYLE_KEYS, VECTOR_COLOR_RAMPS, activeQuickFilters, applyCopiedLayerStyle, applyGroupEffects, applyJoinsToLayer, applyLayerJoins, applyLayerVirtualFields, applyMatchedSelection, applyProjectToStore, applySelectionMode, attributeFormFieldLabel, attributeLinkUrl, batchDecodePolylines, bodyLengthToEarth, buildForwardGeocodeUrl, buildIsochroneRequest, buildLayerPanelUnits, buildLayerTree, buildMatrixRequest, buildReverseGeocodeUrl, buildRouteRequest, canRedoProjectRestore, canSaveLayerToLibrary, canUndoProjectRestore, captureLayerLibraryEntry, cascadeLayerJoinRefresh, circleRadiusValue, clearExternalNativePaintBridge, clearHistory, clearQuickFilterValues, coerceAttributeFormValue, collectDiagramData, collectTransitiveJoinSourceIds, compareSequenceValues, compileFeatureExpression, compileQuickFilter, compileQuickFilters, controlRendersLayer, copyableLayerStyleKind, createDefaultMapView, createDefaultPrintLayout, createEmptyProject, createEqualIntervalBreaks, createGraduatedClassBreaks, createLayerLibraryEntryId, createPointerElevationResolver, createProjectTemplate, createQuantileBreaks, createSampleStoryMap, createStyleLibraryEntryId, csvRowsToGeocodeRequests, currentEditorIdentity, darkenHex, decodePolyline, decodePolylineDetailed, detachProjectCopy, detectNonGeographicCoordinates, diagramAnchor, diagramPixelSize, diagramsSuppressedByPointRenderer, dominantGeometry, drawMarkerPath, earthAreaToBody, earthLengthToBody, editorTrackingFieldNames, effectiveLayerRenderState, effectiveVectorRules, encodePolyline, ensureEditorTrackingFields, evaluateMapExpression, excludeHiddenFieldsFromGeojson, excludeHiddenFieldsFromProject, extractCopiedLayerStyle, extractStyleLibraryStyle, extrusionColorValue, extrusionHeightValue, featureSelectionId, fetchElevations, formatCameraAltitude, formatExpressionPreviewValue, formatPopupValue, formatRoundNum, generatorCircleRadiusValue, generatorSizeRange, geoJSONToPolylineStr, geocodeForward, geocodeMatchToFeature, geocodeReverse, geocoderMinIntervalMs, geocoderNeedsApiKey, geojsonHasZCoordinates, getActiveBodyRadiusRatio, getActiveEllipsoid, getActiveMeanRadiusMeters, getActiveSemiMajorAxisMeters, getAttributeFormField, getBuildEnvironment, getCesiumIonToken, getEllipsoid, getExternalNativePaintBridge, getGeocoderConfig, getGeocodingProvider, getGoogleMapsApiKey, getHistoryCoalesceMs, getMapboxAccessToken, getMaxHistoryFeatureCount, getPlanetaryBasemapById, getPlanetaryBasemapByStyleUrl, getProtomapsApiKey, getProtomapsStyleUrl, getRegionalBasemapById, getRegionalBasemapByStyleUrl, getRoundNum, getRoutingConfig, getRuntimeEnvironment, getSpatialExtensionPath, getVectorColorRamp, googleMapsApiKeyHeaderValue, groupMemberIndices, hasActiveQuickFilter, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, invertSelection, isAbsoluteFilesystemPath, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCredentialFieldName, isDefaultPrintLayout, isDiagramStyleEnabled, isDuckDBQueryLayer, isExternalNativeLayerRecord, isGooglePhotorealisticTilesetUrl, isHexColor, isInitialLayerStyle, isInlineImageValue, isInternalPopupField, isIpadDesktopUserAgent, isMaintainedEditorTrackingField, isPopupClickEnabled, isPopupHoverEnabled, isRegionalBasemapSentinel, isSafePopupUrl, isStyleLibraryTargetLayer, isStyleSpecColor, isVectorColorExpression, isochroneResponseToFeatures, layerGroupDepth, layerGroupMoveability, layerJoinKey, layerLibraryConfigPatch, layerLibraryEntryNeedsLocalFile, layerPanelGroupHeaders, lineWidthValue, mapZoomStepOutputs, matchFeaturesByExpression, matrixResponseToFeatures, meanRadiusMeters, mercatorMetersPerPixelAtZoom0, metersWidthExpression, nextDelayMs, nextLayerPaletteColor, nominatimResultToFeature, nominatimReverseResultToDisplay, nonEmptyRecord, normalizeDashboardColumns, normalizeGeocodingProviderId, normalizeGroupContiguity, normalizeHexColor, normalizeLayerCapabilities, normalizeLayerLibraryEntries, normalizeMapLayout, normalizeMapViewState, normalizeModelGraph, normalizeModels, normalizePrintLayoutConfig, normalizeProcessingHistory, normalizeProjectComments, normalizeSecondaryMapViews, normalizeStoryMap, normalizeStyleLibraryEntries, normalizeWidgets, parseContours, parseHexColor, parseHexColorList, parseJsonExpression, parseLayerLibrary, parseProject, parseStoryMapCsv, parseStoryMapJson, parseStyleLibrary, parseValueMapText, persistedThreeDTilesRequestHeaders, pickEditorIdentity, planLayerLibraryAdd, pluginOwnsPaint, polylineStrToGeoJSON, popupFieldLabel, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, removeTrailingJsonCommas, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveConfiguredPopupTitle, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveLayerCapabilities, resolveMapGrid, resolvePopupBody, resolvePopupRows, resolvePopupTitle, resolveSvgSource, resolveThreeDTilesRequestHeaders, rgbToHex, routeResponseToFeatures, rowCap, ruleBasedColorExpression, ruleBasedVisibilityFilter, sampleMapTerrain, sampleMapTerrainPoint, sampleRemoteElevations, sanitizeLayerStylePatch, scaleAltitudeToActiveBody, scaleDenomination, scaleSpan, scrubCommentsForRemovedLayers, scrubLegendForRemovedLayers, scrubPrintLayoutForLayers, scrubPrintLayoutForRemovedLayers, scrubWidgetsForRemovedLayers, serializeLayerLibrary, serializeProject, serializeStoryMapCsv, serializeStoryMapJson, serializeStyleLibrary, setActiveEllipsoidId, setExternalNativePaintBridge, setGeocodingFetch, setHistoryCoalesceMs, setMaxHistoryFeatureCount, setStoredAuthorName, shouldThrottle, shouldUseTiledRendering, simpleStyleNumberValue, stampFeatureCollectionEditorTracking, stampFeatureEditorTracking, stampFeaturePropertiesEditorTracking, storyMapHasContent, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, useAppStore, 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_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_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, 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, 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, SELECTION_MODES, SQL_QUERY_SOURCE_KIND, STYLE_LIBRARY_BUNDLE_TYPE, STYLE_LIBRARY_BUNDLE_VERSION, SYMBOL_STYLE_KEYS, VECTOR_COLOR_RAMPS, activeLayerFilterExpression, activeQuickFilters, 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, circleRadiusValue, clampLabelDecimals, clearExternalNativePaintBridge, clearHistory, clearQuickFilterValues, coerceAttributeFormValue, collectDiagramData, collectTransitiveJoinSourceIds, compareSequenceValues, compileFeatureExpression, compileLayerFilters, compileQuickFilter, compileQuickFilters, controlRendersLayer, copyableLayerStyleKind, createCesiumIonLayer, createCesiumKmlLayer, createCzmlLayer, createDefaultAppCapabilities, createDefaultMapView, createDefaultPrintLayout, createEmptyProject, createEqualIntervalBreaks, createGraduatedClassBreaks, createLayerLibraryEntryId, createPointerElevationResolver, createProjectTemplate, createQuantileBreaks, createSampleStoryMap, createStyleLibraryEntryId, csvRowsToGeocodeRequests, currentEditorIdentity, czmlSource, darkenHex, decodePolyline, decodePolylineDetailed, detachProjectCopy, detectNonGeographicCoordinates, diagramAnchor, diagramPixelSize, diagramsSuppressedByPointRenderer, documentLocale, dominantGeometry, drawMarkerPath, earthAreaToBody, earthLengthToBody, editorTrackingFieldNames, effectiveLayerRenderState, effectiveVectorRules, encodePolyline, ensureEditorTrackingFields, evaluateMapExpression, excludeHiddenFieldsFromGeojson, excludeHiddenFieldsFromProject, extractCopiedLayerStyle, extractStyleLibraryStyle, extrusionColorValue, extrusionHeightValue, featureSelectionId, fetchElevations, formatCameraAltitude, formatExpressionPreviewValue, formatLabelNumber, formatLabelNumberSample, formatPixelValue, formatPopupValue, formatRoundNum, generatorCircleRadiusValue, generatorSizeRange, geoJSONToPolylineStr, geocodeForward, geocodeMatchToFeature, geocodeReverse, geocoderMinIntervalMs, geocoderNeedsApiKey, geojsonHasZCoordinates, getActiveBodyRadiusRatio, getActiveEllipsoid, getActiveMeanRadiusMeters, getActiveSemiMajorAxisMeters, getAttributeFormField, getBuildEnvironment, getCesiumIonToken, getEllipsoid, getExternalNativePaintBridge, getGeocoderConfig, getGeocodingProvider, getGoogleMapsApiKey, getHistoryCoalesceMs, getMapboxAccessToken, getMaxHistoryFeatureCount, getPlanetaryBasemapById, getPlanetaryBasemapByStyleUrl, getProtomapsApiKey, getProtomapsStyleUrl, getRegionalBasemapById, getRegionalBasemapByStyleUrl, getRoundNum, getRoutingConfig, getRuntimeEnvironment, getSpatialExtensionPath, getVectorColorRamp, googleMapsApiKeyHeaderValue, groupMemberIndices, hasActiveLayerFilter, hasActiveQuickFilter, hasAppPrivilege, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, heatmapRampColors, horizontalBbox, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, intersectPrivileges, invertSelection, isAbsoluteFilesystemPath, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCesiumIonLayer, isCesiumKmlLayer, isCesiumOnlyLayer, isCredentialFieldName, isCzmlLayer, isDefaultPrintLayout, isDeploymentCapability, isDiagramStyleEnabled, isDuckDBQueryLayer, isExternalNativeLayerRecord, isGooglePhotorealisticTilesetUrl, isHexColor, isInitialLayerStyle, isInlineImageValue, isInternalPopupField, isIpadDesktopUserAgent, isMaintainedEditorTrackingField, isPopupClickEnabled, isPopupHoverEnabled, isRegionalBasemapSentinel, isSafePopupUrl, isStoryHiddenLayer, isStyleLibraryTargetLayer, isStyleSpecColor, isVectorColorExpression, isochroneResponseToFeatures, labelFieldTextField, layerGroupDepth, layerGroupMoveability, layerJoinKey, layerLibraryConfigPatch, layerLibraryEntryNeedsLocalFile, layerPanelGroupHeaders, lineWidthValue, localFileName, mapZoomStepOutputs, matchFeaturesByExpression, matrixResponseToFeatures, meanRadiusMeters, mercatorMetersPerPixelAtZoom0, metersWidthExpression, nextDelayMs, nextLayerPaletteColor, nominatimResultToFeature, nominatimReverseResultToDisplay, nonEmptyRecord, normalizeAppPrivileges, normalizeBlankBackgroundColor, normalizeCesiumBasemap, normalizeDashboardColumns, normalizeGeocodingProviderId, normalizeGroupContiguity, normalizeHexColor, normalizeLayerCapabilities, normalizeLayerLibraryEntries, normalizeMapLayout, normalizeMapViewState, normalizeModelGraph, normalizeModels, normalizePrimaryRenderer, normalizePrintLayoutConfig, normalizeProcessingHistory, normalizeProjectComments, normalizeSecondaryMapViews, normalizeStoryMap, normalizeStyleLibraryEntries, normalizeWidgets, parseCesiumIonAssetId, parseContours, parseCzml, parseDeploymentCapabilities, parseHexColor, parseHexColorList, parseJsonExpression, parseLayerLibrary, parseProject, parseStoryMapCsv, parseStoryMapJson, parseStyleLibrary, parseValueMapText, persistedThreeDTilesRequestHeaders, pickEditorIdentity, planLayerLibraryAdd, pluginOwnsPaint, polylineStrToGeoJSON, popupFieldLabel, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, removeTrailingJsonCommas, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveConfiguredPopupTitle, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveLabelNumberLocale, resolveLayerCapabilities, resolveMapGrid, resolvePopupBody, resolvePopupRows, resolvePopupTitle, resolveRolePrivileges, resolveSvgSource, resolveThreeDTilesRequestHeaders, rgbToHex, routeResponseToFeatures, rowCap, ruleBasedColorExpression, ruleBasedVisibilityFilter, sameCesiumImagery, sampleMapTerrain, sampleMapTerrainPoint, sampleRemoteElevations, sanitizeLayerStylePatch, scaleAltitudeToActiveBody, scaleDenomination, scaleSpan, scrubCommentsForRemovedLayers, scrubLegendForRemovedLayers, scrubPrintLayoutForLayers, scrubPrintLayoutForRemovedLayers, scrubWidgetsForRemovedLayers, serializeLayerLibrary, serializeProject, serializeStoryMapCsv, serializeStoryMapJson, serializeStyleLibrary, setActiveEllipsoidId, setExternalNativePaintBridge, setGeocodingFetch, setHistoryCoalesceMs, setMaxHistoryFeatureCount, setStoredAuthorName, shouldThrottle, shouldUseTiledRendering, simpleStyleNumberValue, stampFeatureCollectionEditorTracking, stampFeatureEditorTracking, stampFeaturePropertiesEditorTracking, storyLayerOpacityFactor, storyMapHasContent, storyVisibleLayers, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, uniqueImportedLayerName, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, useAppCapability, useAppStore, validateAttributeFormField, validateAttributeFormValues, validateMapExpression, valueMapLabelFor, valueMapToText, vectorCircleColorValue, vectorColorExpression, vectorFillColorValue, vectorFillOpacityValue, vectorLineColorValue, vectorOutlineColorValue, vectorStrokeWidthValue, visiblePopupFields, visiblePopupProperties };
 
 //# sourceMappingURL=index.mjs.map