@geolibre/core 3.1.0 → 3.2.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { Color, createExpression } from "@maplibre/maplibre-gl-style-spec";
+import { Color, createExpression, featureFilter, latest, normalizePropertyExpression } from "@maplibre/maplibre-gl-style-spec";
 import { create } from "zustand";
 import { temporal } from "zundo";
 import { v4 } from "uuid";
@@ -4346,6 +4346,86 @@ function extrusionColorValue(style) {
 	return parseJsonExpression(styleValue(style, "extrusionAdvancedStyleEnabled") ? styleValue(style, "extrusionColorExpression") : "") ?? flat;
 }
 //#endregion
+//#region src/style-layer-evaluator.ts
+const GEOMETRY_TYPE = {
+	Point: 1,
+	LineString: 2,
+	Polygon: 3
+};
+/**
+* Compile a MapLibre style layer's filter and properties for evaluation
+* outside MapLibre, for a renderer that draws the layer itself (the ArcGIS
+* renderer drawing a plugin's own GeoJSON overlay, say). Uses the style spec's
+* own evaluator, so data-driven and zoom expressions, legacy functions and
+* defaults behave as they do on MapLibre. Each property compiles once.
+*
+* @param layer - The style layer (its `type`, `filter`, `paint`, `layout`).
+* @returns The layer's evaluator.
+*/
+function createStyleLayerEvaluator(layer) {
+	const root = `layers[${layer.id ?? ""}]`;
+	let filter;
+	try {
+		const compiled = featureFilter(layer.filter, `${root}.filter`);
+		filter = (zoom, feature) => compiled.filter({ zoom }, feature);
+	} catch {
+		filter = () => false;
+	}
+	const compiled = /* @__PURE__ */ new Map();
+	const compile = (group, name) => {
+		const key = `${group}/${name}`;
+		if (compiled.has(key)) return compiled.get(key);
+		const spec = latest[`${group}_${layer.type}`]?.[name];
+		let evaluate = null;
+		if (spec) {
+			const raw = layer[group]?.[name];
+			try {
+				const expression = normalizePropertyExpression(raw ?? spec.default, `${root}.${group}.${name}`, spec);
+				evaluate = (globals, feature) => expression.evaluate(globals, feature);
+			} catch {
+				evaluate = null;
+			}
+		}
+		compiled.set(key, evaluate);
+		return evaluate;
+	};
+	const input = (feature) => ({
+		type: GEOMETRY_TYPE[feature.kind],
+		id: feature.id,
+		properties: feature.properties ?? {}
+	});
+	return {
+		passes: (zoom, feature) => {
+			try {
+				return filter(zoom, input(feature));
+			} catch {
+				return false;
+			}
+		},
+		value: (group, name, zoom, feature) => {
+			const evaluate = compile(group, name);
+			if (!evaluate) return void 0;
+			let result;
+			try {
+				result = evaluate({ zoom }, input(feature));
+			} catch {
+				return;
+			}
+			if (result instanceof Color) {
+				const [r, g, b, a] = result.rgb;
+				return [
+					Math.round(r * 255),
+					Math.round(g * 255),
+					Math.round(b * 255),
+					a
+				];
+			}
+			if (result && typeof result === "object" && "sections" in result) return String(result);
+			return result;
+		}
+	};
+}
+//#endregion
 //#region src/document-locale.ts
 /**
 * The document language, so formatted numbers and dates follow the UI locale.
@@ -4645,6 +4725,20 @@ function supportsBridgedOpacity(layerId) {
 function rendererAppliesOpacity(layer, renderer) {
 	return (renderer === "arcgis" || renderer === "cesium") && layer.type === "zarr";
 }
+/**
+* Whether `layer` is an Add Vector Layer layer GeoLibre adopted
+* (`maplibre-gl-vector-adopted`, ADOPTED_VECTOR_SOURCE_KIND in
+* @geolibre/plugins) that has no features yet. A project saves a URL- or
+* path-backed adopted layer without them, and the vector control reads them
+* again on reopen. Until then its `source.url` may name GeoParquet or
+* GeoPackage, so a renderer must wait rather than load that URL as GeoJSON.
+*
+* @param layer - A store layer.
+* @returns True while the adopted layer awaits its features.
+*/
+function isAdoptedVectorAwaitingFeatures(layer) {
+	return layer.metadata.sourceKind === "maplibre-gl-vector-adopted" && !layer.geojson;
+}
 //#endregion
 //#region src/attribute-form.ts
 /** Look up the configuration for a field, if any. */
@@ -7340,6 +7434,134 @@ function scrubPrintLayoutForRemovedLayers(config, layerIds) {
 	return clearBlocksForMissingLayers(config, (id) => removed.has(id));
 }
 //#endregion
