@geolibre/core 2.7.0 → 2.9.0

package/dist/index.mjs

@@ -331,6 +331,7 @@ const DEFAULT_PROJECT_PREFERENCES = {
 		ellipsoidId: "earth",
 		scaleUnit: "metric",
 		showPointerElevation: false,
+		terrainEnabled: false,
 		coordinateFormat: "dd"
 	},
 	environmentVariables: [],
@@ -1400,6 +1401,175 @@ 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".
+*/
+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 !== "xyz" || b.kind !== "xyz") return true;
+	return a.template === b.template && 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) {
+	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.
@@ -2270,14 +2440,24 @@ function batchDecodePolylines(input, options = {}) {
 }
 //#endregion
 //#region src/runtime-env.ts
+const buildEnv = typeof __GEOLIBRE_BUILD_ENV__ === "undefined" ? {} : __GEOLIBRE_BUILD_ENV__;
 /**
-* Resolves runtime environment variables shared by the external-service clients
-* (geocoding, routing). Build-time Vite vars (`import.meta.env`) are overlaid
-* with project-supplied runtime vars (`window.__GEOLIBRE_RUNTIME_ENV__`, set
-* from project preferences) so a self-hosted endpoint can be configured without
-* a rebuild. Carries no React/MapLibre dependency so callers stay unit-testable.
+* The allowlisted build-time environment, with no runtime overlay.
+*
+* For settings that must be fixed by the build and NOT overridable by a
+* `.geolibre.json` a user opened — the auth gate, the deployment profile, the
+* embed origin allowlist. Routing those through {@link getRuntimeEnvironment}
+* would let project-supplied `__GEOLIBRE_RUNTIME_ENV__` values relax them.
+*
+* Callers should prefer this over reading `import.meta.env` directly: a
+* whole-object read defeats Vite's per-key replacement and inlines every
+* `VITE_` var on the build machine into the chunk.
+*
+* @returns The build-time environment record.
 */
-const buildEnv = import.meta.env;
+function getBuildEnvironment() {
+	return buildEnv;
+}
 /**
 * Merges build-time env with project runtime env (the latter wins). Falls back
 * to build-time env alone outside a browser (e.g. in tests).
@@ -2285,9 +2465,9 @@ const buildEnv = import.meta.env;
 * @returns The resolved environment variables.
 */
 function getRuntimeEnvironment() {
-	if (typeof window === "undefined") return buildEnv ?? {};
+	if (typeof window === "undefined") return buildEnv;
 	return {
-		...buildEnv ?? {},
+		...buildEnv,
 		...window.__GEOLIBRE_RUNTIME_ENV__ ?? {}
 	};
 }
@@ -2373,13 +2553,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.
@@ -4135,6 +4320,302 @@ function featureForEvaluation(properties, feature) {
 	};
 }
 //#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;
