osmgl 0.10.0 → 0.12.0

package/dist/osmgl.d.ts

@@ -277,9 +277,45 @@ declare class Transform {
     height: number;
     minZoom: number;
     maxZoom: number;
+    /**
+     * Рамка, за которую не выпускается ЦЕНТР карты. `null` — ограничения нет.
+     *
+     * Прижимается в сеттере центра, а не при отрисовке: центр ставят и жесты, и анимация, и
+     * приложение, и проверить это в одном месте — единственный способ не забыть ни одного из них.
+     */
+    maxBounds: LngLatBounds | null;
+    /**
+     * Повторять ли мир по горизонтали при отъезде.
+     *
+     * На мелком зуме в кадр помещается больше одного оборота Земли, и копии закрывают пустоту по
+     * краям. Приложению это иногда мешает — например, когда по карте водят выделение и вторая копия
+     * ловит тот же клик, — поэтому повтор выключается (`map.setRenderWorldCopies`).
+     */
+    renderWorldCopies: boolean;
     minPitch: number;
     maxPitch: number;
+    /**
+     * КРЕН камеры, градусы: поворот вокруг оси взгляда.
+     *
+     * Наклон (`pitch`) кладёт камеру вперёд, поворот (`bearing`) вращает карту под ней, а крен
+     * заваливает сам кадр — как накренившийся самолёт. Нужен полётам и панорамам; на обычной карте
+     * остаётся нулём. Порядок сборки тот же, что у MapLibre: крен идёт МЕЖДУ отъездом камеры и
+     * наклоном, иначе он начал бы вращать не кадр, а землю под ним.
+     *
+     * Свойство, а не поле: присваивание обязано пометить камеру грязной, иначе матрицы останутся
+     * прежними и крен не доедет до кадра.
+     */
+    private _roll;
     private _center;
+    /**
+     * ВЫСОТА ЗЕМЛИ ПОД ЦЕНТРОМ КАРТЫ, метры. Ставится рельефом каждый кадр; без рельефа — ноль.
+     *
+     * Камера у нас стоит на фиксированном расстоянии от ТОЧКИ ЦЕНТРА, а точка эта лежала на нулевой
+     * высоте. Над горой в 2 км это значит, что камера оказывается внутри горы: земля поднялась, а
+     * она — нет. Поднимаем всю связку камера-центр на высоту земли — ровно так же поступает MapLibre
+     * (`transform.elevation`), и по той же причине: иначе рельеф нельзя даже осмотреть.
+     */
+    private _centerElevation;
     private _zoom;
     private _bearing;
     private _pitch;
@@ -325,6 +361,9 @@ declare class Transform {
     constructor();
     get center(): LngLat;
     set center(v: LngLat);
+    /** Высота земли под центром, метры (ставит рельеф). */
+    get centerElevation(): number;
+    set centerElevation(v: number);
     /**
      * Нижняя граница зума на глобусе: дальше шар становится точкой в углу экрана.
      *
@@ -341,6 +380,8 @@ declare class Transform {
     get pitch(): number;
     set pitch(p: number);
     /** Вертикальный угол обзора в градусах. */
+    get roll(): number;
+    set roll(deg: number);
     get fov(): number;
     set fov(deg: number);
     resize(width: number, height: number): void;
@@ -366,6 +407,15 @@ declare class Transform {
     worldPxToPoint(wx: number, wy: number, altitudeMeters?: number): ScreenPoint$1 | null;
     /** Пиксели экрана → география на уровне земли (луч сквозь плоскость z=0). */
     unproject(point: ScreenPoint$1): LngLat;
+    /**
+     * ВЫСОТА ЗЕМЛИ В ТОЧКЕ, метры — её ставит рельеф.
+     *
+     * Без неё обратный перевод «экран → место» считает землю плоскостью на нуле. На рельефе земля
+     * лежит на своей высоте, и на городском зуме при наклоне промах доходит до полутора километров:
+     * клик по дому открывал карточку соседнего квартала, а перетаскивание карты уезжало из-под
+     * пальца. Ровно это же (и ровно так же, итерациями) делает MapLibre в `pointCoordinate3D`.
+     */
+    elevationAt: ((mx: number, my: number) => number) | null;
     /** Пиксели экрана → мировые пиксели на плоскости земли. */
     pointToWorldPx(point: ScreenPoint$1): {
         x: number;
@@ -487,7 +537,7 @@ declare class Transform {
      * @param dir   куда ЛЕТИТ свет (та же система, что у `u_key_dir`)
      * @param maxHeightMeters потолок сцены: выше него теней не бывает
      */
-    updateShadow(dir: Vec3, maxHeightMeters: number): void;
+    updateShadow(dir: Vec3, maxHeightMeters: number, groundMin?: number, groundMax?: number): void;
     /** Матрицы теней посчитаны и пригодны. */
     get shadowReady(): boolean;
     /**
@@ -590,6 +640,169 @@ interface GestureOptions {
  * @param sinceFirstMove сколько прошло с первого замеченного движения, мс
  */
 declare function pitchIntent(a: ScreenPoint$1, b: ScreenPoint$1, sinceFirstMove: number): boolean | undefined;
+/**
+ * Обработка ввода. Единственная точка, которая двигает Transform от пользователя;
+ * после каждого изменения дёргает onChange, а Map решает, когда рисовать кадр.
+ */
+declare class GestureManager {
+    private canvas;
+    private tr;
+    private onChange;
+    private onInteractionEnd;
+    private opts;
+    private pointers;
+    private dragMode;
+    private lastPoint;
+    private panAnchor;
+    private samples;
+    private inertiaRaf;
+    private touch;
+    private lastTapTime;
+    private disposed;
+    /**
+     * ЧТО СЕЙЧАС ВЕДЁТ РУКА.
+     *
+     * Нужно `map.isMoving()` и родне: у MapLibre «движется» — это и анимация камеры, и жест, и
+     * инерция после него. Про анимацию знает карта, а про жест — только этот класс.
+     */
+    get moving(): boolean;
+    get rotating(): boolean;
+    get zooming(): boolean;
+    constructor(canvas: HTMLCanvasElement, tr: Transform, onChange: (reason: 'pan' | 'zoom' | 'rotate' | 'pitch') => void, onInteractionEnd: () => void, options?: Partial<GestureOptions>);
+    setOptions(options: Partial<GestureOptions>): void;
+    private bind;
+    private point;
+    private onContextMenu;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onWheel;
+    private onKeyDown;
+    private beginTouchGesture;
+    private updateTouchGesture;
+    /**
+     * Щипок: масштаб, поворот и перенос — одним движением.
+     *
+     * Точка, взятая между пальцами, остаётся под ними: сначала запоминаем её по ПРЕЖНЕМУ центру пары,
+     * потом меняем масштаб и азимут, и только затем возвращаем её под НОВЫЙ центр. Последний шаг заодно
+     * даёт панораму двумя пальцами — раньше её не было вовсе: карта под двумя пальцами не двигалась,
+     * пока расстояние между ними не менялось.
+     */
+    private applyZoomRotate;
+    private zoomAround;
+    private panBy;
+    private rotateBy;
+    private pushSample;
+    private startInertia;
+    private stopInertia;
+    destroy(): void;
+}
+
+/**
+ * ОБРАБОТЧИКИ ВВОДА КАК ОБЪЕКТЫ: `map.dragPan.disable()` и родня.
+ *
+ * У MapLibre каждый жест — отдельный объект с `enable`/`disable`/`isEnabled`, и приложения
+ * пользуются именно этим: «на время рисования отключить перетаскивание», «запретить зум колесом
+ * внутри формы». У нас жесты живут одним менеджером с набором флагов, и объекты здесь — тонкая
+ * обёртка над ними. Смысл тот же, а второго места, где решается, что делать с пальцем, не заводим.
+ */
+declare class GestureHandler {
+    private manager;
+    private key;
+    private enabled;
+    constructor(manager: () => GestureManager | null, key: keyof GestureOptions, enabled: boolean);
+    isEnabled(): boolean;
+    isActive(): boolean;
+    enable(): void;
+    disable(): void;
+    private set;
+}
+/**
+ * ЗУМ РАМКОЙ: Shift + протянуть мышью.
+ *
+ * Живёт отдельно от менеджера жестов намеренно. Менеджер ведёт непрерывные жесты — тянет карту,
+ * крутит, щиплет; здесь же всё наоборот: рисуется рамка, карта стоит, а движение случается ОДИН
+ * раз, когда кнопку отпустили. Смешивать их значит вплетать в разбор указателя ещё одно состояние
+ * ради одной рамки.
+ */
+declare class BoxZoomHandler {
+    private canvas;
+    private container;
+    private fit;
+    private enabled;
+    private start;
+    private box;
+    constructor(canvas: HTMLCanvasElement, container: HTMLElement, fit: (p0: {
+        x: number;
+        y: number;
+    }, p1: {
+        x: number;
+        y: number;
+    }) => void);
+    isEnabled(): boolean;
+    isActive(): boolean;
+    enable(): void;
+    disable(): void;
+    destroy(): void;
+    private onDown;
+    private onMove;
+    private onUp;
+    private finish;
+    private pointOf;
+}
+/**
+ * ОСТОРОЖНЫЕ ЖЕСТЫ: страница важнее карты.
+ *
+ * Карта во всю ширину статьи ловит прокрутку страницы колесом и не даёт её пролистать — знакомая
+ * беда встроенных карт. Включённый режим требует Ctrl (или двух пальцев на телефоне) и подсказывает
+ * это надписью поверх карты. Поведение и текст — как у MapLibre `cooperativeGestures`.
+ */
+declare class CooperativeGesturesHandler {
+    private canvas;
+    private container;
+    private setScrollZoom;
+    private texts;
+    private enabled;
+    private hint;
+    private timer;
+    constructor(canvas: HTMLCanvasElement, container: HTMLElement, setScrollZoom: (on: boolean) => void, texts?: {
+        windows?: string;
+        mac?: string;
+        mobile?: string;
+    });
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+    destroy(): void;
+    private onWheel;
+    private onTouch;
+    private show;
+    private hide;
+    private isMac;
+}
+
+/**
+ * КОНТРОЛЫ КАРТЫ: кнопки и плашки поверх канвы.
+ *
+ * Интерфейс дословно как у MapLibre — приложение, написанное под него, должно подключать свои
+ * контролы без правок. Договор простой: контрол отдаёт свой элемент, карта кладёт его в угол.
+ *
+ * ★ БЕЗ ВНЕШНЕГО CSS.
+ *
+ * У MapLibre вид контролов задаёт отдельный файл стилей, и забытый `<link>` превращает карту в
+ * россыпь голых кнопок — это первая беда, с которой сталкиваются при подключении. Наши контролы
+ * несут свои стили в себе (inline), поэтому работают всюду, где работает карта, и ничего не
+ * требуют от страницы.
+ */
+/** Угол, в который встаёт контрол. Значения те же, что у MapLibre. */
+type ControlPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/** Что карта ждёт от контрола. `map` намеренно нетипизирован здесь — иначе вышел бы круг импортов. */
+interface IControl {
+    onAdd(map: unknown): HTMLElement;
+    onRemove(map: unknown): void;
+    /** Куда встать, если место не указали при добавлении. */
+    getDefaultPosition?(): ControlPosition;
+}
 
 /**
  * Обёртка над WebGL2 + кеш состояния.
@@ -630,6 +843,15 @@ declare class Context {
     private _boundTextures;
     private _stencilTest;
     constructor(gl: WebGL2RenderingContext);
+    /**
+     * ЗАБЫТЬ ВСЁ, ЧТО МЫ ЗНАЛИ О СОСТОЯНИИ GL.
+     *
+     * Нужно после чужого кода — своего слоя приложения (`CustomLayerInterface`). Он вправе поменять
+     * программу, буферы, смешивание и глубину; наш кеш после этого врёт, и следующий проход
+     * «пропускает» установку, которой на самом деле нет. Дешевле объявить кеш недействительным, чем
+     * потом искать, почему исчезли подписи.
+     */
+    resetState(): void;
     useProgram(program: WebGLProgram | null): boolean;
     bindVAO(vao: WebGLVertexArrayObject | null): void;
     /**
@@ -698,67 +920,26 @@ declare class Shader {
 }
 
 /**
- * Разбор Mapbox Vector Tile (spec 2.1) — наш тайлсервер отдаёт именно его
- * (схема OpenMapTiles v3: building / transportation / water / landuse / poi …).
+ * СВОИ ПРОТОКОЛЫ ЗАГРУЗКИ И ПРАВКА ЗАПРОСОВ.
  *
- * Читаем «лениво»: сначала только оглавление слоёв, геометрию каждой фичи
- * распаковываем по требованию. На тайл с 20 тыс. фич это разница между
- * 40 мс и 3 мс, когда генератору нужен один слой из пятнадцати.
- */
-declare const enum GeomType {
-    Unknown = 0,
-    Point = 1,
-    LineString = 2,
-    Polygon = 3
-}
-type PropValue = string | number | boolean | null;
-/** Кольцо/линия: плоский массив [x0,y0,x1,y1,...] в координатах тайла [0..extent]. */
-type Ring = number[];
-declare class VectorTileFeature {
-    private pbf;
-    readonly keys: string[];
-    readonly values: PropValue[];
-    readonly extent: number;
-    id?: number;
-    type: GeomType;
-    properties: Record<string, PropValue>;
-    /** Позиция блока геометрии в буфере; -1 — геометрии нет. Пишется читателем полей. */
-    geomOffset: number;
-    constructor(pbf: Pbf, keys: string[], values: PropValue[], extent: number);
-    static read(pbf: Pbf, end: number, keys: string[], values: PropValue[], extent: number): VectorTileFeature;
-    /** Кольца/линии фичи. Для полигонов внешние и внутренние идут вперемешку — см. splitPolygons. */
-    loadGeometry(): Ring[];
-    /** BBox фичи в координатах тайла — дешёвый отсев до триангуляции. */
-    bbox(): [number, number, number, number];
-}
-declare class VectorTileLayer {
-    private pbf;
-    version: number;
-    name: string;
-    extent: number;
-    readonly featureOffsets: number[];
-    readonly keys: string[];
-    readonly values: PropValue[];
-    constructor(pbf: Pbf);
-    static read(pbf: Pbf, end: number): VectorTileLayer;
-    get length(): number;
-    feature(i: number): VectorTileFeature;
-    /** Итератор по всем фичам слоя. */
-    features(): Generator<VectorTileFeature>;
-}
-declare class VectorTile {
-    readonly layers: Record<string, VectorTileLayer>;
-    constructor(buffer: ArrayBuffer | Uint8Array);
-}
-/**
- * Разбивает кольца полигона на группы «внешнее + его дырки».
- * Ориентация по знаку площади: в MVT внешние кольца по часовой (положительная
- * площадь в системе с Y вниз), дырки — против.
+ * Два разных вопроса, но оба про «откуда берутся байты тайла»:
+ *
+ *   `addProtocol('pmtiles', …)` — адрес вида `pmtiles://…` обслуживает приложение само: читает из
+ *   одного файла, из IndexedDB, из WebAssembly-читалки;
+ *
+ *   `setTransformRequest(fn)` — обычный адрес, но перед отправкой его правят: подписывают, меняют
+ *   домен, добавляют ключ.
+ *
+ * ★ И ТО И ДРУГОЕ ЖИВЁТ НА ГЛАВНОМ ПОТОКЕ.
+ *
+ * Так же у MapLibre, и по той же причине: обработчик приложенческий — ему нужны ключи, кеш и
+ * хранилища страницы. Требовать, чтобы он работал внутри воркера, значит требовать от приложения
+ * писать под воркер. Поэтому байты добываются здесь, а воркеру достаётся только разбор.
  */
-declare function splitPolygons(rings: Ring[]): {
-    outer: Ring;
-    holes: Ring[];
-}[];
+/** Что обработчик протокола отдаёт: содержимое тайла или `null`, если тайла нет. */
+type ProtocolHandler = (url: string, signal: AbortSignal) => Promise<ArrayBuffer | null>;
+/** Правка адреса перед загрузкой. Возврат `null` означает «оставить как есть». */
+type TransformRequest = (url: string, kind: 'tile' | 'raster' | 'glyph' | 'sprite') => string | null | undefined;
 
 /**
  * Формат стиля движка.
@@ -790,10 +971,21 @@ interface ColorFrom {
     /** Насколько затемнить, 0..1 (0.25 — четверть). */
     darken?: number;
 }
-/** Значение, зависящее от зума: число/цвет либо остановки для интерполяции. */
+/**
+ * Значение, зависящее от зума.
+ *
+ * Три формы, и все три равноправны:
+ *   само значение — `14`, `'#fff'`;
+ *   наши остановки — `{ stops: [[10, 2], [16, 8]] }`, короткая запись линейной шкалы;
+ *   выражение MapLibre — `['interpolate', ['linear'], ['zoom'], 10, 2, 16, 8]`.
+ *
+ * Выражения добавлены не вместо остановок, а рядом: на остановках написаны все наши стили, а на
+ * выражениях — всё, что приходит снаружи. Выбирать между ними не должно приходиться ни приложению,
+ * ни теме (см. `style/expression.ts`).
+ */
 type Interpolated<T> = T | {
     stops: [number, T][];
-};
+} | unknown[];
 /**
  * Фильтр по свойствам фичи. Подмножество синтаксиса MapLibre — ровно то,
  * что встречается в схеме OMT.
@@ -803,7 +995,14 @@ type Interpolated<T> = T | {
  *   ['has', 'name']
  *   ['all', [...], [...]]
  */
-type Filter = ['==' | '!=' | '>' | '>=' | '<' | '<=', string, string | number | boolean] | ['in' | '!in', string, ...(string | number | boolean)[]] | ['has' | '!has', string] | ['all' | 'any', ...Filter[]] | ['!', Filter];
+type Filter = ['==' | '!=' | '>' | '>=' | '<' | '<=', string, string | number | boolean] | ['in' | '!in', string, ...(string | number | boolean)[]] | ['has' | '!has', string] | ['all' | 'any', ...Filter[]] | ['!', Filter]
+/**
+ * Выражение MapLibre: `['==', ['get', 'class'], 'primary']` и любое другое.
+ *
+ * Отличается от старой формы тем, что на месте имени свойства стоит вложенное выражение — по
+ * этому признаку они и различаются при разборе (см. `matchesFilter`).
+ */
+ | unknown[];
 interface LayerBase {
     id: string;
     /**
@@ -1001,6 +1200,30 @@ interface LineLayerSpec extends LayerBase {
          */
         widthExtra?: Interpolated<number>;
         dashArray?: [number, number];
+        /**
+         * ШИРИНА В МЕТРАХ вместо пикселей — для РАЗМЕТКИ.
+         *
+         * Полоса разметки это объект местности: по ГОСТ Р 51256 сплошная осевая — 0.1–0.2 м, зебра —
+         * полосы по 0.4 м. В пикселях такую линию задать нельзя: на z16 она была бы вдвое шире, чем
+         * на z17, и на близком зуме вместо разметки получалась бы полоса во всю полосу движения.
+         *
+         * Задана — ширина считается от неё (`width` при этом не смотрится вовсе).
+         */
+        widthMeters?: Interpolated<number>;
+        /**
+         * СДВИГ ПОПЕРЁК ЛИНИИ В МЕТРАХ — тоже для разметки.
+         *
+         * Полоса лежит не по оси дороги, а на своём месте: осевая по середине, краевая в 3.3 м от неё,
+         * разделительная между полосами. Это размер на земле, и задавать его пикселями нельзя.
+         */
+        offsetMeters?: Interpolated<number>;
+        /**
+         * Пунктир В МЕТРАХ: `[штрих, пропуск]`.
+         *
+         * У разметки 1.5 штрих и пропуск относятся как 1:3 (3 м и 9 м вне перекрёстка) — и это тоже
+         * размер на земле, а не на экране.
+         */
+        dashMeters?: [number, number];
         /**
          * Стрелки направления (односторонние улицы). Рисуются аналитически
          * шевронами поверх полотна — без текстуры, поэтому чёткие на любом зуме.
@@ -1186,6 +1409,27 @@ interface SymbolLayerSpec extends LayerBase {
         maxLineChars?: number;
         /** Не участвовать в коллизиях (подпись всегда видна). */
         allowOverlap?: boolean;
+        /**
+         * НЕ ЗАНИМАТЬ МЕСТА У ОСТАЛЬНЫХ, но самому уступать занятому.
+         *
+         * Половина `allowOverlap`, как `icon-ignore-placement` у Mapbox. Нужна фоновым подписям —
+         * названиям улиц и номерам домов: они рисуются там, где свободно, но не вытесняют собой
+         * значки и названия мест. Без этого на плотной застройке номера домов съедают POI, а их
+         * самих никто не читает.
+         */
+        ignorePlacement?: boolean;
+        /**
+         * ГРУППА РАСКЛАДКИ: с кем подпись всё-таки делит место.
+         *
+         * Работает в паре с `ignorePlacement`. Сам по себе он снимает подпись с учёта полностью — и
+         * тогда названия улиц ложатся поверх номеров домов и друг друга: каждая уступает значкам, но
+         * ни одна не знает о соседке. Общая группа возвращает их в коллизии между собой, оставляя
+         * невидимыми для всех остальных слоёв.
+         *
+         * Значение — любая строка, важно лишь совпадение: слои с одной строкой расталкивают друг
+         * друга, с разными — не видят.
+         */
+        placementGroup?: string;
         /**
          * Дополнительное поле вокруг подписи в пикселях — разрежает однотипные
          * метки. Номер трассы иначе повторяется на каждом отрезке: перекрытия нет,
@@ -1211,6 +1455,21 @@ interface SymbolLayerSpec extends LayerBase {
         iconFrame?: 'circle' | 'pin' | 'none';
         /** Диаметр подложки относительно значка. */
         iconFrameScale?: number;
+        /**
+         * СОСТАВНОЙ ЗНАЧОК: силуэты, нарисованные один поверх другого в одной точке.
+         *
+         * Атлас значков у нас общий с буквами и одноканальный — из него приходит форма, а цвет
+         * ставится на весь поток вершин сразу. Разноцветной пиктограммы одной картинкой поэтому не
+         * получится, и она собирается из частей: у светофора это корпус, три лампы и мачта. Части
+         * перечисляются СНИЗУ ВВЕРХ (первая ложится под остальные), цвета им раздаёт
+         * `paint.partColors`, обводку — `paint.partHaloWidths`.
+         *
+         * Совмещать части координатами не нужно: у них общий viewBox, поэтому и общий растр, и
+         * рисуются они в один и тот же прямоугольник. Сам `iconImage` при этом обязателен — по нему
+         * считается размер и место в коллизиях, и он же остаётся одноцветным запасным вариантом, пока
+         * части не догрузились.
+         */
+        iconParts?: string[];
         /**
          * Свойство фичи с поворотом значка в градусах (0 — север, по часовой).
          * Значок доворачивается на поворот камеры, поэтому стрелка у входа смотрит
@@ -1312,6 +1571,15 @@ interface SymbolLayerSpec extends LayerBase {
         /** Рамка подложки. По умолчанию — цвет значка, приглушённый до трети. */
         frameHaloColor?: Interpolated<string>;
         frameHaloWidth?: Interpolated<number>;
+        /**
+         * Цвета частей составного значка (`layout.iconParts`), по порядку частей.
+         *
+         * Лежат в paint, а не рядом с именами частей: это ЦВЕТ, и тема вправе его перекрасить, как
+         * перекрашивает всё остальное. Части без цвета красятся как обычный значок.
+         */
+        partColors?: (Interpolated<string> | ColorFrom)[];
+        /** Обводка частей, по порядку частей. По умолчанию её нет — см. `partColors`. */
+        partHaloWidths?: Interpolated<number>[];
         opacity?: Interpolated<number>;
     };
 }
@@ -1333,6 +1601,27 @@ interface SurfaceLayerSpec extends LayerBase {
     base?: number;
     /** Ширина фаски по горизонтали, метры. 0 — резкий край. */
     bevel?: number;
+    /**
+     * СТРОИТЬ ПОВЕРХНОСТЬ ИЗ ЛИНИЙ, а не из полигонов: полотно дороги, тротуар, дорожка.
+     *
+     * Дорога в данных — ось, а не площадь, и рисуется она лентой в экранных пикселях: у такой ленты
+     * нет края в мире, поэтому нет и бордюра, и борта, и тени от него. С этим флагом ось
+     * превращается в контур (`generators/ribbon`), и полотно становится обычной поверхностью — со
+     * своим уровнем, фаской и юбкой. Ширина берётся из данных (атрибут `width`, метры), а если её
+     * там нет — из `width` ниже.
+     */
+    fromLines?: boolean;
+    /** Ширина полотна в метрах, когда в данных её нет (тропинка, тротуар). Только с `fromLines`. */
+    width?: number;
+    /** Прибавка к ширине из данных, метры: обочина, свес бордюра. Только с `fromLines`. */
+    widthExtra?: number;
+    /**
+     * Толщина плиты у ПРИПОДНЯТОГО полотна (мост, эстакада), метры.
+     *
+     * Мост без низа читается плёнкой, висящей над улицей: сверху асфальт, а дальше сразу земля.
+     * Толщина даёт ему боковую стенку — ту же, что у берега приподнятой поверхности.
+     */
+    deck?: number;
     /** На сколько фаска опускается, метры. */
     /**
      * Насколько широкую щель между кусками СЛИТЬ, метры. По умолчанию — общее значение движка.
@@ -1342,6 +1631,18 @@ interface SurfaceLayerSpec extends LayerBase {
      * белую плиту.
      */
     weld?: number;
+    /**
+     * УЧАСТВУЕТ ЛИ ПОВЕРХНОСТЬ В ПОЛЕ ВЫСОТ, по которому поднимаются линии. По умолчанию — да.
+     *
+     * Поле отвечает на вопрос «на чём лежит линия»: дорожка, проходящая по приподнятому двору,
+     * поднимается вместе с ним (см. `generators/ground`). Полотну дорог это во вред: линия, которая
+     * просто ПЕРЕСЕКАЕТ асфальт, взбирается на него и рисуется поверх. Самое заметное — русло реки:
+     * мост через неё выходит перечёркнутым синей полосой ровно по проезжей части.
+     *
+     * Поэтому полотно из поля исключается. Своей разметке оно ничего не должно: краска и так лежит
+     * выше асфальта собственной отметкой.
+     */
+    groundField?: boolean;
     bevelDrop?: number;
     paint: MaterialPaint & {
         color: Interpolated<string>;
@@ -1516,28 +1817,118 @@ interface SkySpec {
 }
 declare const DEFAULT_SKY: SkySpec;
 interface SourceSpec {
-    /** Шаблон вида `/tileserver/data/indoor/{z}/{x}/{y}.pbf`. */
-    url: string;
+    /** Шаблон вида `/tileserver/data/indoor/{z}/{x}/{y}.pbf`. У `geojson` адреса нет. */
+    url?: string;
     /**
      * Что лежит по адресу. Без поля — векторные тайлы, как было раньше.
      *
      * `raster` — подложка картинками: её не надо разбирать, поэтому она не идёт
      * через пул воркеров и рисуется одним квадом на тайл (см. `RasterSource`).
      */
-    type?: 'vector' | 'raster';
+    type?: 'vector' | 'raster' | 'raster-dem' | 'geojson' | 'image' | 'video' | 'canvas';
+    /**
+     * Четыре угла картинки, видео или canvas: левый верхний, правый верхний, правый нижний, левый
+     * нижний. Порядок и смысл как у MapLibre — углы независимы, прямоугольник необязателен.
+     */
+    coordinates?: unknown;
+    /** Элемент canvas или его id (`type: 'canvas'`). */
+    canvas?: unknown;
+    /** Перезаливать ли текстуру каждый кадр (живой canvas). */
+    animate?: boolean;
+    /**
+     * ДАННЫЕ ПРИЛОЖЕНИЯ вместо тайлов с сервера (`type: 'geojson'`).
+     *
+     * Сам набор или адрес, откуда его забрать. Нарезкой на тайлы занимается движок
+     * (`source/geojson-source.ts`), поэтому слои ссылаются на такой источник как на обычный.
+     */
+    data?: unknown;
+    /** Имя слоя внутри источника: на него смотрит `source-layer` слоя стиля. По умолчанию `geojson`. */
+    sourceLayer?: string;
+    /** Собирать ли точки в кластеры (`geojson`). */
+    cluster?: boolean;
+    /** Радиус кластера в пикселях экрана. */
+    clusterRadius?: number;
+    /** Зум, выше которого кластеров нет. */
+    clusterMaxZoom?: number;
+    /**
+     * Кодировка высоты у `raster-dem`: `mapbox` (наш набор) или `terrarium`. См. `source/dem.ts`.
+     */
+    encoding?: 'mapbox' | 'terrarium';
     minzoom?: number;
     maxzoom?: number;
 }
+/**
+ * РЕЛЬЕФ: земля перестаёт быть плоскостью.
+ *
+ * `source` — имя источника типа `raster-dem`, `exaggeration` — множитель высоты (1 — как в
+ * данных, 0 — рельеф выключен). Высоту читает вершинный шейдер каждого слоя, который лежит по
+ * земле: заливки, поверхности, дороги. Разбор подхода MapLibre и наш план — в `porting/terrain.md`.
+ *
+ * Тип ИМЕНОВАННЫЙ, а не инлайновый: его принимает `map.setTerrain` — тот самый метод, которым
+ * рельеф включают на лету (имя и смысл как у MapLibre).
+ */
+interface TerrainSpec {
+    source: string;
+    exaggeration?: number;
+    /**
+     * ЧЕМ РЕЛЬЕФ ПОКАЗАН, кроме собственной формы.
+     *
+     * Сверху склон почти не читается — на бумажных картах его для того и красят по высоте
+     * (гипсометрия) и отмывают светом. Оба тона здесь, а не в движке, потому что это ЦВЕТ: у
+     * ледяной темы он холодный, у ночной тёмный, и одним набором на все темы не обойтись.
+     *
+     * `low`/`high` — тон низин и вершин, `range` — между какими высотами растянут переход,
+     * `tint`/`shade` — насколько сильно подмешивать окраску и отмывку (0..1).
+     */
+    tint?: {
+        /**
+         * Тона шкалы высот. НЕОБЯЗАТЕЛЬНЫ: без них рельеф остаётся в цветах самой карты, а объём ему
+         * даёт одна отмывка. Так и нужно, когда карта уже раскрашена по смыслу — окраска по высоте
+         * тогда спорит с ней за внимание.
+         *
+         * Три режима:
+         *   ни одного тона — только отмывка;
+         *   один `high` — тон нарастает к вершинам, низины остаются цветом карты;
+         *   `low` и `high` — полная гипсометрическая шкала по всему диапазону.
+         */
+        low?: string;
+        /** Тон середины: между долиной и вершиной лежат склоны, и без своего тона они пропадают. */
+        mid?: string;
+        high?: string;
+        range?: [number, number];
+        tint?: number;
+        shade?: number;
+    };
+}
 interface StyleSpec {
     version: 1;
     name?: string;
     /** Цвет подложки. */
     background: string;
+    /**
+     * НА СКОЛЬКО МЕТРОВ ПОДНИМАЕТ КАЖДЫЙ УРОВЕНЬ ПЕРЕСЕЧЕНИЯ (`generators/level`): мост — 1, земля —
+     * 0, тоннель — −1.
+     *
+     * Пока дороги были краской, уровень решал только ПОРЯДОК отрисовки (см. `network`). Полотно —
+     * геометрия, и на пересечении без подъёма эстакада и улица под ней оказались бы на одной высоте:
+     * два непрозрачных верха в одной плоскости.
+     *
+     * Число нарочно маленькое. Настоящая эстакада поднята на пять метров и более, но опор и съездов
+     * у нас нет: на такой высоте мост обрывался бы в воздухе там, где кончается его пролёт. Полметра
+     * хватает, чтобы пересечение читалось «над», и не хватает, чтобы стык с обычной дорогой стал
+     * ступенькой.
+     *
+     * ВНИЗ НЕ ОПУСКАЕМ: землю мы не разрезаем, и тоннель под ней просто исчез бы вместе со своей
+     * подписью. Он остаётся на уровне земли — ровно так же, как рисовался лентой до сих пор.
+     */
+    levelHeight?: number;
     light?: Partial<LightSpec>;
     /** Небо и дымка. */
     sky?: Partial<SkySpec>;
     /** Дополнительные источники тайлов помимо `base` (его задаёт карта опцией `tiles`). */
     sources?: Record<string, SourceSpec>;
+    /** Рельеф под картой (см. `TerrainSpec`). */
+    terrain?: TerrainSpec;
     /**
      * Ключ варианта 3D-моделей (см. `ThemeSpec.model3dKey`).
      *
@@ -1557,113 +1948,41 @@ interface StyleSpec {
 declare const DEFAULT_LIGHT: LightSpec;
 
 /**
- * Генератор геометрии зданий: экструзия полигонов слоя `building` (схема OpenMapTiles v3).
- * Работает в воркере, отдаёт готовые типизированные массивы — они уходят в главный
- * поток transfer'ом (без копирования) и грузятся в GPU как есть.
- *
- * Формат вершины (stride 18 байт):
- *   a_pos     2 × Int16   off 0   координаты тайла [0..extent]
- *   a_height  1 × Uint16  off 4   высота вершины в метрах × 4 (до 16383 м, шаг 0.25)
- *   a_tint    1 × Uint8   off 6   оттенок здания (одинаков у всех его вершин)
- *   a_ao      1 × Uint8   off 7   0 — основание, 255 — верх
- *   a_normal  3 × Int8n   off 8   нормаль
- *   a_kind    1 × Uint8   off 11  тип поверхности и класс фасада
- *   a_wall    3 × Uint16  off 12  фасад: смещение вдоль грани, её ширина и высота (метры × 4)
- *
- * Высота ушла из Float32 в Uint16 ради места под a_tint: без разброса оттенка
- * квартал выглядит одной сплошной массой.
+ * План для воркера и общие с ним имена.
  *
- * `a_wall` появился ради РОВНОЙ раскладки окон. Сначала координата вдоль стены
- * считалась в шейдере как проекция позиции на её направление — сетка тогда общая
- * на всю карту, и грань режет её где придётся: у угла дома получается половина
- * окна, а простенки у разных стен разной ширины. Ширина и высота грани позволяют
- * ВПИСАТЬ сетку в неё: поля по краям, целое число ячеек, окно целиком.
+ * Лежит ОТДЕЛЬНО от разбора стиля, хотя логически это его часть. Причина
+ * механическая: воркер собирается в свой бандл и вшивается строкой в основной,
+ * а `style.ts` тянет за собой встроенный стиль и два десятка тем — сотню
+ * килобайт цветов, которые воркеру не нужны вовсе (он строит геометрию, красит
+ * главный поток). Импорт одной функции оттуда удваивал вес этих JSON в сборке.
  */
-declare const BUILDING_VERTEX_STRIDE = 18;
-/** Множитель упаковки высоты в Uint16. */
-declare const BUILDING_HEIGHT_SCALE = 32;
+/** План для воркера: что именно строить из тайла. Должен пережить structured clone. */
+/** Слои, которые вообще строятся из тайла: у подложки строить нечего. */
+type TiledLayerSpec = Extract<StyleLayerSpec, {
+    'source-layer': string;
+}>;
 /**
- * Множитель упаковки ПОЛОЖЕНИЯ вершины: сколько единиц Int16 приходится на единицу тайла.
- *
- * Было единица — то есть 0.47 м на z14, потому что координаты в MVT целые и вершину писали как
- * есть. Пока углы дома были прямыми, этого хватало: вершина и так стояла в узле сетки. Со
- * СКРУГЛЕНИЕМ хватать перестало — дуга радиусом 1.6 м это семь точек в пределах трёх единиц тайла,
- * и округление сажает их на ту же сетку: вместо дуги выходит лесенка со ступенью в полметра, она же
- * «угловатость» на ближнем зуме.
+ * ПОКРАСКА, ЗАВИСЯЩАЯ ОТ ФИЧИ: что посчитать в воркере и положить в вершину.
  *
- * Восемь единиц на тайловую — это 5.9 см, и дуга снова читается дугой. Потолок: тайл 0..4096, при
- * ×8 это 0..32768, и последнее значение на единицу больше, чем помещается в Int16, — оно
- * прижимается (`clampI16`). Ошибка при этом 6 см и только у вершины, стоящей ровно на дальней
- * границе тайла.
+ * Лежит в плане, потому что считается там же, где есть фича, — при тесселяции (см.
+ * `generators/data-paint.ts`). Голые выражения, то есть обычные массивы: structured clone их
+ * переживает, а функции бы не пережил.
  */
-declare const BUILDING_POS_SCALE = 8;
-interface BuildingsMesh {
-    vertices: ArrayBuffer;
-    indices: ArrayBuffer;
-    /** Uint32Array: id фичи на каждый треугольник — для пикинга и подсветки. */
-    featureIds: ArrayBuffer;
-    vertexCount: number;
-    indexCount: number;
-    extent: number;
-}
-interface BuildingsOptions {
-    /**
-     * Радиус скругления углов в МЕТРАХ. Скругляется контур, а значит и стены, и
-     * крыша — она строится по тому же кольцу. Ноль (по умолчанию) — острые углы,
-     * как раньше.
-     */
-    cornerRadius?: number;
-    /** Максимум отрезков на дугу: меньше — дешевле и угловатее. */
-    cornerSegments?: number;
+interface DataPaintSpec {
+    /** Выражение цвета. */
+    color?: unknown;
+    /** Выражение прозрачности: домножает альфу цвета. */
+    opacity?: unknown;
+    /** Выражение ширины линии, CSS-пиксели. */
+    width?: unknown;
     /**
-     * Сколько метров в одной единице тайла. Нужен, чтобы решать по РАЗМЕРУ: дом
-     * в сотню квадратов получает скатную крышу, торговый центр — плоскую. Без
-     * него один и тот же порог на разных зумах означал бы разные здания.
+     * Цвет слоя обычной формой — нужен, когда от фичи зависит только прозрачность.
+     *
+     * Вершинный путь в шейдере включается целиком: раз уж цвет берётся из вершины, в ней должен
+     * лежать весь цвет, а не одна альфа.
      */
-    metersPerUnit?: number;
+    base?: string;
 }
-declare function generateBuildings(layer: VectorTileLayer, extent: number, filter?: Filter, options?: BuildingsOptions, 
-/**
- * Куда складывать дома, задевающие границу тайла.
- *
- * Задан — такие дома здесь НЕ строятся: из куска правильной геометрии не выйдет, их соберут из
- * всех кусков сразу. Не задан — прежнее поведение, каждый кусок сам по себе.
- */
-seams?: BuildingSeam[]): BuildingsMesh | null;
-/**
- * Кусок дома, задевающего границу тайла: контур с пометкой ЛОЖНЫХ рёбер.
- *
- * Уезжает на главный поток, чтобы там сложиться с кусками соседних тайлов в целый дом.
- * Кольца — в координатах СВОЕГО тайла; общую систему строит уже сборщик, он знает номера тайлов.
- */
-interface BuildingSeam {
-    osmId: number;
-    height: number;
-    minHeight: number;
-    seed: number;
-    tint: number;
-    facade: number;
-    outer: number[];
-    holes: number[][];
-    /** `cut[i]` — ребро от вершины i к i+1 порождено обрезкой, а не стеной дома. */
-    outerCut: boolean[];
-    holeCuts: boolean[][];
-}
-
-/**
- * План для воркера и общие с ним имена.
- *
- * Лежит ОТДЕЛЬНО от разбора стиля, хотя логически это его часть. Причина
- * механическая: воркер собирается в свой бандл и вшивается строкой в основной,
- * а `style.ts` тянет за собой встроенный стиль и два десятка тем — сотню
- * килобайт цветов, которые воркеру не нужны вовсе (он строит геометрию, красит
- * главный поток). Импорт одной функции оттуда удваивал вес этих JSON в сборке.
- */
-/** План для воркера: что именно строить из тайла. Должен пережить structured clone. */
-/** Слои, которые вообще строятся из тайла: у подложки строить нечего. */
-type TiledLayerSpec = Extract<StyleLayerSpec, {
-    'source-layer': string;
-}>;
 interface LayerPlan {
     id: string;
     /**
@@ -1695,6 +2014,16 @@ interface LayerPlan {
     bevel?: number;
     weld?: number;
     bevelDrop?: number;
+    /** Поверхность строится из осей линий (см. `SurfaceLayerSpec.fromLines`). */
+    fromLines?: boolean;
+    /** Ширина полотна в метрах, когда её нет в данных. */
+    width?: number;
+    /** Прибавка к ширине из данных, метры. */
+    widthExtra?: number;
+    /** Толщина плиты у приподнятого полотна (мост, эстакада), метры. */
+    deck?: number;
+    /** Метров на уровень пересечения (`StyleSpec.levelHeight`) — им поднимается полотно моста. */
+    levelHeight?: number;
     /**
      * Линия ложится НА ПОВЕРХНОСТЬ, по которой идёт (см. `generators/ground`).
      *
@@ -1703,6 +2032,8 @@ interface LayerPlan {
      * отрисовка, — отсюда флаг в плане.
      */
     ground?: boolean;
+    /** Кладёт ли ПОВЕРХНОСТЬ свои контуры в поле высот (`StyleLayerSpec.groundField`). */
+    groundField?: boolean;
     /**
      * Класс поверхности → её уровень, метры. По этой таблице поднимается РАЗМЕТКА на асфальте.
      *
@@ -1712,6 +2043,8 @@ interface LayerPlan {
      * живут в стиле. Таблица и сводит одно с другим.
      */
     groundBy?: Record<string, number>;
+    /** Покраска на фиче: выражения, которые воркер посчитает и положит в вершину. */
+    dataPaint?: DataPaintSpec;
     /** Только для symbol: шаблоны подставляются уже в воркере, чтобы не гонять свойства. */
     textField?: string | string[];
     iconImage?: string | string[];
@@ -1731,6 +2064,239 @@ declare const BASE_SOURCE = "base";
 declare const SPLIT_SEP = "\u241F";
 declare const splitBucketKey: (layerId: string, value: string | number) => string;
 
+/**
+ * ПОКРАСКА, ЗАВИСЯЩАЯ ОТ ФИЧИ (data-driven paint).
+ *
+ * Цвет и ширина слоя уходят в шейдер ЮНИФОРМАМИ — одно значение на весь слой. Это верно ровно до
+ * тех пор, пока значение задано числом, остановками или зумовым выражением. Стоит написать
+ * `['match', ['get', 'class'], 'primary', '#f00', '#999']`, и одного значения на слой уже не
+ * хватает: у каждой дороги своё.
+ *
+ * Значит, считать надо ТАМ, ГДЕ ЕСТЬ ФИЧА, — в воркере, при тесселяции, — и класть результат
+ * В ВЕРШИНУ. Ровно так же поступает MapLibre, раскладывая data-driven свойства по атрибутам
+ * (`paint_vertex_arrays`): другого места, где фича ещё жива, в конвейере нет.
+ *
+ * Формат отдельного буфера, а не добавка к вершине слоя:
+ *
+ *   a_dcolor  4 × Uint8 (normalized)  off 0   цвет фичи, НЕ домноженный на альфу
+ *   a_dwidth  1 × Float32             off 4   ширина фичи в CSS-пикселях (0 — не задана)
+ *
+ * Буфер отдельный по двум причинам. Раскладка вершины у заливки, линии и дома разная — добавлять
+ * поле пришлось бы в каждую, и каждая выросла бы навсегда, хотя data-driven покраска есть у
+ * единиц слоёв. И буфера просто НЕТ у обычного слоя: атрибут остаётся отключённым, шейдер берёт
+ * юниформ, и ни один старый слой не платит за это ни байта.
+ *
+ * ЗУМ. Выражение считается на зуме ТАЙЛА, а не экрана: тайл разбирается один раз и живёт в кеше на
+ * нескольких зумах. Для `['match', ['get', …]]` это безразлично, а зумовая интерполяция, смешанная
+ * с фичей, окажется ступенчатой по зуму — MapLibre в этом месте тоже запекает значения по зумам
+ * тайла, только держит две ступени и смешивает их в шейдере.
+ */
+declare const DATA_PAINT_STRIDE = 8;
+
+/** Есть ли в слое хоть одно значение, которое придётся считать на фиче. */
+declare function needsDataPaint(spec: DataPaintSpec | undefined): boolean;
+/**
+ * Накопитель значений на вершину.
+ *
+ * Генератор не знает заранее, сколько вершин даст фича: дробление под глобус добавляет
+ * середины рёбер, скругление угла — дугу. Поэтому значения не пишутся по одному, а
+ * ДОГОНЯЮТ геометрию: генератор говорит «вершин теперь столько», и накопитель заполняет
+ * всё, что появилось с прошлого раза, значениями текущей фичи.
+ */
+declare class FeaturePaint {
+    private readonly spec;
+    private readonly zoom;
+    private buffer;
+    private view;
+    private capacity;
+    /** Сколько вершин уже покрашено. */
+    private filled;
+    /** Значения текущей фичи. */
+    private r;
+    private g;
+    private b;
+    private a;
+    private width;
+    /** Цвет слоя, когда от фичи он не зависит: считается один раз на тайл. */
+    private readonly base;
+    constructor(spec: DataPaintSpec, zoom: number);
+    /** Посчитать значения для фичи. Дальше они лягут во все её вершины. */
+    setFeature(properties: Record<string, unknown>, id: number | string | null, geometryType: string | undefined): void;
+    /** Догнать геометрию: все вершины до `vertexCount` красятся текущей фичей. */
+    advanceTo(vertexCount: number): void;
+    /**
+     * Готовый буфер ровно на `vertexCount` вершин.
+     *
+     * Хвост добивается последней фичей: у генераторов бывают служебные вершины (крышка острова,
+     * шов), и оставить их непокрашенными значит получить чёрные треугольники.
+     */
+    take(vertexCount: number): ArrayBuffer;
+    private ensure;
+}
+/** Накопитель, если слою он нужен. */
+declare function makeFeaturePaint(spec: DataPaintSpec | undefined, zoom: number): FeaturePaint | undefined;
+
+/**
+ * Разбор Mapbox Vector Tile (spec 2.1) — наш тайлсервер отдаёт именно его
+ * (схема OpenMapTiles v3: building / transportation / water / landuse / poi …).
+ *
+ * Читаем «лениво»: сначала только оглавление слоёв, геометрию каждой фичи
+ * распаковываем по требованию. На тайл с 20 тыс. фич это разница между
+ * 40 мс и 3 мс, когда генератору нужен один слой из пятнадцати.
+ */
+declare const enum GeomType {
+    Unknown = 0,
+    Point = 1,
+    LineString = 2,
+    Polygon = 3
+}
+type PropValue = string | number | boolean | null;
+/** Кольцо/линия: плоский массив [x0,y0,x1,y1,...] в координатах тайла [0..extent]. */
+type Ring = number[];
+declare class VectorTileFeature {
+    private pbf;
+    readonly keys: string[];
+    readonly values: PropValue[];
+    readonly extent: number;
+    id?: number;
+    type: GeomType;
+    properties: Record<string, PropValue>;
+    /** Позиция блока геометрии в буфере; -1 — геометрии нет. Пишется читателем полей. */
+    geomOffset: number;
+    constructor(pbf: Pbf, keys: string[], values: PropValue[], extent: number);
+    static read(pbf: Pbf, end: number, keys: string[], values: PropValue[], extent: number): VectorTileFeature;
+    /** Кольца/линии фичи. Для полигонов внешние и внутренние идут вперемешку — см. splitPolygons. */
+    loadGeometry(): Ring[];
+    /** BBox фичи в координатах тайла — дешёвый отсев до триангуляции. */
+    bbox(): [number, number, number, number];
+}
+declare class VectorTileLayer {
+    private pbf;
+    version: number;
+    name: string;
+    extent: number;
+    readonly featureOffsets: number[];
+    readonly keys: string[];
+    readonly values: PropValue[];
+    constructor(pbf: Pbf);
+    static read(pbf: Pbf, end: number): VectorTileLayer;
+    get length(): number;
+    feature(i: number): VectorTileFeature;
+    /** Итератор по всем фичам слоя. */
+    features(): Generator<VectorTileFeature>;
+}
+declare class VectorTile {
+    readonly layers: Record<string, VectorTileLayer>;
+    constructor(buffer: ArrayBuffer | Uint8Array);
+}
+/**
+ * Разбивает кольца полигона на группы «внешнее + его дырки».
+ * Ориентация по знаку площади: в MVT внешние кольца по часовой (положительная
+ * площадь в системе с Y вниз), дырки — против.
+ */
+declare function splitPolygons(rings: Ring[]): {
+    outer: Ring;
+    holes: Ring[];
+}[];
+
+/**
+ * Генератор геометрии зданий: экструзия полигонов слоя `building` (схема OpenMapTiles v3).
+ * Работает в воркере, отдаёт готовые типизированные массивы — они уходят в главный
+ * поток transfer'ом (без копирования) и грузятся в GPU как есть.
+ *
+ * Формат вершины (stride 18 байт):
+ *   a_pos     2 × Int16   off 0   координаты тайла [0..extent]
+ *   a_height  1 × Uint16  off 4   высота вершины в метрах × 4 (до 16383 м, шаг 0.25)
+ *   a_tint    1 × Uint8   off 6   оттенок здания (одинаков у всех его вершин)
+ *   a_ao      1 × Uint8   off 7   0 — основание, 255 — верх
+ *   a_normal  3 × Int8n   off 8   нормаль
+ *   a_kind    1 × Uint8   off 11  тип поверхности и класс фасада
+ *   a_wall    3 × Uint16  off 12  фасад: смещение вдоль грани, её ширина и высота (метры × 4)
+ *
+ * Высота ушла из Float32 в Uint16 ради места под a_tint: без разброса оттенка
+ * квартал выглядит одной сплошной массой.
+ *
+ * `a_wall` появился ради РОВНОЙ раскладки окон. Сначала координата вдоль стены
+ * считалась в шейдере как проекция позиции на её направление — сетка тогда общая
+ * на всю карту, и грань режет её где придётся: у угла дома получается половина
+ * окна, а простенки у разных стен разной ширины. Ширина и высота грани позволяют
+ * ВПИСАТЬ сетку в неё: поля по краям, целое число ячеек, окно целиком.
+ */
+declare const BUILDING_VERTEX_STRIDE = 18;
+/** Множитель упаковки высоты в Uint16. */
+declare const BUILDING_HEIGHT_SCALE = 32;
+/**
+ * Множитель упаковки ПОЛОЖЕНИЯ вершины: сколько единиц Int16 приходится на единицу тайла.
+ *
+ * Было единица — то есть 0.47 м на z14, потому что координаты в MVT целые и вершину писали как
+ * есть. Пока углы дома были прямыми, этого хватало: вершина и так стояла в узле сетки. Со
+ * СКРУГЛЕНИЕМ хватать перестало — дуга радиусом 1.6 м это семь точек в пределах трёх единиц тайла,
+ * и округление сажает их на ту же сетку: вместо дуги выходит лесенка со ступенью в полметра, она же
+ * «угловатость» на ближнем зуме.
+ *
+ * Восемь единиц на тайловую — это 5.9 см, и дуга снова читается дугой. Потолок: тайл 0..4096, при
+ * ×8 это 0..32768, и последнее значение на единицу больше, чем помещается в Int16, — оно
+ * прижимается (`clampI16`). Ошибка при этом 6 см и только у вершины, стоящей ровно на дальней
+ * границе тайла.
+ */
+declare const BUILDING_POS_SCALE = 8;
+interface BuildingsMesh {
+    vertices: ArrayBuffer;
+    indices: ArrayBuffer;
+    /** Uint32Array: id фичи на каждый треугольник — для пикинга и подсветки. */
+    featureIds: ArrayBuffer;
+    vertexCount: number;
+    indexCount: number;
+    extent: number;
+    /** Покраска на фиче, если слой её просил (см. `generators/data-paint.ts`). */
+    dataPaint?: ArrayBuffer;
+}
+interface BuildingsOptions {
+    /**
+     * Радиус скругления углов в МЕТРАХ. Скругляется контур, а значит и стены, и
+     * крыша — она строится по тому же кольцу. Ноль (по умолчанию) — острые углы,
+     * как раньше.
+     */
+    cornerRadius?: number;
+    /** Максимум отрезков на дугу: меньше — дешевле и угловатее. */
+    cornerSegments?: number;
+    /**
+     * Сколько метров в одной единице тайла. Нужен, чтобы решать по РАЗМЕРУ: дом
+     * в сотню квадратов получает скатную крышу, торговый центр — плоскую. Без
+     * него один и тот же порог на разных зумах означал бы разные здания.
+     */
+    metersPerUnit?: number;
+    /** Покраска на фиче: цвет и прозрачность считаются здесь и ложатся в вершины. */
+    paint?: FeaturePaint;
+}
+declare function generateBuildings(layer: VectorTileLayer, extent: number, filter?: Filter, options?: BuildingsOptions, 
+/**
+ * Куда складывать дома, задевающие границу тайла.
+ *
+ * Задан — такие дома здесь НЕ строятся: из куска правильной геометрии не выйдет, их соберут из
+ * всех кусков сразу. Не задан — прежнее поведение, каждый кусок сам по себе.
+ */
+seams?: BuildingSeam[]): BuildingsMesh | null;
+/**
+ * Кусок дома, задевающего границу тайла: контур с пометкой ЛОЖНЫХ рёбер.
+ *
+ * Уезжает на главный поток, чтобы там сложиться с кусками соседних тайлов в целый дом.
+ * Кольца — в координатах СВОЕГО тайла; общую систему строит уже сборщик, он знает номера тайлов.
+ */
+interface BuildingSeam {
+    osmId: number;
+    height: number;
+    minHeight: number;
+    seed: number;
+    tint: number;
+    facade: number;
+    outer: number[];
+    holes: number[][];
+    /** `cut[i]` — ребро от вершины i к i+1 порождено обрезкой, а не стеной дома. */
+    outerCut: boolean[];
+    holeCuts: boolean[][];
+}
+
 /**
  * Сбор подписей из тайла.
  *
@@ -1830,6 +2396,13 @@ interface GeometryMesh {
     extent: number;
     /** id фичи на треугольник: пикинг, подсветка и вырезание заменённых моделью фич. */
     featureIds?: ArrayBuffer;
+    /**
+     * ПОКРАСКА НА ФИЧУ, по восемь байт на вершину (см. `generators/data-paint.ts`).
+     *
+     * Есть только у слоёв, чей цвет, прозрачность или ширина зависят от данных. У всех остальных
+     * поля нет вовсе, атрибут в шейдере остаётся отключённым, и ничего не меняется.
+     */
+    dataPaint?: ArrayBuffer;
     /**
      * Только для поверхностей: сколько индексов в начале — обычная геометрия.
      * Хвост после них — крышки островов, их рисуют отдельно и только в глубину.
@@ -1875,12 +2448,32 @@ interface LoadRequest {
      * обычный виден на `z…z+1`, а тайл потолка растягивается на все зумы выше.
      */
     sourceMaxZoom: number;
+    /**
+     * Адрес тайла.
+     *
+     * Нужен там, где свойство фичи задано В ГЕОГРАФИИ, а не в единицах тайла: профиль подъёма рампы
+     * приходит ломаной в градусах (см. `generators/lift`) и обязан лечь в ту же систему координат,
+     * что и геометрия. Пересчитать градусы в единицы тайла без его адреса нельзя.
+     */
+    tile?: {
+        z: number;
+        x: number;
+        y: number;
+    };
     /** Что строить из этого тайла — план из стиля. */
     plan: LayerPlan[];
 }
 interface LoadedResponse {
     type: 'loaded';
     id: number;
+    /**
+     * СЫРОЙ ТАЙЛ, каким он приехал с сервера.
+     *
+     * Нужен запросам к данным (`queryRenderedFeatures`, `querySourceFeatures`): в геометрии остаются
+     * одни номера фич, а свойства — здесь. Отдаётся ПЕРЕДАЧЕЙ владения, то есть бесплатно: воркеру
+     * буфер после разбора не нужен. Так же держит тайлы MapLibre, и по той же причине.
+     */
+    raw?: ArrayBuffer;
     /**
      * Геометрия по id слоя стиля. Слои без геометрии в тайле просто отсутствуют.
      * У разбитых слоёв (`splitBy`) ключ составной — см. `splitBucketKey`.
@@ -1995,7 +2588,13 @@ declare function evaluateColor(v: Interpolated<string> | undefined, zoom: number
  * (кроме '!=' и '!in', где отсутствие считается несовпадением, — так же
  * ведёт себя MapLibre).
  */
-declare function matchesFilter(filter: Filter | undefined, props: PropBag): boolean;
+declare function matchesFilter(filter: Filter | undefined, props: PropBag, 
+/** Остальное окружение фичи: номер, тип геометрии, состояние. Нужно выражениям. */
+ctx?: {
+    id?: number | string | null;
+    geometryType?: string;
+    featureState?: Record<string, unknown>;
+}): boolean;
 
 /**
  * Тема — набор правок поверх базового стиля, а не его копия.
@@ -2073,8 +2672,30 @@ declare class Style {
     /** Набор слоёв MVT, которые вообще нужны — по нему можно резать разбор. */
     sourceLayers(): string[];
 }
+/**
+ * ПОКРАСКА, ЗАВИСЯЩАЯ ОТ ФИЧИ: что из неё придётся считать в воркере.
+ *
+ * Цвет, прозрачность и ширина уходят в шейдер юниформами — по одному значению на слой. Пока
+ * значение задано числом, остановками или зумовым выражением, этого хватает; `['get', …]` внутри
+ * значит, что у каждой фичи оно своё, и считать его надо там, где фича ещё жива, — при тесселяции
+ * (см. `generators/data-paint.ts`).
+ *
+ * Слои с объёмом и рельефом (`surface`) сюда не входят: их цвет собирается из уровня, света и
+ * материала, и одной подменой базового цвета не обойтись.
+ */
+declare function featureDrivenPaint(layer: StyleLayerSpec): DataPaintSpec | null;
 /** Встроенный стиль: карта должна рисоваться без единого запроса за конфигом. */
 declare const DEFAULT_STYLE: StyleSpec;
+/**
+ * РЕЛЬЕФНЫЙ ВАРИАНТ КАРТЫ: земля идёт по высотам, карта натянута на неё.
+ *
+ * Отдельный стиль, а не переключатель в основном, по двум причинам. Первая: рельеф меняет не
+ * покраску, а САМ СПОСОБ отрисовки земли — плоский проход уезжает в текстуру тайла (см.
+ * `drapeTerrain`), и слои, которые рисуются мимо него, на рельефе оказались бы на нуле. Поэтому
+ * здесь нет объёмных поверхностей: вода, зелень и площадки — обычные заливки, и они драпируются
+ * вместе со всем остальным. Вторая: основная карта остаётся ровно такой, какой была.
+ */
+declare const TERRAIN_STYLE: StyleSpec;
 /**
  * Тот же стиль, но со скруглёнными углами (`scripts/make-soft-style.mjs`).
  *
@@ -2132,6 +2753,8 @@ declare class Tile {
     /** Ресурсы GPU по имени слоя — слой создаёт лениво, источник гарантированно чистит. */
     readonly buckets: Map<string, TileBucket>;
     constructor(id: TileID);
+    /** Сырой тайл, каким он приехал: из него запросы берут свойства фич. */
+    get raw(): ArrayBuffer | undefined;
     get hasGeometry(): boolean;
     destroy(): void;
 }
@@ -2178,6 +2801,42 @@ declare class TileSource extends Evented<TileSourceEvents> {
     private version;
     private opts;
     constructor(pool: WorkerPool, options: TileSourceOptions);
+    /** План слоёв: что резать из тайла. Нужен наследнику, который собирает тайлы сам. */
+    protected get plan(): LayerPlan[];
+    /** Потолок зума источника. */
+    protected get maxzoom(): number;
+    /** Завести тайл в кеше: дальше его либо примут, либо отметят ошибкой. */
+    protected newTile(id: TileID): Tile;
+    /** Принять собранный тайл — как будто он приехал с сервера. */
+    protected acceptTile(tile: Tile, data: LoadedResponse): void;
+    /** Отметить тайл сбойным: собрать не удалось. */
+    protected failTile(tile: Tile, message: string): void;
+    /**
+     * Выбросить собранное: данные источника сменились.
+     *
+     * Видимый набор при этом сохраняется — его пересчитает ближайший `update`, а до тех пор на карте
+     * лучше пусто, чем чужая геометрия от прошлых данных.
+     */
+    protected invalidate(): void;
+    /**
+     * Правка адреса перед загрузкой (`map.setTransformRequest`).
+     *
+     * Ставится на источник, а не на пул: ключ бывает свой у каждого набора, и подписывать чужой
+     * запрос чужим ключом — верный способ получить 403 там, где всё работало.
+     */
+    /**
+     * Подробность набора тайлов: во сколько раз крупнее брать и сколько штук максимум.
+     *
+     * Видимый набор пересчитается на ближайшем `update` — дёргать что-то ещё не нужно.
+     */
+    setLodParams(params: {
+        detailBias?: number;
+        maxTiles?: number;
+    }): void;
+    setTransformRequest(transform: TransformRequest | null): void;
+    private transform;
+    /** Отмена загрузок по своему протоколу: у них своя сигнализация, пул о них не знает. */
+    private protocolAborts;
     /** Тайлы, которые слой должен нарисовать в этом кадре. */
     get visibleTiles(): TileID[];
     /** Версия содержимого: меняется, когда приехал очередной тайл или сменился видимый набор. */
@@ -2259,7 +2918,14 @@ declare class TileSource extends Evented<TileSourceEvents> {
      * загрузки.
      */
     deactivate(): void;
-    private loadTile;
+    /**
+     * Заказать тайл.
+     *
+     * `protected`, потому что источник из данных приложения (`GeoJSONSource`) собирает тайл сам, без
+     * сети и без воркера, — но всё остальное у него общее: тот же кеш, то же покрытие предками, та
+     * же отмена при уходе из вида.
+     */
+    protected loadTile(id: TileID, priority?: number): void;
     /**
      * Готовый предок для тайла, который ещё грузится — чтобы на его месте не зияла
      * дыра. Возвращает null, если готового предка в кеше нет.
@@ -2280,14 +2946,131 @@ declare class TileSource extends Evented<TileSourceEvents> {
 }
 
 /**
- * Загрузка SDF-глифов в формате Mapbox (`{fontstack}/{start}-{end}.pbf`).
- * Тот же формат отдаёт наш tileserver-gl (`/tileserver/fonts/...`), поэтому
- * подписи в движке выглядят ровно так же, как в остальных наших картах.
+ * Атлас SDF: глифы и иконки лежат в ОДНОЙ текстуре.
  *
- * Битмап глифа — знаковое поле расстояний в одном канале. Кодировка
- * стандартная и её ВАЖНО не переизобретать: край буквы там не на 0, а на
- * 192/255, а весь диапазон 0..255 растянут на −6..+2 пикселя. Иконки мы
- * генерируем сами и обязаны попасть в ту же кодировку, иначе один шейдер не
+ * Именно поэтому подпись и её иконка красятся одним цветом и одной обводкой —
+ * шейдер не различает, откуда взят кусок текстуры. Ради этого иконки и
+ * приводятся к глифовой кодировке SDF (см. sdf.ts).
+ *
+ * Упаковка полками: простая, без фрагментации на однородных по высоте данных
+ * (а глифы одного кегля именно такие) и не требует перепаковки.
+ */
+interface AtlasEntry {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare class SdfAtlas {
+    readonly size: number;
+    private data;
+    private entries;
+    private shelfY;
+    private shelfX;
+    private shelfHeight;
+    private texture;
+    private dirty;
+    private full;
+    constructor(size?: number);
+    get(key: string): AtlasEntry | undefined;
+    /** Кладёт одноканальный SDF в атлас. Возвращает null, если места больше нет. */
+    add(key: string, sdf: Uint8Array, width: number, height: number): AtlasEntry | null;
+    /** Привязывает текстуру к юниту, при необходимости заливая изменения. */
+    bind(ctx: Context, unit: number): void;
+    destroy(ctx: Context): void;
+}
+
+/**
+ * КАРТИНКИ ПРИЛОЖЕНИЯ: цветные значки, спрайты, всё, что даёт `map.addImage`.
+ *
+ * Зачем отдельно от `IconSource`. Наши иконки — силуэты: SVG растрируется в маску, из маски
+ * строится SDF, и он ложится в общий с буквами одноканальный атлас. Оттуда и главное свойство —
+ * значок красится тем же цветом, что подпись. Цветную картинку так не показать: у неё свои цвета,
+ * и канал в атласе всего один.
+ *
+ * Поэтому здесь второй атлас — RGBA, со своей текстурой, и своя ветка в шейдере подписей. Обе
+ * дороги живут рядом, как и у MapLibre: `addImage(id, image, {sdf: true})` кладёт картинку в
+ * SDF-путь (её будет красить стиль), без `sdf` — в цветной (рисуется как есть).
+ */
+/** Картинка в том виде, в каком её отдаёт приложение. */
+interface StyleImageData {
+    width: number;
+    height: number;
+    /** RGBA, по четыре байта на пиксель — как у `ImageData`. */
+    data: Uint8Array | Uint8ClampedArray;
+}
+interface StyleImageOptions {
+    /**
+     * Во сколько раз картинка подробнее экранного пикселя. Двойка значит «нарисована для Retina»:
+     * на экране она займёт вдвое меньше места, чем пикселей в файле.
+     */
+    pixelRatio?: number;
+    /**
+     * Картинка — это ПОЛЕ РАССТОЯНИЙ, а не рисунок.
+     *
+     * Тогда она уходит в общий с буквами атлас и красится стилем, как наши иконки. Требование то же,
+     * что у MapLibre: в альфе должно лежать готовое SDF, а не силуэт — силуэт даст рваный край.
+     */
+    sdf?: boolean;
+}
+interface StyleImage extends StyleImageOptions {
+    id: string;
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+/**
+ * Цветной атлас: полочная упаковка, как у SDF-атласа.
+ *
+ * Простая и без перепаковки: картинки приложения добавляются десятками, а не тысячами, и
+ * фрагментация на таком количестве не успевает стать проблемой.
+ */
+declare class ImageManager {
+    readonly size: number;
+    private images;
+    private entries;
+    private data;
+    private texture;
+    private dirty;
+    private shelfX;
+    private shelfY;
+    private shelfHeight;
+    private full;
+    /** Растёт при любой правке набора: по нему раскладка понимает, что пора пересобрать квады. */
+    version: number;
+    constructor(size?: number);
+    has(id: string): boolean;
+    get(id: string): StyleImage | undefined;
+    list(): string[];
+    /**
+     * Добавить картинку. Уже занятое имя НЕ перезаписывается — у MapLibre это ошибка, а молча
+     * подменять чужой значок хуже, чем не добавить свой.
+     */
+    add(id: string, image: StyleImageData, options?: StyleImageOptions): boolean;
+    /** Заменить картинку под тем же именем: размер может смениться, место в атласе берётся заново. */
+    update(id: string, image: StyleImageData, options?: StyleImageOptions): boolean;
+    remove(id: string): boolean;
+    /**
+     * Место картинки в атласе. Кладётся при первом обращении — ровно то, что нужно: добавленная, но
+     * никем не нарисованная картинка не занимает ни пикселя.
+     *
+     * `null` — либо такой картинки нет, либо в атласе не осталось места.
+     */
+    entryFor(id: string): AtlasEntry | null;
+    /** Привязать текстуру атласа к блоку. Данные заливаются только когда менялись. */
+    bind(ctx: Context, unit: number): void;
+    destroy(ctx: Context): void;
+}
+
+/**
+ * Загрузка SDF-глифов в формате Mapbox (`{fontstack}/{start}-{end}.pbf`).
+ * Тот же формат отдаёт наш tileserver-gl (`/tileserver/fonts/...`), поэтому
+ * подписи в движке выглядят ровно так же, как в остальных наших картах.
+ *
+ * Битмап глифа — знаковое поле расстояний в одном канале. Кодировка
+ * стандартная и её ВАЖНО не переизобретать: край буквы там не на 0, а на
+ * 192/255, а весь диапазон 0..255 растянут на −6..+2 пикселя. Иконки мы
+ * генерируем сами и обязаны попасть в ту же кодировку, иначе один шейдер не
  * сможет рисовать текст и иконки одинаково.
  */
 declare const SDF_EDGE = 0.75;
@@ -2317,6 +3100,13 @@ declare class GlyphSource {
     constructor(
     /** Шаблон вида /tileserver/fonts/{fontstack}/{range}.pbf */
     urlTemplate: string, fontstack?: string);
+    /**
+     * Сменить адрес шрифтов (`map.setGlyphs`).
+     *
+     * Загруженные диапазоны выбрасываются: они пришли с прежнего сервера, и держать их рядом с
+     * новыми значит показывать одну подпись двумя гарнитурами.
+     */
+    setUrl(template: string): void;
     get(code: number): Glyph | undefined;
     hasRange(code: number): boolean;
     /** Есть ли в строке символы, диапазоны которых ещё не загружены. */
@@ -2374,6 +3164,15 @@ interface Box {
     y1: number;
     x2: number;
     y2: number;
+    /**
+     * Чьё это место.
+     *
+     * `undefined` — место занято у ВСЕХ: так стоит обычная подпись или значок. Строка — место занято
+     * только у своих, у подписей той же группы. Фоновому слою (название улицы, номер дома) нужно
+     * именно это: значку кафе он уступает и не вытесняет его, а вот друг на друга такие подписи
+     * налезать не должны — из двух названий, легших крест-накрест, не читается ни одно.
+     */
+    group?: string;
 }
 interface Candidate {
     layer: SymbolLayerSpec;
@@ -2442,12 +3241,35 @@ declare class SymbolRenderer {
     onAssetsReady: (() => void) | null;
     private pendingText;
     private pendingIcons;
+    /** Сменить адрес шрифтов: `map.setGlyphs`. Разложенные подписи пересоберутся сами. */
+    setGlyphsUrl(url: string): void;
+    /**
+     * Кого звать, когда стиль просит картинку, которой нет (`map.setMissingStyleImageResolver`).
+     *
+     * Зовётся ОДИН РАЗ НА ИМЯ: раскладка идёт каждый кадр, и без этой памяти обработчик дёргался бы
+     * по шестьдесят раз в секунду на один и тот же отсутствующий значок.
+     */
+    setMissingImage(resolver: ((id: string) => void) | null): void;
+    private missingImage;
+    private askedImages;
+    /** Картинки приложения (`map.addImage`): цветной атлас и своя ветка отрисовки. */
+    readonly images: ImageManager;
     /**
      * Контур выбранного здания в мировых пикселях (треугольники по тайлам).
      * Кладёт рендерер перед сбором; по нему слои `showFor: 'highlight'` решают,
      * относится ли точка к выбранному дому.
      */
     highlightFootprint: Float64Array[] | null;
+    /**
+     * ВЫСОТА ЗЕМЛИ ПОД ТОЧКОЙ, метры — на рельефной карте.
+     *
+     * Подпись и значок — экранные, но привязаны к месту НА ЗЕМЛЕ, а земля на рельефе уже не
+     * плоскость. Без этой высоты название посёлка в горах остаётся на уровне моря и уезжает от
+     * самого посёлка на экране тем дальше, чем выше он лежит и сильнее наклонена камера.
+     *
+     * Ставит рендерер; на обычной карте возвращает ноль, и проекция идёт как раньше.
+     */
+    elevationAt: ((mercX: number, mercY: number) => number) | null;
     constructor(fontUrl: string, fontstack?: string);
     init(ctx: Context): void;
     /**
@@ -2674,6 +3496,105 @@ declare function arrowLabelOffset(layer: SymbolLayerSpec, zoom: number, pixelsPe
  */
 declare function iconRotation(layer: SymbolLayerSpec, rotations: Int16Array | null, i: number, bearing: number): number;
 
+/**
+ * КАРТИНКА, ВИДЕО ИЛИ CANVAS, ПРИБИТЫЕ К МЕСТУ НА КАРТЕ.
+ *
+ * Тайлов тут нет вовсе: источник — одна картинка, растянутая по четырём углам. Так у MapLibre
+ * устроены `image`, `video` и `canvas`, и так на карту кладут план здания, скан старой карты,
+ * радарный снимок или поток с камеры.
+ *
+ * ★ ЧЕТЫРЕ УГЛА, А НЕ ПРЯМОУГОЛЬНИК.
+ *
+ * Углы задаются по отдельности и не обязаны образовывать прямоугольник: скан старой карты почти
+ * всегда завален, и прямоугольная рамка легла бы мимо местности. Поэтому геометрия — квад из
+ * четырёх настоящих точек, а не матрица поверх единичного квадрата.
+ *
+ * ★ ВИДЕО И CANVAS ОБНОВЛЯЮТСЯ КАЖДЫЙ КАДР.
+ *
+ * Текстура заливается заново, пока идёт воспроизведение (или пока приложение объявило canvas
+ * живым). Картинка — один раз: перезаливать неподвижный снимок каждый кадр значит жечь шину без
+ * повода.
+ */
+type MediaKind = 'image' | 'video' | 'canvas';
+/** Углы: левый верхний, правый верхний, правый нижний, левый нижний — порядок MapLibre. */
+type MediaCoordinates = [LngLatLike, LngLatLike, LngLatLike, LngLatLike];
+interface MediaSourceOptions {
+    kind: MediaKind;
+    /** Адрес картинки или видео; для canvas — сам элемент. */
+    url?: string | string[];
+    canvas?: HTMLCanvasElement | string;
+    coordinates: MediaCoordinates;
+    /** Держать ли canvas живым: перезаливать текстуру каждый кадр. */
+    animate?: boolean;
+}
+interface MediaSourceEvents extends Record<string, unknown> {
+    data: {
+        source: MediaSource;
+    };
+    error: {
+        message: string;
+    };
+}
+declare class MediaSource extends Evented<MediaSourceEvents> {
+    private options;
+    readonly kind: MediaKind;
+    /** Готовый к отрисовке источник пикселей. */
+    content: TexImageSource | null;
+    /** Углы в нормализованном меркаторе: `[x, y]` по четырём точкам. */
+    corners: [number, number][];
+    /** Меняется при каждой замене содержимого: по нему слой понимает, что текстуру пора залить. */
+    version: number;
+    private video;
+    private animate;
+    constructor(options: MediaSourceOptions);
+    /** Обновляются ли пиксели сами (видео, живой canvas). */
+    get live(): boolean;
+    /** Переставить углы: `setCoordinates` у MapLibre. */
+    setCoordinates(coordinates: MediaCoordinates): this;
+    getCoordinates(): MediaCoordinates;
+    /** Заменить картинку, не трогая углы (`updateImage` у MapLibre). */
+    updateImage(options: {
+        url?: string;
+        coordinates?: MediaCoordinates;
+    }): Promise<this>;
+    getVideo(): HTMLVideoElement | null;
+    play(): void;
+    pause(): void;
+    /** Для canvas: включить или выключить перезаливку каждый кадр. */
+    setAnimate(on: boolean): void;
+    destroy(): void;
+    private load;
+}
+
+/**
+ * СВОЙ СЛОЙ ПРИЛОЖЕНИЯ: чужой WebGL внутри нашего кадра.
+ *
+ * Договор дословно как у MapLibre (`CustomLayerInterface`): приложение получает контекст и матрицу
+ * и рисует что хочет — свою модель, тепловую карту, эффект. Так на карту кладут то, чего в стиле
+ * нет и не будет.
+ *
+ * ★ МАТРИЦА ТА ЖЕ, ЧТО У MapLibre.
+ *
+ * Локальные координаты — нормализованный меркатор (0..1 на весь мир), ось Z — метры. Слой,
+ * написанный под MapLibre, рисуется у нас без единой правки.
+ *
+ * ★ ПОРЯДОК ЗАДАЁТСЯ ЯКОРЕМ, А НЕ МЕСТОМ В СТИЛЕ.
+ *
+ * Слой несёт функцию, а спецификация стиля у нас копируется — функция такого не переживает.
+ * Поэтому свои слои живут отдельным списком, а куда встать, говорит `beforeId` при добавлении.
+ */
+interface CustomLayer {
+    id: string;
+    type: 'custom';
+    /** `'3d'` — рисуется с тестом глубины вместе с объёмом; `'2d'` — по земле. Подсказка приложения. */
+    renderingMode?: '2d' | '3d';
+    /** Позвали при добавлении: место завести буферы и программы. */
+    onAdd?(map: unknown, gl: WebGL2RenderingContext): void;
+    /** Позвали при снятии: место всё освободить. */
+    onRemove?(map: unknown, gl: WebGL2RenderingContext): void;
+    render(gl: WebGL2RenderingContext, matrix: Mat4 | Float32Array): void;
+}
+
 interface AttribSpec {
     name: string;
     /** Число компонент: 1..4. */
@@ -2810,6 +3731,296 @@ declare class IndoorMask {
     } | null;
 }
 
+/**
+ * ВЫСОТА ИЗ КАРТИНКИ: разбор тайла рельефа.
+ *
+ * Рельеф приезжает обычным PNG, в пикселе которого упакована высота. Так устроено у всех — у
+ * Mapbox, у MapLibre, у Terrarium, — и по одной причине: высоту тогда раздаёт тот же тайлсервер,
+ * что и остальное, а распаковать её умеет и GPU, и процессор.
+ *
+ * Наши тайлы собирает `deploy/terrain/build-terrain.sh` из Copernicus GLO-30 в кодировке `mapbox`
+ * с потолком z10 — там же замер, почему потолок не 11 (рельеф стоил бы 84 % сетевого объёма карты).
+ *
+ * Здесь только ЧИСЛА: ни DOM, ни WebGL, поэтому разбор проверяется в node.
+ */
+/** Кодировка высоты в пикселе. */
+type DemEncoding = 'mapbox' | 'terrarium';
+/**
+ * Множители распаковки: `высота = R·r + G·g + B·b − shift`.
+ *
+ * Этот же вектор уезжает в шейдер юниформом (`u_terrain_unpack` у MapLibre): распаковка на GPU
+ * обязана совпадать с распаковкой на CPU до последнего сантиметра, иначе подпись стоит на одной
+ * высоте, а гора под ней нарисована на другой.
+ */
+declare function unpackVector(encoding: DemEncoding): [number, number, number, number];
+/**
+ * Разобранный тайл рельефа: квадрат высот со стороной `size`.
+ *
+ * Высоты держим `Float32Array`, а не распаковываем каждый раз из пикселей: выборка нужна камере на
+ * каждый кадр и подписям на каждую точку привязки, а распаковка — три умножения и вычитание.
+ */
+declare class DemTile {
+    readonly heights: Float32Array;
+    readonly size: number;
+    readonly min: number;
+    readonly max: number;
+    constructor(pixels: Uint8Array | Uint8ClampedArray, size: number, encoding?: DemEncoding);
+    /**
+     * Высота в точке тайла, координаты 0..1 от его левого верхнего угла.
+     *
+     * СМЕСЬ ПО ЧЕТЫРЁМ СОСЕДЯМ, а не «ближайший пиксель». Пиксель рельефа — это ячейка шириной
+     * 30–60 м, и на ближайшем соседе склон превращается в лестницу со ступенью в этаж: её видно и в
+     * рисунке горы, и в том, как по ней едет дорога.
+     *
+     * Пиксель `i` описывает ЦЕНТР своей ячейки, то есть точку `(i + 0.5) / size` — отсюда сдвиг на
+     * полпикселя. Та же договорённость у MapLibre (`DEM_CELL_CENTER_OFFSET`) и в расчёте теней
+     * рельефа; разойдись мы с ней, высота уезжала бы на полклетки.
+     */
+    heightAt(x: number, y: number): number;
+}
+
+/**
+ * Источник рельефа: тайлы высот.
+ *
+ * Отдельный класс от `RasterSource` по той же причине, по которой тот отделён от векторного:
+ * РАЗНАЯ РАБОТА С РЕЗУЛЬТАТОМ. Подложке картинка нужна как картинка — её отдают текстуре и
+ * забывают. Рельефу она нужна дважды: как текстура для шейдера (там высоту распаковывает GPU) и
+ * как числа для процессора — высоту под камерой, под подписью и под точкой клика спрашивают
+ * каждый кадр, и гонять ради этого чтение с GPU нельзя.
+ *
+ * ПОТОЛОК ЗУМА НИЗКИЙ И ЭТО НОРМАЛЬНО. Наш набор собран до z10 (59 м на пиксель): рельеф — это
+ * форма долины и хребта, а не бордюр, и выше он не несёт ничего, кроме трафика. Замер в
+ * `deploy/terrain/build-terrain.sh`: z11 стоил бы 1 ГБ набора и 84 % сетевого объёма карты. Выше
+ * потолка тайл не перезапрашивается — берётся тот же, что и на потолке, как это делает MapLibre.
+ */
+type DemTileState = 'loading' | 'loaded' | 'error';
+/** Загруженный тайл рельефа: картинка для GPU и разобранные высоты для CPU. */
+declare class DemTileEntry {
+    readonly id: TileID;
+    state: DemTileState;
+    /** Картинка как приехала: её отдают текстуре, распаковку делает шейдер. */
+    image: ImageBitmap | null;
+    /** Разобранные высоты. Появляются по первому запросу с CPU — см. `heights`. */
+    dem: DemTile | null;
+    error: string | null;
+    /** Ресурс GPU, заводит слой рельефа; источник обязан освободить при вытеснении. */
+    texture: {
+        destroy(): void;
+    } | null;
+    constructor(id: TileID);
+    destroy(): void;
+}
+interface DemSourceOptions extends CoverOptions {
+    /** Шаблон вида `/tileserver/data/terrain/{z}/{x}/{y}.webp`. */
+    url: string;
+    /** Кодировка высоты в пикселе. По умолчанию `mapbox` — в ней собран наш набор. */
+    encoding?: DemEncoding;
+    /** Сколько тайлов держать сверх видимых. */
+    cacheSize?: number;
+}
+interface DemSourceEvents extends Record<string, unknown> {
+    data: {
+        tile: DemTileEntry;
+    };
+    error: {
+        tile: TileID;
+        message: string;
+    };
+}
+declare class DemSource extends Evented<DemSourceEvents> {
+    private cache;
+    private visible;
+    private opts;
+    private aborts;
+    constructor(options: DemSourceOptions);
+    get encoding(): DemEncoding;
+    get visibleTiles(): TileID[];
+    getTile(id: TileID): DemTileEntry | undefined;
+    /** Пересчитывает видимый набор под камеру и подгружает недостающее. */
+    update(tr: Transform): void;
+    /**
+     * Высоты тайла, разобранные в числа. Первый вызов декодирует картинку, дальше отдаётся готовое.
+     *
+     * Декодируем ЛЕНИВО: на кадр высота спрашивается в нескольких точках, а тайлов в кеше десятки —
+     * разбирать все при загрузке значит платить за то, чего никто не спросит.
+     */
+    heights(tile: DemTileEntry): DemTile | null;
+    destroy(): void;
+    private loadTile;
+    private fetchImage;
+}
+
+/** Цель отрисовки одного тайла: цветная текстура с буфером глубины. */
+declare class TileTarget {
+    private ctx;
+    readonly size: number;
+    readonly texture: WebGLTexture;
+    readonly framebuffer: WebGLFramebuffer;
+    /** Ключ содержимого: пока совпадает, перерисовывать нечего. */
+    key: string;
+    constructor(ctx: Context, size: number);
+    /** Залить цель сплошным цветом: так выглядит квадрат, которому перерисовка ещё не досталась. */
+    clear(color: readonly number[]): void;
+    destroy(): void;
+}
+declare class Terrain {
+    /** Преувеличение высоты. 1 — как в данных. */
+    exaggeration: number;
+    /**
+     * Счётчик приехавших тайлов высот.
+     *
+     * По нему пересобирается то, что считает высоту НА ПРОЦЕССОРЕ и держит результат в буфере, —
+     * маршрут, зоны. Пока тайл не приехал, высота нулевая, и без этого счётчика маршрут так бы и
+     * остался лежать на нуле: геометрия у него не меняется, пересобирать её нечему.
+     */
+    revision: number;
+    private source;
+    private empty;
+    private unsubscribe;
+    /** Тайлы рельефа этого кадра — те самые, чьи решётки рисуются. */
+    private current;
+    /** Последний подошедший тайл: следующий вопрос почти наверняка про него же. */
+    private lastCover;
+    setSource(source: DemSource | null): void;
+    get enabled(): boolean;
+    /**
+     * Ставит юниформы рельефа для конкретного тайла карты.
+     *
+     * Рельефа нет или тайл высот ещё не приехал — ставим нулевое преувеличение: шейдер пропускает
+     * выборку и рисует по плоской земле. Это НЕ заглушка на чёрный день, а обычный кадр: тайлы
+     * высот грузятся сетью, и первые кадры карта всегда плоская.
+     */
+    apply(ctx: Context, shader: Shader, tile: TileID): void;
+    /**
+     * DEM ДЛЯ ТАЙЛА КАРТЫ — ТОТ ЖЕ, ЧТО У ЗЕМЛИ ПОД НИМ.
+     *
+     * Дом обязан стоять на той земле, которая под ним нарисована. А нарисована она решёткой тайла
+     * РЕЛЬЕФА, и тайл этот крупнее тайла карты (`TILE_DETAIL_BIAS`) — значит и DEM у него бывает
+     * другой, погрубее: вдали тайл рельефа уже z8, когда у карты под ним ещё z10. Возьми дом высоту
+     * из своего, подробного DEM — он встанет на настоящую вершину, а сглаженный холм под ним окажется
+     * ниже, и дом повиснет в воздухе. Это и было видно на дальнем плане.
+     *
+     * Поэтому сначала ищем тайл рельефа, накрывающий тайл карты, берём ЕГО DEM и уже внутри него
+     * вырезаем свой кусок. У MapLibre то же самое делает `getTerrainData`: объект получает текстуру и
+     * матрицу того тайла рельефа, на котором стоит, а не ближайшую подробную.
+     */
+    private demFor;
+    /**
+     * Самая низкая и самая высокая земля в кадре, метры.
+     *
+     * Нужна теням: объём карты теней строится вокруг земли, а она на рельефе не на нуле. Берём по
+     * центрам тайлов рельефа — их десятки, и точность здесь нужна до сотни метров, не до метра.
+     */
+    groundRange(): [number, number];
+    /** Есть ли под тайлом карты земля этого кадра. Пусто — рисовать на нём нечего. */
+    covers(tile: TileID): boolean;
+    /** Тайл рельефа из нарисованного набора, накрывающий тайл карты. */
+    private coverFor;
+    /**
+     * DEM-тайл под тайлом карты и перевод координат в него.
+     *
+     * Поднимаемся по пирамиде от самого тайла вверх: у рельефа свой потолок зума, и на городских
+     * зумах подходящий предок находится с первой же попытки. Дальше корня не идём — там рельефа нет.
+     */
+    private tileFor;
+    /**
+     * Текстура DEM-тайла. `NEAREST` и без мипов: в пикселе лежит ЧИСЛО, разложенное по каналам, и
+     * любое усреднение соседей смешивает разряды — из двух соседних высот получается третья, которой
+     * в природе нет. Сглаживание делает сам шейдер, уже по распакованным высотам.
+     */
+    private textureFor;
+    /** Заглушка 1×1 на кадры без рельефа: сэмплер обязан быть привязан, иначе программа не рисует. */
+    private emptyTexture;
+    /**
+       * ВЫСОТА ЗЕМЛИ В ТОЧКЕ, метры. Нужна тому, что считается на процессоре: камере и подписям.
+       *
+       * Ищем самый подробный ЗАГРУЖЕННЫЙ тайл высот, накрывающий точку, и берём выборку из него.
+       * Пока ни один не приехал — ноль: карта в этот момент и так плоская, а ждать загрузки, чтобы
+       * поставить камеру, значит не показать ничего.
+       */
+    heightAt(lng: number, lat: number): number;
+    /** То же по нормализованному меркатору 0..1 — так координату держат подписи и раскладка. */
+    heightAtMerc(mx: number, my: number): number;
+    /**
+     * Тайл рельефа этого кадра, накрывающий точку меркатора.
+     *
+     * Начинаем с того, что подошёл в прошлый раз. Высоту спрашивают подряд для соседних точек —
+     * вершин маршрута, мест подписей, — и почти всегда это тот же тайл. Без этой памяти каждый
+     * вопрос перебирал бы весь набор, а их на кадр тысячи.
+     */
+    private coverForPoint;
+    private inside;
+    /**
+       * ТАЙЛЫ РЕЛЬЕФА — СВОЙ НАБОР, а не тайлы карты.
+       *
+       * Так сделано у MapLibre (`TerrainTileManager.update`), и вот зачем. Каждому такому тайлу нужна
+       * своя текстура 1024×1024 — четыре мегабайта видеопамяти. Тайлов карты на экране бывает под
+       * сотню (на z14 их 73), и вместе это триста мегабайт, которые GPU молча не даёт: текстуры
+       * перестают создаваться, а карта — рисоваться.
+       *
+       * Поэтому набор берётся КРУПНЕЕ: `detailBias` вдвое — это примерно на зум грубее, то есть вчетверо
+       * меньше тайлов. Разрешение при этом не страдает: в текстуру тайла рельефа рисуются ВСЕ тайлы
+       * карты, которые он накрывает, каждый своей матрицей.
+       */
+    tilesFor(tr: Transform): TileID[];
+    /**
+     * РАЗМЕР ТЕКСТУРЫ НА КАЖДЫЙ ТАЙЛ — ПО ЕГО МЕСТУ НА ЭКРАНЕ.
+     *
+     * Одинаковый размер на все тайлы расточителен с обеих сторон: дальний тайл занимает полсотни
+     * пикселей и держит те же четыре мегабайта, а ближний растянут на весь экран и мылит. Поэтому
+     * размер берётся от экранной стороны тайла, с оглядкой на плотность экрана, и укладывается в
+     * бюджет видеопамяти: тайлы идут от ближнего к дальнему (`tilesFor` их так и сортирует), и
+     * сначала своё получают те, на которые смотрят.
+     */
+    sizesFor(tr: Transform, tiles: TileID[], dpr: number): number[];
+    private mesh;
+    private targets;
+    /**
+     * Решётка тайла: квадрат 0..1, разбитый на клетки, плюс ЮБКА по краю.
+     *
+     * Одна на все тайлы — высоту в вершину подставляет шейдер, и геометрия от тайла не зависит. Так
+     * же сделано у MapLibre: меш кешируется один раз на карту.
+     */
+    meshOf(ctx: Context, locations: Map<string, number>): {
+        vao: VertexArray;
+        count: number;
+    };
+    /**
+     * Цель отрисовки для тайла: та самая 2D-карта, которая ляжет на рельеф.
+     *
+     * `key` решает, надо ли перерисовывать: пока не поменялись ни данные тайла, ни зум (ширина
+     * дорог у нас экранная, и на другом зуме картинка другая), готовая текстура годится. Это и есть
+     * отпечаток MapLibre (`RTTFingerprint`), только короче — у нас один источник на тайл.
+     */
+    /** Готовая цель тайла, если она есть. Не создаёт и не трогает ключ — только смотрит. */
+    targetOf(dataKey: string): TileTarget | undefined;
+    /**
+     * Цель тайла. `fresh` — она только что заведена, и в ней ПУСТО.
+     *
+     * Ключ содержимого здесь НЕ проставляется: рисовать или отложить, решает вызывающий (на кадр
+     * отводится бюджет перерисовок), а пометить готовым то, что не нарисовано, значит оставить в
+     * кадре вчерашнюю картинку навсегда.
+     */
+    targetFor(ctx: Context, dataKey: string, size?: number): {
+        target: TileTarget;
+        fresh: boolean;
+    };
+    /** Убирает цели тайлов, которых больше нет в кадре: каждая — 4 МБ видеопамяти. */
+    keepOnly(visible: Set<string>): void;
+    /** Сторона текстуры драпировки — в неё же ставится вьюпорт на время отрисовки тайла. */
+    get drapeSize(): number;
+    /**
+     * На сколько опускать юбку, метры. Считается ПО ТАЙЛУ, а не по камере.
+     *
+     * Юбка закрывает щель на шве: соседние тайлы берут высоту края из разных пикселей DEM и
+     * расходятся тем сильнее, чем крупнее тайл. Значит и мерка у неё тайловая. По зуму КАМЕРЫ юбка
+     * выходила одинаковой для всех тайлов в кадре: на ближних, мелких, она становилась в пятую часть
+     * их размера и на пологом взгляде торчала из земли стеной с размазанной по ней картой.
+     */
+    skirtMeters(tileZoom: number): number;
+    destroy(ctx: Context): void;
+}
+
 /**
  * Источник растровых тайлов: подложка картинками.
  *
@@ -2866,6 +4077,18 @@ declare class RasterSource extends Evented<RasterSourceEvents> {
     /** Перечитать подложку (сменился набор тайлов на сервере). */
     reload(): void;
     destroy(): void;
+    /** Правка адреса перед загрузкой (`map.setTransformRequest`). */
+    /**
+     * Подробность набора тайлов: во сколько раз крупнее брать и сколько штук максимум.
+     *
+     * Видимый набор пересчитается на ближайшем `update` — дёргать что-то ещё не нужно.
+     */
+    setLodParams(params: {
+        detailBias?: number;
+        maxTiles?: number;
+    }): void;
+    setTransformRequest(transform: TransformRequest | null): void;
+    private transform;
     private loadTile;
     private fetchImage;
 }
@@ -3202,6 +4425,15 @@ declare function distToSegment(p: Projected, a: Projected, b: Projected): number
 declare function pointInRing(p: Projected, ring: Projected[]): boolean;
 
 declare class ObjectManager {
+    /**
+     * Высота земли в точке нормализованного меркатора — её даёт рельеф.
+     *
+     * Маршрут лежит НА ЗЕМЛЕ, а земля на рельефе не плоскость: без высоты трасса уходила под гору и
+     * появлялась только там, где склон случайно ниже нуля.
+     */
+    elevationAt: ((mx: number, my: number) => number) | null;
+    /** Ревизия рельефа: сменилась — высоты вершин пересчитываются. */
+    elevationRevision: number;
     private objects;
     private markers;
     private gpu;
@@ -3250,6 +4482,13 @@ declare class ObjectManager {
         north: number;
     } | null;
     private gpuFor;
+    /**
+     * Высота земли под каждой вершиной части, метры.
+     *
+     * Читается прямо из готовой ленты: положение лежит первым полем вершины, а сама вершина задана в
+     * меркаторе ОТНОСИТЕЛЬНО начала объекта — прибавляем начало и спрашиваем рельеф.
+     */
+    private groundOf;
     destroy(): void;
 }
 
@@ -3487,6 +4726,14 @@ declare class Model {
     userData: Record<string, unknown>;
     coordinates: LngLatLike;
     altitude: number;
+    /**
+     * ПОДЪЁМ РЕЛЬЕФОМ, метры: высота земли под моделью.
+     *
+     * Держится отдельно от `altitude`, а не складывается с ней при создании, по двум причинам: сама
+     * высота модели приходит из данных и не должна теряться, а рельеф догружается сетью и меняется
+     * уже после того, как модель поставлена.
+     */
+    groundZ: number;
     rotation: number;
     rotationTiltX: number;
     rotationTiltZ: number;
@@ -3774,6 +5021,13 @@ declare class ModelLayer {
     private readonly lightPacks;
     private uploadLights;
     private inView;
+    /**
+     * ВЫСОТА ЗЕМЛИ ПОД МОДЕЛЬЮ, метры. Ставит рендерер слоёв, когда включён рельеф.
+     *
+     * Отдельным крючком, а не полем модели: рельеф догружается сетью и меняется уже после того, как
+     * модель поставлена, — значит спрашивать высоту надо каждый кадр, а не при создании.
+     */
+    elevationAt: ((mercX: number, mercY: number) => number) | null;
     advanceTransitions(): void;
     /** Проход глубины: модели отбрасывают тень вместе со зданиями. */
     renderDepth(ctx: Context, tr: Transform, shader: Shader, locations: Map<string, number>): void;
@@ -3834,12 +5088,32 @@ declare class LayerRenderer {
     private raster;
     /** Растровая подложка: текстуры тайлов и их отрисовка квадами. */
     private readonly rasterLayer;
-    private globeBody;
-    private globeClip;
-    private globeMesh;
-    /** Квадрат тайла: две треугольника под проход тени по земле. */
-    private quad;
-    private fillLocs;
+    /**
+     * Картинки, видео и canvas, прибитые к четырём углам.
+     *
+     * Отдельный проход, потому что отдельная геометрия: у тайла единичный квад и матрица, здесь —
+     * четыре настоящих угла (см. `MediaLayer`). Набор источников карта передаёт вместе с растровыми.
+     */
+    private readonly mediaLayer;
+    /** Медиа-источники этого кадра: их держит карта, рендеру они приходят на отрисовку. */
+    mediaSources: Map<string, MediaSource>;
+    /**
+     * СВОИ СЛОИ ПРИЛОЖЕНИЯ (`CustomLayerInterface`).
+     *
+     * Живут не в стиле, а здесь, и вот почему: слой несёт ФУНКЦИЮ отрисовки, а спецификация стиля у
+     * нас копируется (`structuredClone` при накладывании правок, отдача наружу из `getStyle`) —
+     * функция такого не переживает. Поэтому в стиле их нет вовсе, а порядок задаётся якорем `before`.
+     */
+    customLayers: {
+        layer: CustomLayer;
+        before?: string;
+    }[];
+    private globeBody;
+    private globeClip;
+    private globeMesh;
+    /** Квадрат тайла: две треугольника под проход тени по земле. */
+    private quad;
+    private fillLocs;
     private lineLocs;
     /** Линии рантайм-объектов рисуются своей программой — см. OBJECT_LINE_VERT. */
     private objectLine;
@@ -3962,6 +5236,23 @@ declare class LayerRenderer {
      * Поэтому маска геометрическая, ровно как привязка входов.
      */
     readonly indoorMask: IndoorMask;
+    /**
+     * Рельеф: высота под каждой точкой земли. Источник ставит карта по стилю (`syncTerrain`),
+     * а здесь он раздаёт юниформы тем программам, которые рисуют по земле.
+     */
+    readonly terrain: Terrain;
+    /**
+     * Тайл, в текстуру которого сейчас рисуется плоская карта (драпировка рельефа).
+     *
+     * Пока он задан, весь плоский проход смотрит на мир иначе: матрица тайла становится
+     * ортографической на его квадрат, а из видимых тайлов рисуется ровно этот. Так у нас устроен
+     * `isRenderingToTexture` у MapLibre — там он живёт в контексте отрисовки.
+     */
+    private drapeTile;
+    /** Остались квадраты рельефа, которым не хватило бюджета перерисовки: нужен ещё кадр. */
+    private drapePending;
+    private terrainShader;
+    private terrainLocs;
     /**
      * Дома, которые не рисуем объёмом: их место заняла детальная 3D-модель.
      *
@@ -4133,6 +5424,38 @@ declare class LayerRenderer {
      * нужно знать, какому куску мира она принадлежит, — отсюда `u_tile_merc`.
      * На плоской карте всё наоборот: матрица своя у каждого тайла.
      */
+    /**
+     * ПЛОСКИЙ ПРОХОД: земля в порядке стиля, без теста глубины.
+     *
+     * Вынесен в метод, потому что зовётся из двух мест. Обычно — прямо на экран. С рельефом — в
+     * текстуру каждого тайла, откуда её берёт решётка рельефа (`drapeTerrain`): тот же код, другая
+     * матрица и другой кадровый буфер. Так же устроено у MapLibre, где слои перечисляет
+     * `RenderToTexture.renderLayer`, а рисует их обычный `painter.renderLayer`.
+     */
+    private drawFlatLayers;
+    /**
+     * Отрисовать свои слои, привязанные к этому слою стиля.
+     *
+     * Матрица та же, что у рантайм-объектов: локальные координаты — нормализованный меркатор, ось Z —
+     * метры. Ровно это MapLibre и отдаёт в `render(gl, matrix)`, поэтому слой, написанный под него,
+     * рисуется у нас без правок.
+     */
+    private drawCustomBefore;
+    private drawCustomRest;
+    private drawCustom;
+    /**
+     * РЕЛЬЕФ: карта тайла — в текстуру, текстура — на решётку.
+     *
+     * Два шага, оба из MapLibre (RenderToTexture + drawTerrain):
+     *   1. для каждого видимого тайла рисуем его плоскую карту в собственную текстуру —
+     *      ортографически и без камеры, получается «плитка карты» 1024×1024;
+     *   2. рисуем решётку тайла, поднимая её вершины по DEM и натягивая эту плитку.
+     *
+     * Перерисовываем плитку не каждый кадр, а по ключу: пока не менялись ни данные тайла, ни зум
+     * (ширина дорог у нас экранная), готовая картинка годится. Без этого кадр стоил бы столько
+     * отрисовок карты, сколько тайлов на экране.
+     */
+    private drapeTerrain;
     private applyTileMatrix;
     /**
      * Юниформы дымки.
@@ -4216,7 +5539,7 @@ declare class LayerRenderer {
      * Юниформы теней, общие на слой. Матрица тени ставится отдельно, НА ТАЙЛ —
      * она своя у каждого, как и обычная.
      */
-    applyShadowUniforms(shader: Shader): void;
+    applyShadowUniforms(shader: Shader, ground?: boolean): void;
     /** Активны ли тени в этом кадре — по этому флагу ставится матрица на тайл. */
     get shadowsActive(): boolean;
     /**
@@ -4257,6 +5580,13 @@ declare class LayerRenderer {
      * прямо по чётности координат — шесть цветов по кругу, и любые два смежных тайла всегда разные.
      */
     private tileTint;
+    /**
+     * Масштаб тайла, рисунок материала — и ВЫСОТА РЕЛЬЕФА.
+     *
+     * Рельеф ставится здесь же, а не отдельным вызовом у каждого прохода, ровно по той причине, по
+     * которой здесь стоит всё остальное: это свойства ТАЙЛА, и нужны они каждому, кто по этому тайлу
+     * рисует землю. Программе без соответствующих юниформов установка молча проходит мимо.
+     */
     private applyTileScale;
     private applyMaterial;
     private drawFill;
@@ -4530,6 +5860,58 @@ declare class Objects3DManager {
     clear(drop: (m: Model) => void): void;
 }
 
+/**
+ * ЧТО НАРИСОВАНО ПОД ТОЧКОЙ — с теми же именами полей, что у MapLibre.
+ *
+ * Отличие от нашего `queryBuilding` одно, зато принципиальное: тот отвечает «какое здание», а этот
+ * — «какие фичи каких слоёв», включая их свойства из тайла. Свойства берутся из СЫРОГО тайла, а не
+ * из геометрии: в геометрии остаются только номера фич (см. `GeometryMesh.featureIds`), и хранить
+ * рядом с ней ещё и таблицу свойств значило бы держать их в памяти всегда, даже когда никто не
+ * спрашивает. Сырой тайл лежит и так — его же кладёт обратно воркер.
+ */
+interface QueriedFeature {
+    /** Номер фичи из тайла (`osm_id` в нашей схеме). */
+    id: number;
+    /** Имя источника: `base`, `indoor`, … */
+    source: string;
+    /** Слой MVT, откуда фича. */
+    sourceLayer: string;
+    /** Идентификатор слоя СТИЛЯ, которым она нарисована. */
+    layer: string;
+    properties: Record<string, unknown>;
+    /** Состояние фичи, назначенное `setFeatureState`. */
+    state: Record<string, unknown>;
+    /** Тайл, в котором нашлась. */
+    tile: TileID;
+}
+/** Точка или прямоугольник экрана, по которому спрашивают. */
+type QueryGeometry = ScreenPoint$1 | [ScreenPoint$1, ScreenPoint$1];
+interface RenderedQueryOptions {
+    /** Спрашивать только эти слои стиля. Пусто — все. */
+    layers?: string[];
+    /** Радиус вокруг точки, пиксели: без него тонкая линия ловится лишь идеальным попаданием. */
+    tolerance?: number;
+}
+/**
+ * ЧТО ПОПАЛО В ЗАПРОС — по нарисованной геометрии, а не по данным.
+ *
+ * Проверка идёт в координатах ТАЙЛА: прямоугольник экрана переводится в них обратной матрицей, и
+ * дальше сравниваются числа одного порядка. Так же устроен и пикинг зданий (`picking.ts`), и по
+ * той же причине: собирать мировые координаты каждой вершины — это мегабайты работы на клик.
+ */
+declare function queryRendered(tr: Transform, sources: Map<string, TileSource>, layers: StyleLayerSpec[], geometry: QueryGeometry, opts: RenderedQueryOptions, stateOf: (source: string, sourceLayer: string, id: number) => Record<string, unknown>): QueriedFeature[];
+/**
+ * ФИЧИ ИСТОЧНИКА — из сырых тайлов, без оглядки на то, что нарисовано.
+ *
+ * Отвечает на другой вопрос, чем `queryRendered`: не «что видно в этой точке», а «что вообще есть в
+ * загруженных тайлах». У MapLibre ровно та же пара и ровно то же ограничение: за пределами уже
+ * загруженных тайлов ответа нет, и полным он не бывает.
+ */
+declare function querySource(source: TileSource, sourceName: string, params: {
+    sourceLayer?: string;
+    filter?: (props: Record<string, unknown>) => boolean;
+}, stateOf: (source: string, sourceLayer: string, id: number) => Record<string, unknown>): QueriedFeature[];
+
 /**
  * Балун, привязанный к точке карты.
  *
@@ -4601,7 +5983,15 @@ interface BuildingHit {
 declare function pickBuilding(tr: Transform, source: TileSource, layerId: string, point: {
     x: number;
     y: number;
-}): BuildingHit | null;
+}, 
+/**
+ * Высота земли в точке нормализованного меркатора, метры. Есть только на рельефе.
+ *
+ * Меш здания лежит в тайле БЕЗ рельефа: высота в нём отсчитывается от нуля, а рисуется дом от
+ * земли под собой. Значит и луч надо опустить на ту же землю, иначе он проходит под домом —
+ * на городском зуме мимо на восемьсот метров, и клик не попадал ни во что.
+ */
+groundAtMerc?: (mx: number, my: number) => number): BuildingHit | null;
 /**
  * Помещение плана этажа под курсором.
  *
@@ -4613,7 +6003,9 @@ declare function pickBuilding(tr: Transform, source: TileSource, layerId: string
 declare function pickFill(tr: Transform, source: TileSource, layerIds: string[], point: {
     x: number;
     y: number;
-}): BuildingHit | null;
+}, 
+/** Высота земли, метры: план этажа на рельефе лежит на склоне, как и всё остальное. */
+groundAtMerc?: (mx: number, my: number) => number): BuildingHit | null;
 /**
  * Треугольники одной фичи — из них строится подсветка.
  *
@@ -5091,6 +6483,54 @@ interface RoundOptions {
     maxChord?: number;
 }
 declare function roundRing(ring: Ring, opts: RoundOptions): Ring;
+/**
+ * СКРУГЛЕНИЕ УГЛОВ ОТКРЫТОЙ ЛОМАНОЙ — для ОСИ дороги, а не для её контура.
+ *
+ * `roundRing` выше скругляет уже готовый контур. Оси это не годится: у дороги скругляться должен
+ * САМ ПУТЬ, а контур обязан идти за ним параллельно. Скругли мы контур — внешняя и внутренняя
+ * кромки получили бы разный радиус, и полотно на повороте стало бы разной ширины.
+ *
+ * Зачем вообще. В данных ось дороги это ломаная, и в парке или на съезде её изломы доходят до
+ * тридцати градусов между звеньями по три метра. Лента честно повторяет их углами, и дорожка
+ * выглядит собранной из спичек — ровно то, чего в жизни не бывает: любая дорога поворачивает по
+ * дуге, потому что по ней едут и ходят.
+ *
+ * Радиус ограничен половиной каждого соседнего звена, поэтому скругления двух соседних углов
+ * никогда не налезают друг на друга, а на коротком звене радиус сам уменьшается до возможного.
+ * Концы ломаной не трогаются вовсе: они лежат в узлах, и сдвинуть их — значит разорвать сеть.
+ */
+declare function roundLine(line: Ring, radius: number, segments?: number): Ring;
+/**
+ * ПОДРАЗБИЕНИЕ ЛОМАНОЙ ПО ЧАЙКИНУ: гладкая кривая там, где скруглять углы нечем.
+ *
+ * `roundLine` выше вписывает в угол дугу заданного радиуса и ограничивает её половиной соседнего
+ * звена. На улице это ровно то, что нужно: прямые участки остаются точными прямыми, скругляется
+ * только поворот. Но на парковой дорожке прямых нет вовсе — там ломаная из звеньев по три метра,
+ * каждое со своим изломом, и радиус, ужатый под половину звена, срезает полтора метра из угла в
+ * тридцать градусов. Дорожка остаётся угловатой.
+ *
+ * Чайкин работает иначе: он не вписывает дугу, а ЗАМЕНЯЕТ каждую вершину двумя точками на четверти
+ * и трёх четвертях звена. Угол исчезает целиком, за две-три итерации ломаная становится гладкой
+ * (в пределе это квадратичный B-сплайн), и длина звеньев ему безразлична.
+ *
+ * Плата — кривая срезает угол изнутри, до четверти звена. Для дорожки в парке это незаметно и
+ * честнее исходных данных: она и в жизни поворачивает плавно. Для улицы с прямыми участками
+ * лучше `roundLine` — там срезать прямую нельзя.
+ *
+ * Концы остаются на месте: они лежат в узлах сети.
+ */
+declare function refineLine(line: Ring, iterations?: number): Ring;
+/**
+ * УПЛОТНЕНИЕ ЛОМАНОЙ: ни одного звена длиннее `step`.
+ *
+ * Нужно перед подразбиением. Чайкин срезает угол на четверть соседнего звена, и на звене в тридцать
+ * метров это семь метров — дорожка заметно уезжает внутрь поворота, а угол всё равно остаётся
+ * читаемым, только собранным из четырёх граней вместо одной. Разбив звенья на пятиметровые, мы
+ * получаем и срез в пределах метра, и по-настоящему гладкую кривую: сглаживанию есть за что взяться.
+ *
+ * Сама линия при этом не меняется ни на миллиметр — новые вершины ставятся на ней самой.
+ */
+declare function densifyLine(line: Ring, step: number): Ring;
 
 /**
  * Плоские заливки: вода, зелень, землепользование.
@@ -5107,6 +6547,8 @@ interface FillMesh {
     indices: ArrayBuffer;
     vertexCount: number;
     indexCount: number;
+    /** Покраска на фиче, если слой её просил (см. `generators/data-paint.ts`). */
+    dataPaint?: ArrayBuffer;
     /**
      * Id фичи на ТРЕУГОЛЬНИК — тем же способом, что у зданий.
      *
@@ -5118,7 +6560,9 @@ interface FillMesh {
 }
 declare function generateFill(layer: VectorTileLayer, filter: Filter | undefined, maxSegment?: number, round?: RoundOptions, 
 /** Обрезать по квадрату тайла: нужно полупрозрачным слоям. */
-clip?: boolean, extent?: number): FillMesh | null;
+clip?: boolean, extent?: number, 
+/** Покраска на фиче: цвет и прозрачность считаются здесь и ложатся в вершины. */
+paint?: FeaturePaint): FillMesh | null;
 
 /**
  * Альфа-маска (0..255, ширина × высота) → SDF того же размера, но с полем
@@ -5175,39 +6619,108 @@ declare function shapeText(text: string, source: GlyphSource, maxLineChars?: num
 declare function abbreviateStreet(name: string): string;
 
 /**
- * Атлас SDF: глифы и иконки лежат в ОДНОЙ текстуре.
+ * ДОРОЖНЫЕ ЗНАКИ — настоящие, а не пиктограммы.
  *
- * Именно поэтому подпись и её иконка красятся одним цветом и одной обводкой —
- * шейдер не различает, откуда взят кусок текстуры. Ради этого иконки и
- * приводятся к глифовой кодировке SDF (см. sdf.ts).
+ * Остальные наши значки (`text/icons.ts`) одноцветные: они уходят в SDF-атлас, и цвет им задаёт
+ * стиль. Для POI это правильно — кафе на ночной карте должно быть светлым, на дневной тёмным.
  *
- * Упаковка полками: простая, без фрагментации на однородных по высоте данных
- * (а глифы одного кегля именно такие) и не требует перепаковки.
+ * С дорожным знаком так нельзя. Знак узнаётся ФОРМОЙ И ЦВЕТОМ раньше, чем пиктограммой: красный
+ * круг — запрет, синий круг — предписание, треугольник — предупреждение, восьмиугольник — «стоп».
+ * Перекрашенный знак перестаёт быть знаком. Поэтому они лежат отдельно и идут в ЦВЕТНОЙ атлас
+ * (`map.addImage`, см. `text/images.ts`), а не в SDF.
+ *
+ * Пропорции — по ГОСТ Р 52290 (он же в основе Венской конвенции): кайма запрещающего знака это
+ * десятая часть диаметра, красная полоса «движение запрещено» идёт под 45°, у предупреждающего
+ * треугольника углы скруглены. Всё нарисовано в квадрате 64×64, чтобы в атласе знак ложился
+ * целым числом текселей на любом разумном размере.
  */
-interface AtlasEntry {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-declare class SdfAtlas {
-    readonly size: number;
-    private data;
-    private entries;
-    private shelfY;
-    private shelfX;
-    private shelfHeight;
-    private texture;
-    private dirty;
-    private full;
-    constructor(size?: number);
-    get(key: string): AtlasEntry | undefined;
-    /** Кладёт одноканальный SDF в атлас. Возвращает null, если места больше нет. */
-    add(key: string, sdf: Uint8Array, width: number, height: number): AtlasEntry | null;
-    /** Привязывает текстуру к юниту, при необходимости заливая изменения. */
-    bind(ctx: Context, unit: number): void;
-    destroy(ctx: Context): void;
+/** Сторона знака в SVG: все знаки рисуются в одном квадрате. */
+declare const SIGN_SIZE = 64;
+/**
+ * НАБОР ЗНАКОВ.
+ *
+ * Здесь ровно то, что встречается на городской карте и что мы умеем расставить по данным OSM:
+ * запреты и ограничения, приоритет, предписания, переход и переезд. Их немного намеренно — знак,
+ * которого нет в данных, на карте взяться неоткуда, а в бандле он весит.
+ */
+declare const ROAD_SIGNS: Record<string, string>;
+/**
+ * Знак ограничения скорости с любым числом.
+ *
+ * Скорость в данных бывает какая угодно (30, 50, 80), и держать в наборе по знаку на каждую — это
+ * лишний вес в бандле. Рисуем по запросу и отдаём тем же SVG, который уйдёт в цветной атлас.
+ */
+declare function speedSign(limit: number): string;
+
+/**
+ * ДОРОЖНАЯ РАЗМЕТКА — ФИГУРАМИ НА ПОЛОТНЕ.
+ *
+ * Линиями задаётся только то, что и в жизни линия: осевая, краевая, полосы. Всё остальное —
+ * стрелка направления по полосе, зебра, вафельница, стоп-линия — это ПЯТНО НА АСФАЛЬТЕ, и рисовать
+ * его линией нельзя: у линии нет формы, она везде одинаковой ширины.
+ *
+ * Так же устроена разметка в картах, которые это уже сделали: в 2ГИС точечная разметка (стрелки
+ * направления, пешеходные переходы) кладётся отдельным слоем «плоское изображение» с поворотом по
+ * данным, линейная — слоем линий, а площадная (та самая «вафельница» 1.26) — полигоном.
+ *
+ * Здесь считаются КОНТУРЫ в метрах, в местных осях: X — вдоль дороги (вперёд по движению), Y —
+ * поперёк (вправо). Дальше их поворачивают по азимуту полосы и переносят на место — так же, как
+ * это делает любая расстановка значков. Размеры по ГОСТ Р 51256:
+ *
+ *   1.18 стрелка направления — длина 5 м (в городе 3 м), древко 0.3 м, голова до 1.4 м;
+ *   1.14.1 зебра — полосы 0.4 м с промежутком 0.6 м, длина полосы 4 м;
+ *   1.12 стоп-линия — 0.4 м;
+ *   1.26 вафельница — сетка из полос 0.4 м с шагом 2 м, по диагонали.
+ */
+/** Кольцо в местных осях: пары (вдоль, поперёк), в метрах. */
+type MarkingRing = number[];
+/** Что нарисовать стрелкой 1.18. */
+type LaneArrow = 'straight' | 'left' | 'right' | 'straight-left' | 'straight-right' | 'u-turn';
+/** Размеры стрелки 1.18, метры. Умолчания — городские (короткая стрелка). */
+interface ArrowSize {
+    /** Полная длина стрелки вдоль дороги. */
+    length?: number;
+    /** Ширина древка. */
+    shaft?: number;
+    /** Размах головы поперёк. */
+    head?: number;
+    /** Длина головы вдоль. */
+    headLength?: number;
+    /** Вылет бокового пера (для «прямо и направо»). */
+    branch?: number;
 }
+/**
+ * СТРЕЛКА НАПРАВЛЕНИЯ ПО ПОЛОСЕ (1.18).
+ *
+ * Возвращает одно или несколько колец: у составных стрелок («прямо и направо») перо идёт отдельной
+ * фигурой — так их и красят на асфальте, одной краской, но двумя мазками.
+ */
+declare function laneArrow(kind: LaneArrow, size?: ArrowSize): MarkingRing[];
+/**
+ * ЗЕБРА (1.14.1): полосы поперёк дороги.
+ *
+ * `width` — ширина проезжей части, `depth` — длина перехода вдоль движения (по ГОСТ 4 м, на
+ * широкой дороге 6 м). Полосы идут ВДОЛЬ движения, поперёк проезжей части: пешеход идёт между
+ * ними, и именно так зебра выглядит с высоты.
+ */
+declare function zebra(width: number, depth?: number, stripe?: number, gap?: number): MarkingRing[];
+/** Стоп-линия (1.12): сплошная полоса поперёк проезжей части. */
+declare function stopLine(width: number, thickness?: number): MarkingRing[];
+/**
+ * ВАФЕЛЬНИЦА (1.26): сетка из диагональных полос на перекрёстке.
+ *
+ * Квадрат со стороной `size`, полосы шириной `stripe` с шагом `step` в двух направлениях под 45°.
+ * Полосы обрезаются по квадрату — иначе сетка вылезала бы за перекрёсток.
+ */
+declare function waffle(size: number, stripe?: number, step?: number): MarkingRing[];
+/**
+ * ФИГУРУ — НА МЕСТО: поворот по азимуту и перенос в точку.
+ *
+ * `angle` — направление дороги в радианах (0 — на восток, как у `Math.atan2`), `x`/`y` — точка в
+ * тех же единицах, что и результат. Масштаб задаётся снаружи: на карте это метры в единицы
+ * источника, на стенде — метры в градусы.
+ */
+declare function placeMarking(ring: MarkingRing, angle: number, x: number, y: number, scaleX: number, scaleY?: number): number[];
 
 /**
  * Контуры в НОРМАЛИЗОВАННОМ МЕРКАТОРЕ и проверка принадлежности точки.
@@ -5365,6 +6878,30 @@ declare function splitByGround(field: GroundField, pts: number[]): {
     levels: number[];
 };
 
+/** Адрес тайла: профиль приходит в градусах, а геометрия — в единицах тайла. */
+interface TileAddress {
+    z: number;
+    x: number;
+    y: number;
+}
+/** Высота над уровнем слоя в точке тайла, метры. */
+type LiftField = (x: number, y: number) => number;
+/**
+ * Разобрать профиль в поле высот тайла.
+ *
+ * Возвращает `null`, если профиля нет или в нём меньше двух точек: одна точка не задаёт склона, и
+ * обычная отметка `lift` справится с ней лучше и дешевле.
+ */
+declare function parseLift(raw: unknown, tile: TileAddress, extent: number): LiftField | null;
+/**
+ * Разбор профилей с кешем на тайл.
+ *
+ * Профиль один на всю рампу, а фич с ним — и полотно, и каждая линия разметки на нём. Разбирать
+ * одну и ту же строку заново на каждую из них незачем, а вот пересчёт в единицы тайла у каждого
+ * тайла свой, поэтому кеш живёт ровно столько, сколько тайл строится.
+ */
+declare function liftFields(tile: TileAddress | undefined, extent: number): (props: Record<string, unknown>) => LiftField | null;
+
 /**
  * Тесселяция линий (дороги, реки, границы).
  *
@@ -5392,6 +6929,7 @@ declare function splitByGround(field: GroundField, pts: number[]): {
  *   a_ground 2 × Int8     off 10  уровень земли под p0 и под p1, сантиметры
  *   a_dist   1 × Float32  off 12  расстояние от начала линии до p0, единицы тайла
  *   a_width  1 × Float32  off 16  ширина объекта в МЕТРАХ, 0 — не задана
+ *   a_lift   2 × Int16    off 20  подъём полотна под p0 и под p1, сантиметры
 
  * a_width делает полотно объектом местности, а не линией в пикселях: у каждой дороги своя ширина,
  * а внутри слоя она была общей. Ноль означает «в тайле такого атрибута нет» — тогда шейдер берёт
@@ -5405,62 +6943,1028 @@ declare function splitByGround(field: GroundField, pts: number[]): {
  * a_ground — уровень поверхности, ПО КОТОРОЙ идёт дорога (см. `ground.ts`). Два числа, а не одно:
  * вершина знает оба конца отрезка и берёт свой, а между ними шейдер сам растянет подъём. Лёг в те
  * два байта, что и так уходили на выравнивание, — размер вершины не вырос.
+ *
+ * a_lift — ПОДЪЁМ ЭСТАКАДЫ И ЕЁ ПОДХОДА (см. `generators/lift`). Отдельно от `a_ground`, хотя
+ * отвечают они на один вопрос: `a_ground` — байт в сантиметрах, и дальше метра с четвертью не
+ * берёт, а подъём развязки — восемь метров. Расширить байт нельзя: он мерит разницу уровней
+ * поверхностей, где важен как раз сантиметр. Поэтому у подъёма свои два Int16 — те же
+ * сантиметры, но на триста метров вверх, чего хватит любой развязке.
+ *
+ * Без подъёма разметка оставалась лежать на земле под взлетевшей рампой: краска — это линии, а
+ * высоту слой умел задавать только целым уровнем, одним на весь бакет.
  */
-declare const LINE_VERTEX_STRIDE = 20;
+declare const LINE_VERTEX_STRIDE = 24;
 interface LineMesh {
     vertices: ArrayBuffer;
     indices: ArrayBuffer;
     vertexCount: number;
     indexCount: number;
+    /** Покраска на фиче, если слой её просил (см. `generators/data-paint.ts`). */
+    dataPaint?: ArrayBuffer;
+    /**
+     * id фичи НА ТРЕУГОЛЬНИК — тем же форматом, что у заливки и зданий.
+     *
+     * Нужен, чтобы вырезать линию из готового меша: под 3D-моделью прячется не только здание, но и
+     * дорожки вокруг него, а их в наборе замен обычно больше всего.
+     */
+    featureIds: ArrayBuffer;
+}
+interface LineOptions {
+    /** Покраска на фиче: цвет, прозрачность и ширина считаются здесь и ложатся в вершины. */
+    paint?: FeaturePaint;
+    /**
+     * Уровень пересечения (см. `generators/level`): берём только фичи этого уровня.
+     *
+     * `undefined` — уровни не разделяем, слой строится целиком (так живут все слои, кроме дорожной
+     * сети: у реки или границы пересечений без связи не бывает).
+     */
+    level?: number;
+    /**
+     * ПОДЪЁМ ПОЛОТНА ПОД ЛИНИЕЙ — профиль склона по свойствам фичи (см. `generators/lift`).
+     *
+     * Разметка на рампе обязана ехать вместе с асфальтом. Уровень (`level`) тут не помощник: он
+     * целый и один на бакет, а подход к эстакаде набирает высоту непрерывно.
+     */
+    liftAt?: (properties: Record<string, unknown>) => LiftField | null;
+}
+declare function generateLine(layer: VectorTileLayer, filter: Filter | undefined, maxSegment?: number, 
+/** Уровни поверхностей тайла: по ним дорога ложится на то, по чему идёт. Нет — лежит на нуле. */
+ground?: GroundField, 
+/** Метров в единице тайла. Ноль — плавный переход ширины на стыках не строится. */
+metersPerUnit?: number, opts?: LineOptions): LineMesh | null;
+
+/**
+ * УРОВЕНЬ ПЕРЕСЕЧЕНИЯ — какой из двух дорог быть сверху там, где они пересекаются без связи.
+ *
+ * ЗАЧЕМ. Плоская карта рисуется краской: слои идут в порядке стиля, и внутри слоя порядок фич
+ * произволен. Поэтому эстакада над улицей ничем не отличалась от перекрёстка — обводки сливались,
+ * полотна пересекались, и место читалось как съезд, которого в жизни нет. Ровно этим у Яндекса
+ * занят `line-z-level` (`["get","z_level"]` у КАЖДОГО дорожного слоя, все они в одной сети
+ * `line-network: "roads"`): сеть рисуется не по слоям, а по уровням, и мост со своей тенью и
+ * обводкой целиком ложится поверх того, что под ним.
+ *
+ * ОТКУДА ЧИСЛО. Готового `z_level` в наших тайлах нет, зато есть то, из чего его считают:
+ *   `layer`   — тег OSM, честный уровень (−1 подземный, 1 над землёй, изредка 2…5);
+ *   `brunnel` — «мост / тоннель / брод», он приходит и там, где `layer` не проставлен.
+ * Поэтому берём `layer`, а если его нет — выводим уровень из `brunnel`. Мост без `layer`
+ * (в Душанбе таких большинство) получает 1, тоннель — −1, обычная улица — 0.
+ *
+ * Считается в ВОРКЕРЕ, при тесселяции: по уровню бьётся меш, и рендеру остаётся только порядок.
+ */
+/**
+ * Дальше этого уровни не разводим. В OSM попадается и `layer=5`, и опечатки в сотни: каждое
+ * значение — это отдельный бакет и отдельный вызов отрисовки, поэтому хвост подрезаем. Пять этажей
+ * развязки — больше, чем бывает на настоящих.
+ */
+declare const LEVEL_LIMIT = 5;
+/** Уровень фичи: `layer` из тегов, иначе вывод из `brunnel`. */
+declare function featureLevel(props: Record<string, unknown>): number;
+
+/**
+ * СТЫКИ ДОРОГ: общая ширина в узле и плавный переход к ней.
+ *
+ * Лежит отдельным модулем, потому что этим пользуются ДВОЕ: лента дороги в пикселях
+ * (`generators/line`) и её полотно как настоящая геометрия (`generators/ribbon`, через
+ * `generators/surface`). Пока индекс жил внутри линий, полотно считало ширину по-своему —
+ * постоянной на кусок, — и на каждом стыке двух кусков одной улицы выходил уступ: рисунок дороги
+ * уже раскрылся к соседу, а асфальт под ним ещё нет. Общее место снимает расхождение
+ * по построению.
+ */
+/**
+ * Узлы тайла: наибольшая ширина дороги в узле и число сошедшихся в нём КОНЦОВ.
+ *
+ * ЗАЧЕМ. Ширина полотна приходит из данных на КАЖДЫЙ кусок улицы отдельно, а куски у одного узла
+ * бывают разной ширины по делу: съезд с развязки — одна полоса (3.8 м), улица, в которую он
+ * вливается, — две (6.5 м). Без перехода полотно на стыке обрывается ступенькой в два с лишним
+ * метра, и на ближнем зуме это читается как вырезанный уступ.
+ *
+ * Индекс даёт каждому концу линии ширину САМОГО ШИРОКОГО соседа. Дальше узкий кусок раскрывается
+ * к ней на длине `taper`, а широкий остаётся как был: у обоих в самом узле получается одно и то
+ * же число, поэтому стык сходится без ступеньки, кто бы из них ни рисовался первым.
+ *
+ * Строится по ВСЕМУ слою источника, а не по отфильтрованному слою стиля: улица и съезд у нас
+ * попадают в разные слои стиля, и видеть друг друга иначе не могли бы.
+ *
+ * ★ ШИРИНА СЧИТАЕТСЯ БЕЗ ОГЛЯДКИ НА УРОВЕНЬ — и это важно именно для мостов. Мост и его подъезд
+ * это ОДНА улица, разрезанная на два way по тегу `bridge`, и в узле у них общий конец: раскрыться
+ * друг к другу они обязаны, иначе на въезде полотно скачком расширяется и мост читается «таблеткой»
+ * поперёк улицы. А дороги, которые ПЕРЕСЕКАЮТСЯ БЕЗ СВЯЗИ, общего конца не имеют вовсе: эстакада
+ * проходит над улицей серединой своей геометрии, узла там нет, и в индекс такая пара не попадает —
+ * сливать их было нечего и раньше.
+ *
+ * ★ ЧИСЛО КОНЦОВ — С УРОВНЕМ, оно нужно тени моста: по нему видно, где мост КОНЧАЕТСЯ (единственный
+ * конец этого уровня в узле — дальше идёт дорога на земле, и тень надо гасить), а где просто
+ * состыкованы два его куска (два и больше — тень идёт насквозь, длинный мост нарезан на ways).
+ *
+ * Считается один раз на слой тайла: слоёв дорог в стиле полдюжины, и каждый спрашивает тот же
+ * самый индекс.
+ */
+interface Junctions {
+    /** Узел → ширина самой широкой ПРОЕЗЖЕЙ ЧАСТИ, приходящей в него, метры (мосты уже поправлены). */
+    width: Map<number, number>;
+    /** Узел И УРОВЕНЬ → сколько концов линий этого уровня в нём сошлось. */
+    ends: Map<number, number>;
+    /** Узел И УРОВЕНЬ → ширина как записана в данных. По земле (уровень 0) её берёт поправка мостов. */
+    raw: Map<number, number>;
+}
+declare function junctionIndex(layer: VectorTileLayer): Junctions;
+/**
+ * ДЛИНА ПЛАВНОГО ПЕРЕХОДА НА СТЫКЕ, метры.
+ *
+ * Двенадцать метров — примерно длина, на которой съезд у настоящей развязки раскрывается к
+ * проезжей части. Меньше — переход читается изломом, больше — расширение заезжает на весь съезд.
+ */
+declare const TAPER_METERS = 12;
+/** Ширина вдоль оси: собственная ширина куска плюс раскрытие к соседям на концах. */
+interface TaperedWidth {
+    /** Ширина куска, метры, уже с поправкой мостов (см. `carriageway`). */
+    width: number;
+    /** Ширина на расстоянии `d` от начала оси. `null` — раскрываться не к кому. */
+    at: ((d: number) => number) | null;
+    /** Полная длина оси в тех же единицах, что и координаты. */
+    total: number;
+    /** Где рампа ломается: эти расстояния полезно врезать в ось вершинами. */
+    knots: number[];
+}
+/**
+ * ПЛАВНЫЙ ПЕРЕХОД ШИРИНЫ НА СТЫКЕ.
+ *
+ * Узкий кусок раскрывается к ширине самого широкого соседа в узле, широкий остаётся как был. Оба
+ * берут ОДНО И ТО ЖЕ число из индекса, поэтому в самом узле их полотна совпадают.
+ *
+ * Только расширяем, никогда не сужаем: сузить — значит соврать про ширину улицы там, где она
+ * измерена, ради стыка со съездом.
+ *
+ * Раскрываемся к соседу, но НЕ БОЛЬШЕ ЧЕМ ВДВОЕ. Съезд с развязки и улица, в которую он вливается,
+ * отличаются в полтора раза — этот случай переход и придуман сглаживать. А тропинка в 2,8 м,
+ * упирающаяся в проспект в 20 м, при раскрытии «до самого широкого» превращается в клин с тёмным
+ * пятном на конце: связь там есть, но полотна у них разного порядка, и общей ширины у стыка
+ * не бывает.
+ */
+declare function taperedWidth(pts: number[], opts: {
+    junctions: Junctions;
+    /** Ширина куска из данных, метры. */
+    width: number;
+    /** Уровень пересечения куска — по нему поправляются мосты. */
+    level: number;
+    /** Длина перехода в тех же единицах, что и координаты оси. */
+    taper: number;
+}): TaperedWidth;
+/** Кусок улицы как ось: точки, свойства фичи-хозяина и номера всех фич, вошедших в цепочку. */
+interface AxisChain {
+    pts: number[];
+    props: Record<string, unknown>;
+    ids: number[];
+}
+/**
+ * ОСИ, СКЛЕЕННЫЕ В ЦЕПОЧКИ: улица перестаёт быть набором отдельных кусков.
+ *
+ * Зачем. В данных улица нарезана на ways по чему угодно — по смене имени, по мосту, по границе
+ * района. Каждый кусок сам по себе давал свою ленту, а у ленты есть ТОРЦЫ: два полукруглых конца
+ * с бордюром. Посреди сплошного асфальта это читается поперечным швом через всю проезжую часть —
+ * ровно то, чего на настоящей улице нет.
+ *
+ * Склеиваем там, где склейка бесспорна: в узле ровно два конца, и у обоих кусков совпадают ширина
+ * и уровень. Перекрёстки (три конца и больше) не трогаем: там ленты и должны пересекаться, а их
+ * торцы прячутся под соседним полотном.
+ *
+ * Так же поступают процедурные генераторы дорог: сегменты между узлами строятся одной лентой, а
+ * отдельная геометрия появляется только на перекрёстке.
+ */
+declare function chainAxes(layer: VectorTileLayer, keep: (props: Record<string, unknown>) => boolean, widthOf: (props: Record<string, unknown>) => number | null): AxisChain[];
+
+/**
+ * ГРАФ ДОРОЖНОЙ СЕТИ: УЗЛЫ, ЛУЧИ И ЧЕСТНЫЕ СТЫКИ.
+ *
+ * В данных улица не существует — существуют куски. OSM режет линию где угодно: на смене имени, на
+ * въезде на мост, на границе района, просто потому что так редактировали. Поэтому «две линии
+ * сошлись в точке» НЕ ЗНАЧИТ «перекрёсток»: чаще всего это середина прямой улицы.
+ *
+ * Пока это не различается, всё, что делается «в узле», делается не там: разметка рвётся посреди
+ * квартала, торцы лент проступают поперёк асфальта швом, стоп-линии встают там, где останавливаться
+ * не перед чем. Ровно это и видно на любой карте, где дорога нарисована по кускам.
+ *
+ * Граф различает три случая по СТЕПЕНИ узла:
+ *
+ *   1 — тупик: конец улицы, дальше ничего;
+ *   2 — СТЫК: два конца, улица продолжается. Ничего «узлового» здесь быть не должно — куски
+ *       склеиваются в одну ось (`chains`), и разметка идёт насквозь;
+ *   3 и больше — ПЕРЕКРЁСТОК: вот здесь полотна пересекаются, разметка обрывается, а перед
+ *       обрывом встают стоп-линия и переход.
+ *
+ * ВЫЛЕТ ЧУЖОГО ПОЛОТНА (`clearance`) считается по углу, а не «на глазок». Дорога шириной w,
+ * пересекающая нашу под углом α, накрывает наш путь на (w/2)/sin α: под прямым углом это половина
+ * её ширины, под косым — заметно больше. Без синуса разметка на косом перекрёстке вылезает на
+ * чужое полотно — та самая мелочь, по которой рисованная улица отличается от настоящей.
+ *
+ * Модуль СЧИТАЕТ В МЕТРАХ и ничего не знает ни о тайлах, ни о проекции: на входе оси в метрах, на
+ * выходе — узлы и расстояния в метрах. Тайловый слой и geojson приводятся к этому снаружи.
+ */
+/** Ось дороги: точки в метрах (x0,y0,x1,y1…) и то, что о ней известно из данных. */
+interface RoadAxis {
+    pts: number[];
+    /** Ширина проезжей части, метры. */
+    width: number;
+    /** Уровень пересечения: эстакада и улица под ней в одной точке — не узел. */
+    level?: number;
+    /** Одностороннее движение: встречного потока нет, значит нет и осевой. */
+    oneway?: boolean;
+    /** Число полос, если известно. */
+    lanes?: number;
+    /** Класс дороги из данных. */
+    cls?: string;
+    /** Номер исходной фичи — чтобы вернуть результат к ней. */
+    id?: number;
+}
+/** Конец оси, приходящий в узел. */
+interface RoadRay {
+    /** Номер оси в списке, поданном на вход. */
+    axis: number;
+    /** Этот конец — хвост оси (иначе голова). */
+    atTail: boolean;
+    /** Направление ОТ узла вдоль оси, радианы. */
+    angle: number;
+    /** Ширина этой оси, метры. */
+    width: number;
+    level: number;
+    /** Класс дороги — по нему пятно перекрёстка берёт себе цвет самого крупного подхода. */
+    cls: string;
+    /**
+     * Одностороннее движение по этой оси.
+     *
+     * Вместе с `atTail` даёт то, чего иначе не узнать: можно ли ПО НЕЙ УЕХАТЬ из узла. Ось
+     * односторонняя и кончается здесь — значит движение по ней идёт к нам, и такого манёвра нет.
+     */
+    oneway: boolean;
+}
+interface RoadNode {
+    x: number;
+    y: number;
+    /** Все концы, сошедшиеся здесь, по возрастанию угла. */
+    rays: RoadRay[];
+    /** Сколько концов сошлось. 1 — тупик, 2 — стык, 3 и больше — перекрёсток. */
+    degree: number;
+    /** Это настоящий перекрёсток, а не стык двух кусков одной улицы. */
+    crossing: boolean;
+}
+/** Ось, склеенная из кусков: у улицы должен быть один асфальт, а не набор плиток. */
+interface RoadChain {
+    pts: number[];
+    /** Оси, вошедшие в цепочку, в порядке склейки. */
+    axes: number[];
+    /** Свойства взяты у первого куска: у склеенных они совпадают по построению. */
+    width: number;
+    level: number;
+    oneway: boolean;
+    lanes: number;
+    cls: string;
+    /** Узлы на концах цепочки. */
+    head: number;
+    tail: number;
+}
+interface RoadGraph {
+    nodes: RoadNode[];
+    /** Ось → номера узлов на её концах. */
+    ends: [number, number][];
+    /** Улицы, склеенные из кусков через стыки. */
+    chains: RoadChain[];
+    /**
+     * Насколько далеко от центра узла тянется ЧУЖОЕ полотно вдоль этого луча, метры.
+     *
+     * Ноль у тупика и у стыка: там пересекаться не с чем. У перекрёстка — по самому «длинному»
+     * из остальных лучей с поправкой на угол.
+     */
+    clearance(node: number, ray: RoadRay): number;
+    /**
+     * То же, но для направления, а не для луча из списка.
+     *
+     * Цепочка склеена из нескольких осей, и «своего» луча у неё нет: в узле лежит конец крайней
+     * оси, а спрашивает вся улица. Направление и уровень она знает про себя сама.
+     */
+    clearanceAt(node: number, angle: number, level: number, exceptAxes: number[]): number;
+    /**
+     * Ширина САМОЙ ШИРОКОЙ проезжей части, приходящей в узел на этом уровне, метры.
+     *
+     * По ней полотна сходятся без уступа: узкий подход раскрывается к общему числу, широкий
+     * остаётся как есть, и в самом узле у них совпадают кромки — кто бы из них ни рисовался первым.
+     */
+    nodeWidth(node: number, level: number): number;
+}
+interface RoadGraphOptions {
+    /**
+     * РАДИУС СКРУГЛЕНИЯ ПОВОРОТОВ ОСИ, в ширинах дороги. 0 — не скруглять.
+     *
+     * В данных ось это ломаная, и её изломы лента повторяет углами: дорожка в парке выглядит
+     * собранной из спичек, хотя в жизни любая дорога поворачивает по дуге — по ней едут и ходят.
+     * Радиус привязан к ширине, потому что широкая улица и поворачивает шире: у проспекта в 20 м
+     * поворот заметно положе, чем у дворового проезда.
+     *
+     * Скругление живёт ЗДЕСЬ, а не в построении полотна, чтобы полотно и разметка шли по ОДНОЙ
+     * кривой. Посчитай их по разным осям — и краска на повороте сойдёт с асфальта.
+     */
+    smooth?: number;
+    /** Потолок радиуса скругления, метры: у самых широких дорог он иначе уезжает в десятки метров. */
+    maxSmooth?: number;
+    /**
+     * ИТЕРАЦИИ ПОДРАЗБИЕНИЯ по Чайкину — для дорожек, у которых прямых участков нет вовсе.
+     *
+     * Скругление углов ограничено половиной звена, и на ломаной из трёхметровых звеньев его почти не
+     * видно. Подразбиению длина звена безразлична: оно снимает угол целиком. Улицам это не нужно —
+     * там прямая должна остаться прямой, — поэтому по умолчанию выключено.
+     */
+    refine?: number;
+    /**
+     * Максимальная длина звена перед подразбиением, метры. Работает только вместе с `refine`.
+     *
+     * Без него сглаживание на длинных звеньях и срезает много, и сглаживает мало — см. `densifyLine`.
+     */
+    densify?: number;
+}
+declare function buildRoadGraph(axes: RoadAxis[], options?: RoadGraphOptions): RoadGraph;
+
+/**
+ * РАЗМЕТКА ПО ГРАФУ ДОРОГ.
+ *
+ * Здесь считается вся краска на асфальте: осевая между встречными потоками, краевые у кромки
+ * полотна, разделители между рядами, стоп-линии и переходы. Каждая линия получает СВОЁ место от
+ * той дороги, которой принадлежит: её ширины, её числа полос, её направления.
+ *
+ * Работает по ЦЕПОЧКАМ (`RoadChain`), а не по кускам из данных. Это главное: улица в OSM нарезана
+ * на ways по чему угодно, и разметка, построенная по кускам, рвётся посреди прямой на каждом шве.
+ * Цепочка склеена через стыки, поэтому продольная краска идёт по улице насквозь и обрывается ровно
+ * там, где ей и положено, — у перекрёстка.
+ *
+ * Отступ от перекрёстка берётся из графа (`clearanceAt`): он считает, насколько далеко чужое
+ * полотно лезет на наш путь ПО УГЛУ пересечения. Под прямым углом это половина чужой ширины, под
+ * косым — заметно больше, и именно поэтому на косых перекрёстках разметка обычно и вылезает
+ * на соседнее полотно.
+ *
+ * Размеры по умолчанию — из ГОСТ Р 51256 и китайского GB 5768; они близки, а там, где расходятся,
+ * задаются снаружи. Цвет здесь не решается вовсе: модуль отдаёт ГДЕ красить, а чем — дело стиля.
+ * Это важно для Китая, где осевую красят жёлтым, а разделители полос белым.
+ */
+
+/** Что за линия разметки. Стиль красит их по-разному, поэтому вид едет вместе с геометрией. */
+type MarkingKind = 
+/** Осевая между встречными потоками (в Китае жёлтая, у нас белая). */
+'centre'
+/** Краевая у кромки проезжей части. */
+ | 'edge'
+/** Разделитель полос одного направления — пунктир. */
+ | 'lane'
+/** Стоп-линия поперёк своей половины проезжей части. */
+ | 'stop'
+/** Полоса пешеходного перехода. */
+ | 'zebra';
+interface Marking {
+    kind: MarkingKind;
+    /** Точки в метрах, в тех же осях, что и граф. */
+    pts: number[];
+    /** Класс дороги — стилю удобно фильтровать по нему. */
+    cls: string;
+    level: number;
+    /**
+     * НОМЕР ЦЕПОЧКИ в `graph.chains`, по которой нанесена эта краска.
+     *
+     * По нему линию можно свести с полотном той же цепочки — например, чтобы проверить, что она
+     * легла на асфальт, а не рядом с ним.
+     */
+    chain: number;
+}
+interface MarkingOptions {
+    /** Отступ краевой линии от кромки асфальта, метры. */
+    edgeInset?: number;
+    /** Половина зазора между линиями двойной осевой, метры. */
+    centreGap?: number;
+    /** Разметка не наносится на дороги уже этой ширины, метры. */
+    minWidth?: number;
+    /** Классы дорог, которые вообще не размечаются (проезды, дворы). */
+    skipClasses?: string[];
+    /** Классы, на подходах которых к перекрёстку ставятся стоп-линия и переход. */
+    crossingClasses?: string[];
+    /** Насколько краска не доходит до края перекрёстка, метры. */
+    setback?: number;
+    /** Куски короче этого не размечаются вовсе, метры. */
+    minPiece?: number;
+    /** Длина полосы перехода вдоль движения, метры. */
+    zebraDepth?: number;
+    /** Шаг полос перехода поперёк, метры. */
+    zebraStep?: number;
+    /**
+     * СТАВИТЬ ЛИ ПЕРЕХОДЫ САМИМ.
+     *
+     * По умолчанию да: без данных о переходах это единственный способ их показать. Но догадка здесь
+     * грубая — переход предполагается на каждом подходе к перекрёстку, а в жизни на раздельных
+     * проезжих частях подходов вдвое больше, чем переходов, и на съездах их нет вовсе. Когда
+     * переходы есть в данных (в OSM они размечены поштучно), надёжнее выключить это и взять их
+     * оттуда; стоп-линии при этом остаются — они привязаны к подходу, а не к пешеходу.
+     */
+    zebra?: boolean;
+    /**
+     * ОСЬ, ПО КОТОРОЙ УЖЕ ПОСТРОЕНО ПОЛОТНО, — по номеру цепочки.
+     *
+     * Краска отмеряется от оси теми же полуширинами, что и кромка асфальта, и обязана лечь на него
+     * один в один. Но ось, которую берёт полотно, — не та, что лежит в графе: сперва она
+     * разглаживается до кривизны, при которой эквидистанта вообще существует, иначе кромка на
+     * крутом повороте выворачивается наизнанку. Разметка же отмеряла от сырой — и на таком повороте
+     * краевая линия уходила туда, где кромка давно разгладилась, то есть мимо асфальта.
+     *
+     * Считать разглаживание заново нельзя: полотно ведёт его по своей полуширине, с прибавкой на
+     * обочину, и две «одинаковые» дуги расходятся на метры. Поэтому сюда кладут ГОТОВУЮ осевую из
+     * тройки полотна (`RoadSurface.edges.centre` по `RoadSurface.chain`). Чего в списке нет, то
+     * считается по-старому, от графа.
+     */
+    axes?: (number[] | undefined)[];
+    /**
+     * ВО СКОЛЬКО РАЗ КРАСКА МОЖЕТ РАЗДАТЬСЯ К УЗЛУ вслед за полотном.
+     *
+     * Улица шириной в 6.8 м, продолжающаяся куском в 10.2, — обычное дело в данных. Полотно на
+     * таком шве раздаётся до ширины узла, чтобы кромки соседей сошлись; краска, отмеренная от
+     * постоянной полуширины, — нет, и краевая линия обрывалась у шва уступом в метр семьдесят.
+     *
+     * Значения должны совпадать с теми, по которым строится полотно (`RoadSurfaceOptions`), иначе
+     * линия снова разойдётся с кромкой.
+     */
+    maxGrow?: number;
+    /** Наименьшая длина отгона ширины, метры. Совпадает с `taper` у полотна. */
+    taper?: number;
+    /**
+     * ГДЕ КРАСКИ БЫТЬ НЕ ДОЛЖНО — например, на проезжей части кольцевой развязки.
+     *
+     * Подход к кольцу в данных не пересекает его ось и не делит с ним узла: он просто упирается в
+     * круг и кончается где-то на его полотне. Граф такого пересечения не видит, отступать ему не от
+     * чего, и разметка подхода идёт по кольцу насквозь — поперёк чужой проезжей части.
+     *
+     * Что именно занято, знает вызывающий: у кольца своя геометрия, и описать её общим правилом
+     * нельзя. Краска обрезается по границе этой зоны — так же, как обрывается у перекрёстка.
+     *
+     * Третьим доводом идёт сама улица: без неё кольцо запретило бы краску самому себе — его
+     * разметка целиком лежит внутри его же полотна, и вырезалась бы вся.
+     */
+    keepOut?: (x: number, y: number, chain: RoadChain) => boolean;
+    /**
+     * ГДЕ НА ПОДХОДЕ СТОИТ ПЕШЕХОДНЫЙ ПЕРЕХОД — расстояние ОТ УЗЛА вдоль оси, в метрах.
+     *
+     * Сам движок ставит его по отступу узла: перекрёсток кончился — через метр с небольшим переход.
+     * Для одной проезжей части это верно, а для улицы из нескольких — нет: узлы у них на
+     * перекрёстке стоят вразнобой, и переходы выходят лесенкой. Кто знает про соседей — тот и
+     * скажет, где ряд; вернул `null` — считаем сами, как раньше.
+     *
+     * Стоп-линия отмеряется ОТ ПЕРЕХОДА, поэтому едет вместе с ним и остаётся к нему прижатой.
+     */
+    crossingAt?: (chain: RoadChain, index: number, node: number) => number | null;
+}
+declare function roadMarkings(graph: RoadGraph, options?: MarkingOptions): Marking[];
+
+/**
+ * СТРЕЛКИ НАПРАВЛЕНИЯ ПО ПОЛОСАМ — ИЗ ТОПОЛОГИИ ПЕРЕКРЁСТКА.
+ *
+ * На подходе к перекрёстку на асфальте нарисовано, куда с какой полосы можно ехать. В картах
+ * Яндекса и Baidu это одна из самых заметных деталей: по стрелкам перекрёсток читается раньше, чем
+ * по знакам.
+ *
+ * Откуда брать манёвры. В OSM для этого есть тег `turn:lanes` — но есть он далеко не везде: в
+ * выкачке по Луцзяцзуй, например, его нет НИ У ОДНОЙ дороги. Поэтому манёвры выводятся из графа:
+ * из узла видно, какие дороги из него выходят, под какими углами, и по каким из них вообще можно
+ * уехать. Это та же логика, по которой навигатор строит манёвр, только результат рисуется краской.
+ *
+ * Куда нельзя: по односторонней дороге, которая в этот узел ВХОДИТ (её конец здесь — значит
+ * движение по ней идёт к нам), и назад, откуда приехали. Всё остальное раскладывается по полосам:
+ * левые манёвры к левому краю, правые к правому, «прямо» в середину.
+ *
+ * Стрелки ставятся только там, где известно число полос: рисовать три стрелки на дороге, у которой
+ * полос может быть и две, и четыре, — значит выдумывать разметку.
+ */
+
+interface LaneGuide {
+    /** Что нарисовано: стрелка того или иного манёвра. */
+    kind: LaneArrow;
+    /** Контур стрелки в метрах, замкнутый; составная стрелка отдаёт несколько таких. */
+    pts: number[];
+    cls: string;
+    level: number;
+    /**
+     * ЦЕПОЧКА, НА КОТОРОЙ СТОИТ СТРЕЛКА, и расстояние вдоль неё до её середины.
+     *
+     * Нужны высоте. На развязке стрелка лежит на рампе, а прямо под рампой проходит улица — и по
+     * плану одна ближе другой лишь на метры: взять отметку «у ближайшей оси» значит уронить стрелку
+     * с эстакады на землю. Из цепочки же высота читается однозначно.
+     */
+    chain: number;
+    at: number;
+}
+interface LaneGuideOptions {
+    /** Классы дорог, на которых рисуются стрелки. */
+    classes?: string[];
+    /** На каком расстоянии от края перекрёстка ставить стрелку, метры. */
+    setback?: number;
+    /** Длина стрелки вдоль дороги, метры. */
+    length?: number;
+    /** Подход короче этого стрелок не получает: ставить их вплотную к предыдущему узлу незачем. */
+    minApproach?: number;
+    /** Угол, в пределах которого манёвр считается «прямо», радианы. */
+    straightAngle?: number;
+    /** Больше этого угол считается разворотом и в расчёт не идёт, радианы. */
+    maxAngle?: number;
+    /**
+     * ГДЕ СТРЕЛКУ СТАВИТЬ НЕЛЬЗЯ — например, на пешеходном переходе.
+     *
+     * Стрелку рисуют на свободном асфальте перед стоп-линией, а не поверх зебры: две разметки на
+     * одном месте не наносят никогда. Где именно лежат переходы, модуль знать не может — они
+     * приходят из данных и стоят не там, где их поставила бы догадка, — поэтому проверку задаёт
+     * вызывающий. При попадании стрелка отодвигается дальше от перекрёстка, а если места нет и
+     * там — не рисуется вовсе.
+     */
+    blocked?: (x: number, y: number) => boolean;
+    /** На сколько отодвигать стрелку, если место занято, метры. */
+    retreat?: number;
+}
+declare function laneGuides(graph: RoadGraph, options?: LaneGuideOptions): LaneGuide[];
+
+/**
+ * ТРОЙКА «КРОМКА — ОСЬ — КРОМКА»: полотно, у которого ширина одинакова ВЕЗДЕ.
+ *
+ * До сих пор полотно строилось одной операцией: вокруг оси обводился контур, а всё, что при этом
+ * заворачивалось внутрь (на повороте круче полуширины кромка неизбежно образует петлю), потом
+ * распутывалось обрезкой. Так делают все библиотеки смещения, и на хорошей геометрии это работает.
+ * Беда в том, что дорожная ось в данных хорошей не бывает: изломы по тридцать градусов между
+ * трёхметровыми звеньями — норма. Петли идут одна за другой, обрезка сшивает не те края, и по
+ * кромке ползут зубцы и вырезы.
+ *
+ * Здесь задача решается с другого конца. Полотно описывается ТРЕМЯ согласованными линиями — левой
+ * кромкой, осью и правой кромкой, — и главное свойство задаётся ДО построения: ось разглаживается
+ * так, чтобы её радиус кривизны нигде не был меньше полуширины. На такой оси эквидистанта
+ * существует и не самопересекается — это геометрический факт, а не эвристика, — и обе кромки
+ * получаются простым смещением по нормали, всегда параллельные, всегда на одном расстоянии.
+ *
+ * Распутывать после этого нечего, потому что путаться уже нечему.
+ *
+ * Кромки нужны не только полотну: по ним идёт краевая разметка, и взятая из той же тройки, она
+ * ложится ровно вдоль края асфальта, а не «примерно там же».
+ */
+
+/** Полотно как три линии: обе кромки и ось между ними. Точки в метрах, по вершинам согласованы. */
+interface RoadEdges {
+    /** Левая кромка по ходу оси. */
+    left: number[];
+    /** Разглаженная ось — та, от которой отмерены обе кромки. */
+    centre: number[];
+    /** Правая кромка по ходу оси. */
+    right: number[];
+}
+/**
+ * ОСЬ, РАЗГЛАЖЕННАЯ ДО ЗАДАННОГО РАДИУСА КРИВИЗНЫ.
+ *
+ * В каждой вершине радиус считается по описанной окружности трёх соседних точек. Где он меньше
+ * нужного, вершина подтягивается к середине между соседями — тем сильнее, чем грубее нарушение.
+ * Несколько проходов, и кривизна везде укладывается в норму.
+ *
+ * Это не косметика: при радиусе меньше полуширины эквидистанта внутренней стороны ФИЗИЧЕСКИ
+ * выворачивается наизнанку. Никакой обводкой этого не исправить — можно только не подавать такую
+ * ось. Настоящая дорога с таким поворотом тоже не построена: радиус поворота проезжей части всегда
+ * больше её ширины, иначе по ней не проехать.
+ *
+ * Концы остаются на месте — они лежат в узлах сети. Смещение каждой вершины ограничено полушириной:
+ * разгладить дорогу можно, а переложить её в другое место нельзя.
+ */
+declare function relaxCurvature(line: number[], minRadius: number, iterations?: number): number[];
+/**
+ * ОСЬ, У КОТОРОЙ НЕТ ИЗЛОМОВ КРУЧЕ ЗАДАННОГО УГЛА.
+ *
+ * Радиуса кривизны для ровной ширины мало, и это не сразу очевидно: радиус считается по трём
+ * точкам и на ДЛИННЫХ звеньях выходит большим даже при изломе в сто двадцать градусов. А кромка
+ * ставится по биссектрисе с выносом на косинус половины излома — и при таком угле вынос почти
+ * вдвое больше полуширины. На настоящих данных именно это и давало разброс ширины в полтора раза
+ * там, где радиус формально был в норме.
+ *
+ * Поэтому угол ограничивается отдельно: вершина подтягивается к середине между соседями, пока
+ * излом не уложится в норму. При тридцати градусах вынос отличается от полуширины на три процента.
+ */
+declare function relaxAngle(line: number[], maxTurn: number, iterations?: number, limit?: number): number[];
+/**
+ * ТРОЙКА ЛИНИЙ ПО ОСИ.
+ *
+ * Ось сначала разглаживается до радиуса `half * safety`, потом обе кромки отмеряются от неё по
+ * нормали. Нормаль в вершине — усреднённая по соседним звеньям, со срезом на косинус половины
+ * излома: без него на повороте кромка подрезалась бы внутрь и полотно теряло ширину ровно там, где
+ * его удобнее всего разглядывать.
+ */
+declare function roadEdges(axis: number[], half: number, opts?: {
+    safety?: number;
+    iterations?: number;
+    maxTurn?: number;
+    /**
+     * ПОЛУШИРИНА ВДОЛЬ ОСИ: `d` — расстояние от начала, метры.
+     *
+     * Нужна раскрытию к узлу: у одной улицы куски приходят разной ширины, и к общей ширине узла
+     * полотно должно раскрываться плавно. Расстояние считается по УЖЕ разглаженной оси — на ней и
+     * строятся кромки, так что раскрытие попадает ровно туда, куда задумано.
+     */
+    halfAt?: (d: number) => number;
+}): RoadEdges | null;
+/**
+ * ТРОЙКА ДЛЯ ЗАМКНУТОЙ ОСИ — кольцевой развязки, круга во дворе.
+ *
+ * У кольца нет ни начала, ни конца, и в этом вся разница. Обычная тройка считает нормаль в
+ * вершине по её соседям, а у первой и последней вершины соседа с одной стороны нет — направление
+ * берётся по единственному звену. На разомкнутой улице это правильно (там торец), а на кольце
+ * первая вершина — такая же рядовая, как все, просто с неё начали обход. Из-за этого в месте
+ * замыкания кромка получала излом, и круг изнутри выглядел многоугольником.
+ *
+ * Здесь соседи берутся ПО КРУГУ: у первой вершины предыдущая — последняя. Разглаживание при этом
+ * не нужно: замкнутую ось граф сглаживает сам, тоже по кругу (см. `unwrap` в `road-graph`).
+ */
+declare function ringEdges(axis: number[], half: number): RoadEdges | null;
+/**
+ * КОНТУР ПОЛОТНА ИЗ ТРОЙКИ: правая кромка вперёд, торец, левая назад, торец.
+ *
+ * Торцы — полукружия радиуса `half` вокруг концов оси: так кончается настоящая дорога, и так же
+ * её кончают все, кто рисует дороги лентой.
+ */
+declare function ribbonFromEdges(edges: RoadEdges, half: number, arcSegments?: number, flatHead?: boolean, flatTail?: boolean): Ring;
+
+/**
+ * ПОЛОТНО ДОРОГ ПО ГРАФУ: ПЕРЕГОНЫ И ПЯТНА ПЕРЕКРЁСТКОВ.
+ *
+ * Полотно, построенное «по куску за раз», не сходится никогда. Куски приходят из данных с разной
+ * шириной (у одной улицы это сплошь и рядом 10 м и 10.2 м на соседних ways), и на каждом шве
+ * асфальт даёт уступ в десяток сантиметров — ровно ту рваную кромку, по которой видно, что дорога
+ * нарисована, а не построена. А на перекрёстке между лентами остаются вогнутые выемки: четыре
+ * прямоугольника, наложенные крест-накрест, оставляют по углам пустые клинья.
+ *
+ * Настоящие карты (и процедурные генераторы дорог) строят дорожную сеть иначе, в два вида кусков:
+ *
+ *   ПЕРЕГОН — лента между двумя узлами. Одна на всю улицу, а не по ленте на way: цепочки уже
+ *     склеены графом, поэтому торцов посреди квартала не возникает вовсе. Ширина плавно
+ *     раскрывается к ширине узла, и в самом узле у всех подходов кромки совпадают;
+ *
+ *   ПЯТНО ПЕРЕКРЁСТКА — отдельная фигура, накрывающая всё пересечение. Её контур обходит концы
+ *     подходов по кругу и скругляется по радиусу поворота, как скругляется бордюр на настоящем
+ *     углу. Выемок в углах не остаётся по построению.
+ *
+ * Считает в метрах, как и весь граф. Дальше полигоны отдаются обычному слою поверхности — со своей
+ * толщиной, фаской и бортом.
+ */
+
+interface RoadSurface {
+    /** Перегон между узлами или пятно перекрёстка. */
+    kind: 'carriageway' | 'junction' | 'fillet';
+    outer: number[];
+    /** Дырки: бывают у кольцевой развязки. */
+    holes: number[][];
+    cls: string;
+    level: number;
+    /** Ширина, по которой полотно построено, метры — стилю удобно ей сортировать. */
+    width: number;
+    /**
+     * Узлы на концах перегона (у пятна и у слитой сети их нет).
+     *
+     * Нужны тому, кто считает высоту: эстакада выходит на неё рампой, а где эта рампа начинается,
+     * видно только по узлу — если в него приходят дороги нижнего уровня, значит здесь съезд на
+     * землю.
+     */
+    head?: number;
+    tail?: number;
+    /**
+     * УЗЛЫ, КОТОРЫМ ПРИНАДЛЕЖИТ ПЯТНО ИЛИ ЗАКРУГЛЕНИЕ.
+     *
+     * Тому же, кто считает высоту. У перегона отметка берётся по его цепочке, а у пятна цепочки нет
+     * вовсе — и без этого списка оно оставалось лежать на земле под взлетевшей развязкой бесформенным
+     * тёмным пятном: асфальт есть, а дороги, которой он принадлежит, над ним.
+     */
+    nodes?: number[];
+    /**
+     * ТРОЙКА, ПО КОТОРОЙ ПОСТРОЕНО ЭТО ПОЛОТНО (только в режиме `edges`).
+     *
+     * Отдаётся наружу не для красоты: по кромкам идёт краевая разметка, а отладочный слой показывает
+     * их поверх асфальта. Построй он свою тройку теми же параметрами — она всё равно разошлась бы с
+     * полотном везде, где ширина переменная, и «край дороги не по графу» вернулся бы. Здесь лежит та
+     * самая, из которой сделан контур.
+     */
+    edges?: RoadEdges;
+    /**
+     * ТРОЙКИ КУСКОВ, ИЗ КОТОРЫХ СЛЕПЛЕНА ЭТА ФИГУРА (только у слитой сети).
+     *
+     * Слияние сводит десятки полотен в один контур, и своей тройки у него уже нет — а показать, по
+     * чему сеть построена, всё равно надо. Иначе отладка считает кромки заново, по другим
+     * параметрам, и рисует их мимо асфальта: ровно то расхождение, из-за которого кажется, что край
+     * дороги идёт не по графу.
+     */
+    sourceEdges?: RoadSourceEdges[];
+    /**
+     * НОМЕР ЦЕПОЧКИ в `graph.chains`, по которой построено это полотно.
+     *
+     * По нему разметка находит ту самую тройку, из которой сделан асфальт. Без него ей пришлось бы
+     * считать свою — а своя расходится: полотно разглаживает ось по СВОЕЙ полуширине (с прибавкой
+     * на обочину), и на крутом повороте две «одинаковые» дуги отходят друг от друга на метры.
+     */
+    chain?: number;
+}
+/** Тройка куска вместе с номером его цепочки: по нему её находит разметка. */
+interface RoadSourceEdges {
+    chain: number;
+    edges: RoadEdges;
+}
+interface RoadSurfaceOptions {
+    /** Длина раскрытия ширины к узлу, метры. */
+    taper?: number;
+    /** Больше чем во столько раз к соседу не раскрываемся. */
+    maxGrow?: number;
+    /** Радиус скругления угла на перекрёстке, метры. */
+    cornerRadius?: number;
+    /** Прибавка к ширине из данных: обочина, свес бордюра, метры. */
+    widthExtra?: number;
+    /**
+     * ДОПУСК УПРОЩЕНИЯ КОНТУРА ПОСЛЕ СЛИЯНИЯ, метры.
+     *
+     * Слитая сеть обходится по кромкам десятков отдельных лент, и там, где две кромки почти
+     * совпадают, но не точно, на контуре остаётся ступенька в считанные сантиметры. Формы она не
+     * несёт, зато край полотна становится ломаным, будто его рвали руками.
+     *
+     * Десятая доля метра. Полметра, стоявшие здесь раньше, ступеньки снимали, но вместе с ними
+     * срезали и саму дорогу: на дворовом проезде в шесть метров это шестая часть ширины, и упрощение
+     * уводило кромку внутрь настолько, что вдоль неё тянулась полоса, где асфальта уже нет, а по
+     * графу дорога есть. По Шанхаю таких проб набиралось четыре с половиной тысячи против ста
+     * восьмидесяти при десяти сантиметрах.
+     *
+     * Заодно выяснилось, что полметра ничего и не выпрямляли: с меньшим допуском контур выходит
+     * РОВНЕЕ (средний излом 4.5° против 3.9°, острых углов 148 против 132) — упрощение само сдвигало
+     * вершины и создавало изломы, которые должно было убирать. Платим за это двадцатью процентами
+     * вершин контура.
+     */
+    tolerance?: number;
+    /**
+     * НАСКОЛЬКО БЛИЗКИЕ УЗЛЫ СЧИТАТЬ ОДНИМ ПЕРЕКРЁСТКОМ, метры.
+     *
+     * Перекрёсток улиц с раздельными проезжими частями состоит из нескольких узлов: каждая часть
+     * пересекается с каждой отдельно. Пока пятна строились вокруг каждого по отдельности, между ними
+     * оставались клинья голой земли.
+     */
+    cluster?: number;
+    /**
+     * ОБРЕЗАТЬ ПОЛОТНО У ПЕРЕКРЁСТКА, где в него входит дорога ШИРЕ.
+     *
+     * Лента строится на всю длину оси и кончается круглым торцом. В узле, где сходятся равные, это
+     * правильно: торцы прячутся под пятном перекрёстка. А вот проезд, упирающийся в проспект, своим
+     * торцом выезжает на его полотно и торчит поперёк полосы — мелкая деталь, по которой сразу
+     * видно, что дороги нарисованы по отдельности.
+     *
+     * Насколько отступить, знает граф: `clearance` считает, как далеко чужое полотно лезет на наш
+     * путь по УГЛУ пересечения. Обрезав на эту величину, мы ставим торец ровно на кромку чужой
+     * дороги, а стык закрывает пятно перекрёстка.
+     *
+     * Обрезается только МЕНЬШАЯ: главная дорога через перекрёсток проходит насквозь, и укорачивать
+     * её незачем.
+     */
+    trim?: boolean;
+    /**
+     * СТРОИТЬ ПОЛОТНО ТРОЙКОЙ «кромка — ось — кромка» вместо обводки контура.
+     *
+     * Обводка вокруг оси на плохой геометрии даёт петли, которые потом распутывает обрезка, — и на
+     * дорожках с изломами по тридцать градусов она сшивает не те края, оставляя по кромке зубцы.
+     * Тройка заходит с другого конца: ось сперва разглаживается до радиуса кривизны, при котором
+     * эквидистанта существует, и кромки после этого просто отмеряются от неё. Распутывать нечего,
+     * ширина держится с точностью до долей процента.
+     *
+     * Платит за это ось: её заломы круче полуширины разглаживаются, то есть геометрия слегка
+     * отходит от данных. Там, где данные точны и важны (проезжая часть по измеренной оси), лучше
+     * оставить обводку; там, где важнее вид (дорожки в парке), — тройку.
+     */
+    edges?: boolean;
+    /**
+     * СЛИТЬ ПОЛОТНА В СПЛОШНУЮ СЕТЬ и скруглить уже её контур, радиусом `cornerRadius`.
+     *
+     * Перегон и пятно перекрёстка — фигуры правильные, но ОТДЕЛЬНЫЕ: на их стыке лента упирается
+     * в пятно под своим углом, и сеть собирается из граней. На проезжей части этого не видно —
+     * там перегоны длинные, а перекрёстки редкие, — а вот в парке, где дорожки нарезаны кусками
+     * по двадцать метров и сходятся под всеми углами сразу, вся сеть и выглядит гранёной.
+     *
+     * После слияния внутренних границ нет вовсе, и скругление работает по настоящему краю сети.
+     * Стоит это булевой операции на весь набор, поэтому включается там, где кусков много и они
+     * мелкие, — то есть на дорожках.
+     */
+    merge?: boolean;
+    /**
+     * СЛИВАТЬ И РАЗНЫЕ КЛАССЫ ТОЖЕ — всю сеть уровня в одну фигуру.
+     *
+     * Обычное слияние идёт по уровню И КЛАССУ: проспект и проезд остаются разными фигурами, потому
+     * что красятся они по-разному, и слить их значило бы потерять цвет. Но там, где цвет у всех
+     * один, класс разделять больше нечего, а платить за разделение приходится: проезд, влившийся в
+     * проспект, лежит на нём своей фигурой, и слой строит по её контуру БОРТ — бордюрную стенку
+     * поперёк чужого асфальта. На Шанхае таких швов набирается двадцать километров.
+     *
+     * Со слитыми классами внутренних границ не остаётся вовсе: борт идёт только по настоящему краю
+     * сети. Класс у получившейся фигуры — самой широкой дороги в ней: если стиль всё же чем-то по
+     * нему различает, пусть это будет главная.
+     */
+    mergeClasses?: boolean;
+    /**
+     * КУСКИ, КОТОРЫЕ НЕЛЬЗЯ СЛИВАТЬ С ОСТАЛЬНОЙ СЕТЬЮ.
+     *
+     * Слияние сводит десятки полотен в одну фигуру, и высота у неё может быть только одна на всех.
+     * Для наземной сети это верно, а вот подход к эстакаде поднимается вдоль себя, и слитый с
+     * землёй он либо утонет, либо утащит за собой квартал.
+     *
+     * Спрашивается про ВЕСЬ кусок, а не только про его цепочку: на развязке между рампами лежат ещё
+     * и пятна перекрёстков с бордюрными закруглениями, у которых цепочки нет вовсе. Пока вопрос был
+     * про цепочку, они уходили в общую кучу и оставались на земле — под поднявшейся развязкой от
+     * них оставался бесформенный тёмный островок асфальта, к которому не подходит ни одна дорога.
+     */
+    apart?: (piece: RoadSurface) => boolean;
+    /**
+     * РАДИУС БОРДЮРНОГО ЗАКРУГЛЕНИЯ НА УГЛУ, метры. Ноль — не строить.
+     *
+     * На настоящем перекрёстке бордюр не ломается под прямым углом: он ПЛАВНО УХОДИТ с одной улицы
+     * на другую дугой в несколько метров — по ней машина и поворачивает. Без неё на стыке остаётся
+     * клин голой земли, вдвинутый в асфальт острым носом, и перекрёсток выглядит склеенным из
+     * прямоугольников.
+     *
+     * Скруглением контура этого не получить, и вот почему: улицы разных классов красятся
+     * по-разному, а значит и сливаются в разные фигуры. Угол между проспектом и проездом не
+     * существует как вершина ни у одной из них — он возникает только там, где их полотна
+     * НАКЛАДЫВАЮТСЯ. Округлять нечего.
+     *
+     * Поэтому закругление строится отдельной фигурой прямо по графу: берём два соседних по углу
+     * луча узла, их обращённые друг к другу кромки, и заполняем асфальтом ровно то, что срезала бы
+     * дуга, касающаяся обеих. Радиус подгоняется под узкий из подходов — на дворовом проезде
+     * семиметровая дуга съела бы весь угол.
+     */
+    fillet?: number;
+}
+declare function roadSurfaces(graph: RoadGraph, options?: RoadSurfaceOptions): RoadSurface[];
+
+/**
+ * ВЫСОТА ДОРОЖНОЙ СЕТИ: ГРАФ В ПРОСТРАНСТВЕ.
+ *
+ * В данных высоты нет. Есть `layer` — целое число, которое говорит, кто над кем, и больше ничего:
+ * ни на сколько метров, ни как туда подняться. Поэтому эстакада, построенная прямо по нему, встаёт
+ * из земли стеной, а на её концах улица обрывается вертикальным уступом в восемь метров.
+ *
+ * Считать подъём на самой эстакаде тоже нельзя. Мост через канал — это сто метров пролёта, а
+ * восемь метров набираются по нормальному уклону за сто тридцать: втиснутый в пролёт, подъём
+ * выходит в пятнадцать процентов, вдвое круче любого съезда. В жизни эстакада поднята ВСЯ, а
+ * поднимаются к ней ПОДХОДЫ — обычные улицы перед ней, которые в данных лежат тем же нулевым
+ * слоем.
+ *
+ * Значит высота — свойство не куска, а СЕТИ, и решать её надо по графу целиком.
+ *
+ *   1. Всё, что лежит выше нуля, поднято на свою полную высоту по всей длине. Это и значит
+ *      `layer=1`: дорога идёт над чем-то, и над этим «чем-то» она не может быть ниже.
+ *
+ *   2. От концов поднятого высота РАСТЕКАЕТСЯ по сети, спадая ровно по заданному уклону: узел
+ *      получает наибольшую высоту, до которой можно дотянуться от какой-нибудь эстакады. Это
+ *      обычный поиск кратчайшего пути, только вместо расстояния — потеря высоты. Подход сам
+ *      находит себе длину: сколько нужно, столько улиц перед мостом и поднимется.
+ *
+ *      Высота считается НА УЗЛЕ, а не на конце куска. Иначе в узле, где сходятся несколько
+ *      подходов, соседние куски получают разные отметки, и полотно рвётся: проверено, доходило
+ *      до шести метров разрыва.
+ *
+ *   3. Прямой конус, который из этого выходит, имеет два излома: у вершины (переход с плато на
+ *      уклон) и у подножия (переход с уклона на землю). На карте излом виден изломом полотна.
+ *
+ *      Сглаживаем не расстояние, а САМУ ВЫСОТУ: `h = верх · S(h / верх)`, где `S(t) = t²(3−2t)` —
+ *      кубическая кривая с нулевой производной на обоих концах. У вершины и у подножия уклон
+ *      обращается в ноль, и переход выходит плавным; а поскольку это функция от самой высоты, то
+ *      на стыке двух кусков ничего не меняется — высота там и так общая, значит и уклон общий.
+ *
+ *      Платит за это середина: у такой кривой она в полтора раза круче. Значит уклон в решателе
+ *      берётся в полтора раза меньше — чтобы в самом крутом месте выйти ровно на заданный.
+ *
+ * Считает в метрах, как и весь граф.
+ */
+
+interface RoadHeightOptions {
+    /** Сколько метров приходится на один уровень `layer`. */
+    levelHeight?: number;
     /**
-     * id фичи НА ТРЕУГОЛЬНИК — тем же форматом, что у заливки и зданий.
+     * Наибольший уклон подъёма, доля (0.06 — шесть процентов).
      *
-     * Нужен, чтобы вырезать линию из готового меша: под 3D-моделью прячется не только здание, но и
-     * дорожки вокруг него, а их в наборе замен обычно больше всего.
+     * СП 42.13330 для городских улиц даёт шестьдесят промилле; на съездах развязок берут до
+     * восьмидесяти. Это уклон в САМОМ КРУТОМ месте кривой, а не средний.
      */
-    featureIds: ArrayBuffer;
+    maxGrade?: number;
 }
-interface LineOptions {
+interface RoadHeights {
+    /** Высота узла, метры. */
+    node(id: number): number;
+    /** Высота на расстоянии `d` метров от головы цепочки. */
+    at(chain: number, d: number): number;
+    /** Длина цепочки по её оси, метры. */
+    length(chain: number): number;
     /**
-     * Уровень пересечения (см. `generators/level`): берём только фичи этого уровня.
+     * Цепочка лежит на земле целиком.
      *
-     * `undefined` — уровни не разделяем, слой строится целиком (так живут все слои, кроме дорожной
-     * сети: у реки или границы пересечений без связи не бывает).
+     * Такую можно сливать с остальной наземной сетью в одну фигуру; поднятую или наклонную — нельзя,
+     * у неё своя отметка.
      */
-    level?: number;
+    flat(chain: number): boolean;
+    /** Наибольший уклон, получившийся на этой цепочке, доля. */
+    grade(chain: number): number;
 }
-declare function generateLine(layer: VectorTileLayer, filter: Filter | undefined, maxSegment?: number, 
-/** Уровни поверхностей тайла: по ним дорога ложится на то, по чему идёт. Нет — лежит на нуле. */
-ground?: GroundField, 
-/** Метров в единице тайла. Ноль — плавный переход ширины на стыках не строится. */
-metersPerUnit?: number, opts?: LineOptions): LineMesh | null;
+declare function roadHeights(graph: RoadGraph, options?: RoadHeightOptions): RoadHeights;
 
 /**
- * УРОВЕНЬ ПЕРЕСЕЧЕНИЯ — какой из двух дорог быть сверху там, где они пересекаются без связи.
+ * МОСТ КАК СООРУЖЕНИЕ: продольный профиль и опоры.
  *
- * ЗАЧЕМ. Плоская карта рисуется краской: слои идут в порядке стиля, и внутри слоя порядок фич
- * произволен. Поэтому эстакада над улицей ничем не отличалась от перекрёстка — обводки сливались,
- * полотна пересекались, и место читалось как съезд, которого в жизни нет. Ровно этим у Яндекса
- * занят `line-z-level` (`["get","z_level"]` у КАЖДОГО дорожного слоя, все они в одной сети
- * `line-network: "roads"`): сеть рисуется не по слоям, а по уровням, и мост со своей тенью и
- * обводкой целиком ложится поверх того, что под ним.
+ * Полотно моста у нас поднято на высоту уровня пересечения (см. `StyleSpec.levelHeight`), и до сих
+ * пор подъём был СТУПЕНЬКОЙ: кусок дороги целиком либо на земле, либо наверху. На карте это видно
+ * сразу — эстакада обрывается в воздухе на своих концах, а въезда на неё нет.
  *
- * ОТКУДА ЧИСЛО. Готового `z_level` в наших тайлах нет, зато есть то, из чего его считают:
- *   `layer`   — тег OSM, честный уровень (−1 подземный, 1 над землёй, изредка 2…5);
- *   `brunnel` — «мост / тоннель / брод», он приходит и там, где `layer` не проставлен.
- * Поэтому берём `layer`, а если его нет — выводим уровень из `brunnel`. Мост без `layer`
- * (в Душанбе таких большинство) получает 1, тоннель — −1, обычная улица — 0.
+ * Здесь считаются две вещи, которых не хватало:
  *
- * Считается в ВОРКЕРЕ, при тесселяции: по уровню бьётся меш, и рендеру остаётся только порядок.
+ *   РАМПА — продольный профиль высоты. Мост поднимается от земли плавно, с ограниченным уклоном,
+ *   и так же плавно спускается. Форма подъёма — S-образная (smoothstep), а не прямая: у настоящей
+ *   рампы переломов в начале и в конце нет, иначе машина «подпрыгивает» на въезде, и на карте это
+ *   читается изломом полотна.
+ *
+ *   ОПОРЫ — столбы под плитой. Мост без них висит в воздухе; ставятся они с постоянным шагом и
+ *   только там, где под плитой есть место (на рампе у земли опора выродилась бы в пятно).
+ *
+ * Обе величины считаются по ОСИ дороги, в единицах тайла, и обе отдают готовые числа: генератору
+ * поверхностей — высоту в каждой вершине, генератору опор — точки и высоты столбов. Так же
+ * устроены процедурные генераторы дорог: сначала продольный профиль с ограничением уклона, потом
+ * расстановка опор по нему.
  */
 /**
- * Дальше этого уровни не разводим. В OSM попадается и `layer=5`, и опечатки в сотни: каждое
- * значение — это отдельный бакет и отдельный вызов отрисовки, поэтому хвост подрезаем. Пять этажей
- * развязки — больше, чем бывает на настоящих.
+ * Наибольший продольный уклон эстакады, доля.
+ *
+ * Шесть процентов — верхняя граница для городской улицы (СП 42.13330 держит 60 ‰ для магистральных
+ * улиц). Круче — это уже горная дорога, и на карте такой въезд читается обрывом.
  */
-declare const LEVEL_LIMIT = 5;
-/** Уровень фичи: `layer` из тегов, иначе вывод из `brunnel`. */
-declare function featureLevel(props: Record<string, unknown>): number;
+declare const MAX_GRADE = 0.06;
+/** Шаг опор, метры: пролёт городской эстакады — два-три десятка метров. */
+declare const PIER_SPACING_METERS = 24;
+/**
+ * Наименьшая высота опоры, метры: ниже она превращается в пятно под плитой.
+ *
+ * Считается от НИЗА плиты: у моста в метр высотой с полуметровой плитой под ней остаётся полметра,
+ * и столб там не нужен — плита садится на насыпь.
+ */
+declare const MIN_PIER_HEIGHT_METERS = 0.8;
+interface RampOptions {
+    /** Высота полотна над землёй, метры. */
+    height: number;
+    /** Метров в одной единице оси. */
+    metersPerUnit: number;
+    /** Наибольший уклон, доля; по умолчанию `MAX_GRADE`. */
+    maxGrade?: number;
+    /** Начало оси стоит на земле — там нужен въезд. */
+    rampStart?: boolean;
+    /** Конец оси стоит на земле — там нужен съезд. */
+    rampEnd?: boolean;
+}
+interface BridgeProfile {
+    /** Высота полотна на расстоянии `d` от начала оси, метры. */
+    heightAt: (d: number) => number;
+    /** Длина въездной и съездной рампы в единицах оси (0 — рампы нет). */
+    rampIn: number;
+    rampOut: number;
+    /** Где профиль ломается: эти расстояния полезно врезать в ось вершинами. */
+    knots: number[];
+    /** Полная длина оси в её единицах. */
+    total: number;
+}
+/**
+ * ПРОДОЛЬНЫЙ ПРОФИЛЬ МОСТА.
+ *
+ * Длина рампы берётся из уклона: у S-образной кривой уклон наибольший в середине и равен
+ * `1.5 · высота / длина`, поэтому длина считается как `1.5 · высота / уклон`. Если моста не
+ * хватает на две такие рампы, они укорачиваются поровну — тогда уклон выходит круче заданного, но
+ * зато мост не превращается в горку без ровной части.
+ */
+declare function bridgeProfile(axis: Ring | number[], opts: RampOptions): BridgeProfile;
+/** Опора моста: точка на оси, направление оси в ней и высота столба. */
+interface Pier {
+    x: number;
+    y: number;
+    /** Направление оси в этой точке, радианы: опора ставится поперёк дороги. */
+    angle: number;
+    /** Высота столба от земли до низа плиты, метры. */
+    height: number;
+    /** Расстояние от начала оси, единицы оси. */
+    at: number;
+}
+interface PierOptions {
+    /** Метров в одной единице оси. */
+    metersPerUnit: number;
+    /** Толщина плиты, метры: столб держит её снизу. */
+    deck: number;
+    /** Шаг опор, метры; по умолчанию `PIER_SPACING_METERS`. */
+    spacing?: number;
+    /** Ниже этой высоты столб не ставится, метры. */
+    minHeight?: number;
+}
+/**
+ * ОПОРЫ ПОД ПЛИТОЙ.
+ *
+ * Ставятся с постоянным шагом от СЕРЕДИНЫ моста, а не от его начала: так они стоят симметрично, и
+ * у короткой эстакады опора оказывается там, где она и должна быть — посередине пролёта.
+ *
+ * Пропускаются там, где плита идёт низко: на рампе у земли столб выродился бы в пятно под
+ * полотном, а на настоящей эстакаде въезд и правда лежит на насыпи.
+ */
+declare function bridgePiers(axis: Ring | number[], profile: BridgeProfile, opts: PierOptions): Pier[];
 
 /**
  * Положение камеры в адресе страницы.
@@ -5499,6 +8003,328 @@ declare function formatHash(camera: HashCamera, name?: string): string;
  */
 declare function parseHash(hash: string, name?: string): Partial<HashCamera> | null;
 
+/**
+ * ИСТОЧНИК ИЗ ДАННЫХ ПРИЛОЖЕНИЯ, а не с сервера.
+ *
+ * У всех остальных источников тайлы режет сервер: приходит готовый MVT, воркер собирает из него
+ * геометрию. Здесь резать приходится самим — данные приложение держит у себя целиком (маршрут,
+ * выдача поиска, тысяча точек на карте) и меняет их когда захочет (`setData`).
+ *
+ * ★ ГЕОМЕТРИЮ СОБИРАЕТ ТОТ ЖЕ КОД, ЧТО И ДЛЯ ТАЙЛОВ.
+ *
+ * Нарезка заканчивается тем, что из кусков собирается «слой тайла» — объект той же формы, что
+ * отдаёт разбор MVT. Дальше работает `buildTile`, общий с воркером. Иначе слой из GeoJSON рисовался
+ * бы не так, как точно такой же слой из тайлов, и разницу пришлось бы объяснять в каждом стиле.
+ *
+ * ★ ГДЕ СЧИТАЕТСЯ: НА ГЛАВНОМ ПОТОКЕ.
+ *
+ * У MapLibre нарезка живёт в воркере. У нас воркер занят тайлами с сервера и умеет ровно одно —
+ * забрать по адресу и разобрать; учить его хранить чужие наборы данных значит заводить им
+ * состояние и протокол синхронизации. Наборы приложения при этом на порядки меньше карты (точки,
+ * маршруты, зоны), и нарезка каждого тайла — это единицы миллисекунд. Когда набор станет большим,
+ * его правильное место — тайлы с сервера, а не память страницы.
+ */
+/** То, что принимает `setData`: сам набор или ссылка на него. */
+type GeoJSONData = GeoJSONFeatureCollection | GeoJSONFeature | string;
+interface GeoJSONFeature {
+    type: 'Feature';
+    id?: number | string;
+    geometry: GeoJSONGeometry | null;
+    properties?: Record<string, unknown> | null;
+}
+interface GeoJSONFeatureCollection {
+    type: 'FeatureCollection';
+    features: GeoJSONFeature[];
+}
+type GeoJSONGeometry = {
+    type: 'Point';
+    coordinates: [number, number];
+} | {
+    type: 'MultiPoint';
+    coordinates: [number, number][];
+} | {
+    type: 'LineString';
+    coordinates: [number, number][];
+} | {
+    type: 'MultiLineString';
+    coordinates: [number, number][][];
+} | {
+    type: 'Polygon';
+    coordinates: [number, number][][];
+} | {
+    type: 'MultiPolygon';
+    coordinates: [number, number][][][];
+};
+interface GeoJSONSourceOptions extends Partial<Omit<TileSourceOptions, 'url'>> {
+    data?: GeoJSONData;
+    /** Как называется слой внутри источника: на него ссылается `source-layer` слоя стиля. */
+    sourceLayer?: string;
+    /** Поле тайла в единицах тайла: геометрия у границы должна заезжать к соседу. */
+    buffer?: number;
+    /** Собирать ли точки в кластеры. */
+    cluster?: boolean;
+    /** Радиус кластера в пикселях экрана (как у MapLibre — 50). */
+    clusterRadius?: number;
+    /** Зум, выше которого кластеров нет: точки показываются по одной. */
+    clusterMaxZoom?: number;
+}
+declare class GeoJSONSource extends TileSource {
+    private features;
+    private readonly layerName;
+    private readonly bufferUnits;
+    private readonly clusterOn;
+    private readonly clusterRadiusPx;
+    private readonly clusterTopZoom;
+    /** Кластеры по зумам: считаются лениво и переживают панораму — набор от камеры не зависит. */
+    private clusters;
+    constructor(pool: WorkerPool, options?: GeoJSONSourceOptions);
+    /**
+     * Сменить данные. Строка — адрес: набор скачается сам.
+     *
+     * Тайлы после этого собираются заново: готовые выбрасываются, потому что они собраны из прежних
+     * данных. Это и есть `setData` у MapLibre, вплоть до поведения — карта перерисуется, когда новые
+     * тайлы соберутся.
+     */
+    setData(data: GeoJSONData): Promise<void>;
+    /** Сколько фич в наборе — по нему видно, доехали ли данные. */
+    get featureCount(): number;
+    /**
+     * Тайл собирается ЗДЕСЬ И СРАЗУ, без воркера и без сети.
+     *
+     * Дальше он неотличим от тайла с сервера: та же структура ответа, та же геометрия, тот же кеш.
+     */
+    protected loadTile(id: TileID): void;
+    /**
+     * КЛАСТЕРЫ НА ЗУМ — жадной сеткой, а не иерархией.
+     *
+     * Точки складываются в ячейки размером с радиус кластера и сливаются в одну, с числом собранных
+     * в свойстве `point_count` — так же, как это видит приложение у MapLibre. Иерархического
+     * дерева (supercluster) здесь нет намеренно: оно нужно наборам в сотни тысяч точек, а на тех
+     * размерах данные всё равно пора отдавать тайлами с сервера.
+     */
+    private clustersFor;
+}
+
+/**
+ * Зум и компас.
+ *
+ * Компас показывает поворот и наклон СРАЗУ: стрелка поворачивается вместе с картой, и по ней видно,
+ * куда «север», даже когда карта наклонена. Клик возвращает и поворот, и наклон — раздельные кнопки
+ * для этого у MapLibre были, и от них отказались именно потому, что вернуть хотят обычно всё.
+ */
+declare class NavigationControl implements IControl {
+    private options;
+    private group;
+    private needle;
+    private map;
+    private onMove;
+    constructor(options?: {
+        showCompass?: boolean;
+        showZoom?: boolean;
+        visualizePitch?: boolean;
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: unknown): HTMLElement;
+    onRemove(map: unknown): void;
+    private syncCompass;
+}
+/** Линейка масштаба. Метры и футы — как у MapLibre, включая морские мили. */
+declare class ScaleControl implements IControl {
+    private options;
+    private element;
+    private map;
+    private onMove;
+    constructor(options?: {
+        maxWidth?: number;
+        unit?: 'metric' | 'imperial' | 'nautical';
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: unknown): HTMLElement;
+    onRemove(map: unknown): void;
+    setUnit(unit: 'metric' | 'imperial' | 'nautical'): void;
+    private sync;
+}
+/** Атрибуция: кто дал данные. Сворачивается в кружок «i», как у MapLibre. */
+declare class AttributionControl implements IControl {
+    private options;
+    constructor(options?: {
+        compact?: boolean;
+        customAttribution?: string | string[];
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(): HTMLElement;
+    onRemove(): void;
+}
+/** Полный экран для контейнера карты. */
+declare class FullscreenControl implements IControl {
+    private options;
+    private target;
+    constructor(options?: {
+        container?: HTMLElement;
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: unknown): HTMLElement;
+    onRemove(): void;
+}
+/**
+ * Геолокация: показать, где пользователь.
+ *
+ * Разрешение спрашивает БРАУЗЕР, и только по клику — это его правило, а не наше. Слежение
+ * (`trackUserLocation`) держит подписку, поэтому снимается при удалении контрола: забытый
+ * `watchPosition` продолжает будить GPS и на вкладке, которую давно не смотрят.
+ */
+declare class GeolocateControl implements IControl {
+    private options;
+    private watchId;
+    private map;
+    constructor(options?: {
+        trackUserLocation?: boolean;
+        fitBoundsOptions?: {
+            zoom?: number;
+        };
+        positionOptions?: PositionOptions;
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: unknown): HTMLElement;
+    onRemove(): void;
+    private locate;
+}
+/** Тумблер рельефа: включает и выключает горы. */
+declare class TerrainControl implements IControl {
+    private options;
+    private button;
+    private saved;
+    constructor(options: {
+        source: string;
+        exaggeration?: number;
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: unknown): HTMLElement;
+    onRemove(): void;
+}
+/** Тумблер глобуса: плоская карта ↔ шар. */
+declare class GlobeControl implements IControl {
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: unknown): HTMLElement;
+    onRemove(): void;
+}
+/** Логотип или любая другая ссылка в углу. */
+declare class LogoControl implements IControl {
+    private options;
+    constructor(options?: {
+        compact?: boolean;
+        href?: string;
+        src?: string;
+        label?: string;
+    });
+    getDefaultPosition(): ControlPosition;
+    onAdd(): HTMLElement;
+    onRemove(): void;
+}
+
+/**
+ * ВЫРАЖЕНИЯ СТИЛЯ MapLibre.
+ *
+ * Стиль, написанный под MapLibre, почти целиком состоит из них: ширина дороги — `interpolate` по
+ * зуму, цвет — `match` по классу, видимость — `case`. Без интерпретатора такой стиль у нас не
+ * работает вовсе, а переписывать его на наши упрощённые формы (`stops`) для каждого приложения —
+ * это ровно та работа, которой перенос и должен избавить.
+ *
+ * ★ ИНТЕРПРЕТАТОР, А НЕ КОМПИЛЯТОР.
+ *
+ * MapLibre компилирует выражение в замыкания один раз и потом зовёт их. Мы считаем прямо по
+ * массиву, но КЕШИРУЕМ разбор (`compile`) — на зумовых свойствах это вызов на слой за кадр, и
+ * разница между подходами там неизмерима. На фильтрах, где вызовов десятки тысяч на тайл, кеш
+ * решает: разобранное выражение переиспользуется для каждой фичи.
+ *
+ * ★ ЧТО УМЕЕТ, А ЧТО НЕТ.
+ *
+ * Умеет всё, что встречается в стилях: данные (`get`, `has`, `id`, `geometry-type`,
+ * `feature-state`, `global-state`), решения (`case`, `match`, `coalesce`, логика, сравнения),
+ * шкалы (`interpolate` линейный, экспоненциальный и по кривой Безье, `step`), арифметику,
+ * строки, цвета, переменные (`let`/`var`), массивы (`at`, `length`, `slice`, `in`).
+ *
+ * Не умеет: `format` (богатый текст с разными шрифтами в одной подписи — у нас подпись
+ * однородная), `image` в значении «встроить картинку в текст», `distance`, `within` для линий и
+ * полигонов (точка проверяется, остальное — нет), `resolved-locale`. Всё перечисленное отмечено и
+ * в `porting/maplibre-api.md`.
+ */
+/** Значение выражения: то, чем оперирует язык. */
+type ExprValue = number | string | boolean | null | ExprValue[] | RGBAColor;
+/** Цвет как значение языка: четыре канала 0..1, как их отдаёт `parseColor`. */
+interface RGBAColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** Всё, что выражение может спросить об окружении. */
+interface ExprContext {
+    zoom?: number;
+    /** Свойства фичи (для фильтров и data-driven значений). */
+    properties?: Record<string, unknown>;
+    /** Номер фичи: `['id']`. */
+    id?: number | string | null;
+    /** Тип геометрии: `Point`, `LineString`, `Polygon`. */
+    geometryType?: string;
+    /** Состояние фичи (`map.setFeatureState`). */
+    featureState?: Record<string, unknown>;
+    /** Общее состояние стиля (`map.setGlobalStateProperty`). */
+    globalState?: Record<string, unknown>;
+    /** Точка фичи в координатах карты — нужна `within` для точечных фич. */
+    point?: [number, number];
+}
+/** Похоже ли значение на выражение: массив, первый элемент которого — имя операции. */
+declare function isExpression(value: unknown): value is ExprValue[];
+/**
+ * Посчитать выражение.
+ *
+ * Разбор кешируется на самом массиве: стиль живёт долго, а значения из него берут каждый кадр.
+ */
+declare function evaluateExpression(expr: unknown, ctx: ExprContext): ExprValue;
+/** Число из выражения; `fallback`, если получилось не число. */
+declare function expressionNumber(expr: unknown, ctx: ExprContext, fallback: number): number;
+/** Цвет из выражения в наш формат `[r, g, b, a]`. */
+declare function expressionColor(expr: unknown, ctx: ExprContext): [number, number, number, number] | null;
+
+interface RibbonOptions {
+    /** Полуширина полотна в единицах тайла. */
+    halfWidth: number;
+    /**
+     * ПОЛУШИРИНА ВДОЛЬ ОСИ: `d` — расстояние от начала оси в единицах тайла.
+     *
+     * Нужна плавному переходу на стыке (см. `generators/junctions`): у одной улицы куски приходят
+     * разной ширины, и без раскрытия к соседу асфальт обрывается уступом ровно там, где рисунок
+     * дороги уже расширился. Не задана — лента постоянной ширины, как раньше.
+     */
+    halfWidthAt?: (d: number) => number;
+    /** Метров в единице тайла — по нему считается дробность дуг. */
+    metersPerUnit: number;
+    /**
+     * Замкнутую ось (кольцевая развязка, двор) обходим как кольцо: у неё нет концов, и торцевые
+     * полукружия на стыке начала с концом оставили бы наплыв.
+     */
+    closed?: boolean;
+}
+/**
+ * Контур ленты вокруг ломаной. `null` — из такой оси ленты не выходит
+ * (одна точка, нулевая ширина, вырожденная геометрия).
+ */
+declare function ribbonRing(line: Ring, opts: RibbonOptions): Ring | null;
+/**
+ * ЛЕНТА КАК ФИГУРА: внешний контур и дырки.
+ *
+ * Дырка бывает ровно у замкнутой оси — у кольцевой развязки, у круга во дворе. Её полотно это
+ * КОЛЬЦО: снаружи один контур, внутри другой, и между ними асфальт. Одним контуром такую фигуру
+ * не задать: обход внешней стороны и обход внутренней склеились бы перемычкой, а заливка (и у
+ * тесселяции, и у canvas правило одно — по числу оборотов) закрасила бы середину целиком.
+ * Кольцевая развязка на карте превращалась при этом в сплошной асфальтовый блин.
+ */
+declare function ribbonShape(line: Ring, opts: RibbonOptions): {
+    outer: Ring;
+    holes: Ring[];
+} | null;
+
 /**
  * Рельефные поверхности: парк приподнят над землёй, вода утоплена, площадка
  * лежит своим уровнем.
@@ -5592,6 +8418,43 @@ interface SurfaceOptions {
      * переход на голой земле.
      */
     liftBy?: (properties: Record<string, unknown>) => number;
+    /**
+     * ПОДЪЁМ НА ВЕРШИНУ, а не на фигуру — профиль склона (см. `generators/lift`).
+     *
+     * Нужен рампе: восемь метров эстакады набираются склоном в сотню метров, и одной отметкой такой
+     * склон не описать. Возвращает поле высот по свойствам фичи или `null` — тогда работает обычный
+     * `liftBy`, одно число на всю фигуру.
+     */
+    liftAt?: (properties: Record<string, unknown>) => LiftField | null;
+    /**
+     * СТРОИТЬ ПОВЕРХНОСТЬ ИЗ ЛИНИЙ: полотно дороги, тротуар, дорожка.
+     *
+     * Функция возвращает ширину полотна в МЕТРАХ по свойствам фичи (в тайле она лежит в `width`,
+     * см. `Transportation.roadWidthMeters`), ноль или null — такую линию пропускаем. Ось
+     * превращается в контур (`generators/ribbon`), дальше всё как у обычного полигона: сварка,
+     * фаска-бордюр, юбка, свет.
+     */
+    widthOf?: (properties: Record<string, unknown>) => number | null;
+    /**
+     * Прибавка к ширине полотна из стиля, МЕТРЫ (обочина, свес бордюра).
+     *
+     * Нужна отдельно от `widthOf`, хотя та её уже включает: плавный переход на стыке
+     * (`generators/junctions`) считается по ширине ПРОЕЗЖЕЙ ЧАСТИ — по тому же числу, что и у
+     * рисунка дороги, — а прибавка кладётся поверх результата. Смешай их, и полотно раскрывалось бы
+     * к соседу на другое число, чем лента поверх него.
+     */
+    widthExtra?: number;
+    /**
+     * ТОЛЩИНА ПЛИТЫ У ПРИПОДНЯТОГО ПОЛОТНА (мост, эстакада), МЕТРЫ.
+     *
+     * Обычное полотно лежит на земле, и низа у него нет вовсе: юбка вырождается в ноль. У моста
+     * низ есть — это и делает его сооружением, а не плёнкой на воздухе. Поэтому пол у приподнятого
+     * куска опускается на толщину плиты, и по её краю идёт та же юбка, что у берега поверхности.
+     *
+     * Только у приподнятых: мостом кусок делает уровень пересечения (см. `StyleSpec.levelHeight`),
+     * и у дороги на земле никакой плиты нет.
+     */
+    deck?: number;
 }
 interface SurfaceMesh {
     vertices: ArrayBuffer;
@@ -5670,6 +8533,14 @@ interface Shape {
     outer: Ring;
     holes: Ring[];
     lift?: number;
+    /**
+     * Своё поле высот (склон рампы, см. `generators/lift`).
+     *
+     * Объединение сливает только то, что лежит на ОДНОЙ высоте: слитые фигуры дальше живут как одна,
+     * с одной отметкой на всех. У склона отметки нет вовсе — она у него в каждой вершине своя, — и
+     * слить его с соседом значило бы уронить рампу на землю. Поэтому склон в объединение не идёт.
+     */
+    at?: unknown;
 }
 
 /**
@@ -5850,6 +8721,26 @@ declare function fogPlanes(tr: Transform, style: Style): FogPlanes;
  *   })
  */
 
+/** Правка камеры перед кадром (см. `Map.setTransformCameraUpdate`). */
+type CameraUpdate = (camera: {
+    center: LngLat;
+    zoom: number;
+    bearing: number;
+    pitch: number;
+}) => Partial<{
+    center: LngLatLike;
+    zoom: number;
+    bearing: number;
+    pitch: number;
+}> | void;
+/** Своё ограничение камеры (см. `Map.setTransformConstrain`). */
+type TransformConstrain = (camera: {
+    center: LngLat;
+    zoom: number;
+}) => {
+    center?: LngLatLike;
+    zoom?: number;
+} | void;
 interface MapOptions {
     container: string | HTMLElement;
     center?: LngLatLike;
@@ -5891,6 +8782,12 @@ interface MapOptions {
     background?: string;
     /** Ограничение devicePixelRatio: на 4K-экранах 2× часто избыточно. */
     maxPixelRatio?: number;
+    /**
+     * Осторожные жесты: карта не перехватывает прокрутку страницы.
+     *
+     * Нужно встроенной карте внутри статьи — иначе колесо над ней листает не страницу, а зум.
+     */
+    cooperativeGestures?: boolean;
     /**
      * Детальные 3D-объекты (сервис Objects3D).
      *
@@ -6054,6 +8951,8 @@ declare class Map$1 extends Evented<MapEvents> {
      * которые сегодня не знают о подложке вовсе.
      */
     private rasterSources;
+    /** Источники высот (`raster-dem`). Рельеф читает их вершинный шейдер каждого слоя земли. */
+    private demSources;
     private renderer;
     private objects;
     /** Слой над канвой под DOM-маркеры: сам событий не ловит, маркеры — ловят. */
@@ -6066,10 +8965,59 @@ declare class Map$1 extends Evented<MapEvents> {
     /** Поля видимой области: место, занятое интерфейсом (см. setPadding). */
     private padding;
     private animation;
-    private loaded;
+    /** Стиль разобран и первый кадр показан. Имя `loaded` занято методом MapLibre. */
+    private ready;
     private destroyed;
     private background;
     private maxPixelRatio;
+    /** Шаг прилипания зума у кнопок (`zoomIn`/`zoomOut`). Ноль — не липнет. */
+    /** Плотность буфера кадра, как её посчитал `resize`. */
+    private pixelRatio;
+    /**
+     * Правки структуры слоёв, сделанные на лету: добавления, удаления, перестановки, зумы, фильтры.
+     *
+     * Хранятся списком РАСПОРЯЖЕНИЙ, а не результатом: стиль пересобирается из исходной
+     * спецификации при каждой смене темы, и правки накладываются на неё заново (см. `setStyle`).
+     */
+    private layerEdits;
+    /**
+     * Состояние фич: ключ `источник␟слой␟номер` → произвольные поля.
+     *
+     * Живёт у карты, а не у тайлов: тайл пересобирается при каждой смене темы и при каждом новом
+     * зуме, а «выбрано» и «под курсором» обязаны это пережить.
+     */
+    private featureStates;
+    /** Держится ли центр за землю (см. `setCenterClampedToGround`). */
+    private centerClamped;
+    /** Основной спрайт и дополнительные: их значки живут как обычные картинки. */
+    private spriteUrl;
+    private extraSprites;
+    /** Какая картинка из какого спрайта пришла: по этому и снимаются при `removeSprite`. */
+    private spriteImages;
+    private glyphsUrl;
+    /** Картинки, видео и canvas, прибитые к углам: тайлов у них нет, и живут они отдельно. */
+    private mediaSources;
+    /**
+     * Правка адреса от приложения.
+     *
+     * Хранится, а не только раздаётся: источники заводятся и после `setTransformRequest` (тема
+     * добавила слой, приложение позвало `addSource`), и новому источнику правку надо отдать тоже.
+     */
+    private transformRequest;
+    private cameraUpdate;
+    private transformConstrain;
+    /** Углы для контролов над канвой. */
+    private controls;
+    /**
+     * Обработчики ввода объектами (`map.dragPan.disable()`).
+     *
+     * Заводятся сразу, до жестов: приложение вправе выключить перетаскивание ещё до первого кадра, а
+     * менеджер жестов появляется только вместе с контекстом GL.
+     */
+    private handlers;
+    private zoomSnap;
+    /** Порог доворота на север, градусы (`snapToNorth`). Значение MapLibre. */
+    private readonly bearingSnap;
     /** Текущий профиль качества и то, разрешено ли двигать его самому. */
     private quality;
     /**
@@ -6169,6 +9117,14 @@ declare class Map$1 extends Evented<MapEvents> {
      * источник иначе.
      */
     private venuesForMask;
+    /**
+     * Свести рельеф стиля с загруженными источниками высот.
+     *
+     * Стиль и источник приезжают в разном порядке: `setStyle` объявляет и то и другое, а источник
+     * заводится асинхронно. Поэтому связь пересобирается и после смены стиля, и после каждого
+     * `addSource`, а не один раз при старте.
+     */
+    private syncTerrain;
     /** Подключить источник тайлов. Слои стиля ссылаются на него полем `source`. */
     addSource(name: string, spec: SourceSpec): this;
     private initInput;
@@ -6229,8 +9185,128 @@ declare class Map$1 extends Evented<MapEvents> {
     cameraForBounds(bounds: LngLatBounds, opts?: FitBoundsOptions): CameraOptions | null;
     /** Показать рамку целиком. `padding` — место, занятое интерфейсом. */
     fitBounds(bounds: LngLatBounds, opts?: FitBoundsOptions): this;
+    /**
+     * Сдвинуть карту на столько-то ПИКСЕЛЕЙ ЭКРАНА.
+     *
+     * Сдвигается карта, а не камера: `panBy([100, 0])` уводит содержимое влево, как палец,
+     * потянувший карту вправо. Центр ищется обратным переводом точки экрана — и на рельефе он
+     * честно ложится на землю (см. `Transform.elevationAt`).
+     */
+    panBy(offset: [number, number], opts?: AnimationOptions): this;
+    /** Перелёт к точке без смены зума, наклона и поворота. */
+    panTo(center: LngLatLike, opts?: AnimationOptions): this;
+    /** Зум до значения. Без `duration` — мгновенно. */
+    zoomTo(zoom: number, opts?: AnimationOptions): this;
+    zoomIn(opts?: AnimationOptions): this;
+    zoomOut(opts?: AnimationOptions): this;
+    /** Поворот до азимута. */
+    rotateTo(bearing: number, opts?: AnimationOptions): this;
+    /** Повернуть на север. */
+    resetNorth(opts?: AnimationOptions): this;
+    /** Повернуть на север И положить карту плашмя. */
+    resetNorthPitch(opts?: AnimationOptions): this;
+    /**
+     * Довернуть на север, если до него осталось немного.
+     *
+     * Порог тот же, что у MapLibre (`bearingSnap`, 7°): карту редко поворачивают «почти на север»
+     * нарочно, обычно это недоворот рукой.
+     */
+    snapToNorth(opts?: AnimationOptions): this;
+    /** Остановить анимацию камеры. Жест, начатый рукой, она не трогает — его останавливает палец. */
+    stop(): this;
+    /** Идёт анимация камеры (`easeTo`, `flyTo`, `fitBounds`). */
+    isEasing(): boolean;
+    /** Карта движется — хоть анимацией, хоть рукой. */
+    isMoving(): boolean;
+    isZooming(): boolean;
+    isRotating(): boolean;
+    getMinZoom(): number;
+    setMinZoom(zoom: number): this;
+    getMaxZoom(): number;
+    setMaxZoom(zoom: number): this;
+    getMinPitch(): number;
+    setMinPitch(pitch: number): this;
+    getMaxPitch(): number;
+    setMaxPitch(pitch: number): this;
+    /** Рамка, за которую камеру не выпускают. `null` — снять ограничение. */
+    getMaxBounds(): LngLatBounds | null;
+    setMaxBounds(bounds: LngLatBounds | null): this;
+    /**
+     * Шаг, к которому липнет зум у кнопок.
+     *
+     * Ноль — не липнет вовсе (так по умолчанию и у нас, и у MapLibre). Единица даёт целые зумы:
+     * с 14.3 кнопка «плюс» ведёт на 15, а не на 15.3.
+     */
+    getZoomSnap(): number;
+    setZoomSnap(snap: number): this;
+    /** Вертикальный угол обзора, градусы. */
+    getVerticalFieldOfView(): number;
+    setVerticalFieldOfView(degrees: number): this;
+    /** Высота земли под центром, метры: её ставит рельеф, но задать можно и руками. */
+    getCenterElevation(): number;
+    setCenterElevation(elevation: number): this;
+    /** Высота точки, на которую смотрит камера. У MapLibre это то же, что высота центра. */
+    getCameraTargetElevation(): number;
+    getContainer(): HTMLElement;
+    getCanvas(): HTMLCanvasElement;
+    getCanvasContainer(): HTMLElement;
+    /** Плотность буфера кадра. Ноль или меньше — вернуться к плотности экрана. */
+    getPixelRatio(): number;
+    setPixelRatio(ratio: number): this;
+    /** Перерисовать кадр. Синоним `triggerRepaint` — под именем MapLibre. */
+    redraw(): this;
+    /** Снести карту. Синоним `destroy` — под именем MapLibre. */
+    remove(): void;
+    /** Карта готова: стиль разобран и видимые тайлы на месте. */
+    loaded(): boolean;
+    /**
+     * Все ли тайлы видимой области уже пришли.
+     *
+     * Считаются ТОЛЬКО те источники, которые сейчас рисуются. Выключенный слой (пробки, планы
+     * этажей, размещения моделей) держит свой прошлый набор тайлов и ничего не грузит — по нему
+     * карта никогда не стала бы «готовой», хотя показывать он ничего и не собирается.
+     */
+    areTilesLoaded(): boolean;
+    /**
+     * Пришли ли все видимые тайлы этого источника.
+     *
+     * Пустой тайл и тайл с ошибкой считаются пришедшими: ждать их больше нечего, и без этого
+     * `loaded()` навсегда оставался бы ложью на любой дырке в данных.
+     */
+    isSourceLoaded(id: string): boolean;
+    /**
+     * Вписать в кадр прямоугольник, заданный ДВУМЯ ТОЧКАМИ ЭКРАНА.
+     *
+     * Нужно рамке выделения: пользователь тянет прямоугольник мышью, и карта должна показать ровно
+     * то, что он обвёл. Точки переводятся в координаты обратным переводом, дальше обычный `fitBounds`.
+     */
+    fitScreenCoordinates(p0: ScreenPoint$1, p1: ScreenPoint$1, bearing?: number, opts?: FitBoundsOptions): this;
+    /**
+     * Камера «откуда — куда»: поставить её в точку `from` на высоте `altitudeFrom` и направить на
+     * точку `to`. Возвращает обычные параметры камеры — их можно отдать в `jumpTo` или `easeTo`.
+     *
+     * Формулы из MapLibre (`MercatorTransform.calculateCameraOptionsFromTo`, BSD-3-Clause).
+     */
+    calculateCameraOptionsFromTo(from: LngLatLike, altitudeFrom: number, to: LngLatLike, altitudeTo?: number): CameraOptions & {
+        elevation: number;
+    };
+    /** Зум, прилипший к шагу `zoomSnap`. */
+    private snapZoom;
     private stepAnimation;
     private afterCameraChange;
+    /**
+     * ПРАВКИ КАМЕРЫ ОТ ПРИЛОЖЕНИЯ.
+     *
+     * Зовутся в одном месте — здесь, после любого изменения камеры, — и в одном порядке: сначала
+     * поправка (`setTransformCameraUpdate`), потом ограничение (`setTransformConstrain`). Порядок не
+     * произвольный: ограничение обязано быть последним, иначе поправка смогла бы вынести камеру за
+     * рамку уже после проверки.
+     *
+     * Защита от рекурсии обязательна: обработчик ставит центр, сеттер снова зовёт этот метод, и без
+     * флага получается бесконечный спуск.
+     */
+    private applyCameraHooks;
+    private inCameraHooks;
     /** move шлём не чаще кадра — на нём часто висит перерисовка UI. */
     private emitMove;
     project(lngLat: LngLatLike, altitudeMeters?: number): ScreenPoint$1;
@@ -6245,8 +9321,283 @@ declare class Map$1 extends Evented<MapEvents> {
      * перемалываются заново, картинка меняется в том же кадре.
      */
     setStyle(spec: StyleSpec): this;
+    /**
+     * Добавить слой. `beforeId` — перед каким слоем встать; без него слой ложится поверх всех.
+     *
+     * Тайлы пересобираются, только если слою нужна геометрия, которой ещё никто не просил: решает
+     * это сравнение планов в `setStyle`, а не мы здесь.
+     */
+    addLayer(layer: StyleLayerSpec | CustomLayer, beforeId?: string): this;
+    /** Убрать слой. Несуществующий — молча ничего: у MapLibre это ошибка, но нам она ни к чему. */
+    removeLayer(id: string): this;
+    /** Переставить слой: перед `beforeId`, а без него — наверх. */
+    moveLayer(id: string, beforeId?: string): this;
+    /** Слой стиля как он есть сейчас, со всеми правками. `undefined` — такого слоя нет. */
+    getLayer(id: string): StyleLayerSpec | CustomLayer | undefined;
+    /** Порядок слоёв снизу вверх — их идентификаторы. */
+    getLayersOrder(): string[];
+    /** Диапазон зумов, на которых слой виден. */
+    setLayerZoomRange(id: string, minzoom?: number, maxzoom?: number): this;
+    /** Фильтр слоя: какие фичи тайла ему достаются. У растрового слоя фильтра нет вовсе. */
+    getFilter(id: string): Filter | undefined;
+    /**
+     * Сменить фильтр слоя.
+     *
+     * Фильтр решает, что попадёт в геометрию, поэтому тайлы пересобираются — в отличие от
+     * `setPaintProperty`, который меняет только юниформы.
+     */
+    setFilter(id: string, filter: Filter | null): this;
+    /** Спецификация стиля целиком — копией, чтобы правки снаружи не меняли живой стиль. */
+    getStyle(): StyleSpec;
+    /**
+     * Стиль разобран.
+     *
+     * У нас он приходит объектом и разбирается сразу в конструкторе, поэтому ответ всегда
+     * положительный — в отличие от MapLibre, где стиль может ещё качаться по ссылке.
+     */
+    isStyleLoaded(): boolean;
+    /** Источники света стиля. */
+    getLight(): LightSpec;
+    /** Рельеф: источник высот и преувеличение. `null` — выключить. */
+    setTerrain(terrain: TerrainSpec | null): this;
+    getTerrain(): TerrainSpec | null;
+    /**
+     * Источник по имени: векторный, растровый или из данных приложения.
+     *
+     * Им приложение добирается до того, что умеет сам источник: у `geojson` это `setData`. Имя и
+     * смысл как у MapLibre, где смена данных устроена так же — `map.getSource(id).setData(…)`.
+     */
+    getSource(id: string): TileSource | RasterSource | DemSource | MediaSource | undefined;
+    /**
+     * Отключить источник и выбросить его тайлы.
+     *
+     * Слои, которые на него ссылались, остаются в стиле и просто перестают рисоваться — это
+     * нормальное состояние (см. `sourceFor` в рендерере), и оно же позволяет вернуть источник
+     * обратно, не трогая стиль.
+     */
+    removeSource(id: string): this;
+    /** Перекачать тайлы источника заново — данные на сервере поменялись. */
+    refreshTiles(id: string): this;
+    /** Крен камеры, градусы: поворот вокруг оси взгляда. */
+    getRoll(): number;
+    setRoll(roll: number): this;
+    /**
+     * Наложить на спецификацию правки структуры слоёв, сделанные на лету.
+     *
+     * Список, а не результат: стиль пересобирается из исходной спецификации при каждой смене темы,
+     * и правки надо уметь применить заново — в том же порядке, в каком их сделали.
+     */
+    private applyLayerEdits;
+    /**
+     * ЧТО НАРИСОВАНО В ЭТОЙ ТОЧКЕ (или в этом прямоугольнике) ЭКРАНА.
+     *
+     * Отвечает по НАРИСОВАННОЙ геометрии: фича, которую слой отфильтровал или которая не попала в
+     * видимый зум, в ответ не придёт, даже если в тайле она есть. Для второго вопроса — «что вообще
+     * есть в данных» — существует `querySourceFeatures`.
+     *
+     * Без аргументов отвечает по всему экрану: так же ведёт себя MapLibre.
+     */
+    queryRenderedFeatures(geometry?: QueryGeometry, opts?: RenderedQueryOptions): QueriedFeature[];
+    /**
+     * ЧТО ЕСТЬ В ЗАГРУЖЕННЫХ ТАЙЛАХ ИСТОЧНИКА.
+     *
+     * Ответ неполон по устройству: за пределами загруженного его взять неоткуда. Ровно то же
+     * ограничение и та же оговорка у MapLibre.
+     */
+    querySourceFeatures(sourceId: string, params?: {
+        sourceLayer?: string;
+        filter?: (props: Record<string, unknown>) => boolean;
+    }): QueriedFeature[];
+    /**
+     * СОСТОЯНИЕ ФИЧИ: наведение, выбор, всё, что не в данных, но влияет на вид.
+     *
+     * Хранится отдельно от тайлов, потому что переживает их пересборку: тайл приедет заново, а
+     * «эта улица выбрана» останется. Сейчас состояние отдаётся в ответах запросов; красить по нему
+     * будут выражения стиля (`['feature-state', …]`) — это фаза 7.
+     */
+    setFeatureState(target: {
+        source: string;
+        sourceLayer?: string;
+        id: number;
+    }, state: Record<string, unknown>): this;
+    getFeatureState(target: {
+        source: string;
+        sourceLayer?: string;
+        id: number;
+    }): Record<string, unknown>;
+    /**
+     * Снять состояние: всей фичи, одного ключа или целого источника.
+     *
+     * Без `id` чистится весь источник — так у MapLibre сбрасывают подсветку разом.
+     */
+    removeFeatureState(target: {
+        source: string;
+        sourceLayer?: string;
+        id?: number;
+    }, key?: string): this;
+    /**
+     * Высота земли в точке, метры. `null` — рельеф выключен или тайл высот ещё не приехал.
+     *
+     * Та же высота, по которой рисуется сама земля: одна функция на всех (`Terrain.heightAt`), иначе
+     * подпись стояла бы на одной отметке, а склон под ней был бы нарисован на другой.
+     */
+    queryTerrainElevation(lngLat: LngLatLike): number | null;
+    /**
+     * Держится ли центр карты ЗА ЗЕМЛЮ.
+     *
+     * По умолчанию да: центр лежит на склоне, и камера поднимается вместе с ним. Выключение
+     * оставляет центр на той высоте, где он оказался, — это нужно облётам, где камера идёт по своей
+     * траектории, а не ползёт по рельефу.
+     */
+    setCenterClampedToGround(clamped: boolean): this;
+    getCenterClampedToGround(): boolean;
+    /**
+     * Состояние фичи — КОПИЕЙ.
+     *
+     * Отдай мы живой объект, снятие одного ключа меняло бы и то, что приложение уже держит у себя:
+     * ответ запроса, сделанного минуту назад, вдруг менялся бы задним числом.
+     */
+    private featureStateOf;
+    /**
+     * Добавить картинку под именем, на которое ссылается `iconImage` слоя.
+     *
+     * Занятое имя не перезаписывается — для замены есть `updateImage`. Так же ведёт себя MapLibre:
+     * молча подменить чужой значок хуже, чем не добавить свой.
+     */
+    addImage(id: string, image: StyleImageData, options?: StyleImageOptions): this;
+    /** Заменить картинку под тем же именем. Размер может смениться. */
+    updateImage(id: string, image: StyleImageData, options?: StyleImageOptions): this;
+    removeImage(id: string): this;
+    hasImage(id: string): boolean;
+    getImage(id: string): StyleImage | undefined;
+    /** Имена всех картинок приложения. Встроенные значки сюда не входят — они не картинки. */
+    listImages(): string[];
+    /**
+     * ЧТО ДЕЛАТЬ, ЕСЛИ СТИЛЬ ПРОСИТ КАРТИНКУ, КОТОРОЙ НЕТ.
+     *
+     * Обработчик получает имя и может дорисовать её на лету (`addImage`) — так у MapLibre грузят
+     * значки по требованию, вместо того чтобы тянуть весь набор заранее.
+     */
+    setMissingStyleImageResolver(resolver: ((id: string) => void) | null): this;
+    /**
+     * СПРАЙТ: одна картинка с сеткой значков и описание, где какой лежит.
+     *
+     * Грузится парой файлов, как у MapLibre: `<url>.json` с рамками и `<url>.png` с пикселями.
+     * Разрезается на обычные картинки, дальше они ничем не отличаются от добавленных вручную.
+     */
+    setSprite(url: string | null): Promise<this>;
+    getSprite(): {
+        id: string;
+        url: string;
+    }[];
+    /** Добавить ещё один спрайт: его значки получают имена вида `id:name`, как у MapLibre. */
+    addSprite(id: string, url: string): Promise<this>;
+    removeSprite(id: string): this;
+    /** Откуда брать глифы: шаблон вида `/fonts/{fontstack}/{range}.pbf`. */
+    getGlyphs(): string;
+    setGlyphs(url: string): this;
+    /**
+     * Разрезать спрайт на картинки.
+     *
+     * Имя значка из спрайта по умолчанию — как в описании; у дополнительного спрайта оно
+     * получает приставку `id:`, чтобы не спорить с основным (правило MapLibre).
+     */
+    private loadSprite;
+    /**
+     * Поставить контрол в угол карты.
+     *
+     * Без `position` контрол встаёт туда, куда просится сам (`getDefaultPosition`), а без этого —
+     * в правый верхний угол. Те же правила и те же названия углов, что у MapLibre.
+     */
+    addControl(control: IControl, position?: ControlPosition): this;
+    removeControl(control: IControl): this;
+    hasControl(control: IControl): boolean;
+    /** Перетаскивание карты пальцем или мышью. */
+    get dragPan(): GestureHandler;
+    /** Поворот и наклон правой кнопкой. */
+    get dragRotate(): GestureHandler;
+    /** Зум колесом. */
+    get scrollZoom(): GestureHandler;
+    /** Зум двойным щелчком. */
+    get doubleClickZoom(): GestureHandler;
+    /** Щипок двумя пальцами: зум и поворот. */
+    get touchZoomRotate(): GestureHandler;
+    /** Наклон двумя пальцами. */
+    get touchPitch(): GestureHandler;
+    /** Управление с клавиатуры. */
+    get keyboard(): GestureHandler;
+    /** Зум рамкой: Shift + протянуть мышью. */
+    get boxZoom(): BoxZoomHandler;
+    /** Осторожные жесты: карта не перехватывает прокрутку страницы. */
+    get cooperativeGestures(): CooperativeGesturesHandler;
+    /**
+     * СВОЙ ПРОТОКОЛ ЗАГРУЗКИ: `pmtiles://`, `custom://`, что угодно.
+     *
+     * Приложение отдаёт функцию, которая по адресу возвращает содержимое тайла. Дальше тайл идёт
+     * обычным путём — тем же разбором и теми же генераторами, что тайл с сервера.
+     *
+     * Обработчик живёт на ГЛАВНОМ потоке, как и у MapLibre: он приложенческий, может ходить в
+     * IndexedDB, в свой кеш, в WebAssembly-читалку, и переносить всё это в воркер значит требовать
+     * от приложения писать под воркер.
+     */
+    static addProtocol(scheme: string, handler: ProtocolHandler): void;
+    static removeProtocol(scheme: string): void;
+    /**
+     * ПРАВКА ЗАПРОСА ПЕРЕД ОТПРАВКОЙ: подпись, ключ, свой домен.
+     *
+     * Возвращённый адрес уходит в загрузку вместо исходного. Зовётся на главном потоке — там, где
+     * приложение и держит свои ключи.
+     */
+    setTransformRequest(transform: TransformRequest | null): this;
+    /**
+     * ПРАВКА КАМЕРЫ ПЕРЕД КАДРОМ.
+     *
+     * Зовётся на каждое изменение камеры и может вернуть свои значения — так делают привязку к
+     * маршруту, ограничение по коридору, плавное сопровождение. У MapLibre это
+     * `setTransformCameraUpdate`.
+     */
+    setTransformCameraUpdate(update: CameraUpdate | null): this;
+    /**
+     * ОГРАНИЧЕНИЕ КАМЕРЫ: своя замена встроенной рамке.
+     *
+     * Возвращает поправленные центр и зум. Нужно там, где рамка не прямоугольная — например, карта
+     * одного города с вырезом.
+     */
+    setTransformConstrain(constrain: TransformConstrain | null): this;
+    /**
+     * ПОДРОБНОСТЬ НАБОРА ТАЙЛОВ У ИСТОЧНИКА.
+     *
+     * `detailBias` — во сколько раз крупнее брать тайлы (двойка это примерно на зум грубее и вчетверо
+     * меньше тайлов), `maxTiles` — потолок числа тайлов в наборе. Тем же у MapLibre заведует
+     * `setSourceTileLodParams`; у нас это настройки покрытия, и они же решают, сколько сети и памяти
+     * уйдёт на источник.
+     */
+    setSourceTileLodParams(id: string, params: {
+        detailBias?: number;
+        maxTiles?: number;
+    }): this;
+    /**
+     * ОБЩЕЕ СОСТОЯНИЕ СТИЛЯ: значение, которое читают выражения (`['global-state', 'key']`).
+     *
+     * Им переключают вид карты, не пересобирая стиль: «показать этажи выше третьего», «подсветить
+     * выбранный маршрут». Значение живёт у стиля, а не у слоя, — поэтому и имя общее.
+     */
+    setGlobalStateProperty(key: string, value: unknown): this;
+    getGlobalState(): Record<string, unknown>;
+    /** Повторять ли мир по горизонтали при отъезде. */
+    getRenderWorldCopies(): boolean;
+    setRenderWorldCopies(render: boolean): this;
     /** Переключить тему оформления поверх текущей структуры слоёв. */
     setTheme(theme: string | ThemeSpec): this;
+    /**
+     * СМЕНИТЬ ОСНОВУ, на которую ложатся темы.
+     *
+     * `setStyle` ставит стиль на один раз: следующий же `setTheme` соберёт тему поверх той основы, с
+     * которой карту создали, и всё вернётся. Для переключения варианта карты (например, обычная ↔
+     * рельефная) нужно заменить саму основу — этим и занимается этот метод. Тема применяется сразу,
+     * чтобы палитра не слетала на время переключения.
+     */
+    setBaseStyle(style: StyleSpec, theme?: string | ThemeSpec): this;
     /** Имена доступных тем. */
     static get themes(): string[];
     /**
@@ -6274,6 +9625,10 @@ declare class Map$1 extends Evented<MapEvents> {
      * Правка paint-свойств слоя на лету. Геометрия НЕ пересобирается — меняются
      * только юниформы, поэтому цвет и ширину можно крутить хоть каждый кадр.
      * Для правки filter/source-layer нужен setStyle: там меняется геометрия.
+     *
+     * ИСКЛЮЧЕНИЕ — значение, зависящее от ФИЧИ (`['get', …]` в цвете, прозрачности или ширине).
+     * Такое считается в воркере и лежит в вершинах (см. `generators/data-paint.ts`), поэтому правка
+     * тянет за собой новый план и перекачку разбора — как `textField` у раскладки.
      */
     setPaintProperty(layerId: string, prop: string, value: unknown): this;
     /**
@@ -6322,6 +9677,13 @@ declare class Map$1 extends Evented<MapEvents> {
      * метку с названием: иначе тот же текст оказывается на карте дважды.
      */
     setSymbolHidden(hit: SymbolHit | null): this;
+    /**
+     * Высота земли в точке, метры — для того, что считается на процессоре.
+     *
+     * Поле, а не метод: его передают колбэком в пикинг, и связанная функция создаётся один раз, а не
+     * на каждый клик. Рельефа нет — возвращается `undefined`, и пикинг работает по плоской земле.
+     */
+    private readonly groundAt;
     queryBuilding(point: ScreenPoint$1): BuildingHit | null;
     /**
      * Подсветить здание (или снять подсветку, передав null).
@@ -6553,4 +9915,4 @@ declare class Map$1 extends Evented<MapEvents> {
     destroy(): void;
 }
 
-export { type AnimationOptions, AssetLoader, type AssetLoaderOptions, BASE_SOURCE, BUILDING_HEIGHT_SCALE, BUILDING_POS_SCALE, BUILDING_VERTEX_STRIDE, type BuildingHit, type BuildingsMesh, CITY_STYLE, type CameraOptions, Circle, type CircleOptions, type CoverOptions, DEFAULT_ICONS, DEFAULT_LIGHT, DEFAULT_SHADOWS, DEFAULT_SKY, DEFAULT_STYLE, DepthTarget, type DeviceHints, EARTH_CIRCUMFERENCE, FILL_VERTEX_STRIDE, type Filter, type FitBoundsOptions, type FitViewport, type FogPlanes, GLOBE_MAX_PITCH, GLOBE_ZOOM_MAX, GLOBE_ZOOM_MIN, GLYPH_BORDER, GLYPH_SIZE, GROUND_SCALE, GeomType, type GestureOptions, type Glyph, type GlyphMetric, GlyphSource, type GpuClass, GroundArrows, IconSource, IndoorMask, type Interpolated, LEVEL_LIMIT, LINE_VERTEX_STRIDE, type LayerPlan, LayerRenderer, type LightSpec, type LinePlacement, type LngLat, LngLatBounds, type LngLatLike, MAX_LATITUDE, MODEL_VERTEX_STRIDE, Map$1 as Map, type MapEvents, MapObject, type MapObjectOptions, type MapOptions, Marker, type MarkerOptions, Model, ModelLayer, type ModelMesh, type ModelOptions, type ModelPrimitive, ObjectManager, type ObjectPaint, type ObjectPart, type Padding, type PlacedGlyph, type PlacedSymbol, Polygon, type PolygonOptions, type PolygonPiece, Polyline, type PolylineOptions, type PolylineSegment, Popup, type PopupOptions, type Projection, type QualityChange, QualityGovernor, type QualityName, type QualityProfile, RELIEF_STYLE, RUNTIME_FILL_STRIDE, RUNTIME_LINE_STRIDE, RasterSource, type RasterSourceOptions, RasterTile, type RoundOptions, type RuntimeMesh, SDF_EDGE, SDF_PX, SOFT_STYLE, SPLIT_SEP, SURFACE_CUT_BLEED, SURFACE_LEVEL_SCALE, SURFACE_VERTEX_STRIDE, type ScreenPoint$1 as ScreenPoint, SdfAtlas, type ShadowSettings, type SkySpec, Style, type StyleLayerSpec, type StyleSpec, type SymbolHit, SymbolRenderer, THEMES, TILE_SIZE, type ThemeSpec, TileID, Transform, VectorTile, VectorTileFeature, VectorTileLayer, abbreviateStreet, addGround, altitudeFromMercatorZ, applyTheme, arrowLabelOffset, arrowVertices, buildRuntimeFill, buildRuntimeLine, cameraForBounds, circumferenceAtLatitude, clampLat, clampPixelRatio, classifyRenderer, clipLineToRect, coordinateDigits, coveringTiles, createGround, Map$1 as default, deviceHints, distToSegment, evaluateColor, evaluateNumber, extractFeature, featureLevel, fillFootprint, fogPlanes, footprintOf, formatHash, generateBuildings, generateFill, generateLine, generateSurface, generateSymbols, globeBasis, globeFlatMix, globeRadius, globeToLocal, groundAt, iconRotation, insideFootprint, latFromMercatorY, lngFromMercatorX, lngLatToUnit, matchesFilter, mercatorMetersPerTile, mercatorX, mercatorY, mercatorZFromAltitude, metersPerPixel, metersPerTile, nextQualityDown, parseGlb, parseGlbAsync, parseGlyphs, parseHash, patchUV, pickBuilding, pickFill, pitchIntent, pixelsPerMeter, placeAlongLine, pointInRing, qualityFor, qualityProfile, raySphere, resolveTemplate, roundRing, sdfFromAlpha, shapeText, splitBucketKey, splitByGround, splitPolygons, stitchPieces, styleWithTheme, tileOriginMeters, tileUrl, toLngLat, unitToLngLat, worldSize };
+export { type AnimationOptions, type ArrowSize, AssetLoader, type AssetLoaderOptions, AttributionControl, type AxisChain, BASE_SOURCE, BUILDING_HEIGHT_SCALE, BUILDING_POS_SCALE, BUILDING_VERTEX_STRIDE, BoxZoomHandler, type BridgeProfile, type BuildingHit, type BuildingsMesh, CITY_STYLE, type CameraOptions, type CameraUpdate, Circle, type CircleOptions, type ControlPosition, CooperativeGesturesHandler, type CoverOptions, type CustomLayer, DATA_PAINT_STRIDE, DEFAULT_ICONS, DEFAULT_LIGHT, DEFAULT_SHADOWS, DEFAULT_SKY, DEFAULT_STYLE, type DataPaintSpec, type DemEncoding, DemSource, type DemSourceOptions, DemTile, DemTileEntry, DepthTarget, type DeviceHints, EARTH_CIRCUMFERENCE, type ExprContext, type ExprValue, FILL_VERTEX_STRIDE, FeaturePaint, type Filter, type FitBoundsOptions, type FitViewport, type FogPlanes, FullscreenControl, GLOBE_MAX_PITCH, GLOBE_ZOOM_MAX, GLOBE_ZOOM_MIN, GLYPH_BORDER, GLYPH_SIZE, GROUND_SCALE, type GeoJSONData, type GeoJSONFeature, type GeoJSONFeatureCollection, type GeoJSONGeometry, GeoJSONSource, GeolocateControl, GeomType, GestureHandler, type GestureOptions, GlobeControl, type Glyph, type GlyphMetric, GlyphSource, type GpuClass, GroundArrows, type IControl, IconSource, ImageManager, IndoorMask, type Interpolated, type Junctions, LEVEL_LIMIT, LINE_VERTEX_STRIDE, type LaneArrow, type LaneGuide, type LaneGuideOptions, type LayerPlan, LayerRenderer, type LiftField, type LightSpec, type LinePlacement, type LngLat, LngLatBounds, type LngLatLike, LogoControl, MAX_GRADE, MAX_LATITUDE, MIN_PIER_HEIGHT_METERS, MODEL_VERTEX_STRIDE, Map$1 as Map, type MapEvents, MapObject, type MapObjectOptions, type MapOptions, Marker, type MarkerOptions, type Marking, type MarkingKind, type MarkingOptions, type MarkingRing, type MediaCoordinates, type MediaKind, MediaSource, Model, ModelLayer, type ModelMesh, type ModelOptions, type ModelPrimitive, NavigationControl, ObjectManager, type ObjectPaint, type ObjectPart, PIER_SPACING_METERS, type Padding, type Pier, type PierOptions, type PlacedGlyph, type PlacedSymbol, Polygon, type PolygonOptions, type PolygonPiece, Polyline, type PolylineOptions, type PolylineSegment, Popup, type PopupOptions, type Projection, type ProtocolHandler, type QualityChange, QualityGovernor, type QualityName, type QualityProfile, type QueriedFeature, type QueryGeometry, RELIEF_STYLE, ROAD_SIGNS, RUNTIME_FILL_STRIDE, RUNTIME_LINE_STRIDE, type RampOptions, RasterSource, type RasterSourceOptions, RasterTile, type RenderedQueryOptions, type RoadAxis, type RoadChain, type RoadEdges, type RoadGraph, type RoadGraphOptions, type RoadHeightOptions, type RoadHeights, type RoadNode, type RoadRay, type RoadSourceEdges, type RoadSurface, type RoadSurfaceOptions, type RoundOptions, type RuntimeMesh, SDF_EDGE, SDF_PX, SIGN_SIZE, SOFT_STYLE, SPLIT_SEP, SURFACE_CUT_BLEED, SURFACE_LEVEL_SCALE, SURFACE_VERTEX_STRIDE, ScaleControl, type ScreenPoint$1 as ScreenPoint, SdfAtlas, type ShadowSettings, type SkySpec, Style, type StyleImage, type StyleImageData, type StyleImageOptions, type StyleLayerSpec, type StyleSpec, type SymbolHit, SymbolRenderer, TAPER_METERS, TERRAIN_STYLE, THEMES, TILE_SIZE, type TaperedWidth, TerrainControl, type ThemeSpec, type TileAddress, TileID, Transform, type TransformConstrain, type TransformRequest, VectorTile, VectorTileFeature, VectorTileLayer, abbreviateStreet, addGround, altitudeFromMercatorZ, applyTheme, arrowLabelOffset, arrowVertices, bridgePiers, bridgeProfile, buildRoadGraph, buildRuntimeFill, buildRuntimeLine, cameraForBounds, chainAxes, circumferenceAtLatitude, clampLat, clampPixelRatio, classifyRenderer, clipLineToRect, coordinateDigits, coveringTiles, createGround, Map$1 as default, densifyLine, deviceHints, distToSegment, evaluateColor, evaluateExpression, evaluateNumber, expressionColor, expressionNumber, extractFeature, featureDrivenPaint, featureLevel, fillFootprint, fogPlanes, footprintOf, formatHash, generateBuildings, generateFill, generateLine, generateSurface, generateSymbols, globeBasis, globeFlatMix, globeRadius, globeToLocal, groundAt, iconRotation, insideFootprint, isExpression, junctionIndex, laneArrow, laneGuides, latFromMercatorY, liftFields, lngFromMercatorX, lngLatToUnit, makeFeaturePaint, matchesFilter, mercatorMetersPerTile, mercatorX, mercatorY, mercatorZFromAltitude, metersPerPixel, metersPerTile, needsDataPaint, nextQualityDown, parseGlb, parseGlbAsync, parseGlyphs, parseHash, parseLift, patchUV, pickBuilding, pickFill, pitchIntent, pixelsPerMeter, placeAlongLine, placeMarking, pointInRing, qualityFor, qualityProfile, queryRendered, querySource, raySphere, refineLine, relaxAngle, relaxCurvature, resolveTemplate, ribbonFromEdges, ribbonRing, ribbonShape, ringEdges, roadEdges, roadHeights, roadMarkings, roadSurfaces, roundLine, roundRing, sdfFromAlpha, shapeText, speedSign, splitBucketKey, splitByGround, splitPolygons, stitchPieces, stopLine, styleWithTheme, taperedWidth, tileOriginMeters, tileUrl, toLngLat, unitToLngLat, unpackVector, waffle, worldSize, zebra };