+//#region src/store/session-slice.ts
+/** Reserved Identify target for querying every visible queryable layer at once. */
+const IDENTIFY_ALL_LAYERS_ID = "__geolibre_identify_all_layers__";
+/**
+* Resolve an Identify target against the layers that exist.
+*
+* Shared by the scripting `setIdentify` command and by project load, which
+* applies a project's saved `interaction.identify` (issue #2688).
+*
+* @param target - A layer id, `"all"`, a list of layer ids, or null/undefined.
+* @param layerIds - Ids of the layers currently in the project.
+* @returns The store fields to set. Ids that name no layer are dropped; a list
+*   that keeps one id becomes a single-layer target, and one that keeps several
+*   becomes the all-layers mode restricted to those ids.
+*/
+function resolveIdentifyTarget(target, layerIds) {
+	const off = {
+		identifyLayerId: null,
+		identifyLayerIds: null
+	};
+	if (target === null || target === void 0) return off;
+	if (target === "all") return {
+		identifyLayerId: IDENTIFY_ALL_LAYERS_ID,
+		identifyLayerIds: null
+	};
+	const known = new Set(layerIds);
+	if (typeof target === "string") return known.has(target) ? {
+		identifyLayerId: target,
+		identifyLayerIds: null
+	} : off;
+	const ids = [...new Set(target)].filter((id) => known.has(id));
+	if (ids.length === 0) return off;
+	if (ids.length === 1) return {
+		identifyLayerId: ids[0],
+		identifyLayerIds: null
+	};
+	return {
+		identifyLayerId: IDENTIFY_ALL_LAYERS_ID,
+		identifyLayerIds: ids
+	};
+}
+/**
+* Whether the all-layers Identify mode may query a layer.
+*
+* @param layerId - The candidate layer's id.
+* @param identifyLayerIds - The store's `identifyLayerIds` restriction.
+* @returns True when there is no restriction or the layer is in it.
+*/
+function identifyAllIncludes(layerId, identifyLayerIds) {
+	return !identifyLayerIds || identifyLayerIds.includes(layerId);
+}
+/**
+* Drop removed layers from the Identify state.
+*
+* @param state - The current Identify fields.
+* @param removed - Ids of the layers being removed.
+* @returns The Identify fields with those layers gone. A restricted all-layers
+*   mode left with one layer narrows to it, and with none turns Identify off.
+*/
+function identifyStateWithoutLayers(state, removed) {
+	if (state.identifyLayerId !== null && removed.has(state.identifyLayerId)) return {
+		identifyLayerId: null,
+		identifyLayerIds: null
+	};
+	const unchanged = {
+		identifyLayerId: state.identifyLayerId,
+		identifyLayerIds: state.identifyLayerIds
+	};
+	if (!state.identifyLayerIds) return unchanged;
+	const ids = state.identifyLayerIds.filter((id) => !removed.has(id));
+	if (ids.length === state.identifyLayerIds.length) return unchanged;
+	if (ids.length === 0) return {
+		identifyLayerId: null,
+		identifyLayerIds: null
+	};
+	if (ids.length === 1) return {
+		identifyLayerId: ids[0],
+		identifyLayerIds: null
+	};
+	return {
+		identifyLayerId: state.identifyLayerId,
+		identifyLayerIds: ids
+	};
+}
+const createSessionSlice = (set) => ({
+	hoverTooltipsEnabled: true,
+	setHoverTooltipsEnabled: (enabled) => set({ hoverTooltipsEnabled: enabled }),
+	selectedLayerId: null,
+	selectedFeatureId: null,
+	selectedFeatureIds: [],
+	identifyLayerId: null,
+	identifyLayerIds: null,
+	pointerCoords: null,
+	pointerElevation: null,
+	cameraAltitude: null,
+	gpsStatus: null,
+	attributeFilter: "",
+	setPointerCoords: (coords) => set(coords ? { pointerCoords: coords } : {
+		pointerCoords: null,
+		pointerElevation: null
+	}),
+	setPointerElevation: (elevation) => set({ pointerElevation: elevation }),
+	setCameraAltitude: (altitude) => set({ cameraAltitude: altitude }),
+	setGpsStatus: (fix) => set({ gpsStatus: fix }),
+	selectLayer: (id) => set({
+		selectedLayerId: id,
+		selectedFeatureId: null,
+		selectedFeatureIds: []
+	}),
+	selectFeature: (id) => set({
+		selectedFeatureId: id,
+		selectedFeatureIds: id === null ? [] : [id]
+	}),
+	selectFeatures: (ids, anchorId) => set({
+		selectedFeatureIds: ids,
+		selectedFeatureId: anchorId != null && ids.includes(anchorId) ? anchorId : ids.at(-1) ?? null
+	}),
+	setIdentifyLayer: (id) => set({
+		identifyLayerId: id,
+		identifyLayerIds: null
+	}),
+	setIdentifyState: ({ identifyLayerId, identifyLayerIds }) => set({
+		identifyLayerId,
+		identifyLayerIds
+	}),
+	setAttributeFilter: (filter) => set({ attributeFilter: filter })
+});
+//#endregion
 //#region src/store/layer-removal.ts
 /**
 * Reference scrubbing shared by the actions that delete layers (`removeLayer`
@@ -7485,7 +7707,10 @@ const createLayerGroupsSlice = (set, get) => ({
 			selectedLayerId: selectionRemoved ? layers[layers.length - 1]?.id ?? null : s.selectedLayerId,
 			selectedFeatureId: selectionRemoved ? null : s.selectedFeatureId,
 			selectedFeatureIds: selectionRemoved ? [] : s.selectedFeatureIds,
-			identifyLayerId: s.identifyLayerId !== null && removedIds.has(s.identifyLayerId) ? null : s.identifyLayerId,
+			...removeChildren ? identifyStateWithoutLayers(s, removedIds) : {
+				identifyLayerId: s.identifyLayerId,
+				identifyLayerIds: s.identifyLayerIds
+			},
 			ui: removeChildren ? {
 				...s.ui,
 				selectByExpressionLayerId: s.ui.selectByExpressionLayerId !== null && removedIds.has(s.ui.selectByExpressionLayerId) ? null : s.ui.selectByExpressionLayerId,
@@ -8342,7 +8567,7 @@ const RASTER_APPEARANCE_STATE_KEYS = [
 	"stretch",
 	"gamma"
 ];
-function isPlainObject$2(value) {
+function isPlainObject$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -8379,11 +8604,11 @@ function extractCopiedLayerStyle(layer) {
 	};
 	const rasterState = layer.metadata.rasterState;
 	const rasterSymbology = layer.metadata.rasterSymbology;
-	const hasRasterSymbology = isPlainObject$2(rasterSymbology);
+	const hasRasterSymbology = isPlainObject$3(rasterSymbology);
 	return {
 		kind,
 		sourceName: layer.name,
-		rasterState: isPlainObject$2(rasterState) ? structuredClone(rasterState) : void 0,
+		rasterState: isPlainObject$3(rasterState) ? structuredClone(rasterState) : void 0,
 		hasRasterSymbology,
 		...hasRasterSymbology ? { rasterSymbology: structuredClone(rasterSymbology) } : {}
 	};
@@ -8400,7 +8625,7 @@ function extractCopiedLayerStyle(layer) {
 function applyCopiedLayerStyle(target, copied) {
 	if (copyableLayerStyleKind(target) !== copied.kind) return null;
 	if (copied.kind === "vector") return { style: structuredClone(copied.style) };
-	const targetState = isPlainObject$2(target.metadata.rasterState) ? target.metadata.rasterState : {};
+	const targetState = isPlainObject$3(target.metadata.rasterState) ? target.metadata.rasterState : {};
 	const source = copied.rasterState ?? {};
 	const expectedRescaleLength = rescaleEntryCount(targetState);
 	const mergedState = { ...targetState };
@@ -8427,6 +8652,202 @@ function rescaleEntryCount(state) {
 	return 1;
 }
 //#endregion
+//#region src/layer-style-file.ts
+/** `type` tag identifying a layer styles file. */
+const LAYER_STYLES_FILE_TYPE = "geolibre-layer-styles";
+/** Format version written by {@link serializeLayerStylesFile}. */
+const LAYER_STYLES_FILE_VERSION = 1;
+function isPlainObject$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Capture the style of every layer that has one. Layers without copyable
+* symbology (basemap tiles, 3D tiles, ...) are skipped. Layers that share a
+* name are all written, in stack order; the first one wins when the file is
+* applied (see {@link findLayerStyleEntryIndex}).
+*
+* @param layers - The layers to export, in store (bottom-to-top) order.
+* @returns The style entries.
+*/
+function extractLayerStyleEntries(layers) {
+	const entries = [];
+	for (const layer of layers) {
+		const copied = extractCopiedLayerStyle(layer);
+		if (!copied) continue;
+		if (copied.kind === "vector") entries.push({
+			layerName: layer.name,
+			kind: "vector",
+			style: copied.style
+		});
+		else entries.push({
+			layerName: layer.name,
+			kind: "raster",
+			...copied.rasterState ? { rasterState: copied.rasterState } : {},
+			...isPlainObject$2(copied.rasterSymbology) ? { rasterSymbology: copied.rasterSymbology } : {}
+		});
+	}
+	return entries;
+}
+/**
+* Serialize style entries into the JSON written by Export Layer Styles.
+*
+* @param entries - The entries to write.
+* @returns Pretty-printed file content.
+*/
+function serializeLayerStylesFile(entries) {
+	const file = {
+		type: LAYER_STYLES_FILE_TYPE,
+		version: 1,
+		styles: [...entries]
+	};
+	return JSON.stringify(file, null, 2);
+}
+const RASTER_STRETCHES = [
+	"linear",
+	"log",
+	"sqrt"
+];
+const RASTER_NODATA_MODES = ["off", "auto"];
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/**
+* Validators for the raster appearance keys a style file may carry, by the
+* types `maplibre-gl-raster`'s `RasterLayerState` declares for them.
+*/
+const RASTER_APPEARANCE_VALIDATORS = {
+	colormap: (value) => typeof value === "string" && value.length > 0,
+	reversed: (value) => typeof value === "boolean",
+	rescale: (value) => value === null || Array.isArray(value) && value.length > 0 && value.every((range) => Array.isArray(range) && range.length === 2 && isFiniteNumber(range[0]) && isFiniteNumber(range[1])),
+	nodata: (value) => isFiniteNumber(value) || RASTER_NODATA_MODES.includes(value),
+	stretch: (value) => RASTER_STRETCHES.includes(value),
+	gamma: (value) => isFiniteNumber(value) && value > 0
+};
+/**
+* Keep only the raster appearance keys a style applies, each with a value of
+* the type the raster renderer expects. The data selection (`mode`, `bands`,
+* ...) is dropped too: a style never applies it.
+*/
+function sanitizeRasterAppearanceState(state) {
+	const out = {};
+	for (const key of RASTER_APPEARANCE_STATE_KEYS) if (key in state && RASTER_APPEARANCE_VALIDATORS[key](state[key])) out[key] = structuredClone(state[key]);
+	return out;
+}
+/**
+* Coerce untrusted entries (a hand-edited file, or a copy kept in settings)
+* into clean ones. An entry without a name or a known kind is dropped; a
+* vector style is sanitized and completed against the default style, and a
+* raster state keeps only well-typed appearance keys, so applying an entry
+* never hands a renderer an unknown, missing or wrong-typed field.
+*
+* @param value - The raw `styles` array.
+* @returns The usable entries.
+*/
+function normalizeLayerStyleEntries(value) {
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const item of value) {
+		if (!isPlainObject$2(item)) continue;
+		const layerName = typeof item.layerName === "string" ? item.layerName : "";
+		if (!layerName.trim()) continue;
+		if (item.kind === "vector") {
+			if (!isPlainObject$2(item.style)) continue;
+			entries.push({
+				layerName,
+				kind: "vector",
+				style: {
+					...structuredClone(DEFAULT_LAYER_STYLE),
+					...sanitizeLayerStylePatch(item.style)
+				}
+			});
+		} else if (item.kind === "raster") entries.push({
+			layerName,
+			kind: "raster",
+			...isPlainObject$2(item.rasterState) ? { rasterState: sanitizeRasterAppearanceState(item.rasterState) } : {},
+			...isPlainObject$2(item.rasterSymbology) ? { rasterSymbology: structuredClone(item.rasterSymbology) } : {}
+		});
+	}
+	return entries;
+}
+/**
+* Parse a file written by {@link serializeLayerStylesFile}.
+*
+* @param json - The file content.
+* @returns The normalized entries.
+* @throws Error when the content is not a layer styles file, comes from a
+*   newer format version, or holds no usable entries.
+*/
+function parseLayerStylesFile(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		throw new Error("Not a valid layer styles file (invalid JSON).");
+	}
+	if (!isPlainObject$2(parsed) || parsed.type !== "geolibre-layer-styles") throw new Error("Not a valid layer styles file.");
+	if (parsed.version !== 1) throw new Error("Unsupported layer styles file version.");
+	const entries = normalizeLayerStyleEntries(parsed.styles);
+	if (entries.length === 0) throw new Error("The layer styles file holds no usable styles.");
+	return entries;
+}
+function nameKey(name) {
+	return name.trim().toLocaleLowerCase();
+}
+/**
+* Find the entry for a layer name: an exact match first, then one that differs
+* only in case or surrounding whitespace, so `Roads` still picks up a style
+* saved for `roads`. The first match in file order wins.
+*
+* @param entries - The style entries.
+* @param layerName - The layer name to look up.
+* @param kind - When given, only entries of this style family are considered,
+*   so a raster style saved under a shared name does not shadow the vector one.
+* @returns The matching entry's index in `entries`, or -1.
+*/
+function findLayerStyleEntryIndex(entries, layerName, kind) {
+	const ofKind = (entry) => !kind || entry.kind === kind;
+	const exact = entries.findIndex((entry) => ofKind(entry) && entry.layerName === layerName);
+	if (exact >= 0) return exact;
+	const key = nameKey(layerName);
+	return entries.findIndex((entry) => ofKind(entry) && nameKey(entry.layerName) === key);
+}
+function toCopiedLayerStyle(entry) {
+	if (entry.kind === "vector") return {
+		kind: "vector",
+		sourceName: entry.layerName,
+		style: entry.style
+	};
+	return {
+		kind: "raster",
+		sourceName: entry.layerName,
+		rasterState: entry.rasterState,
+		hasRasterSymbology: entry.rasterSymbology !== void 0,
+		...entry.rasterSymbology !== void 0 ? { rasterSymbology: entry.rasterSymbology } : {}
+	};
+}
+/**
+* Build the patch that restyles a layer from the entry matching its name, with
+* the same semantics as pasting a copied style: a vector style replaces the
+* whole style bag, a raster style merges its appearance keys and keeps the
+* layer's own band selection, and layer opacity is left alone.
+*
+* @param layer - The layer to restyle.
+* @param entries - The style entries.
+* @returns The matched entry and patch, or `null` when no entry of the layer's
+*   style family matches its name (or the layer has no stylable symbology).
+*/
+function matchLayerStyleEntry(layer, entries) {
+	const kind = copyableLayerStyleKind(layer);
+	if (!kind) return null;
+	const entryIndex = findLayerStyleEntryIndex(entries, layer.name, kind);
+	if (entryIndex < 0) return null;
+	const patch = applyCopiedLayerStyle(layer, toCopiedLayerStyle(entries[entryIndex]));
+	return patch ? {
+		entryIndex,
+		patch
+	} : null;
+}
+//#endregion
 //#region src/store/layers-slice.ts
 /**
 * The layer types {@link AppState.addTileLayer} accepts. Each renders through
@@ -8476,7 +8897,7 @@ const createLayersSlice = (set, get) => ({
 		selectedLayerId: s.selectedLayerId === id ? s.layers.find((l) => l.id !== id)?.id ?? null : s.selectedLayerId,
 		selectedFeatureId: s.selectedLayerId === id ? null : s.selectedFeatureId,
 		selectedFeatureIds: s.selectedLayerId === id ? [] : s.selectedFeatureIds,
-		identifyLayerId: s.identifyLayerId === id ? null : s.identifyLayerId,
+		...identifyStateWithoutLayers(s, /* @__PURE__ */ new Set([id])),
 		ui: {
 			...s.ui,
 			selectByExpressionLayerId: s.ui.selectByExpressionLayerId === id ? null : s.ui.selectByExpressionLayerId,
@@ -8551,6 +8972,29 @@ const createLayersSlice = (set, get) => ({
 		get().updateLayer(id, patch);
 		return true;
 	},
+	applyLayerStyleEntries: (entries, layerIds) => {
+		if (entries.length === 0) return [];
+		const scope = layerIds ? new Set(layerIds) : null;
+		const applied = [];
+		const layers = get().layers.map((layer) => {
+			if (scope && !scope.has(layer.id)) return layer;
+			const match = matchLayerStyleEntry(layer, entries);
+			if (!match) return layer;
+			applied.push({
+				layerId: layer.id,
+				entryIndex: match.entryIndex
+			});
+			return {
+				...layer,
+				...match.patch
+			};
+		});
+		if (applied.length > 0) set({
+			layers,
+			isDirty: true
+		});
+		return applied;
+	},
 	reorderLayer: (id, direction) => set((s) => {
 		const idx = s.layers.findIndex((l) => l.id === id);
 		if (idx < 0) return s;
@@ -9043,6 +9487,82 @@ function createCesiumIonLayer(options) {
 	};
 }
 //#endregion
+//#region src/header-references.ts
+/**
+* `${NAME}` references in request header values.
+*
+* A header such as `Authorization: Bearer ${TILES_TOKEN}` is saved as typed
+* and resolved from the project's Environment Variables when a request is
+* made, so the secret itself never sits on the layer. This module is pure (no
+* store import): `credentials.ts` depends on it, and the store depends on
+* `credentials.ts`.
+*/
+/** `${NAME}` where NAME follows the environment-variable name rule. */
+const HEADER_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+const HAS_HEADER_REFERENCE = /\$\{[A-Za-z_][A-Za-z0-9_]*\}/;
+/**
+* Optional auth scheme word, whitespace, one reference, nothing else. Kept in
+* lockstep with `_HEADER_REFERENCE_ONLY` in `python/src/geolibre/project.py`.
+*/
+const REFERENCE_ONLY = /^(?:[A-Za-z][A-Za-z0-9._-]*\s+)?\$\{[A-Za-z_][A-Za-z0-9_]*\}$/;
+const warnedMissing = /* @__PURE__ */ new Set();
+function hasHeaderReferences(headers) {
+	if (!headers) return false;
+	return Object.values(headers).some((value) => typeof value === "string" && HAS_HEADER_REFERENCE.test(value));
+}
+/**
+* Whether `value` carries no secret of its own: at most a scheme word such as
+* `Bearer` followed by a single `${NAME}`. Redaction keeps such values.
+*/
+function isHeaderReferenceOnly(value) {
+	return REFERENCE_ONLY.test(value.trim());
+}
+/**
+* Whether credential-bearing request headers may be sent to `url`: HTTPS, or
+* plain HTTP to loopback so a local dev server still works. The scheme is read
+* off a parsed URL, so an unusually cased `HTTPS://` is not misread as
+* plaintext; a relative or unparseable URL is refused.
+*/
+function allowsCredentialHeaders(url) {
+	try {
+		const { protocol, hostname } = new URL(url);
+		if (protocol === "https:") return true;
+		return protocol === "http:" && (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]");
+	} catch {
+		return false;
+	}
+}
+/**
+* `headers` with every `${NAME}` replaced by `values[NAME]`. A header that
+* references an unset (or empty) variable is omitted rather than sent with a
+* hole in it. Returns the input unchanged when nothing references a variable,
+* and `undefined` when no header remains.
+*/
+function resolveHeaderReferences(headers, values) {
+	if (!headers) return void 0;
+	if (!Object.values(headers).some((value) => typeof value === "string" && value.includes("${"))) return headers;
+	const resolved = {};
+	for (const [name, value] of Object.entries(headers)) {
+		if (typeof value !== "string") continue;
+		let missing = null;
+		const next = value.replace(HEADER_REFERENCE, (_match, variable) => {
+			const replacement = Object.hasOwn(values, variable) ? values[variable] : "";
+			if (!replacement) missing ??= variable;
+			return replacement;
+		});
+		if (missing !== null) {
+			const warnKey = `${name}:${missing}`;
+			if (!warnedMissing.has(warnKey)) {
+				warnedMissing.add(warnKey);
+				console.warn(`[GeoLibre] Request header "${name}" references unset environment variable ${missing}; the header is not sent.`);
+			}
+			continue;
+		}
+		resolved[name] = next;
+	}
+	return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+//#endregion
 //#region src/credentials.ts
 /**
 * Project fields whose values are credentials. Keep this registry as the
@@ -9095,7 +9615,8 @@ const PUBLISHABLE_PLUGIN_SETTINGS = {
 	"maplibre-gl-swipe": null,
 	"maplibre-gl-components": ["legend", "colorbar"],
 	"maplibre-gl-time-slider": null,
-	"gods-eye-view": null
+	"gods-eye-view": null,
+	"geolibre-point-cloud-annotation": null
 };
 /**
 * Hash a credential value to a short, stable 64-bit token: two independent
@@ -9234,6 +9755,16 @@ function redactConfigurationValue(value, path, accumulator, depth = 0) {
 	const result = {};
 	for (const [key, nested] of Object.entries(value)) {
 		const nestedPath = path ? `${path}.${key}` : key;
+		const normalizedKey = normalizeCredentialName(key);
+		if ((normalizedKey === "requestheaders" || normalizedKey === "headers") && isPlainObject$1(nested)) {
+			const kept = {};
+			const removed = {};
+			for (const [name, headerValue] of Object.entries(nested)) if (typeof headerValue === "string" && isHeaderReferenceOnly(headerValue)) kept[name] = headerValue;
+			else removed[name] = headerValue;
+			if (Object.keys(removed).length > 0) recordRedaction(accumulator, nestedPath, removed);
+			if (Object.keys(kept).length > 0) result[key] = kept;
+			continue;
+		}
 		if (isCredentialFieldName(key)) {
 			recordRedaction(accumulator, nestedPath, nested);
 			continue;
@@ -9288,14 +9819,14 @@ function redactProjectCredentials(project) {
 	if (redactedMapboxStyleUrl !== mapboxStyleUrl) recordRedaction(accumulator, "preferences.map.mapboxStyleUrl", mapboxStyleUrl);
 	const preferences = project.preferences ? {
 		...project.preferences,
-		environmentVariables: [],
+		environmentVariables: (project.preferences.environmentVariables ?? []).filter((variable) => variable.secret === false),
 		geocoding,
 		...redactedMapboxStyleUrl !== mapboxStyleUrl ? { map: {
 			...project.preferences.map,
 			mapboxStyleUrl: redactedMapboxStyleUrl
 		} } : {}
 	} : project.preferences;
-	const populatedEnvironmentVariables = project.preferences?.environmentVariables?.filter((variable) => variable.key.trim()) ?? [];
+	const populatedEnvironmentVariables = project.preferences?.environmentVariables?.filter((variable) => variable.secret !== false && variable.value !== "") ?? [];
 	if (populatedEnvironmentVariables.length > 0) recordRedaction(accumulator, "preferences.environmentVariables", populatedEnvironmentVariables, populatedEnvironmentVariables.length);
 	const geocodingApiKeys = project.preferences?.geocoding?.apiKeys ?? {};
 	if (Object.keys(geocodingApiKeys).length > 0) recordRedaction(accumulator, "preferences.geocoding.apiKeys", geocodingApiKeys, Object.keys(geocodingApiKeys).length);
@@ -10280,6 +10811,7 @@ function parseProject(json) {
 	const { mapLayout, secondaryMapViews } = resolveMapGrid(normalizeMapLayout(data.mapLayout), normalizeSecondaryMapViews(data.secondaryMapViews), { mapView });
 	const styleLibrary = normalizeStyleLibraryEntries(data.styleLibrary);
 	const parsedComments = normalizeProjectComments(data.comments);
+	const parsedInteraction = normalizeProjectInteraction(data.interaction);
 	return {
 		version: data.version,
 		name: data.name,
@@ -10309,6 +10841,7 @@ function parseProject(json) {
 		...normalizePrimaryRenderer(data.primaryRenderer) ? { primaryRenderer: normalizePrimaryRenderer(data.primaryRenderer) } : {},
 		...styleLibrary.length > 0 ? { styleLibrary } : {},
 		...parsedComments.length > 0 ? { comments: parsedComments } : {},
+		...parsedInteraction ? { interaction: parsedInteraction } : {},
 		metadata: data.metadata ?? {}
 	};
 }
@@ -10969,6 +11502,34 @@ function normalizeDashboardColumns(value) {
 	if (typeof value !== "number" || !Number.isFinite(value)) return 2;
 	return Math.max(1, Math.min(6, Math.trunc(value)));
 }
+/**
+* Coerce an untrusted `interaction` block into a {@link ProjectInteraction}.
+*
+* Layer ids are kept even when no such layer exists: the block is replayed
+* against whatever layers the project has when it opens, and the loader drops
+* the ones it cannot find. Control names are kept as written for the same
+* reason; the app ignores names it does not know.
+*
+* @param value - Raw `interaction` value from the project JSON or the store.
+* @returns The normalized block, or null when it carries nothing to apply.
+*/
+function normalizeProjectInteraction(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const raw = value;
+	const result = {};
+	if (raw.identify === null) result.identify = null;
+	else if (typeof raw.identify === "string" && raw.identify) result.identify = raw.identify;
+	else if (Array.isArray(raw.identify)) {
+		const ids = [...new Set(raw.identify.filter((id) => typeof id === "string" && !!id))];
+		if (ids.length > 0) result.identify = ids;
+	}
+	if (raw.controls && typeof raw.controls === "object" && !Array.isArray(raw.controls)) {
+		const controls = {};
+		for (const [name, shown] of Object.entries(raw.controls)) if (name && typeof shown === "boolean") controls[name] = shown;
+		if (Object.keys(controls).length > 0) result.controls = controls;
+	}
+	return "identify" in result || result.controls ? result : null;
+}
 function normalizeProjectPreferences(preferences) {
 	if (!preferences || typeof preferences !== "object") return DEFAULT_PROJECT_PREFERENCES;
 	const candidate = preferences;
@@ -11055,7 +11616,8 @@ function normalizeEnvironmentVariable(variable) {
 	return {
 		key,
 		value: typeof candidate.value === "string" ? candidate.value : "",
-		enabled: normalizeBoolean(candidate.enabled, true)
+		enabled: normalizeBoolean(candidate.enabled, true),
+		...candidate.secret === false ? { secret: false } : {}
 	};
 }
 const PROJECT_PLUGIN_CONTROL_POSITIONS = /* @__PURE__ */ new Set([
@@ -11251,6 +11813,7 @@ function projectFromStore(state) {
 	const processingHistory = normalizeProcessingHistory(state.processingHistory);
 	const widgets = normalizeWidgets(state.widgets);
 	const comments = normalizeProjectComments(state.comments);
+	const interaction = normalizeProjectInteraction(state.interaction);
 	const dashboardColumns = state.dashboardColumns === void 0 ? 2 : normalizeDashboardColumns(state.dashboardColumns);
 	const layerGroups = state.layerGroups ?? [];
 	const { mapLayout, secondaryMapViews } = resolveMapGrid(normalizeMapLayout(state.mapLayout), normalizeSecondaryMapViews(state.secondaryMapViews), { mapView: state.mapView });
@@ -11286,6 +11849,7 @@ function projectFromStore(state) {
 		...normalizePrimaryRenderer(state.primaryRenderer) ? { primaryRenderer: normalizePrimaryRenderer(state.primaryRenderer) } : {},
 		...styleLibrary.length > 0 ? { styleLibrary } : {},
 		...comments.length > 0 ? { comments } : {},
+		...interaction ? { interaction } : {},
 		metadata: state.metadata
 	};
 }
@@ -11327,6 +11891,10 @@ function prepareLayerForSave(layer) {
 		const { geojson: _geojson, ...rest } = layer;
 		layer = rest;
 	}
+	if (layer.geojson && layer.metadata.sourceKind === "maplibre-gl-vector-adopted" && hasRestorableSourceUrl(layer)) {
+		const { geojson: _geojson, ...rest } = layer;
+		layer = rest;
+	}
 	if (layer.geojson && layer.metadata.localFileReloadable === true) {
 		const { geojson: _geojson, ...rest } = layer;
 		layer = rest;
@@ -11447,6 +12015,7 @@ function applyProjectToStore(project) {
 		primaryRenderer: normalizePrimaryRenderer(project.primaryRenderer) ?? "maplibre",
 		projectStyleLibrary: normalizeStyleLibraryEntries(project.styleLibrary),
 		comments: scrubbedComments,
+		projectInteraction: normalizeProjectInteraction(project.interaction),
 		metadata: project.metadata
 	};
 }
@@ -11789,6 +12358,7 @@ const createProjectContentSlice = (set) => ({
 	widgets: [],
 	dashboardColumns: 2,
 	comments: [],
+	projectInteraction: null,
 	addComment: (comment) => set((s) => {
 		if (s.comments.some((c) => c.id === comment.id)) return s;
 		return {
@@ -12368,6 +12938,7 @@ const createProjectSlice = (set, get) => ({
 		const applied = applyProjectToStore(createEmptyProject(options.name, options));
 		set((s) => ({
 			...applied,
+			hoverTooltipsEnabled: true,
 			projectPath: null,
 			projectGeneration: s.projectGeneration + 1,
 			isDirty: false,
@@ -12375,6 +12946,7 @@ const createProjectSlice = (set, get) => ({
 			selectedFeatureId: null,
 			selectedFeatureIds: [],
 			identifyLayerId: null,
+			identifyLayerIds: null,
 			copiedLayerStyle: null,
 			pointerCoords: null,
 			pointerElevation: null,
@@ -12405,13 +12977,14 @@ const createProjectSlice = (set, get) => ({
 		const selectedLayerId = project.selectedLayerId === null ? null : typeof project.selectedLayerId === "string" && applied.layers.some((layer) => layer.id === project.selectedLayerId) ? project.selectedLayerId : applied.layers[0]?.id ?? null;
 		set((s) => ({
 			...applied,
+			hoverTooltipsEnabled: true,
 			projectPath: path,
 			projectGeneration: s.projectGeneration + 1,
 			isDirty: false,
 			selectedLayerId,
 			selectedFeatureId: null,
 			selectedFeatureIds: [],
-			identifyLayerId: null,
+			...resolveIdentifyTarget(applied.projectInteraction?.identify, applied.layers.map((layer) => layer.id)),
 			copiedLayerStyle: null,
 			pointerCoords: null,
 			pointerElevation: null,
@@ -12441,43 +13014,6 @@ const createProjectSlice = (set, get) => ({
 	}
 });
 //#endregion
-//#region src/store/session-slice.ts
-/** Reserved Identify target for querying every visible queryable layer at once. */
-const IDENTIFY_ALL_LAYERS_ID = "__geolibre_identify_all_layers__";
-const createSessionSlice = (set) => ({
-	selectedLayerId: null,
-	selectedFeatureId: null,
-	selectedFeatureIds: [],
-	identifyLayerId: null,
-	pointerCoords: null,
-	pointerElevation: null,
-	cameraAltitude: null,
-	gpsStatus: null,
-	attributeFilter: "",
-	setPointerCoords: (coords) => set(coords ? { pointerCoords: coords } : {
-		pointerCoords: null,
-		pointerElevation: null
-	}),
-	setPointerElevation: (elevation) => set({ pointerElevation: elevation }),
-	setCameraAltitude: (altitude) => set({ cameraAltitude: altitude }),
-	setGpsStatus: (fix) => set({ gpsStatus: fix }),
-	selectLayer: (id) => set({
-		selectedLayerId: id,
-		selectedFeatureId: null,
-		selectedFeatureIds: []
-	}),
-	selectFeature: (id) => set({
-		selectedFeatureId: id,
-		selectedFeatureIds: id === null ? [] : [id]
-	}),
-	selectFeatures: (ids, anchorId) => set({
-		selectedFeatureIds: ids,
-		selectedFeatureId: anchorId != null && ids.includes(anchorId) ? anchorId : ids.at(-1) ?? null
-	}),
-	setIdentifyLayer: (id) => set({ identifyLayerId: id }),
-	setAttributeFilter: (filter) => set({ attributeFilter: filter })
-});
-//#endregion
 //#region src/store/ui-slice.ts
 const createUiSlice = (set) => ({
 	ui: {
@@ -12825,20 +13361,36 @@ var ElevationFetchError = class extends Error {
 	}
 };
 /**
+* Normalize longitude into [-180, 180] degrees (handles unwrapped coordinates
+* from antimeridian cross-overs and world-copy pannings).
+*/
+function normalizeLongitude(lng) {
+	if (!Number.isFinite(lng)) return 0;
+	return ((lng + 180) % 360 + 360) % 360 - 180;
+}
+/**
+* Clamp latitude into [-90, 90] degrees.
+*/
+function clampLatitude(lat) {
+	if (!Number.isFinite(lat)) return 0;
+	return Math.min(90, Math.max(-90, lat));
+}
+/**
 * Fetch elevations (in meters) for an ordered list of coordinates.
 *
 * @param points - Coordinates as `[lng, lat]`, at most {@link MAX_POINTS_PER_REQUEST}
 * @param fetchImpl - Optional `fetch` implementation; defaults to the global `fetch`
 * @returns The elevation in meters for each input coordinate, in the same order
-* @throws {ElevationFetchError} On too many points, a network error, a non-2xx
-*   response, a malformed body, or a length mismatch
+* @throws {ElevationFetchError} On too many points, a non-finite coordinate, a
+*   network error, a non-2xx response, a malformed body, or a length mismatch
 */
 async function fetchElevations(points, fetchImpl) {
 	if (points.length === 0) return [];
 	if (points.length > 100) throw new ElevationFetchError(`Too many points: ${points.length} (max 100).`);
+	if (points.some(([lng, lat]) => !Number.isFinite(lng) || !Number.isFinite(lat))) throw new ElevationFetchError("Invalid coordinate: longitude and latitude must be finite.");
 	const doFetch = fetchImpl ?? ((url, init) => fetch(url, init));
-	const latitudes = points.map((p) => p[1].toFixed(6)).join(",");
-	const longitudes = points.map((p) => p[0].toFixed(6)).join(",");
+	const latitudes = points.map((p) => clampLatitude(p[1]).toFixed(6)).join(",");
+	const longitudes = points.map((p) => normalizeLongitude(p[0]).toFixed(6)).join(",");
 	const url = `${ENDPOINT}?latitude=${latitudes}&longitude=${longitudes}`;
 	const controller = new AbortController();
 	const timeoutId = setTimeout(() => controller.abort(), ELEVATION_REQUEST_TIMEOUT_MS);
@@ -13059,6 +13611,408 @@ function formatPixelValue(value) {
 	return String(Number(value.toPrecision(6)));
 }
 //#endregion
+//#region src/s3.ts
+/** SigV4 allows a presigned URL to live at most seven days. */
+const S3_MAX_PRESIGN_SECONDS = 604800;
+const S3_SCHEME = /^s3a?:\/\//i;
+const VIRTUAL_HOST = /^(.+)\.s3(?:[.-](?:dualstack\.)?([a-z0-9-]+))?\.amazonaws\.com(?:\.cn)?$/i;
+const PATH_HOST = /^s3(?:[.-](?:dualstack\.)?([a-z0-9-]+))?\.amazonaws\.com(?:\.cn)?$/i;
+function regionFromHost(value) {
+	if (!value || value === "external-1" || value === "dualstack") return void 0;
+	return value.toLowerCase();
+}
+/** Static-website endpoints serve HTML, not the REST API a signature targets. */
+function isWebsiteRegion(value) {
+	return Boolean(value && /^website/i.test(value));
+}
+function decodeKey(path) {
+	try {
+		return decodeURIComponent(path);
+	} catch {
+		return path;
+	}
+}
+/**
+* Parses an `s3://bucket/key` URI or an AWS S3 HTTPS object URL
+* (virtual-hosted or path-style, any region) into its bucket and key.
+* Query strings and fragments are ignored, so a presigned URL parses to the
+* object it signs.
+*
+* @param url The URL to parse.
+* @returns The bucket and key, or null when the URL is not an S3 object URL.
+*/
+function parseS3Url(url) {
+	const trimmed = url.trim();
+	if (S3_SCHEME.test(trimmed)) {
+		const rest = trimmed.replace(S3_SCHEME, "").split(/[?#]/)[0];
+		const slash = rest.indexOf("/");
+		const bucket = slash === -1 ? rest : rest.slice(0, slash);
+		const key = slash === -1 ? "" : rest.slice(slash + 1);
+		return isSafeBucketName(bucket) ? {
+			bucket,
+			key
+		} : null;
+	}
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return null;
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+	const host = parsed.hostname.toLowerCase();
+	const path = parsed.pathname.replace(/^\//, "");
+	const virtual = host.match(VIRTUAL_HOST);
+	if (virtual && !PATH_HOST.test(host)) {
+		if (isWebsiteRegion(virtual[2])) return null;
+		const region = regionFromHost(virtual[2]);
+		return {
+			bucket: virtual[1],
+			key: decodeKey(path),
+			...region ? { region } : {}
+		};
+	}
+	const pathStyle = host.match(PATH_HOST);
+	if (pathStyle) {
+		if (isWebsiteRegion(pathStyle[1])) return null;
+		const slash = path.indexOf("/");
+		const bucket = slash === -1 ? path : path.slice(0, slash);
+		if (!bucket) return null;
+		const region = regionFromHost(pathStyle[1]);
+		return {
+			bucket: decodeKey(bucket),
+			key: slash === -1 ? "" : decodeKey(path.slice(slash + 1)),
+			...region ? { region } : {}
+		};
+	}
+	return null;
+}
+/**
+* Bucket names are letters, digits, dots, dashes, and underscores (the last
+* two outside AWS's own rules, for S3-compatible stores). Anything else, a
+* backslash or `@` say, could move a virtual-hosted URL's authority to
+* another host before a signature is attached, so it is refused outright.
+*/
+const SAFE_BUCKET_NAME = /^[A-Za-z0-9._-]{1,255}$/;
+function isSafeBucketName(bucket) {
+	return SAFE_BUCKET_NAME.test(bucket);
+}
+/** Whether `url` is an `s3://` URI (as opposed to an HTTPS object URL). */
+function isS3Uri(url) {
+	return S3_SCHEME.test(url.trim());
+}
+/** Formats a location as an `s3://bucket/key` URI. */
+function formatS3Uri(location) {
+	return `s3://${location.bucket}/${location.key}`;
+}
+/**
+* URI-encodes a key the way SigV4 canonicalizes an S3 path: every byte except
+* the unreserved set and `/` is percent-encoded, once.
+*/
+function encodeS3Key(key) {
+	return key.split("/").map((segment) => encodeURIComponent(segment).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
+}
+/** A custom endpoint's path, without a trailing slash ("" for none). */
+function endpointPathPrefix(base) {
+	return base.pathname.replace(/\/+$/, "");
+}
+/**
+* Builds the HTTPS URL of an object.
+*
+* AWS buckets whose name contains a dot are addressed path-style, since the
+* `*.s3.amazonaws.com` wildcard certificate covers one label only.
+*
+* @param location The bucket and key.
+* @param config The endpoint; without one the global AWS endpoint is used.
+* @returns The unsigned object URL.
+*/
+function s3ObjectHttpsUrl(location, config = {}) {
+	if (location.bucket && !isSafeBucketName(location.bucket)) throw new Error(`Invalid S3 bucket name: ${location.bucket}`);
+	const key = encodeS3Key(location.key);
+	const endpoint = config.endpoint?.trim().replace(/\/+$/, "");
+	if (!location.bucket) {
+		if (endpoint) {
+			const base = new URL(endpoint.includes("://") ? endpoint : `https://${endpoint}`);
+			return `${base.protocol}//${base.host}${endpointPathPrefix(base)}/`;
+		}
+		const serviceRegion = config.region || location.region;
+		return serviceRegion && serviceRegion !== "us-east-1" ? `https://s3.${serviceRegion}.amazonaws.com/` : "https://s3.amazonaws.com/";
+	}
+	if (endpoint) {
+		const base = new URL(endpoint.includes("://") ? endpoint : `https://${endpoint}`);
+		const prefix = endpointPathPrefix(base);
+		return config.pathStyle ? `${base.protocol}//${base.host}${prefix}/${encodeS3Key(location.bucket)}/${key}` : `${base.protocol}//${location.bucket}.${base.host}${prefix}/${key}`;
+	}
+	const region = config.region || location.region;
+	const host = region && region !== "us-east-1" ? `s3.${region}.amazonaws.com` : "s3.amazonaws.com";
+	if (config.pathStyle || location.bucket.includes(".")) return `https://${host}/${encodeS3Key(location.bucket)}/${key}`;
+	return `https://${location.bucket}.${host}/${key}`;
+}
+const encoder = new TextEncoder();
+function toHex(buffer) {
+	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(value) {
+	return toHex(await crypto.subtle.digest("SHA-256", encoder.encode(value)));
+}
+async function hmac(key, value) {
+	const cryptoKey = await crypto.subtle.importKey("raw", key, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return crypto.subtle.sign("HMAC", cryptoKey, encoder.encode(value));
+}
+/** RFC 3986 encoding, as SigV4 requires for query names and values. */
+function encodeRfc3986(value) {
+	return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function amzDate(date) {
+	const stamp = date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+	return {
+		stamp,
+		day: stamp.slice(0, 8)
+	};
+}
+/**
+* Presigns an S3 request with AWS Signature Version 4 in the query string.
+* Runs on WebCrypto, so it works in the browser, the Tauri webview, and Node.
+*
+* The URL authorizes exactly one method: a GET URL cannot answer a HEAD, so
+* readers that probe with HEAD need a GET range request instead.
+*
+* @param options The object URL, region, credentials, and lifetime.
+* @returns The presigned URL.
+*/
+async function presignS3Url(options) {
+	const { credentials, region } = options;
+	const method = (options.method ?? "GET").toUpperCase();
+	const url = new URL(options.url);
+	const { stamp, day } = amzDate(options.now ?? /* @__PURE__ */ new Date());
+	const scope = `${day}/${region}/s3/aws4_request`;
+	const expiresIn = Math.max(1, Math.min(S3_MAX_PRESIGN_SECONDS, Math.floor(options.expiresIn)));
+	const params = [];
+	url.searchParams.forEach((value, name) => {
+		if (!name.toLowerCase().startsWith("x-amz-")) params.push([name, value]);
+	});
+	params.push(["X-Amz-Algorithm", "AWS4-HMAC-SHA256"], ["X-Amz-Credential", `${credentials.accessKeyId}/${scope}`], ["X-Amz-Date", stamp], ["X-Amz-Expires", String(expiresIn)], ["X-Amz-SignedHeaders", "host"]);
+	if (credentials.sessionToken) params.push(["X-Amz-Security-Token", credentials.sessionToken]);
+	const canonicalQuery = params.map(([name, value]) => [encodeRfc3986(name), encodeRfc3986(value)]).sort(([a, av], [b, bv]) => a < b ? -1 : a > b ? 1 : av < bv ? -1 : av > bv ? 1 : 0).map(([name, value]) => `${name}=${value}`).join("&");
+	const canonicalPath = url.pathname || "/";
+	const stringToSign = [
+		"AWS4-HMAC-SHA256",
+		stamp,
+		scope,
+		await sha256Hex([
+			method,
+			canonicalPath,
+			canonicalQuery,
+			`host:${url.host}\n`,
+			"host",
+			"UNSIGNED-PAYLOAD"
+		].join("\n"))
+	].join("\n");
+	const signature = toHex(await hmac(await hmac(await hmac(await hmac(await hmac(encoder.encode(`AWS4${credentials.secretAccessKey}`), day), region), "s3"), "aws4_request"), stringToSign));
+	return `${url.origin}${canonicalPath}?${canonicalQuery}&X-Amz-Signature=${signature}`;
+}
+let activeSigner = null;
+/** Presigned URL → the unsigned URL it was minted for. Bounded. */
+const sourceBySignedHref = /* @__PURE__ */ new Map();
+const SIGNED_SOURCE_LIMIT = 500;
+/** Installs (or with null, removes) the app's S3 signer. */
+function registerS3UrlSigner(signer) {
+	activeSigner = signer;
+}
+/**
+* Whether reading `url` needs the S3 signer: it names an S3 object in a bucket
+* a configured connection covers.
+*/
+function isCredentialedS3Url(url) {
+	if (!activeSigner) return false;
+	const location = parseS3Url(url);
+	return Boolean(location && activeSigner.covers(location.bucket));
+}
+/** Records that `signedHref` reads `sourceUrl`, so a layer can keep the latter. */
+function rememberSignedSource(signedHref, sourceUrl) {
+	sourceBySignedHref.delete(signedHref);
+	if (sourceBySignedHref.size >= SIGNED_SOURCE_LIMIT) {
+		const oldest = sourceBySignedHref.keys().next().value;
+		if (oldest !== void 0) sourceBySignedHref.delete(oldest);
+	}
+	sourceBySignedHref.set(signedHref, sourceUrl);
+}
+/** Removes the SigV4 query parameters (credential, token, signature) from a URL. */
+function stripPresignParameters(url) {
+	try {
+		const parsed = new URL(url);
+		for (const name of [...parsed.searchParams.keys()]) if (name.toLowerCase().startsWith("x-amz-")) parsed.searchParams.delete(name);
+		return parsed.href;
+	} catch {
+		return url;
+	}
+}
+function unsignedSourceUrl(url) {
+	if (url === void 0) return void 0;
+	const known = sourceBySignedHref.get(url);
+	if (known !== void 0) return known;
+	if (!/[?&]x-amz-signature=/i.test(url)) return url;
+	const location = parseS3Url(url);
+	return location && !/[?#]/.test(location.key) ? formatS3Uri(location) : stripPresignParameters(url);
+}
+/**
+* Resolves a data URL into one a plain HTTP reader can fetch:
+*
+* - an S3 object in a bucket a configured connection covers → a presigned URL;
+* - any other `s3://` URI → the public HTTPS object URL (anonymous read);
+* - anything else → unchanged.
+*
+* @param url The URL a layer or query names.
+* @param signal Aborts a pending credential lookup.
+* @returns The URL to hand the reader.
+* @throws When the bucket is covered but its credentials cannot be resolved.
+*/
+async function resolveReadableUrl(url, signal) {
+	const location = parseS3Url(url);
+	if (!location) return url;
+	if (activeSigner?.covers(location.bucket)) {
+		const signed = await activeSigner.presign({
+			bucket: location.bucket,
+			key: location.key,
+			region: location.region
+		}, signal);
+		if (signed) {
+			rememberSignedSource(signed.href, url);
+			return signed.href;
+		}
+	}
+	return isS3Uri(url) ? s3ObjectHttpsUrl(location) : url;
+}
+/** The installed signer, for the S3 browser. */
+function getS3UrlSigner() {
+	return activeSigner;
+}
+function decodeXmlText(value) {
+	return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code))).replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16))).replace(/&amp;/g, "&");
+}
+function xmlTag(block, tag) {
+	const match = block.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+	return match ? decodeXmlText(match[1]) : void 0;
+}
+function xmlBlocks(xml, tag) {
+	return Array.from(xml.matchAll(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "g")), (m) => m[1]);
+}
+/**
+* Parses a ListObjectsV2 XML body. S3's listing XML is flat and predictable,
+* so this reads it with patterns rather than an XML DOM, which keeps it usable
+* in workers and Node tests.
+*/
+function parseS3ListObjects(xml) {
+	const prefixes = xmlBlocks(xml, "CommonPrefixes").map((block) => xmlTag(block, "Prefix")).filter((value) => Boolean(value));
+	const objects = xmlBlocks(xml, "Contents").flatMap((block) => {
+		const key = xmlTag(block, "Key");
+		if (key === void 0) return [];
+		const lastModified = xmlTag(block, "LastModified");
+		return [{
+			key,
+			size: Number(xmlTag(block, "Size") ?? 0),
+			...lastModified ? { lastModified } : {}
+		}];
+	});
+	const truncated = xmlTag(xml, "IsTruncated") === "true";
+	const token = xmlTag(xml, "NextContinuationToken");
+	return {
+		prefixes,
+		objects,
+		...truncated && token ? { nextContinuationToken: token } : {}
+	};
+}
+/** The error code and message of an S3 XML error body, when it is one. */
+function parseS3Error(xml) {
+	const block = xmlBlocks(xml, "Error")[0];
+	if (block === void 0) return null;
+	const endpoint = xmlTag(block, "Endpoint");
+	const region = xmlTag(block, "Region") ?? (endpoint ? parseS3Url(`https://${endpoint}/`)?.region : void 0);
+	return {
+		code: xmlTag(block, "Code") ?? "Error",
+		message: xmlTag(block, "Message") ?? "",
+		...region ? { region } : {}
+	};
+}
+/** Bucket names from a ListBuckets (`GET /` on the service) XML body. */
+function parseS3BucketList(xml) {
+	return xmlBlocks(xml, "Bucket").map((block) => xmlTag(block, "Name")).filter((name) => Boolean(name));
+}
+/**
+* How browsers word a request they blocked or could not complete, plus the
+* readers that already guess at CORS themselves (maplibre-gl-lidar's message
+* tells the user to use a file picker, which is wrong for a bucket).
+*/
+const NETWORK_FAILURE = /failed to fetch|networkerror|load failed|network request failed|err_failed|cross-origin|\bcors\b/i;
+function errorText(error) {
+	const parts = [];
+	let current = error;
+	for (let depth = 0; current && depth < 4; depth += 1) {
+		parts.push(current instanceof Error ? `${current.name}: ${current.message}` : String(current));
+		current = current instanceof Error ? current.cause : null;
+	}
+	return parts.join(" | ");
+}
+/** A read the bucket's CORS configuration blocked. */
+var S3CorsError = class extends Error {
+	bucket;
+	origin;
+	constructor(message, bucket, origin, cause) {
+		super(message, { cause });
+		this.name = "S3CorsError";
+		this.bucket = bucket;
+		this.origin = origin;
+	}
+};
+/**
+* Explains why reading an S3 object failed when the browser only said
+* "Failed to fetch". A browser reports a request the bucket's CORS rules
+* blocked exactly like a network outage, so this repeats the request twice:
+* normally, where success means the failure was transient; then in `no-cors`
+* mode, which CORS cannot block. Only when the first fails and the second gets
+* an answer is the bucket's CORS configuration the cause.
+*
+* @param url The `s3://` URI or object URL that was being read.
+* @param error What the reader threw.
+* @param translate Turns the message into the UI language.
+* @returns An {@link S3CorsError} naming the bucket and the origin to allow,
+*   or `error` unchanged when it is not a CORS refusal of an S3 read.
+*/
+async function explainS3ReadError(url, error, translate) {
+	const location = parseS3Url(url);
+	if (!location || error instanceof S3CorsError) return error;
+	if (!NETWORK_FAILURE.test(errorText(error))) return error;
+	if (typeof fetch !== "function" || typeof window === "undefined") return error;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), 1e4);
+	try {
+		const href = await resolveReadableUrl(url);
+		const probe = {
+			signal: controller.signal,
+			cache: "no-store"
+		};
+		if (await fetch(href, probe).then(() => true, () => false)) return error;
+		await fetch(href, {
+			...probe,
+			mode: "no-cors"
+		});
+	} catch {
+		return error;
+	} finally {
+		controller.abort();
+		clearTimeout(timer);
+	}
+	const origin = window.location.origin;
+	const fallback = `The bucket "${location.bucket}" does not allow reads from ${origin}: its CORS configuration is missing or does not list this origin. Add a CORS rule that allows GET and HEAD from this origin and exposes Content-Length, Content-Range, and ETag (see Settings > Cloud Storage).`;
+	return new S3CorsError(translate ? translate("s3Browser.corsError", fallback, {
+		bucket: location.bucket,
+		origin
+	}) : fallback, location.bucket, origin, error);
+}
+//#endregion
 //#region src/storymap-sample.ts
 const SAMPLE_ASSET_BASE = "https://opengeos.org/maplibre-gl-storymaps/assets";
 /**
@@ -14465,6 +15419,184 @@ function persistedThreeDTilesRequestHeaders(url, headers) {
 	return nonEmptyRecord(stripGoogleMapsApiKeyHeader(headers));
 }
 //#endregion
+//#region src/project-credential-refs.ts
+/**
+* Credentials a project refers to by name rather than carrying inline.
+*
+* On the desktop app the geocoding API keys and secret environment variables
+* of a project live in the OS keychain, keyed device-wide by provider id /
+* variable name. The project file keeps the names with empty values. Request
+* headers never go there: they reference variables as `${NAME}` instead (see
+* `resolveProjectHeaderReferences`). This module is the pure half of that
+* scheme: the account names, the overlay that fills empty values from the
+* stored ones, and the split that moves values out of a project before it is
+* written. The app installs the lookup; without one (web, Jupyter) every
+* function here is the identity, so values stay in the project file.
+*
+* A non-empty value in the project always wins over the stored one: a file
+* that still carries plaintext (older files, the web build) is used as-is for
+* the session.
+*/
+function geocodingApiKeyAccount(providerId) {
+	return `project.geocoding.apiKey.${providerId}`;
+}
+function environmentVariableAccount(key) {
+	return `project.env.${key}`;
+}
+/** Rows are secret unless explicitly marked `secret: false`. */
+function isSecretEnvironmentVariable(variable) {
+	return variable.secret !== false;
+}
+let projectCredentialLookup = null;
+/** Install (or clear, with `null`) the source of stored project credentials. */
+function setProjectCredentialLookup(lookup) {
+	projectCredentialLookup = lookup;
+}
+/** The stored value for `account`, or `undefined` when none (or no lookup). */
+function lookupProjectCredential(account) {
+	const value = projectCredentialLookup?.(account);
+	return value ? value : void 0;
+}
+/** Fill empty geocoding API keys from the stored ones. */
+function overlayStoredGeocodingApiKeys(geocoding) {
+	let apiKeys = null;
+	for (const { id } of GEOCODING_PROVIDERS) {
+		if (geocoding.apiKeys[id]?.trim()) continue;
+		const stored = lookupProjectCredential(geocodingApiKeyAccount(id));
+		if (!stored) continue;
+		apiKeys ??= { ...geocoding.apiKeys };
+		apiKeys[id] = stored;
+	}
+	return apiKeys ? {
+		...geocoding,
+		apiKeys
+	} : geocoding;
+}
+/** Fill empty secret environment variable values from the stored ones. */
+function overlayStoredEnvironmentVariables(variables) {
+	let changed = false;
+	const overlaid = variables.map((variable) => {
+		if (!isSecretEnvironmentVariable(variable) || variable.value !== "") return variable;
+		const key = variable.key.trim();
+		const stored = key ? lookupProjectCredential(environmentVariableAccount(key)) : void 0;
+		if (!stored) return variable;
+		changed = true;
+		return {
+			...variable,
+			value: stored
+		};
+	});
+	return changed ? overlaid : variables;
+}
+/** Preferences with every empty stored credential filled in. */
+function overlayStoredPreferenceCredentials(preferences) {
+	const geocoding = overlayStoredGeocodingApiKeys(preferences.geocoding);
+	const environmentVariables = overlayStoredEnvironmentVariables(preferences.environmentVariables);
+	if (geocoding === preferences.geocoding && environmentVariables === preferences.environmentVariables) return preferences;
+	return {
+		...preferences,
+		geocoding,
+		environmentVariables
+	};
+}
+/**
+* The credential changes an edited Settings draft makes, keyed by account
+* (`""` deletes).
+*
+* - `seeded`: the overlaid preferences the dialog opened with.
+* - `next`: the normalized draft being saved.
+*
+* Only values the user changed are returned, so an untouched session override
+* (plaintext from the opened file) stays out of the keychain and opening a
+* file never writes it. Removing, renaming, or un-secreting a variable never
+* deletes its stored value: names are shared by every project on the device.
+* Clearing a field deletes the stored value only when the field showed that
+* stored value; clearing a file override that differed from it just drops the
+* override, so the shared value applies again and other projects keep it.
+*/
+function changedPreferenceCredentials(seeded, next) {
+	const changes = {};
+	const record = (account, seededValue, nextValue) => {
+		if (nextValue === seededValue) return;
+		if (nextValue === "" && seededValue !== lookupProjectCredential(account)) return;
+		changes[account] = nextValue;
+	};
+	const providerIds = /* @__PURE__ */ new Set([...Object.keys(seeded.geocoding.apiKeys), ...Object.keys(next.geocoding.apiKeys)]);
+	for (const providerId of providerIds) record(geocodingApiKeyAccount(providerId), seeded.geocoding.apiKeys[providerId]?.trim() ?? "", next.geocoding.apiKeys[providerId]?.trim() ?? "");
+	const seededSecrets = /* @__PURE__ */ new Map();
+	for (const variable of seeded.environmentVariables) {
+		if (!isSecretEnvironmentVariable(variable) || seededSecrets.has(variable.key)) continue;
+		seededSecrets.set(variable.key, variable.value);
+	}
+	for (const variable of next.environmentVariables) {
+		if (!isSecretEnvironmentVariable(variable)) continue;
+		const seededValue = seededSecrets.get(variable.key);
+		if (seededValue === void 0 && variable.value === "") continue;
+		record(environmentVariableAccount(variable.key), seededValue ?? "", variable.value);
+	}
+	return changes;
+}
+/**
+* Move unambiguous geocoding API keys and secret environment variable values
+* out of `project` (a copy; the input is untouched) into `secrets`, keyed by
+* account. Secret environment rows that have no unique name remain in the
+* project for an explicit keep/strip choice. Layers pass through: their
+* request headers reference variables as `${NAME}` rather than holding
+* secrets that need moving.
+*/
+function splitProjectCredentials(project) {
+	const secrets = {};
+	for (const [providerId, apiKey] of Object.entries(project.preferences.geocoding.apiKeys)) {
+		const trimmed = apiKey.trim();
+		if (trimmed) secrets[geocodingApiKeyAccount(providerId)] = trimmed;
+	}
+	const nameCounts = /* @__PURE__ */ new Map();
+	for (const variable of project.preferences.environmentVariables) {
+		const key = variable.key.trim();
+		if (key) nameCounts.set(key, (nameCounts.get(key) ?? 0) + 1);
+	}
+	const environmentVariables = project.preferences.environmentVariables.map((variable) => {
+		if (!isSecretEnvironmentVariable(variable) || variable.value === "") return variable;
+		const key = variable.key.trim();
+		if (!key || (nameCounts.get(key) ?? 0) > 1) return variable;
+		secrets[environmentVariableAccount(key)] = variable.value;
+		return {
+			...variable,
+			value: ""
+		};
+	});
+	return {
+		project: {
+			...project,
+			preferences: {
+				...project.preferences,
+				geocoding: {
+					...project.preferences.geocoding,
+					apiKeys: {}
+				},
+				environmentVariables
+			}
+		},
+		secrets
+	};
+}
+/**
+* `headers` with every `${NAME}` resolved from the project's enabled
+* Environment Variables (stored secret values filled in). Only those rows
+* count, not the OS environment or build-time values that share the runtime
+* env. A header referencing an unset variable is dropped.
+*/
+function resolveProjectHeaderReferences(headers) {
+	if (!headers) return headers;
+	const values = {};
+	const variables = overlayStoredEnvironmentVariables(useAppStore.getState().preferences.environmentVariables);
+	for (const variable of variables) {
+		const key = variable.key.trim();
+		if (variable.enabled && key) values[key] = variable.value;
+	}
+	return resolveHeaderReferences(headers, values);
+}
+//#endregion
 //#region src/visibility.ts
 /**
 * Returns a new FeatureCollection with properties marked as "excluded" removed.
@@ -14744,6 +15876,6 @@ function currentEditorIdentity() {
 	return pickEditorIdentity(isActive ? selfName : void 0, readStoredAuthorName());
 }
 //#endregion
-export { ALL_APP_PRIVILEGES, ALL_DEPLOYMENT_CAPABILITIES, BLANK_BASEMAP, BLEND_MODES, BUILT_IN_STYLE_PRESETS, CARTOCIUDAD_MIN_INTERVAL_MS, CARTOCIUDAD_PUBLIC_HOST, CESIUM_BASEMAPS, CESIUM_BING_AERIAL_ASSET_ID, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID, CESIUM_ION_QUICK_PICKS, CESIUM_ION_SOURCE_KIND, CESIUM_KML_SOURCE_KIND, CESIUM_OSM_BUILDINGS_ASSET_ID, CHINA_BASEMAPS, CZML_QUICK_PICKS, CZML_SOURCE_KIND, DEFAULT_BASEMAP, DEFAULT_BLEND_MODE, DEFAULT_COLLABORATION_STATE, DEFAULT_DASHBOARD_COLUMNS, DEFAULT_EDITOR_IDENTITY, DEFAULT_EDITOR_TRACKING_CONFIG, DEFAULT_ELLIPSOID_ID, DEFAULT_FORWARD_GEOCODE_ENDPOINT, DEFAULT_GEOCODING_PROVIDER_ID, DEFAULT_LAYER_GROUP_OPACITY, DEFAULT_LAYER_STYLE, DEFAULT_LEGEND_CONFIG, DEFAULT_MAP_GRID_LAYOUT, DEFAULT_PRIMARY_RENDERER, DEFAULT_PRINT_LAYOUT, DEFAULT_PROJECT_NAME, DEFAULT_PROJECT_PREFERENCES, DEFAULT_REVERSE_GEOCODE_ENDPOINT, DEFAULT_ROUTING_ENDPOINT, DEFAULT_STORY_MAP, DEPLOYMENT_CAPABILITIES, DUCKDB_VECTOR_FEATURE_WARN_COUNT, DUCKDB_VECTOR_ROUTE_BYTES, EARTH_MEAN_RADIUS_METERS, EDITOR_IDENTITY_STORAGE_KEY, ELEVATION_REQUEST_TIMEOUT_MS, ELLIPSOIDS, EXPRESSION_FUNCTION_CATEGORIES, ElevationFetchError, FEET_PER_METER, FEET_PER_MILE, GEOCODE_DISPLAY_NAME_KEY, GEOCODE_LAT_KEY, GEOCODE_LON_KEY, GEOCODE_PROVIDER_KEY, GEOCODE_SCORE_KEY, GEOCODE_STATUS_KEY, GEOCODING_PROVIDERS, GOOGLE_MAPS_API_KEY_HEADER, IDENTIFY_ALL_LAYERS_ID, LABEL_NUMBER_LOCALES, LABEL_NUMBER_SAMPLE, LARGE_VECTOR_FEATURE_THRESHOLD, LAYER_LIBRARY_BUNDLE_TYPE, LAYER_LIBRARY_BUNDLE_VERSION, LAYER_PALETTE, LAYER_TYPES, MAX_DASHBOARD_COLUMNS, MAX_DIAGRAM_FEATURES, MAX_DIAGRAM_SCAN_FEATURES, MAX_LAYER_LIBRARY_ENTRIES, MAX_LAYER_LIBRARY_ENTRY_BYTES, MAX_MAP_GRID_DIM, MAX_POINTS_PER_REQUEST, MAX_PROCESSING_HISTORY, MAX_REDACT_DEPTH, MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0, METERS_PER_FOOT, METERS_PER_MILE, METERS_PER_NAUTICAL_MILE, MIN_DASHBOARD_COLUMNS, MIN_DIAGRAM_SIZE, NETCDF_IMAGE_SOURCE_KIND, NOMINATIM_MIN_INTERVAL_MS, NOMINATIM_PUBLIC_HOST, NO_DEPLOYMENT_CAPABILITIES, NO_LAYERS, OPENFREEMAP_BASEMAPS, PHOTO_FULL_PROPERTY, PHOTO_PROPERTY, PLANETARY_BASEMAPS, PLANETARY_BASEMAP_GROUPS, PLANETARY_BASEMAP_SENTINEL_PREFIX, PLANET_SWITCHER_OPTIONS, POINTER_ELEVATION_CACHE_LIMIT, POINTER_ELEVATION_DEBOUNCE_MS, POPUP_IMAGE_HEIGHT_RANGE, POPUP_MAX_WIDTH_RANGE, PROJECT_CREDENTIAL_FIELDS, PROJECT_VERSION, PROTOMAPS_BASEMAPS, PUBLIC_GEOCODE_ROW_CAP, PUBLISHABLE_PLUGIN_SETTINGS, RAMP_STYLE_KEYS, RASTER_APPEARANCE_STATE_KEYS, REGIONAL_BASEMAPS, REGIONAL_BASEMAP_GROUPS, REGIONAL_BASEMAP_SENTINEL_PREFIX, ROLE_PRIVILEGES, RoutingRequestError, 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, createProjectLayerSerializationCache, 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, getArcgisApiKey, 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, layerGroupSortability, 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, portableWmsTileUrl, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, removeTrailingJsonCommas, rendererAppliesOpacity, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveConfiguredPopupTitle, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveLabelNumberLocale, resolveLayerCapabilities, resolveMapGrid, resolvePopupBody, resolvePopupImageHeight, resolvePopupMaxWidth, resolvePopupRows, resolvePopupTitle, resolveRolePrivileges, resolveSvgSource, resolveThreeDTilesRequestHeaders, rgbToHex, routeResponseToFeatures, rowCap, ruleBasedColorExpression, ruleBasedVisibilityFilter, sameCesiumImagery, sampleMapTerrain, sampleMapTerrainPoint, sampleRemoteElevations, sanitizeLayerStylePatch, scaleAltitudeToActiveBody, scaleDenomination, scaleSpan, scrubCommentsForRemovedLayers, scrubLegendForRemovedLayers, scrubPrintLayoutForLayers, scrubPrintLayoutForRemovedLayers, scrubWidgetsForRemovedLayers, selectLayerById, selectLayerIds, selectLayerSummaries, selectLayersWhen, serializeLayerLibrary, serializeProject, serializeProjectWithLayerCache, serializeStoryMapCsv, serializeStoryMapJson, serializeStyleLibrary, setActiveEllipsoidId, setExternalNativePaintBridge, setGeocodingFetch, setHistoryCoalesceMs, setMaxHistoryFeatureCount, setStoredAuthorName, shouldThrottle, shouldUseTiledRendering, simpleStyleNumberValue, sortLayerGroupInPanel, stampFeatureCollectionEditorTracking, stampFeatureEditorTracking, stampFeaturePropertiesEditorTracking, storyLayerOpacityFactor, storyMapHasContent, storyVisibleLayers, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, uniqueImportedLayerName, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, useAppCapability, useAppStore, useLayer, useLayerIds, useLayerSummaries, useLayersWhen, validateAttributeFormField, validateAttributeFormValues, validateMapExpression, valueMapLabelFor, valueMapToText, vectorCircleColorValue, vectorColorExpression, vectorFillColorValue, vectorFillOpacityValue, vectorLineColorValue, vectorOutlineColorValue, vectorStrokeWidthValue, visiblePopupFields, visiblePopupProperties };
+export { ALL_APP_PRIVILEGES, ALL_DEPLOYMENT_CAPABILITIES, BLANK_BASEMAP, BLEND_MODES, BUILT_IN_STYLE_PRESETS, CARTOCIUDAD_MIN_INTERVAL_MS, CARTOCIUDAD_PUBLIC_HOST, CESIUM_BASEMAPS, CESIUM_BING_AERIAL_ASSET_ID, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID, CESIUM_ION_QUICK_PICKS, CESIUM_ION_SOURCE_KIND, CESIUM_KML_SOURCE_KIND, CESIUM_OSM_BUILDINGS_ASSET_ID, CHINA_BASEMAPS, CZML_QUICK_PICKS, CZML_SOURCE_KIND, DEFAULT_BASEMAP, DEFAULT_BLEND_MODE, DEFAULT_COLLABORATION_STATE, DEFAULT_DASHBOARD_COLUMNS, DEFAULT_EDITOR_IDENTITY, DEFAULT_EDITOR_TRACKING_CONFIG, DEFAULT_ELLIPSOID_ID, DEFAULT_FORWARD_GEOCODE_ENDPOINT, DEFAULT_GEOCODING_PROVIDER_ID, DEFAULT_LAYER_GROUP_OPACITY, DEFAULT_LAYER_STYLE, DEFAULT_LEGEND_CONFIG, DEFAULT_MAP_GRID_LAYOUT, DEFAULT_PRIMARY_RENDERER, DEFAULT_PRINT_LAYOUT, DEFAULT_PROJECT_NAME, DEFAULT_PROJECT_PREFERENCES, DEFAULT_REVERSE_GEOCODE_ENDPOINT, DEFAULT_ROUTING_ENDPOINT, DEFAULT_STORY_MAP, DEPLOYMENT_CAPABILITIES, DUCKDB_VECTOR_FEATURE_WARN_COUNT, DUCKDB_VECTOR_ROUTE_BYTES, EARTH_MEAN_RADIUS_METERS, EDITOR_IDENTITY_STORAGE_KEY, ELEVATION_REQUEST_TIMEOUT_MS, ELLIPSOIDS, EXPRESSION_FUNCTION_CATEGORIES, ElevationFetchError, FEET_PER_METER, FEET_PER_MILE, GEOCODE_DISPLAY_NAME_KEY, GEOCODE_LAT_KEY, GEOCODE_LON_KEY, GEOCODE_PROVIDER_KEY, GEOCODE_SCORE_KEY, GEOCODE_STATUS_KEY, GEOCODING_PROVIDERS, GOOGLE_MAPS_API_KEY_HEADER, IDENTIFY_ALL_LAYERS_ID, LABEL_NUMBER_LOCALES, LABEL_NUMBER_SAMPLE, LARGE_VECTOR_FEATURE_THRESHOLD, LAYER_LIBRARY_BUNDLE_TYPE, LAYER_LIBRARY_BUNDLE_VERSION, LAYER_PALETTE, LAYER_STYLES_FILE_TYPE, LAYER_STYLES_FILE_VERSION, LAYER_TYPES, MAX_DASHBOARD_COLUMNS, MAX_DIAGRAM_FEATURES, MAX_DIAGRAM_SCAN_FEATURES, MAX_LAYER_LIBRARY_ENTRIES, MAX_LAYER_LIBRARY_ENTRY_BYTES, MAX_MAP_GRID_DIM, MAX_POINTS_PER_REQUEST, MAX_PROCESSING_HISTORY, MAX_REDACT_DEPTH, MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0, METERS_PER_FOOT, METERS_PER_MILE, METERS_PER_NAUTICAL_MILE, MIN_DASHBOARD_COLUMNS, MIN_DIAGRAM_SIZE, NETCDF_IMAGE_SOURCE_KIND, NOMINATIM_MIN_INTERVAL_MS, NOMINATIM_PUBLIC_HOST, NO_DEPLOYMENT_CAPABILITIES, NO_LAYERS, OPENFREEMAP_BASEMAPS, PHOTO_FULL_PROPERTY, PHOTO_PROPERTY, PLANETARY_BASEMAPS, PLANETARY_BASEMAP_GROUPS, PLANETARY_BASEMAP_SENTINEL_PREFIX, PLANET_SWITCHER_OPTIONS, POINTER_ELEVATION_CACHE_LIMIT, POINTER_ELEVATION_DEBOUNCE_MS, POPUP_IMAGE_HEIGHT_RANGE, POPUP_MAX_WIDTH_RANGE, PROJECT_CREDENTIAL_FIELDS, PROJECT_VERSION, PROTOMAPS_BASEMAPS, PUBLIC_GEOCODE_ROW_CAP, PUBLISHABLE_PLUGIN_SETTINGS, RAMP_STYLE_KEYS, RASTER_APPEARANCE_STATE_KEYS, REGIONAL_BASEMAPS, REGIONAL_BASEMAP_GROUPS, REGIONAL_BASEMAP_SENTINEL_PREFIX, ROLE_PRIVILEGES, RoutingRequestError, S3CorsError, S3_MAX_PRESIGN_SECONDS, SELECTION_MODES, SQL_QUERY_SOURCE_KIND, STYLE_LIBRARY_BUNDLE_TYPE, STYLE_LIBRARY_BUNDLE_VERSION, SYMBOL_STYLE_KEYS, VECTOR_COLOR_RAMPS, activeLayerFilterExpression, activeQuickFilters, allowsCredentialHeaders, appPrivilegeReason, applyCopiedLayerStyle, applyGroupEffects, applyJoinsToLayer, applyLayerJoins, applyLayerVirtualFields, applyMatchedSelection, applyProjectToStore, applySelectionMode, applyStoryLayerOpacity, attributeFormFieldLabel, attributeLinkUrl, availableCesiumBasemap, basemapToCesiumImagery, batchDecodePolylines, bodyLengthToEarth, buildForwardGeocodeUrl, buildIsochroneRequest, buildLayerPanelUnits, buildLayerTree, buildMatrixRequest, buildReverseGeocodeUrl, buildRouteRequest, canRedoProjectRestore, canSaveLayerToLibrary, canUndoProjectRestore, captureLayerLibraryEntry, cascadeLayerJoinRefresh, cesiumIonAssetId, cesiumIonAssetKind, cesiumKmlSource, changedPreferenceCredentials, circleRadiusValue, clampLabelDecimals, clampLatitude, clearExternalNativePaintBridge, clearHistory, clearQuickFilterValues, coerceAttributeFormValue, collectDiagramData, collectTransitiveJoinSourceIds, compareSequenceValues, compileFeatureExpression, compileLayerFilters, compileQuickFilter, compileQuickFilters, controlRendersLayer, copyableLayerStyleKind, createCesiumIonLayer, createCesiumKmlLayer, createCzmlLayer, createDefaultAppCapabilities, createDefaultMapView, createDefaultPrintLayout, createEmptyProject, createEqualIntervalBreaks, createGraduatedClassBreaks, createLayerLibraryEntryId, createPointerElevationResolver, createProjectLayerSerializationCache, createProjectTemplate, createQuantileBreaks, createSampleStoryMap, createStyleLayerEvaluator, createStyleLibraryEntryId, csvRowsToGeocodeRequests, currentEditorIdentity, czmlSource, darkenHex, decodePolyline, decodePolylineDetailed, detachProjectCopy, detectNonGeographicCoordinates, diagramAnchor, diagramPixelSize, diagramsSuppressedByPointRenderer, documentLocale, dominantGeometry, drawMarkerPath, earthAreaToBody, earthLengthToBody, editorTrackingFieldNames, effectiveLayerRenderState, effectiveVectorRules, encodePolyline, encodeS3Key, ensureEditorTrackingFields, environmentVariableAccount, evaluateMapExpression, excludeHiddenFieldsFromGeojson, excludeHiddenFieldsFromProject, explainS3ReadError, extractCopiedLayerStyle, extractLayerStyleEntries, extractStyleLibraryStyle, extrusionColorValue, extrusionHeightValue, featureSelectionId, fetchElevations, findLayerStyleEntryIndex, formatCameraAltitude, formatExpressionPreviewValue, formatLabelNumber, formatLabelNumberSample, formatPixelValue, formatPopupValue, formatRoundNum, formatS3Uri, generatorCircleRadiusValue, generatorSizeRange, geoJSONToPolylineStr, geocodeForward, geocodeMatchToFeature, geocodeReverse, geocoderMinIntervalMs, geocoderNeedsApiKey, geocodingApiKeyAccount, geojsonHasZCoordinates, getActiveBodyRadiusRatio, getActiveEllipsoid, getActiveMeanRadiusMeters, getActiveSemiMajorAxisMeters, getArcgisApiKey, getAttributeFormField, getBuildEnvironment, getCesiumIonToken, getEllipsoid, getExternalNativePaintBridge, getGeocoderConfig, getGeocodingProvider, getGoogleMapsApiKey, getHistoryCoalesceMs, getMapboxAccessToken, getMaxHistoryFeatureCount, getPlanetaryBasemapById, getPlanetaryBasemapByStyleUrl, getProtomapsApiKey, getProtomapsStyleUrl, getRegionalBasemapById, getRegionalBasemapByStyleUrl, getRoundNum, getRoutingConfig, getRuntimeEnvironment, getS3UrlSigner, getSpatialExtensionPath, getVectorColorRamp, googleMapsApiKeyHeaderValue, groupMemberIndices, hasActiveLayerFilter, hasActiveQuickFilter, hasAppPrivilege, hasHeaderReferences, hasPathTraversal, hasRestorableLayerSource, hasSimpleStyleProperties, heatmapRampColors, horizontalBbox, identifyAllIncludes, identifyStateWithoutLayers, inferFieldTypes, inferLayerCapabilities, initialLayerStyle, interpolateColors, interpolateHexColor, interpolateRampColors, intersectPrivileges, invertSelection, isAbsoluteFilesystemPath, isAdoptedVectorAwaitingFeatures, isAllowedPluginManifestUrl, isAttributeFormFieldVisible, isCesiumIonLayer, isCesiumKmlLayer, isCesiumOnlyLayer, isCredentialFieldName, isCredentialedS3Url, isCzmlLayer, isDefaultPrintLayout, isDeploymentCapability, isDiagramStyleEnabled, isDuckDBQueryLayer, isExternalNativeLayerRecord, isGooglePhotorealisticTilesetUrl, isHeaderReferenceOnly, isHexColor, isInitialLayerStyle, isInlineImageValue, isInternalPopupField, isIpadDesktopUserAgent, isMaintainedEditorTrackingField, isPopupClickEnabled, isPopupHoverEnabled, isRegionalBasemapSentinel, isS3Uri, isSafePopupUrl, isSecretEnvironmentVariable, isStoryHiddenLayer, isStyleLibraryTargetLayer, isStyleSpecColor, isVectorColorExpression, isochroneResponseToFeatures, labelFieldTextField, layerGroupDepth, layerGroupMoveability, layerGroupSortability, layerJoinKey, layerLibraryConfigPatch, layerLibraryEntryNeedsLocalFile, layerPanelGroupHeaders, lineWidthValue, localFileName, lookupProjectCredential, mapZoomStepOutputs, matchFeaturesByExpression, matchLayerStyleEntry, matrixResponseToFeatures, meanRadiusMeters, mercatorMetersPerPixelAtZoom0, metersWidthExpression, nextDelayMs, nextLayerPaletteColor, nominatimResultToFeature, nominatimReverseResultToDisplay, nonEmptyRecord, normalizeAppPrivileges, normalizeBlankBackgroundColor, normalizeCesiumBasemap, normalizeDashboardColumns, normalizeGeocodingProviderId, normalizeGroupContiguity, normalizeHexColor, normalizeLayerCapabilities, normalizeLayerLibraryEntries, normalizeLayerStyleEntries, normalizeLongitude, normalizeMapLayout, normalizeMapViewState, normalizeModelGraph, normalizeModels, normalizePrimaryRenderer, normalizePrintLayoutConfig, normalizeProcessingHistory, normalizeProjectComments, normalizeProjectInteraction, normalizeSecondaryMapViews, normalizeStoryMap, normalizeStyleLibraryEntries, normalizeWidgets, overlayStoredEnvironmentVariables, overlayStoredGeocodingApiKeys, overlayStoredPreferenceCredentials, parseCesiumIonAssetId, parseContours, parseCzml, parseDeploymentCapabilities, parseHexColor, parseHexColorList, parseJsonExpression, parseLayerLibrary, parseLayerStylesFile, parseProject, parseS3BucketList, parseS3Error, parseS3ListObjects, parseS3Url, parseStoryMapCsv, parseStoryMapJson, parseStyleLibrary, parseValueMapText, persistedThreeDTilesRequestHeaders, pickEditorIdentity, planLayerLibraryAdd, pluginOwnsPaint, polylineStrToGeoJSON, popupFieldLabel, portableWmsTileUrl, presignS3Url, printLayoutConfigsEqual, projectFromStore, projectPathLabel, proportionalRadiusExpression, proportionalSizeRange, readStoredAuthorName, reapplyLayerJoins, redactCredentials, redactProjectCredentials, redactUrlCredentials, redo, registerProjectRestoreHistory, registerS3UrlSigner, removeTrailingJsonCommas, rendererAppliesOpacity, reorderLayerGroupInPanel, requestIsochrone, requestMatrix, requestRoute, resolveConfiguredPopupTitle, resolveEditorTrackingConfig, resolveGeocoderConfig, resolveHeaderReferences, resolveIdentifyTarget, resolveLabelNumberLocale, resolveLayerCapabilities, resolveMapGrid, resolvePopupBody, resolvePopupImageHeight, resolvePopupMaxWidth, resolvePopupRows, resolvePopupTitle, resolveProjectHeaderReferences, resolveReadableUrl, resolveRolePrivileges, resolveSvgSource, resolveThreeDTilesRequestHeaders, rgbToHex, routeResponseToFeatures, rowCap, ruleBasedColorExpression, ruleBasedVisibilityFilter, s3ObjectHttpsUrl, sameCesiumImagery, sampleMapTerrain, sampleMapTerrainPoint, sampleRemoteElevations, sanitizeLayerStylePatch, scaleAltitudeToActiveBody, scaleDenomination, scaleSpan, scrubCommentsForRemovedLayers, scrubLegendForRemovedLayers, scrubPrintLayoutForLayers, scrubPrintLayoutForRemovedLayers, scrubWidgetsForRemovedLayers, selectLayerById, selectLayerIds, selectLayerSummaries, selectLayersWhen, serializeLayerLibrary, serializeLayerStylesFile, serializeProject, serializeProjectWithLayerCache, serializeStoryMapCsv, serializeStoryMapJson, serializeStyleLibrary, setActiveEllipsoidId, setExternalNativePaintBridge, setGeocodingFetch, setHistoryCoalesceMs, setMaxHistoryFeatureCount, setProjectCredentialLookup, setStoredAuthorName, shouldThrottle, shouldUseTiledRendering, simpleStyleNumberValue, sortLayerGroupInPanel, splitProjectCredentials, stampFeatureCollectionEditorTracking, stampFeatureEditorTracking, stampFeaturePropertiesEditorTracking, storyLayerOpacityFactor, storyMapHasContent, storyVisibleLayers, stringifyPopupValue, stripGoogleMapsApiKeyHeader, stripJoinFields, stripVirtualFieldColumns, styleValue, subscribeProjectRestoreHistory, substituteExpressionVariables, supportsBridgedOpacity, transformGeojsonElevation, trimHistoryBySize, undo, unescapePolyline, uniqueImportedLayerName, unmatchedGeocodeFeature, unresolvedLayerLibraryJoins, unsignedSourceUrl, useAppCapability, useAppStore, useLayer, useLayerIds, useLayerSummaries, useLayersWhen, validateAttributeFormField, validateAttributeFormValues, validateMapExpression, valueMapLabelFor, valueMapToText, vectorCircleColorValue, vectorColorExpression, vectorFillColorValue, vectorFillOpacityValue, vectorLineColorValue, vectorOutlineColorValue, vectorStrokeWidthValue, visiblePopupFields, visiblePopupProperties };
 
 //# sourceMappingURL=index.mjs.map