+/**
+* A trimmed non-empty string, or `undefined` for anything else.
+*
+* Popup configs arrive from untrusted JSON — a hand-edited `.geolibre.json`, an
+* imported layer-library bundle, an MCP-authored project — so a field typed as
+* `string` may hold a number, an object or null. `value.trim()` on one of those
+* throws and takes the whole popup render with it, so every string read here
+* goes through this.
+*/
+function trimmedString(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+/** Whether the Identify popup should open for a layer. Default: yes. */
+function isPopupClickEnabled(popup) {
+	return popup?.click !== false;
+}
+/** Whether a hover tooltip should follow the pointer. Default: no. */
+function isPopupHoverEnabled(popup) {
+	return popup?.hover === true;
+}
+/** The label a popup shows for a configured field. */
+function popupFieldLabel(config) {
+	return trimmedString(config.label) ?? config.field;
+}
+/**
+* Property keys that never belong in a popup: GeoLibre's own internal columns
+* and the full-resolution companion of a photo thumbnail (an internal twin of
+* a value already shown, and often multiple megabytes of data URL).
+*/
+function isInternalPopupField(key) {
+	return key === "photo_full" || key.startsWith("__geolibre_");
+}
+/**
+* The property keys a popup may show, before any popup config narrows them:
+* the feature's own keys minus the internal ones and anything the author
+* marked `"hidden"` or `"excluded"`.
+*/
+function visiblePopupFields(properties, fieldVisibility) {
+	return Object.keys(properties).filter((key) => !isInternalPopupField(key) && !fieldVisibility?.[key]);
+}
+function formatNumber(value, format, locale) {
+	const options = { useGrouping: format.thousands === true };
+	if (format.decimals != null && Number.isFinite(format.decimals)) {
+		const digits = Math.max(0, Math.min(20, Math.trunc(format.decimals)));
+		options.minimumFractionDigits = digits;
+		options.maximumFractionDigits = digits;
+	}
+	return new Intl.NumberFormat(locale, options).format(value);
+}
+/**
+* Coerce a property value to a Date. A number is epoch milliseconds (what a
+* GeoJSON timestamp column normally holds); a string goes through `Date`'s own
+* parser. Anything that does not parse comes back as `null` so the caller can
+* fall back to the raw text rather than printing "Invalid Date".
+*/
+function toDate(value) {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+	if (typeof value === "number" && Number.isFinite(value)) {
+		const fromEpoch = new Date(value);
+		return Number.isNaN(fromEpoch.getTime()) ? null : fromEpoch;
+	}
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = new Date(value);
+		return Number.isNaN(parsed.getTime()) ? null : parsed;
+	}
+	return null;
+}
+function formatDate(date, dateFormat, locale) {
+	switch (dateFormat) {
+		case "datetime": return date.toLocaleString(locale);
+		case "time": return date.toLocaleTimeString(locale);
+		case "iso": return date.toISOString();
+		case "year": return String(date.getFullYear());
+		default: return date.toLocaleDateString(locale);
+	}
+}
+/** Stringify a value the way the untyped popup always has. */
+function stringifyPopupValue(value) {
+	if (value == null) return "";
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+/**
+* Render one value as text under a field's kind and format. `"auto"` and
+* `"image"` values are returned verbatim (the renderer draws them itself);
+* every other kind is stringified, formatted, then wrapped in the configured
+* prefix/suffix.
+*/
+function formatPopupValue(value, config = {}, options = {}) {
+	const kind = config.kind ?? "auto";
+	const format = config.format ?? {};
+	if (kind === "auto" || kind === "image") return stringifyPopupValue(value);
+	if (value == null || typeof value === "string" && value.trim() === "") return "";
+	let body;
+	if (kind === "number") {
+		const numeric = typeof value === "number" ? value : Number(stringifyPopupValue(value));
+		body = Number.isFinite(numeric) ? formatNumber(numeric, format, options.locale) : stringifyPopupValue(value);
+	} else if (kind === "date") {
+		const date = toDate(value);
+		body = date ? formatDate(date, format.dateFormat ?? "date", options.locale) : stringifyPopupValue(value);
+	} else body = stringifyPopupValue(value);
+	if (body === "") return "";
+	return `${format.prefix ?? ""}${body}${format.suffix ?? ""}`;
+}
+/** Whether a row would draw as a picture rather than as text. */
+function rendersAsImage(kind, value) {
+	return kind === "image" || kind === "auto" && isInlineImageValue(value);
+}
+/**
+* The properties a popup may read, with the author's hidden and excluded
+* fields and GeoLibre's internal columns removed.
+*
+* Expressions get this rather than the raw record. `["get", "ssn"]` in a title
+* or body would otherwise reach a column the author hid, printing it into the
+* popup — and onto the hover tooltip, which needs no click at all. The rest of
+* this module already honors `fieldVisibility` field by field; an expression
+* has no field list to filter, so the filtering has to happen to its input.
+*/
+function visiblePopupProperties(properties, fieldVisibility) {
+	const visible = {};
+	for (const key of visiblePopupFields(properties, fieldVisibility)) visible[key] = properties[key];
+	return visible;
+}
+/**
+* The rows a popup (or hover tooltip) should render for one feature's
+* properties.
+*
+* With no `popup.fields`, every visible property is returned in the feature's
+* own key order and left untyped, which is exactly what the popup did before
+* the designer existed. With a list, only the listed fields appear, in the
+* listed order, under their labels and formats — and a listed field the
+* feature does not carry is skipped rather than printed empty, so one config
+* can cover a layer whose features have ragged properties.
+*
+* `hover: true` narrows the list to fields flagged `hover`. A hover request
+* with no flagged field returns nothing: an author who turned the tooltip on
+* without choosing a field gets no tip rather than the whole table following
+* the pointer.
+*/
+function resolvePopupRows(properties, options = {}) {
+	const { popup, fieldVisibility, hover = false, locale } = options;
+	const configured = (Array.isArray(popup?.fields) ? popup.fields : []).filter((config) => Boolean(config) && typeof config.field === "string");
+	if (configured.length === 0) {
+		if (hover) return [];
+		return visiblePopupFields(properties, fieldVisibility).map((field) => ({
+			field,
+			label: field,
+			value: properties[field],
+			text: stringifyPopupValue(properties[field]),
+			kind: "auto"
+		}));
+	}
+	const rows = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const config of configured) {
+		if (hover && config.hover !== true) continue;
+		if (fieldVisibility?.[config.field]) continue;
+		if (isInternalPopupField(config.field)) continue;
+		if (!(config.field in properties)) continue;
+		if (seen.has(config.field)) continue;
+		const value = properties[config.field];
+		if (hover && rendersAsImage(config.kind ?? "auto", value)) continue;
+		seen.add(config.field);
+		rows.push({
+			field: config.field,
+			label: popupFieldLabel(config),
+			value,
+			text: formatPopupValue(value, config, { locale }),
+			kind: config.kind ?? "auto",
+			...trimmedString(config.format?.linkLabel) ? { linkLabel: trimmedString(config.format?.linkLabel) } : {}
+		});
+	}
+	return rows;
+}
+/**
+* Compiled title/body expressions, keyed by zoom and source.
+*
+* `createHoverTooltipElement` calls {@link resolvePopupTitle} once per
+* animation frame for as long as the pointer sits on a hovered feature, and
+* compiling means a `JSON.parse` plus a full style-spec validation. Without
+* this the same unchanged source string would be re-parsed sixty times a
+* second. Zoom is part of the key because a compiled expression bakes it in
+* for `["zoom"]`; it is constant through a hover, so the cache still hits.
+*/
+const EXPRESSION_CACHE = /* @__PURE__ */ new Map();
+/** Bound on the cache, so a project full of layers cannot grow it without end. */
+const EXPRESSION_CACHE_LIMIT = 64;
+function compiledPopupExpression(source, zoom) {
+	const key = `${zoom}\u0000${source}`;
+	const cached = EXPRESSION_CACHE.get(key);
+	if (cached) return cached;
+	const compiled = compileFeatureExpression(source, { zoom });
+	if (EXPRESSION_CACHE.size >= EXPRESSION_CACHE_LIMIT) {
+		const oldest = EXPRESSION_CACHE.keys().next().value;
+		if (oldest !== void 0) EXPRESSION_CACHE.delete(oldest);
+	}
+	EXPRESSION_CACHE.set(key, compiled);
+	return compiled;
+}
+/**
+* Evaluate a popup expression against a feature's properties, or return
+* `undefined` when it does not compile or throws. Both failures mean the same
+* thing to every caller here: fall back to what the popup would show without
+* the expression.
+*/
+function evaluatePopupExpression(source, properties, options) {
+	const compiled = compiledPopupExpression(source, options.zoom ?? 0);
+	if (!compiled.ok || !compiled.evaluate) return void 0;
+	try {
+		return compiled.evaluate(featureFor(visiblePopupProperties(properties, options.fieldVisibility), options.feature));
+	} catch {
+		return;
+	}
+}
+/** Build the synthetic feature an expression is evaluated against. */
+function featureFor(properties, feature) {
+	if (feature) return {
+		...feature,
+		properties
+	};
+	return {
+		type: "Feature",
+		geometry: null,
+		properties
+	};
+}
+/**
+* The heading a popup should show: the title expression's value, else the
+* title field's value, else the layer name. An expression that fails to
+* compile or evaluate, and a title field that is empty or hidden, both fall
+* back to the layer name rather than leaving the popup headless.
+*/
+function resolvePopupTitle(layerName, properties, popup, options = {}) {
+	return resolveConfiguredPopupTitle(properties, popup, options) ?? layerName;
+}
+/**
+* The title the author's own configuration produced, or `null` when there is
+* none — no title field or expression, or one that evaluated to nothing, or a
+* field the author hid.
+*
+* {@link resolvePopupTitle} is this plus the layer-name fallback. The hover
+* tooltip needs the two apart: a tip with no fields and no configured title
+* would be a box repeating the layer name, so it is suppressed — but that
+* decision has to rest on whether a title was *configured*, not on whether the
+* resolved text happens to equal the layer name. A city layer named "Olympia"
+* whose feature is also called "Olympia" is a real title, not a fallback.
+*/
+function resolveConfiguredPopupTitle(properties, popup, options = {}) {
+	const source = trimmedString(popup?.titleExpression);
+	if (source) {
+		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
@@ -4604,6 +5085,246 @@ function reapplyLayerJoins(layers) {
 	return current;
 }
 //#endregion
+//#region src/quick-filters.ts
+/**
+* Quick filters (issue #2114): per-layer, data-driven filter controls that
+* compile down to the MapLibre filter a layer already supports.
+*
+* The persisted record is the *control state* (field, kind, chosen values),
+* never the compiled expression. Storing the compiled output would make a
+* filter unreadable and un-editable the moment it is saved, which is exactly
+* the wall this feature exists to remove: a rule filter, Select by Expression,
+* and the attribute table's filter box all already accept a hand-written
+* MapLibre expression.
+*
+* Compilation happens at sync time in `@geolibre/map`'s layer sync, which
+* combines the result with the transient `timeFilter`, the embed API's
+* `embedFilter`, and the rule-based visibility filter under one `["all", …]`,
+* so a host page's filter and a user's filter narrow the layer together
+* instead of clobbering each other.
+*
+* Every clause reads the property in place, so the same expression is correct
+* for a GeoJSON source and for a tile-backed source whose tiles decode later.
+*/
+/** Day length in milliseconds, used to make a date filter's end day inclusive. */
+const DAY_MS = 864e5;
+/** The `YYYY-MM-DD` prefix length every ISO date comparison slices to. */
+const ISO_DAY_LENGTH = 10;
+/** Whether a filter is switched on (the field defaults to enabled). */
+function isEnabled(filter) {
+	return filter.enabled !== false;
+}
+/**
+* Validate a `YYYY-MM-DD` bound, returning its canonical text and UTC midnight,
+* or `null` when the text is blank, malformed, or not a real calendar day.
+*
+* The round-trip check is what rejects a day that does not exist: `Date.parse`
+* happily reads `2026-02-30` as March 2, so shape-checking alone would compile
+* a bound the user never chose. Rejecting here means a half-typed or impossible
+* bound compiles to no clause at all, leaving that side unconstrained rather
+* than filtering on a date nobody asked for.
+*/
+function parseIsoDayBound(day) {
+	if (typeof day !== "string") return null;
+	const trimmed = day.trim();
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return null;
+	const ms = Date.parse(`${trimmed}T00:00:00Z`);
+	if (!Number.isFinite(ms)) return null;
+	return new Date(ms).toISOString().slice(0, ISO_DAY_LENGTH) === trimmed ? {
+		day: trimmed,
+		ms
+	} : null;
+}
+/** A finite number, or `null` for every other input (including `NaN`). */
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+* `["get", field]` coerced for comparison, guarded by `["has", field]` where a
+* missing property would otherwise coerce into range (`to-number` turns a
+* missing property into `0`, and `to-string` into `""`, either of which can sit
+* inside a one-sided bound).
+*/
+function presenceGuard(field) {
+	return ["has", field];
+}
+function compileCategorical(filter) {
+	const values = filter.values ?? [];
+	if (values.length === 0) return null;
+	return [
+		"in",
+		["get", filter.field],
+		["literal", values]
+	];
+}
+function compileRange(filter) {
+	const first = finite(filter.min);
+	const second = finite(filter.max);
+	if (first === null && second === null) return null;
+	const min = first !== null && second !== null ? Math.min(first, second) : first;
+	const max = first !== null && second !== null ? Math.max(first, second) : second;
+	const value = ["to-number", ["get", filter.field]];
+	const clauses = [presenceGuard(filter.field)];
+	if (min !== null) clauses.push([
+		">=",
+		value,
+		min
+	]);
+	if (max !== null) clauses.push([
+		"<=",
+		value,
+		max
+	]);
+	return ["all", ...clauses];
+}
+function compileDate(filter) {
+	const first = parseIsoDayBound(filter.start);
+	const second = parseIsoDayBound(filter.end);
+	if (first === null && second === null) return null;
+	const inverted = first !== null && second !== null && first.ms > second.ms;
+	const start = inverted ? second : first;
+	const end = inverted ? first : second;
+	const clauses = [presenceGuard(filter.field)];
+	if ((filter.dateKind ?? "iso") === "iso") {
+		const value = [
+			"slice",
+			["to-string", ["get", filter.field]],
+			0,
+			ISO_DAY_LENGTH
+		];
+		if (start !== null) clauses.push([
+			">=",
+			value,
+			start.day
+		]);
+		if (end !== null) clauses.push([
+			"<=",
+			value,
+			end.day
+		]);
+		return ["all", ...clauses];
+	}
+	const scale = filter.dateKind === "epochS" ? .001 : 1;
+	const value = ["to-number", ["get", filter.field]];
+	if (start !== null) clauses.push([
+		">=",
+		value,
+		start.ms * scale
+	]);
+	if (end !== null) clauses.push([
+		"<",
+		value,
+		(end.ms + DAY_MS) * scale
+	]);
+	return ["all", ...clauses];
+}
+function compileText(filter) {
+	const needle = filter.text?.trim().toLowerCase() ?? "";
+	if (needle === "") return null;
+	const haystack = ["downcase", ["to-string", ["get", filter.field]]];
+	switch (filter.operator ?? "contains") {
+		case "equals": return [
+			"==",
+			haystack,
+			needle
+		];
+		case "startsWith": return [
+			"==",
+			[
+				"index-of",
+				needle,
+				haystack
+			],
+			0
+		];
+		default: return [
+			"!=",
+			[
+				"index-of",
+				needle,
+				haystack
+			],
+			-1
+		];
+	}
+}
+/**
+* Compile one quick filter to a MapLibre filter expression, or `null` when it
+* places no constraint (switched off, no field, or nothing chosen yet). A
+* control that has been added but not yet answered must never hide features.
+*
+* @param filter - The persisted control state.
+* @returns A MapLibre filter expression, or `null`.
+*/
+function compileQuickFilter(filter) {
+	if (!isEnabled(filter) || typeof filter.field !== "string" || filter.field === "") return null;
+	switch (filter.kind) {
+		case "categorical": return compileCategorical(filter);
+		case "range": return compileRange(filter);
+		case "date": return compileDate(filter);
+		case "text": return compileText(filter);
+		default: return null;
+	}
+}
+/**
+* Compile a layer's quick filters into a single MapLibre filter expression.
+* Multiple controls narrow the data together (`["all", …]`), matching how a
+* viewer reads a stack of filters. Returns `null` when no control constrains
+* anything, so the common path adds no filter at all.
+*
+* @param filters - The layer's persisted quick filters.
+* @returns A MapLibre filter expression, or `null`.
+*/
+function compileQuickFilters(filters) {
+	if (!filters || filters.length === 0) return null;
+	const clauses = [];
+	for (const filter of filters) {
+		const compiled = compileQuickFilter(filter);
+		if (compiled) clauses.push(compiled);
+	}
+	if (clauses.length === 0) return null;
+	return clauses.length === 1 ? clauses[0] : ["all", ...clauses];
+}
+/**
+* The quick filters that actually constrain the layer right now. Drives the
+* "filtered" badge on the layer row and its count, so an active filter is
+* never mistaken for missing data.
+*
+* @param layer - The layer to inspect.
+* @returns The constraining filters, in their configured order.
+*/
+function activeQuickFilters(layer) {
+	return (layer.quickFilters ?? []).filter((filter) => compileQuickFilter(filter) !== null);
+}
+/**
+* Whether the layer is currently narrowed by at least one quick filter.
+*
+* @param layer - The layer to inspect.
+* @returns `true` when a quick filter constrains the rendered features.
+*/
+function hasActiveQuickFilter(layer) {
+	return (layer.quickFilters ?? []).some((filter) => compileQuickFilter(filter) !== null);
+}
+/**
+* Clear every chosen value while keeping the controls themselves, so "Clear
+* filters" is one action that leaves the layer's configured controls in place
+* for the next question.
+*
+* @param filters - The layer's persisted quick filters.
+* @returns The same controls with their selections emptied.
+*/
+function clearQuickFilterValues(filters) {
+	return (filters ?? []).map((filter) => ({
+		...filter,
+		values: filter.kind === "categorical" ? [] : filter.values,
+		min: filter.kind === "range" ? null : filter.min,
+		max: filter.kind === "range" ? null : filter.max,
+		start: filter.kind === "date" ? null : filter.start,
+		end: filter.kind === "date" ? null : filter.end,
+		text: filter.kind === "text" ? "" : filter.text
+	}));
+}
+//#endregion
 //#region src/capabilities.ts
 /**
 * Default inferred capabilities for a layer based on its type and metadata.
@@ -4682,6 +5403,171 @@ 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/history.ts
 /**
@@ -6287,6 +7173,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],
@@ -6303,6 +7192,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: {},
@@ -6424,6 +7314,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);
@@ -6435,6 +7326,7 @@ function parseProject(json) {
 		basemapStyleUrl,
 		basemapVisible,
 		basemapOpacity,
+		blankBackgroundColor,
 		layers,
 		...selectedLayerId !== void 0 ? { selectedLayerId } : {},
 		...layerGroups.length > 0 ? { layerGroups } : {},
@@ -7119,6 +8011,7 @@ function normalizeProjectPreferences(preferences) {
 			ellipsoidId: getEllipsoid(map.ellipsoidId).id,
 			scaleUnit: normalizeScaleUnit(map.scaleUnit),
 			showPointerElevation: normalizeBoolean(map.showPointerElevation, DEFAULT_PROJECT_PREFERENCES.map.showPointerElevation),
+			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)) : [],
@@ -7351,6 +8244,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 } : {},
@@ -7397,6 +8291,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;
@@ -7412,11 +8318,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,
@@ -7432,6 +8350,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));
@@ -7460,6 +8379,7 @@ function applyProjectToStore(project) {
 		basemapStyleUrl,
 		basemapVisible,
 		basemapOpacity,
+		blankBackgroundColor,
 		layers: normalizedLayers,
 		layerGroups,
 		preferences: normalizeProjectPreferences(project.preferences),
@@ -8373,7 +9293,8 @@ function captureLayerLibraryEntry(layer, options) {
 		...localPath ? { sourcePath: localPath } : {},
 		...layer.joins?.length ? { joins: structuredClone(layer.joins) } : {},
 		...layer.virtualFields?.length ? { virtualFields: structuredClone(layer.virtualFields) } : {},
-		...layer.attributeForm ? { attributeForm: structuredClone(layer.attributeForm) } : {}
+		...layer.attributeForm ? { attributeForm: structuredClone(layer.attributeForm) } : {},
+		...layer.popup ? { popup: structuredClone(layer.popup) } : {}
 	};
 	const withFeatures = embed && !controlPainted ? {
 		...base,
@@ -8429,7 +9350,8 @@ function planLayerLibraryAdd(entry, options) {
 			...entry.geojson ? { geojson: structuredClone(entry.geojson) } : {},
 			...entry.joins ? { joins: structuredClone(entry.joins) } : {},
 			...entry.virtualFields ? { virtualFields: structuredClone(entry.virtualFields) } : {},
-			...entry.attributeForm ? { attributeForm: structuredClone(entry.attributeForm) } : {}
+			...entry.attributeForm ? { attributeForm: structuredClone(entry.attributeForm) } : {},
+			...entry.popup ? { popup: structuredClone(entry.popup) } : {}
 		}
 	};
 }
@@ -8447,7 +9369,8 @@ function layerLibraryConfigPatch(entry) {
 		opacity: entry.opacity,
 		...entry.joins ? { joins: structuredClone(entry.joins) } : {},
 		...entry.virtualFields ? { virtualFields: structuredClone(entry.virtualFields) } : {},
-		...entry.attributeForm ? { attributeForm: structuredClone(entry.attributeForm) } : {}
+		...entry.attributeForm ? { attributeForm: structuredClone(entry.attributeForm) } : {},
+		...entry.popup ? { popup: structuredClone(entry.popup) } : {}
 	};
 }
 /**
@@ -8533,6 +9456,24 @@ function validAttributeForm(value) {
 		fields
 	});
 }
+/**
+* A structurally plausible popup design, or undefined. `fields` is optional (a
+* config may carry only a title or the hover flag), so unlike the attribute
+* form an empty field list does not disqualify the block — but a config with
+* nothing set at all is dropped rather than stored as an empty object.
+*/
+function validPopup(value) {
+	const config = plainObject(value);
+	if (!config) return void 0;
+	const fields = Array.isArray(config.fields) ? config.fields.filter((field) => plainObject(field) !== void 0 && nonEmptyString(field.field)) : void 0;
+	const rest = { ...config };
+	delete rest.fields;
+	if (!fields?.length && Object.keys(rest).length === 0) return void 0;
+	return structuredClone({
+		...rest,
+		...fields?.length ? { fields } : {}
+	});
+}
 /** An array of plain JSON objects, or undefined when nothing usable is present. */
 function objectArray(value) {
 	if (!Array.isArray(value)) return void 0;
@@ -8598,10 +9539,12 @@ function normalizeLayerLibraryEntries(value) {
 				const joins = validJoins(candidate.joins);
 				const virtualFields = validVirtualFields(candidate.virtualFields);
 				const attributeForm = validAttributeForm(candidate.attributeForm);
+				const popup = validPopup(candidate.popup);
 				return {
 					...joins ? { joins } : {},
 					...virtualFields ? { virtualFields } : {},
-					...attributeForm ? { attributeForm } : {}
+					...attributeForm ? { attributeForm } : {},
+					...popup ? { popup } : {}
 				};
 			})(),
 			...geojson ? { geojson: structuredClone(geojson) } : {},
@@ -8764,6 +9707,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
@@ -9002,6 +9947,7 @@ const useAppStore = create()(temporal((set, get) => ({
 	basemapStyleUrl: DEFAULT_BASEMAP,
 	basemapVisible: true,
 	basemapOpacity: 1,
+	blankBackgroundColor: null,
 	layers: [],
 	layerGroups: [],
 	preferences: DEFAULT_PROJECT_PREFERENCES,
@@ -9033,7 +9979,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,
@@ -9311,6 +10259,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
@@ -9660,6 +10612,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) => {
@@ -9729,6 +10682,7 @@ const useAppStore = create()(temporal((set, get) => ({
 		};
 	}),
 	setLayerAttributeForm: (id, attributeForm) => get().updateLayer(id, { attributeForm }),
+	setLayerPopup: (id, popup) => get().updateLayer(id, { popup }),
 	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);
@@ -9738,6 +10692,7 @@ const useAppStore = create()(temporal((set, get) => ({
 			isDirty: true
 		};
 	}),
+	setLayerQuickFilters: (id, filters) => get().updateLayer(id, { quickFilters: filters.length > 0 ? filters : void 0 }),
 	setLayerVisibility: (id, visible) => get().updateLayer(id, { visible }),
 	setLayerOpacity: (id, opacity) => get().updateLayer(id, { opacity }),
 	setLayerStyle: (id, style) => set((s) => ({
@@ -10122,6 +11077,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) => ({
@@ -10130,10 +11130,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);
@@ -10258,6 +11259,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
 /**
@@ -10583,6 +11597,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";
 /**
@@ -10853,12 +11884,14 @@ function parseCsvRows(text) {
 	const input = text.replace(/\r\n?/g, "\n");
 	for (let i = 0; i < input.length; i++) {
 		const ch = input[i];
-		if (inQuotes) if (ch === "\"") if (input[i + 1] === "\"") {
-			field += "\"";
-			i++;
-		} else inQuotes = false;
-		else field += ch;
-		else if (ch === "\"") inQuotes = true;
+		if (inQuotes) {
+			if (ch === "\"") {
+				if (input[i + 1] === "\"") {
+					field += "\"";
+					i++;
+				} else inQuotes = false;
+			} else field += ch;
+		} else if (ch === "\"") inQuotes = true;
 		else if (ch === ",") {
 			row.push(field);
 			field = "";
@@ -12058,6 +13091,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, 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, coerceAttributeFormValue, collectDiagramData, collectTransitiveJoinSourceIds, compareSequenceValues, compileFeatureExpression, 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, formatRoundNum, generatorCircleRadiusValue, generatorSizeRange, geoJSONToPolylineStr, geocodeForward, geocodeMatchToFeature, geocodeReverse, geocoderMinIntervalMs, geocoderNeedsApiKey, geojsonHasZCoordinates, getActiveBodyRadiusRatio, getActiveEllipsoid, getActiveMeanRadiusMeters, getActiveSemiMajorAxisMeters, getAttributeFormField, getCesiumIonToken, getEllipsoid, getExternalNativePaintBridge, getGeocoderConfig, getGeocodingProvider, getGoogleMapsApiKey, getHistoryCoalesceMs, getMapboxAccessToken, getMaxHistoryFeatureCount, getPlanetaryBasemapById, getPlanetaryBasemapByStyleUrl, getProtomapsApiKey, getProtomapsStyleUrl, getRegionalBasemapById, getRegionalBasemapByStyleUrl, getRoundNum, getRoutingConfig, getRuntimeEnvironment, getSpatialExtensionPath, getVectorColorRamp, googleMapsApiKeyHeaderValue, groupMemberIndices, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, invertSelection, isAbsoluteFilesystemPath, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCredentialFieldName, isDefaultPrintLayout, isDiagramStyleEnabled, isDuckDBQueryLayer, isExternalNativeLayerRecord, isGooglePhotorealisticTilesetUrl, isHexColor, isInitialLayerStyle, isIpadDesktopUserAgent, isMaintainedEditorTrackingField, isRegionalBasemapSentinel, 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, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, removeTrailingJsonCommas, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveLayerCapabilities, resolveMapGrid, 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, 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 };
+export { ALL_APP_PRIVILEGES, ALL_DEPLOYMENT_CAPABILITIES, 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, 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, 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, activeQuickFilters, appPrivilegeReason, applyCopiedLayerStyle, applyGroupEffects, applyJoinsToLayer, applyLayerJoins, applyLayerVirtualFields, applyMatchedSelection, applyProjectToStore, applySelectionMode, attributeFormFieldLabel, attributeLinkUrl, basemapToCesiumImagery, 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, createDefaultAppCapabilities, 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, 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, hasActiveQuickFilter, hasAppPrivilege, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, intersectPrivileges, invertSelection, isAbsoluteFilesystemPath, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCredentialFieldName, isDefaultPrintLayout, isDeploymentCapability, 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, normalizeAppPrivileges, normalizeBlankBackgroundColor, normalizeDashboardColumns, normalizeGeocodingProviderId, normalizeGroupContiguity, normalizeHexColor, normalizeLayerCapabilities, normalizeLayerLibraryEntries, normalizeMapLayout, normalizeMapViewState, normalizeModelGraph, normalizeModels, normalizePrintLayoutConfig, normalizeProcessingHistory, normalizeProjectComments, normalizeSecondaryMapViews, normalizeStoryMap, normalizeStyleLibraryEntries, normalizeWidgets, parseContours, 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, 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, storyMapHasContent, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, useAppCapability, useAppStore, validateAttributeFormField, validateAttributeFormValues, validateMapExpression, valueMapLabelFor, valueMapToText, vectorCircleColorValue, vectorColorExpression, vectorFillColorValue, vectorFillOpacityValue, vectorLineColorValue, vectorOutlineColorValue, vectorStrokeWidthValue, visiblePopupFields, visiblePopupProperties };
 
 //# sourceMappingURL=index.mjs.map