@geolibre/core 3.2.0 → 3.4.0

package/dist/project-diff-BD23T4xv.d.mts

@@ -0,0 +1,3803 @@
+//#region src/cesium-imagery.d.ts
+/**
+ * Maps the project's basemap onto imagery the Cesium globe can render.
+ *
+ * The 2D panes render `basemapStyleUrl` through MapLibre, which understands
+ * vector GL styles and GeoLibre's `geolibre://` sentinels. Cesium understands
+ * neither: it draws imagery from tile providers only. So a globe pane that
+ * simply mounted the store basemap would show nothing, which is why the pane
+ * used to hardcode Ion World Imagery (with a token) or OpenStreetMap (without)
+ * and ignore the user's choice entirely — leaving a bright globe beside dark 2D
+ * panes and breaking the "same map, different projection" promise the multi-map
+ * grid makes.
+ *
+ * This module is the translation. It is deliberately **engine-free** — it
+ * returns a plain descriptor and never imports Cesium — so it lives in
+ * `@geolibre/core` beside the basemap catalogs it reads, the 2D and 3D
+ * renderers share one source of truth, and the Cesium chunk boundary in
+ * `vite.config.ts` stays intact.
+ *
+ * Three outcomes are possible, and the caller has to handle all three (see
+ * {@link CesiumBasemapImagery}): tiles to draw, nothing to draw, or "no raster
+ * equivalent exists — pick your own default".
+ */
+/** Stable project IDs and the corresponding Cesium bundled thumbnails / ion assets. */
+declare const CESIUM_BASEMAPS: readonly [{
+  readonly id: "project";
+  readonly name: "Project basemap";
+  readonly icon: "naturalEarthII.png";
+}, {
+  readonly id: "natural-earth";
+  readonly name: "Natural Earth II";
+  readonly icon: "naturalEarthII.png";
+}, {
+  readonly id: "bing-aerial";
+  readonly name: "Bing Maps Aerial";
+  readonly icon: "bingAerial.png";
+  readonly assetId: 2;
+}, {
+  readonly id: "bing-labels";
+  readonly name: "Bing Maps Aerial with Labels";
+  readonly icon: "bingAerialLabels.png";
+  readonly assetId: 3;
+}, {
+  readonly id: "bing-roads";
+  readonly name: "Bing Maps Roads";
+  readonly icon: "bingRoads.png";
+  readonly assetId: 4;
+}, {
+  readonly id: "sentinel-2";
+  readonly name: "Sentinel-2";
+  readonly icon: "sentinel-2.png";
+  readonly assetId: 3954;
+}, {
+  readonly id: "blue-marble";
+  readonly name: "Blue Marble";
+  readonly icon: "blueMarble.png";
+  readonly assetId: 3845;
+}, {
+  readonly id: "earth-at-night";
+  readonly name: "Earth at night";
+  readonly icon: "earthAtNight.png";
+  readonly assetId: 3812;
+}, {
+  readonly id: "google-satellite";
+  readonly name: "Google Maps Satellite";
+  readonly icon: "googleSatellite.png";
+  readonly assetId: 3830182;
+}, {
+  readonly id: "google-labels";
+  readonly name: "Google Maps Satellite with Labels";
+  readonly icon: "googleSatelliteLabels.png";
+  readonly assetId: 3830183;
+}, {
+  readonly id: "google-roads";
+  readonly name: "Google Maps Roadmap";
+  readonly icon: "googleRoadmap.png";
+  readonly assetId: 3830184;
+}, {
+  readonly id: "google-contour";
+  readonly name: "Google Maps Contour";
+  readonly icon: "googleContour.png";
+  readonly assetId: 3830186;
+}, {
+  readonly id: "azure-aerial";
+  readonly name: "Azure Maps Aerial";
+  readonly icon: "azureAerial.png";
+  readonly assetId: 3891168;
+}, {
+  readonly id: "azure-roads";
+  readonly name: "Azure Maps Roads";
+  readonly icon: "azureRoads.png";
+  readonly assetId: 3891169;
+}, {
+  readonly id: "esri-imagery";
+  readonly name: "ArcGIS World Imagery";
+  readonly icon: "ArcGisMapServiceWorldImagery.png";
+  readonly category: "Other";
+  readonly service: "World_Imagery";
+}, {
+  readonly id: "esri-hillshade";
+  readonly name: "ArcGIS World Hillshade";
+  readonly icon: "ArcGisMapServiceWorldHillshade.png";
+  readonly category: "Other";
+  readonly service: "Elevation/World_Hillshade";
+}, {
+  readonly id: "esri-ocean";
+  readonly name: "Esri World Ocean";
+  readonly icon: "ArcGisMapServiceWorldOcean.png";
+  readonly category: "Other";
+  readonly service: "Ocean/World_Ocean_Base";
+}, {
+  readonly id: "osm";
+  readonly name: "OpenStreetMap";
+  readonly icon: "openStreetMap.png";
+  readonly category: "Other";
+}];
+type CesiumBasemapId = (typeof CESIUM_BASEMAPS)[number]["id"];
+declare function normalizeCesiumBasemap(value: unknown): CesiumBasemapId;
+/**
+ * Missing credentials fall back to keyless imagery without changing the saved
+ * choice.
+ *
+ * The fallback is ArcGIS World Imagery rather than the project background: a
+ * globe wants to look like the Earth, and the project's own basemap is usually
+ * a vector street style whose raster analogue is mostly empty ocean from
+ * orbit. It needs no key, so the globe looks the same with or without an Ion
+ * token — only terrain and the Ion-only basemaps are lost.
+ */
+declare function availableCesiumBasemap(value: unknown, hasIonToken: boolean): CesiumBasemapId;
+/**
+ * What the globe should draw underneath the project's data layers.
+ *
+ * - `xyz` — a tile template to render, with the credit and zoom bounds that go
+ *   with it.
+ * - `none` — the user chose the blank basemap; draw a bare ellipsoid.
+ * - `default` — this basemap has no raster equivalent (a custom style URL, a
+ *   provider style, an offline archive). The renderer falls back to whatever it
+ *   can offer, which is Ion World Imagery when a token is configured and
+ *   OpenStreetMap otherwise.
+ */
+type CesiumBasemapImagery = {
+  kind: "none";
+} | {
+  kind: "default";
+} | {
+  kind: "ion";
+  assetId: number;
+} | {
+  kind: "natural-earth";
+} | {
+  kind: "arcgis";
+  url: string;
+} | {
+  kind: "xyz";
+  /** Tile template with `{z}`/`{x}`/`{y}` placeholders. */
+  template: string;
+  /** Credit to show on the globe, as the HTML the 2D map already uses. */
+  attribution: string;
+  /** Max native zoom of the source, so the globe overzooms rather than 404s. */
+  maximumLevel?: number;
+  /**
+   * Tile row ordering. `"tms"` numbers rows from the bottom; absent means
+   * standard XYZ. Cesium has no `scheme` option, so a TMS template needs
+   * `{y}` swapped for its `{reverseY}` placeholder at render time.
+   */
+  scheme?: "tms";
+  /**
+   * A transparent overlay drawn directly above {@link template} — the
+   * roads-and-labels tiles a hybrid basemap (Amap Hybrid) bakes in, so one
+   * basemap selection still yields a labelled satellite globe.
+   */
+  overlayTemplate?: string;
+};
+/**
+ * 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.
+ */
+declare function sameCesiumImagery(a: CesiumBasemapImagery, b: CesiumBasemapImagery): boolean;
+/**
+ * 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.
+ */
+declare function basemapToCesiumImagery(styleUrl: string | undefined, cesiumBasemap?: CesiumBasemapId): CesiumBasemapImagery;
+//#endregion
+//#region ../../node_modules/@types/geojson/index.d.ts
+/**
+ * The value values for the "type" property of GeoJSON Objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+type GeoJsonTypes = GeoJSON$1["type"];
+/**
+ * Bounding box
+ * https://tools.ietf.org/html/rfc7946#section-5
+ */
+type BBox = [number, number, number, number] | [number, number, number, number, number, number];
+/**
+ * A Position is an array of coordinates.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.1
+ * Array should contain between two and three elements.
+ * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
+ * but the current specification only allows X, Y, and (optionally) Z to be defined.
+ *
+ * Note: the type will not be narrowed down to `[number, number] | [number, number, number]` due to
+ * marginal benefits and the large impact of breaking change.
+ *
+ * See previous discussions on the type narrowing:
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/21590|Nov 2017}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/67773|Dec 2023}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71441| Dec 2024}
+ *
+ * One can use a
+ * {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates|user-defined type guard that returns a type predicate}
+ * to determine if a position is a 2D or 3D position.
+ *
+ * @example
+ * import type { Position } from 'geojson';
+ *
+ * type StrictPosition = [x: number, y: number] | [x: number, y: number, z: number]
+ *
+ * function isStrictPosition(position: Position): position is StrictPosition {
+ *   return position.length === 2 || position.length === 3
+ * };
+ *
+ * let position: Position = [-116.91, 45.54];
+ *
+ * let x: number;
+ * let y: number;
+ * let z: number | undefined;
+ *
+ * if (isStrictPosition(position)) {
+ *   // `tsc` would throw an error if we tried to destructure a fourth parameter
+ * 	 [x, y, z] = position;
+ * } else {
+ * 	 throw new TypeError("Position is not a 2D or 3D point");
+ * }
+ */
+type Position = number[];
+/**
+ * The base GeoJSON object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ * The GeoJSON specification also allows foreign members
+ * (https://tools.ietf.org/html/rfc7946#section-6.1)
+ * Developers should use "&" type in TypeScript or extend the interface
+ * to add these foreign members.
+ */
+interface GeoJsonObject {
+  // Don't include foreign members directly into this type def.
+  // in order to preserve type safety.
+  // [key: string]: any;
+  /**
+   * Specifies the type of GeoJSON object.
+   */
+  type: GeoJsonTypes;
+  /**
+   * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
+   * The value of the bbox member is an array of length 2*n where n is the number of dimensions
+   * represented in the contained geometries, with all axes of the most southwesterly point
+   * followed by all axes of the more northeasterly point.
+   * The axes order of a bbox follows the axes order of geometries.
+   * https://tools.ietf.org/html/rfc7946#section-5
+   */
+  bbox?: BBox | undefined;
+}
+/**
+ * Union of GeoJSON objects.
+ */
+type GeoJSON$1<G extends Geometry | null = Geometry, P = GeoJsonProperties> = G | Feature<G, P> | FeatureCollection<G, P>;
+/**
+ * Geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ */
+type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
+/**
+ * Point geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.2
+ */
+interface Point extends GeoJsonObject {
+  type: "Point";
+  coordinates: Position;
+}
+/**
+ * MultiPoint geometry object.
+ *  https://tools.ietf.org/html/rfc7946#section-3.1.3
+ */
+interface MultiPoint extends GeoJsonObject {
+  type: "MultiPoint";
+  coordinates: Position[];
+}
+/**
+ * LineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.4
+ */
+interface LineString extends GeoJsonObject {
+  type: "LineString";
+  coordinates: Position[];
+}
+/**
+ * MultiLineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.5
+ */
+interface MultiLineString extends GeoJsonObject {
+  type: "MultiLineString";
+  coordinates: Position[][];
+}
+/**
+ * Polygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ */
+interface Polygon extends GeoJsonObject {
+  type: "Polygon";
+  coordinates: Position[][];
+}
+/**
+ * MultiPolygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.7
+ */
+interface MultiPolygon extends GeoJsonObject {
+  type: "MultiPolygon";
+  coordinates: Position[][][];
+}
+/**
+ * Geometry Collection
+ * https://tools.ietf.org/html/rfc7946#section-3.1.8
+ */
+interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
+  type: "GeometryCollection";
+  geometries: G[];
+}
+type GeoJsonProperties = {
+  [name: string]: any;
+} | null;
+/**
+ * A feature object which contains a geometry and associated properties.
+ * https://tools.ietf.org/html/rfc7946#section-3.2
+ */
+interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+  type: "Feature";
+  /**
+   * The feature's geometry
+   */
+  geometry: G;
+  /**
+   * A value that uniquely identifies this feature in a
+   * https://tools.ietf.org/html/rfc7946#section-3.2.
+   */
+  id?: string | number | undefined;
+  /**
+   * Properties associated with this feature.
+   */
+  properties: P;
+}
+/**
+ * A collection of feature objects.
+ *  https://tools.ietf.org/html/rfc7946#section-3.3
+ */
+interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+  type: "FeatureCollection";
+  features: Array<Feature<G, P>>;
+}
+//#endregion
+//#region src/print-layout-config.d.ts
+/**
+ * Print Layout composer settings that belong to a project.
+ *
+ * The Print Layout dialog composes a printable page out of the current map:
+ * a title block, page size and orientation, the cartographic furniture
+ * (legend, scale bar, north arrow), optional data blocks, and an atlas /
+ * map-series definition. All of that describes the *project's* map document,
+ * so it round-trips through `.geolibre.json` (GeoLibre discussion #1992 —
+ * before this, reopening a project lost the title, page format and
+ * orientation, and the dialog kept showing the previous project's settings).
+ *
+ * Deliberately **not** in here: everything that is per-session rather than
+ * part of the document — the captured map image, export progress, error and
+ * clipboard notices, the current atlas page, and the dialog's own chrome
+ * (panel widths, dialog size).
+ *
+ * The unions below are the storage contract. Their app-side counterparts
+ * (`PaperSizeId`, `Orientation`, `BodyCorner`, ... in
+ * `apps/geolibre-desktop/src/lib/`) are checked against these by ordinary
+ * assignment in the dialog's snapshot/restore paths, so adding a paper size or
+ * a corner on one side without the other fails the build.
+ */
+/** A page corner an overlay block can be pinned to. */
+type PrintLayoutCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+/** Which features a data block covers when the atlas paginates the map. */
+type PrintLayoutPageFilter = "all" | "contained" | "intersecting";
+/** One hand-authored swatch in the composer's user-defined legend. */
+interface PrintLayoutLegendEntry {
+  id: string;
+  label: string;
+  color: string;
+}
+interface PrintLayoutConfig {
+  title: string;
+  subtitle: string;
+  titlePlacement: "outside" | "inside";
+  titleAlign: "left" | "center" | "right";
+  paperSize: "a4" | "a3" | "letter" | "legal" | "tabloid" | "fullhd" | "hd" | "uhd4k" | "square" | "custom";
+  orientation: "portrait" | "landscape";
+  customWidth: number;
+  customHeight: number;
+  customUnit: "mm" | "px";
+  pageMargin: "normal" | "narrow" | "none";
+  showPageBorder: boolean;
+  pageBorderColor: string;
+  pageBorderWidth: number;
+  mapBorderColor: string;
+  mapBorderWidth: number;
+  mapBackground: string;
+  showTitle: boolean;
+  showSubtitle: boolean;
+  showLegend: boolean;
+  showScaleBar: boolean;
+  showNorthArrow: boolean;
+  navigationGrouped: boolean;
+  showFooter: boolean;
+  footerText: string;
+  showDate: boolean;
+  /** Blank means "today", resolved when the page is drawn. */
+  dateText: string;
+  showAttribution: boolean;
+  showColorbar: boolean;
+  colorbarRamp: string;
+  /** Kept as typed text so a half-entered value survives a round trip. */
+  colorbarMin: string;
+  colorbarMax: string;
+  colorbarLabel: string;
+  colorbarOrientation: "vertical" | "horizontal";
+  colorbarLength: number;
+  colorbarPosition: PrintLayoutCorner;
+  showCustomLegend: boolean;
+  customLegendTitle: string;
+  customLegendEntries: PrintLayoutLegendEntry[];
+  customLegendPosition: PrintLayoutCorner;
+  showDataTable: boolean;
+  tableLayerId: string;
+  tableTitle: string;
+  tableColumns: string[];
+  tableSortField: string;
+  tableSortDesc: boolean;
+  tableMaxRows: number;
+  tableFitRows: boolean;
+  tablePosition: PrintLayoutCorner;
+  tablePageFilter: PrintLayoutPageFilter;
+  tableFilterToAtlasFeature: boolean;
+  showDataChart: boolean;
+  chartLayerId: string;
+  chartTitle: string;
+  chartType: "bar" | "pie" | "line";
+  chartCategoryField: string;
+  chartAggregation: "count" | "sum" | "mean";
+  chartValueField: string;
+  chartPosition: PrintLayoutCorner;
+  chartPageFilter: PrintLayoutPageFilter;
+  showInfoBlock: boolean;
+  author: string;
+  projectNumber: string;
+  crs: string;
+  revision: string;
+  captureMode: "viewport" | "extent";
+  /** Drawn print extent as `[west, south, east, north]`; null when unset. */
+  extentBbox: [number, number, number, number] | null;
+  atlasEnabled: boolean;
+  atlasLayerId: string;
+  atlasCoverage: "features" | "line";
+  atlasSegmentKm: string;
+  atlasNameField: string;
+  atlasExtentMode: "margin" | "scale";
+  atlasMarginPct: number;
+  atlasMaskEnabled: boolean;
+  atlasScale: string;
+  atlasSortField: string;
+  atlasSortDescending: boolean;
+  atlasFilter: string;
+  atlasFilenamePattern: string;
+}
+/**
+ * Settings a project starts with, and the shape every partial or hand-edited
+ * `printLayout` is filled out against. Also the dialog's initial state, so
+ * "new project" and "a project saved before this feature" compose identically.
+ */
+declare const DEFAULT_PRINT_LAYOUT: PrintLayoutConfig;
+/** A fresh copy of the defaults, safe to hand to a store or a component. */
+declare function createDefaultPrintLayout(): PrintLayoutConfig;
+/**
+ * Coerce an untrusted (possibly hand-edited, possibly partial) `printLayout`
+ * into a complete {@link PrintLayoutConfig}, filling every missing or
+ * malformed field from {@link DEFAULT_PRINT_LAYOUT}.
+ *
+ * @param value - The raw `printLayout` value read from a project file.
+ * @returns The normalized config, or null when the project carries none, so
+ *   callers can tell "absent" from "explicitly default".
+ */
+declare function normalizePrintLayoutConfig(value: unknown): PrintLayoutConfig | null;
+/**
+ * Whether a config is still the untouched default, so a project that never
+ * opened the composer serializes without a `printLayout` key and stays
+ * byte-identical to one saved before this feature.
+ */
+declare function isDefaultPrintLayout(config: PrintLayoutConfig): boolean;
+/**
+ * Structural equality for two configs. Used to skip no-op store writes, so
+ * merely opening the Print Layout dialog never marks a project dirty.
+ */
+declare function printLayoutConfigsEqual(a: PrintLayoutConfig, b: PrintLayoutConfig): boolean;
+/**
+ * Drop references to layers the project no longer carries, so a composer that
+ * pointed at a since-deleted layer opens with the block cleared instead of
+ * rendering nothing from a dangling id. Mirrors the widget/comment/legend
+ * scrubbing in `applyProjectToStore`.
+ *
+ * @param config - The config to scrub.
+ * @param existingLayerIds - Ids of the layers present in the project.
+ * @returns The same object when nothing referenced a missing layer.
+ */
+declare function scrubPrintLayoutForLayers(config: PrintLayoutConfig, existingLayerIds: ReadonlySet<string>): PrintLayoutConfig;
+/**
+ * The delete-time counterpart, matching `scrubLegendForRemovedLayers` and its
+ * siblings: called when layers are removed from the open project so the saved
+ * file never carries a block pointing at a layer that is already gone.
+ *
+ * @param config - The config to scrub.
+ * @param layerIds - The removed layer id, or ids.
+ * @returns The same object when no block referenced a removed layer.
+ */
+declare function scrubPrintLayoutForRemovedLayers(config: PrintLayoutConfig, layerIds: string | Iterable<string>): PrintLayoutConfig;
+//#endregion
+//#region src/types.d.ts
+declare const OPENFREEMAP_BASEMAPS: readonly [{
+  readonly id: "liberty";
+  readonly name: "Liberty";
+  readonly styleUrl: "https://tiles.openfreemap.org/styles/liberty";
+}, {
+  readonly id: "liberty-3d";
+  readonly name: "Liberty 3D";
+  readonly styleUrl: "https://tiles.openfreemap.org/styles/liberty";
+}, {
+  readonly id: "positron";
+  readonly name: "Positron";
+  readonly styleUrl: "https://tiles.openfreemap.org/styles/positron";
+}, {
+  readonly id: "bright";
+  readonly name: "Bright";
+  readonly styleUrl: "https://tiles.openfreemap.org/styles/bright";
+}, {
+  readonly id: "dark";
+  readonly name: "Dark";
+  readonly styleUrl: "https://tiles.openfreemap.org/styles/dark";
+}, {
+  readonly id: "fiord";
+  readonly name: "Fiord";
+  readonly styleUrl: "https://tiles.openfreemap.org/styles/fiord";
+}];
+/**
+ * Protomaps v5 basemap flavors. These are resolved to full style URLs at use
+ * time by `getProtomapsStyleUrl`, which injects the `VITE_PROTOMAPS_API_KEY`
+ * runtime env var. The key is only present in builds configured with it (e.g.
+ * the GitHub Pages web demo), so consumers should hide these options when no
+ * key is available.
+ */
+declare const PROTOMAPS_BASEMAPS: readonly [{
+  readonly id: "protomaps-light";
+  readonly name: "Light";
+  readonly flavor: "light";
+}, {
+  readonly id: "protomaps-dark";
+  readonly name: "Dark";
+  readonly flavor: "dark";
+}, {
+  readonly id: "protomaps-white";
+  readonly name: "White";
+  readonly flavor: "white";
+}, {
+  readonly id: "protomaps-grayscale";
+  readonly name: "Grayscale";
+  readonly flavor: "grayscale";
+}, {
+  readonly id: "protomaps-black";
+  readonly name: "Black";
+  readonly flavor: "black";
+}];
+declare const DEFAULT_BASEMAP = "https://tiles.openfreemap.org/styles/liberty";
+declare const BLANK_BASEMAP = "";
+declare const PROJECT_VERSION = "0.2.0";
+/**
+ * Every layer type, as a runtime list so untrusted input (an imported Layer
+ * Library bundle, a hand-edited project) can be validated against it.
+ * {@link LayerType} is derived from this array, so the two cannot drift.
+ */
+declare const LAYER_TYPES: readonly ["geojson", "raster", "wms", "wmts", "xyz", "vector-tiles", "arcgis", "pmtiles", "mbtiles", "zarr", "lidar", "gaussian-splat", "3d-tiles", "cog", "flatgeobuf", "geoparquet", "duckdb-query", "deckgl-viz", "video", "image"];
+type LayerType = (typeof LAYER_TYPES)[number];
+type VectorStyleMode = "single" | "graduated" | "categorized" | "rule-based" | "expression";
+/**
+ * One entry in a {@link LayerStyle.vectorRules} rule-based renderer. Each rule
+ * pairs a MapLibre filter expression (a boolean expression array, serialized as
+ * JSON) with a symbol color. Rules are evaluated top to bottom; the first whose
+ * filter matches wins. The catch-all rule (`isElse`) has no filter and supplies
+ * the color for features no other rule matched. Mirrors the QGIS/ArcGIS
+ * rule-based renderer.
+ */
+interface VectorRule {
+  id: string;
+  /** Human-readable label shown in the editor and the legend. */
+  label: string;
+  /**
+   * A MapLibre boolean filter expression serialized as JSON, e.g.
+   * `["==", ["get", "TYPE"], "park"]`. Ignored when {@link isElse} is set or
+   * the JSON is invalid.
+   */
+  filter: string;
+  /** The symbol fill/circle color for features this rule matches (6-digit hex). */
+  color: string;
+  /**
+   * When true this is the catch-all "else" rule: {@link filter} is unused and
+   * the rule is an unconditional fallback for features no other rule matched,
+   * so the {@link minZoom}/{@link maxZoom} and {@link parentId} fields are
+   * ignored on it. Its symbol overrides and {@link enabled} toggle do apply.
+   */
+  isElse: boolean;
+  /**
+   * Whether the rule participates in rendering. `false` temporarily disables
+   * the rule (and, for a group, its whole subtree) without deleting it,
+   * mirroring the QGIS rule checkbox. Absent means enabled.
+   */
+  enabled?: boolean;
+  /**
+   * Lowest zoom (inclusive) the rule applies at, mirroring MapLibre's layer
+   * `minzoom` convention. Absent means no lower bound.
+   */
+  minZoom?: number;
+  /**
+   * Zoom the rule stops applying at (exclusive, like MapLibre's layer
+   * `maxzoom`). Absent means no upper bound. Together with {@link minZoom}
+   * this is the QGIS per-rule "scale range".
+   */
+  maxZoom?: number;
+  /**
+   * The id of the parent rule when this rule is nested inside a group (QGIS
+   * rule tree). A child rule matches only features that also match every
+   * ancestor's filter, and inherits the intersection of the ancestors' zoom
+   * ranges and enabled state. A rule that has children acts as a group: its
+   * own symbol is not rendered; only leaf rules draw. Absent or dangling
+   * means a top-level rule.
+   */
+  parentId?: string;
+  /**
+   * Per-rule stroke/outline color override (6-digit hex): the polygon outline
+   * and circle stroke color for matching features. Absent inherits the layer
+   * {@link LayerStyle.strokeColor}.
+   */
+  strokeColor?: string;
+  /**
+   * Per-rule stroke width override in pixels: the line width (lines and
+   * polygon outlines) and circle stroke width for matching features. Absent
+   * inherits the layer {@link LayerStyle.strokeWidth}.
+   */
+  strokeWidth?: number;
+  /**
+   * Per-rule fill/circle opacity override (0..1) for matching features.
+   * Absent inherits the layer {@link LayerStyle.fillOpacity}.
+   */
+  fillOpacity?: number;
+  /**
+   * Per-rule circle radius override in pixels for matching point features.
+   * Absent inherits the layer {@link LayerStyle.circleRadius}.
+   */
+  circleRadius?: number;
+}
+/**
+ * The fill pattern applied to polygon layers. `"none"` keeps a flat fill; the
+ * named patterns are generated as recolorable sprite tiles; `"svg"` rasterizes
+ * the user-supplied markup in {@link LayerStyle.fillPatternSvg}.
+ */
+type FillPattern = "none" | "hatch" | "cross-hatch" | "horizontal" | "vertical" | "dots" | "svg";
+/**
+ * The built-in marker shape for a point layer, or `"custom"` to rasterize the
+ * user-supplied SVG in {@link LayerStyle.markerSvg}. Built-in shapes are drawn
+ * on a sprite tile and recolored via {@link LayerStyle.markerColor}.
+ */
+type MarkerShape = "circle" | "square" | "triangle" | "diamond" | "star" | "cross" | "pin" | "custom";
+/**
+ * How a point layer is rendered: as individual markers, a density heatmap, or
+ * clustered bubbles. Only applies to point geometry.
+ */
+type PointRenderer = "single" | "heatmap" | "cluster";
+/**
+ * The repeated decoration symbol drawn along line features (and polygon
+ * outlines), or `"none"` when decorations are off. Mirrors the QGIS
+ * marker-line / arrow symbol layers: `"arrow"` renders directional arrowheads
+ * that follow the line, the other shapes render as repeated markers.
+ */
+type LineDecoration = "none" | "arrow" | "triangle" | "circle" | "square";
+/**
+ * The per-feature derived geometry rendered by the geometry generator, or
+ * `"none"` when the generator is off. Mirrors QGIS geometry-generator symbol
+ * layers: each feature's derived geometry (its centroid, bounding box, convex
+ * hull, or a buffer) is drawn as an extra symbol over the layer's normal
+ * symbology. `"centroid"` derives points; the rest derive polygons.
+ */
+type GeometryGeneratorType = "none" | "centroid" | "bounding-box" | "convex-hull" | "buffer";
+/**
+ * Unit a stroke/line width is measured in. `"pixels"` is constant screen space;
+ * `"meters"` is ground distance, so the rendered width scales with the map
+ * scale (zoom). See {@link LayerStyle.strokeWidthUnit}.
+ */
+type StrokeWidthUnit = "pixels" | "meters";
+/**
+ * The chart drawn on top of each feature by the diagram renderer (QGIS-style
+ * diagram symbology), or `"none"` when diagrams are off. Diagrams visualize
+ * several numeric attributes per feature at once — e.g. election results by
+ * party per county — and render through the shared deck.gl overlay on the
+ * feature's point location or polygon centroid.
+ */
+type DiagramType = "none" | "pie" | "donut" | "bar" | "stacked-bar";
+/**
+ * How the overall diagram size is determined.
+ *
+ * - `"fixed"`: every diagram renders at {@link LayerStyle.diagramSize} pixels.
+ * - `"sum"`: scaled by the sum of the mapped attribute values, so the largest
+ *   total renders at {@link LayerStyle.diagramSize} pixels (area-true square
+ *   root scaling).
+ * - `"attribute"`: scaled the same way by the single numeric attribute in
+ *   {@link LayerStyle.diagramSizeProperty}.
+ */
+type DiagramSizeMode = "fixed" | "sum" | "attribute";
+/** One attribute rendered as a slice/bar of a feature diagram. */
+interface DiagramField {
+  /** Numeric feature property visualized by this slice/bar. */
+  property: string;
+  /** Slice/bar color (6-digit hex). */
+  color: string;
+}
+interface VectorStyleStop {
+  value: string | number;
+  color: string;
+  label?: string;
+}
+/** Attribute-driven labeling for a vector layer (rendered as a MapLibre symbol layer). */
+interface LabelStyle {
+  /** Whether labels are shown for the layer. */
+  enabled: boolean;
+  /** Attribute field whose value becomes the label text. */
+  field: string;
+  /**
+   * Optional MapLibre expression (JSON string) for the label text, which
+   * overrides {@link field} when non-empty (e.g. concatenating several fields).
+   */
+  expression: string;
+  /** `"point"` labels at the feature/centroid; `"line"` places them along lines. */
+  placement: "point" | "line";
+  /** Label text size in pixels. */
+  size: number;
+  /** CSS color string for the label text. */
+  color: string;
+  /** CSS color string for the text halo drawn behind the label. */
+  haloColor: string;
+  /** Width of the text halo in pixels. */
+  haloWidth: number;
+  /** Scale range for labels; `0` / `24` inherit the layer's own zoom range. */
+  minZoom: number;
+  maxZoom: number;
+  /** Let labels overlap instead of hiding colliding ones. */
+  allowOverlap: boolean;
+  /**
+   * Where the label sits relative to its anchor point (MapLibre `text-anchor`),
+   * e.g. `"top"` places the text above the point. Ignored for line placement.
+   */
+  anchor: LabelAnchor;
+  /** Horizontal label offset in ems (MapLibre `text-offset` x). */
+  offsetX: number;
+  /** Vertical label offset in ems (MapLibre `text-offset` y; positive is down). */
+  offsetY: number;
+  /** Label rotation in degrees clockwise (MapLibre `text-rotate`). */
+  rotation: number;
+  /** Maximum line width in ems before the label wraps (MapLibre `text-max-width`). */
+  maxWidth: number;
+  /** Letter-case transform applied to the label text (MapLibre `text-transform`). */
+  transform: LabelTransform;
+  /**
+   * Render a numeric {@link field} with the locale's thousands and decimal
+   * separators (issue #2336), so `1234567.5` labels as `1,234,567.5` instead
+   * of running together. Non-numeric values are unaffected, and it is not
+   * applied to {@link expression}, which formats its own output (MapLibre's
+   * `number-format`, offered in the Expression Builder).
+   */
+  numberFormatEnabled: boolean;
+  /** Decimal places kept while {@link numberFormatEnabled} is on (0-10). */
+  numberDecimals: number;
+  /**
+   * BCP 47 tag picking the separators for {@link numberFormatEnabled}, from
+   * {@link LABEL_NUMBER_LOCALES}. Empty (the default) follows the app's own
+   * language, the way popup number fields do.
+   */
+  numberLocale: string;
+  /**
+   * How to handle features that share a label.
+   *
+   * - `"off"`: every feature is labeled (the historical behavior).
+   * - `"unique"`: features stacked at the same point are collapsed to a single
+   *   label, so co-located points (e.g. several antennas at one cell site) do not
+   *   stack overlapping text.
+   * - `"concatenate"`: co-located points are merged into one label that joins
+   *   their distinct {@link field} values, one per line.
+   *
+   * Applies to point layers rendered through the inline GeoJSON path and uses
+   * {@link field} (not {@link expression}) as the label value.
+   */
+  dedupe: LabelDedupe;
+  /**
+   * Data-defined override for {@link size}: a MapLibre expression (JSON
+   * string) producing a number, e.g. sizing labels by population. Empty means
+   * "use the literal {@link size}". Like the other data-defined overrides
+   * below, it reads source feature attributes, so it is skipped while
+   * {@link dedupe} collapsing is active (the aggregated features carry only
+   * the label value).
+   */
+  sizeExpression: string;
+  /**
+   * Data-defined override for {@link color}: a MapLibre expression (JSON
+   * string) producing a color, e.g. coloring labels by category.
+   */
+  colorExpression: string;
+  /**
+   * Data-defined label opacity: a MapLibre expression (JSON string) producing
+   * a number in 0..1. When set it replaces the layer-wide opacity for labels
+   * (wrapping it would invalidate top-level `["zoom"]` interpolations).
+   */
+  opacityExpression: string;
+  /**
+   * Per-feature label visibility: a MapLibre expression (JSON string)
+   * producing a boolean. Features evaluating false get no label (e.g. hide
+   * labels below an attribute threshold). Combined with the layer's other
+   * feature filters.
+   */
+  visibilityExpression: string;
+  /**
+   * Per-feature placement priority: a MapLibre expression (JSON string)
+   * producing a number, applied as `symbol-sort-key`. Labels with lower
+   * values are placed first, so they win when space is tight.
+   */
+  priorityExpression: string;
+}
+/** MapLibre `text-anchor` positions offered for {@link LabelStyle.anchor}. */
+type LabelAnchor = "center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+/** Letter-case transform offered for {@link LabelStyle.transform}. */
+type LabelTransform = "none" | "uppercase" | "lowercase";
+/** Duplicate-label handling offered for {@link LabelStyle.dedupe}. */
+type LabelDedupe = "off" | "unique" | "concatenate";
+/**
+ * Cartographic blend modes offered for {@link LayerStyle.blendMode}.
+ *
+ * The list is bounded by what WebGL *fixed-function* blending can express --
+ * one `blendFunc` factor pair plus one `blendEquation` -- because that is the
+ * only blend state MapLibre's renderer exposes, and it applies to colour and
+ * alpha together. Two consequences shaped this list:
+ *
+ * - Modes needing the destination colour inside a fragment shader (`overlay`,
+ *   `color-dodge`, `soft-light`, `difference`, and the non-separable HSL modes)
+ *   are absent. MapLibre draws straight into the map framebuffer, which a
+ *   shader cannot sample, so computing them would need an extra copy pass.
+ * - `darken` and `subtract` are absent even though `MIN` and
+ *   `FUNC_REVERSE_SUBTRACT` look like they would serve. Both also apply to the
+ *   alpha channel, where they drive the map canvas transparent: `MIN` takes the
+ *   whole canvas to `min(0, dst) = 0` everywhere the layer does not cover, and
+ *   `FUNC_REVERSE_SUBTRACT` leaves `dstA - srcA` inside it. Correcting either
+ *   needs `blendEquationSeparate` / `blendFuncSeparate`, which MapLibre's state
+ *   tracker does not offer.
+ *
+ * Every mode here leaves the canvas opaque and leaves the map untouched
+ * wherever the layer contributes nothing. See `docs/user-guide/layers.md`.
+ */
+declare const BLEND_MODES: readonly ["normal", "multiply", "screen", "lighten", "add"];
+/**
+ * How a layer's pixels combine with the map beneath it. `"normal"` is ordinary
+ * alpha compositing (the default, and what every layer did before blend modes
+ * existed). See {@link BLEND_MODES}.
+ */
+type BlendMode = (typeof BLEND_MODES)[number];
+/**
+ * The mode a layer renders with unless it says otherwise. Declared separately
+ * from {@link DEFAULT_LAYER_STYLE} so consumers get a non-optional
+ * {@link BlendMode} to fall back to: `blendMode` is optional on
+ * {@link LayerStyle}, so `DEFAULT_LAYER_STYLE.blendMode` is typed
+ * `BlendMode | undefined` however it is initialized.
+ */
+declare const DEFAULT_BLEND_MODE: BlendMode;
+interface LayerStyle {
+  minZoom: number;
+  maxZoom: number;
+  fillColor: string;
+  strokeColor: string;
+  strokeWidth: number;
+  /**
+   * Unit the {@link strokeWidth} value is expressed in.
+   *
+   * - `"pixels"` (default): a constant screen-space width that never changes
+   *   with zoom — the historical behavior.
+   * - `"meters"`: a ground-distance width, so the rendered line stays
+   *   proportional to the map scale (thicker zoomed in, thinner zoomed out),
+   *   matching QGIS "map units". Only affects line/polygon-outline rendering;
+   *   point/circle outlines remain pixel-based.
+   */
+  strokeWidthUnit: StrokeWidthUnit;
+  fillOpacity: number;
+  circleRadius: number;
+  textColor: string;
+  textHaloColor: string;
+  textHaloWidth: number;
+  textSize: number;
+  labels: LabelStyle;
+  extrusionEnabled: boolean;
+  extrusionColor: string;
+  extrusionOpacity: number;
+  extrusionHeightProperty: string;
+  extrusionHeightScale: number;
+  extrusionBase: number;
+  extrusionAdvancedStyleEnabled: boolean;
+  extrusionColorExpression: string;
+  extrusionHeightExpression: string;
+  /**
+   * When true, a vector layer whose coordinates carry Z values (e.g. a GPX
+   * track with elevations) renders in true 3D through the shared deck.gl
+   * overlay instead of MapLibre's flat 2D layers, so features sit at their
+   * own altitude. Orthogonal to {@link extrusionEnabled}, which extrudes flat
+   * polygons by an attribute; only one of the two should be on at a time.
+   */
+  elevation3dEnabled: boolean;
+  /** Multiplier applied to each coordinate's Z value (vertical exaggeration). */
+  elevation3dVerticalScale: number;
+  /** Constant altitude offset in meters added after the vertical scale. */
+  elevation3dOffset: number;
+  vectorStyleMode: VectorStyleMode;
+  vectorStyleProperty: string;
+  vectorStyleClassCount: number;
+  vectorStyleColorRamp: string;
+  vectorStyleClassificationScheme: string;
+  vectorStyleStops: VectorStyleStop[];
+  vectorStyleExpression: string;
+  /**
+   * Ordered rules for the `"rule-based"` {@link vectorStyleMode}. Compiled to a
+   * MapLibre `case` color expression (first matching filter wins, catch-all
+   * last). See {@link VectorRule}.
+   */
+  vectorRules: VectorRule[];
+  /**
+   * When true, the point circle radius (or line width) is sized by a numeric
+   * field via an `interpolate` between {@link proportionalSizeMinValue} ..
+   * {@link proportionalSizeMaxValue} mapped onto {@link proportionalSizeMinRadius}
+   * .. {@link proportionalSizeMaxRadius} (QGIS "graduated → size" / proportional
+   * symbols). Orthogonal to the color {@link vectorStyleMode}.
+   */
+  proportionalSizeEnabled: boolean;
+  proportionalSizeProperty: string;
+  proportionalSizeMinValue: number;
+  proportionalSizeMaxValue: number;
+  proportionalSizeMinRadius: number;
+  proportionalSizeMaxRadius: number;
+  /**
+   * Polygon fill pattern. `"none"` keeps the flat fill; other values render a
+   * recolorable sprite tile ({@link fillPatternColor}); `"svg"` rasterizes
+   * {@link fillPatternSvg}. See {@link FillPattern}.
+   */
+  fillPattern: FillPattern;
+  fillPatternColor: string;
+  /** Raw SVG markup (or a data URL) used when {@link fillPattern} is `"svg"`. */
+  fillPatternSvg: string;
+  /**
+   * When true, point features render as a marker icon ({@link markerShape})
+   * instead of a plain circle. Built-in shapes are recolored via
+   * {@link markerColor}; `"custom"` rasterizes {@link markerSvg}.
+   */
+  markerEnabled: boolean;
+  markerShape: MarkerShape;
+  markerColor: string;
+  markerSize: number;
+  /**
+   * The custom marker image used when {@link markerShape} is `"custom"`: raw
+   * SVG markup, a `data:` URL (SVG or a raster PNG/JPEG/GIF), or an `http(s)`
+   * URL. Only SVG sources take {@link markerColor}; raster images draw as-is.
+   */
+  markerSvg: string;
+  /**
+   * When true, per-feature [simplestyle-spec](https://github.com/mapbox/simplestyle-spec)
+   * properties (`fill`, `fill-opacity`, `stroke`, `stroke-width`,
+   * `stroke-opacity`, `marker-color`) override the flat layer style on a
+   * per-feature basis. Set automatically when a GeoJSON layer is added whose
+   * features carry these properties (e.g. styled KML/KMZ), so embedded
+   * symbology renders without manual configuration.
+   */
+  simpleStyleEnabled: boolean;
+  /**
+   * Per-feature chart symbology (QGIS-style diagrams). `"none"` disables it;
+   * any other value renders one {@link DiagramType} chart per feature over the
+   * layer's normal symbology, built from the numeric attributes in
+   * {@link diagramFields}. See `@geolibre/core`'s `diagram.ts` helpers.
+   */
+  diagramType: DiagramType;
+  /** Attributes (and their colors) charted by the diagram renderer, in order. */
+  diagramFields: DiagramField[];
+  /** How the per-feature diagram size is determined. */
+  diagramSizeMode: DiagramSizeMode;
+  /**
+   * Diagram size in pixels: the rendered diameter/height for `"fixed"` sizing,
+   * or the diameter/height of the largest feature for scaled sizing.
+   */
+  diagramSize: number;
+  /** Numeric attribute driving `"attribute"` sizing (see {@link DiagramSizeMode}). */
+  diagramSizeProperty: string;
+  /** Minimum zoom at which diagrams are drawn, to avoid clutter when zoomed out. */
+  diagramMinZoom: number;
+  /**
+   * When true, diagrams that would overlap an already-placed diagram on screen
+   * are skipped (largest first), decluttering dense areas. Recomputed as the
+   * view changes.
+   */
+  diagramDeclutter: boolean;
+  pointRenderer: PointRenderer;
+  heatmapRadius: number;
+  heatmapIntensity: number;
+  /** Built-in color ramp used by the heatmap density renderer. */
+  heatmapColorRamp: string;
+  /** Numeric feature property used as heatmap weight; blank gives every point equal weight. */
+  heatmapWeightProperty: string;
+  clusterRadius: number;
+  clusterMaxZoom: number;
+  /**
+   * When true, the polygon fill renders *inverted*: the area outside the
+   * features is filled (with {@link fillColor}/{@link fillOpacity}) and the
+   * features themselves become holes, mirroring the QGIS "Inverted polygons"
+   * renderer. Feature outlines still render normally. Only applies to layers
+   * with polygon geometry; ignored while {@link extrusionEnabled} is on.
+   */
+  invertedFillEnabled: boolean;
+  /**
+   * Repeated decoration symbol drawn along line features and polygon outlines
+   * (QGIS marker-line / arrow lines). `"none"` disables it. See
+   * {@link LineDecoration}.
+   */
+  lineDecoration: LineDecoration;
+  /**
+   * Decoration symbol color (6-digit hex). An empty string inherits
+   * {@link strokeColor} so decorations follow the stroke by default.
+   */
+  lineDecorationColor: string;
+  /** Decoration symbol size in pixels. */
+  lineDecorationSize: number;
+  /** Distance between consecutive decoration symbols in pixels. */
+  lineDecorationSpacing: number;
+  /**
+   * Per-feature derived geometry drawn over the layer's normal symbology
+   * (QGIS geometry generator). `"none"` disables it. See
+   * {@link GeometryGeneratorType}.
+   */
+  geometryGenerator: GeometryGeneratorType;
+  /** Buffer distance in meters for the `"buffer"` generator. */
+  geometryGeneratorBufferDistance: number;
+  /**
+   * Attribute driving the `"buffer"` generator's distance, so each feature is
+   * buffered by its own value in meters (QGIS data-defined override on a
+   * geometry-generator symbol). An empty string buffers every feature by the
+   * flat {@link geometryGeneratorBufferDistance}, which also stands in for
+   * features whose value is missing or non-numeric.
+   */
+  geometryGeneratorBufferProperty: string;
+  /** Fill color (6-digit hex) for generated polygons and centroid points. */
+  geometryGeneratorFillColor: string;
+  /** Outline color (6-digit hex) for generated geometry. */
+  geometryGeneratorStrokeColor: string;
+  /** Outline width in pixels for generated geometry. */
+  geometryGeneratorStrokeWidth: number;
+  /** Fill opacity (0..1) for generated polygons and centroid points. */
+  geometryGeneratorOpacity: number;
+  /** Circle radius in pixels for generated centroid points. */
+  geometryGeneratorCircleRadius: number;
+  /**
+   * Attribute driving the radius of generated centroid points, scaling them
+   * between {@link geometryGeneratorSizeMinRadius} and
+   * {@link geometryGeneratorSizeMaxRadius} across
+   * {@link geometryGeneratorSizeMinValue} ..
+   * {@link geometryGeneratorSizeMaxValue} (proportional symbols on the derived
+   * centroids). An empty string draws every centroid at the flat
+   * {@link geometryGeneratorCircleRadius}.
+   *
+   * Deliberately separate from {@link proportionalSizeProperty}: that one also
+   * drives line width, so reusing it here would resize a polygon layer's
+   * outlines as a side effect of sizing its centroids.
+   */
+  geometryGeneratorSizeProperty: string;
+  geometryGeneratorSizeMinValue: number;
+  geometryGeneratorSizeMaxValue: number;
+  geometryGeneratorSizeMinRadius: number;
+  geometryGeneratorSizeMaxRadius: number;
+  rasterBrightnessMin: number;
+  rasterBrightnessMax: number;
+  rasterSaturation: number;
+  rasterContrast: number;
+  rasterHueRotate: number;
+  /**
+   * How this layer composites onto whatever is drawn beneath it. `"normal"`
+   * (the default) is ordinary alpha compositing; `"multiply"` is the classic
+   * cartographic case of laying colour over a hillshade so the relief still
+   * reads through. Applies to the layer's own rendered geometry and raster
+   * tiles, not to its labels, which stay legible on top. See
+   * {@link BLEND_MODES} for the available modes and why the list is what it is.
+   */
+  blendMode?: BlendMode;
+}
+declare const DEFAULT_LAYER_STYLE: LayerStyle;
+/**
+ * Read a layer style property, falling back to the shared default when the
+ * layer does not define it. Shared by `@geolibre/map` and the desktop app so
+ * the two consumers cannot drift.
+ */
+declare function styleValue<K extends keyof LayerStyle>(style: LayerStyle, key: K): LayerStyle[K];
+/**
+ * Feature-count threshold above which a local vector (GeoJSON) layer is rendered
+ * through client-side vector tiles (geojson-vt / supercluster served by a custom
+ * MapLibre protocol) instead of one in-memory geojson source pushed via
+ * `setData`. Small layers stay on the simpler inline path. Mirrors the
+ * `MAX_CEREUS_FEATURES` precedent in the desktop SQL engine.
+ */
+declare const LARGE_VECTOR_FEATURE_THRESHOLD = 50000;
+/**
+ * Decide whether a GeoJSON layer should use the tiled rendering path.
+ *
+ * @param geojson - The layer's feature collection (may be undefined for
+ *   non-vector layers).
+ * @returns `true` when the collection exceeds
+ *   {@link LARGE_VECTOR_FEATURE_THRESHOLD} features.
+ */
+declare function shouldUseTiledRendering(geojson: GeoJSON.FeatureCollection | undefined): boolean;
+/**
+ * Match statistics from the last time a {@link LayerJoin} was applied, shown in
+ * the Joins UI so silent key mismatches are visible (mirrors QGIS's join
+ * feedback). Recomputed on every apply; persisted harmlessly with the join.
+ */
+interface LayerJoinStats {
+  /** Target features whose key matched a join-table row. */
+  matchedCount: number;
+  /** Target features with no matching join-table row (their joined columns are null). */
+  unmatchedTargetCount: number;
+  /** Join-table rows (with a non-empty key) that matched no target feature. */
+  unmatchedJoinCount: number;
+}
+/**
+ * A persistent attribute join attached to a layer (QGIS Layer Properties →
+ * Joins): a live left join that augments the layer's attribute table with
+ * columns from another layer (typically a geometry-less table added via
+ * Delimited Text with no coordinate fields) matched on a key field. Unlike the
+ * Processing → Vector attribute join, the layer keeps its identity — styles,
+ * labels, and position — and the joined columns refresh whenever the join
+ * table's data changes. Definitions persist in `.geolibre.json` and re-resolve
+ * on project load. See `joins.ts` for the engine.
+ */
+interface LayerJoin {
+  /** Stable id for list edits. */
+  id: string;
+  /** Id of the layer providing the joined columns (its geometry is ignored). */
+  joinLayerId: string;
+  /** Key field on the layer that owns this join. */
+  targetField: string;
+  /** Key field on the join layer. */
+  joinField: string;
+  /**
+   * Join-layer fields to bring over; `undefined` brings every field except the
+   * key. Names are the join layer's own (pre-prefix) field names.
+   */
+  fields?: string[];
+  /** Optional prefix prepended to every joined column name (as in QGIS). */
+  prefix?: string;
+  /** `false` detaches the joined columns without deleting the definition. */
+  enabled?: boolean;
+  /**
+   * Bookkeeping written by the engine: the output column names this join added
+   * to the layer's features. Applying joins strips these first, which makes
+   * re-application idempotent without keeping a duplicate copy of the base
+   * data (base columns always win a name collision, so a joined column never
+   * shadows one). Not user-editable.
+   */
+  addedFields?: string[];
+  /** Last-run match statistics; see {@link LayerJoinStats}. */
+  stats?: LayerJoinStats;
+}
+/** Edit-widget kinds the Attribute Form designer can assign to a field. */
+type AttributeFormWidget = "text" | "number" | "range" | "checkbox" | "date" | "valueMap";
+/** One selectable entry of a `valueMap` widget (stored value + display label). */
+interface AttributeFormValueMapEntry {
+  /** The value written to the feature property (compared as a string). */
+  value: string;
+  /** Human-readable label shown in the dropdown; defaults to {@link value}. */
+  label?: string;
+}
+/**
+ * Per-field configuration authored in the Attribute Form designer (layer
+ * properties → Attributes Form, QGIS-style): which edit widget the attribute
+ * editing surfaces render for the field, plus optional expression-based
+ * constraints and conditional visibility. Consumed by the attribute table's
+ * inline editor and the Field Collection capture form; helpers live in
+ * `attribute-form.ts`.
+ */
+interface AttributeFormFieldConfig {
+  /** Feature property key this configuration applies to. */
+  field: string;
+  widget: AttributeFormWidget;
+  /** Display label override shown in forms instead of the raw field name. */
+  alias?: string;
+  /**
+   * When true, a null/empty value fails validation. Checkbox widgets are
+   * exempt: unchecked is a valid state, not a missing value.
+   */
+  required?: boolean;
+  /** Dropdown entries for the `valueMap` widget. */
+  valueMap?: AttributeFormValueMapEntry[];
+  /**
+   * Declared storage type of the field. When set, coercion follows it instead
+   * of guessing from the value map (a text field whose codes are "1" and "2"
+   * still stores strings), and validation rejects values of another type or,
+   * for `integer`, fractional numbers. Service-derived configs (ArcGIS domains)
+   * set it from the field's declared type; designer-authored configs leave it
+   * unset.
+   */
+  valueType?: "string" | "number" | "integer";
+  /** Lower bound for `number`/`range` widgets (inclusive). */
+  min?: number;
+  /** Upper bound for `number`/`range` widgets (inclusive). */
+  max?: number;
+  /** Step for the `range` widget's input. */
+  step?: number;
+  /**
+   * Boolean MapLibre expression that must evaluate to `true` against the
+   * feature's (candidate) properties for the value to be accepted, e.g.
+   * `[">", ["get", "population"], 0]`. Stored as the expression source string
+   * the Expression Builder edits.
+   */
+  constraintExpression?: string;
+  /** Human-readable message shown when the constraint fails. */
+  constraintDescription?: string;
+  /**
+   * Boolean MapLibre expression controlling whether the field is shown in
+   * attribute forms; `false` hides the field (and skips its validation).
+   * Empty/invalid expressions fail open so a typo cannot hide data entry.
+   */
+  visibilityExpression?: string;
+}
+/** The Attribute Form designer's whole per-layer configuration. */
+interface AttributeFormConfig {
+  fields: AttributeFormFieldConfig[];
+}
+/** Point of contact recorded in a layer's {@link LayerDescriptiveMetadata}. */
+interface LayerMetadataContact {
+  name?: string;
+  email?: string;
+  organization?: string;
+}
+/** A related resource recorded in a layer's {@link LayerDescriptiveMetadata}. */
+interface LayerMetadataLink {
+  /** Absolute URL of the resource. */
+  href: string;
+  /** Relation type (STAC/IANA link relation such as `"license"` or `"related"`). */
+  rel?: string;
+  /** Human-readable label. */
+  title?: string;
+}
+/**
+ * Time span the layer's data covers. Each bound is an ISO 8601 date
+ * (`YYYY-MM-DD`) or date-time; either may be omitted for an open interval.
+ */
+interface LayerMetadataTemporalExtent {
+  start?: string;
+  end?: string;
+}
+/**
+ * User-authored, catalog-style description of a layer (issue #2858), edited in
+ * the layer's Metadata dialog and exported as a STAC Item. Distinct from the
+ * internal {@link GeoLibreLayer.metadata} record the renderers and plugins key
+ * off: every field here is free-form documentation that changes nothing about
+ * how the layer renders. Helpers live in `layer-descriptive-metadata.ts`.
+ */
+interface LayerDescriptiveMetadata {
+  title?: string;
+  /** Free-text summary of the data (STAC `description`, ISO abstract). */
+  abstract?: string;
+  keywords?: string[];
+  /** SPDX license identifier (e.g. `"CC-BY-4.0"`) or free text. */
+  license?: string;
+  /** Credit line for the data's producers. */
+  attribution?: string;
+  contact?: LayerMetadataContact;
+  /** How the data was produced: sources and processing steps. */
+  lineage?: string;
+  temporalExtent?: LayerMetadataTemporalExtent;
+  links?: LayerMetadataLink[];
+}
+/**
+ * How a popup renders one field's value (issue #2113). `"auto"` reproduces the
+ * untyped rendering the Identify popup has always done — sanitized KML
+ * `description` markup, an inline `data:image/*;base64` value as a thumbnail,
+ * anything else stringified. The remaining kinds are explicit author choices
+ * so a popup never has to guess from the value.
+ */
+type PopupFieldKind = "auto" | "text" | "number" | "date" | "link" | "image";
+/** How a `"date"` field's value is written out. */
+type PopupDateFormat = "date" | "datetime" | "time" | "iso" | "year";
+/** Value formatting for one popup field. Every part is optional. */
+interface PopupFieldFormat {
+  /** Fixed number of decimals for a `"number"` field. */
+  decimals?: number;
+  /** Group thousands with the locale's separator (`"number"` fields). */
+  thousands?: boolean;
+  /** Date rendering for a `"date"` field; defaults to `"date"`. */
+  dateFormat?: PopupDateFormat;
+  /** Text placed before the formatted value. */
+  prefix?: string;
+  /** Text placed after the formatted value, e.g. a unit suffix. */
+  suffix?: string;
+  /** Link text for a `"link"` field; the value itself is used when unset. */
+  linkLabel?: string;
+}
+/** One field's entry in a layer's popup configuration. */
+interface PopupFieldConfig {
+  /** Feature property key. */
+  field: string;
+  /** Display label shown instead of the raw field name. */
+  label?: string;
+  /** How the value renders; defaults to `"auto"`. */
+  kind?: PopupFieldKind;
+  format?: PopupFieldFormat;
+  /** Include this field in the hover tooltip's short subset. */
+  hover?: boolean;
+}
+/**
+ * Per-layer configuration for what a viewer sees when they interact with a
+ * feature (issue #2113): which fields the Identify popup shows, in what order,
+ * under what labels and formatting, plus an optional hover tooltip.
+ *
+ * A layer with no `popup` block behaves exactly as it did before this existed:
+ * the layer name as the heading, then every property as a key/value row.
+ * {@link GeoLibreLayer.fieldVisibility} stays authoritative — a `"hidden"` or
+ * `"excluded"` field is dropped even when a popup config names it.
+ */
+interface LayerPopupConfig {
+  /** `false` suppresses the Identify popup for this layer. Defaults to `true`. */
+  click?: boolean;
+  /** `true` shows a hover tooltip built from the `hover` fields. Defaults to `false`. */
+  hover?: boolean;
+  /** Field whose value titles the popup instead of the layer name. */
+  titleField?: string;
+  /**
+   * MapLibre expression source producing the popup title. Wins over
+   * {@link titleField}; when it fails or produces nothing the title falls
+   * through to `titleField`, and only then to the layer name.
+   */
+  titleExpression?: string;
+  /**
+   * MapLibre expression source producing the whole popup body as text, for
+   * authors who want a sentence rather than a table. When it evaluates, it
+   * replaces the field rows.
+   */
+  bodyExpression?: string;
+  /** `false` drops the synthetic `id` row. Defaults to `true`. */
+  showFeatureId?: boolean;
+  /**
+   * Widest the click popup may grow, in CSS pixels. Unset keeps the default
+   * (520px, or 420px for a popup carrying an image). Clamped to the range
+   * `resolvePopupMaxWidth` enforces and always capped by the viewport, so a
+   * value wider than the window still leaves the map usable.
+   */
+  maxWidth?: number;
+  /**
+   * Tallest an `"image"` field's thumbnail may draw inside the popup, in CSS
+   * pixels. Unset keeps the default (`min(50vh, 420px)`). Clamped by
+   * `resolvePopupImageHeight`. Pair it with {@link maxWidth} for a
+   * bigger picture: the thumbnail keeps its aspect ratio, so widening the
+   * popup is what lets a landscape photo use the extra height.
+   */
+  imageHeight?: number;
+  /**
+   * The fields to show and their order. An empty or absent list keeps today's
+   * behavior: every visible property, in the feature's own key order.
+   */
+  fields?: PopupFieldConfig[];
+}
+/**
+ * A virtual field attached to a vector layer (QGIS Field Calculator → "Create
+ * virtual field", issue #1321): a column defined by a MapLibre expression that
+ * recomputes live instead of being written once as static values. The engine
+ * (`virtual-fields.ts`) materializes the computed values into the layer's
+ * feature properties — so the attribute table, Expression Builder,
+ * data-driven styling, labels, and selection all see the column with no
+ * further wiring — and re-derives them whenever the layer's data (or its
+ * joins) change. Definitions persist in `.geolibre.json` and re-resolve on
+ * project load; the expression is a declarative MapLibre expression (never
+ * arbitrary code), so re-evaluating it from a shared project file is safe.
+ */
+interface LayerVirtualField {
+  /** Stable id for list edits. */
+  id: string;
+  /** The output column name. A name already taken by a base column is skipped. */
+  name: string;
+  /**
+   * MapLibre expression source (JSON text, e.g. `["/", ["get", "pop"],
+   * ["get", "area_km2"]]`) evaluated against each feature.
+   */
+  expression: string;
+  /** `false` detaches the computed column without deleting the definition. */
+  enabled?: boolean;
+  /**
+   * Bookkeeping written by the engine: the column name actually materialized
+   * on the last apply, absent when the field was disabled, failed to compile,
+   * or was skipped because the name collided with an existing column.
+   * Applying virtual fields strips these first, which makes re-application
+   * idempotent (an existing column is never shadowed, so stripping exactly
+   * restores the pre-apply properties). Not user-editable.
+   */
+  addedField?: string;
+  /** Compile error from the last apply, when the expression failed to parse. */
+  error?: string;
+  /**
+   * Features whose evaluation threw at runtime on the last apply (their cell
+   * is null). Surfaced so the UI can warn without one bad feature aborting
+   * the whole column.
+   */
+  errorCount?: number;
+}
+/**
+ * Quick filters (issue #2114): the data-driven filter controls a layer offers
+ * in its Quick Filters section. What persists is the *control state* — field,
+ * kind, chosen values — not the compiled output; `quick-filters.ts` compiles it
+ * to a MapLibre filter at sync time so a saved filter can always be reopened
+ * and edited.
+ */
+/** Which control a quick filter renders, and how it compiles. */
+type QuickFilterKind = "categorical" | "range" | "date" | "text";
+/** The comparison a `text` quick filter applies (always case-insensitive). */
+type QuickFilterTextOperator = "contains" | "startsWith" | "equals";
+/**
+ * How a date field stores its values, deciding whether a `date` quick filter
+ * compares ISO text or epoch numbers. `iso` covers both `YYYY-MM-DD` and full
+ * `YYYY-MM-DDTHH:MM:SSZ` timestamps: only the leading `YYYY-MM-DD` slice is
+ * compared, so a trailing time, a milliseconds fraction, or a `Z` cannot break
+ * a boundary. Mirrors (deliberately, in a smaller form) the value kinds the
+ * Time Slider's `detectValueKind` reports.
+ */
+type QuickFilterDateKind = "iso" | "epochMs" | "epochS";
+/** A single filter control persisted on a layer. */
+interface LayerQuickFilter {
+  /** Stable id, used as the React key and for edits/removal. */
+  id: string;
+  /** The feature property this control narrows. */
+  field: string;
+  kind: QuickFilterKind;
+  /**
+   * `false` keeps the control configured but inert, so a filter can be muted
+   * without losing the values chosen for it. Defaults to enabled.
+   */
+  enabled?: boolean;
+  /**
+   * `categorical`: the chosen values. An empty (or omitted) selection means
+   * "every value" and compiles to nothing — unchecking the last box clears the
+   * filter rather than emptying the map.
+   */
+  values?: (string | number | boolean)[];
+  /** `range`: inclusive bounds. `null`/omitted leaves that side open. */
+  min?: number | null;
+  max?: number | null;
+  /**
+   * `date`: inclusive `YYYY-MM-DD` bounds. The end day is included in full, so
+   * a timestamp field filtered to a single day keeps that whole day.
+   */
+  start?: string | null;
+  end?: string | null;
+  /** `date`: how the field stores its values. Defaults to `iso`. */
+  dateKind?: QuickFilterDateKind;
+  /** `text`: the comparison. Defaults to `contains`. */
+  operator?: QuickFilterTextOperator;
+  /** `text`: the needle. Blank means no constraint. */
+  text?: string;
+}
+/** Persisted refresh policy and most recent synchronization result for a layer. */
+interface LayerConnection {
+  /** Owning layer id. Repeated here so records remain self-describing when exported. */
+  layerId: string;
+  /** Automatic refresh cadence in seconds, or null for manual synchronization only. */
+  interval: number | null;
+  /** ISO timestamp of the most recent successful synchronization. */
+  lastSyncedAt: string | null;
+  /** Most recent synchronization error. Cleared by a successful synchronization. */
+  lastError: string | null;
+  /** Whether a failed synchronization retains the last good data or clears it. */
+  onFailure: "keep-last" | "clear";
+}
+/**
+ * Configuration for automatic feature editor tracking (Issue #1677).
+ * Maintains `created_by`, `created_at`, `edited_by`, `edited_at` fields
+ * automatically when features are created or updated.
+ */
+interface EditorTrackingConfig {
+  /** `true` enables automatic creation/edit timestamp and author stamping. */
+  enabled: boolean;
+  /** Field name for creation author (default `"created_by"`). */
+  createdByField?: string;
+  /** Field name for creation timestamp (default `"created_at"`). */
+  createdAtField?: string;
+  /** Field name for last-edit author (default `"edited_by"`). */
+  editedByField?: string;
+  /** Field name for last-edit timestamp (default `"edited_at"`). */
+  editedAtField?: string;
+}
+/**
+ * Visibility of a layer's attribute field.
+ * - "hidden": Not shown in the attribute table, identify popup, tooltips, or field pickers, but remains in the data.
+ * - "excluded": Removed entirely from the data when the project is shared or exported.
+ */
+type FieldVisibility = "hidden" | "excluded";
+/**
+ * Explicit capability flags defining what actions a user/session may perform on a layer.
+ * Any omitted capability falls back to the inferred default behavior for that layer's source.
+ */
+interface LayerCapabilities {
+  /** Can the layer's features or attributes be queried / identified. */
+  query?: boolean;
+  /** Can new features be created/added to the layer. */
+  create?: boolean;
+  /** Can existing features/attributes be modified. */
+  update?: boolean;
+  /** Can features be deleted from the layer. */
+  delete?: boolean;
+  /** Can the layer data/symbology be exported/downloaded. */
+  export?: boolean;
+}
+/**
+ * Application privilege identifiers defining discrete capabilities in GeoLibre.
+ */
+type AppPrivilege = "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 named roles bundling application privileges.
+ */
+type AppRole = "viewer" | "editor" | "publisher" | "administrator" | "custom";
+/**
+ * Ephemeral application capabilities state defining the active role, effective privileges,
+ * and optional restriction reason for the current session/deployment.
+ */
+interface AppCapabilities {
+  /**
+   * The assigned application role. `custom` once an ad-hoc `grantAppPrivilege` /
+   * `revokeAppPrivilege` has moved the set away from the bundle a named role
+   * defines, so the role never claims a shape the privileges do not have.
+   */
+  role: AppRole;
+  /** List of granted privileges for the active role or custom configuration. */
+  privileges: AppPrivilege[];
+  /**
+   * Optional human-readable reason covering the whole set (e.g. "Action disabled
+   * by deployment policy"), used for any privilege without its own.
+   */
+  reason?: string;
+  /**
+   * Per-privilege reasons, and why they exist: two privileges can be withheld by
+   * different causes — a role bundle plus a licence limit, say — and a single
+   * `reason` would make the second revocation relabel the first, so every gate
+   * would explain itself with whichever cause happened to be recorded last.
+   * Takes precedence over `reason` for the privileges it names.
+   */
+  privilegeReasons?: Partial<Record<AppPrivilege, string>>;
+}
+interface GeoLibreLayer {
+  id: string;
+  name: string;
+  type: LayerType;
+  source: Record<string, unknown>;
+  visible: boolean;
+  opacity: number;
+  style: LayerStyle;
+  metadata: Record<string, unknown>;
+  beforeId?: string;
+  geojson?: FeatureCollection;
+  /** A SQL Server write needs a successful table reread before it may be submitted again. */
+  mssqlWritebackPending?: boolean;
+  /**
+   * Explicit capability set for the layer (query, create, update, delete, export).
+   * Unset capabilities default to the inferred behavior for the layer's source kind.
+   */
+  capabilities?: LayerCapabilities;
+  /**
+   * Automatic editor tracking configuration for feature creation/updates.
+   */
+  editorTracking?: EditorTrackingConfig;
+  /**
+   * Field-level visibility overrides. Fields marked as "excluded" are physically
+   * removed from the data during export and sharing.
+   */
+  fieldVisibility?: Record<string, FieldVisibility>;
+  /**
+   * Per-field edit-widget, constraint, and visibility configuration authored
+   * in the Attribute Form designer. Applied by the attribute editing surfaces
+   * (attribute table inline editor, Field Collection capture form); persists
+   * with the project like {@link joins}.
+   */
+  attributeForm?: AttributeFormConfig;
+  /**
+   * Popup and hover-tooltip design for this layer, authored in the Style
+   * panel's Popup section. Absent means the default full-property dump.
+   */
+  popup?: LayerPopupConfig;
+  /**
+   * User-authored catalog metadata (title, abstract, keywords, license,
+   * contact, lineage, temporal extent, links), edited in the layer's Metadata
+   * dialog. Absent when nothing has been entered; an empty record is never
+   * written to a project file.
+   */
+  descriptiveMetadata?: LayerDescriptiveMetadata;
+  /**
+   * Persistent attribute joins applied to this layer's features, in order.
+   * The joined columns are materialized into `geojson` feature properties (so
+   * the attribute table, Expression Builder, styling, and labels all see them)
+   * and re-derived whenever the layer's or a join table's data changes.
+   */
+  joins?: LayerJoin[];
+  /**
+   * Expression-backed virtual fields computed for this layer's features, in
+   * order. Applied after joins (so an expression can read joined columns) and
+   * materialized into `geojson` feature properties; re-derived whenever the
+   * layer's data changes. See {@link LayerVirtualField}.
+   */
+  virtualFields?: LayerVirtualField[];
+  /**
+   * Transient MapLibre filter expression applied on top of every rendered
+   * sub-layer's geometry filter. The Time Slider plugin sets this on a bound
+   * vector layer so scrubbing the timeline narrows the visible features to the
+   * current time window, while the layer's own styling and opacity stay
+   * untouched. It is derived from the slider's current date, so it is NOT
+   * persisted (stripped by `prepareLayerForSave`); the binding config lives in
+   * `metadata.timeBinding` and the filter is recomputed live on the next
+   * activation. `undefined` means no time filter is applied.
+   */
+  timeFilter?: unknown[];
+  /** Transient MapLibre expression applied by the iframe embed API. */
+  embedFilter?: unknown[];
+  /**
+   * Project-persisted boolean MapLibre expression that narrows the features
+   * rendered for this layer. Unlike a selection, this leaves the source data
+   * intact and keeps non-matching features hidden until the filter is cleared.
+   * It is composed with transient filters, quick filters, and rule visibility
+   * by the map renderers.
+   */
+  filterExpression?: unknown[];
+  /**
+   * Data-driven filter controls authored in the layer's Quick Filters section
+   * (issue #2114). Unlike {@link timeFilter} and {@link embedFilter} this is
+   * persisted control *state*, not a compiled expression: `@geolibre/map`
+   * compiles it at sync time (see `compileQuickFilters`) and combines the
+   * result with the transient filters and the rule-based visibility filter, so
+   * a host page's filter and a user's filter narrow the layer together.
+   */
+  quickFilters?: LayerQuickFilter[];
+  sourcePath?: string;
+  /**
+   * Id of the {@link LayerGroup} this layer belongs to, or `undefined` when the
+   * layer sits at the top level of the layer panel. Layers sharing a `groupId`
+   * are kept contiguous in the store's flat `layers` array so the group renders
+   * as one block; see `@geolibre/core`'s `layer-groups` helpers.
+   */
+  groupId?: string;
+  /**
+   * Project-persisted connection policy for reloadable layers. Runtime timers
+   * are reconstructed from this record when a project opens.
+   */
+  connection?: LayerConnection;
+}
+/**
+ * Options for {@link AppState.addTileLayer}: a native raster tile layer (XYZ,
+ * WMS, or WMTS) that appears in the Layers panel and persists with the project,
+ * just like a layer added through the Add Data dialog. Mirrors the raster
+ * `source` fields MapLibre understands so an external plugin can register tile
+ * layers without touching the map directly.
+ */
+interface AddTileLayerOptions {
+  /**
+   * One or more XYZ tile URL templates (with `{x}`/`{y}`/`{z}` placeholders).
+   * At least one non-empty template is required, or the layer renders nothing.
+   */
+  tiles: string[];
+  /**
+   * Layer discriminator, controlling how the layer is labelled and (for WMS)
+   * dev-server proxied. Defaults to `"xyz"`. The layer's `source.type` is
+   * always `"raster"`, so any other value (such as `"vector-tiles"` from an
+   * untyped JS caller) throws rather than persisting a mislabelled source.
+   */
+  type?: "xyz" | "wms" | "wmts" | "raster";
+  /** Service or base URL recorded on the source for display and restore. */
+  url?: string;
+  /** Tile size in pixels (default 256). */
+  tileSize?: number;
+  /** Attribution string shown in the map's attribution control. */
+  attribution?: string;
+  /** Visible extent as `[west, south, east, north]` in WGS84 degrees. */
+  bounds?: [number, number, number, number];
+  /** Minimum zoom at which tiles are requested. */
+  minzoom?: number;
+  /** Maximum zoom at which tiles are requested. */
+  maxzoom?: number;
+  /** Tile y-axis scheme; `"tms"` flips the y origin. Defaults to `"xyz"`. */
+  scheme?: "xyz" | "tms";
+  /** Initial visibility (default true). */
+  visible?: boolean;
+  /** Initial opacity in [0, 1] (default 1). */
+  opacity?: number;
+  /**
+   * Extra source fields merged onto the layer's `source` (e.g. the WMS
+   * `layers`/`styles`/`format` recorded for restore). The required `type`,
+   * `tiles`, and `tileSize` always win over keys supplied here.
+   */
+  source?: Record<string, unknown>;
+  /** Extra metadata merged onto the layer record. */
+  metadata?: Record<string, unknown>;
+}
+/**
+ * A named, collapsible folder in the layer panel that organizes a contiguous
+ * run of layers. Groups may be nested by referencing another group as their
+ * parent; the root groups omit `parentId`.
+ *
+ * The group's `visible` flag and `opacity` multiplier are folded into each
+ * child layer's effective render state by `applyGroupEffects` before the map
+ * syncs, so children keep their own stored `visible`/`opacity` values.
+ */
+interface LayerGroup {
+  id: string;
+  name: string;
+  /** Parent folder id, or undefined when this folder is at the panel root. */
+  parentId?: string;
+  /** When true, the group's children are hidden in the panel (not on the map). */
+  collapsed: boolean;
+  /** Group-level visibility; ANDed with each child layer's own visibility. */
+  visible: boolean;
+  /** Group-level opacity in [0, 1]; multiplied into each child's opacity. */
+  opacity: number;
+}
+/**
+ * Metadata `sourceKind` marking a live SQL query layer: a GeoJSON-backed layer
+ * created from a SQL Workspace result whose DuckDB statement is stored on the
+ * layer metadata and re-executed on refresh. Defined here so the desktop app
+ * (which owns the query/refresh logic) and `@geolibre/plugins` (which excludes
+ * these layers from in-place geometry editing) share one value.
+ */
+declare const SQL_QUERY_SOURCE_KIND = "sql-query";
+/**
+ * Metadata `sourceKind` marking a NetCDF/HDF grid baked into an `image` overlay,
+ * as opposed to the KML ground overlays that otherwise use that layer type.
+ *
+ * Defined here so `@geolibre/map` (which must not run its feature-query identify
+ * on these) and the desktop app (which owns the symbology panel, the pixel
+ * readout, and the spectral profile) share one value.
+ */
+declare const NETCDF_IMAGE_SOURCE_KIND = "netcdf-image";
+/**
+ * Detect a DuckDB query layer rendered through the plugin's external deck.gl
+ * overlay. Shared by `@geolibre/map`, `@geolibre/plugins`, and the desktop
+ * app so the detection criteria cannot drift.
+ */
+declare function isDuckDBQueryLayer(layer: Pick<GeoLibreLayer, "metadata" | "type"> | undefined): boolean;
+interface MapViewState {
+  center: [number, number];
+  zoom: number;
+  bearing: number;
+  pitch: number;
+  bbox?: [number, number, number, number];
+}
+/**
+ * Multi-map (split/grid) support. The workspace can show several map panes in a
+ * `rows x cols` grid. Pane 0 is always the *primary* map: it keeps the existing
+ * single-map wiring (the global `mapView` + `basemap*` fields, the layer/style
+ * panels, plugins, deck.gl). Panes 1..N are *secondary* maps described by
+ * `SecondaryMapView` records: every pane shares the same basemap and the same
+ * `layers`, but each secondary pane may override which layers are visible so
+ * different panes can show different layers. When `syncView` is on,
+ * panning/zooming any pane mirrors the camera to every other pane.
+ */
+interface MapGridLayout {
+  /** Grid rows (>= 1). */
+  rows: number;
+  /** Grid columns (>= 1). `rows * cols` is the total number of panes. */
+  cols: number;
+  /** When true, all panes share a synchronized camera. */
+  syncView: boolean;
+}
+/**
+ * Which engine draws a map pane.
+ *
+ * `"maplibre"` is the 2D MapLibre GL map that owns the app's plugin, styling,
+ * and deck.gl integrations. `"cesium"` is the 3D globe (see `CesiumCanvas`),
+ * which renders the same shared store state — camera, basemap, layers, group
+ * effects — through CesiumJS. `"mapbox"` is Mapbox GL JS and `"arcgis"` the
+ * ArcGIS Maps SDK for JavaScript, loaded from Esri's CDN at runtime (see
+ * `ArcgisCanvas`); both draw the same store state through their own engines.
+ *
+ * Used both for secondary panes ({@link SecondaryMapView.viewKind}) and for the
+ * primary workspace ({@link GeoLibreProject.primaryRenderer}), so the two never
+ * drift apart.
+ */
+type MapRendererKind = "maplibre" | "cesium" | "mapbox" | "arcgis";
+/**
+ * The engine that draws the primary map area when a project says nothing. The
+ * 2D map: it is the renderer every tool, plugin, and panel is wired to, so an
+ * existing project (and a new one) opens exactly as it always did.
+ */
+declare const DEFAULT_PRIMARY_RENDERER: MapRendererKind;
+/**
+ * A non-primary map pane: shares the primary map's basemap and layers, with its
+ * own camera and per-layer visibility overrides.
+ */
+interface SecondaryMapView {
+  /** Stable id, used as the React key and the sync-group registration id. */
+  id: string;
+  view: MapViewState;
+  /** Optional user-entered label shown on the pane (e.g. a date or scenario). */
+  label?: string;
+  /**
+   * Which rendering engine draws this pane. Defaults to `"maplibre"` (the 2D
+   * map) when absent, so existing projects and panes are unchanged. `"cesium"`
+   * renders a 3D globe (see {@link CesiumCanvas}) over the same shared layers.
+   */
+  viewKind?: MapRendererKind;
+  /**
+   * Per-layer visibility overrides keyed by layer id. A layer absent from this
+   * map inherits the primary map's visibility (`layer.visible`); an entry forces
+   * the layer visible (`true`) or hidden (`false`) in this pane only.
+   */
+  layerVisibility: Record<string, boolean>;
+}
+/** The default single-map grid (one pane, sync enabled so it turns on cleanly). */
+declare const DEFAULT_MAP_GRID_LAYOUT: MapGridLayout;
+/** Maximum rows or columns in the map grid (so at most a 4x4 = 16-pane grid). */
+declare const MAX_MAP_GRID_DIM = 4;
+/**
+ * Live multi-user collaboration (issue #307). These types describe the
+ * *ephemeral* session state the store holds while a live session is active. It
+ * is intentionally never written to the `.geolibre.json` project file (the
+ * `project.ts` serializers never read it) and never tracked in undo history (the
+ * store's `partialize` never lists it), so it resets cleanly on reload.
+ */
+type CollaborationRole = "host" | "guest";
+/** Whether guests may edit (`co-edit`) or only watch (`view-only`). */
+type CollaborationMode = "view-only" | "co-edit";
+interface ParticipantIdentity {
+  provider: string;
+  userId: string;
+  username: string;
+}
+interface CollabInvite {
+  token: string;
+  role: CollaborationMode;
+  createdAt: number;
+  maxUses?: number;
+  useCount: number;
+  revoked: boolean;
+}
+interface CollaborationParticipant {
+  clientId: string;
+  displayName: string;
+  color: string;
+  role: CollaborationRole;
+  /**
+   * Host-set per-participant edit override (#754). `null` follows the session
+   * `mode`; `true`/`false` pins this participant to can-edit / view-only. Always
+   * `null` for the host (the host can always edit).
+   */
+  editOverride: boolean | null;
+  /** Optional account identity when signed-in identity binding is enabled. */
+  identity?: ParticipantIdentity | null;
+}
+/** A remote participant's live cursor + viewport, used to render presence. */
+interface CollaborationPresence {
+  displayName: string;
+  color: string;
+  cursor?: {
+    lng: number;
+    lat: number;
+  } | null;
+  view?: MapViewState | null;
+}
+/** One in-session chat message (#754). Ephemeral; never persisted to a project. */
+interface CollaborationChatMessage {
+  /** Server-assigned id (stable React key / dedupe). */
+  id: string;
+  /** clientId of the author. */
+  clientId: string;
+  displayName: string;
+  color: string;
+  text: string;
+  /** Optional map coordinate the author attached; clickable to recenter. */
+  coordinate?: {
+    lng: number;
+    lat: number;
+  } | null;
+  /** Server-assigned epoch-ms timestamp. */
+  ts: number;
+}
+interface CollaborationState {
+  /** True once connected and joined to a session. */
+  isActive: boolean;
+  /** True while connecting/reconnecting (UI shows a spinner). */
+  connecting: boolean;
+  sessionId: string | null;
+  clientId: string | null;
+  role: CollaborationRole | null;
+  mode: CollaborationMode;
+  selfName: string;
+  selfColor: string;
+  participants: CollaborationParticipant[];
+  /** Remote presence keyed by participant clientId (never includes self). */
+  presence: Record<string, CollaborationPresence>;
+  /** When true, this participant's camera follows the host's viewport. */
+  followHost: boolean;
+  /** Recent session chat, oldest first, capped to a bounded window (#754). */
+  chat: CollaborationChatMessage[];
+  /** Session flag requiring participants to be signed in. */
+  requireIdentity: boolean;
+  /**
+   * Whether the connected relay has an identity issuer configured. False (the
+   * default) means it cannot verify a sign-in, so the host UI hides the
+   * "require a signed-in account" toggle instead of offering a gate that would
+   * lock every guest out.
+   */
+  identitySupported: boolean;
+  /** Layer IDs marked locked by the host. */
+  lockedLayerIds: string[];
+  /** Active session invites minted by host. */
+  invites: CollabInvite[];
+  /** Last human-readable error, surfaced in the Collaborate dialog. */
+  error: string | null;
+}
+/** Map projection the renderer uses. Mirrors the GlobeControl toggle. */
+type MapProjection = "globe" | "mercator";
+/**
+ * Unit system the scale bar reports distances in. `"metric"` uses m/km,
+ * `"imperial"` uses ft/mi, and `"nautical"` uses nautical miles.
+ */
+type MapScaleUnit = "metric" | "imperial" | "nautical";
+interface MapPreferences {
+  restrictBounds: boolean;
+  bounds: [number, number, number, number];
+  minZoom: number;
+  maxZoom: number;
+  maxPitch: number;
+  renderWorldCopies: boolean;
+  projection: MapProjection;
+  /**
+   * Celestial body / ellipsoid the project's coordinates describe (keys into the
+   * ellipsoid registry in `@geolibre/core`). Drives measurement radii and pairs
+   * with planetary basemaps. Defaults to `"earth"` (WGS 84).
+   */
+  ellipsoidId: string;
+  /**
+   * Unit system the scale bar displays. Defaults to `"metric"`; switch to
+   * `"imperial"` for feet/miles or `"nautical"` for nautical miles.
+   */
+  scaleUnit: MapScaleUnit;
+  /**
+   * Whether the status bar resolves and shows the ground elevation under the
+   * pointer (issue #1813). **Defaults to `false`**: with 3D terrain off the
+   * lookup falls back to the public Open-Meteo service, so hovering would send
+   * coordinates off the device for a readout the user never asked for. Toggled
+   * from Controls -> Elevation.
+   */
+  showPointerElevation: boolean;
+  /** Whether the built-in 3D terrain control and terrain surface are enabled. */
+  terrainEnabled: boolean;
+  /**
+   * Optional Cesium Ion terrain asset used by the globe when terrain is enabled.
+   * Ignored by 2D renderers; absent means the renderer's normal global source.
+   */
+  terrainIonAssetId?: number;
+  /** Mapbox-only style. New projects use Streets; absent follows the shared basemap. */
+  mapboxStyleUrl?: string;
+  /**
+   * ArcGIS-only basemap: an Esri basemap style id (`arcgis/streets`,
+   * `arcgis/imagery`, `osm/standard`, ...). New projects use Streets. Absent
+   * follows the shared basemap, translated to tiles the SDK can draw; the id
+   * is also set aside when no ArcGIS API key is configured, since Esri's
+   * basemap styles service requires one.
+   */
+  arcgisBasemap?: string;
+  /**
+   * ArcGIS-only projection of the flat map, as a WKID the ArcGIS Maps SDK
+   * resolves (`54099` Spilhaus, `54030` Robinson, ...). Absent means Web
+   * Mercator. Vector layers are reprojected on the client; tiled layers and
+   * basemaps cannot be, so they do not draw in another projection. The globe
+   * (a `SceneView`) ignores it. See `arcgis-projection.ts`.
+   */
+  arcgisWkid?: number;
+  /** Cesium imagery override; absent follows the shared project basemap. */
+  cesiumBasemap?: CesiumBasemapId;
+  /**
+   * Notation the status bar reports the pointer coordinate in: `"dd"` decimal
+   * degrees (default), `"dms"` degrees/minutes/seconds, `"ddm"` degrees and
+   * decimal minutes, `"utm"` zone easting/northing, `"mgrs"`/`"usng"` grid
+   * references, or `"epsg"` x/y in the CRS named by `coordinateEpsgCode`.
+   * Stored as a string rather than a union so `@geolibre/core` does not have to
+   * depend on the formatter, which lives with the app's DMS helpers and the
+   * Gridlines plugin's UTM projection; the app normalises unknown values to
+   * `"dd"`.
+   */
+  coordinateFormat: string;
+  /**
+   * EPSG code the `"epsg"` coordinate format projects the pointer into, e.g.
+   * `3857` or `32618`. Kept beside `coordinateFormat` rather than inside it so
+   * the code survives cycling through the other notations. Absent means the
+   * app default (EPSG:3857).
+   */
+  coordinateEpsgCode?: number;
+  /**
+   * Whether the map fits to a layer's extent after data is added (Add Data
+   * menus, drag-and-drop, file import, tool outputs). Defaults to `true`; turn
+   * it off to keep the current view. Explicit "Zoom to layer" actions always
+   * fit regardless of this setting.
+   */
+  zoomToNewLayers: boolean;
+}
+interface RuntimeEnvironmentVariable {
+  key: string;
+  value: string;
+  enabled: boolean;
+  /**
+   * Absent or `true`: the value is a secret (desktop keeps it in the OS
+   * keychain; every egress removes it). `false`: an ordinary value saved in the
+   * project and kept on share/export.
+   */
+  secret?: boolean;
+}
+declare global {
+  interface Window {
+    __GEOLIBRE_RUNTIME_ENV__?: Record<string, string>;
+  }
+}
+/**
+ * Geocoding backend selection persisted in the project. The provider id keys
+ * into the geocoding registry in `@geolibre/core`; API keys are stored per
+ * provider so switching backends does not discard the others' keys. Empty
+ * endpoint overrides fall back to the provider's default endpoints.
+ */
+interface GeocodingPreferences {
+  providerId: string;
+  /** Per-provider API key / access token, keyed by provider id. */
+  apiKeys: Record<string, string>;
+  /** Optional custom forward endpoint (else the provider default). */
+  forwardEndpoint?: string;
+  /** Optional custom reverse endpoint (else the provider default). */
+  reverseEndpoint?: string;
+  /** Contact email sent to identify the client (used by Nominatim). */
+  email?: string;
+}
+interface ProjectPreferences {
+  map: MapPreferences;
+  environmentVariables: RuntimeEnvironmentVariable[];
+  geocoding: GeocodingPreferences;
+}
+type ProjectPluginControlPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+interface ProjectPluginState {
+  manifestUrls: string[];
+  activePluginIds: string[];
+  mapControlPositions: Record<string, ProjectPluginControlPosition>;
+  settings: Record<string, unknown>;
+}
+declare const DEFAULT_PROJECT_PREFERENCES: ProjectPreferences;
+/**
+ * A single user override for one legend item, keyed in {@link LegendConfig.overrides}
+ * by a stable item key (a layer id for a whole entry, or `${layerId}::${index}`
+ * for an individual class within a graduated/categorized entry).
+ */
+interface LegendItemOverride {
+  /** User-supplied label that replaces the auto-generated one. */
+  label?: string;
+  /** When true, the item is omitted from the rendered legend. */
+  hidden?: boolean;
+}
+/** Swatch shape for a hand-authored legend item. */
+type LegendCustomShape = "square" | "circle" | "line";
+/** One hand-authored legend item: a color swatch plus its label. */
+interface LegendCustomItem {
+  /** Display label (e.g. an NLCD class name). */
+  label: string;
+  /** Swatch color as a CSS color (typically `#rrggbb`). */
+  color: string;
+  /** Swatch shape; defaults to `"square"`. */
+  shape?: LegendCustomShape;
+  /**
+   * Symbol size in map pixels (circle radius / line width). Carried so that
+   * customizing a proportional-symbol entry keeps the graduated sizes it was
+   * seeded from instead of flattening every symbol to one size.
+   */
+  size?: number;
+}
+/**
+ * A hand-authored legend entry. Keyed by layer id it REPLACES that layer's
+ * auto-derived classes (the fallback when automatic derivation is wrong or
+ * impossible, e.g. a paletted land-cover raster like NLCD); keyed by a
+ * `custom:` id it renders as a standalone section not tied to any layer.
+ */
+interface LegendCustomEntry {
+  /** Optional heading; a layer-keyed entry falls back to the layer name. */
+  title?: string;
+  /** The items to render, top to bottom. */
+  items: LegendCustomItem[];
+}
+/** Map corner the on-map legend panel docks to. */
+type LegendPanelPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+/**
+ * User customizations for the legend (the on-map Legend panel and the Print
+ * Layout legend). The legend itself is always derived from the visible layers'
+ * symbology; this record only stores the edits layered on top (title, ordering,
+ * per-item rename/hide, hand-authored entries), so it survives layer additions
+ * and removals and is persisted in the `.geolibre.json` project.
+ */
+interface LegendConfig {
+  /** Heading drawn above the legend entries. */
+  title: string;
+  /** When true, classes are grouped under a per-layer heading. */
+  groupByLayer: boolean;
+  /**
+   * Custom top-level entry order by layer id, top-first. Layer ids not listed
+   * keep their default order after the listed ones.
+   */
+  order: string[];
+  /** Per-item overrides keyed by stable item key. */
+  overrides: Record<string, LegendItemOverride>;
+  /**
+   * Hand-authored entries keyed by layer id (replacing that layer's
+   * auto-derived classes) or by a standalone `custom:` id. See
+   * {@link LegendCustomEntry}.
+   */
+  customEntries?: Record<string, LegendCustomEntry>;
+  /** Whether the on-map Legend panel is open (persisted with the project). */
+  panelVisible?: boolean;
+  /** Whether the open panel is collapsed to just its header bar. */
+  panelCollapsed?: boolean;
+  /** Map corner the on-map Legend panel docks to; defaults to `"top-left"`. */
+  panelPosition?: LegendPanelPosition;
+  /**
+   * User-resized panel width in px (via the corner drag handles). Absent means
+   * the default width; height absent means auto-fit to content within the map.
+   */
+  panelWidth?: number;
+  /** User-resized panel height in px. See {@link LegendConfig.panelWidth}. */
+  panelHeight?: number;
+}
+declare const DEFAULT_LEGEND_CONFIG: LegendConfig;
+/**
+ * Camera target captured for a story chapter. `pitch` and `bearing` are
+ * optional in memory: a location built in code may omit them, and every engine
+ * then keeps that part of the current camera (see `storyLocationView`). A
+ * chapter read from a project file or a CSV never omits them: loading fills an
+ * absent value with 0 (`normalizeStoryChapter`, `parseStoryMapCsv`), so a file
+ * without them still plays north-up and flat, as it always has.
+ */
+interface StoryChapterLocation {
+  center: [number, number];
+  zoom: number;
+  pitch?: number;
+  bearing?: number;
+}
+/** Where a chapter's text panel sits over the map. */
+type StoryChapterAlignment = "left" | "center" | "right" | "full";
+/** How the map transitions to a chapter's location. */
+type StoryChapterAnimation = "flyTo" | "easeTo" | "jumpTo";
+/** A layer opacity change triggered when a chapter is entered or exited. */
+interface StoryLayerOpacityChange {
+  /** Stable identity for React list keys; optional for older project files. */
+  id?: string;
+  /** GeoLibre store layer id whose opacity should change. */
+  layerId: string;
+  opacity: number;
+  /** Transition duration in milliseconds. */
+  duration?: number;
+}
+/** A single scene in a scroll-driven story map. */
+interface StoryChapter {
+  id: string;
+  title: string;
+  description: string;
+  /** Optional image shown in the chapter panel (URL or data URI). */
+  image?: string;
+  alignment: StoryChapterAlignment;
+  /** Hide the text panel while still transitioning the map. */
+  hidden: boolean;
+  location: StoryChapterLocation;
+  mapAnimation: StoryChapterAnimation;
+  /** Slowly rotate the camera once the transition settles. */
+  rotateAnimation: boolean;
+  onChapterEnter: StoryLayerOpacityChange[];
+  onChapterExit: StoryLayerOpacityChange[];
+}
+type StoryInsetPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+/**
+ * A non-chapter intro/outro slide shown before the first or after the last
+ * chapter (#998). `"none"` disables it. The remaining modes are:
+ * - `"blank"` a solid screen in the panel theme color,
+ * - `"black"` a solid black screen,
+ * - `"global"` a zoomed-out global view of the map with no text,
+ * - `"adjacent"` the camera of the neighboring chapter (the first chapter for
+ *   the start slide, the last chapter for the closing slide) with all text and
+ *   media hidden, so the presenter can zoom into the full content next.
+ */
+type StorySlideMode = "none" | "blank" | "black" | "global" | "adjacent";
+/** A start/closing slide that is actually shown (every mode except `"none"`). */
+type StoryActiveSlideMode = Exclude<StorySlideMode, "none">;
+/** Scroll-driven story map authored on top of a GeoLibre project. */
+interface StoryMap {
+  title: string;
+  subtitle: string;
+  byline: string;
+  footer: string;
+  theme: "light" | "dark";
+  showMarkers: boolean;
+  markerColor: string;
+  inset: boolean;
+  insetPosition: StoryInsetPosition;
+  /**
+   * Start the presentation with the chapter itinerary/navigation panel hidden,
+   * revealing chapters one at a time instead of listing every upcoming location
+   * up front (#995). The presenter still offers a toggle to open the list.
+   */
+  hideChapterNav: boolean;
+  /** Optional intro slide shown before the first chapter (#998). */
+  startSlide: StorySlideMode;
+  /** Optional closing slide shown after the last chapter (#998). */
+  endSlide: StorySlideMode;
+  chapters: StoryChapter[];
+}
+declare const DEFAULT_STORY_MAP: StoryMap;
+/**
+ * One step in a {@link ProcessingModel}: a processing tool invoked with a fixed
+ * set of parameters. The runner chains steps by feeding each step's output layer
+ * into the next step's input layer parameter (`inputParam`, default `"layer"`),
+ * so a step's stored `parameters` for that input is ignored for every step after
+ * the first.
+ */
+interface ProcessingModelStep {
+  /** Stable id, unique within the model (used as the React key and run label). */
+  id: string;
+  /** The processing tool's registry id (e.g. `"buffer"`). */
+  toolId: string;
+  /** Parameter values keyed by the tool's parameter ids. */
+  parameters: Record<string, unknown>;
+  /**
+   * Which `type: "layer"` parameter receives the previous step's output. Defaults
+   * to `"layer"`; set it for tools whose primary input is named differently.
+   */
+  inputParam?: string;
+}
+/**
+ * What flows along a model edge. Vector nodes exchange FeatureCollections;
+ * raster nodes exchange GeoTIFF bytes. A port declaring `"any"` accepts either
+ * and is resolved to a concrete kind at run time by whatever is wired into it.
+ */
+type ModelPortKind = "vector" | "raster" | "any";
+/** One connection point on a {@link ModelGraphNode}. */
+interface ModelGraphPort {
+  /**
+   * Port id, unique within its node and direction. For a tool node's inputs
+   * this is the underlying tool parameter id, so wiring an edge and setting the
+   * parameter by hand are the same operation.
+   */
+  id: string;
+  label: string;
+  kind: ModelPortKind;
+  /** Inputs only: the run fails when nothing is wired in and no value is set. */
+  required?: boolean;
+}
+/**
+ * What a node does. `input` sources an existing project layer, `tool` runs a
+ * processing algorithm, and `output` names a result to add back to the map.
+ */
+type ModelGraphNodeKind = "input" | "tool" | "output";
+/** One node on the Model Builder canvas. */
+interface ModelGraphNode {
+  /** Stable id, unique within the graph; referenced by {@link ModelGraphEdge}. */
+  id: string;
+  kind: ModelGraphNodeKind;
+  /** Canvas position in graph coordinates (unscaled by zoom). */
+  x: number;
+  y: number;
+  /** `input` nodes: the project layer id this node sources. */
+  layerId?: string;
+  /**
+   * `tool` nodes: the tool's id within {@link provider}'s registry. Kept
+   * separate from the provider so the same short id can exist in both.
+   */
+  toolId?: string;
+  /** `tool` nodes: which registry resolves {@link toolId}. */
+  provider?: ModelToolProvider;
+  /** `tool` nodes: parameter values for everything not supplied by an edge. */
+  parameters?: Record<string, unknown>;
+  /** `output` nodes: the layer name given to the result added to the map. */
+  name?: string;
+}
+/**
+ * A directed connection from one node's output port to another node's input
+ * port. Ports are named, so a tool with several inputs (Clip's target and
+ * overlay, say) wires each one unambiguously.
+ */
+interface ModelGraphEdge {
+  id: string;
+  from: string;
+  fromPort: string;
+  to: string;
+  toPort: string;
+}
+/** The node-and-edge graph authored on the Model Builder canvas. */
+interface ProcessingModelGraph {
+  nodes: ModelGraphNode[];
+  edges: ModelGraphEdge[];
+}
+/** Which registry a {@link ModelGraphNode.toolId} is resolved against. */
+type ModelToolProvider = "vector" | "whitebox";
+/**
+ * A reusable processing pipeline ("model" in QGIS Graphical Modeler / ArcGIS
+ * ModelBuilder terms), saved in the project file so it can be reloaded and
+ * re-run.
+ *
+ * Two shapes coexist. {@link steps} is the original strictly linear chain, and
+ * remains the only thing older builds understand. {@link graph} is the
+ * Model Builder's directed graph, which supports multi-input tools, branches
+ * and merges. When both are present `graph` wins; a model saved by the canvas
+ * also writes a `steps` projection whenever its graph happens to be a single
+ * chain, so older builds can still run it.
+ */
+interface ProcessingModel {
+  id: string;
+  name: string;
+  steps: ProcessingModelStep[];
+  graph?: ProcessingModelGraph;
+}
+/**
+ * Which dialog family executed a {@link ProcessingRun}. Drives the History
+ * panel's re-run routing: each kind maps to the dialog (and store open-flag)
+ * that can be reopened pre-filled with the run's parameters.
+ */
+type ProcessingRunKind = "vector" | "statistics" | "network" | "whitebox" | "raster" | "conversion" | "algorithm";
+type ProcessingRunStatus = "success" | "error";
+/** Upper bound on persisted processing-history entries (oldest are dropped). */
+declare const MAX_PROCESSING_HISTORY = 100;
+/**
+ * One recorded processing tool run (issue #1292). Appended by every processing
+ * dialog when a run finishes and persisted in the project file, so a saved
+ * project documents how its derived layers were produced. Parameter values are
+ * stored exactly as the dialog dispatched them (layer parameters hold layer
+ * ids), which is what re-run pre-fills and "Copy as Python" emit.
+ */
+interface ProcessingRun {
+  /** Stable id, unique within the project (React key and update key). */
+  id: string;
+  kind: ProcessingRunKind;
+  /** The tool's registry id (e.g. `"buffer"`, `"slope"`). */
+  toolId: string;
+  /** Human-readable tool name captured at run time. */
+  toolName: string;
+  /** Engine that executed the run: `client`, `wasm`, `sidecar`, `pyodide`, `browser`. */
+  engine: string;
+  /** Parameter values keyed by the tool's parameter ids. */
+  parameters: Record<string, unknown>;
+  /** Names of input layers referenced by layer parameters, keyed by layer id. */
+  inputLayerNames?: Record<string, string>;
+  /** Names of layers the run added to the map. */
+  outputLayerNames?: string[];
+  /** Input file path/name, for file-based tools (raster/conversion). */
+  inputPath?: string;
+  /** Output file path/name, for file-based tools (raster/conversion). */
+  outputPath?: string;
+  /** ISO timestamp of when the run started. */
+  startedAt: string;
+  /** Wall-clock duration of the run in milliseconds. */
+  durationMs?: number;
+  status: ProcessingRunStatus;
+  /** Error message when `status` is `"error"`. */
+  error?: string;
+}
+/**
+ * A pending "re-run from History" request. The History panel writes it to the
+ * store and opens the target dialog; the dialog consumes it (pre-filling its
+ * parameter form) and clears it. `autoRun` asks the dialog to start the run
+ * immediately after pre-filling (plain Re-run vs Edit & re-run).
+ */
+interface ProcessingRerunRequest {
+  kind: ProcessingRunKind;
+  toolId: string;
+  parameters: Record<string, unknown>;
+  /** Engine to preselect, when the dialog offers a choice. */
+  engine?: string;
+  autoRun?: boolean;
+}
+/** Column-count bounds for the Dashboard panel's widget grid. */
+declare const MIN_DASHBOARD_COLUMNS = 1;
+declare const MAX_DASHBOARD_COLUMNS = 6;
+declare const DEFAULT_DASHBOARD_COLUMNS = 2;
+/** The chart a {@link DashboardWidget} draws. Mirrors the attribute Charts
+ * panel's types so a widget reuses the same rendering. The `"indicator"` type
+ * is a non-chart KPI tile (issue #1381). */
+type DashboardWidgetType = "histogram" | "scatter" | "bar" | "line" | "box" | "pie" | "indicator" | "selector" | "list";
+/** How a bar widget reduces its category groups. */
+type DashboardWidgetAggregation = "count" | "sum" | "mean";
+/**
+ * One chart in the Dashboard panel: a chart type bound to a layer and the
+ * field(s) it plots. Which `field*`/`category`/`aggregation` keys apply depends
+ * on `type` (histogram/line/box use `field`; scatter uses `xField`/`yField`;
+ * bar uses `category` + `aggregation` and, for sum/mean, `valueField`). Unused
+ * keys are simply ignored, so the record stays flat and easy to hand-edit.
+ * Saved in the project file so a dashboard reopens with its widgets intact.
+ */
+/**
+ * A saved map view in the Bookmarks panel. Mirrors `MapBookmark` from
+ * maplibre-gl-components so the panel can load it unchanged.
+ */
+interface ProjectBookmark {
+  /** Unique within the project. */
+  id: string;
+  name: string;
+  /** Camera center longitude, -180..180. */
+  lng: number;
+  /** Camera center latitude, -90..90. */
+  lat: number;
+  zoom: number;
+  /** Camera tilt in degrees, 0..85. */
+  pitch: number;
+  /** Camera rotation in degrees. */
+  bearing: number;
+  /** Creation time, milliseconds since the epoch. */
+  createdAt: number;
+  /** The {@link ProjectBookmarkGroup} it belongs to; absent when ungrouped. */
+  groupId?: string;
+  /**
+   * Host state captured with the view. GeoLibre stores `visibleLayerIds`
+   * (the layers to show when the bookmark is opened).
+   */
+  extra?: Record<string, unknown>;
+}
+/** A folder in the Bookmarks panel. Folders do not nest. */
+interface ProjectBookmarkGroup {
+  id: string;
+  name: string;
+  /** Whether the folder is collapsed in the panel. */
+  collapsed: boolean;
+}
+interface DashboardWidget {
+  /** Stable id, unique within the project (React key and store key). */
+  id: string;
+  /** The layer whose features feed this widget. */
+  layerId: string;
+  /** The chart to draw. */
+  type: DashboardWidgetType;
+  /** Optional custom title; the panel derives a label from the fields if absent. */
+  title?: string;
+  /** Optional hex color (`#rgb`/`#rrggbb`) for the chart's marks. Single-series
+   * charts use it as the series color; bar/pie use it as the base of a
+   * monochromatic ramp. Defaults to the theme primary / multi-color palette. */
+  color?: string;
+  /** Value field for histogram/line/box. */
+  field?: string;
+  /** X-axis field for scatter. */
+  xField?: string;
+  /** Y-axis field for scatter. */
+  yField?: string;
+  /** Number of bins for a histogram. */
+  bins?: number;
+  /** Category field for a bar chart. */
+  category?: string;
+  /** Aggregation for a bar chart (default `count`). */
+  aggregation?: DashboardWidgetAggregation;
+  /** Value field a bar chart's sum/mean reduces (ignored for `count`). */
+  valueField?: string;
+  /** Indicator widget: aggregation function for the KPI value (issue #1381).
+   * Extends bar aggregation with min, max, and median. */
+  indicatorAggregation?: IndicatorAggregation;
+  /** Indicator widget: optional prefix (e.g. "€", "$"). */
+  prefix?: string;
+  /** Indicator widget: optional suffix (e.g. " kg", " ha"). */
+  suffix?: string;
+  /** Selector widget: whether multiple values can be picked (default false). */
+  multiple?: boolean;
+  /** List widget: columns to display. */
+  listFields?: string[];
+  /** List widget: field to sort by. */
+  sortBy?: string;
+  /** List widget: sort direction (default "desc"). */
+  sortDir?: "asc" | "desc";
+  /** List widget: max rows to show (default 20). */
+  limit?: number;
+}
+/** Aggregation functions for indicator widgets (issue #1381). Extends the bar
+ * widget aggregation with min, max, and median. */
+type IndicatorAggregation = "count" | "sum" | "mean" | "min" | "max" | "median";
+/**
+ * What slice of a layer's styling a Style Manager entry captures (issue #1294).
+ *
+ * - `"style"`: the layer's complete {@link LayerStyle} snapshot.
+ * - `"symbol"`: fill/stroke/marker/pattern symbology only, so it can restyle a
+ *   layer without touching its labels or renderer configuration.
+ * - `"labels"`: the {@link LabelStyle} block only.
+ * - `"ramp"`: the color ramp + classification settings only (ramp name, class
+ *   count, classification scheme), independent of the attribute the target
+ *   layer classifies on.
+ */
+type StyleLibraryEntryKind = "style" | "symbol" | "labels" | "ramp";
+/**
+ * One saved, reusable style in the Style Manager library (issue #1294). The
+ * payload is a {@link LayerStyle} subset chosen by {@link kind}; applying an
+ * entry merges that subset onto the target layer's style. Entries live either
+ * in the app-level library (persisted across projects) or embedded in a
+ * project file's `styleLibrary` array.
+ */
+interface StyleLibraryEntry {
+  /** Stable id, used as the IndexedDB/store key; upserts overwrite by id. */
+  id: string;
+  /** Display name shown in the Style Manager. */
+  name: string;
+  /** Which style subset {@link style} carries. */
+  kind: StyleLibraryEntryKind;
+  /** Free-form tags for filtering the library. */
+  tags: string[];
+  /** The saved {@link LayerStyle} subset (see {@link kind}). */
+  style: Partial<LayerStyle>;
+  /** ISO timestamp of the last save; empty for built-in presets. */
+  updatedAt: string;
+}
+/**
+ * One saved, re-addable layer in the Layer Library (issue #1520) — the "My
+ * Data" section of the Browser panel. Stores the layer's **source
+ * specification** plus its full presentation state (style, labels, filters,
+ * joins, virtual fields, attribute form), deliberately *not* the data, so the
+ * library stays small and an entry always reflects the current contents of its
+ * source.
+ *
+ * The exception is a layer whose features exist only in memory (drawn features,
+ * processing output) or in a local file: those have no re-fetchable source, so
+ * their features are embedded in {@link geojson} behind a size cap. See
+ * `layer-library.ts` for how an entry is captured and re-added.
+ */
+interface LayerLibraryEntry {
+  /** Stable id, used as the IndexedDB/store key; upserts overwrite by id. */
+  id: string;
+  /** Display name shown in the Browser panel's My Data section. */
+  name: string;
+  /** ISO timestamp of the last save. */
+  addedAt: string;
+  /** The layer type to recreate ({@link GeoLibreLayer.type}). */
+  layerType: LayerType;
+  /** The MapLibre/plugin source spec to recreate the layer from. */
+  source: Record<string, unknown>;
+  /** The saved layer's complete {@link LayerStyle} (labels included). */
+  style: LayerStyle;
+  /** Layer opacity in [0, 1]. */
+  opacity: number;
+  /** The layer metadata the renderers and plugin sync modules key off. */
+  metadata: Record<string, unknown>;
+  /** Absolute local path, for a layer read from a file on disk. */
+  sourcePath?: string;
+  /** Persistent attribute joins to reapply. */
+  joins?: LayerJoin[];
+  /** Expression-backed virtual fields to reapply. */
+  virtualFields?: LayerVirtualField[];
+  /** Per-field edit-widget/constraint configuration to reapply. */
+  attributeForm?: AttributeFormConfig;
+  /** Popup/tooltip design to reapply. */
+  popup?: LayerPopupConfig;
+  /** User-authored catalog metadata to reapply. */
+  descriptiveMetadata?: LayerDescriptiveMetadata;
+  /**
+   * Embedded features, present only for a layer whose source cannot be
+   * re-read (in-memory features) or whose local file may be unavailable.
+   */
+  geojson?: FeatureCollection;
+  /**
+   * True when the entry can only be re-added by a host that can read
+   * {@link sourcePath} — i.e. its features were too large to embed, so the
+   * desktop app must re-read the file and the browser build cannot.
+   */
+  needsLocalFile?: boolean;
+}
+/** One saved template in the Template Library. */
+interface ProjectTemplateEntry {
+  id: string;
+  name: string;
+  description?: string;
+  project: GeoLibreProject;
+  createdAt: string;
+  updatedAt: string;
+}
+interface GeoLibreProject {
+  id?: string;
+  version: string;
+  name: string;
+  mapView: MapViewState;
+  basemapStyleUrl: string;
+  basemapVisible: boolean;
+  basemapOpacity: number;
+  /** Custom colour for the Blank background. Null uses the current theme default. */
+  blankBackgroundColor?: string | null;
+  layers: GeoLibreLayer[];
+  /**
+   * Layer selected in the Layers panel when the project was saved. Omitted by
+   * legacy projects; `null` deliberately restores no active layer.
+   */
+  selectedLayerId?: string | null;
+  /** Named folders that organize the flat `layers` list in the layer panel. */
+  layerGroups?: LayerGroup[];
+  styles: Record<string, LayerStyle>;
+  preferences: ProjectPreferences;
+  plugins?: ProjectPluginState;
+  /** User customizations for the Print Layout legend. */
+  legend?: LegendConfig;
+  /**
+   * Print Layout composer settings (title, page size, orientation, blocks,
+   * atlas). Omitted while the composer is untouched, so projects that never
+   * opened it are unaffected (GeoLibre discussion #1992).
+   */
+  printLayout?: PrintLayoutConfig;
+  storymap?: StoryMap;
+  /** Saved processing pipelines (batch/model chaining; issue #344). */
+  models?: ProcessingModel[];
+  /** Recorded processing tool runs (Processing History; issue #1292). */
+  processingHistory?: ProcessingRun[];
+  /**
+   * Object-Based Analysis workbench state and run provenance (issue #3053):
+   * settings, classes, and the tool calls, parameters, seeds and engine
+   * versions behind the last segmentation, measurement and classification.
+   * A versioned JSON object owned by the desktop app; omitted until the
+   * workbench is used.
+   */
+  obia?: Record<string, unknown>;
+  /** Saved Dashboard panel chart widgets (issue #401). */
+  widgets?: DashboardWidget[];
+  /**
+   * Saved map views (the Bookmarks panel), in panel order. Omitted when there
+   * are none. Before #2869 these lived only in the browser's localStorage.
+   */
+  bookmarks?: ProjectBookmark[];
+  /** Folders the {@link bookmarks} are organized into. Omitted when none. */
+  bookmarkGroups?: ProjectBookmarkGroup[];
+  /** Number of columns in the Dashboard widget grid; omitted when default. */
+  dashboardColumns?: number;
+  /**
+   * Multi-map grid layout; omitted (single 1x1 pane) for default projects so
+   * legacy readers and single-map files are unaffected.
+   */
+  mapLayout?: MapGridLayout;
+  /**
+   * Secondary map panes (everything past the primary pane). Omitted when the
+   * grid is a single pane. The primary pane uses the top-level `mapView` /
+   * `basemap*` fields.
+   */
+  secondaryMapViews?: SecondaryMapView[];
+  /** User-entered label for the primary pane; omitted when empty. */
+  primaryMapLabel?: string;
+  /**
+   * Which engine draws the primary map area (issue #2217). Omitted for the
+   * default 2D map, so every project written before this existed — and every
+   * project that never leaves MapLibre — is byte-identical to before. A project
+   * saved as `"cesium"` reopens directly on the 3D globe.
+   *
+   * This is independent of {@link mapLayout}: a 1x1 workspace can be either
+   * renderer, and a multi-pane grid can still mix the two through each pane's
+   * {@link SecondaryMapView.viewKind}.
+   */
+  primaryRenderer?: MapRendererKind;
+  /**
+   * Project-scoped Style Manager entries (issue #1294), so a project can carry
+   * its reusable styles to teammates. Omitted when empty; the app-level
+   * library is persisted outside the project file and never serialized here.
+   */
+  styleLibrary?: StyleLibraryEntry[];
+  /** Anchored review comments on map points or features (issue #1518). */
+  comments?: ProjectComment[];
+  /**
+   * Interaction state applied when the project opens: the Identify target and
+   * which map controls and toolbar panels start shown (issue #2688). Written by
+   * the Python `geolibre` package from `set_identify` / `show_control`, so a
+   * saved or HTML-exported notebook map opens the way it was set up. Omitted
+   * by default; the app keeps what it loaded and writes it back unchanged.
+   */
+  interaction?: ProjectInteraction;
+  metadata: Record<string, unknown>;
+}
+/**
+ * Startup interaction state carried by a project (see
+ * {@link GeoLibreProject.interaction}).
+ */
+interface ProjectInteraction {
+  /**
+   * Identify target on open: a layer id, `"all"` for every visible queryable
+   * layer, a list of layer ids to identify only those, or `null` for off.
+   */
+  identify?: string | string[] | null;
+  /**
+   * Map control or toolbar panel name (`"search"`, `"bookmark"`, `"globe"`,
+   * ...) to whether it starts shown. Unknown names are ignored on open.
+   */
+  controls?: Record<string, boolean>;
+}
+type CommentAnchor = {
+  type: "point";
+  lngLat: [number, number];
+} | {
+  type: "feature";
+  layerId: string;
+  featureId: string | number;
+  lngLat?: [number, number];
+};
+interface CommentAuthor {
+  name: string;
+  color: string;
+}
+interface CommentReply {
+  id: string;
+  author: CommentAuthor;
+  body: string;
+  createdAt: string;
+}
+interface ProjectComment {
+  id: string;
+  anchor: CommentAnchor;
+  author: CommentAuthor;
+  body: string;
+  createdAt: string;
+  resolved: boolean;
+  replies: CommentReply[];
+}
+interface RecentProjectEntry {
+  path: string;
+  name: string;
+  openedAt: string;
+}
+/**
+ * Size at or above which a local vector file is read through DuckDB instead of
+ * the in-memory JavaScript readers, and the feature count above which the user
+ * is asked before every feature is materialized as GeoJSON.
+ *
+ * These live in core so the desktop loaders (`duckdb-vector-guard.ts`) and the
+ * Add Vector Layer panel (`@geolibre/plugins`, which configures the
+ * `maplibre-gl-vector` control's `autoThreshold`) switch strategy at the *same*
+ * numbers. Before they were unified the two entry points disagreed — the panel
+ * tiled at 25 MB / 50k while drag-and-drop stayed in memory to 100 MB — so the
+ * same file behaved differently depending on how it was added, and no single
+ * number could be documented.
+ */
+declare const DUCKDB_VECTOR_ROUTE_BYTES: number;
+declare const DUCKDB_VECTOR_FEATURE_WARN_COUNT = 100000;
+/** A collection whose coordinates cannot be WGS84 longitude/latitude. */
+interface NonGeographicCoordinates {
+  /** How many coordinates were inspected. */
+  sampled: number;
+  /** The largest |x| seen — a longitude may not exceed 180. */
+  maxAbsX: number;
+  /** The largest |y| seen — a latitude may not exceed 90. */
+  maxAbsY: number;
+}
+/**
+ * Detect a collection that declares (or is assumed to be) WGS84 but carries
+ * projected coordinates — the failure mode where a layer loads cleanly, appears
+ * in the Layers panel, and renders nowhere because its "longitude" is a easting
+ * in metres or feet.
+ *
+ * GeoLibre honours whatever CRS a file declares, so a file that declares
+ * `CRS84`/`GCS_WGS_1984` while holding State Plane or Albers coordinates is
+ * passed through untouched and lands off the map with no error. Callers use
+ * this to warn instead of failing silently; it does not guess the true CRS,
+ * which only the user knows.
+ *
+ * Sampling stops at `sampleLimit` coordinates: out-of-range values are a
+ * property of the whole file, so a prefix is enough and a 3-million-coordinate
+ * collection is not walked twice.
+ *
+ * @returns Details when a coordinate is out of geographic range, else null.
+ */
+declare function detectNonGeographicCoordinates(geojson: GeoJSON.FeatureCollection | undefined, sampleLimit?: number): NonGeographicCoordinates | null;
+//#endregion
+//#region src/ellipsoids.d.ts
+/**
+ * Celestial-body ellipsoids and the planetary basemaps that pair with them.
+ *
+ * GeoLibre is Earth-centric by construction: MapLibre only renders Web Mercator
+ * and all vector data is kept as WGS84 lon/lat GeoJSON. This module does *not*
+ * change that — MapLibre still treats the planet as a unit sphere and there is
+ * no true multi-CRS rendering (see maplibre-gl-js#168). What it adds is a
+ * per-project notion of *which body* the coordinates describe, so that:
+ *
+ *   - distance / area / scale measurements use that body's radius instead of a
+ *     hardcoded Earth radius, and
+ *   - Moon / Mars basemaps (published in a Web-Mercator tiling scheme) can be
+ *     selected like any other basemap.
+ *
+ * The active ellipsoid is a lightweight module-level singleton kept in sync with
+ * the project's map preferences (see the store's `setPreferences`). Measurement
+ * helpers read it lazily at call time, so callers in other packages don't need
+ * the value threaded through their signatures — a deliberate prototype-friendly
+ * shortcut over a full CRS/context refactor.
+ */
+/** A biaxial (rotational) ellipsoid describing a celestial body. */
+interface Ellipsoid {
+  /** Stable id persisted in the project (`map.ellipsoidId`). */
+  id: string;
+  /** Human-readable name shown in the UI. */
+  name: string;
+  /** Equatorial (semi-major) radius in metres — the "web mercator" radius. */
+  semiMajorAxisMeters: number;
+  /**
+   * Inverse flattening `1/f`. `0` denotes a perfect sphere (Moon), in which case
+   * the polar radius equals {@link semiMajorAxisMeters}.
+   */
+  inverseFlattening: number;
+}
+/**
+ * Built-in ellipsoids. Earth is WGS 84; every other body uses IAU-adopted
+ * figures. Only Earth and Mars are appreciably oblate; the rest are modelled as
+ * spheres (`inverseFlattening: 0`), which is how the IAU/USGS simple-cylindrical
+ * products treat them and is well within the accuracy MapLibre's unit-sphere
+ * rendering can represent anyway.
+ */
+declare const ELLIPSOIDS: readonly [{
+  readonly id: "earth";
+  readonly name: "Earth (WGS 84)";
+  readonly semiMajorAxisMeters: 6378137;
+  readonly inverseFlattening: 298.257223563;
+}, {
+  readonly id: "moon";
+  readonly name: "Moon";
+  readonly semiMajorAxisMeters: 1737400;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "mars";
+  readonly name: "Mars (IAU 2000)";
+  readonly semiMajorAxisMeters: 3396190;
+  readonly inverseFlattening: 169.894447;
+}, {
+  readonly id: "mercury";
+  readonly name: "Mercury";
+  readonly semiMajorAxisMeters: 2439400;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "venus";
+  readonly name: "Venus";
+  readonly semiMajorAxisMeters: 6051800;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "io";
+  readonly name: "Io";
+  readonly semiMajorAxisMeters: 1821600;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "europa";
+  readonly name: "Europa";
+  readonly semiMajorAxisMeters: 1560800;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "ganymede";
+  readonly name: "Ganymede";
+  readonly semiMajorAxisMeters: 2631200;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "callisto";
+  readonly name: "Callisto";
+  readonly semiMajorAxisMeters: 2410300;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "titan";
+  readonly name: "Titan";
+  readonly semiMajorAxisMeters: 2574730;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "pluto";
+  readonly name: "Pluto";
+  readonly semiMajorAxisMeters: 1188300;
+  readonly inverseFlattening: 0;
+}, {
+  readonly id: "charon";
+  readonly name: "Charon";
+  readonly semiMajorAxisMeters: 606000;
+  readonly inverseFlattening: 0;
+}];
+type EllipsoidId = (typeof ELLIPSOIDS)[number]["id"];
+declare const DEFAULT_ELLIPSOID_ID: EllipsoidId;
+/** Look an ellipsoid up by id, falling back to Earth for unknown ids. */
+declare function getEllipsoid(id: string | undefined): Ellipsoid;
+/**
+ * Mean radius `R = (2a + b) / 3` in metres, where `b` is the polar radius
+ * derived from the inverse flattening. This is the radius used for spherical
+ * (haversine) distance and area math.
+ */
+declare function meanRadiusMeters(ellipsoid: Ellipsoid): number;
+/** Earth's mean radius in metres — the radius Turf.js and MapLibre bake in. */
+declare const EARTH_MEAN_RADIUS_METERS: number;
+/**
+ * Point the measurement helpers at a body. Unknown ids fall back to Earth so a
+ * malformed project can never break measurements. Safe to call on every
+ * preferences change; it is a cheap assignment.
+ */
+declare function setActiveEllipsoidId(id: string | undefined): void;
+declare function getActiveEllipsoid(): Ellipsoid;
+/** Mean radius (metres) of the active body — for haversine distance/area. */
+declare function getActiveMeanRadiusMeters(): number;
+/** Semi-major axis (metres) of the active body — for its Web-Mercator scale. */
+declare function getActiveSemiMajorAxisMeters(): number;
+/**
+ * The active body's mean radius as a fraction of Earth's — `R_body / R_earth`,
+ * and exactly `1` on Earth.
+ *
+ * Everything GeoLibre measures ultimately comes from lon/lat *angles*, and the
+ * only thing that turns an angle into a ground distance is the radius it is
+ * multiplied by. Turf.js hardcodes Earth's, with no per-call override (that is
+ * the "Turf is Earth-locked" half of GeoLibre#1128), so rather than patch or
+ * replace Turf we post-scale what it returns and pre-scale what we hand it. The
+ * result is exact for a sphere, which is how every non-Earth body GeoLibre
+ * offers is modelled anyway, and within Mars' 0.6% flattening at worst.
+ *
+ * Suggested by @thareUSGS (USGS Astrogeology) on GeoLibre#1128 as the practical
+ * workaround planetary web maps have long used on Earth-locked engines.
+ */
+declare function getActiveBodyRadiusRatio(): number;
+/**
+ * Convert a length Turf.js measured on Earth into the active body's true ground
+ * length. A no-op on Earth.
+ *
+ * Use on anything Turf *returns* — a distance, a length, a perimeter.
+ *
+ * The correction is a dimensionless ratio, so it is unit-agnostic: pass the
+ * length in whatever unit Turf gave it back (metres, kilometres, miles) and the
+ * result is in that same unit. There is no hidden unit conversion here.
+ */
+declare function earthLengthToBody(length: number): number;
+/**
+ * Convert a true ground length on the active body into the Earth-equivalent
+ * length to hand Turf.js. A no-op on Earth.
+ *
+ * Use on anything passed *into* Turf as a distance — a buffer width, a circle
+ * or sector radius, a search threshold — so the resulting geometry spans that
+ * distance on this body rather than on Earth.
+ *
+ * Unit-agnostic like {@link earthLengthToBody}: pass the length in whatever
+ * unit you are about to hand Turf alongside it, and the result is in that unit.
+ */
+declare function bodyLengthToEarth(length: number): number;
+/**
+ * Convert an area Turf.js measured on Earth into the active body's true ground
+ * area. A no-op on Earth.
+ *
+ * Areas scale with the *square* of the radius ratio, so this is not the same
+ * correction as {@link earthLengthToBody}. Unit-agnostic in the same way, for
+ * whatever squared unit the area is expressed in.
+ */
+declare function earthAreaToBody(area: number): number;
+/**
+ * A raster basemap for a celestial body — the Moon and Mars mosaics, plus the
+ * Earth satellite imagery the planet switcher pairs with Earth. The tiles are
+ * XYZ (or TMS, see {@link scheme}) images in that body's Web-Mercator scheme, so
+ * MapLibre renders them directly. The `styleUrl` is a `geolibre://basemap/<id>`
+ * sentinel; the map controller expands it into a raster style at apply time (it
+ * is not a fetchable URL).
+ */
+interface PlanetaryBasemap {
+  id: string;
+  name: string;
+  /** Sentinel stored as the basemap style URL. */
+  styleUrl: string;
+  /** XYZ (or TMS, see {@link scheme}) tile template. */
+  tileUrl: string;
+  /**
+   * Tile row ordering. OpenPlanetaryMap's single-layer raster mosaics (the S3
+   * datasets) are published as **TMS** (tile origin bottom-left, Y flipped),
+   * whereas the CARTO `opmbuilder` named maps are standard **XYZ**. Omit for
+   * XYZ; MapLibre defaults to `"xyz"` when `scheme` is absent.
+   */
+  scheme?: "tms";
+  /** Max native zoom of the source (MapLibre overzooms beyond this). */
+  maxZoom: number;
+  /** Attribution shown on the map. */
+  attribution: string;
+  /** The body this basemap depicts, so selecting it can set the ellipsoid. */
+  ellipsoidId: EllipsoidId;
+}
+declare const PLANETARY_BASEMAP_SENTINEL_PREFIX = "geolibre://basemap/";
+declare const PLANETARY_BASEMAPS: readonly PlanetaryBasemap[];
+/**
+ * The section a planetary basemap is grouped under in the New Project and
+ * Change Basemap pickers. The Moon and Mars keep dedicated sections (they are
+ * the most-used bodies and each has several mosaics); every other body is
+ * collapsed into a single "other" section so the picker isn't a wall of
+ * one-item headings.
+ */
+type PlanetaryBasemapSectionId = "moon" | "mars" | "other";
+/** A picker section paired with the planetary basemaps it lists. */
+interface PlanetaryBasemapGroup {
+  id: PlanetaryBasemapSectionId;
+  basemaps: readonly PlanetaryBasemap[];
+}
+/**
+ * {@link PLANETARY_BASEMAPS} grouped for the pickers: one section each for the
+ * Moon and Mars, then a single "Other celestial bodies" section for the rest,
+ * in {@link PLANETARY_BASEMAPS} order (grouped by body). Empty sections are
+ * dropped.
+ */
+declare const PLANETARY_BASEMAP_GROUPS: readonly PlanetaryBasemapGroup[];
+/** Resolve a `geolibre://basemap/<id>` sentinel to its planetary basemap. */
+declare function getPlanetaryBasemapByStyleUrl(styleUrl: string | undefined): PlanetaryBasemap | undefined;
+/** Look a planetary basemap up by its stable id. */
+declare function getPlanetaryBasemapById(id: string): PlanetaryBasemap | undefined;
+/**
+ * The celestial bodies offered by the Layers-panel planet switcher, in menu
+ * order (like Google Earth's planet dropdown). Each body is paired with the
+ * basemap the switcher applies for it — USGS satellite imagery for Earth, the
+ * OpenPlanetaryMap Hillshaded Albedo mosaic for the Moon, and the OpenPlanetaryMap
+ * Viking mosaic for Mars.
+ */
+declare const PLANET_SWITCHER_OPTIONS: readonly [{
+  readonly ellipsoidId: "earth";
+  readonly basemapId: "earth-usgs-imagery";
+}, {
+  readonly ellipsoidId: "moon";
+  readonly basemapId: "moon-hillshaded-albedo";
+}, {
+  readonly ellipsoidId: "mars";
+  readonly basemapId: "mars-viking-mdim21";
+}, {
+  readonly ellipsoidId: "callisto";
+  readonly basemapId: "callisto-galileo-voyager";
+}, {
+  readonly ellipsoidId: "charon";
+  readonly basemapId: "charon-mosaic";
+}, {
+  readonly ellipsoidId: "europa";
+  readonly basemapId: "europa-galileo-voyager";
+}, {
+  readonly ellipsoidId: "ganymede";
+  readonly basemapId: "ganymede-galileo-voyager";
+}, {
+  readonly ellipsoidId: "io";
+  readonly basemapId: "io-galileo-color";
+}, {
+  readonly ellipsoidId: "mercury";
+  readonly basemapId: "mercury-messenger-color";
+}, {
+  readonly ellipsoidId: "pluto";
+  readonly basemapId: "pluto-mosaic";
+}, {
+  readonly ellipsoidId: "titan";
+  readonly basemapId: "titan-cassini";
+}, {
+  readonly ellipsoidId: "venus";
+  readonly basemapId: "venus-magellan-color";
+}];
+//#endregion
+//#region src/geojson-z.d.ts
+/**
+ * Helpers for vector data whose coordinates carry a Z value (elevation), e.g.
+ * GPX tracks with `<ele>` readings or LineStringZ/PointZ geometries. MapLibre's
+ * 2D style layers ignore the third coordinate, so layers that want to render
+ * their Z values use these helpers to detect and rescale elevations before
+ * handing the data to a deck.gl overlay. The same data can carry its elevation
+ * in a `bbox` member too, which `horizontalBbox` trims back to two dimensions.
+ */
+/**
+ * Reduces a bounding box to its horizontal extent, `[west, south, east, north]`.
+ *
+ * RFC 7946 §5 lets a `bbox` member carry elevation, in which case it holds six
+ * values — `[west, south, minAltitude, east, north, maxAltitude]` — and
+ * `@turf/bbox` returns a collection's own member verbatim rather than
+ * recomputing it. A consumer reading such a box as four values takes the
+ * altitude for a longitude and the east edge for a latitude; that is how a 3D
+ * feed reached MapLibre as an out-of-range latitude (#2358).
+ *
+ * Returns null when there is no usable horizontal extent: a box of any other
+ * length, or one carrying a non-finite value anywhere — an empty collection, or
+ * one whose features all have a null geometry, bboxes to ±Infinity, and a box
+ * whose altitudes are not finite is not one to trust the rest of.
+ *
+ * @param box - A GeoJSON or Turf bounding box, of four or six values.
+ */
+declare function horizontalBbox(box: readonly number[] | null | undefined): [number, number, number, number] | null;
+/**
+ * Returns true when any coordinate in the GeoJSON carries a finite, non-zero
+ * Z value. All-zero Z arrays are treated as flat data because rendering them
+ * "in 3D" would be indistinguishable from the 2D result. The result is
+ * cached per GeoJSON object, so repeated calls on the same data are free.
+ *
+ * @param geojson - Any GeoJSON object (geometry, feature, or collection).
+ * @param includeZero - Accept zero elevations when explicit absolute-height placement matters.
+ */
+declare function geojsonHasZCoordinates(geojson: GeoJSON$1 | null | undefined, includeZero?: boolean): boolean;
+/**
+ * Returns a copy of the GeoJSON with every coordinate's Z value mapped to
+ * `z * verticalScale + offset` (missing or non-finite Z treated as 0). Used
+ * to apply vertical exaggeration and a constant altitude offset before 3D
+ * rendering. The identity transform (`verticalScale === 1 && offset === 0`)
+ * still produces a copy so the non-finite-Z sanitization applies on every
+ * path — WebGL does not handle NaN positions gracefully.
+ *
+ * @param geojson - The feature collection to transform.
+ * @param verticalScale - Multiplier applied to each Z value.
+ * @param offset - Constant altitude in meters added after scaling.
+ */
+declare function transformGeojsonElevation(geojson: FeatureCollection, verticalScale: number, offset: number): FeatureCollection;
+//#endregion
+//#region src/polyline.d.ts
+/**
+ * Pure TypeScript Google Encoded Polyline algorithm codec.
+ *
+ * Supports arbitrary precision:
+ * - precision = 5: Google Maps standard, OSRM, HERE (factor 1e5, ~1.1m precision)
+ * - precision = 6: Valhalla, Mapbox, Open Source Routing Machine 6 (factor 1e6, ~0.11m precision)
+ *
+ * Coordinates are represented as `[lon, lat]` pairs in GeoJSON format.
+ */
+/**
+ * Unescapes backslashes in a polyline string.
+ *
+ * When polyline strings are copied from JSON payloads, log files, or source code,
+ * backslashes are frequently double-escaped as `\\` or formatted with escape sequences.
+ *
+ * @param str - Input string with potentially escaped backslashes.
+ * @returns Cleaned polyline string.
+ */
+declare function unescapePolyline(str: string): string;
+interface PolylineDecodeResult {
+  coordinates: [number, number][];
+  complete: boolean;
+}
+/**
+ * Decodes an encoded polyline string into an array of `[lon, lat]` coordinates,
+ * along with a `complete` flag indicating whether the entire string was consumed
+ * as complete coordinate pairs without truncation or malformed characters.
+ *
+ * @param encoded - The ASCII-encoded polyline string.
+ * @param precision - Number of decimal digits (default: 5).
+ * @param unescape - Whether to unescape double-escaped backslashes before decoding (default: false).
+ * @returns Object with decoded `coordinates` and `complete` boolean status.
+ */
+declare function decodePolylineDetailed(encoded: string, precision?: number, unescape?: boolean): PolylineDecodeResult;
+/**
+ * Decodes an encoded polyline string into an array of `[lon, lat]` coordinates.
+ *
+ * @param encoded - The ASCII-encoded polyline string.
+ * @param precision - Number of decimal digits (default: 5).
+ * @param unescape - Whether to unescape double-escaped backslashes before decoding (default: false).
+ * @returns Array of `[lon, lat]` coordinate pairs in GeoJSON order.
+ */
+declare function decodePolyline(encoded: string, precision?: number, unescape?: boolean): [number, number][];
+/**
+ * Encodes an array of `[lon, lat]` coordinates into a Google Encoded Polyline string.
+ *
+ * @param coordinates - Array of `[lon, lat]` coordinate pairs.
+ * @param precision - Number of decimal digits (default: 5).
+ * @returns The encoded polyline string.
+ */
+declare function encodePolyline(coordinates: [number, number][], precision?: number): string;
+/**
+ * Decodes an encoded polyline string into a GeoJSON `Feature<LineString>`.
+ *
+ * @param encoded - The polyline string.
+ * @param precision - Coordinate precision (default: 5).
+ * @param properties - Optional feature properties.
+ * @returns A GeoJSON LineString Feature.
+ */
+declare function polylineStrToGeoJSON(encoded: string, precision?: number, properties?: GeoJsonProperties): Feature<LineString>;
+/**
+ * Encodes a GeoJSON LineString, MultiLineString, Feature, or FeatureCollection into encoded polyline string(s).
+ *
+ * @param geojson - The GeoJSON input geometry or feature.
+ * @param precision - Coordinate precision (default: 5).
+ * @returns An encoded polyline string for LineString, or an array of strings for MultiLineString / FeatureCollection.
+ */
+declare function geoJSONToPolylineStr(geojson: LineString | MultiLineString | Feature<LineString | MultiLineString> | FeatureCollection<LineString | MultiLineString>, precision?: number): string | string[];
+interface PolylineBatchOptions {
+  /** Coordinate precision (default: 5) */
+  precision?: number;
+  /** Whether to unescape `\\` backslashes (default: true) */
+  unescape?: boolean;
+  /** Custom delimiter string or RegExp separating individual polylines (default: newline) */
+  delimiter?: string | RegExp;
+  /** Whether to merge lines into a single MultiLineString feature (default: false) */
+  asMultiLine?: boolean;
+  /** Optional base properties to assign to output features */
+  baseProperties?: GeoJsonProperties;
+}
+/**
+ * Parses and batch-decodes multiple polylines from a text block or file content.
+ *
+ * @param input - Multiline string or delimited text containing encoded polylines.
+ * @param options - Decoding and parsing configuration.
+ * @returns A FeatureCollection containing LineString (or MultiLineString) features.
+ */
+declare function batchDecodePolylines(input: string, options?: PolylineBatchOptions): FeatureCollection<LineString | MultiLineString>;
+//#endregion
+//#region src/joins.d.ts
+/**
+ * Match key for a persistent join: empty values (null/undefined/NaN/empty
+ * string) never match a row, mirroring a SQL/pandas NaN join key. Non-empty
+ * values are keyed by their string form, so a numeric `5` and the string `"5"`
+ * join while a zero-padded code like `"01001"` only matches another `"01001"`.
+ * Kept in sync with the Processing attribute join's `attributeJoinKey`.
+ */
+declare function layerJoinKey(value: unknown): string | null;
+/**
+ * Remove every column previously added by `joins` (per their `addedFields`
+ * bookkeeping) from a copy of `features`, restoring the pre-join properties.
+ * Features without any tracked column are returned unchanged (same reference).
+ */
+declare function stripJoinFields(features: Feature[], joins: LayerJoin[] | undefined): Feature[];
+/** Result of {@link applyLayerJoins}: joined features plus refreshed join records. */
+interface ApplyLayerJoinsResult {
+  features: Feature[];
+  /** Input joins with `addedFields` and `stats` recomputed for this run. */
+  joins: LayerJoin[];
+}
+/**
+ * Apply `joins` in order to base (already-stripped) `features`, returning new
+ * feature objects with the joined columns merged into their properties.
+ *
+ * Semantics per join: left join, first matching join row wins, and joined
+ * columns are null-filled on unmatched features so the schema stays
+ * consistent. An output name (prefix + field) that collides with an existing
+ * column — from the base data or an earlier join — drops that one column;
+ * the join's other columns still apply. A disabled join, or one whose source
+ * cannot be resolved, contributes nothing and gets empty `addedFields` and no
+ * stats.
+ *
+ * @param features - The layer's base features (strip previous joins first).
+ * @param joins - Join definitions in application order.
+ * @param resolveSource - Maps a join's `joinLayerId` to that layer's current
+ *   feature collection, or `undefined` when the layer is gone (or is the
+ *   target itself; self-joins are refused by the caller).
+ */
+declare function applyLayerJoins(features: Feature[], joins: LayerJoin[] | undefined, resolveSource: (joinLayerId: string) => FeatureCollection | undefined): ApplyLayerJoinsResult;
+/**
+ * Strip-and-reapply this layer's derived columns — persistent joins, then
+ * virtual fields (so an expression can read joined columns) — resolving join
+ * sources from `allLayers`. Pass `nextJoins`/`nextVirtualFields` to replace
+ * the definitions (the layer's current bookkeeping still drives the strip, so
+ * removed definitions clean up after themselves); omit them to refresh the
+ * existing definitions against current data. Layers without a feature
+ * collection are returned unchanged.
+ */
+declare function applyJoinsToLayer(layer: GeoLibreLayer, allLayers: GeoLibreLayer[], nextJoins?: LayerJoin[], nextVirtualFields?: LayerVirtualField[]): GeoLibreLayer;
+/**
+ * Ids of every layer whose data (directly or transitively) feeds `layerId`'s
+ * joins, following `joinLayerId` edges through each source's own joins.
+ * Disabled joins count too: re-enabling one must not spring a cycle. The Joins
+ * UI uses this to keep a layer that already consumes the target — however
+ * indirectly — out of the join-source picker, so circular joins cannot be
+ * authored (the refresh cascade still breaks them defensively for hand-edited
+ * projects).
+ */
+declare function collectTransitiveJoinSourceIds(layers: GeoLibreLayer[], layerId: string): Set<string>;
+/**
+ * Refresh every layer whose joins (directly or transitively) consume the
+ * layer identified by `seedId`, after that layer's data changed — or after it
+ * was removed (a gone source resolves to nothing, so its frozen columns strip
+ * away). The affected layers re-derive in topological dependency order, so a
+ * layer joining two other affected layers sees both of them fresh regardless
+ * of their positions in the layer panel. The seed itself is not touched.
+ */
+declare function cascadeLayerJoinRefresh(layers: GeoLibreLayer[], seedId: string): GeoLibreLayer[];
+/**
+ * Re-resolve every layer's persistent joins against the freshly loaded layer
+ * set (project open). Layers re-derive in topological order of their join
+ * dependencies, so a chain (`C joins A, A joins B`) resolves A before C; a
+ * hand-edited cycle is broken by forcing one of its members through first
+ * (see {@link topologicalJoinOrder}), so consumers downstream of the cycle
+ * still re-derive after it. Layers with virtual fields but no joins re-derive
+ * too (their expressions run against the freshly loaded features). Layer sets
+ * without joins or virtual fields pass through by reference.
+ */
+declare function reapplyLayerJoins(layers: GeoLibreLayer[]): GeoLibreLayer[];
+//#endregion
+//#region src/project.d.ts
+/** Placeholder name a project carries before the user names it. */
+declare const DEFAULT_PROJECT_NAME = "Untitled Project";
+interface CreateProjectOptions {
+  basemapStyleUrl?: string;
+  mapView?: MapViewState;
+  /** Celestial body the project describes; defaults to Earth when omitted. */
+  ellipsoidId?: string;
+}
+declare function normalizeBlankBackgroundColor(value: unknown): string | null;
+declare function createDefaultMapView(): MapViewState;
+declare function createEmptyProject(name?: string, options?: CreateProjectOptions): GeoLibreProject;
+/**
+ * Serialize a project to `.geolibre.json` text: indented project structure with
+ * compact (unindented) embedded GeoJSON. See {@link serializeProjectValue} for
+ * why the two halves are formatted differently.
+ *
+ * @param project Project to serialize.
+ * @returns The file contents to write.
+ */
+declare function serializeProject(project: GeoLibreProject): string;
+/**
+ * Per-layer serialized text kept across {@link serializeProjectWithLayerCache}
+ * calls, keyed by the layer record each entry was built from. A `WeakMap`, so a
+ * layer the store has replaced or removed drops its text with it.
+ */
+type ProjectLayerSerializationCache = WeakMap<object, {
+  index: number;
+  text: string;
+}>;
+/** Create an empty {@link ProjectLayerSerializationCache}. */
+declare function createProjectLayerSerializationCache(): ProjectLayerSerializationCache;
+/**
+ * Serialize a project exactly as {@link serializeProject} does, reusing the
+ * text of every layer whose source record is unchanged since an earlier call.
+ *
+ * Feature data lives inside layer records, so re-stringifying every layer on
+ * each autosave costs megabytes of main-thread work for a project with large
+ * GeoJSON layers — even when only the camera moved (GeoLibre#2633). The store
+ * replaces a layer object whenever it changes, so object identity is a sound
+ * cache key: a camera move reuses every layer, and an edit to one layer
+ * re-serializes only that one.
+ *
+ * `layerSources[i]` must be the record `project.layers[i]` was derived from
+ * (e.g. the store's `layers`, before `projectFromStore` prepared them), and that
+ * derivation must depend on the record alone — as `buildProjectSnapshot`'s does
+ * — or a cached entry could outlive a change it should have reflected. When the
+ * two arrays differ in length the cache is bypassed rather than trusted.
+ *
+ * @param project Project to serialize, as built from `layerSources`.
+ * @param layerSources Immutable source record for each entry of
+ *   `project.layers`, in the same order, used as the cache key.
+ * @param cache Cache shared between calls; see
+ *   {@link createProjectLayerSerializationCache}.
+ * @returns The same text {@link serializeProject} returns for `project`.
+ */
+declare function serializeProjectWithLayerCache(project: GeoLibreProject, layerSources: readonly object[], cache: ProjectLayerSerializationCache): string;
+/**
+ * {@link serializeProjectWithLayerCache} that hands the main thread back
+ * between layers, so autosave on a project with several large layers is many
+ * short tasks instead of one 300-400 ms freeze (GeoLibre#2869).
+ *
+ * The cache makes a camera move free, so the cost lands on the first autosave
+ * and on edits to a big layer: each layer that misses the cache is serialized
+ * in its own slice, and the thread is released once a slice has run longer than
+ * a few milliseconds. A single huge layer is still one slice. The result is
+ * identical to the synchronous call. `project` and `layerSources` must not be
+ * mutated while this runs; the store replaces records rather than editing them,
+ * so a snapshot taken from it stays valid.
+ *
+ * @param project Project to serialize, as built from `layerSources`.
+ * @param layerSources Immutable source record for each entry of
+ *   `project.layers`, in the same order, used as the cache key.
+ * @param cache Cache shared between calls.
+ * @param yieldFn Hands the thread back; replaced in tests.
+ * @returns The same text {@link serializeProject} returns for `project`.
+ */
+declare function serializeProjectWithLayerCacheAsync(project: GeoLibreProject, layerSources: readonly object[], cache: ProjectLayerSerializationCache, yieldFn?: () => Promise<void>): Promise<string>;
+declare function parseProject(json: string): GeoLibreProject;
+/**
+ * Coerce an untrusted (possibly hand-edited) legend config into a valid
+ * {@link LegendConfig}, dropping malformed entries. Returns undefined when no
+ * usable config is present so the default is applied downstream.
+ */
+declare function normalizeLegendConfig(legend: unknown): LegendConfig | undefined;
+/**
+ * Validate and coerce a story map loaded from an untrusted project file.
+ *
+ * Returns null when the value carries no chapters so empty story maps stay out
+ * of the saved project, mirroring how plugins are only persisted when present.
+ *
+ * @param storymap Raw value read from the project JSON.
+ * @returns A normalized story map, or null when there is nothing to keep.
+ */
+declare function normalizeStoryMap(storymap: unknown): StoryMap | null;
+/** Whether a story map carries chapters or any non-default setting. */
+declare function storyMapHasContent(story: StoryMap): boolean;
+/**
+ * Coerce an untrusted (possibly hand-edited) `models` array into valid
+ * {@link ProcessingModel} records. Drops models and steps without a usable id or
+ * tool id, de-duplicates models by id, and keeps step `parameters` as a plain
+ * object (the runner validates parameter values per tool at run time). Returns
+ * `null` when there is nothing worth persisting, so a model-less project stays
+ * free of the key.
+ *
+ * @param value Raw `models` value from the project JSON.
+ * @returns Normalized models, or `null` when none survive.
+ */
+declare function normalizeModels(value: unknown): ProcessingModel[] | null;
+/**
+ * Coerce an untrusted `graph` value into a {@link ProcessingModelGraph}. Drops
+ * nodes without a usable id or an unknown kind, de-duplicates node ids, and
+ * drops edges that do not connect two surviving nodes or that name an empty
+ * port. Self-edges are dropped too, since a node cannot feed itself.
+ *
+ * Structural validity beyond this (cycles, type mismatches, missing required
+ * inputs) is the runner's job — those depend on the tool registries, which the
+ * project layer deliberately does not import.
+ *
+ * @param value Raw `graph` value from the project JSON.
+ * @returns The normalized graph, or `null` when it has no usable nodes.
+ */
+declare function normalizeModelGraph(value: unknown): ProcessingModelGraph | null;
+/**
+ * Coerce an untrusted (possibly hand-edited) `processingHistory` array into
+ * valid {@link ProcessingRun} records. Drops entries without a usable id, tool
+ * id, or known kind, de-duplicates by id, keeps `parameters` as a plain object,
+ * and caps the list at {@link MAX_PROCESSING_HISTORY} (keeping the newest,
+ * i.e. last, entries). Returns `null` when nothing survives, so a history-less
+ * project stays free of the key.
+ *
+ * @param value Raw `processingHistory` value from the project JSON.
+ * @returns Normalized runs, or `null` when none survive.
+ */
+/**
+ * Accept the Object-Based Analysis workbench blob (`obia`) only as a plain,
+ * JSON-serializable object carrying a numeric `version`. Its fields are owned
+ * and validated by the desktop app, which treats anything it does not
+ * recognise as absent; core only guarantees the shape survives a round trip.
+ *
+ * @param value Raw `obia` value from the project JSON.
+ * @returns A detached copy, or `null` when absent or malformed.
+ */
+declare function normalizeObiaWorkbench(value: unknown): Record<string, unknown> | null;
+declare function normalizeProcessingHistory(value: unknown): ProcessingRun[] | null;
+/**
+ * Coerce an untrusted (possibly hand-edited) camera object into a valid
+ * {@link MapViewState}, falling back to the default view for missing parts.
+ */
+declare function normalizeMapViewState(value: unknown): MapViewState;
+/**
+ * Coerce an untrusted `mapLayout` into a valid {@link MapGridLayout}. Returns
+ * null when absent or effectively single-pane so default projects stay
+ * byte-identical (the field is only written when the grid is larger than 1x1).
+ */
+declare function normalizeMapLayout(value: unknown): MapGridLayout | null;
+/**
+ * Coerce an untrusted `primaryRenderer` into a known engine id (issue #2217).
+ *
+ * Returns null for the default 2D map — absent, unknown, or an explicit
+ * `"maplibre"` — because the field is only written when it is not the default,
+ * so a MapLibre project serializes byte-identically to before this existed.
+ * The return type is narrowed to `"cesium" | "mapbox" | "arcgis" | null` rather
+ * than the full {@link MapRendererKind} for that reason: `"maplibre"` is never a
+ * result.
+ */
+declare function normalizePrimaryRenderer(value: unknown): "cesium" | "mapbox" | "arcgis" | null;
+/**
+ * Coerce an untrusted `secondaryMapViews` array into valid
+ * {@link SecondaryMapView} records, dropping entries without a usable id and
+ * de-duplicating by id. Returns null when none are valid.
+ */
+declare function normalizeSecondaryMapViews(value: unknown): SecondaryMapView[] | null;
+/**
+ * Reconcile a parsed grid layout with its secondary panes so the store invariant
+ * holds: `secondaryMapViews.length === rows * cols - 1`. Surplus panes are
+ * dropped; missing panes are filled by cloning the primary map. A null/absent
+ * layout (or a 1x1 grid) collapses to the single-map default.
+ */
+declare function resolveMapGrid(layout: MapGridLayout | null, secondaryViews: SecondaryMapView[] | null, primary: {
+  mapView: MapViewState;
+}): {
+  mapLayout: MapGridLayout;
+  secondaryMapViews: SecondaryMapView[];
+};
+/** Bookmarks kept per project, as the panel's own default limit allows. */
+declare const MAX_PROJECT_BOOKMARKS = 500;
+/**
+ * Coerce an untrusted `bookmarkGroups` array into valid folders: drops entries
+ * without a string id and de-duplicates by id. A missing name becomes
+ * "Folder"; `collapsed` defaults to false.
+ *
+ * @param value Raw `bookmarkGroups` value from the project JSON.
+ * @returns The folders (possibly empty).
+ */
+declare function normalizeBookmarkGroups(value: unknown): ProjectBookmarkGroup[];
+/**
+ * Coerce an untrusted `bookmarks` array into valid saved views: drops entries
+ * without a string id or a finite, in-range camera, de-duplicates by id, wraps
+ * the bearing into 0-360, and drops a `groupId` that names no folder in
+ * `groups`. Keeps at most {@link MAX_PROJECT_BOOKMARKS}.
+ *
+ * @param value Raw `bookmarks` value from the project JSON.
+ * @param groups The project's (normalized) folders.
+ * @returns The bookmarks (possibly empty).
+ */
+declare function normalizeBookmarks(value: unknown, groups?: readonly ProjectBookmarkGroup[]): ProjectBookmark[];
+/**
+ * Coerce an untrusted (possibly hand-edited) `widgets` array into valid
+ * {@link DashboardWidget} records. Drops widgets without a usable id, layer id,
+ * or recognized chart type, de-duplicates by id, and keeps only the optional
+ * keys that are present and well-typed (the Dashboard panel falls back to
+ * sensible defaults for anything missing). Returns `null` when there is nothing
+ * worth persisting, so a widget-less project stays free of the key.
+ *
+ * @param value Raw `widgets` value from the project JSON.
+ * @returns Normalized widgets, or `null` when none survive.
+ */
+declare function normalizeWidgets(value: unknown): DashboardWidget[] | null;
+/**
+ * Clamp an untrusted dashboard column count into the supported range, falling
+ * back to the default for a missing or non-finite value.
+ *
+ * @param value Raw `dashboardColumns` value from the project JSON.
+ * @returns An integer column count within [MIN, MAX].
+ */
+declare function normalizeDashboardColumns(value: unknown): number;
+/**
+ * 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.
+ */
+declare function normalizeProjectInteraction(value: unknown): ProjectInteraction | null;
+declare function isAllowedPluginManifestUrl(url: string): boolean;
+declare function normalizeProjectComments(rawComments: unknown): ProjectComment[];
+declare function projectFromStore(state: {
+  projectName: string;
+  mapView: MapViewState;
+  basemapStyleUrl: string;
+  basemapVisible: boolean;
+  basemapOpacity: number;
+  blankBackgroundColor?: string | null;
+  layers: GeoLibreLayer[];
+  selectedLayerId?: string | null;
+  layerGroups?: LayerGroup[];
+  preferences: ProjectPreferences;
+  plugins?: ProjectPluginState | null;
+  legend?: LegendConfig | null;
+  printLayout?: PrintLayoutConfig | null;
+  storymap?: StoryMap | null;
+  models?: ProcessingModel[] | null;
+  processingHistory?: ProcessingRun[] | null;
+  obia?: Record<string, unknown> | null;
+  widgets?: DashboardWidget[] | null;
+  bookmarks?: ProjectBookmark[] | null;
+  bookmarkGroups?: ProjectBookmarkGroup[] | null;
+  dashboardColumns?: number;
+  mapLayout?: MapGridLayout;
+  secondaryMapViews?: SecondaryMapView[];
+  primaryMapLabel?: string;
+  primaryRenderer?: MapRendererKind;
+  /** Project-scoped Style Manager entries (the store's `projectStyleLibrary`). */
+  styleLibrary?: StyleLibraryEntry[] | null;
+  comments?: ProjectComment[] | null;
+  /** Startup interaction state loaded with the project, written back as-is. */
+  interaction?: ProjectInteraction | null;
+  metadata: Record<string, unknown>;
+}): GeoLibreProject;
+/**
+ * Whether a layer lives only for the current session and is never written to a
+ * project file. A plugin sets `metadata.sessionOnly` on a store row that mirrors
+ * something it draws itself and cannot restore, such as a point cloud streamed
+ * from a short-lived signed URL, so the row shows in the Layers panel while the
+ * plugin runs but a reopened project carries no dead entry for it.
+ *
+ * @param layer - The layer to check.
+ * @returns `true` when the layer must be left out of saved projects.
+ */
+declare function isSessionOnlyLayer(layer: GeoLibreLayer): boolean;
+/**
+ * The plain HTTP(S) WMS template inside the desktop app's `geolibre-wms://`
+ * wrapper (its CORS-exempt native fetcher), or the tile unchanged when it is
+ * not wrapped or the wrapped URL is not HTTP(S). Shared by project export and
+ * the ArcGIS engine's story-export templates.
+ *
+ * @param tile - A tile template, wrapped or not.
+ * @returns The unwrapped template, or `tile` itself.
+ */
+declare function portableWmsTileUrl(tile: unknown): unknown;
+/**
+ * The store form of one project layer: its style completed from
+ * {@link DEFAULT_LAYER_STYLE} and the project's top-level `styles` entry.
+ *
+ * Legacy and externally-authored projects can carry a partial top-level style
+ * alongside newer fields on the layer itself. Those layer fields are kept,
+ * while the top-level copy stays authoritative where it explicitly supplies a
+ * value.
+ *
+ * @param project - The project the layer belongs to (for its `styles` map).
+ * @param layer - One of `project.layers`.
+ * @returns A new layer record ready for the store.
+ */
+declare function hydrateProjectLayer(project: Pick<GeoLibreProject, "styles">, layer: GeoLibreLayer): GeoLibreLayer;
+declare function applyProjectToStore(project: GeoLibreProject): {
+  projectName: string;
+  mapView: MapViewState;
+  basemapStyleUrl: string;
+  basemapVisible: boolean;
+  basemapOpacity: number;
+  blankBackgroundColor: string | null;
+  layers: GeoLibreLayer[];
+  layerGroups: LayerGroup[];
+  preferences: ProjectPreferences;
+  projectPlugins: ProjectPluginState | null;
+  legend: LegendConfig;
+  printLayout: PrintLayoutConfig;
+  storymap: StoryMap | null;
+  models: ProcessingModel[];
+  processingHistory: ProcessingRun[];
+  obiaWorkbench: Record<string, unknown> | null;
+  widgets: DashboardWidget[];
+  bookmarks: ProjectBookmark[];
+  bookmarkGroups: ProjectBookmarkGroup[];
+  dashboardColumns: number;
+  mapLayout: MapGridLayout;
+  secondaryMapViews: SecondaryMapView[];
+  primaryMapLabel: string;
+  primaryRenderer: MapRendererKind;
+  projectStyleLibrary: StyleLibraryEntry[];
+  comments: ProjectComment[];
+  projectInteraction: ProjectInteraction | null;
+  metadata: Record<string, unknown>;
+};
+/**
+ * Create an unlinked copy of a project, suffixed with "(copy)" by default and
+ * stripped of share-specific metadata (shareId, shareUrl, etc.).
+ */
+declare function detachProjectCopy(project: GeoLibreProject, options?: {
+  nameSuffix?: string;
+}): GeoLibreProject;
+/**
+ * Create a template snapshot of a project. Optionally strips data layers while
+ * keeping basemap, layer groups, styles, legend config, preferences, widgets, and
+ * print layout.
+ */
+declare function createProjectTemplate(project: GeoLibreProject, options?: {
+  name?: string;
+  stripDataLayers?: boolean;
+}): GeoLibreProject;
+//#endregion
+//#region src/project-diff.d.ts
+/** One changed value, with bounded human-readable previews of each side. */
+interface ProjectValueChange {
+  /** Dotted key path relative to the section, e.g. `fillColor` or `labels.field`. */
+  path: string;
+  /** Preview of the earlier value; `undefined` when the key was absent. */
+  before?: string;
+  /** Preview of the later value; `undefined` when the key is now absent. */
+  after?: string;
+}
+/** Counts of embedded GeoJSON feature changes in one layer. */
+interface FeatureChangeSummary {
+  added: number;
+  removed: number;
+  modified: number;
+  unchanged: number;
+  /**
+   * How features were matched: `"id"` when every feature carries a unique
+   * `id`, `"geometry"` when none does (matched by geometry hash), `"mixed"`
+   * otherwise.
+   */
+  matchedBy: "id" | "geometry" | "mixed";
+}
+/** Changes to one layer between the two projects. */
+interface LayerDiff {
+  id: string;
+  /** Layer name in the later project (or the earlier one when removed). */
+  name: string;
+  /** Layer type in the later project (or the earlier one when removed). */
+  type: string;
+  status: "added" | "removed" | "changed";
+  /** Set when the layer was renamed. */
+  renamed?: {
+    before: string;
+    after: string;
+  };
+  /**
+   * Set when the layer changed position relative to the layers present in
+   * both projects (bottom-to-top indexes in each project's `layers`).
+   */
+  moved?: {
+    before: number;
+    after: number;
+  };
+  visibility?: {
+    before: boolean;
+    after: boolean;
+  };
+  opacity?: {
+    before: number;
+    after: number;
+  };
+  /** Style keys other than labels. */
+  style: ProjectValueChange[];
+  /** Label style keys (`style.labels.*`), without the `labels.` prefix. */
+  labels: ProjectValueChange[];
+  /** `filterExpression` and `quickFilters`. */
+  filter: ProjectValueChange[];
+  /** `type`, `source.*` and `sourcePath`. */
+  source: ProjectValueChange[];
+  /** Any other persisted layer field (popup, joins, metadata.*, ...). */
+  other: ProjectValueChange[];
+  /** Embedded GeoJSON feature changes; absent when the data is unchanged. */
+  features?: FeatureChangeSummary;
+  /** Feature count for an added or removed layer with embedded GeoJSON. */
+  featureCount?: number;
+}
+/** Changes to one plugin's project state. */
+interface PluginDiff {
+  id: string;
+  /** `added`/`removed` mean the plugin was activated/deactivated. */
+  status: "added" | "removed" | "changed";
+  changes: ProjectValueChange[];
+}
+/** The full structured difference between two projects. */
+interface ProjectDiff {
+  layers: {
+    added: LayerDiff[];
+    removed: LayerDiff[];
+    changed: LayerDiff[];
+    /** True when any layer present in both projects changed position. */
+    reordered: boolean;
+  };
+  camera: ProjectValueChange[];
+  basemap: ProjectValueChange[];
+  /** Map projection (`preferences.map.projection`). */
+  projection: ProjectValueChange[];
+  /** Other project preferences (`preferences.*` minus the projection). */
+  preferences: ProjectValueChange[];
+  plugins: PluginDiff[];
+  /** Plugin manifest URLs added to or removed from the project. */
+  pluginManifests: {
+    added: string[];
+    removed: string[];
+  };
+  /** Project name (`name`), `metadata.description` and other metadata keys. */
+  metadata: ProjectValueChange[];
+  /** Other top-level sections that changed (`legend`, `storymap`, ...). */
+  sections: string[];
+  /** Total number of reported changes; 0 means the projects are equivalent. */
+  changeCount: number;
+}
+/** Options for {@link diffProjects}. */
+interface ProjectDiffOptions {
+  /** Maximum characters of a before/after preview (default 80). */
+  maxPreviewLength?: number;
+}
+/**
+ * Deep structural equality for JSON-like values. A key whose value is
+ * `undefined` is treated as absent, so an in-memory record compares equal to
+ * its JSON round trip.
+ *
+ * @param a - First value.
+ * @param b - Second value.
+ * @returns True when the two values are structurally equal.
+ */
+declare function jsonValuesEqual(a: unknown, b: unknown): boolean;
+/**
+ * Render a bounded JSON-ish preview of a value without serializing more of it
+ * than the preview can show, so a large array or object costs no more than
+ * `maxLength` characters of work.
+ *
+ * @param value - The value to preview.
+ * @param maxLength - Maximum preview length; longer output ends with `…`.
+ * @returns The preview, or `undefined` for `undefined`.
+ */
+declare function previewValue(value: unknown, maxLength?: number): string | undefined;
+/**
+ * Count the features added, removed and modified between two feature
+ * collections. Features are matched by `id` when they carry one; id-less
+ * features are matched by geometry hash, so a feature whose properties
+ * changed but whose geometry did not counts as modified, while a moved
+ * id-less feature counts as one removal plus one addition.
+ *
+ * @param before - Earlier collection (absent counts as empty).
+ * @param after - Later collection (absent counts as empty).
+ * @returns The change counts.
+ */
+declare function diffFeatureCollections(before: FeatureCollection | null | undefined, after: FeatureCollection | null | undefined): FeatureChangeSummary;
+/**
+ * Compute a structured summary of what changed from `before` to `after`.
+ *
+ * Layers are matched by id. Embedded GeoJSON is compared per feature (by id,
+ * falling back to geometry hash) and each feature is hashed once per object,
+ * so diffing the same parsed project against several others reuses its
+ * hashes; callers keep and pass the same parsed project objects to benefit.
+ *
+ * @param before - The earlier project (e.g. an autosave snapshot).
+ * @param after - The later project (e.g. the current project).
+ * @param options - Preview length and other tuning.
+ * @returns The grouped change summary.
+ */
+declare function diffProjects(before: GeoLibreProject, after: GeoLibreProject, options?: ProjectDiffOptions): ProjectDiff;
+//#endregion
+export { collectTransitiveJoinSourceIds as $, LegendCustomEntry as $n, SQL_QUERY_SOURCE_KIND as $r, CollaborationParticipant as $t, normalizeMapViewState as A, scrubPrintLayoutForRemovedLayers as Ai, IndicatorAggregation as An, PopupFieldConfig as Ar, getActiveBodyRadiusRatio as At, normalizeWidgets as B, CesiumBasemapImagery as Bi, LayerGroup as Bn, ProjectBookmark as Br, AppCapabilities as Bt, isSessionOnlyLayer as C, PrintLayoutLegendEntry as Ci, EditorTrackingConfig as Cn, NonGeographicCoordinates as Cr, PLANET_SWITCHER_OPTIONS as Ct, normalizeDashboardColumns as D, normalizePrintLayoutConfig as Di, GeoLibreProject as Dn, ParticipantIdentity as Dr, bodyLengthToEarth as Dt, normalizeBookmarks as E, isDefaultPrintLayout as Ei, GeoLibreLayer as En, PROTOMAPS_BASEMAPS as Er, PlanetaryBasemapSectionId as Et, normalizeProcessingHistory as F, MultiPolygon as Fi, LabelStyle as Fn, ProcessingModelStep as Fr, getPlanetaryBasemapById as Ft, serializeProject as G, LayerMetadataLink as Gn, ProjectPluginState as Gr, AttributeFormValueMapEntry as Gt, portableWmsTileUrl as H, basemapToCesiumImagery as Hi, LayerJoinStats as Hn, ProjectComment as Hr, AppRole as Ht, normalizeProjectComments as I, Point as Ii, LabelTransform as In, ProcessingRerunRequest as Ir, getPlanetaryBasemapByStyleUrl as It, storyMapHasContent as J, LayerQuickFilter as Jn, QuickFilterDateKind as Jr, BLEND_MODES as Jt, serializeProjectWithLayerCache as K, LayerMetadataTemporalExtent as Kn, ProjectPreferences as Kr, AttributeFormWidget as Kt, normalizeProjectInteraction as L, Polygon as Li, LayerCapabilities as Ln, ProcessingRun as Lr, meanRadiusMeters as Lt, normalizeModels as M, FeatureCollection as Mi, LAYER_TYPES as Mn, PopupFieldKind as Mr, getActiveMeanRadiusMeters as Mt, normalizeObiaWorkbench as N, Geometry as Ni, LabelAnchor as Nn, ProcessingModel as Nr, getActiveSemiMajorAxisMeters as Nt, normalizeLegendConfig as O, printLayoutConfigsEqual as Oi, GeocodingPreferences as On, PointRenderer as Or, earthAreaToBody as Ot, normalizePrimaryRenderer as P, LineString as Pi, LabelDedupe as Pn, ProcessingModelGraph as Pr, getEllipsoid as Pt, cascadeLayerJoinRefresh as Q, LegendConfig as Qn, RuntimeEnvironmentVariable as Qr, CollaborationMode as Qt, normalizeSecondaryMapViews as R, CESIUM_BASEMAPS as Ri, LayerConnection as Rn, ProcessingRunKind as Rr, setActiveEllipsoidId as Rt, isAllowedPluginManifestUrl as S, PrintLayoutCorner as Si, DiagramType as Sn, NETCDF_IMAGE_SOURCE_KIND as Sr, PLANETARY_BASEMAP_SENTINEL_PREFIX as St, normalizeBookmarkGroups as T, createDefaultPrintLayout as Ti, FillPattern as Tn, PROJECT_VERSION as Tr, PlanetaryBasemapGroup as Tt, projectFromStore as U, normalizeCesiumBasemap as Ui, LayerLibraryEntry as Un, ProjectInteraction as Ur, AttributeFormConfig as Ut, parseProject as V, availableCesiumBasemap as Vi, LayerJoin as Vn, ProjectBookmarkGroup as Vr, AppPrivilege as Vt, resolveMapGrid as W, sameCesiumImagery as Wi, LayerMetadataContact as Wn, ProjectPluginControlPosition as Wr, AttributeFormFieldConfig as Wt, applyJoinsToLayer as X, LayerType as Xn, QuickFilterTextOperator as Xr, CollabInvite as Xt, ApplyLayerJoinsResult as Y, LayerStyle as Yn, QuickFilterKind as Yr, BlendMode as Yt, applyLayerJoins as Z, LayerVirtualField as Zn, RecentProjectEntry as Zr, CollaborationChatMessage as Zt, createEmptyProject as _, isDuckDBQueryLayer as _i, DashboardWidget as _n, ModelGraphNode as _r, ELLIPSOIDS as _t, ProjectDiffOptions as a, StoryChapterLocation as ai, CommentReply as an, MAX_DASHBOARD_COLUMNS as ar, batchDecodePolylines as at, detachProjectCopy as b, DEFAULT_PRINT_LAYOUT as bi, DiagramField as bn, ModelPortKind as br, PLANETARY_BASEMAPS as bt, diffProjects as c, StoryMap as ci, DEFAULT_DASHBOARD_COLUMNS as cn, MIN_DASHBOARD_COLUMNS as cr, encodePolyline as ct, CreateProjectOptions as d, StyleLibraryEntry as di, DEFAULT_MAP_GRID_LAYOUT as dn, MapProjection as dr, unescapePolyline as dt, SecondaryMapView as ei, CollaborationPresence as en, LegendCustomItem as er, layerJoinKey as et, DEFAULT_PROJECT_NAME as f, StyleLibraryEntryKind as fi, DEFAULT_PRIMARY_RENDERER as fn, MapRendererKind as fr, geojsonHasZCoordinates as ft, createDefaultMapView as g, detectNonGeographicCoordinates as gi, DUCKDB_VECTOR_ROUTE_BYTES as gn, ModelGraphEdge as gr, EARTH_MEAN_RADIUS_METERS as gt, applyProjectToStore as h, VectorStyleStop as hi, DUCKDB_VECTOR_FEATURE_WARN_COUNT as hn, MarkerShape as hr, DEFAULT_ELLIPSOID_ID as ht, ProjectDiff as i, StoryChapterAnimation as ii, CommentAuthor as in, LineDecoration as ir, PolylineDecodeResult as it, normalizeModelGraph as j, Feature as ji, LARGE_VECTOR_FEATURE_THRESHOLD as jn, PopupFieldFormat as jr, getActiveEllipsoid as jt, normalizeMapLayout as k, scrubPrintLayoutForLayers as ki, GeometryGeneratorType as kn, PopupDateFormat as kr, earthLengthToBody as kt, jsonValuesEqual as l, StorySlideMode as li, DEFAULT_LAYER_STYLE as ln, MapGridLayout as lr, geoJSONToPolylineStr as lt, ProjectLayerSerializationCache as m, VectorStyleMode as mi, DEFAULT_STORY_MAP as mn, MapViewState as mr, transformGeojsonElevation as mt, LayerDiff as n, StoryChapter as ni, CollaborationState as nn, LegendItemOverride as nr, stripJoinFields as nt, ProjectValueChange as o, StoryInsetPosition as oi, DEFAULT_BASEMAP as on, MAX_MAP_GRID_DIM as or, decodePolyline as ot, MAX_PROJECT_BOOKMARKS as p, VectorRule as pi, DEFAULT_PROJECT_PREFERENCES as pn, MapScaleUnit as pr, horizontalBbox as pt, serializeProjectWithLayerCacheAsync as q, LayerPopupConfig as qn, ProjectTemplateEntry as qr, BLANK_BASEMAP as qt, PluginDiff as r, StoryChapterAlignment as ri, CommentAnchor as rn, LegendPanelPosition as rr, PolylineBatchOptions as rt, diffFeatureCollections as s, StoryLayerOpacityChange as si, DEFAULT_BLEND_MODE as sn, MAX_PROCESSING_HISTORY as sr, decodePolylineDetailed as st, FeatureChangeSummary as t, StoryActiveSlideMode as ti, CollaborationRole as tn, LegendCustomShape as tr, reapplyLayerJoins as tt, previewValue as u, StrokeWidthUnit as ui, DEFAULT_LEGEND_CONFIG as un, MapPreferences as ur, polylineStrToGeoJSON as ut, createProjectLayerSerializationCache as v, shouldUseTiledRendering as vi, DashboardWidgetAggregation as vn, ModelGraphNodeKind as vr, Ellipsoid as vt, normalizeBlankBackgroundColor as w, PrintLayoutPageFilter as wi, FieldVisibility as wn, OPENFREEMAP_BASEMAPS as wr, PlanetaryBasemap as wt, hydrateProjectLayer as x, PrintLayoutConfig as xi, DiagramSizeMode as xn, ModelToolProvider as xr, PLANETARY_BASEMAP_GROUPS as xt, createProjectTemplate as y, styleValue as yi, DashboardWidgetType as yn, ModelGraphPort as yr, EllipsoidId as yt, normalizeStoryMap as z, CesiumBasemapId as zi, LayerDescriptiveMetadata as zn, ProcessingRunStatus as zr, AddTileLayerOptions as zt };
+//# sourceMappingURL=project-diff-BD23T4xv.d.mts.map