osmgl 0.31.31 → 0.31.32

package/dist/core.d.ts

@@ -1,8 +1,4 @@
-import { ad as Transform, a4 as ScreenPoint$1, a7 as StyleLayerSpec, h as Filter, I as Interpolated, o as LightSpec, a5 as SkySpec, ab as ThemeSpecV2, a8 as StyleSpec, u as MapLibreLightSpec, j as FogSpec, cJ as RasterLayerSpec, B as BackgroundLayerSpec, g as DemLayerSpec, ac as TileID, cK as SymbolLayerSpec, ae as TransitionSpec, s as LngLatLike, cL as Mat4, p as LngLat, U as PointLike, v as MapObject, x as Model, S as Objects3DLayout, m as HillshadeLayerSpec, c as ColorReliefLayerSpec, J as ModelMesh, _ as Projection, a6 as SourceSpec, a9 as StyleSpecV2, q as LngLatBounds, r as LngLatBoundsLike, cM as TerrainSpec, aT as SpeedLimit } from './model-mshqbG69.js';
-export { A as AlongFade, C as Circle, a as CircleLayerSpec, b as CircleOptions, D as DEFAULT_FOG, d as DEFAULT_LIGHT, e as DEFAULT_MAPLIBRE_LIGHT, f as DEFAULT_SKY, E as EARTH_CIRCUMFERENCE, F as FOG_CUTOFF_MIN_M, i as FitViewport, G as GLOBE_MAX_PITCH, k as GLOBE_ZOOM_MAX, l as GLOBE_ZOOM_MIN, H as HeatmapLayerSpec, L as LayerSpecV2, n as LiftAt, M as MAX_LATITUDE, t as MODEL_VERTEX_STRIDE, w as MapObjectOptions, y as ModelLayerSpec, z as ModelLayout, K as ModelOptions, N as ModelPrimitive, O as OSMGL_FORMAT_VERSION, P as OSMGL_VERSION_KEY, Q as ObjectPaint, R as ObjectPart, T as PITCH_BY_ZOOM, V as Polygon, W as PolygonOptions, X as Polyline, Y as PolylineOptions, Z as PolylineSegment, $ as RUNTIME_FILL_STRIDE, a0 as RUNTIME_LINE_STRIDE, a1 as RouteArea, a2 as RouteAreaOptions, a3 as RuntimeMesh, aa as TILE_SIZE, af as alongFadeFactor, ag as altitudeFromMercatorZ, ah as buildRuntimeFill, ai as buildRuntimeLine, aj as cameraForBounds, ak as circumferenceAtLatitude, al as clampLat, am as distToSegment, an as globeBasis, ao as globeFlatMix, ap as globeRadius, aq as globeToLocal, ar as isDemLayer, as as isOsmglV2, at as latFromMercatorY, au as layerV1toV2, av as lngFromMercatorX, aw as lngLatToUnit, ax as mercatorMetersPerTile, ay as mercatorX, az as mercatorY, aA as mercatorZFromAltitude, aB as metersPerPixel, aC as metersPerTile, aD as parseGlb, aE as parseGlbAsync, aF as pitchLimitAt, aG as pixelsPerMeter, aH as pointInRing, aI as propertyV2toV1, aJ as raySphere, aK as styleV1toV2, aL as themeToInternal, aM as themeV1toV2, aN as tileOriginMeters, aO as toLngLat, aP as toMapLibreStyle, aQ as toPoint, aR as unitToLngLat, aS as worldSize } from './model-mshqbG69.js';
-import { b as VectorTileLayer, P as PropValue, G as GeomType, k as Ring, R as RoadName } from './speed-index-kbbQG2xX.js';
-export { V as VectorTile, a as VectorTileFeature, s as splitPolygons } from './speed-index-kbbQG2xX.js';
-import 'pbf';
+import Pbf from 'pbf';
 
 type Listener<T = unknown> = (payload: T) => void;
 /** Базовый источник событий движка: Map, source'ы и слои наследуются от него. */
@@ -15,6 +11,865 @@ declare class Evented<Events extends Record<string, unknown> = Record<string, un
     removeAllListeners(): void;
 }
 
+declare const TILE_SIZE = 512;
+declare const EARTH_CIRCUMFERENCE = 40075016.686;
+/** За этой широтой меркатор уходит в бесконечность; тот же предел, что у тайловых схем. */
+declare const MAX_LATITUDE = 85.051129;
+interface LngLat {
+    lng: number;
+    lat: number;
+}
+type LngLatLike = LngLat | [number, number];
+declare function toLngLat(v: LngLatLike): LngLat;
+declare const worldSize: (zoom: number) => number;
+declare const clampLat: (lat: number) => number;
+/** Долгота → нормализованный меркатор [0..1]. */
+declare function mercatorX(lng: number): number;
+/** Широта → нормализованный меркатор [0..1], север сверху. */
+declare function mercatorY(lat: number): number;
+declare function lngFromMercatorX(x: number): number;
+declare function latFromMercatorY(y: number): number;
+/** Длина окружности Земли на данной широте — база для перевода метров в пиксели. */
+declare function circumferenceAtLatitude(lat: number): number;
+/** Метры высоты → нормализованные меркаторные единицы (та же шкала, что x/y). */
+declare function mercatorZFromAltitude(altitudeMeters: number, lat: number): number;
+declare function altitudeFromMercatorZ(z: number, lat: number): number;
+/** Сколько мировых пикселей в одном метре на данной широте и зуме. */
+declare function pixelsPerMeter(lat: number, zoom: number): number;
+/** Сколько метров в одном экранном пикселе — для порогов упрощения геометрии. */
+declare function metersPerPixel(lat: number, zoom: number): number;
+/**
+ * Ширина тайла в метрах на широте его центра.
+ *
+ * Нужна там, где решение принимается в МЕТРАХ, а данные приходят в единицах
+ * тайла: скатная крыша ставится по размеру дома, рисунок фасада — по высоте
+ * этажа. В единицах тайла один и тот же порог означал бы разные здания на
+ * разных зумах и широтах.
+ */
+declare function metersPerTile(z: number, y: number): number;
+/**
+ * Ширина тайла в МЕРКАТОРНЫХ метрах — одинаковая для всех тайлов зума.
+ *
+ * ★ Это и есть система координат процедурного рисунка. `metersPerTile` берёт
+ * широту СВОЕГО тайла, и потому не годится: у соседей по вертикали ширина тайла
+ * отличается (на z18 — на 1,8 мм), а начало координат считается как `x × ширина`,
+ * где x это сотни тысяч. Полтора миллиметра, умноженные на 181 тысячу, дают
+ * ТРИСТА МЕТРОВ расхождения — рисунок на горизонтальном шве не просто съезжает,
+ * он оказывается в другом месте волны, и шов виден как разрез. Меркаторные метры
+ * от широты не зависят, поэтому непрерывны и по x, и по y, и между зумами
+ * (у родителя вдвое шире, а x вдвое меньше — начало то же).
+ *
+ * Цена: меркаторный метр на широте 38° длиннее настоящего в 1/cos. Обратно в
+ * настоящие переводит делитель по широте ЦЕНТРА КАРТЫ
+ * (`LayerRenderer.patternScale`) — делятся и масштаб, и начало, поэтому размеры
+ * рисунков остаются прежними, а непрерывность точной. Делитель обязан быть
+ * общим на кадр: возьми его по широте тайла — швы вернутся.
+ */
+declare function mercatorMetersPerTile(z: number): number;
+/**
+ * Начало тайла в меркаторных метрах — чтобы процедурный рисунок был СКВОЗНЫМ.
+ *
+ * Материалы и кровли считаются от координаты в метрах. Если брать её внутри
+ * тайла, рисунок начинается заново на каждой границе, и по швам тайлов идут
+ * отчётливые полосы — их видно на любой заливке с рисунком.
+ *
+ * Полную мировую координату во Float32 не отдать: на экваторе это 4·10⁷ метров,
+ * где шаг float — метры. Поэтому берём остаток от 65536 м: соседние тайлы
+ * по-прежнему отличаются ровно на свою ширину, точность остаётся миллиметровой,
+ * а разрыв случается раз в 65 километров — там, где его никто не увидит.
+ */
+declare function tileOriginMeters(z: number, x: number, y: number): [number, number];
+
+/**
+ * Прямоугольник по координатам.
+ *
+ * Нужен ровно для одного — «покажи это целиком»: маршрут, выдачу поиска,
+ * границу района. Имена методов те же, что у Mapbox и MapLibre (`extend`,
+ * `getCenter`, `contains`), чтобы чужой код переносился без переписывания.
+ *
+ * Через 180-й меридиан прямоугольник НЕ переносится: у нас нет данных по обе
+ * стороны океана, а поддержка переноса тянет за собой особый случай в каждом
+ * методе. Если понадобится — добавлять его надо вместе с тестами на склейку.
+ */
+/**
+ * Рамка любым из видов MapLibre: `LngLatBounds`, пара углов `[юго-запад, северо-восток]` или `[запад, юг, восток, север]`
+ * (02.11.2026).
+ */
+type LngLatBoundsLike = LngLatBounds | readonly [LngLatLike, LngLatLike] | readonly [number, number, number, number];
+declare class LngLatBounds {
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    constructor(sw?: LngLatLike, ne?: LngLatLike);
+    /** Рамка по набору точек. Пустой набор даёт пустую рамку, а не ошибку. */
+    /** Рамка из любого вида `LngLatBoundsLike`; `LngLatBounds` возвращается как есть. */
+    static convert(input: LngLatBoundsLike): LngLatBounds;
+    static from(points: Iterable<LngLatLike>): LngLatBounds;
+    extend(point: LngLatLike | LngLatBounds): this;
+    isEmpty(): boolean;
+    getCenter(): LngLat;
+    getWest(): number;
+    getSouth(): number;
+    getEast(): number;
+    getNorth(): number;
+    getNorthWest(): LngLat;
+    getSouthEast(): LngLat;
+    /** `[[запад, юг], [восток, север]]`, как `toArray` MapLibre. */
+    toArray(): [[number, number], [number, number]];
+    getSouthWest(): LngLat;
+    getNorthEast(): LngLat;
+    contains(point: LngLatLike): boolean;
+    /** Расширить на долю своего размера — «немного воздуха» вокруг объекта. */
+    pad(fraction: number): this;
+    /** Углы в нормализованном меркаторе — в этих единицах и считается вписывание. */
+    toMercator(): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+/** Размер экрана, поворот и поля — всё, что нужно, чтобы вписать рамку. */
+interface FitViewport {
+    width: number;
+    height: number;
+    bearing?: number;
+    padding?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    maxZoom?: number;
+    minZoom?: number;
+}
+/**
+ * Камера, при которой рамка видна целиком.
+ *
+ * Считается ЧИСТОЙ функцией, отдельно от карты: так её можно проверить без
+ * браузера — а «влезло ровно» или «влезло с запасом в полтора зума» на
+ * скриншоте всё равно не различить.
+ *
+ * Два неочевидных места:
+ *  • Рамка вписывается в ПОВЁРНУТОЙ системе. При развороте карты тот же
+ *    прямоугольник занимает другую часть экрана, и вписывание по осям меркатора
+ *    срезало бы углы.
+ *  • Поля — это не «отступ внутрь», а занятое интерфейсом место. Поэтому центр
+ *    карты уезжает на половину разницы полей: рамка встаёт в середину
+ *    СВОБОДНОЙ области, а не экрана.
+ */
+declare function cameraForBounds(bounds: LngLatBounds, view: FitViewport): {
+    center: LngLat;
+    zoom: number;
+    bearing: number;
+} | null;
+
+interface SpeedLimit {
+    kmh: number;
+    source: 'osm' | 'class';
+    cls?: string;
+    urban?: boolean;
+}
+
+/**
+ * Разбор 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[];
+}[];
+
+/**
+ * ОГРАНИЧЕНИЕ СКОРОСТИ ПО ИНДЕКСУ ТАЙЛА — источник правды для портов (`SpeedLimits.kt`, `SpeedLimitIndex.swift`)
+ * и натива (`native/src/navigram/speed_limit.cpp`, откуда логика и пришла, 17.10.2026).
+ *
+ * Зачем. Навигатор спрашивал знак раз в 0.9 с запросом по НАРИСОВАННОМУ: `project` + до четырёх
+ * `queryRenderedFeatures` (дорога точкой с допуском 3, 7, 12 px и застройка в 12 px) в потоке карты перед кадром.
+ * Перебор слоёв стиля и всех треугольников домов тайла под машиной — 18 мс на Redmi Note 11, провал кадра «раз в
+ * 0.9 с» (PLAN N6). Здесь сырой тайл основы ОДИН раз разбирается в индекс по слоям тайла: отрезки `transportation`
+ * сеткой 32² и признаки застройки (`landuse` городских классов — многоугольниками, `building`/`housenumber`/`poi` —
+ * битовой сеткой присутствия 256²). Ответ по готовому индексу — микросекунды. Где собирать индекс (воркер, пул,
+ * очередь) — решает платформа: сборка чистая, на входе байты, на выходе неизменяемый индекс.
+ *
+ * ★ Отличие от запроса по нарисованному — осознанное: дорога — БЛИЖАЙШАЯ проезжая в пределах 12 px (а не верхняя
+ * по порядку отрисовки среди попавших в 3/7/12 px), застройка — дом/номер дома/POI в радиусе 12 px или городской
+ * `landuse` под точкой. Запрос по нарисованному домов и подписей рядом с осью дороги почти не находил (заливка
+ * ловится попаданием центра, символы не ловятся вовсе), и «в городе ли» решал фактически один `landuse`.
+ * Сверка со старым ответом — `scripts/speed-index-vs-query.mjs`, цифры — в `native/PLAN.md`.
+ *
+ * Решение по найденному — та же чистая часть `speedLimitFromFeatures`: дорога одной фичей `transportation`,
+ * застройка — одной фичей `building` (её слой и есть признак, свойства не читаются).
+ */
+
+/** Название улицы: местное, русское (если есть) и номер дороги (`M41`). */
+interface RoadName {
+    name: string;
+    nameRu: string | null;
+    ref: string | null;
+}
+
+type Mat4 = Float64Array;
+type Vec3 = [number, number, number];
+
+/**
+ * Идентификатор тайла. wrap — номер копии мира по X (карта повторяется при панораме
+ * через антимеридиан): данные у копий одни и те же, а матрица разная, поэтому
+ * ключ кеша данных (dataKey) и ключ отрисовки (key) — разные вещи.
+ */
+declare class TileID {
+    readonly z: number;
+    readonly x: number;
+    readonly y: number;
+    readonly wrap: number;
+    private dataKeyOrNull;
+    private keyOrNull;
+    constructor(z: number, x: number, y: number, wrap?: number);
+    get dataKey(): string;
+    get key(): string;
+    parent(): TileID | null;
+    children(): TileID[];
+    /** Предок на заданном зуме (или сам тайл). */
+    scaledTo(z: number): TileID;
+    isAncestorOf(other: TileID): boolean;
+    /** Границы тайла в нормализованном меркаторе, с учётом копии мира. */
+    bounds(): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    toString(): string;
+}
+
+/**
+ * Глобус.
+ *
+ * Устроен так же, как у Mapbox: тайлы остаются ОБЫЧНЫМИ меркаторными, а на сферу
+ * их натягивает вершинный шейдер. Переписывать конвейер данных не пришлось —
+ * поменялось только то, как вершина попадает из тайла в пространство камеры.
+ *
+ * Ключевое решение, которое позволило не трогать камеру вовсе: глобус даёт не
+ * своё пространство, а **локальные координаты в касательной плоскости центра
+ * карты** — x на восток, y на юг, z вверх, начало в точке под камерой. Ровно то
+ * же, что даёт плоская карта. Поэтому:
+ *
+ *  - вся существующая камера (наклон, поворот, перспектива, пирамида видимости)
+ *    работает без единой правки;
+ *  - переход «глобус → плоская карта» это обычный `mix` двух позиций в ОДНОМ
+ *    пространстве, а не сшивка разных проекций. В центре кадра они совпадают
+ *    тождественно, поэтому шва там нет по построению.
+ *
+ * Ориентация осей повторяет меркатор: y растёт на ЮГ (`-sin(lat)`), как и в
+ * наших мировых пикселях. Иначе на переходе карта переворачивалась бы.
+ */
+/**
+ * Потолок наклона на глобусе. Столько же по умолчанию у Mapbox: выше камера
+ * заваливается за горизонт шара, и смотреть становится не на что.
+ */
+declare const GLOBE_MAX_PITCH = 60;
+/** Зумы, на которых происходит переход. Ниже — сфера, выше — плоскость. */
+declare const GLOBE_ZOOM_MIN = 4.5;
+declare const GLOBE_ZOOM_MAX = 6;
+/**
+ * Радиус сферы в мировых пикселях.
+ *
+ * Берём так, чтобы длина экватора совпала с шириной мира меркатора: тогда на
+ * экваторе масштабы глобуса и плоской карты равны, и переход не «дышит».
+ * Mapbox согласует масштаб на широте 45°, но у нас минимальный зум не такой
+ * мелкий, и экватор нагляднее.
+ */
+declare const globeRadius: (worldSize: number) => number;
+/**
+ * Доля плоской карты в смеси: 0 — чистая сфера, 1 — чистый меркатор.
+ * Между порогами интерполируется гладко, иначе переход виден скачком.
+ */
+declare function globeFlatMix(zoom: number): number;
+/** Единичный вектор направления на точку. Y на юг — как в меркаторе. */
+declare function lngLatToUnit(lng: number, lat: number): Vec3;
+declare function unitToLngLat(v: Vec3): {
+    lng: number;
+    lat: number;
+};
+interface GlobeBasis {
+    /** Восток, юг, вверх в точке центра карты — колонки перехода в локальные координаты. */
+    east: Vec3;
+    south: Vec3;
+    up: Vec3;
+}
+/**
+ * Касательный базис в точке центра карты.
+ *
+ * Порядок осей (восток, юг, вверх) совпадает с нашими мировыми пикселями, где
+ * y направлен вниз/на юг. Система при этом левая — та же, что у тайлов, поэтому
+ * намотка полигонов и отсечение граней остаются прежними.
+ */
+declare function globeBasis(lng: number, lat: number): GlobeBasis;
+/**
+ * Точка сферы → локальные координаты касательной плоскости центра.
+ * Ровно та же формула, что в вершинном шейдере, — держать их согласованными
+ * обязательно, иначе CPU и GPU разойдутся в размещении подписей.
+ */
+declare function globeToLocal(unit: Vec3, radius: number, basis: GlobeBasis): Vec3;
+/**
+ * Пересечение луча со сферой — обратная проекция на глобусе.
+ * Возвращает БЛИЖНЮЮ точку или null, если луч прошёл мимо.
+ */
+declare function raySphere(origin: Vec3, dir: Vec3, radius: number): Vec3 | null;
+
+type Projection = 'mercator' | 'globe';
+interface ScreenPoint$1 {
+    x: number;
+    y: number;
+}
+/** Экранная точка объектом или массивом `[x, y]` — как `PointLike` MapLibre (02.11.2026). */
+type PointLike = ScreenPoint$1 | readonly [number, number];
+/** `PointLike` → `{ x, y }`. */
+declare function toPoint(p: PointLike): ScreenPoint$1;
+/**
+ * Состояние камеры и все производные матрицы.
+ *
+ * Пространства координат:
+ *  - «мировые пиксели» (px): нормализованный меркатор · worldSize(zoom), Y вниз;
+ *  - пространство рендера: то же по X/Y, но Z в МЕТРАХ (матрица сама домножает на
+ *    pixelsPerMeter). Так вершины зданий несут честную высоту и не зависят от зума.
+ *
+ * Отсюда две матрицы: viewProjPx (отсечение, LOD, расстояния — всё в пикселях)
+ * и projMatrix (рендер, Z в метрах). Их легко перепутать — единицы Z разные.
+ */
+/**
+ * Ближе этого (метры) дальняя плоскость камеры и кромка тумана не встают — на крупном зуме дорога видна
+ * хотя бы на километр. Чуть дальше стены дымки (`FOG_FAR_MIN_M` = 900 м, `layers/fog`), чтобы обрыв
+ * геометрии прятался в уже сплошной дымке.
+ */
+declare const FOG_CUTOFF_MIN_M = 1000;
+/**
+ * НАКЛОН ПО ВЫСОТЕ КАМЕРЫ — как у Apple Maps: наклонная 3D-карта бывает только у земли.
+ *
+ * Отдалились — карта сама выпрямляется (с z13 и выше — в 2D), приблизились — наклон возвращается к
+ * тому, что просил пользователь (`Transform.wantedPitch`). Отсюда же поведение тумана, как у Apple:
+ * он виден только с горизонтом в кадре, а горизонт виден только вблизи. И отсюда экономия: на мелком
+ * зуме наклон 75° открывал до горизонта всю область вокруг — сотни тайлов, которые прятал туман.
+ *
+ * Узлы — зум и предел наклона, между ними линейно; ниже первого — предел первого, с последнего зума
+ * предела нет (только `maxPitch`). Похоже устроено у Google Maps (до z10 — 30°, к z14 — 45°, выше —
+ * больше) и у MapKit (наклон ограничен высотой камеры).
+ */
+declare const PITCH_BY_ZOOM: ReadonlyArray<readonly [number, number]>;
+/** Предел наклона на зуме по узлам `PITCH_BY_ZOOM`; `Infinity` — с последнего узла предела нет. */
+declare function pitchLimitAt(zoom: number, stops?: ReadonlyArray<readonly [number, number]>): number;
+declare class Transform {
+    width: number;
+    height: number;
+    minZoom: number;
+    maxZoom: number;
+    /**
+     * Рамка, за которую не выпускается ЦЕНТР карты. `null` — ограничения нет.
+     *
+     * Прижимается в сеттере центра, а не при отрисовке: центр ставят и жесты, и анимация, и
+     * приложение, и проверить это в одном месте — единственный способ не забыть ни одного из них.
+     */
+    maxBounds: LngLatBounds | null;
+    /**
+     * Повторять ли мир по горизонтали при отъезде.
+     *
+     * На мелком зуме в кадр помещается больше одного оборота Земли, и копии закрывают пустоту по
+     * краям. Приложению это иногда мешает — например, когда по карте водят выделение и вторая копия
+     * ловит тот же клик, — поэтому повтор выключается (`map.setRenderWorldCopies`).
+     */
+    renderWorldCopies: boolean;
+    minPitch: number;
+    maxPitch: number;
+    private _fogCutoff;
+    /**
+     * ДАЛЬНОСТЬ ОТСЕЧЕНИЯ ТУМАНА (`fog` стиля): глубина по оси взгляда в расстояниях до центра кадра.
+     *
+     * Становится ДАЛЬНЕЙ ПЛОСКОСТЬЮ камеры: за ней GPU не рисует ничего, а отбор тайлов (та же пирамида
+     * видимости в `isTileVisible`) их не выбирает и не грузит — как и 3D-модели (`isSphereVisible`).
+     * Туман в шейдере меряет ту же глубину, поэтому на кромке он уже сплошной. `Infinity` — не режем.
+     */
+    get fogCutoff(): number;
+    /**
+     * Дальняя плоскость тумана в мировых пикселях по оси взгляда: `fogCutoff` в долях расстояния до
+     * центра, но НЕ БЛИЖЕ `FOG_CUTOFF_MIN_M` метров. Доли на крупном зуме — десятки метров (z22: ~32 м), и
+     * камера обрезала дорогу прямо перед собой. `Infinity` — не режем.
+     */
+    fogCutoffDepth(): number;
+    set fogCutoff(k: number);
+    /**
+     * КРЕН камеры, градусы: поворот вокруг оси взгляда.
+     *
+     * Наклон (`pitch`) кладёт камеру вперёд, поворот (`bearing`) вращает карту под ней, а крен
+     * заваливает сам кадр — как накренившийся самолёт. Нужен полётам и панорамам; на обычной карте
+     * остаётся нулём. Порядок сборки тот же, что у MapLibre: крен идёт МЕЖДУ отъездом камеры и
+     * наклоном, иначе он начал бы вращать не кадр, а землю под ним.
+     *
+     * Свойство, а не поле: присваивание обязано пометить камеру грязной, иначе матрицы останутся
+     * прежними и крен не доедет до кадра.
+     */
+    private _roll;
+    private _center;
+    /**
+     * ВЫСОТА ЗЕМЛИ ПОД ЦЕНТРОМ КАРТЫ, метры. Ставится рельефом каждый кадр; без рельефа — ноль.
+     *
+     * Камера у нас стоит на фиксированном расстоянии от ТОЧКИ ЦЕНТРА, а точка эта лежала на нулевой
+     * высоте. Над горой в 2 км это значит, что камера оказывается внутри горы: земля поднялась, а
+     * она — нет. Поднимаем всю связку камера-центр на высоту земли — ровно так же поступает MapLibre
+     * (`transform.elevation`), и по той же причине: иначе рельеф нельзя даже осмотреть.
+     */
+    private _centerElevation;
+    private _zoom;
+    private _bearing;
+    private _pitch;
+    /** Наклон, который просили (`pitch =`); на экране — он же, урезанный пределом по зуму. */
+    private _wantedPitch;
+    /** Предел наклона по зуму. У голой математики камеры выключен; карта включает его опцией `pitchByZoom`. */
+    private _pitchByZoom;
+    private _fov;
+    private _worldSize;
+    private _pixelsPerMeter;
+    private _cameraToCenterDistance;
+    private _centerX;
+    private _centerY;
+    private _projMatrix;
+    /** Элемент [14] перспективы: z клипа = A·z + B (см. `projZOffset`). */
+    private _projZ;
+    private _viewProjPx;
+    private _viewMatrix;
+    private _pixelMatrix;
+    private _pixelMatrixInverse;
+    private _cameraPosPx;
+    private _frustumPlanes;
+    private _dirty;
+    /**
+     * Проекция. `globe` действует только до GLOBE_ZOOM_MAX — выше карта всё равно
+     * плоская, и держать сферу там значило бы платить за неё зря.
+     */
+    projection: Projection;
+    /**
+     * ЗУМЫ ПЕРЕХОДА ШАР → ПЛОСКОСТЬ ИЗ СТИЛЯ (этап y, `porting/unified-style-format.md` §15): `projection.type`
+     * MapLibre по зуму (`["interpolate", …, ["zoom"], z0, "vertical-perspective", z1, "mercator"]`, сахар
+     * `globe` — z11 → z12). Доля плоскости между ними — кривой `interpolate` (у MapLibre — линейная смесь
+     * положений, `GlobeProjection.transitionState`); `max: Infinity` — шар на любом зуме (`vertical-perspective`).
+     * `null` — свои зумы глобуса (`GLOBE_ZOOM_MIN`–`GLOBE_ZOOM_MAX`, гладкая ступенька).
+     */
+    globeZooms: {
+        min: number;
+        max: number;
+        base?: number;
+    } | null;
+    /** Зум, с которого шар уже не нужен. */
+    private get globeTop();
+    /** Доля плоской карты на зуме: из стиля — кривой `interpolate`, иначе своя гладкая ступенька. */
+    private flatMixAt;
+    private _f32;
+    private _tileMatrix;
+    private _localView;
+    private _localProj;
+    private _localPixel;
+    private _localPixelInverse;
+    private _localF32;
+    private _globeBasis;
+    private _objectF32;
+    private _objectMatrix;
+    private _shadowView;
+    private _shadowProj;
+    private _shadowVP;
+    /** То же, но принимает высоту в метрах — как projMatrix. */
+    private _shadowVPm;
+    private _shadowTile;
+    private _shadowObject;
+    private _shadowTile32;
+    private _shadowObject32;
+    private _shadowValid;
+    constructor();
+    get center(): LngLat;
+    set center(v: LngLat);
+    /** Высота земли под центром, метры (ставит рельеф). */
+    get centerElevation(): number;
+    set centerElevation(v: number);
+    /**
+     * Нижняя граница зума на глобусе: дальше шар становится точкой в углу экрана.
+     *
+     * Считается от размера кадра, а не числом: радиус сферы в мировых пикселях
+     * растёт с зумом, и «достаточно крупно» — это доля меньшей стороны экрана.
+     */
+    globeMinZoom(): number;
+    /** Нижняя граница зума с учётом проекции. */
+    effectiveMinZoom(): number;
+    get zoom(): number;
+    set zoom(z: number);
+    get bearing(): number;
+    set bearing(b: number);
+    get pitch(): number;
+    set pitch(p: number);
+    /** Наклон, который просили; на экране может быть меньше — по пределу зума (`pitchByZoom`). */
+    get wantedPitch(): number;
+    /**
+     * Наклон по высоте камеры (`PITCH_BY_ZOOM`). У карты по умолчанию включён (`MapOptions.pitchByZoom`).
+     * Выключают его те, кто ставит камеру сам и знает, зачем: ведение навигатора держит свой наклон.
+     */
+    get pitchByZoom(): boolean;
+    set pitchByZoom(on: boolean);
+    /** Предел наклона на текущем зуме: `maxPitch`, глобус и высота камеры. */
+    pitchLimit(): number;
+    private applyPitch;
+    /** Вертикальный угол обзора в градусах. */
+    get roll(): number;
+    set roll(deg: number);
+    get fov(): number;
+    set fov(deg: number);
+    resize(width: number, height: number): void;
+    get worldSize(): number;
+    get pixelsPerMeter(): number;
+    get cameraToCenterDistance(): number;
+    get cameraPositionPx(): [number, number, number];
+    /**
+     * Свободный член глубины перспективы (B в z клипа = A·z + B).
+     *
+     * Нужен, чтобы сдвинуть глубину точки к камере, не сдвигая её на экране: приблизить точку на долю
+     * `k` её расстояния — то же самое, что прибавить к z клипа `B·k/(1−k)`, одну постоянную на кадр
+     * (см. `LineLayerSpec.depthTest`).
+     */
+    get projZOffset(): number;
+    get projMatrix(): Mat4;
+    /** Мировые пиксели → экран в однородных координатах (x, y, z, w; делить на w). */
+    get pixelMatrix(): Mat4;
+    get viewMatrix(): Mat4;
+    /** Центр карты в мировых пикселях. */
+    get centerPointPx(): {
+        x: number;
+        y: number;
+    };
+    clone(): Transform;
+    /** Географическая точка (+ высота в метрах) → пиксели экрана. */
+    project(lngLat: LngLat, altitudeMeters?: number): ScreenPoint$1;
+    /**
+     * Мировые пиксели → экран. null, если точка за камерой: при наклоне 70°
+     * половина мира оказывается позади, и без этой проверки подписи «отражаются»
+     * в верхнюю часть экрана.
+     */
+    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;
+        y: number;
+    };
+    /** Сдвигает центр так, чтобы координата lngLat оказалась под точкой экрана. */
+    setLocationAtPoint(lngLat: LngLat, point: ScreenPoint$1): void;
+    /**
+     * Центр, посчитанный жестом или инерцией (минуя сеттер, без рамки `maxBounds` — её держит карта). Точка экрана
+     * за горизонтом или нечисловое касание дают NaN — такой шаг пропускается, как и в сеттере.
+     */
+    private placeCenter;
+    /**
+     * Сдвигает карту на (dx, dy) пикселей экрана В МАСШТАБЕ ЦЕНТРА: содержимое у центра уезжает ровно на
+     * столько же.
+     *
+     * Нужен инерции броска. Сдвиг здесь ЛИНЕЕН по дельте (пиксель центра переводится в мировые пиксели
+     * один раз, разностью по полпикселя в обе стороны), поэтому сумма шагов равна одному большому шагу
+     * — путь броска не зависит от частоты кадров, в том числе при наклоне. `setLocationAtPoint` вокруг
+     * центра этого не даёт: при перспективе он нелинеен, и десять мелких шагов уводят не туда, куда один
+     * крупный. На шаре линейного сдвига нет — там тот же поворот, что у жеста.
+     */
+    panByScreenDelta(dx: number, dy: number): void;
+    /**
+     * Матрица тайла: локальные координаты MVT [0..extent] + высота в метрах → клип.
+     * Возвращает переиспользуемый Float32Array — грузить в юниформ сразу, не хранить.
+     */
+    tileMatrix(tile: TileID, extent: number): Float32Array;
+    /** Та же матрица, но в Float64 — для расчётов на CPU (пикинг, отладка). */
+    tileMatrix64(tile: TileID, extent: number, out?: Mat4): Mat4;
+    /**
+     * Матрица рантайм-объекта: локальные координаты — нормализованный меркатор
+     * ОТНОСИТЕЛЬНО origin, Z — метры над землёй.
+     *
+     * Отличается от тайловой только тем, откуда берётся начало и масштаб: у тайла
+     * они продиктованы сеткой, у объекта их выбирает он сам по своей рамке. Смысл
+     * переноса тот же — увести из Float32 огромные мировые координаты.
+     */
+    objectMatrix(originX: number, originY: number, altitudeMeters?: number): Float32Array;
+    /**
+     * КВАДРАТ ДРАПИРОВКИ, в который сейчас рисуется плоская карта (15.10.2026). `null` — рисуем на экран.
+     *
+     * На рельефе плоский проход уходит в текстуры тайлов рельефа (`Renderer.drapeTerrain`), и всё, что в
+     * нём рисуется, обязано класть себя в КВАДРАТ ТАЙЛА, а не в кадр. Слои стиля так и делают (матрица
+     * тайла), а свои слои приложения и стрелки входов берут матрицу у `objectMatrix` — и получали
+     * экранную камеру. Полотно детальных дорог (`ld-pascal-mesh` на вебе, `LdMesh` на Android/iOS)
+     * рисовалось в каждую текстуру тайла по проекции кадра и легло на рельеф обрывками тёмных полос
+     * поперёк реки (жалоба с navi.gram.tj, Худжанд, z17, наклон 65°). Пока квадрат задан, `objectMatrix`
+     * переводит меркатор в квадрат рельефа, а высоту в метрах обнуляет: в текстуре земля плоская, рельеф
+     * ей даст решётка.
+     */
+    drapeSquare: {
+        z: number;
+        x: number;
+        y: number;
+    } | null;
+    /**
+     * `objectMatrix` в драпировке: локальный меркатор (от `origin`) → клип квадрата `drapeSquare`.
+     *
+     *   x = 2ⁿ⁺¹·lx + (2ⁿ⁺¹·ox − 2·T.x − 1),  y = −2ⁿ⁺¹·ly + (−2ⁿ⁺¹·oy + 2·T.y + 1),  z = 0
+     *
+     * Та же раскладка, что у тайла карты в драпировке (`Renderer.applyTileMatrix`): ось Y перевёрнута, её
+     * возвращает шейдер рельефа. Перенос считается в двойной точности — как у обычной `objectMatrix`.
+     */
+    private drapeObjectMatrix;
+    /**
+     * Экранная координата Y линии горизонта (сверху вниз, CSS-пиксели).
+     *
+     * Крена у нашей камеры нет, поэтому горизонт — всегда ГОРИЗОНТАЛЬНАЯ линия, и
+     * небо можно рисовать вертикальным градиентом в экранных координатах. Это и
+     * точно, и на порядок дешевле, чем считать направление луча в каждом фрагменте.
+     *
+     * Значение может быть отрицательным: при малом наклоне горизонт уходит выше
+     * кадра, и неба на экране просто нет.
+     */
+    horizonScreenY(): number;
+    /** Сфера сейчас активна: режим включён и зум ещё не перевалил за переход. */
+    get globeActive(): boolean;
+    /** Доля плоской карты в смеси: 0 — чистая сфера, 1 — чистый меркатор. */
+    get globeFlatMix(): number;
+    get globeRadiusPx(): number;
+    /**
+     * Радиус шара в мировых пикселях. Свой — по экватору (`globeRadius`); у стиля MapLibre (зумы перехода
+     * из стиля, этап y) — как у `GlobeTransform` MapLibre: делённый на косинус широты центра, чтобы масштаб
+     * в центре кадра совпадал с меркатором и переход шар → плоскость не менял размера карты.
+     */
+    private globeRadiusOf;
+    get globeBasis(): GlobeBasis;
+    /** Та же матрица в Float64 — для расчётов на CPU. */
+    get localProjMatrix(): Mat4;
+    /**
+     * Камера относительно ЦЕНТРА ШАРА, в локальных координатах: направление и
+     * косинус угла до горизонта.
+     *
+     * Считать горизонт от вертикали в центре карты нельзя — это верно только при
+     * наклоне 0. При наклоне камера уходит вбок, настоящий горизонт наклоняется
+     * вместе с ней, а плоскость, перпендикулярная вертикали, срезает шар по
+     * прямой: ровно это и было видно как «часть глобуса скрывается».
+     */
+    globeCamera(): {
+        dir: Vec3;
+        horizonCos: number;
+    };
+    /**
+     * Направления лучей через углы кадра, в локальных координатах.
+     *
+     * Нужны небу: чтобы посчитать, на каком угловом расстоянии от края планеты
+     * находится пиксель, нужен его луч. Считать обратную проекцию в каждом
+     * фрагменте дорого и незачем — направления линейны по экрану, поэтому хватает
+     * четырёх углов и интерполяции. Так же делает Mapbox (u_frustum_tl/tr/br/bl).
+     *
+     * Порядок: левый верх, правый верх, левый низ, правый низ.
+     */
+    localRayCorners(): Vec3[];
+    /**
+     * Базис камеры в МИРОВЫХ осях движка (X восток, Y юг, Z вверх) и фокус в пикселях вида.
+     *
+     * По ним из пикселя восстанавливается луч: dir = normalize(fwd*focal + right*dx + up*dy). Небу
+     * этого хватает, чтобы считаться от УГЛА ЛУЧА, а не от экранной высоты, — только так у горизонта
+     * получается настоящая воздушная масса, а не нарисованная полоса.
+     */
+    cameraRay(): {
+        right: Vec3;
+        up: Vec3;
+        fwd: Vec3;
+        focal: number;
+        axisElev: number;
+    };
+    /** Направление на центр планеты и её угловой радиус — для каймы атмосферы. */
+    globeDisc(): {
+        dir: Vec3;
+        angle: number;
+    };
+    /** Матрица камеры для ЛОКАЛЬНЫХ координат (глобус их и отдаёт). */
+    localMatrix(): Float32Array;
+    /**
+     * Нормализованный меркатор → локальные координаты. Повторяет формулу
+     * вершинного шейдера один в один: разойдись они — и подписи, размещаемые на
+     * CPU, поедут относительно геометрии.
+     */
+    globeLocal(mx: number, my: number): Vec3;
+    /** Локальные координаты → экран. null, если точка за камерой. */
+    localToPoint(local: Vec3): ScreenPoint$1 | null;
+    /**
+     * Обратная проекция на сфере: луч из камеры до пересечения с шаром.
+     *
+     * Центр шара в локальных координатах — (0, 0, −R): начало там, где сфера
+     * касается касательной плоскости, а центр на радиус ниже.
+     */
+    globeUnproject(point: ScreenPoint$1): LngLat | null;
+    /**
+     * Видна ли точка сферы: и по горизонту, и по кадру.
+     *
+     * Горизонт считается от ВЫСОТЫ камеры, а не «передней полусферы»: с конечной
+     * высоты видно заметно меньше половины шара, и без этого дальняя сторона
+     * рисовалась бы поверх ближней (тест глубины у плоских слоёв выключен).
+     */
+    isOnGlobeFront(lng: number, lat: number, slack?: number): boolean;
+    /**
+     * Пересчитывает матрицы карты теней под текущую камеру.
+     *
+     * Объём источника подгоняется под ВИДИМУЮ землю, а не задаётся раз и навсегда:
+     * при наклоне 70° видимая площадь больше, чем при взгляде сверху, в десятки
+     * раз, и фиксированный объём либо обрежет тени спереди, либо размажет их в
+     * кашу сзади (весь бюджет текселей уйдёт на пустоту).
+     *
+     * @param dir   куда ЛЕТИТ свет (та же система, что у `u_key_dir`)
+     * @param maxHeightMeters потолок сцены: выше него теней не бывает
+     */
+    updateShadow(dir: Vec3, maxHeightMeters: number, groundMin?: number, groundMax?: number): void;
+    /** Матрицы теней посчитаны и пригодны. */
+    get shadowReady(): boolean;
+    /**
+     * Матрица тени для рантайм-объекта: локальные координаты (нормализованный
+     * меркатор относительно origin) → клип источника света.
+     */
+    shadowObjectMatrix(originX: number, originY: number, altitudeMeters?: number): Float32Array;
+    /** Матрица тайла для прохода глубины: локальные координаты MVT → клип источника. */
+    shadowTileMatrix(tile: TileID, extent: number): Float32Array;
+    /**
+     * Сколько единиц глубины карты теней приходится на МЕТР высоты.
+     *
+     * Нужно, чтобы задавать смещение против самозатенения в метрах, а не в долях
+     * диапазона глубины. Диапазон зависит от объёма источника, а тот — от зума и
+     * наклона: одно и то же «0.0015» означало 49 метров на z16 и 15 на z19, и
+     * тени обычных домов просто съедались смещением.
+     *
+     * Матрица источника ортографическая, то есть аффинная, поэтому производная
+     * глубины по высоте — это просто её коэффициент при z.
+     */
+    shadowDepthPerMeter(): number;
+    /** Размер текселя карты теней в мировых пикселях — для наклонного bias. */
+    shadowTexelWorldSize(mapSize: number): number;
+    /**
+     * AABB тайла (мировые пиксели, Z тоже пиксели) против пирамиды видимости.
+     * Классический тест «полностью снаружи одной из плоскостей»: даёт ложные
+     * попадания на углах, но не теряет видимое — для отбора тайлов этого достаточно.
+     */
+    isTileVisible(tile: TileID): boolean;
+    /**
+     * Видна ли сфера: центр задан в нормализованном меркаторе, высота и радиус — в метрах.
+     *
+     * Тем же набором плоскостей, что и у тайлов ([[isTileVisible]]). Нужна отсечению 3D-моделей: их
+     * отбирают по расстоянию от ЦЕНТРА КАРТЫ, а не по кадру, и при наклонной камере заметная часть
+     * радиуса приходится за спину — рисовать её незачем.
+     */
+    isSphereVisible(mercX: number, mercY: number, heightM: number, radiusM: number): boolean;
+    /**
+     * Лежит ли точка ЗА КРОМКОЙ ТУМАНА (`fogCutoff`): её глубина по оси взгляда дальше дальней плоскости.
+     * Мировые пиксели по X/Y, высота в метрах. Нужна тому, что рисуется не GPU, — DOM-маркерам.
+     */
+    beyondFog(x: number, y: number, altitudeM?: number): boolean;
+    /** Расстояние от камеры до ближайшей точки AABB тайла (мировые пиксели). */
+    distanceToTile(tile: TileID): number;
+    /**
+     * Самая дальняя точка земли у НЕНАКЛОНЁННОЙ карты — точка отсчёта для слова «далеко».
+     *
+     * Смотрим сверху вниз: дальше всех от камеры угол экрана. Всё, что дальше этого, на плоской карте
+     * не встречается вовсе и появляется только от наклона.
+     */
+    get flatFarDistance(): number;
+    /**
+     * Зум, на который тайл ТЯНЕТ с такого расстояния.
+     *
+     * При наклоне карта одним кадром показывает и двор под ногами, и город за несколько километров, а
+     * зум у неё один на всех. Дальние тайлы от этого рисуются со всей мелочью ближнего плана: номера
+     * домов, тропинки, дворовые проезды — всё то, что на таком расстоянии сливается в грязь, но честно
+     * стоит вершин и вызовов отрисовки. Здесь считается, во сколько раз тайл дальше самого дальнего
+     * угла плоской карты, и на столько же зум-уровней он «отодвигается»: слой со своим `minzoom` сам
+     * пропадёт там, где стал бы неразличим. Ровно это происходит у Mapbox, где дальние тайлы физически
+     * берутся с меньшего зума.
+     *
+     * На ненаклонённой карте не меняет ничего: там дальше отсчётной точки ничего и нет.
+     *
+     * @param distancePx расстояние от камеры до тайла в мировых пикселях (`distanceToTile`)
+     */
+    detailZoom(distancePx: number): number;
+    private _ensure;
+    private _calc;
+    private _calcCameraPosition;
+    /**
+     * Плоскости пирамиды видимости из обратной view-projection: берём 8 углов клипа,
+     * переводим в мир и строим 6 плоскостей с нормалями внутрь.
+     */
+    private _calcFrustum;
+    /** Размер тайла зума z в пикселях экрана на расстоянии dist — критерий дробления. */
+    tileScreenSize(z: number, dist: number): number;
+    /** Сколько копий мира по X видно (панорама через антимеридиан). */
+    visibleWrapRange(): {
+        min: number;
+        max: number;
+    };
+}
+
 interface GestureOptions {
     dragPan: boolean;
     scrollZoom: boolean;
@@ -278,194 +1133,1970 @@ interface Capabilities {
     timerQuery: boolean;
     rendererName: string;
     /**
-     * Есть `KHR_parallel_shader_compile`: о готовности программы можно спросить, не дожидаясь её
-     * (см. `Shader.ready`). Без расширения такой вопрос сам ждёт конца компиляции.
+     * Есть `KHR_parallel_shader_compile`: о готовности программы можно спросить, не дожидаясь её
+     * (см. `Shader.ready`). Без расширения такой вопрос сам ждёт конца компиляции.
+     */
+    parallelCompile: boolean;
+}
+type DepthFunc = 'less' | 'lequal' | 'always' | 'greater';
+type BlendMode = 'none' | 'alpha' | 'premultiplied' | 'add' | 'multiply';
+type CullMode = 'none' | 'back' | 'front';
+declare class Context {
+    readonly gl: WebGL2RenderingContext;
+    readonly caps: Capabilities;
+    private _program;
+    private _vao;
+    private _framebuffer;
+    private _depthTest;
+    private _depthMask;
+    private _colorMask;
+    private _depthFunc;
+    private _blend;
+    private _cull;
+    private _viewport;
+    private _activeTexture;
+    private _boundTextures;
+    private _stencilTest;
+    constructor(gl: WebGL2RenderingContext);
+    /**
+     * ЗАБЫТЬ ВСЁ, ЧТО МЫ ЗНАЛИ О СОСТОЯНИИ GL.
+     *
+     * Нужно после чужого кода — своего слоя приложения (`CustomLayerInterface`). Он вправе поменять
+     * программу, буферы, смешивание и глубину; наш кеш после этого врёт, и следующий проход
+     * «пропускает» установку, которой на самом деле нет. Дешевле объявить кеш недействительным, чем
+     * потом искать, почему исчезли подписи.
+     */
+    resetState(): void;
+    useProgram(program: WebGLProgram | null): boolean;
+    bindVAO(vao: WebGLVertexArrayObject | null): void;
+    /**
+     * Куда уходит «экранный» кадр. По умолчанию `null` — канва. Диагностика
+     * подменяет его на свой буфер: проходы внутри рендера (тени, пикинг)
+     * возвращаются с bindFramebuffer(null), и без этой подмены весь кадр после
+     * первого же такого прохода уходил бы мимо буфера.
+     */
+    screen: WebGLFramebuffer | null;
+    /**
+     * Привязанный сейчас кадровый буфер (этап e: проход в свою текстуру посреди кадра — плотность
+     * тепловой карты, уклон отмывки — обязан вернуть ровно тот буфер, куда шёл кадр, в том числе
+     * текстуру драпировки рельефа). `null` — канва (или `screen`).
+     */
+    get currentFramebuffer(): WebGLFramebuffer | null;
+    /** Текущий режим смешивания — чтобы проход, сменивший его на время, вернул прежний. */
+    get blendMode(): BlendMode;
+    bindFramebuffer(fb: WebGLFramebuffer | null): void;
+    bindTexture(unit: number, texture: WebGLTexture | null, target?: number): void;
+    /** Ширина и высота текущего вьюпорта (ещё не заданного — кадрового буфера), пиксели. */
+    get viewportWidth(): number;
+    get viewportHeight(): number;
+    viewport(x: number, y: number, w: number, h: number): void;
+    setDepthTest(on: boolean): void;
+    setDepthMask(on: boolean): void;
+    /**
+     * Запись цвета. Выключенная маска — это рисование «только в глубину»:
+     * геометрия перекрывает то, что нарисуют дальше, но сама не видна (так
+     * закрываются дырки в утопленных поверхностях — острова).
+     */
+    setColorMask(on: boolean): void;
+    /** Текущая функция глубины — чтобы проход, сменивший её на время, вернул прежнюю. */
+    get depthFunc(): DepthFunc;
+    setDepthFunc(f: DepthFunc): void;
+    setBlend(mode: BlendMode): void;
+    setCull(mode: CullMode): void;
+    setStencilTest(on: boolean): void;
+    clear(color: [number, number, number, number] | null, depth?: boolean, stencil?: boolean): void;
+    /** Сбрасывает кеш — вызывать после чужого кода, трогавшего контекст напрямую. */
+    invalidateState(): void;
+}
+
+/**
+ * Скомпилированная программа с кешем локаций.
+ *
+ * `defines` подставляются в начало обоих шейдеров — так один исходник даёт варианты
+ * (с тенями / без, с пикингом / без) без ветвления в горячем цикле фрагмента.
+ */
+declare class Shader {
+    private ctx;
+    readonly name: string;
+    private readonly _program;
+    private uniforms;
+    private attribs;
+    /**
+     * ПОСЛЕДНЕЕ, ЧТО ПОЛОЖИЛИ В КАЖДЫЙ ЮНИФОРМ (перенос `Shader.kt` порта Android, 18.10.2026).
+     *
+     * Юниформ — состояние ПРОГРАММЫ: значение лежит там, пока его не сменят, а рендерер льёт их на каждую отрисовку:
+     * цвет, ширина и пороги зума у слоя одни на все его тайлы, меняется только матрица. На Android кеш снял 1457 → 669
+     * вызовов на кадр из 101 отрисовки; в WebGL каждый `uniform*` — проверка и запись в буфер команд браузера. Натив
+     * решает то же блоками по частоте (`OsmglFrame`/`OsmglMaterial`), у GL — вот этот кеш.
+     *
+     * Безопасно потому, что значения принадлежат объекту программы, а менять их может только `uniform*` по ней — то
+     * есть только сеттеры ниже; перелинковки нет, потеря контекста заводит `Shader` заново. Ключ — само место
+     * юниформа (`WebGLUniformLocation`), значения — копией (рендерер правит матрицы на месте). Сравнение — по
+     * числам JS, без `fround`: два разных числа с одним `float32` уйдут дважды, но лишнего не сэкономим никогда.
+     * Целые — отдельно: `Float64Array` с ними не путается, но `uniform1i` и `uniform1f` — разные вызовы.
+     */
+    private values;
+    private ints;
+    /** Сколько вызовов `uniform*` не ушло в GL: значение уже лежало в программе. */
+    savedUniforms: number;
+    /**
+     * Сборка ещё не проверена: шейдеры лежат здесь до первого обращения к программе.
+     *
+     * ★ ПРОВЕРКА ОТЛОЖЕНА НАМЕРЕННО (03.10.2026). Конструктор раньше сразу спрашивал
+     * `COMPILE_STATUS`/`LINK_STATUS`, а этот вопрос ЖДЁТ конца компиляции в главном потоке. Программ
+     * при создании карты два десятка, и они собирались строго по очереди: 24 ожидания на 0.8–0.9 с
+     * одной задачей (замер: холодный профиль Chromium, D3D11). Теперь все программы сначала
+     * отправляются компилятору, и он собирает их в своих потоках одновременно, а ждём мы только ту, что
+     * понадобилась первой (`finish`), — к тому моменту остальные уже в работе или готовы.
+     */
+    private pending;
+    constructor(ctx: Context, name: string, vertexSource: string, fragmentSource: string, defines?: Record<string, string | number | boolean>, 
+    /**
+     * Места атрибутов, которые надо повторить, — у ВАРИАНТА программы (см. surfaceShader): VAO
+     * собран по местам базовой программы и обязан подойти каждому варианту. Общий список мест
+     * (ATTRIB_SLOTS) тут не годится: атрибутов больше, чем гарантированных шестнадцати мест.
+     */
+    bind?: ReadonlyMap<string, number>);
+    /** Программа GL. Первое обращение дожидается сборки (см. `pending`). */
+    get program(): WebGLProgram;
+    /** Сборка не удалась: каждое следующее обращение бросает ту же ошибку, а не рисует удалённой программой. */
+    private failure;
+    /**
+     * Собрана ли программа — НЕ дожидаясь её, если драйвер это умеет (`KHR_parallel_shader_compile`).
+     * Без расширения честного неблокирующего ответа нет, и программа считается готовой: тогда первое
+     * обращение просто подождёт, как и раньше.
+     */
+    get ready(): boolean;
+    /** Дождаться сборки, проверить её и разобрать места юниформов и атрибутов. */
+    private finish;
+    private cacheLocations;
+    use(): void;
+    attribLocation(name: string): number;
+    private loc;
+    /** Надо ли слать значение в GL: `false` — там уже лежит такое же. */
+    private changed;
+    private readonly scratch;
+    private changed4;
+    /** Юниформ, вырезанный оптимизатором, молча игнорируется — это нормально. */
+    setMat4(name: string, v: Float32Array): void;
+    /** mat3 по КОЛОНКАМ — как того ждёт GLSL. */
+    setMat3(name: string, v: ArrayLike<number>): void;
+    setFloat(name: string, v: number): void;
+    setInt(name: string, v: number): void;
+    setVec2(name: string, x: number, y: number): void;
+    setVec3(name: string, x: number, y: number, z: number): void;
+    setVec4(name: string, x: number, y: number, z: number, w: number): void;
+    setVec4v(name: string, v: ArrayLike<number>): void;
+    /**
+     * МАССИВ vec4 одним вызовом. Имя — без индекса: драйвер отдаёт локацию массива по `u_name[0]`,
+     * но ищем мы и по голому имени, потому что часть драйверов регистрирует его именно так.
+     *
+     * Нужен для источников света модели: их до восьми, и восемь отдельных `uniform4f` на каждый
+     * примитив — это восемь вызовов GL там, где хватает одного.
+     */
+    setVec4Array(name: string, v: Float32Array): void;
+    /** Массив float одним вызовом (этап c: длины пунктира) — как `setVec4Array`. */
+    setFloatArray(name: string, v: Float32Array): void;
+    destroy(): void;
+}
+
+/**
+ * СВОИ ПРОТОКОЛЫ ЗАГРУЗКИ И ПРАВКА ЗАПРОСОВ.
+ *
+ * Два разных вопроса, но оба про «откуда берутся байты тайла»:
+ *
+ *   `addProtocol('pmtiles', …)` — адрес вида `pmtiles://…` обслуживает приложение само: читает из
+ *   одного файла, из IndexedDB, из WebAssembly-читалки;
+ *
+ *   `setTransformRequest(fn)` — обычный адрес, но перед отправкой его правят: подписывают, меняют
+ *   домен, добавляют ключ.
+ *
+ * ★ И ТО И ДРУГОЕ ЖИВЁТ НА ГЛАВНОМ ПОТОКЕ.
+ *
+ * Так же у MapLibre, и по той же причине: обработчик приложенческий — ему нужны ключи, кеш и
+ * хранилища страницы. Требовать, чтобы он работал внутри воркера, значит требовать от приложения
+ * писать под воркер. Поэтому байты добываются здесь, а воркеру достаётся только разбор.
+ */
+/** Что обработчик протокола отдаёт: содержимое тайла или `null`, если тайла нет. */
+type ProtocolHandler = (url: string, signal: AbortSignal) => Promise<ArrayBuffer | null>;
+/** Правка адреса перед загрузкой. Возврат `null` означает «оставить как есть». */
+type TransformRequest = (url: string, kind: 'tile' | 'raster' | 'glyph' | 'sprite') => string | null | undefined;
+
+/**
+ * Формат стиля движка.
+ *
+ * Сознательно НЕ повторяет style spec MapLibre: там половина возможностей
+ * (символы, sprite, expressions полного вида) нам сейчас не нужна, а тащить их
+ * означало бы тащить и интерпретатор выражений. Здесь — минимум, который
+ * покрывает схему OpenMapTiles v3: фильтр по свойствам, значение по зуму,
+ * три типа слоёв.
+ *
+ * Стиль хранится в `styles/*.json` и целиком вшивается в бандл — карта должна
+ * рисоваться без единого сетевого запроса за конфигом.
+ */
+/**
+ * Цвет, ВЫВЕДЕННЫЙ ИЗ ЦВЕТА ДРУГОГО СЛОЯ: «как у него, только темнее».
+ *
+ * Нужен обводке моста. Собственный цвет ей задать нельзя: тем два десятка, каждая красит дороги
+ * по-своему, и любой фиксированный хекс на половине из них смотрелся бы чужим. Полупрозрачная
+ * затемняющая краска эту задачу решала, но полупрозрачной линии нельзя: капсулы соседних отрезков
+ * перекрываются на изломах, и краска ложится дважды — по вершинам идёт цепочка тёмных бусин.
+ * (Трафарет «красить пиксель один раз» бусины убирает, но взамен оставляет светлый шов по
+ * сглаженному краю первой капсулы — проверено.)
+ *
+ * Ссылка снимает вопрос: тема красит обводку дороги, а обводка моста едет следом сама.
+ */
+interface ColorFrom {
+    /** Идентификатор слоя, у которого берём цвет. */
+    from: string;
+    /** Насколько затемнить, 0..1 (0.25 — четверть). */
+    darken?: number;
+    /**
+     * Какое свойство покраски слоя-источника брать; по умолчанию `color`. Плоские здания мелкого зума
+     * берут `roofColor` объёмного слоя: сверху у дома видна крыша, и темы красят её отдельно.
+     */
+    property?: string;
+}
+/**
+ * Значение, зависящее от зума.
+ *
+ * Три формы, и все три равноправны:
+ *   само значение — `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.
+ *
+ *   ['==', 'class', 'motorway']
+ *   ['in', 'class', 'primary', 'secondary']
+ *   ['has', 'name']
+ *   ['all', [...], [...]]
+ */
+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[]
+/** То же, записанное `as const` (02.11.2026): массив только для чтения тоже фильтр. */
+ | readonly unknown[];
+interface LayerBase {
+    id: string;
+    /**
+     * Источник тайлов. По умолчанию `base` — основная карта. Планы этажей лежат
+     * в отдельном наборе (`indoor.mbtiles`, зумы 15–18), и смешивать их с основным
+     * нельзя: у наборов разные потолки зума и разная частота пересборки.
+     */
+    source?: string;
+    /** Слой MVT, откуда брать фичи. */
+    'source-layer': string;
+    filter?: Filter;
+    minzoom?: number;
+    maxzoom?: number;
+    /**
+     * Разбить слой на отдельные меши по значению этого свойства фичи.
+     *
+     * Нужно этажам. Фильтры у нас применяются в ВОРКЕРЕ, на этапе тесселяции,
+     * поэтому «просто дописать `level == 3` в фильтр» означало бы пересобирать
+     * геометрию всех тайлов на каждое переключение этажа. Разбив слой заранее,
+     * переключение сводится к выбору другого готового буфера — как с темами,
+     * которые тоже ничего не пересобирают.
+     */
+    splitBy?: string;
+    /**
+     * Накладка: слой рисуется вне общей очереди, без теста глубины. Значение говорит, ГДЕ.
+     *
+     * `'volume'` (и `true` — прежнее написание) — поверх объёма. Нужно планам этажей: они лежат
+     * внутри здания, и в обычном порядке их закрыла бы его крыша. План этажа и есть накладка —
+     * «мы внутри», — а покрывает он ровно контур своего здания, поэтому соседние дома остаются
+     * видимыми.
+     *
+     * `'roads'` — сразу после дорог и ДО объёма. Это место разметки: зебры, перекрытия, всё, что
+     * лежит на асфальте. Дороги рисуются позже поверхностей, поэтому в общую очередь такая
+     * разметка не встаёт, но и поверх объёма ей делать нечего — зебра, висящая на стене дома,
+     * первой бросается в глаза.
+     *
+     * `'route'` — ВМЕСТЕ С ЛИНИЕЙ МАРШРУТА, в проходе рантайм-объектов (после объёма), и в отличие от
+     * остальных накладок — С ТЕСТОМ ГЛУБИНЫ, сдвинутой к камере на долю расстояния (`DEPTH_NUDGE`, как
+     * у `LineLayerSpec.depthTest`): асфальт, разметка и плиты полотна в сантиметрах ниже слой не
+     * закрывают (раньше лента по полосам рябила и пропадала кусками на настиле и детальных дорогах),
+     * а дом впереди и настил эстакады в метрах над ним — закрывают. Глубину не пишет. Между объектами:
+     * объекты с `zIndex` ниже `ROUTE_OVERLAY_Z` (невыбранные варианты) — под слоем, остальные (линия,
+     * пройденная часть, стрелки поворотов) — над ним. Так рисуется лента по полосам — продолжение линии.
+     */
+    overlay?: boolean | 'roads' | 'volume' | 'route';
+    /** Выключить слой, не удаляя из стиля. */
+    visible?: boolean;
+    /** Свободные данные приложения у слоя (`metadata` слоя MapLibre). Движок их не читает. */
+    metadata?: Record<string, unknown>;
+    /** Плавная смена свойств покраски по полю (`*-transition` MapLibre, этап d) — главнее `transition` корня. */
+    paintTransition?: Record<string, TransitionSpec>;
+    /**
+     * Радиус скругления углов в МЕТРАХ (заливки и объём).
+     *
+     * Это ГЕОМЕТРИЯ, а не покраска: правка радиуса пересобирает тайлы, как и
+     * правка фильтра. Поэтому свойство лежит рядом с фильтром, а не в `paint` —
+     * там всё меняется одними юниформами, без пересборки.
+     *
+     * У здания скругляется контур, а значит и стены, и КРЫША: она строится по
+     * тому же кольцу. На границе тайла срез не делается — иначе половинки дома
+     * из соседних тайлов сошлись бы со ступенькой.
+     */
+    cornerRadius?: number;
+    /**
+     * Крыши только плоские — как у `fill-extrusion` MapLibre. По умолчанию невысокий дом простой
+     * формы получает скатную крышу (по тегу `roof_shape` или по размеру); стилю, пришедшему из
+     * MapLibre, это чужой облик. Геометрия — поэтому поле рядом с фильтром, а не в `paint`.
+     */
+    flatRoofs?: boolean;
+    /**
+     * СВЕТ ОБЪЁМА ПО МОДЕЛИ MapLibre (`'maplibre'`) — у `fill-extrusion`, пришедшего из стиля MapLibre.
+     *
+     * Цвет вершины считается ровно формулой `fill_extrusion.vertex.glsl`: яркость цвета, подсветка
+     * 0.03, один направленный источник из `StyleSpec.mapLibreLight`, градиент стены по высоте. Наш
+     * свет, затенение у основания, тени, дымка, стекло и разброс тона такой слой не получает вовсе —
+     * у MapLibre их нет, и «похожий» облик был бы другим цветом каждой грани.
+     *
+     * Поле не только покраска, но и ГЕОМЕТРИЯ: нормали стен у такого слоя плоские на каждое ребро, как
+     * у MapLibre (`fill_extrusion_bucket`), без нашего сглаживания на пологих изломах. Поэтому оно
+     * лежит рядом с фильтром и едет в план воркера.
+     */
+    lighting?: 'maplibre';
+    /**
+     * Обрезать заливку по квадрату тайла.
+     *
+     * Нужно ПОЛУПРОЗРАЧНЫМ слоям: тайл приходит с буфером, полигон у границы
+     * приезжает и сюда, и к соседу, и в полосе перекрытия прозрачная заливка
+     * ложится дважды — по стыку идёт полоса иной плотности. Непрозрачной заливке
+     * буфер, наоборот, полезен: он закрывает волосяные щели на стыке.
+     */
+    clipToTile?: boolean;
+    /**
+     * Класс поверхности → её уровень в метрах: по нему РАЗМЕТКА поднимается вместе с дорогой.
+     *
+     * Зебра перехода живёт в своём наборе тайлов, где никаких газонов и парковок нет, и высоту под
+     * собой посчитать не может (в отличие от дороги, см. `generators/ground`). Зато база знает, в
+     * каком полигоне лежит переход, и кладёт его класс в свойство `on` — `слой:класс`, теми же
+     * словами, что и тайлы. Таблица переводит класс в высоту, а собирают её скрипты стилей из
+     * уровней тех же самых поверхностей, чтобы числа не разъезжались.
+     */
+    groundBy?: Record<string, number>;
+    /** Максимум отрезков на одну дугу (по умолчанию 4). */
+    cornerSegments?: number;
+}
+/**
+ * Материал плоского слоя — «из чего он сделан».
+ *
+ * По умолчанию материала нет: слой рисуется сплошной заливкой, ровно как
+ * раньше, и не стоит ни одной лишней инструкции в шейдере. Остальные варианты
+ * дают поверхности микрорельеф, а значит светотень: у сплошной заливки нормали
+ * нет вовсе, поэтому свет на неё не ложится и карта читается бумажной.
+ *
+ * Настраивается ИЗ СТИЛЯ (и переопределяется темой — это те же paint-поля):
+ *   "paint": { "color": "#a5cbe3", "material": "water", "materialScale": 9 }
+ */
+type MaterialName = 'flat' | 'water' | 'foliage' | 'sand' | 'asphalt';
+/** Общие настройки материала. Ими правят вид, не трогая сам движок. */
+interface MaterialPaint {
+    material?: MaterialName;
+    /** Выраженность рисунка, 0..1. Ноль — тот же сплошной цвет. */
+    materialStrength?: Interpolated<number>;
+    /** Размер рисунка в метрах: у воды это длина волны, у зелени — размер крон. */
+    materialScale?: Interpolated<number>;
+    /** Скорость анимации (вода). Ноль — статичная поверхность без перерисовок. */
+    materialSpeed?: Interpolated<number>;
+}
+/**
+ * Растровая подложка.
+ *
+ * Слой особый: у него нет ни фильтра, ни слоя MVT — рисуется весь тайл целиком.
+ * Поэтому он и не наследует `LayerBase`, где `source-layer` обязателен.
+ */
+interface RasterLayerSpec {
+    id: string;
+    type: 'raster';
+    /** Имя растрового источника. Обязательно: подложка не бывает «из основного». */
+    source: string;
+    minzoom?: number;
+    maxzoom?: number;
+    visible?: boolean;
+    /** Свободные данные приложения у слоя (`metadata` слоя MapLibre). Движок их не читает. */
+    metadata?: Record<string, unknown>;
+    /** Плавная смена свойств покраски по полю (этап d) — как у `LayerBase`. */
+    paintTransition?: Record<string, TransitionSpec>;
+    /**
+     * Рисовать ПОВЕРХ векторной карты, а не под ней.
+     *
+     * Подложка по смыслу лежит внизу, но растровым бывает и слой ПОВЕРХ: пробки,
+     * снимки событий, любая картинка, которую рисует сервер. Разделяет их только
+     * этот признак — конвейер у них общий.
+     */
+    overlay?: boolean;
+    paint?: {
+        opacity?: Interpolated<number>;
+        /** Поворот тона, градусы (`raster-hue-rotate`). */
+        hueRotate?: Interpolated<number>;
+        /** Яркость: чёрное → `brightnessMin`, белое → `brightnessMax` (0..1). */
+        brightnessMin?: Interpolated<number>;
+        brightnessMax?: Interpolated<number>;
+        /** Насыщенность, −1..1 (`raster-saturation`). */
+        saturation?: Interpolated<number>;
+        /** Контраст, −1..1 (`raster-contrast`). */
+        contrast?: Interpolated<number>;
+        /** Выборка текстуры при увеличении: `linear` или `nearest` (`raster-resampling`). */
+        resampling?: 'linear' | 'nearest';
+        /** Проявление нового тайла, мс (`raster-fade-duration`); 0 — сразу. */
+        fadeDuration?: Interpolated<number>;
+    };
+}
+/**
+ * Круги в точках (и в вершинах линий и полигонов) — слой `circle` MapLibre: заливка, обводка
+ * СНАРУЖИ радиуса, размытие всего круга. Значения — по зуму и по фиче.
+ */
+interface CircleLayerSpec extends LayerBase {
+    type: 'circle';
+    paint: {
+        radius?: Interpolated<number>;
+        color?: Interpolated<string>;
+        blur?: Interpolated<number>;
+        opacity?: Interpolated<number>;
+        strokeWidth?: Interpolated<number>;
+        strokeColor?: Interpolated<string>;
+        strokeOpacity?: Interpolated<number>;
+        translate?: Interpolated<[number, number]>;
+        translateAnchor?: 'map' | 'viewport';
+        /** `map` — круг сокращается с перспективой, `viewport` — одного размера на экране. */
+        pitchScale?: 'map' | 'viewport';
+        /** `map` — круг лежит на земле, `viewport` — смотрит в экран. */
+        pitchAlignment?: 'map' | 'viewport';
+    };
+    /** Порядок кругов внутри слоя (`circle-sort-key`). */
+    sortKey?: unknown;
+}
+/**
+ * Фон слоем — `background` MapLibre: заливка всего кадра на своём месте в списке слоёв, цвет и
+ * прозрачность по зуму, узор из спрайта. Фон корня (`StyleSpec.background`) остаётся: в него
+ * загрузчик кладёт ПЕРВЫЙ постоянный фон стиля, как и прежде.
+ */
+interface BackgroundLayerSpec {
+    id: string;
+    type: 'background';
+    /** Источника у фона нет — поле только чтобы общий код читал `layer.source` без разбора типа. */
+    source?: never;
+    overlay?: never;
+    minzoom?: number;
+    maxzoom?: number;
+    visible?: boolean;
+    metadata?: Record<string, unknown>;
+    /** Плавная смена свойств покраски по полю (этап d) — как у `LayerBase`. */
+    paintTransition?: Record<string, TransitionSpec>;
+    paint: {
+        color?: Interpolated<string>;
+        opacity?: Interpolated<number>;
+        pattern?: unknown;
+    };
+}
+/**
+ * ПЛАВНАЯ СМЕНА СВОЙСТВА (`transition` MapLibre, этап d): за `duration` мс после `delay` мс.
+ * Без поля у стиля MapLibre — 300/0, у своего стиля osmgl — сразу (`style/transition.ts`).
+ */
+interface TransitionSpec {
+    duration?: number;
+    delay?: number;
+}
+/**
+ * Тепловая карта — слой `heatmap` MapLibre: ядро Гаусса на каждую точку складывается в плотность
+ * (своя текстура в четверть экрана), плотность красится шкалой `heatmap-color`. Радиус и вес — по
+ * зуму и по фиче; сила, шкала и прозрачность — по зуму.
+ */
+interface HeatmapLayerSpec extends LayerBase {
+    type: 'heatmap';
+    paint: {
+        /** Радиус ядра, CSS-пиксели (`heatmap-radius`). */
+        radius?: Interpolated<number>;
+        /** Вес точки (`heatmap-weight`). */
+        weight?: Interpolated<number>;
+        /** Множитель плотности (`heatmap-intensity`), только по зуму. */
+        intensity?: Interpolated<number>;
+        /** Цвет по плотности: выражение от `["heatmap-density"]` (`heatmap-color`). */
+        color?: unknown;
+        opacity?: Interpolated<number>;
+    };
+}
+/** Общие поля слоёв по источнику высот (`raster-dem`): фичи и фильтра у них нет, как у растра. */
+interface DemLayerBase {
+    id: string;
+    /** Имя источника типа `raster-dem`. */
+    source: string;
+    minzoom?: number;
+    maxzoom?: number;
+    visible?: boolean;
+    metadata?: Record<string, unknown>;
+    overlay?: never;
+}
+/**
+ * Отмывка рельефа плоским слоем — `hillshade` MapLibre по тайлам `raster-dem`: уклон считается из
+ * высот (подготовка в текстуру тайла), свет — одним из пяти методов MapLibre 5.
+ */
+interface HillshadeLayerSpec extends DemLayerBase {
+    type: 'hillshade';
+    paint: {
+        /** Азимут света, градусы; массив — несколько источников (метод `multidirectional`). */
+        illuminationDirection?: Interpolated<number> | number[];
+        /** Высота света над горизонтом, градусы (не у `standard`). */
+        illuminationAltitude?: Interpolated<number> | number[];
+        /** `viewport` — свет поворачивается с экраном, `map` — стоит на карте. */
+        illuminationAnchor?: 'map' | 'viewport';
+        exaggeration?: Interpolated<number>;
+        shadowColor?: Interpolated<string> | string[];
+        highlightColor?: Interpolated<string> | string[];
+        accentColor?: Interpolated<string>;
+        method?: 'standard' | 'basic' | 'combined' | 'igor' | 'multidirectional';
+        /** Выборка подготовленной текстуры при увеличении. */
+        resampling?: 'linear' | 'nearest';
+    };
+}
+/** Гипсометрия плоским слоем — `color-relief` MapLibre: цвет пикселя по высоте из `raster-dem`. */
+interface ColorReliefLayerSpec extends DemLayerBase {
+    type: 'color-relief';
+    paint: {
+        /** Цвет по высоте: `interpolate` от `["elevation"]` (`color-relief-color`). */
+        color?: unknown;
+        opacity?: Interpolated<number>;
+        resampling?: 'linear' | 'nearest';
+    };
+}
+/** Слои по источнику высот (этап e): без фич и без плана воркера, как растр. */
+type DemLayerSpec = HillshadeLayerSpec | ColorReliefLayerSpec;
+/** Слой по источнику высот (`hillshade`, `color-relief`) — этап (e). */
+declare function isDemLayer(layer: {
+    type: string;
+}): layer is DemLayerSpec;
+interface FillLayerSpec extends LayerBase {
+    type: 'fill';
+    paint: MaterialPaint & {
+        /** Цвет заливки; `{ from, property }` — «как у такого-то слоя» (плоские здания берут `roofColor`). */
+        color: Interpolated<string> | ColorFrom;
+        opacity?: Interpolated<number>;
+        /**
+         * Сглаживающий контур в 1 пиксель по краю заливки — `fill-antialias` MapLibre. Без поля — нет
+         * (облик osmgl); импортёр стиля MapLibre ставит `true`, как умолчание спецификации.
+         */
+        antialias?: boolean;
+        /** Цвет контура (`fill-outline-color`); без поля — цвет заливки. Бывает по фиче. */
+        outlineColor?: Interpolated<string>;
+        /** Этап (d): прозрачность слоя ЦЕЛИКОМ (`fill-layer-opacity`) — без накопления на перекрытиях. */
+        layerOpacity?: Interpolated<number>;
+        /** Сдвиг заливки на экране, пиксели (`fill-translate`). */
+        translate?: Interpolated<[number, number]>;
+        /** `map` — сдвиг поворачивается с картой, `viewport` — по экрану (`fill-translate-anchor`). */
+        translateAnchor?: 'map' | 'viewport';
+        /** Узор из спрайта (`fill-pattern`): имя картинки или выражение (по зуму и по фиче). */
+        pattern?: unknown;
+    };
+    /** Порядок фич внутри слоя (`fill-sort-key`): меньший рисуется раньше. Бывает по фиче. */
+    sortKey?: unknown;
+}
+interface LineLayerSpec extends LayerBase {
+    type: 'line';
+    /**
+     * СЕТЬ, внутри которой порядок отрисовки решают не слои, а уровни пересечения.
+     *
+     * Все дорожные слои стиля — обводки, полотна, тень моста — помечаются одним именем (`roads`), и
+     * рисуются они не подряд, а по уровням: сначала вся сеть уровня −1 (тоннели), потом вся сеть
+     * земли, потом вся сеть эстакад. Поэтому мост со своей тенью и обводкой ложится ЦЕЛИКОМ поверх
+     * улицы под ним, какого бы класса та ни была, — а не «полотно моста поверх, обводка под».
+     *
+     * Так же устроено у Яндекса: у каждого дорожного слоя `line-network: "roads"` и
+     * `line-z-level: ["get","z_level"]`. Уровень фичи считается по `generators/level`.
+     *
+     * Сеть рисуется целиком НА МЕСТЕ ПЕРВОГО своего слоя в стиле; порядок внутри уровня — обычный,
+     * по порядку слоёв.
+     */
+    network?: string;
+    /**
+     * УСТУПИТЬ МЕСТО ПОДРОБНОМУ СЛОЮ: id слоя-ПОВЕРХНОСТИ (`surface`), который рисует то же самое
+     * точнее.
+     *
+     * Так живёт пара «линия дороги — асфальт»: у асфальта свой набор тайлов (с z15), и пока его тайл
+     * не приехал, на его месте не должно быть пусто. Линия поэтому не выключается по зуму, а рисуется
+     * везде, КРОМЕ квадратов, в которых подробный слой уже нарисован: там её закрывает трафарет
+     * (`PAINTED_BIT`, см. `layers/renderer.ts`). Так же ведёт себя Baidu: грубая карта видна сразу, и
+     * подробная ложится на неё кусками, по мере прихода (`useThumbData`).
+     *
+     * Уступка идёт ПО КВАДРАТУ ТАЙЛА, а не по пикселю асфальта. Линия дороги шире асфальта (её
+     * ширина — приём картографии в пикселях, а не размер сооружения), и маска по самому асфальту
+     * оставила бы вдоль каждой кромки полоску старой линии.
+     *
+     * Заодно это чинит дальний план наклонённой карты: подробный слой там гаснет по зуму детализации
+     * (`Transform.detailZoom`), квадратов не размечает — и линия остаётся. Раньше линию гасили
+     * `maxzoom` по зуму КАМЕРЫ, и при сильном наклоне дорога вдали пропадала совсем: асфальта уже нет,
+     * линии ещё нет.
+     */
+    yieldTo?: string;
+    /**
+     * ЛИНИЮ ЗАКРЫВАЕТ ТО, ЧТО НАД НЕЙ: краска на асфальте прячется под эстакадой, как в жизни.
+     *
+     * Поднятые линии рисуются без теста глубины: краска лежит на своём асфальте в сантиметрах, и такой
+     * зазор буфер глубины не различает — линия мерцала бы на собственном полотне (см. проход поднятых
+     * линий в `layers/renderer.ts`). Поэтому краска улицы под эстакадой проступала сквозь настил.
+     *
+     * С этим флагом линия проходит тест глубины, а её глубина сдвинута к камере на долю расстояния
+     * (`DEPTH_NUDGE`): своё полотно в сантиметрах ниже её не закрывает, а настил в метрах над ней —
+     * закрывает. Записи глубины нет, как и у всех поднятых линий. На шаре и в текстуре рельефа флаг
+     * не действует: там глубины для такого сравнения нет.
+     */
+    depthTest?: boolean;
+    /**
+     * ЛИНИЯ В ОЧЕРЕДИ ПОВЕРХНОСТЕЙ: поднятая линия рисуется не после ВСЕХ поверхностей, а на СВОЁМ МЕСТЕ
+     * среди них, по порядку слоёв стиля.
+     *
+     * Поднятые линии идут отдельным проходом после поверхностей и без теста глубины — дорога лежит на газоне,
+     * а не спорит с ним за глубину. Но так же она ложится и на асфальт полотна, а тротуар поверх проезжей
+     * части — это пунктир через зебру. С флагом линия рисуется в очереди поверхностей: поверхности ДО неё
+     * (земля, газон, двор) — под ней, поверхности ПОСЛЕ (асфальт полотна, детальных дорог) закрывают её своей
+     * глубиной. Ровно как у стиля MapLibre, где пешеходная линия лежит под линией дороги по порядку слоёв.
+     *
+     * Рисуется без теста и без записи глубины, как поднятая линия (`depthTest` здесь не действует: всё, что
+     * может её закрыть, идёт в очереди позже). В сеть (`network`) такая
+     * линия не входит: место ей задаёт порядок стиля, а не уровень пересечения. Действует только у поднятой
+     * линии (`elevation > 0`); у плоской место и так в плоском проходе. На рельефе — как прочие поднятые
+     * (уезжает в текстуры тайлов).
+     */
+    surfaceOrder?: boolean;
+    paint: MaterialPaint & {
+        /** Цвет линии; `{ from, darken }` — «как у такого-то слоя, только темнее» (см. `ColorFrom`). */
+        color: Interpolated<string> | ColorFrom;
+        /** Ширина в ЭКРАННЫХ пикселях: линия не толстеет с приближением к камере. */
+        width: Interpolated<number>;
+        opacity?: Interpolated<number>;
+        /** Сдвиг поперёк линии в пикселях — для обочин и параллельных путей. */
+        offset?: Interpolated<number>;
+        /**
+         * РАЗМЫТИЕ КРАЯ в пикселях: край растягивается на столько вместо обычного полупикселя.
+         *
+         * Нужно тени моста. У Яндекса тени нет вовсе как отдельной сущности — там на каждый мост
+         * рисуется ВОСЕМЬ вложенных контуров (`road-sd-shadow-1…8__bridge`), каждый с прозрачностью
+         * 0.03–0.08, и их сумма изображает размытие. Это обход отсутствующего в их движке размытия:
+         * восемь слоёв в стиле и восемь вызовов отрисовки на тайл ради градиента.
+         *
+         * У нас край линии и так вырезает фрагментный шейдер по расстоянию до оси — растянуть переход
+         * стоит одного юниформа. Поэтому тень моста здесь ОДИН слой с честным мягким краем.
+         */
+        blur?: Interpolated<number>;
+        /**
+         * Уровень полотна в МЕТРАХ — для рельефных вариантов карты: дорожка внутри
+         * приподнятого парка должна лежать на нём, а не тонуть под ним. Меняется
+         * юниформом, геометрия не пересобирается.
+         */
+        elevation?: Interpolated<number>;
+        /**
+         * ПРИЗРАК: с какой прозрачностью линия просвечивает СКВОЗЬ ЗДАНИЯ (0 — не
+         * просвечивает вовсе). Отдельный проход после объёма и с ПЕРЕВЁРНУТОЙ
+         * проверкой глубины, поэтому в него попадают ровно те куски, что ушли за
+         * дом, — видимые не рисуются дважды и яркость не удваивается. То же, что
+         * `ghostOpacity` у рантайм-объектов: в плотной застройке от ленты пробок
+         * иначе остаются обрывки, и куда идёт улица — непонятно.
+         */
+        ghostOpacity?: Interpolated<number>;
+        /**
+         * Пунктир: `[штрих, пропуск]` в пикселях. Рисунок идёт непрерывно вдоль
+         * всей линии, а не начинается заново на каждом отрезке.
+         */
+        /**
+         * Брать ширину ИЗ ДАННЫХ (атрибут width тайла, в метрах), а не из `width` в пикселях.
+         *
+         * Нужно дорогам: у каждой своя ширина, и полотно обязано быть объектом местности. Там, где
+         * атрибута в тайле нет, работает обычная `width` — поэтому флаг безопасно включить заранее.
+         */
+        widthFromData?: boolean;
+        /**
+         * Прибавка к ширине из данных, ПИКСЕЛИ. Нужна обводке: она обязана быть шире полотна, иначе
+         * при одинаковой ширине из данных её попросту не видно.
+         */
+        widthExtra?: Interpolated<number>;
+        dashArray?: [number, number];
+        /**
+         * Пунктир В ШИРИНАХ ЛИНИИ — как `line-dasharray` у MapLibre: [штрих, пробел] множителями
+         * текущей ширины. Толще линия — длиннее штрих, поэтому пунктир на любом зуме одинаков по виду.
+         *
+         * Этап (c): любой длины `[штрих, пробел, штрих, …]` и выражением (по зуму — смена рисунка со
+         * смешением, по фиче — свой у фичи), как `line-dasharray` MapLibre. Постоянная пара рисуется
+         * прежним путём шейдера.
+         */
+        dashWidths?: [number, number] | number[] | unknown[];
+        /**
+         * Зазор посередине линии в пикселях — `line-gap-width` у MapLibre. Ненулевой превращает линию
+         * в «трубу»: две полосы шириной `width` по краям зазора. Так рисуются обводки мостов и тоннелей.
+         */
+        gapWidth?: Interpolated<number>;
+        /**
+         * Концы и стыки линии — `line-cap`, `line-join`, `line-miter-limit` MapLibre. Без них — прежняя
+         * капсула (скругление везде). Заданные включают свой вариант программы и данные стыков в вершине.
+         */
+        lineCap?: 'butt' | 'round' | 'square';
+        lineJoin?: 'bevel' | 'round' | 'miter';
+        miterLimit?: 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];
+        /**
+         * Стрелки направления (односторонние улицы). Рисуются аналитически
+         * шевронами поверх полотна — без текстуры, поэтому чёткие на любом зуме.
+         */
+        arrow?: boolean;
+        /**
+         * Каким рисунком показывать направление: `chevron` — «птичка» поверх
+         * полотна (односторонние улицы), `head` — сплошное остриё во всю ширину
+         * ленты (пробки: так это рисует сервер и так же выглядит у Яндекса).
+         */
+        arrowStyle?: 'chevron' | 'head' | 'headOnly' | 'dash';
+        /**
+         * Просвет между стрелками-штрихами, пиксели (`arrowStyle: 'dash'`). Из него
+         * и `arrowPeriod` выводится длина самой стрелки.
+         */
+        arrowGap?: Interpolated<number>;
+        /**
+         * Насколько раздуть фигуру стрелки, пиксели. Обводка делается ВТОРЫМ слоем
+         * с тем же набором чисел и ненулевым раздутием: у знакового расстояния это
+         * сдвиг порога, поэтому обводка получается равномерной и со скруглёнными
+         * краями.
+         */
+        arrowOutline?: Interpolated<number>;
+        /** Полуширина древка стрелки-штриха, пиксели. */
+        arrowShaft?: Interpolated<number>;
+        /** Полуширина головы у основания, пиксели. Больше древка — иначе не стрелка. */
+        arrowHead?: Interpolated<number>;
+        arrowColor?: Interpolated<string>;
+        /** Расстояние между стрелками и их размер, пиксели. */
+        arrowPeriod?: Interpolated<number>;
+        arrowSize?: Interpolated<number>;
+        /** Этап (d): прозрачность слоя ЦЕЛИКОМ (`line-layer-opacity`) — без накопления на перекрытиях. */
+        layerOpacity?: Interpolated<number>;
+        /** Сдвиг линии на экране, пиксели (`line-translate`). */
+        translate?: Interpolated<[number, number]>;
+        /** `map` — сдвиг поворачивается с картой, `viewport` — по экрану (`line-translate-anchor`). */
+        translateAnchor?: 'map' | 'viewport';
+        /**
+         * `line-round-limit`: круглый стык с поворотом положе этого (длина острия в полуширинах)
+         * рисуется острым. Только при `lineJoin: round`; без поля — 1.05, как у MapLibre.
+         */
+        roundLimit?: number;
+        /** Узор из спрайта вдоль линии (`line-pattern`): имя картинки или выражение. */
+        pattern?: unknown;
+        /**
+         * Этап (x): цвет вдоль линии (`line-gradient`) — выражение от `["line-progress"]`, доли длины
+         * всей линии. Главнее `color`; доли знает только GeoJSON-источник с `lineMetrics: true`.
+         */
+        gradient?: unknown;
+    };
+    /** Порядок фич внутри слоя (`line-sort-key`): меньший рисуется раньше. Бывает по фиче. */
+    sortKey?: unknown;
+}
+interface FillExtrusionLayerSpec extends LayerBase {
+    type: 'fill-extrusion';
+    paint: {
+        /** Цвет стен; `{ from }` — «как у такого-то слоя» (так красятся этажи под цвет дома). */
+        color: Interpolated<string> | ColorFrom;
+        /**
+         * Высота и низ стены в метрах — как `fill-extrusion-height/base` у MapLibre: число или
+         * выражение по фиче. Не заданы — берутся из свойств тайла (`render_height`, `height`, этажи).
+         */
+        height?: unknown;
+        base?: unknown;
+        roofColor?: Interpolated<string>;
+        opacity?: Interpolated<number>;
+        /** Затенение у основания, 0..1. */
+        aoStrength?: Interpolated<number>;
+        /** Разброс оттенка между зданиями, 0..1 — чтобы квартал не был однотонным. */
+        tintVariation?: Interpolated<number>;
+        /**
+         * Рисунок фасада и кровли, 0..1. Ноль — гладкие стены (так выглядели здания
+         * до появления фасадов), единица — окна, швы и фальцы. Считается процедурно,
+         * текстур не требует и на мелких зумах гасится сам.
+         */
+        facadeDetail?: Interpolated<number>;
+        /** Цвет остекления. */
+        windowColor?: Interpolated<string>;
+        /** Цвет переплёта и откосов. */
+        windowFrameColor?: Interpolated<string>;
+        /**
+         * Разброс тона и градиента стекла, 0..1 (по умолчанию 1).
+         *
+         * Свой тон у каждого окна и отражение неба по высоте дают фасаду вторую фактуру. На синем
+         * остеклении это жизнь, а на стекле в тон стене — пятна: часть окон темнее стены, часть
+         * светлее. Ноль оставляет ровно середину.
+         */
+        windowVariation?: Interpolated<number>;
+        /**
+         * Сила швов на стенах и кровлях, 0..1 (по умолчанию 1).
+         *
+         * Швы делают дом сборным. Но там, где стена и стекло одного тона, они остаются единственным
+         * контрастом на фасаде, и дом читается сеткой линий, а не объёмом.
+         */
+        seamStrength?: Interpolated<number>;
+        /**
+         * ЛЁД, 0..1. Ноль — обычный матовый дом.
+         *
+         * Настоящий лёд выдают две вещи, и обе видно на 3D-домах Baidu: кромка светится тем сильнее,
+         * чем острее угол взгляда к грани (у стекла и льда так отражается небо), и низ стены светлее
+         * верха — свет уходит в толщу и рассеивается. Ни то, ни другое не задать цветом: это зависит
+         * от камеры и от высоты точки, то есть считается в шейдере.
+         *
+         * Цвет при этом остаётся за темой: ручка только добавляет блик и градиент поверх него.
+         */
+        ice?: Interpolated<number>;
+        /**
+         * ОТРАЖЕНИЕ ДОМОВ В СТЕКЛЯННОЙ ЗЕМЛЕ, 0..1 — сила зеркала. Ноль — отражения нет.
+         *
+         * Работает только с z18 (`REFLECTION_MIN_ZOOM` в `layers/renderer`) и без рельефа: это второй
+         * проход по всем домам кадра, и на общем плане он удвоил бы самую дорогую геометрию.
+         */
+        reflection?: Interpolated<number>;
+        /**
+         * БЛЕСК СТЕКЛЯННОЙ ЗЕМЛИ, 0..1: отражение неба по Френелю — чем дальше и чем более скользящий
+         * взгляд, тем сильнее земля берёт цвет горизонта. Работает на любом зуме (это один квад), в
+         * отличие от отражения домов.
+         */
+        reflectionGloss?: Interpolated<number>;
+        /**
+         * ДОМ КАК СТЕКЛО (по образцу Baidu) — только вместе с `ice`.
+         *
+         * `glassTint` — цвет стекла у земли (у Baidu бирюзовый), `glassTintAmount` — насколько (0..1),
+         * `glassTintHeight` — на какой высоте, метры, цвет растворяется: низ цветной, верх светлый, как
+         * у Baidu. Кровля светлее всего — оттенка на ней одна десятая. `glassRim` — светлая
+         * кромка по Френелю: грань, повёрнутая к взгляду ребром, светится, как край стекла.
+         */
+        glassTint?: Interpolated<string>;
+        glassTintAmount?: Interpolated<number>;
+        glassTintHeight?: Interpolated<number>;
+        glassRim?: Interpolated<number>;
+        /**
+         * Насколько верх дома ярче низа, 0..1 — в СВОЁМ цвете, без подмеса белого (0.1 — на 10 %).
+         * Кровля — наравне с верхом стены. Только с `glassTintAmount`.
+         */
+        glassTopLight?: Interpolated<number>;
+        /**
+         * Градиент по плоской крыше, 0..1: ближний к камере край — в тон стекла, дальний — светлый.
+         * Чтобы крыши стеклянного квартала не сливались в одно поле. Только с `glassTintAmount`.
+         */
+        glassRoofGradient?: Interpolated<number>;
+        /**
+         * Доля светящихся окон, 0..1 — для ночных тем. Какие именно окна горят,
+         * решает хеш ячейки, поэтому при движении камеры свет не «бегает».
+         */
+        windowGlow?: Interpolated<number>;
+        /** Высота этажа в метрах: шаг сетки окон. */
+        floorHeight?: Interpolated<number>;
+        /**
+         * На сколько метров стекло утоплено от плоскости стены (по умолчанию 0.18).
+         * Край проёма кладёт на утопленное стекло тень со стороны, где нет солнца, —
+         * именно она и читается как глубина. Ноль возвращает плоское окно.
+         */
+        windowRecess?: Interpolated<number>;
+        /** Глубина тени откоса, 0..1. */
+        windowRecessShade?: Interpolated<number>;
+        /**
+         * Высота в метрах, на которой цокольное затемнение сходит на нет (по умолчанию 4).
+         * Затемнение считается для ВСЕЙ стены, включая скруглённые углы и фронтоны.
+         */
+        plinthHeight?: Interpolated<number>;
+        /** Сила цокольного затемнения у самой земли, 0..1. */
+        plinthShade?: Interpolated<number>;
+        /**
+         * Разброс цвета СКАТНЫХ кровель, 0..1. Тон берётся из хеша здания, яркость
+         * остаётся от темы — иначе терракота всплыла бы посреди ночной карты.
+         */
+        roofVariation?: Interpolated<number>;
+        /** Множитель высоты (например, 0 — «сложить» здания). */
+        heightScale?: Interpolated<number>;
+        /**
+         * Градиент стены по высоте — `fill-extrusion-vertical-gradient` MapLibre. Работает только со
+         * светом MapLibre (`lighting: 'maplibre'`); не задан — включён, как и у MapLibre.
+         */
+        verticalGradient?: boolean;
+        /** Сдвиг объёма по земле, пиксели экрана (`fill-extrusion-translate`). */
+        translate?: Interpolated<[number, number]>;
+        /** `map` — сдвиг поворачивается с картой, `viewport` — по экрану. */
+        translateAnchor?: 'map' | 'viewport';
+        /** Узор из спрайта на стенах и крыше (`fill-extrusion-pattern`). */
+        pattern?: unknown;
+    };
+}
+/**
+ * Подписи и иконки.
+ *
+ * Иконка и текст рисуются ОДНОЙ программой из одного SDF-атласа, поэтому
+ * `color`/`haloColor` применяются к ним одинаково. Цена этого решения —
+ * иконки силуэтные (одноцветные): раскрасить пиктограмму в несколько цветов
+ * таким способом нельзя.
+ */
+/** Якорь подписи или значка — какая точка бокса стоит на объекте (`text-anchor` у MapLibre). */
+type SymbolAnchor = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+interface SymbolLayerSpec extends LayerBase {
+    type: 'symbol';
+    layout?: {
+        /** Шаблон подписи `"{name}"` либо список запасных: первый непустой побеждает. */
+        textField?: string | string[];
+        /** Шаблон имени иконки, например `"{class}"`. */
+        iconImage?: string | string[];
+        /** Кегль подписи в CSS-пикселях. */
+        textSize?: Interpolated<number>;
+        /**
+         * Сокращать родовое слово в названии: «улица Истаравшан» → «ул. Истаравшан».
+         *
+         * Для подписи вдоль дороги это не косметика, а вопрос «поместится или нет»: родовое слово
+         * занимает до половины строки. Так подписывают улицы Яндекс и 2ГИС — см. `text/abbreviate`.
+         */
+        abbreviate?: boolean;
+        /**
+         * Регистр подписи — как `text-transform` у MapLibre. Меняется в воркере вместе с сокращением:
+         * под этот текст раскладка и ищет место.
+         */
+        textTransform?: 'none' | 'uppercase' | 'lowercase' | unknown[];
+        /**
+         * Гарнитура подписи — имя набора глифов на сервере шрифтов, как `text-font` у MapLibre
+         * (`Noto Sans Bold`). Не задана — общий шрифт карты (`Noto Sans Regular`).
+         */
+        textFont?: string;
+        /**
+         * Разрядка букв в долях кегля — как `text-letter-spacing` у Mapbox.
+         *
+         * Не задана — считается от толщины обводки: та раздувает каждую букву в сторону соседней, и без
+         * разрядки плотное слово читается слипшимся пятном (см. `letterSpacingFor`).
+         */
+        letterSpacing?: Interpolated<number>;
+        /** Размер иконки в CSS-пикселях. */
+        iconSize?: Interpolated<number>;
+        /**
+         * Зазор между иконкой и текстом в пикселях — по горизонтали при боковой
+         * раскладке, по вертикали при верхней. Задаётся на слой: у значка над
+         * подписью уместен зазор в пару пикселей, у бокового — заметно больше.
+         */
+        iconTextGap?: number;
+        /**
+         * Где стоит иконка относительно подписи: `top` — над ней по центру (так у
+         * Mapbox Standard и у Яндекса: значок ровно над точкой объекта), `left` и
+         * `right` — сбоку, плотнее по вертикали, `behind` — плашка под подписью.
+         *
+         * `auto` — ПЕРЕБОР сторон: подпись справа от значка, занято — слева, занято — под ним. Так
+         * подписей на плотной карте помещается заметно больше: подпись, которой не нашлось места с
+         * одной стороны, находит его с другой вместо того, чтобы пропасть. Работает только с
+         * `iconFrame: 'pin'` — значок при этом остаётся остриём на объекте.
+         */
+        iconPlacement?: 'top' | 'left' | 'right' | 'behind' | 'auto';
+        /**
+         * Как ставится подпись: `point` — горизонтально у точки привязки (по
+         * умолчанию), `line` — вдоль линии объекта, изгибаясь по ней.
+         *
+         * Вдоль линии подпись читается как часть дороги, а не как ярлык рядом с
+         * ней; так подписаны улицы во всех больших картах. Значка при таком
+         * размещении нет: он не поворачивается вместе с текстом и выглядел бы
+         * приклеенным сбоку.
+         */
+        textPlacement?: 'point' | 'line';
+        /**
+         * Как подпись вдоль линии стоит относительно наклона карты.
+         *
+         * `viewport` (по умолчанию) — буквы обращены к экрану и при наклоне не сжимаются: читается
+         * лучше всего. `map` — буквы ЛЕЖАТ НА ДОРОГЕ и в наклоне сжимаются в перспективе вместе с ней,
+         * как `text-pitch-alignment: map` у MapLibre (у `symbol-placement: line` это его умолчание).
+         * Только для `textPlacement: 'line'`.
+         */
+        textPitchAlignment?: 'viewport' | 'map';
+        /**
+         * Шаг повторения подписи вдоль линии, экранные пиксели (`textPlacement:
+         * 'line'`). По умолчанию 250 — как `symbol-spacing` у Mapbox.
+         *
+         * Длинная улица подписывается несколько раз: название, поставленное один
+         * раз, находится только в одном месте, и на соседнем экране та же улица
+         * снова безымянная. Ноль — ставить ровно один раз.
+         */
+        symbolSpacing?: Interpolated<number>;
+        /** Смещение подписи от точки привязки, CSS-пиксели. */
+        offset?: [number, number];
+        /** Максимум символов в строке до переноса. */
+        maxLineChars?: number;
+        /**
+         * РАСКЛАДКА ПО ЯКОРЯМ, КАК У MapLibre. Заданный `textAnchor` или `iconAnchor` включает её вместо
+         * нашей блочной (`iconPlacement`): значок и подпись ставятся НЕЗАВИСИМО — каждый своим якорем к
+         * точке объекта, подпись ещё и со смещением `textOffset` в em (кеглях). Так устроены все стили
+         * MapLibre: значок POI стоит центром на объекте, подпись — верхним краем под ним.
+         */
+        textAnchor?: SymbolAnchor | unknown[];
+        /** Смещение подписи от точки в em (× `textSize`), `text-offset` у MapLibre. */
+        textOffset?: [number, number] | unknown[];
+        iconAnchor?: SymbolAnchor | unknown[];
+        /**
+         * ── РАСКЛАДКА MapLibre (`placementMode: maplibre`), этап b формата v2 ──
+         * Поля ниже читает только раскладка по якорям; у блочной раскладки свои правила.
+         */
+        /** Смещение значка в пикселях значка (× `icon-size`), `icon-offset`. */
+        iconOffset?: [number, number] | unknown[];
+        /** Поворот подписи в градусах по часовой, `text-rotate`. */
+        textRotate?: Interpolated<number>;
+        /** Межстрочный интервал в em, `text-line-height` (по умолчанию 1.2). */
+        textLineHeight?: Interpolated<number>;
+        /** Выравнивание строк многострочной подписи, `text-justify`; `auto` — по якорю. */
+        textJustify?: 'auto' | 'left' | 'center' | 'right' | unknown[];
+        /** Якоря-кандидаты: перебираются по порядку, пока подпись не встанет, `text-variable-anchor`. */
+        textVariableAnchor?: SymbolAnchor[];
+        /** Якоря-кандидаты со своими смещениями (em): `[якорь, [x, y], якорь, [x, y], …]`, `text-variable-anchor-offset`. */
+        textVariableAnchorOffset?: unknown[];
+        /** Смещение подписи от точки по радиусу в em при переборе якорей, `text-radial-offset`. */
+        textRadialOffset?: Interpolated<number>;
+        /** Значок растягивается под подпись, `icon-text-fit`. */
+        iconTextFit?: 'none' | 'width' | 'height' | 'both';
+        /** Поля вокруг подписи при растяжке значка, пиксели `[верх, право, низ, лево]`, `icon-text-fit-padding`. */
+        iconTextFitPadding?: [number, number, number, number];
+        /** Перекрытие значка отдельно от подписи, `icon-allow-overlap` (без поля — как `allowOverlap`). */
+        iconAllowOverlap?: boolean;
+        /** Значок не занимает места отдельно от подписи, `icon-ignore-placement` (без поля — как `ignorePlacement`). */
+        iconIgnorePlacement?: boolean;
+        /**
+         * Этап (z): `text-overlap: cooperative` — подпись встаёт поверх `always` и других `cooperative`,
+         * но не поверх `never`. `always`/`never` — по-прежнему `allowOverlap`. Только раскладка MapLibre.
+         */
+        textOverlap?: 'cooperative';
+        /** То же для значка, `icon-overlap: cooperative`. */
+        iconOverlap?: 'cooperative';
+        /**
+         * Этап (z): режимы набора по порядку (`text-writing-mode`): `vertical` ставит столбцом подпись со
+         * знаками «прямой» ориентации (иероглифы), `horizontal` — строкой. Только точка раскладки MapLibre.
+         */
+        textWritingMode?: ('horizontal' | 'vertical')[];
+        /** Подпись необязательна: не встала — значок остаётся один, `text-optional`. */
+        textOptional?: boolean;
+        /** Значок необязателен: не встал — подпись остаётся одна, `icon-optional`. */
+        iconOptional?: boolean;
+        /** Поле вокруг бокса подписи, пиксели, `text-padding` (по умолчанию 2). */
+        textPadding?: Interpolated<number>;
+        /** Поле вокруг бокса значка, пиксели: число или `[верх, право, низ, лево]` CSS, `icon-padding`. */
+        iconPadding?: number | number[] | unknown[];
+        /** Порядок раскладки внутри слоя: меньший ключ ставится раньше и рисуется ниже, `symbol-sort-key`. */
+        symbolSortKey?: Interpolated<number>;
+        /** Порядок наложения внутри слоя, `symbol-z-order`. */
+        symbolZOrder?: 'auto' | 'viewport-y' | 'source';
+        /**
+         * Этап (x): высота точечного символа над опорой, метры (`symbol-height-offset`); по зуму и по фиче.
+         * Только раскладка MapLibre и только у точки (вдоль линии — не действует, как у MapLibre).
+         */
+        symbolHeightOffset?: unknown;
+        /** От чего мерить высоту: `ground` — от рельефа под символом, `absolute` — от нуля (`symbol-height-anchor`). */
+        symbolHeightAnchor?: 'ground' | 'absolute';
+        /** Поворот подписи у точки: `map` — вместе с картой, `viewport`/`auto` — к экрану, `text-rotation-alignment`. */
+        textRotationAlignment?: 'auto' | 'map' | 'viewport' | 'viewport-glyph';
+        /** То же для значка у точки, `icon-rotation-alignment`. */
+        iconRotationAlignment?: 'auto' | 'map' | 'viewport';
+        /** Подпись «по карте» не переворачивается вверх ногами, `text-keep-upright` (по умолчанию да). */
+        textKeepUpright?: boolean;
+        /** Этап (z): значок вдоль линии, повёрнутый по ней, разворачивается «головой вверх», `icon-keep-upright` (по умолчанию нет). */
+        iconKeepUpright?: boolean;
+        /**
+         * Размер значка МНОЖИТЕЛЕМ его натурального размера — `icon-size` у MapLibre. Натуральный —
+         * размер картинки спрайта в CSS-пикселях (пиксели / `pixelRatio`). Задан — `iconSize` не читается.
+         */
+        iconScale?: Interpolated<number>;
+        /** Перенос строк по ширине в em — `text-max-width` у MapLibre (по умолчанию у них 10). */
+        textMaxWidth?: Interpolated<number>;
+        /**
+         * Вдоль линии (`textPlacement: 'line'`) подпись ставится НЕ изгибом по дороге, а горизонтально
+         * в узлах сетки — как щит трассы у MapLibre (`text-rotation-alignment: viewport`).
+         */
+        lineUpright?: boolean;
+        /** Значок вдоль линии повёрнут по дороге (`icon-rotation-alignment: map`) — стрелка односторонней. */
+        iconAlongLine?: boolean;
+        /**
+         * Значок ЛЕЖИТ на карте (`icon-pitch-alignment: map`): при наклоне сплющивается вместе с землёй.
+         * Пока — у значков вдоль линии без подписи (стрелки направления).
+         */
+        iconPitchAlignment?: 'map' | 'viewport';
+        /**
+         * Места вдоль линии (`textPlacement: 'line'`, значки и подписи «стоя») — по алгоритму MapLibre:
+         * в координатах тайла, с переувеличением и срезом по тайлу (`text/maplibre-anchors.ts`). Без поля —
+         * наша сетка по земле. Ставит импортёр стилей MapLibre.
+         */
+        lineAnchors?: 'maplibre';
+        /**
+         * Раскладка коллизий КАК У MapLibre: порядок — верхний слой первым, тайлы по их правилу, внутри
+         * тайла по порядку символов, без надбавки «уже стоявшим»; подпись вдоль линии занимает место
+         * цепочкой кругов. Ставит импортёр стилей MapLibre.
+         */
+        placementMode?: 'maplibre';
+        /** Одно место в середине линии (`symbol-placement: line-center`); только с `lineAnchors`. */
+        lineCenter?: boolean;
+        /** Наибольший излом под подписью вдоль линии, градусы (`text-max-angle`, по умолчанию 45). */
+        textMaxAngle?: Interpolated<number>;
+        /**
+         * Что делать с незнакомым именем значка: `dot` (по умолчанию) — нейтральная точка, чтобы объект
+         * не пропал; `skip` — не рисовать значок вовсе, как MapLibre (подпись при этом остаётся).
+         */
+        iconMissing?: 'dot' | 'skip';
+        /** Значок — из встроенного набора движка, даже при `iconMissing: 'skip'` (круги слоя `circle`). */
+        iconBuiltin?: boolean;
+        /** Не участвовать в коллизиях (подпись всегда видна). */
+        allowOverlap?: boolean;
+        /**
+         * НЕ ЗАНИМАТЬ МЕСТА У ОСТАЛЬНЫХ, но самому уступать занятому.
+         *
+         * Половина `allowOverlap`, как `icon-ignore-placement` у Mapbox. Нужна фоновым подписям —
+         * названиям улиц и номерам домов: они рисуются там, где свободно, но не вытесняют собой
+         * значки и названия мест. Без этого на плотной застройке номера домов съедают POI, а их
+         * самих никто не читает.
+         */
+        ignorePlacement?: boolean;
+        /**
+         * ГРУППА РАСКЛАДКИ: с кем подпись всё-таки делит место.
+         *
+         * Работает в паре с `ignorePlacement`. Сам по себе он снимает подпись с учёта полностью — и
+         * тогда названия улиц ложатся поверх номеров домов и друг друга: каждая уступает значкам, но
+         * ни одна не знает о соседке. Общая группа возвращает их в коллизии между собой, оставляя
+         * невидимыми для всех остальных слоёв.
+         *
+         * Значение — любая строка, важно лишь совпадение: слои с одной строкой расталкивают друг
+         * друга, с разными — не видят.
+         */
+        placementGroup?: string;
+        /**
+         * Дополнительное поле вокруг подписи в пикселях — разрежает однотипные
+         * метки. Номер трассы иначе повторяется на каждом отрезке: перекрытия нет,
+         * а на карте это рябь из одинаковых плашек.
+         */
+        collisionPadding?: number;
+        /** Добавка к приоритету слоя при коллизиях. */
+        priority?: number;
+        /**
+         * Круглая подложка под значком — как у Яндекса и в Mapbox Standard: значок
+         * стоит на кружке фона с тонкой рамкой и читается на любой заливке, а не
+         * только на светлой земле.
+         *
+         * Это ОТДЕЛЬНЫЙ значок под иконкой, а не обводка: обводка у нас общая с
+         * текстом (одна программа), и «жирный контур» вокруг пиктограммы выглядит
+         * грязно, а кружок — фигура со своей заливкой и своей рамкой.
+         *
+         * `pin` — та же подложка, но с остриём вниз. Отличие не в рисунке, а в ТОЧКЕ ПРИВЯЗКИ: у
+         * кружка на объекте стоит его середина, у булавки — остриё. Поэтому с булавкой подпись можно
+         * увести вбок (`iconPlacement: 'left'`), не теряя, к чему она относится: показывает не значок
+         * целиком, а его кончик. Так устроены POI у Baidu Maps.
+         */
+        iconFrame?: 'circle' | 'pin' | 'none';
+        /** Диаметр подложки относительно значка. */
+        iconFrameScale?: number;
+        /**
+         * СОСТАВНОЙ ЗНАЧОК: силуэты, нарисованные один поверх другого в одной точке.
+         *
+         * Атлас значков у нас общий с буквами и одноканальный — из него приходит форма, а цвет
+         * ставится на весь поток вершин сразу. Разноцветной пиктограммы одной картинкой поэтому не
+         * получится, и она собирается из частей: у светофора это корпус, три лампы и мачта. Части
+         * перечисляются СНИЗУ ВВЕРХ (первая ложится под остальные), цвета им раздаёт
+         * `paint.partColors`, обводку — `paint.partHaloWidths`.
+         *
+         * Совмещать части координатами не нужно: у них общий viewBox, поэтому и общий растр, и
+         * рисуются они в один и тот же прямоугольник. Сам `iconImage` при этом обязателен — по нему
+         * считается размер и место в коллизиях, и он же остаётся одноцветным запасным вариантом, пока
+         * части не догрузились.
+         */
+        iconParts?: string[];
+        /**
+         * Свойство фичи с поворотом значка в градусах (0 — север, по часовой).
+         * Значок доворачивается на поворот камеры, поэтому стрелка у входа смотрит
+         * внутрь дома при любом развороте карты.
+         */
+        iconRotate?: string | number | unknown[];
+        /**
+         * Показывать слой ТОЛЬКО у выбранного здания (`highlight`).
+         *
+         * Так устроены входы: висеть у каждого дома они не должны — это шум, а при
+         * выборе дома нужны сразу. Привязка геометрическая, по контуру выбранного
+         * здания: id зданий в тайлах и id в базе живут в РАЗНЫХ пространствах
+         * (тайлы собраны планетайлером, правки — своей схемой), складывать их по id
+         * нечем.
+         */
+        showFor?: 'highlight';
+        /**
+         * Где живёт значок: `screen` (по умолчанию) — лицом к пользователю, как
+         * обычная подпись; `map` — НА ПОВЕРХНОСТИ карты.
+         *
+         * У `map` значок рисуется не картинкой из атласа, а геометрией на земле:
+         * стрелка входа поворачивается вместе с картой, уходит в перспективу при
+         * наклоне и прячется за домом, который стоит перед ней. Так это выглядит у
+         * Яндекса, и иначе она не читается как «зайти отсюда». Подпись (номер
+         * подъезда) при этом остаётся экранной — её надо читать при любом наклоне.
+         */
+        placement?: 'screen' | 'map';
+        /**
+         * В чём заданы размеры стрелки: `pixels` (по умолчанию) — в ЭКРАННЫХ
+         * пикселях, `meters` — в метрах на местности.
+         *
+         * Пиксели нужны, чтобы размер не менялся с зумом. Метры на земле означают
+         * рост вдвое на каждый уровень: между z17 и z22 стрелка вырастала с двух
+         * десятков пикселей до трёхсот. Стопы по зуму это лечат лишь отчасти —
+         * интерполяция между ними ЛИНЕЙНАЯ, а масштаб растёт экспоненциально, и
+         * внутри каждого шага размер всё равно вспухает. Так же устроена ширина
+         * линий: она задана в пикселях, а в единицы геометрии переводится в шейдере.
+         */
+        arrowUnits?: 'pixels' | 'meters';
+        /** Длина стрелки (единицы — по `arrowUnits`). */
+        arrowLength?: Interpolated<number>;
+        /** Ширина древка. */
+        arrowWidth?: Interpolated<number>;
+        /** Толщина обводки. 0 — без обводки. */
+        arrowOutline?: Interpolated<number>;
+        /**
+         * Радиус кружка НА САМОЙ двери. Стрелка показывает, откуда заходить, точка —
+         * куда именно; так это устроено у Яндекса. 0 — без точки.
+         */
+        arrowDotRadius?: Interpolated<number>;
+        /**
+         * Отступ точки от стены. Дом рисуется следующим проходом с честной глубиной,
+         * и стена перекрывает всё, что лежит у её основания: без отступа точка
+         * пропадает под домом на любом наклоне.
+         */
+        arrowDotGap?: Interpolated<number>;
+        /**
+         * Отступ остриё↔стена. Стрелка не упирается в дом, а стоит перед ним:
+         * впритык остриё сливается со стеной, а под наклоном ещё и уходит под неё.
+         */
+        arrowGap?: Interpolated<number>;
+    };
+    paint: {
+        /**
+         * Цвет подписи; `{ from }` — «как у такого-то слоя» (см. `ColorFrom`).
+         *
+         * Ссылка тут нужна ровно затем же, зачем обводке моста: тем два десятка, и слой, отколотый от
+         * существующего (мелкие населённые пункты от крупных), в каждой из них пришлось бы красить
+         * заново. Своего хекса у такого слоя нет — у него есть «как у родителя», и ссылка это и говорит.
+         * Берётся ОДНОИМЁННОЕ свойство: `haloColor: { from: 'place-label' }` — это обводка того слоя.
+         */
+        color: Interpolated<string> | ColorFrom;
+        haloColor?: Interpolated<string> | ColorFrom;
+        /** Толщина обводки в CSS-пикселях. Обводка обязательна поверх пёстрой карты. */
+        haloWidth?: Interpolated<number>;
+        /** Размытие обводки текста в пикселях — `text-halo-blur` MapLibre. */
+        haloBlur?: Interpolated<number>;
+        /** Размытие обводки значка — `icon-halo-blur`. */
+        iconHaloBlur?: Interpolated<number>;
+        /**
+         * Свой цвет значка — иначе он красится цветом подписи (одна программа на
+         * текст и иконки). Нужен плашкам: щит номера трассы это светлая заливка с
+         * рамкой, а номер на ней тёмный.
+         */
+        /**
+         * НАСЫЩЕННОСТЬ ПОДПИСИ: добавка к толщине штриха в пикселях (0 — как в шрифте).
+         *
+         * Своего полужирного начертания у нас нет: глифы приходят одним набором с сервера шрифтов, и
+         * второй набор — это вторая загрузка и второй атлас на каждую карту. Зато буква хранится
+         * полем расстояний, а в нём «жирнее» — это просто сдвиг границы наружу: тот же контур,
+         * отпущенный на доли пикселя. Так набирают полужирный и в Mapbox, и в Яндексе.
+         *
+         * Мера — пиксели экрана, а не условная единица: на глаз подпись прибавляет ровно столько,
+         * и на любом кегле прибавка одна и та же.
+         */
+        textWeight?: Interpolated<number>;
+        iconColor?: Interpolated<string>;
+        iconHaloColor?: Interpolated<string>;
+        iconHaloWidth?: Interpolated<number>;
+        /**
+         * Заливка круглой подложки. По умолчанию — цвет обводки подписи: он в каждой
+         * теме и есть «цвет фона под текстом», светлый на дневных палитрах и тёмный
+         * на ночных, так что кружок подхватывает тему без отдельной настройки.
+         */
+        frameColor?: Interpolated<string>;
+        /**
+         * Непрозрачность ЗАЛИВКИ подложки, 0..1 (по умолчанию 1).
+         *
+         * Кружок под значком — фон, а не фигура: сплошной он закрывает карту и на
+         * плотной застройке читается дырой. Полупрозрачный отделяет пиктограмму от
+         * подложки, но оставляет видимым то, что под ним. Рамка сохраняет свою
+         * непрозрачность — иначе кружок теряет край.
+         */
+        frameOpacity?: Interpolated<number>;
+        /** Рамка подложки. По умолчанию — цвет значка, приглушённый до трети. */
+        frameHaloColor?: Interpolated<string>;
+        frameHaloWidth?: Interpolated<number>;
+        /**
+         * ГРАДИЕНТ ПО ПОДЛОЖКЕ: насколько верх кружка светлее, а низ темнее своего цвета (0..1,
+         * по умолчанию 0 — ровная заливка).
+         *
+         * Задан силой, а не парой цветов, нарочно. Цвет у подложки один на категорию — у еды свой,
+         * у транспорта свой, — и вторым цветом пришлось бы задавать их все заново, по два на каждую.
+         * Светлота же считается от того цвета, что уже есть, поэтому объём получают сразу все
+         * категории, и перекрашивание темы ничего не ломает.
+         */
+        frameGradient?: Interpolated<number>;
+        /**
+         * ТЕНЬ ПОД ПОДЛОЖКОЙ: непрозрачность, 0..1 (по умолчанию 0 — без тени).
+         *
+         * Кружок без тени лежит В карте, с тенью — НАД ней, и на пёстрой застройке это разница между
+         * «пятно среди домов» и «метка поверх города».
+         */
+        frameShadow?: Interpolated<number>;
+        /** Сдвиг тени вниз в пикселях экрана (по умолчанию 3). */
+        frameShadowOffset?: Interpolated<number>;
+        /** Размытие тени в пикселях экрана (по умолчанию 6). */
+        frameShadowBlur?: Interpolated<number>;
+        /**
+         * Свой цвет тени. По умолчанию — цвет подложки, притемнённый: серая тень под цветным значком
+         * читается грязью, а потемневший собственный цвет — глубиной.
+         */
+        frameShadowColor?: Interpolated<string>;
+        /**
+         * Цвета частей составного значка (`layout.iconParts`), по порядку частей.
+         *
+         * Лежат в paint, а не рядом с именами частей: это ЦВЕТ, и тема вправе его перекрасить, как
+         * перекрашивает всё остальное. Части без цвета красятся как обычный значок.
+         */
+        partColors?: (Interpolated<string> | ColorFrom)[];
+        /** Обводка частей, по порядку частей. По умолчанию её нет — см. `partColors`. */
+        partHaloWidths?: Interpolated<number>[];
+        opacity?: Interpolated<number>;
+        /** Непрозрачность значка отдельно от подписи, `icon-opacity` (без поля — как `opacity`). */
+        iconOpacity?: Interpolated<number>;
+        /** Сдвиг подписи в пикселях `[x, y]`, `text-translate`. */
+        textTranslate?: [number, number] | unknown[];
+        /** От чего отсчитывается сдвиг подписи: `map` — по карте, `viewport` — по экрану. */
+        textTranslateAnchor?: 'map' | 'viewport';
+        /** Сдвиг значка в пикселях, `icon-translate`. */
+        iconTranslate?: [number, number] | unknown[];
+        iconTranslateAnchor?: 'map' | 'viewport';
+    };
+}
+/**
+ * Поверхность со своим уровнем: приподнятый парк, утопленная вода, площадка.
+ *
+ * От `fill` отличается тем, что живёт в объёме: у неё есть уровень (в том числе
+ * отрицательный), борт-фаска и юбка до земли, она пишет глубину и получает
+ * свет. От `fill-extrusion` — тем, что уровень задаёт СТИЛЬ, а не данные, и
+ * вместо стены с окнами у неё мягкий край.
+ *
+ * Уровень и фаска — ГЕОМЕТРИЯ: их правка пересобирает тайлы.
+ */
+interface SurfaceLayerSpec extends LayerBase {
+    type: 'surface';
+    /** Уровень верхней плоскости в метрах; отрицательный — ниже земли. */
+    elevation: number;
+    /** До какого уровня опускается юбка. По умолчанию земля (0). */
+    base?: number;
+    /** Ширина фаски по горизонтали, метры. 0 — резкий край. */
+    bevel?: number;
+    /**
+     * СТРОИТЬ ПОВЕРХНОСТЬ ИЗ ЛИНИЙ, а не из полигонов: полотно дороги, тротуар, дорожка.
+     *
+     * Дорога в данных — ось, а не площадь, и рисуется она лентой в экранных пикселях: у такой ленты
+     * нет края в мире, поэтому нет и бордюра, и борта, и тени от него. С этим флагом ось
+     * превращается в контур (`generators/ribbon`), и полотно становится обычной поверхностью — со
+     * своим уровнем, фаской и юбкой. Ширина берётся из данных (атрибут `width`, метры), а если её
+     * там нет — из `width` ниже.
+     */
+    fromLines?: boolean;
+    /** Ширина полотна в метрах, когда в данных её нет (тропинка, тротуар). Только с `fromLines`. */
+    width?: number;
+    /** Прибавка к ширине из данных, метры: обочина, свес бордюра. Только с `fromLines`. */
+    widthExtra?: number;
+    /**
+     * Толщина плиты у ПРИПОДНЯТОГО полотна (мост, эстакада), метры.
+     *
+     * Мост без низа читается плёнкой, висящей над улицей: сверху асфальт, а дальше сразу земля.
+     * Толщина даёт ему боковую стенку — ту же, что у берега приподнятой поверхности.
+     */
+    deck?: number;
+    /** На сколько фаска опускается, метры. */
+    /**
+     * Насколько широкую щель между кусками СЛИТЬ, метры. По умолчанию — общее значение движка.
+     *
+     * Ноль нужен слоям, куски которых обязаны остаться порознь. Первый такой — зебра перехода: она
+     * набрана отдельными полосами с промежутками около метра, и общая сварка слепила её в сплошную
+     * белую плиту.
+     */
+    weld?: number;
+    /**
+     * УЧАСТВУЕТ ЛИ ПОВЕРХНОСТЬ В ПОЛЕ ВЫСОТ, по которому поднимаются линии. По умолчанию — да.
+     *
+     * Поле отвечает на вопрос «на чём лежит линия»: дорожка, проходящая по приподнятому двору,
+     * поднимается вместе с ним (см. `generators/ground`). Полотну дорог это во вред: линия, которая
+     * просто ПЕРЕСЕКАЕТ асфальт, взбирается на него и рисуется поверх. Самое заметное — русло реки:
+     * мост через неё выходит перечёркнутым синей полосой ровно по проезжей части.
+     *
+     * Поэтому полотно из поля исключается. Своей разметке оно ничего не должно: краска и так лежит
+     * выше асфальта собственной отметкой.
+     */
+    groundField?: boolean;
+    /**
+     * ПИШЕТ ЛИ ПОВЕРХНОСТЬ ГЛУБИНУ (по умолчанию — да, если непрозрачна и не утоплена; `surfaceWritesDepth`).
+     *
+     * `false` — как утопленная вода: поверхность ложится краской, а то, что стиль рисует следом, ложится
+     * на неё по очереди. Нужна там, где следующий слой лежит выше на сантиметры и спорить за глубину
+     * на Adreno проигрывает: наземное полотно (0.09 м) под асфальтом детальных дорог (0.25 м) давало
+     * светлую линию вдоль асфальта (NaviGram натив, Худжанд, 31.10.2026). Поднятое полотно глубину
+     * пишет по-прежнему — эстакада обязана закрывать то, что под ней.
+     */
+    depthWrite?: boolean;
+    bevelDrop?: number;
+    paint: MaterialPaint & {
+        /** Цвет поверхности; `{ from, darken }` — «как у такого-то слоя» (см. `ColorFrom`). */
+        color: Interpolated<string> | ColorFrom;
+        opacity?: Interpolated<number>;
+        /** Насколько темнее борт и юбка, 0..1. */
+        sideShade?: Interpolated<number>;
+        /**
+         * Цвет борта и юбки. По умолчанию у УТОПЛЕННОЙ поверхности это фон стиля —
+         * то есть земля вокруг: стенка утопленной воды и есть берег, и красить её
+         * водой значит обводить реку тёмной каймой.
+         *
+         * `{ from, darken }` — «как у такого-то слоя» (см. `ColorFrom`): так бордюр полотна берёт цвет
+         * обводки дорог из темы и меняется вместе с ней, а не остаётся одним хексом на все палитры.
+         */
+        sideColor?: Interpolated<string> | ColorFrom;
+        /**
+         * Насколько борт освещается КАК ЗЕМЛЯ (0 — по своей нормали, 1 — по
+         * вертикальной). У берега нормаль горизонтальная, света он почти не
+         * получает и читается тёмной стенкой; у утопленных поверхностей по
+         * умолчанию 1, и край берёт свет окружающей земли.
+         */
+        sideLight?: Interpolated<number>;
+        /**
+         * ТОН ПО ВЫСОТЕ: чем выше лежит верх поверхности, тем он светлее (> 0) или темнее (< 0).
+         *
+         * Уровни развязки читаются сверху, без наклона камеры: у Baidu нижняя дорога под эстакадой
+         * заметно темнее верхней, а по длине съезда тон меняется плавно (замер их кадров,
+         * `sdk/baydumap/RESEARCH.md` §6.4 в монорепозитории). Считается по высоте КАЖДОЙ вершины —
+         * профиль подъёма (`liftPath`) даёт градиент по съезду сам, без нарезки на куски.
+         *
+         * Доля смешивания с белым (или чёрным) на полной высоте [`liftToneHeight`], 0..1. Земля
+         * (верх ниже уровня слоя + четверти метра) не меняется — тема остаётся темой.
+         */
+        liftTone?: Interpolated<number>;
+        /** Высота, на которой тон набирает всю силу, метры. По умолчанию — `levelHeight` стиля или 8. */
+        liftToneHeight?: number;
+    };
+}
+/**
+ * Раскладка детальных 3D-объектов — общая у слоя стиля (`ModelLayerSpec.layout`) и у опции карты
+ * `objects3d.layout`. У опции есть ещё порог показа `minZoom`; у слоя стиля его роль играет
+ * `minzoom` самого слоя, как у любого слоя (см. `Objects3DLayout`).
+ */
+interface ModelLayout {
+    /**
+     * Радиусы в метрах: до какого расстояния грузим и до какого держим уже
+     * загруженное. Второй заметно больше первого — иначе объект на границе
+     * мигал бы при каждом дрожании камеры.
+     */
+    loadRadius?: number;
+    keepRadius?: number;
+    /** Сколько моделей держать в памяти одновременно. */
+    budget?: number;
+    /** Прятать здание, которое модель заменяет (`replaces` + `anchor: replace`). */
+    maskReplaced?: boolean;
+    /**
+     * Полная геометрия (lod0) с самого нижнего зума, без упрощённой ступени.
+     *
+     * По умолчанию у порога показа объект получает lod1 и «дорисовывается» до lod0 только через
+     * два зума. На общем плане это незаметно, но если карта показывает объект как достопримечательность,
+     * читается браком: сначала огрублённый силуэт, потом подмена.
+     *
+     * Число объектов флаг НЕ трогает — за него отвечает `fullBudget`. Разделены они не для порядка:
+     * замер на боевой карте (Душанбе, z15.2, окно 1551×1346, наклон 55°) показал, что кадр сажает
+     * именно количество, а не подробность — со снятыми обеими поблажками медиана кадра при панораме
+     * была 30–38 мс против 17 мс на z17.8.
+     */
+    fullDetail?: boolean;
+    /**
+     * Полный бюджет моделей с нижнего зума.
+     *
+     * По умолчанию на пороге показа берётся четверть бюджета, и дальше он плавно растёт до полного
+     * за три зума: на общем плане объект занимает считанные пиксели, и сотня таких объектов стоит
+     * кадра и трафика, ничего не добавляя глазу. Включать на широком экране с осторожностью —
+     * модели дают около 84 % треугольников кадра.
+     */
+    fullBudget?: boolean;
+}
+/** Раскладка опции карты `objects3d`: то же, что у слоя, плюс порог показа. */
+interface Objects3DLayout extends ModelLayout {
+    /**
+     * С какого зума показывать. Ниже него объекты не грузятся вовсе: детальная
+     * модель на общем плане не читается, а трафик и память тратит.
+     */
+    minZoom?: number;
+}
+/**
+ * ДЕТАЛЬНЫЕ 3D-ОБЪЕКТЫ СЛОЕМ СТИЛЯ (тип `model`, в v2 — `osmgl-model`).
+ *
+ * Тайл источника говорит, ГДЕ стоит модель (набор `model3d`), сама модель — отдельный GLB из
+ * сервиса Objects3D: его адрес — свойство ИСТОЧНИКА (`SourceSpec.modelEndpoint`), потому что номера
+ * файлов в тайле имеют смысл только у того сервиса, из базы которого тайл собран.
+ *
+ * Слой ничего не рисует в общей очереди слоёв: он превращает точки тайла в список моделей, а рисует
+ * их общий проход моделей — вместе со зданиями и с общей картой теней. Поэтому место слоя в списке
+ * на облик не влияет, а рисующие проходы его пропускают (как проход заливок пропускает подписи).
+ *
+ * Раньше объекты задавались только опцией карты `objects3d`, и стиль не мог их ни объявить, ни
+ * спрятать, ни настроить — в редакторе стилей их не было вовсе. Опция осталась путём совместимости:
+ * стиль без такого слоя плюс опция ведут себя как прежде, а слой в стиле главнее опции.
+ *
+ * Имена — в духе слоя `model` Mapbox GL v3 (`model-opacity`, `model-cast-shadows`), но источник и
+ * политика загрузки свои: у Mapbox модель берётся из корня стиля по `model-id`, у нас — из сервиса
+ * по номеру файла в тайле, с радиусами и бюджетом памяти.
+ *
+ * `minzoom` слоя — порог показа (ниже него модели отпускаются); без поля — 14, как у опции.
+ * `filter` отбирает размещения по свойствам тайла (`kind: rule` — замены по типу).
+ */
+interface ModelLayerSpec {
+    /** id слоя; он же ключ бакета размещений в тайле. */
+    id: string;
+    type: 'model';
+    /** Источник размещений; без поля — `base`, но у основной карты размещений нет. */
+    source?: string;
+    'source-layer': string;
+    filter?: Filter;
+    minzoom?: number;
+    maxzoom?: number;
+    visible?: boolean;
+    /** Свободные данные приложения у слоя (`metadata` слоя MapLibre). Движок их не читает. */
+    metadata?: Record<string, unknown>;
+    layout?: ModelLayout;
+    paint?: {
+        /**
+         * Непрозрачность моделей, 0..1. Меньше единицы — модель уходит в прозрачный подпроход (без
+         * записи глубины), как при плавном исчезновении, и рисуется по одной, а не пачкой.
+         */
+        opacity?: Interpolated<number>;
+        /** Отбрасывают ли модели тень в общую карту теней. Получают её в любом случае. */
+        castShadows?: boolean;
+    };
+}
+type StyleLayerSpec = FillLayerSpec | LineLayerSpec | FillExtrusionLayerSpec | SurfaceLayerSpec | SymbolLayerSpec | RasterLayerSpec | ModelLayerSpec | CircleLayerSpec | BackgroundLayerSpec | HeatmapLayerSpec | HillshadeLayerSpec | ColorReliefLayerSpec;
+/**
+ * Освещение сцены: ровный ambient + ДВА направленных источника.
+ *
+ * Ключевой (key) задаёт основную светотень, заполняющий (fill) светит примерно
+ * с противоположной стороны и вытягивает грани, отвёрнутые от ключевого.
+ *
+ * Почему не полусфера (небо сверху / отсвет земли снизу), с которой начинали:
+ * у любой вертикальной стены normal.z = 0, а значит полусферный ambient у всех
+ * четырёх сторон дома ОДИНАКОВ. Отличал их только один солнечный член, и здания
+ * читались плоскими. С двумя источниками каждая ориентация стены получает свою
+ * яркость, и объём виден без всяких теней.
+ */
+interface LightSpec {
+    /** Ровная подсветка со всех сторон. */
+    ambientColor: string;
+    ambientIntensity: number;
+    /** Ключевой источник: азимут в градусах (0 — север, по часовой) и высота над горизонтом. */
+    keyAzimuth: number;
+    keyAltitude: number;
+    keyColor: string;
+    keyIntensity: number;
+    /** Заполняющий источник — обычно с другой стороны и ниже. */
+    fillAzimuth: number;
+    fillAltitude: number;
+    fillColor: string;
+    fillIntensity: number;
+    /**
+     * Сила теней, 0..1 (по умолчанию 1). Ноль — теней нет ВОВСЕ: проход карты теней не запускается.
+     *
+     * Заведено ради стеклянных тем по образцу Baidu: там город светится, и серое пятно у основания
+     * каждого дома читается грязью. Дробное значение ослабляет тень на земле.
+     */
+    shadowStrength?: number;
+}
+/**
+ * Небо и дымка.
+ *
+ * Дальность дымки меряется **в расстояниях от камеры до центра карты**, а не в
+ * метрах и не в пикселях. Так же сделано в Mapbox (`range + 0.5/tan(fov/2)`),
+ * и причина не в удобстве, а в том, что иначе дымка затягивает карту при
+ * взгляде СВЕРХУ.
+ *
+ * При наклоне 0° вся видимая земля равноудалена от камеры — она лежит примерно
+ * на одном расстоянии до центра (у края кадра всего в 1,15 раза дальше). Любой
+ * порог в метрах либо срабатывает сразу на всём кадре, либо не срабатывает
+ * никогда, и подобрать его на все зумы невозможно: на z10 «1200 метров» — это
+ * пол-экрана, на z18 — сто экранов.
+ *
+ * В относительных единицах порог сам собой оказывается ЗА пределами вида при
+ * взгляде сверху и попадает в кадр при наклоне, где земля действительно уходит
+ * вдаль. Настройка получается одна на все зумы.
+ */
+interface SkySpec {
+    /** Рисовать небо и дымку. */
+    enabled: boolean;
+    /** Цвет открытого неба над полосой мглы. */
+    skyColor: string;
+    /**
+     * Цвет ВЕРХНЕЙ АТМОСФЕРЫ — выше по кадру, где воздуха меньше и синь глубже.
+     *
+     * Третья остановка градиента. Двух цветов на небо не хватает: получается ровная заливка, по
+     * которой не читается ни толща воздуха, ни высота. Так же устроено небо у Mapbox (`high-color`).
+     */
+    highColor?: string;
+    /** Цвет у горизонта. В него же уходит дальняя земля — отсюда бесшовный стык. */
+    horizonColor: string;
+    /**
+     * Где дымка начинается и где забивает цвет полностью — в расстояниях от
+     * камеры до центра карты. Значение 1 это ровно центр кадра, поэтому начало
+     * обязано быть больше единицы, иначе дымка ляжет на весь вид сверху.
+     */
+    fogRange: [number, number];
+    /** Предел силы дымки: 1 — дальний план сливается с горизонтом полностью. */
+    fogIntensity: number;
+    /**
+     * Вертикальный диапазон дымки в МЕТРАХ: с какой высоты она начинает отпускать геометрию и на
+     * какой отпускает совсем. Мгла лежит слоем у земли, и башня из неё выходит — низ теряется,
+     * верх остаётся чистым. Ровно выцветшая по всей высоте башня выдаёт нарисованную дымку первой.
+     *
+     * Равные значения выключают учёт высоты. Аналог `fog.vertical-range` у Mapbox.
+     */
+    fogVerticalRange: [number, number];
+    /** Цвет космоса за пределами атмосферы. Виден только на глобусе. */
+    spaceColor: string;
+    /** Цвет атмосферной каймы вокруг планеты. */
+    atmosphereColor: string;
+    /** Яркость звёзд, 0 — выключить. Звёзды закреплены в мире, а не на экране. */
+    starIntensity: number;
+    /**
+     * Толщина полосы МГЛЫ над горизонтом — в синусе угла подъёма луча, как `fog.horizon-blend`
+     * у Mapbox. Значение 0.14 это примерно восемь градусов.
+     *
+     * Величина угловая, а не доля кадра: толщина мглы от кадрирования не зависит. Доля видимого
+     * неба схлопывается в ноль, когда горизонт подходит к кромке кадра (большой зум с наклоном), и
+     * синее небо упирается в мглу стыком.
+     *
+     * Этой же полосой дымка отпускает геометрию по мере подъёма луча — небо и дальний дом обязаны
+     * приходить у горизонта в один цвет.
+     */
+    horizonBlend: number;
+    /**
+     * Чья модель неба и дымки. Без поля — своя (облик osmgl). `maplibre` ставит импортёр стиля MapLibre:
+     * небо — градиент `sky.fragment.glsl` (квадрат по полосе в пикселях над горизонтом), дымка — только
+     * с рельефом, по глубине `terrain.fragment.glsl` (`fog-color` → `horizon-color`, наклон 60–70°).
+     */
+    model?: 'maplibre';
+    /** Цвет дымки у земли (`fog-color`), только `model: maplibre`. */
+    fogColor?: string;
+    /** Где дымка начинается: 0 — центр кадра, 1 — горизонт (`fog-ground-blend`). */
+    fogGroundBlend?: number;
+    /** Где цвет дымки переходит в цвет горизонта (`horizon-fog-blend`). */
+    horizonFogBlend?: number;
+    /** Полоса перехода неба в горизонт, доля полувысоты кадра (`sky-horizon-blend`). */
+    skyHorizonBlend?: number;
+    /**
+     * Этап (x): сила атмосферы на шаре (`atmosphere-blend`), 0 — её нет, 1 — во всю силу; по зуму. Множит
+     * кайму у края планеты и ореол за ним. Без поля — 1 (облик osmgl); у стиля MapLibre — 0.8.
+     */
+    atmosphereBlend?: Interpolated<number>;
+}
+declare const DEFAULT_SKY: SkySpec;
+/**
+ * ТУМАН С ДАЛЬНОСТЬЮ ОТСЕЧЕНИЯ — корневое `fog` стиля (как у Apple Maps: при большом наклоне дальний
+ * план уходит в сплошную стену тумана, а за ней не рисуется и не грузится НИЧЕГО).
+ *
+ * Дальности меряются в РАССТОЯНИЯХ ОТ КАМЕРЫ ДО ЦЕНТРА КАДРА и ВДОЛЬ ОСИ ВЗГЛЯДА (как глубина в
+ * шейдере): 1 — центр кадра. У карты сверху вся земля лежит ровно на единице, поэтому любой туман
+ * дальше 1 её не трогает и появляется только с наклоном. Граница одинаковой глубины на земле — прямая,
+ * параллельная краю экрана, отсюда ровная горизонтальная кромка тумана. Отсечение — той же плоскостью
+ * (дальняя плоскость камеры), поэтому кромка геометрии не видна: на ней туман уже сплошной.
+ *
+ * Без поля `fog` — прежняя дымка неба (`SkySpec.fogRange`), ничего не отсекается сверх прежнего.
+ */
+interface FogSpec {
+    /** Где туман начинается и где он уже сплошной (в расстояниях до центра кадра, начало > 1). */
+    range: [number, number];
+    /** Цвет тумана; он же цвет горизонта неба — так стык невидим. Без поля — `sky.horizonColor`. */
+    color?: string;
+    /** Дальше этого не грузится и не рисуется ничего. Без поля — конец тумана; ближе конца не бывает. */
+    cutoff?: number;
+    /** Высота плотной полосы тумана над горизонтом, градусы: сплошная дымка, уходящая вверх в небо. */
+    height: number;
+    /**
+     * Плотность, 0..1: предел силы тумана. Ниже 1 дальний план просвечивает, и отсекать его без видимой
+     * кромки нельзя — тогда отсечение включается только явным `cutoff`.
      */
-    parallelCompile: boolean;
+    density: number;
+    /** Высоты в метрах, где туман начинает отпускать дома и где отпускает совсем (`vertical-range` Mapbox). */
+    verticalRange?: [number, number];
 }
-type DepthFunc = 'less' | 'lequal' | 'always' | 'greater';
-type BlendMode = 'none' | 'alpha' | 'premultiplied' | 'add' | 'multiply';
-type CullMode = 'none' | 'back' | 'front';
-declare class Context {
-    readonly gl: WebGL2RenderingContext;
-    readonly caps: Capabilities;
-    private _program;
-    private _vao;
-    private _framebuffer;
-    private _depthTest;
-    private _depthMask;
-    private _colorMask;
-    private _depthFunc;
-    private _blend;
-    private _cull;
-    private _viewport;
-    private _activeTexture;
-    private _boundTextures;
-    private _stencilTest;
-    constructor(gl: WebGL2RenderingContext);
+/**
+ * Туман по умолчанию — ПОЛОСА У ГОРИЗОНТА, а не стена посреди города.
+ *
+ * Линия глубины k лежит на (1 − 1/k)/tg(наклона) фокусов над центром кадра. Сплошной туман — с k = 4.5:
+ * при наклоне 75° это ~19 % высоты кадра от верха, при 70° — ~7.5 %; начинается он с 1.3, до наклона
+ * ≈52° не виден вовсе.
+ *
+ * ★ Было [1.3, 1.7] («как у Apple Maps»: стена на трети кадра при 75°). На наклоне 70° молоко начиналось
+ * чуть выше центра кадра и прятало кварталы в 400–500 м за ним (жалоба: «туман перекрывает половину
+ * контента», Худжанд, z16.5). Mapbox по умолчанию — [0.5, 10] высот экрана за центром, у нас это
+ * ≈ [1.33, 7.7]. Взят промежуточный конец: замер на z16.5, 70° — тайлов в кадре 85 → 135 (у Mapbox-диапазона
+ * 167), кварталы читаются до верхних ~15 % кадра. Дальше конец не отодвигаем: за кромкой не грузится
+ * ничего, и это главная экономия на слабых телефонах при большом наклоне.
+ */
+declare const DEFAULT_FOG: FogSpec;
+/** Этап (x): кодировка векторного источника — `mvt` (по умолчанию) или `mlt` (MapLibre Tile, `source/mlt.ts`). */
+type TileEncodingSpec = 'mvt' | 'mlt';
+interface SourceSpec {
+    /** Шаблон вида `/tileserver/data/indoor/{z}/{x}/{y}.pbf`. У `geojson` адреса нет. */
+    url?: string;
     /**
-     * ЗАБЫТЬ ВСЁ, ЧТО МЫ ЗНАЛИ О СОСТОЯНИИ GL.
+     * Что лежит по адресу. Без поля — векторные тайлы, как было раньше.
      *
-     * Нужно после чужого кода — своего слоя приложения (`CustomLayerInterface`). Он вправе поменять
-     * программу, буферы, смешивание и глубину; наш кеш после этого врёт, и следующий проход
-     * «пропускает» установку, которой на самом деле нет. Дешевле объявить кеш недействительным, чем
-     * потом искать, почему исчезли подписи.
+     * `raster` — подложка картинками: её не надо разбирать, поэтому она не идёт
+     * через пул воркеров и рисуется одним квадом на тайл (см. `RasterSource`).
      */
-    resetState(): void;
-    useProgram(program: WebGLProgram | null): boolean;
-    bindVAO(vao: WebGLVertexArrayObject | null): void;
+    type?: 'vector' | 'raster' | 'raster-dem' | 'geojson' | 'image' | 'video' | 'canvas';
     /**
-     * Куда уходит «экранный» кадр. По умолчанию `null` — канва. Диагностика
-     * подменяет его на свой буфер: проходы внутри рендера (тени, пикинг)
-     * возвращаются с bindFramebuffer(null), и без этой подмены весь кадр после
-     * первого же такого прохода уходил бы мимо буфера.
+     * Четыре угла картинки, видео или canvas: левый верхний, правый верхний, правый нижний, левый
+     * нижний. Порядок и смысл как у MapLibre — углы независимы, прямоугольник необязателен.
      */
-    screen: WebGLFramebuffer | null;
+    coordinates?: unknown;
+    /** Элемент canvas или его id (`type: 'canvas'`). */
+    canvas?: unknown;
+    /** Перезаливать ли текстуру каждый кадр (живой canvas). */
+    animate?: boolean;
     /**
-     * Привязанный сейчас кадровый буфер (этап e: проход в свою текстуру посреди кадра — плотность
-     * тепловой карты, уклон отмывки — обязан вернуть ровно тот буфер, куда шёл кадр, в том числе
-     * текстуру драпировки рельефа). `null` — канва (или `screen`).
+     * ДАННЫЕ ПРИЛОЖЕНИЯ вместо тайлов с сервера (`type: 'geojson'`).
+     *
+     * Сам набор или адрес, откуда его забрать. Нарезкой на тайлы занимается движок
+     * (`source/geojson-source.ts`), поэтому слои ссылаются на такой источник как на обычный.
      */
-    get currentFramebuffer(): WebGLFramebuffer | null;
-    /** Текущий режим смешивания — чтобы проход, сменивший его на время, вернул прежний. */
-    get blendMode(): BlendMode;
-    bindFramebuffer(fb: WebGLFramebuffer | null): void;
-    bindTexture(unit: number, texture: WebGLTexture | null, target?: number): void;
-    /** Ширина и высота текущего вьюпорта (ещё не заданного — кадрового буфера), пиксели. */
-    get viewportWidth(): number;
-    get viewportHeight(): number;
-    viewport(x: number, y: number, w: number, h: number): void;
-    setDepthTest(on: boolean): void;
-    setDepthMask(on: boolean): void;
+    data?: unknown;
+    /** Имя слоя внутри источника: на него смотрит `source-layer` слоя стиля. По умолчанию `geojson`. */
+    sourceLayer?: string;
+    /** Собирать ли точки в кластеры (`geojson`). */
+    cluster?: boolean;
+    /** Радиус кластера в пикселях экрана. */
+    clusterRadius?: number;
+    /** Зум, выше которого кластеров нет. */
+    clusterMaxZoom?: number;
     /**
-     * Запись цвета. Выключенная маска — это рисование «только в глубину»:
-     * геометрия перекрывает то, что нарисуют дальше, но сама не видна (так
-     * закрываются дырки в утопленных поверхностях — острова).
+     * Кодировка высоты у `raster-dem`: `mapbox` (наш набор) или `terrarium`. См. `source/dem.ts`.
      */
-    setColorMask(on: boolean): void;
-    /** Текущая функция глубины — чтобы проход, сменивший её на время, вернул прежнюю. */
-    get depthFunc(): DepthFunc;
-    setDepthFunc(f: DepthFunc): void;
-    setBlend(mode: BlendMode): void;
-    setCull(mode: CullMode): void;
-    setStencilTest(on: boolean): void;
-    clear(color: [number, number, number, number] | null, depth?: boolean, stencil?: boolean): void;
-    /** Сбрасывает кеш — вызывать после чужого кода, трогавшего контекст напрямую. */
-    invalidateState(): void;
+    encoding?: 'mapbox' | 'terrarium' | 'custom' | TileEncodingSpec;
+    /**
+     * База сервиса 3D-моделей (Objects3D) у источника размещений, например `/objects3d`.
+     *
+     * Номер файла в тайле размещений имеет смысл только у того сервиса, из базы которого собран тайл,
+     * поэтому адрес — свойство ИСТОЧНИКА, а не слоя. Ключ портала (`?key=`) отдельно писать не нужно:
+     * он берётся из адреса тайлов того же источника — шлюз пускает к тайлам и к моделям одним ключом.
+     * Без поля — `/objects3d` (или `objects3d.endpoint` опции карты). Относительный адрес в стиле,
+     * загруженном по ссылке, разрешается по адресу стиля.
+     */
+    modelEndpoint?: string;
+    minzoom?: number;
+    maxzoom?: number;
+    /** Все шаблоны адреса (`tiles` MapLibre), если их больше одного: тайл берёт `(x + y) % n`-й. `url` — первый. */
+    tiles?: string[];
+    /** `tms` — ось Y снизу вверх (`y = 2^z − 1 − y`), как у MapLibre. */
+    scheme?: 'xyz' | 'tms';
+    /** Рамка данных `[запад, юг, восток, север]`: тайлы вне неё не запрашиваются. */
+    bounds?: [number, number, number, number];
+    /** Сторона растрового тайла в пикселях (`raster`/`raster-dem`): 256 — тайлы на зум мельче. */
+    tileSize?: number;
+    /** Подпись источника для элемента атрибуции. */
+    attribution?: string;
+    /** Свойство, которое служит номером фичи (`["id"]`, `setFeatureState`); у слоёв — своё на каждый. */
+    promoteId?: string | Record<string, string>;
+    /** Не кешировать тайлы источника (`volatile`): у нас кеш в памяти, на диск ничего не пишется. */
+    volatile?: boolean;
+    /** Кодировка `custom` у `raster-dem`: высота = r·red + g·green + b·blue − baseShift. */
+    redFactor?: number;
+    greenFactor?: number;
+    blueFactor?: number;
+    baseShift?: number;
+    /** `geojson`: поле тайла в пикселях (512-пиксельного тайла), упрощение, отбор фич выражением. */
+    buffer?: number;
+    tolerance?: number;
+    filter?: unknown;
+    /** `geojson`: номер фичи — её порядковый номер в наборе. */
+    generateId?: boolean;
+    /** `geojson`: сколько точек нужно на кластер (MapLibre — 2). */
+    clusterMinPoints?: number;
+    /** `geojson`: свойства кластера — `{ имя: [свёртка, выражение] }`, как у MapLibre. */
+    clusterProperties?: Record<string, unknown>;
+    /** `geojson`: длина вдоль линии для `line-gradient` (ждёт `line-progress` в рендере). */
+    lineMetrics?: boolean;
 }
-
 /**
- * Скомпилированная программа с кешем локаций.
+ * РЕЛЬЕФ: земля перестаёт быть плоскостью.
  *
- * `defines` подставляются в начало обоих шейдеров — так один исходник даёт варианты
- * (с тенями / без, с пикингом / без) без ветвления в горячем цикле фрагмента.
+ * `source` — имя источника типа `raster-dem`, `exaggeration` — множитель высоты (1 — как в
+ * данных, 0 — рельеф выключен). Высоту читает вершинный шейдер каждого слоя, который лежит по
+ * земле: заливки, поверхности, дороги. Разбор подхода MapLibre и наш план — в `porting/terrain.md`.
+ *
+ * Тип ИМЕНОВАННЫЙ, а не инлайновый: его принимает `map.setTerrain` — тот самый метод, которым
+ * рельеф включают на лету (имя и смысл как у MapLibre).
  */
-declare class Shader {
-    private ctx;
-    readonly name: string;
-    private readonly _program;
-    private uniforms;
-    private attribs;
+interface TerrainSpec {
+    source: string;
+    exaggeration?: number;
     /**
-     * ПОСЛЕДНЕЕ, ЧТО ПОЛОЖИЛИ В КАЖДЫЙ ЮНИФОРМ (перенос `Shader.kt` порта Android, 18.10.2026).
+     * ЧЕМ РЕЛЬЕФ ПОКАЗАН, кроме собственной формы.
      *
-     * Юниформ — состояние ПРОГРАММЫ: значение лежит там, пока его не сменят, а рендерер льёт их на каждую отрисовку:
-     * цвет, ширина и пороги зума у слоя одни на все его тайлы, меняется только матрица. На Android кеш снял 1457 → 669
-     * вызовов на кадр из 101 отрисовки; в WebGL каждый `uniform*` — проверка и запись в буфер команд браузера. Натив
-     * решает то же блоками по частоте (`OsmglFrame`/`OsmglMaterial`), у GL — вот этот кеш.
+     * Сверху склон почти не читается — на бумажных картах его для того и красят по высоте
+     * (гипсометрия) и отмывают светом. Оба тона здесь, а не в движке, потому что это ЦВЕТ: у
+     * ледяной темы он холодный, у ночной тёмный, и одним набором на все темы не обойтись.
      *
-     * Безопасно потому, что значения принадлежат объекту программы, а менять их может только `uniform*` по ней — то
-     * есть только сеттеры ниже; перелинковки нет, потеря контекста заводит `Shader` заново. Ключ — само место
-     * юниформа (`WebGLUniformLocation`), значения — копией (рендерер правит матрицы на месте). Сравнение — по
-     * числам JS, без `fround`: два разных числа с одним `float32` уйдут дважды, но лишнего не сэкономим никогда.
-     * Целые — отдельно: `Float64Array` с ними не путается, но `uniform1i` и `uniform1f` — разные вызовы.
+     * `low`/`high` — тон низин и вершин, `range` — между какими высотами растянут переход,
+     * `tint`/`shade` — насколько сильно подмешивать окраску и отмывку (0..1).
      */
-    private values;
-    private ints;
-    /** Сколько вызовов `uniform*` не ушло в GL: значение уже лежало в программе. */
-    savedUniforms: number;
+    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;
+    /** Этап (d): плавная смена покраски по умолчанию (`transition` корня MapLibre). Без поля — сразу. */
+    transition?: TransitionSpec;
     /**
-     * Сборка ещё не проверена: шейдеры лежат здесь до первого обращения к программе.
+     * НА СКОЛЬКО МЕТРОВ ПОДНИМАЕТ КАЖДЫЙ УРОВЕНЬ ПЕРЕСЕЧЕНИЯ (`generators/level`): мост — 1, земля —
+     * 0, тоннель — −1.
      *
-     * ★ ПРОВЕРКА ОТЛОЖЕНА НАМЕРЕННО (03.10.2026). Конструктор раньше сразу спрашивал
-     * `COMPILE_STATUS`/`LINK_STATUS`, а этот вопрос ЖДЁТ конца компиляции в главном потоке. Программ
-     * при создании карты два десятка, и они собирались строго по очереди: 24 ожидания на 0.8–0.9 с
-     * одной задачей (замер: холодный профиль Chromium, D3D11). Теперь все программы сначала
-     * отправляются компилятору, и он собирает их в своих потоках одновременно, а ждём мы только ту, что
-     * понадобилась первой (`finish`), — к тому моменту остальные уже в работе или готовы.
+     * Пока дороги были краской, уровень решал только ПОРЯДОК отрисовки (см. `network`). Полотно —
+     * геометрия, и на пересечении без подъёма эстакада и улица под ней оказались бы на одной высоте:
+     * два непрозрачных верха в одной плоскости.
+     *
+     * Число нарочно маленькое. Настоящая эстакада поднята на пять метров и более, но опор и съездов
+     * у нас нет: на такой высоте мост обрывался бы в воздухе там, где кончается его пролёт. Полметра
+     * хватает, чтобы пересечение читалось «над», и не хватает, чтобы стык с обычной дорогой стал
+     * ступенькой.
+     *
+     * ВНИЗ НЕ ОПУСКАЕМ: землю мы не разрезаем, и тоннель под ней просто исчез бы вместе со своей
+     * подписью. Он остаётся на уровне земли — ровно так же, как рисовался лентой до сих пор.
      */
-    private pending;
-    constructor(ctx: Context, name: string, vertexSource: string, fragmentSource: string, defines?: Record<string, string | number | boolean>, 
+    levelHeight?: number;
+    light?: Partial<LightSpec>;
+    /** Свет объёма MapLibre — корневой `light` стиля MapLibre (см. `MapLibreLightSpec`). */
+    mapLibreLight?: Partial<MapLibreLightSpec>;
+    /** Небо и дымка. */
+    sky?: Partial<SkySpec>;
+    /** Туман с дальностью отсечения (см. `FogSpec`). Нет — прежняя дымка неба без отсечения сверх неё. */
+    fog?: Partial<FogSpec>;
+    /** Дополнительные источники тайлов помимо `base` (его задаёт карта опцией `tiles`). */
+    sources?: Record<string, SourceSpec>;
+    /** Рельеф под картой (см. `TerrainSpec`). */
+    terrain?: TerrainSpec;
     /**
-     * Места атрибутов, которые надо повторить, — у ВАРИАНТА программы (см. surfaceShader): VAO
-     * собран по местам базовой программы и обязан подойти каждому варианту. Общий список мест
-     * (ATTRIB_SLOTS) тут не годится: атрибутов больше, чем гарантированных шестнадцати мест.
+     * Ключ варианта 3D-моделей (см. `ThemeSpec.model3dKey`).
+     *
+     * Лежит в стиле, а не в опциях карты, потому что его задаёт ТЕМА, а тема — это накладка на стиль.
+     * Менеджер моделей читает его отсюда после каждого `setStyle` и сам решает, что перезагрузить.
      */
-    bind?: ReadonlyMap<string, number>);
-    /** Программа GL. Первое обращение дожидается сборки (см. `pending`). */
-    get program(): WebGLProgram;
-    /** Сборка не удалась: каждое следующее обращение бросает ту же ошибку, а не рисует удалённой программой. */
-    private failure;
+    model3dKey?: string;
     /**
-     * Собрана ли программа — НЕ дожидаясь её, если драйвер это умеет (`KHR_parallel_shader_compile`).
-     * Без расширения честного неблокирующего ответа нет, и программа считается готовой: тогда первое
-     * обращение просто подождёт, как и раньше.
+     * Свободные данные приложения — как `metadata` у MapLibre. Движок их не читает; хранит редактор
+     * стилей (своё состояние) и продукт (`maps3d:*` — облик SDK). Объявлено, чтобы проверка стиля не
+     * считала поле опечаткой.
      */
-    get ready(): boolean;
-    /** Дождаться сборки, проверить её и разобрать места юниформов и атрибутов. */
-    private finish;
-    private cacheLocations;
-    use(): void;
-    attribLocation(name: string): number;
-    private loc;
-    /** Надо ли слать значение в GL: `false` — там уже лежит такое же. */
-    private changed;
-    private readonly scratch;
-    private changed4;
-    /** Юниформ, вырезанный оптимизатором, молча игнорируется — это нормально. */
-    setMat4(name: string, v: Float32Array): void;
-    /** mat3 по КОЛОНКАМ — как того ждёт GLSL. */
-    setMat3(name: string, v: ArrayLike<number>): void;
-    setFloat(name: string, v: number): void;
-    setInt(name: string, v: number): void;
-    setVec2(name: string, x: number, y: number): void;
-    setVec3(name: string, x: number, y: number, z: number): void;
-    setVec4(name: string, x: number, y: number, z: number, w: number): void;
-    setVec4v(name: string, v: ArrayLike<number>): void;
+    metadata?: Record<string, unknown>;
     /**
-     * МАССИВ vec4 одним вызовом. Имя — без индекса: драйвер отдаёт локацию массива по `u_name[0]`,
-     * но ищем мы и по голому имени, потому что часть драйверов регистрирует его именно так.
+     * ШРИФТЫ СТИЛЯ — шаблон адреса SDF-глифов `…/{fontstack}/{range}.pbf`, ровно как `glyphs` у MapLibre.
      *
-     * Нужен для источников света модели: их до восьми, и восемь отдельных `uniform4f` на каждый
-     * примитив — это восемь вызовов GL там, где хватает одного.
+     * Нет поля — шрифты карты (опция `fonts`, `setGlyphs`). Есть — стиль ставит свои на время, пока он
+     * стоит, а стиль без них возвращает карте её собственные. Так стиль, сохранённый редактором или
+     * переведённый из MapLibre, не теряет шрифтов, с которыми его рисовали.
      */
-    setVec4Array(name: string, v: Float32Array): void;
-    /** Массив float одним вызовом (этап c: длины пунктира) — как `setVec4Array`. */
-    setFloatArray(name: string, v: Float32Array): void;
-    destroy(): void;
+    glyphs?: string;
+    /**
+     * Этап (x): ШРИФТЫ-ФАЙЛЫ (`font-faces` MapLibre) — имя из `text-font` → файл шрифта целиком или на
+     * диапазоны `unicode-range`. Буква из такого диапазона рисуется браузером из файла (только веб,
+     * `text/font-faces.ts`), остальные — с сервера `glyphs`.
+     */
+    fontFaces?: Record<string, string | {
+        url: string;
+        'unicode-range'?: string[];
+    } | (string | {
+        url: string;
+        'unicode-range'?: string[];
+    })[]>;
+    /**
+     * СПРАЙТ СТИЛЯ — адрес без расширения (`…/sprite`, к нему дописываются `.json`/`.png`, а на
+     * плотном экране `@2x`) или список `{ id, url }` — форма та же, что у `sprite` MapLibre, чтобы
+     * редактор и импортёр переносили её как есть. Значки дополнительного спрайта зовутся `id:имя`;
+     * `id: 'default'` — основной, без приставки.
+     *
+     * Нет поля — значки карты (встроенные, `setSprite`/`addSprite`) не трогаются. Есть — правило то же,
+     * что у `glyphs`: на время стиля его спрайт, после — снова карты.
+     */
+    sprite?: string | {
+        id: string;
+        url: string;
+    }[];
+    layers: StyleLayerSpec[];
 }
-
 /**
- * СВОИ ПРОТОКОЛЫ ЗАГРУЗКИ И ПРАВКА ЗАПРОСОВ.
- *
- * Два разных вопроса, но оба про «откуда берутся байты тайла»:
- *
- *   `addProtocol('pmtiles', …)` — адрес вида `pmtiles://…` обслуживает приложение само: читает из
- *   одного файла, из IndexedDB, из WebAssembly-читалки;
+ * СВЕТ ОБЪЁМА MapLibre — корневой `light` стиля MapLibre, как его читает `fill_extrusion_program`.
  *
- *   `setTransformRequest(fn)` — обычный адрес, но перед отправкой его правят: подписывают, меняют
- *   домен, добавляют ключ.
- *
- * ★ И ТО И ДРУГОЕ ЖИВЁТ НА ГЛАВНОМ ПОТОКЕ.
- *
- * Так же у MapLibre, и по той же причине: обработчик приложенческий — ему нужны ключи, кеш и
- * хранилища страницы. Требовать, чтобы он работал внутри воркера, значит требовать от приложения
- * писать под воркер. Поэтому байты добываются здесь, а воркеру достаётся только разбор.
+ * Свой свет (`LightSpec`) им не заменить: у MapLibre другая модель — ОДИН источник, яркость по
+ * формуле от светлоты самого цвета и нижняя граница в оттенок света. Светит он только слоям с
+ * `lighting: 'maplibre'`; наши темы его не видят.
  */
-/** Что обработчик протокола отдаёт: содержимое тайла или `null`, если тайла нет. */
-type ProtocolHandler = (url: string, signal: AbortSignal) => Promise<ArrayBuffer | null>;
-/** Правка адреса перед загрузкой. Возврат `null` означает «оставить как есть». */
-type TransformRequest = (url: string, kind: 'tile' | 'raster' | 'glyph' | 'sprite') => string | null | undefined;
+interface MapLibreLightSpec {
+    /** `viewport` — источник привязан к экрану и поворачивается вместе с курсом камеры; `map` — к карте. */
+    anchor: 'map' | 'viewport';
+    /** `[r, азимут, полярный угол]` в градусах, как в спецификации: азимут 0 — верх (север у `map`). */
+    position: [number, number, number];
+    color: Interpolated<string>;
+    intensity: Interpolated<number>;
+}
+/** Умолчания спецификации MapLibre (`light` в `v8.json`). */
+declare const DEFAULT_MAPLIBRE_LIGHT: MapLibreLightSpec;
+/**
+ * Свет по умолчанию. Азимуты источников намеренно НЕ диагональные (120/300,
+ * а не 135/315): на диагонали пары стен «восток/юг» и «запад/север» получают
+ * одинаковую яркость и дом снова выглядит плоским. При этих значениях четыре
+ * стороны дают заметно разные яркости (примерно 122, 135, 137, 160 из 255),
+ * а крыша — 234 при фоне карты 236.
+ */
+declare const DEFAULT_LIGHT: LightSpec;
 
 /** План для воркера: что именно строить из тайла. Должен пережить structured clone. */
 /** Слои, которые вообще строятся из тайла: у подложки строить нечего. */
@@ -2012,20 +4643,149 @@ interface ExpressionOperatorRef {
     /** Раздел: данные, решения, шкалы, математика… */
     group: string;
 }
-declare const STYLE_REFERENCE: StyleReference;
+declare const STYLE_REFERENCE: StyleReference;
+/**
+ * СВОИ ФЛАГИ v2 БЕЗ ПОЛЯ v1 — переключатели поведения (§1.2): без поля значение — как у MapLibre,
+ * своё поведение движка включается явно. Конвертер v1 → v2 дописывает их во встроенные стили, чтобы
+ * те рисовались как прежде.
+ */
+declare const STYLE_REFERENCE_V2_FLAGS: Record<string, Record<string, PropRef>>;
+/**
+ * Операции выражений, которые понимает движок (`style/expression.ts`). Сверяется тестом со
+ * списком `case` в `compile` — ни одной лишней и ни одной пропущенной.
+ */
+declare const STYLE_REFERENCE_EXPRESSIONS: Record<string, ExpressionOperatorRef>;
+/** Разделы выражений → названия. */
+declare const STYLE_REFERENCE_EXPRESSION_GROUPS: Record<string, string>;
+
+/**
+ * ФОРМАТ СТИЛЯ v2 = MapLibre v8 + `osmgl-*` (`porting/unified-style-format.md`).
+ *
+ * Внешний формат стиля osmgl — синтаксис MapLibre как есть: те же типы слоёв, имена свойств, поля
+ * корня и источников, выражения и старые функции. Свои свойства лежат в тех же `paint`/`layout` с
+ * приставкой `osmgl-` (геометрия — в `layout`, покраска — в `paint`), свой тип слоя —
+ * `osmgl-surface`. Признак расширений — `metadata["osmgl:version"]: 2`; без него файл — «чистый
+ * MapLibre», он же валидный v2.
+ *
+ * ★ ВНУТРЕННЯЯ МОДЕЛЬ ДВИЖКА ОСТАЛАСЬ v1 (`StyleSpec`). Переименовывать поля на трёх платформах
+ * ради имён смысла нет: облик от этого не меняется, а порты читают поля строками по всему рендеру.
+ * Поэтому v2 — формат обмена: загрузчик (`importMapLibreStyle`, расширенный чтением `osmgl-*`)
+ * переводит его во внутреннюю модель, а конвертер здесь — обратно. Таблица имён ОДНА — поле `v2` у
+ * записей `STYLE_REFERENCE`; этот модуль только собирает из неё словари и знает про особые случаи,
+ * где перевод — не переименование (пунктир, капсула, якоря подписи, ссылка на цвет).
+ *
+ * ★ БЕЗ ПОЛЯ — УМОЛЧАНИЕ MapLibre. Иначе стиль MapLibre «без правок» рисовался бы не как в MapLibre.
+ * Своё поведение движка включается явными флагами (§1.2): `osmgl-line-shape: capsule`,
+ * `osmgl-lighting: osmgl`, `osmgl-roofs: auto`, `osmgl-height-from-data`, `osmgl-symbol-layout:
+ * block` (своя система подписей целиком — с её умолчаниями), `osmgl-line-anchors`,
+ * `osmgl-text-halo-tracking`. Конвертер v1 → v2 дописывает их во встроенные стили, и те рисуются
+ * пиксель в пиксель как прежде — это проверяет `tests/style-v2.test.mjs`.
+ */
+/** Ключ признака v2 в `metadata` корня. */
+declare const OSMGL_VERSION_KEY = "osmgl:version";
+/** Значение признака: версия расширений osmgl поверх MapLibre v8. */
+declare const OSMGL_FORMAT_VERSION = 2;
+/** Стиль v2 (он же MapLibre v8) — в той форме, в какой его пишет конвертер. */
+interface StyleSpecV2 {
+    version: 8;
+    name?: string;
+    metadata?: Record<string, unknown>;
+    sources: Record<string, Record<string, unknown>>;
+    layers: LayerSpecV2[];
+    [key: string]: unknown;
+}
+interface LayerSpecV2 {
+    id: string;
+    type: string;
+    source?: string;
+    'source-layer'?: string;
+    minzoom?: number;
+    maxzoom?: number;
+    filter?: unknown;
+    metadata?: unknown;
+    layout?: Record<string, unknown>;
+    paint?: Record<string, unknown>;
+}
+/** Тема v2: та же накладка, ключи — имена v2 (`paint[id]["line-color"]`, `osmgl-light`). */
+interface ThemeSpecV2 {
+    name: string;
+    'osmgl-light'?: Record<string, unknown>;
+    sky?: Record<string, unknown>;
+    paint?: Record<string, Record<string, unknown>>;
+    layout?: Record<string, Record<string, unknown>>;
+    'osmgl-model3d-key'?: string;
+    [key: string]: unknown;
+}
+/** Стиль с признаком v2 (`metadata["osmgl:version"]`). Чистый MapLibre — тоже v2, но без своих полей. */
+declare function isOsmglV2(value: unknown): boolean;
+type V1Where = 'field' | 'paint' | 'layout';
+type V2Where = 'layer' | 'layout' | 'paint';
+/** Что конвертер не смог перенести: `слой: поле`. */
+type ConvertReport = string[];
 /**
- * СВОИ ФЛАГИ v2 БЕЗ ПОЛЯ v1 — переключатели поведения (§1.2): без поля значение — как у MapLibre,
- * своё поведение движка включается явно. Конвертер v1 → v2 дописывает их во встроенные стили, чтобы
- * те рисовались как прежде.
+ * СЛОЙ v1 → v2.
+ *
+ * Подпись: слой, поставленный импортёром MapLibre (`placementMode: maplibre`), остаётся слоем
+ * MapLibre и получает явные значения там, где умолчания v1 и MapLibre расходятся; любой другой — это
+ * своя система подписей (`osmgl-symbol-layout: block`), и его поля переносятся одним
+ * переименованием: умолчания у этой системы свои, и пустое поле значит ровно то же, что в v1.
  */
-declare const STYLE_REFERENCE_V2_FLAGS: Record<string, Record<string, PropRef>>;
+declare function layerV1toV2(layer: StyleLayerSpec, style: StyleSpec, report?: ConvertReport): LayerSpecV2;
 /**
- * Операции выражений, которые понимает движок (`style/expression.ts`). Сверяется тестом со
- * списком `case` в `compile` — ни одной лишней и ни одной пропущенной.
+ * СТИЛЬ v1 → v2. Чистая функция: та же внутренняя модель получается обратно загрузчиком
+ * (`importMapLibreStyle`) — это и есть доказательство «без потерь» (`tests/style-v2.test.mjs`).
  */
-declare const STYLE_REFERENCE_EXPRESSIONS: Record<string, ExpressionOperatorRef>;
-/** Разделы выражений → названия. */
-declare const STYLE_REFERENCE_EXPRESSION_GROUPS: Record<string, string>;
+declare function styleV1toV2(style: StyleSpec, report?: ConvertReport): StyleSpecV2;
+/**
+ * ОДНО СВОЙСТВО v2 → поля v1. Возвращает список правок (`where`, `key`, `value`), `undefined` у
+ * значения — снять поле. `null` — имя незнакомо. Общее для загрузчика, тем и API карты
+ * (`setPaintProperty('road', 'line-color', …)`).
+ */
+declare function propertyV2toV1(type: string, where: V2Where, name: string, value: unknown): {
+    where: V1Where;
+    key: string;
+    value: unknown;
+}[] | null;
+/** Внутренняя накладка: то же, что `ThemeSpec`, плюс поля слоя (их v1-темы не правили). */
+interface ThemeInternal {
+    name: string;
+    background?: string;
+    light?: Partial<LightSpec>;
+    sky?: Partial<SkySpec>;
+    paint?: Record<string, Record<string, unknown>>;
+    layout?: Record<string, Record<string, unknown>>;
+    fields?: Record<string, Record<string, unknown>>;
+    hidden?: string[];
+    model3dKey?: string;
+}
+/**
+ * ТЕМА v1 → v2 ПО БАЗОВОМУ СТИЛЮ: ключ `color` значит `fill-color`, `line-color` или `text-color`
+ * смотря по типу слоя, а тип знает только база. Id, которого в базе нет, переводится по имени поля
+ * (если оно однозначно) и попадает в отчёт.
+ */
+declare function themeV1toV2(theme: ThemeInternal, base: StyleSpec, report?: ConvertReport): ThemeSpecV2;
+/**
+ * ТЕМА (v2 или v1) → ВНУТРЕННЯЯ НАКЛАДКА. Ключи разбираются по одному: имя v2 переводится по
+ * таблице, имя v1 принимается как синоним (с одним предупреждением), незнакомое остаётся как есть —
+ * так тема прошлого выпуска, написанная приложением, продолжает работать.
+ */
+declare function themeToInternal(theme: Record<string, unknown>, base?: StyleSpec): ThemeInternal;
+/**
+ * СТИЛЬ v2 → ЧИСТЫЙ MapLibre v8: «Скачать для MapLibre» (§1.4, вопрос 2 §6).
+ *
+ * MapLibre файл со своими полями не откроет — его валидатор отвергает незнакомые свойства и типы
+ * слоёв. Поэтому `osmgl-*` срезаются, а то, у чего в MapLibre есть ближайший аналог, переводится
+ * ПРИБЛИЖЁННО (и попадает в отчёт `report`): поверхность — заливкой её цвета, ссылка на цвет — уже
+ * разрешённым цветом, список шаблонов подписи — `coalesce`, своя блочная раскладка подписи — её
+ * умолчаниями, записанными явно. Основе без адреса (`base`, «тайлы даёт карта») адрес можно дать
+ * опцией `tiles`.
+ */
+declare function toMapLibreStyle(v2: StyleSpecV2, opts?: {
+    tiles?: string | string[];
+}, report?: ConvertReport): Record<string, unknown> & {
+    version: 8;
+    layers: Record<string, unknown>[];
+};
 
 /**
  * Тема — набор правок поверх базового стиля, а не его копия.
@@ -5036,6 +7796,418 @@ declare class Marker extends Evented<MarkerEvents> {
     private applyVisibility;
 }
 
+/**
+ * Тесселяция геометрии, заданной ПОЛЬЗОВАТЕЛЕМ, а не тайлом.
+ *
+ * Отличие от `generators/*` одно, зато принципиальное — система координат.
+ * Тайловая вершина лежит в целых [0..extent] и помещается в Int16; у рантайм-объекта
+ * своего тайла нет, а маршрут через город — это десятки километров, и Int16 дал бы
+ * на них шаг около метра (на z20 это 8 пикселей дрожания).
+ *
+ * Поэтому локальные координаты здесь — **нормализованный меркатор относительно
+ * origin объекта**, во Float32. Смещения порядка 1e-4, мантиссы хватает на доли
+ * миллиметра.
+ *
+ * ЛИНИЯ СТРОИТСЯ ЛЕНТОЙ СО СТЫКАМИ — как в Mapbox (`line_bucket`): направления
+ * и биссектрисы стыков считаются ЗДЕСЬ, на CPU, в двойной точности, а в вершину
+ * кладётся готовый единичный вектор поперёк полотна. Шейдер только умножает его
+ * на полуширину в пикселях.
+ *
+ * Так было не всегда: сначала каждый отрезок рисовался отдельной «капсулой», а
+ * направление считалось в шейдере как `normalize(p1 - p0)`. В тайле это
+ * работает (координаты — целые 0..4096), а у объекта разность соседних точек в
+ * нормализованном меркаторе порядка 1e-6, и на городском маршруте линия
+ * рассыпалась в цепочку точек: отрезок короче собственной полуширины квад не
+ * накрывал. Ещё и стыков у капсул не было — на изломах оставались щели.
+ *
+ * Раскладка вершины ленты:
+ *
+ *   a_pos     2 × Float32  off 0    точка оси (локальный меркатор)
+ *   a_extrude 2 × Float32  off 8    куда раздувать, единичный (в стыке длиннее — митра)
+ *   a_side    1 × Float32  off 16   −1 | 0 | +1 — сторона полотна, 0 в центре скругления
+ *   a_dist    1 × Float32  off 20   расстояние вдоль линии, в единицах объекта
+ */
+declare const RUNTIME_LINE_STRIDE = 24;
+declare const RUNTIME_FILL_STRIDE = 8;
+interface RuntimeMesh {
+    vertices: ArrayBuffer;
+    indices: Uint32Array;
+    vertexCount: number;
+    /** Прозрачность в вершине — у площади с `alphas` (`buildRuntimeArea`); иначе нет. */
+    alphas?: Float32Array;
+    /** Метр трассы в вершине — у площади со `stations` (`buildRuntimeArea`, он же в поле расстояния вершины); иначе нет. */
+    stations?: Float32Array;
+}
+/** Путь в локальных координатах: x,y вперемешку. */
+type LocalPath = number[];
+/**
+ * Лента линии со стыками и круглыми концами.
+ *
+ * На каждую точку пути кладётся ПАРА вершин по обе стороны оси; соседние пары
+ * сшиваются двумя треугольниками. Куда раздувать вершину — решает биссектриса
+ * соседних отрезков (митра), длина её ограничена `MITER_LIMIT`.
+ *
+ * СТЫКИ СКРУГЛЁННЫЕ (`line-join: round` у Mapbox): на заметном изломе между
+ * концом одного отрезка и началом другого вставляется веер из долек, и угол
+ * получается круглым, а не срезанным. Фаска (одна долька) осталась частным
+ * случаем — ею закрываются пологие изломы, где скругления всё равно не видно.
+ * Концы тоже закрываются веером — получается скруглённый торец, как у маршрута
+ * в любой карте.
+ */
+declare function buildRuntimeLine(paths: LocalPath[]): RuntimeMesh | null;
+/**
+ * Заливка кольцами: первое — внешнее, остальные — дырки.
+ *
+ * Намотку не выправляем: earcut разбирается сам, а порядок вершин в треугольнике
+ * переворачиваем — Y меркатора направлен вниз, и без этого все грани смотрели бы
+ * от камеры (отсечение задних граней у плоских слоёв выключено, но объекты могут
+ * рисоваться и в проходе с отсечением).
+ */
+declare function buildRuntimeFill(rings: LocalPath[]): RuntimeMesh | null;
+
+/**
+ * Рантайм-объекты: то, что кладёт на карту приложение, а не тайлсервер, —
+ * маршрут, зона доставки, трек машины, окружность радиуса.
+ *
+ * Устроены не как источник тайлов, а как отдельный список: этих объектов
+ * единицы, их правят покадрово (машина едет), и гонять их через воркер и LRU
+ * означало бы платить за инфраструктуру, которая здесь ничего не экономит.
+ *
+ * У каждого объекта своё НАЧАЛО КООРДИНАТ — центр его habitat'а в нормализованном
+ * меркаторе. Вершины хранятся относительно него, поэтому во Float32 не теряется
+ * точность даже у маршрута через весь город (см. `mesh.ts`).
+ */
+interface ObjectPaint {
+    color?: string;
+    opacity?: number;
+    /** Ширина линии в CSS-пикселях (у линий) или обводки (у полигонов). */
+    width?: number;
+    /** Обводка снизу — рисуется первой и шире, как у дорог в стиле. */
+    strokeColor?: string;
+    strokeWidth?: number;
+    /** Пунктир `[штрих, пропуск]` в пикселях. */
+    dashArray?: [number, number];
+    /** Стрелки направления вдоль линии. */
+    arrow?: boolean;
+    arrowColor?: string;
+    arrowPeriod?: number;
+    arrowSize?: number;
+    /** Сдвиг поперёк линии в пикселях — для двух направлений на одной дороге. */
+    offset?: number;
+    /**
+     * Насколько виден объект ТАМ, ГДЕ ОН ЗА ГЕОМЕТРИЕЙ (0 — не виден вовсе).
+     *
+     * Маршрут лежит на земле и честно скрывается за домами — иначе он летел бы
+     * поверх города. Но тогда в плотной застройке от трассы остаются обрывки, и
+     * куда она идёт, непонятно. «Призрак» — второй, бледный проход поверх зданий
+     * ровно в тех местах, где линия ушла за них: так делают Яндекс и Google.
+     */
+    ghostOpacity?: number;
+    /**
+     * В чём заданы ширина, шаг и размер стрелок линии: `px` (по умолчанию) — экранные пиксели, `m` —
+     * метры на земле (шевроны ленты по полосам: ширина полосы, а не толщина значка).
+     */
+    units?: 'px' | 'm';
+}
+interface MapObjectOptions extends ObjectPaint {
+    /** Порядок отрисовки среди рантайм-объектов. Больше — выше. */
+    zIndex?: number;
+    /** Высота над землёй в метрах: маршрут на эстакаде, метка на крыше. */
+    altitude?: number;
+    /**
+     * ПОДЪЁМ ПОД ВЕРШИНОЙ, метры, сверх `altitude`: отметка полотна в точке `(lng, lat)` — эстакада под
+     * трассой, съезд с неё. Своя у каждой вершины (по точке оси линии, по углу заливки), поэтому линия и
+     * стрелка поворота идут по настилу и по склону подхода, а не висят на одной высоте над всей длиной.
+     * Вне эстакады — 0: объект лежит на асфальте. Считается при сборке буферов (`ObjectManager.groundOf`),
+     * сменилась функция — `setLiftAt`.
+     */
+    liftAt?: LiftAt | null;
+    /** С какого зума объект виден (как `minzoom` слоя): ниже — не рисуется и не ловит клик. */
+    minZoom?: number;
+    /**
+     * МНОЖИТЕЛЬ ПРОЗРАЧНОСТИ в кадре (0…1, по умолчанию 1): цвет объекта умножается на него при отрисовке,
+     * геометрия не пересобирается; 0 — объект не рисуется. Можно менять каждым кадром — так лента по полосам
+     * и куски линии под ней сменяют друг друга переходом (`RibbonBlend`).
+     */
+    fade?: number;
+    /**
+     * РАСТВОРЕНИЕ ВДОЛЬ ТРАССЫ ПОЗАДИ МАШИНЫ (`AlongFade`): множитель прозрачности по метру трассы точки —
+     * в шейдере, по униформу; метр машины можно менять каждым кадром без пересборки геометрии. Метр точки —
+     * у площади из `RouteAreaOptions.stations`, у линии — `base` плюс расстояние вдоль неё. Нет — не растворяется.
+     */
+    along?: AlongFade | null;
+    visible?: boolean;
+    /** Что угодно прикладное — вернётся при клике. */
+    userData?: Record<string, unknown>;
+    /** Своё имя; иначе будет сгенерировано. */
+    id?: string;
+}
+/** Одна порция геометрии: чем рисовать и какой краской. */
+interface ObjectPart {
+    kind: 'fill' | 'line';
+    mesh: RuntimeMesh;
+    color: [number, number, number, number];
+    /** Ширина в CSS-пикселях; только для `line`. */
+    width: number;
+    dashArray?: [number, number];
+    arrow?: boolean;
+    arrowColor?: [number, number, number, number];
+    arrowPeriod?: number;
+    arrowSize?: number;
+    offset?: number;
+    /**
+     * Цвет В ВЕРШИНЕ (прямой, не домноженный), по 4 числа на вершину меша; `color` тогда — множитель
+     * (берётся только его альфа: прозрачность объекта и призрака). Так рисуется линия с плавными
+     * стыками пробок одним мешем — без перекрытия кусков на стыках.
+     */
+    colors?: Float32Array;
+    /**
+     * ПЛОЩАДЬ ПРОГРАММОЙ ЛИНИИ (`RouteArea`): внутренность красится целиком, кромки — сглаживающей
+     * полосой, как край линии маршрута. Полуширина — полпикселя, сдвига и рисунка нет.
+     */
+    area?: boolean;
+    /** Ширина, шаг и размер стрелок — в метрах на земле (`ObjectPaint.units = 'm'`). */
+    metres?: boolean;
+}
+/** Отметка полотна в точке, метры (`MapObjectOptions.liftAt`). */
+type LiftAt = (lng: number, lat: number) => number;
+/**
+ * Растворение вдоль трассы (`MapObjectOptions.along`): лента по полосам позади машины не обрывается на её
+ * метре, а гаснет на `length` метров (синяя, `dir` +1) и проявляется серой пройденной (`dir` −1).
+ */
+interface AlongFade {
+    /** Метр машины. */
+    at: number;
+    /** Длина растворения позади машины, метры (> 0). */
+    length: number;
+    /** +1 — видно впереди машины, гаснет позади; −1 — наоборот. */
+    dir: 1 | -1;
+    /** У линии: метр её первой точки (метр точки = `base` + расстояние вдоль линии). У площади не нужен. */
+    base?: number;
+    /**
+     * У линии: метров на единицу её длины (меркатор, мир = 1). Нет — длина окружности на широте объекта: на
+     * длинном куске это расходится с мерой трассы на десятки метров, поэтому линия маршрута задаёт масштаб
+     * сама — по точным метрам концов куска (`routeLineAlong`).
+     */
+    scale?: number;
+}
+/**
+ * Множитель растворения в точке с метром `station` — ТО ЖЕ, что считает шейдер (`OBJECT_LINE_FRAG`, `u_along`):
+ * доля `k` = smoothstep от «машина − длина» (0) до машины (1); +1 — `k`, −1 — `1 − k`. Для тестов и сверки портов.
+ */
+declare function alongFadeFactor(along: AlongFade, station: number): number;
+declare abstract class MapObject {
+    readonly id: string;
+    zIndex: number;
+    altitude: number;
+    visible: boolean;
+    userData: Record<string, unknown>;
+    /** Подъём под вершиной (`MapObjectOptions.liftAt`); `null` — нет. */
+    private _liftAt;
+    /** С какого зума объект виден (`MapObjectOptions.minZoom`). */
+    minZoom: number;
+    /** Множитель прозрачности в кадре (`MapObjectOptions.fade`). */
+    fade: number;
+    /** Растворение вдоль трассы (`MapObjectOptions.along`); можно менять каждым кадром. */
+    along: AlongFade | null;
+    /** Начало локальных координат — нормализованный меркатор. */
+    originX: number;
+    originY: number;
+    /**
+     * Насколько объект виден там, где он за геометрией. Читает менеджер: проход
+     * призрака решает по нему, рисовать ли объект второй раз (см. `ObjectPaint`).
+     */
+    get ghostOpacity(): number;
+    protected paint: ObjectPaint;
+    /** Геометрию надо пересобрать (и перезалить в GPU). */
+    private _revision;
+    constructor(options: MapObjectOptions);
+    /** Подъём под вершиной, метры (`MapObjectOptions.liftAt`); `null` — объект на земле. */
+    get liftAt(): LiftAt | null;
+    /** Другая отметка полотна (сцена дорог перестроена) — высоты вершин пересчитываются. */
+    setLiftAt(liftAt: LiftAt | null): this;
+    private _liftRevision;
+    /**
+     * Ревизия ОТМЕТКИ ПОЛОТНА (26.10.2026): новая высота под той же формой (`setLiftAt`). Холодный старт NaviGram на порте:
+     * пачки тайлов сетки детальных дорог во время наезда камеры ведения перекладывали высоту всех объектов маршрута, и
+     * кадр пересобирал их целиком — 50–140 мс раз в 0,3 с (Redmi, `--es slow`).
+     */
+    get liftRevision(): number;
+    /** Меняется при любой правке — по нему менеджер понимает, что буферы устарели. */
+    get revision(): number;
+    protected invalidate(): void;
+    /** Правка оформления без пересборки геометрии — но буферы всё равно общие. */
+    setPaint(paint: ObjectPaint): this;
+    /** Точки объекта в ЭКРАННЫХ координатах нужны и пикингу, и отладке. */
+    abstract rings(): LngLatLike[][];
+    abstract build(): ObjectPart[];
+    /** Попадание точки экрана в объект. `project` возвращает null за камерой. */
+    abstract hitTest(point: {
+        x: number;
+        y: number;
+    }, project: (lng: number, lat: number, alt: number) => {
+        x: number;
+        y: number;
+    } | null, tolerancePx: number): boolean;
+    /**
+     * Начало координат ставим в центр рамки, а не в первую точку: у кольцевого
+     * маршрута первая точка может лежать на краю, и смещения удвоятся зря.
+     */
+    protected setOriginFromCoords(coords: LngLatLike[][]): void;
+    protected toLocal(ring: LngLatLike[]): LocalPath;
+    protected color(key: 'color' | 'strokeColor' | 'arrowColor', fallback: string): [number, number, number, number];
+    /** Общие для линий поля оформления — чтобы не повторять их в каждом объекте. */
+    protected linePaint(part: ObjectPart): ObjectPart;
+}
+/**
+ * Кусок линии со своим цветом: с точки `at` и до `at` следующего куска.
+ *
+ * Так задаётся раскраска маршрута по пробкам. Хранить цвет на каждой точке было
+ * бы и длиннее, и бессмысленно: цвет меняется на границах дорог, а не в каждой
+ * вершине геометрии.
+ */
+interface PolylineSegment {
+    /** Индекс первой точки куска в `coordinates`. */
+    at: number;
+    color: string;
+}
+interface PolylineOptions extends MapObjectOptions {
+    coordinates: LngLatLike[];
+    /**
+     * Куски со своим цветом. Пусто — линия одноцветная (`paint.color`).
+     * Первый кусок обязан начинаться с нуля; куски идут по возрастанию `at`.
+     */
+    segments?: PolylineSegment[];
+    /**
+     * ПЛАВНЫЕ СТЫКИ КУСКОВ: ширина перехода цвета на стыке, метры (0 — ступенькой, как раньше).
+     * Переход линейный, по центру на точке стыка; не шире половины любого из соседних кусков.
+     * Линия тогда строится ОДНИМ мешем с цветом в вершине: на стыке нет ни перекрытия полупрозрачных
+     * кусков, ни шва, а шевроны идут без сбоя фазы.
+     */
+    segmentBlend?: number;
+}
+/**
+ * Ломаная: маршрут, трек, граница коридора.
+ *
+ * Обводка (`strokeColor`) рисуется отдельной, более широкой линией ПОД основной —
+ * тем же приёмом, что дороги в стиле. Отдельного прохода она не требует, потому
+ * что рантайм-объекты и так рисуются по порядку.
+ */
+declare class Polyline extends MapObject {
+    private coordinates;
+    private segments;
+    private segmentBlend;
+    constructor(options: PolylineOptions);
+    /** Ширина плавного стыка кусков, метры (0 — ступенькой). */
+    setSegmentBlend(meters: number): this;
+    setCoordinates(coordinates: LngLatLike[]): this;
+    /** Перекрасить куски линии, не трогая геометрию. Пусто — снова один цвет. */
+    setSegments(segments: PolylineSegment[]): this;
+    getCoordinates(): LngLatLike[];
+    rings(): LngLatLike[][];
+    build(): ObjectPart[];
+    /**
+     * Куски в виде диапазонов точек. Пусто — линия одноцветная.
+     *
+     * Мусор во входных данных гасим здесь, а не в отрисовке: куски приходят из
+     * ответа сервиса, и один сбитый индекс не должен ронять всю линию. Куски вне
+     * диапазона и пустые отбрасываются, порядок восстанавливается сортировкой.
+     */
+    private colorRuns;
+    hitTest(point: {
+        x: number;
+        y: number;
+    }, project: (lng: number, lat: number, alt: number) => {
+        x: number;
+        y: number;
+    } | null, tolerancePx: number): boolean;
+}
+interface PolygonOptions extends MapObjectOptions {
+    /** Кольца: первое внешнее, остальные — дырки. */
+    coordinates: LngLatLike[][];
+}
+declare class Polygon extends MapObject {
+    private coordinates;
+    constructor(options: PolygonOptions);
+    setCoordinates(coordinates: LngLatLike[][]): this;
+    rings(): LngLatLike[][];
+    build(): ObjectPart[];
+    hitTest(point: {
+        x: number;
+        y: number;
+    }, project: (lng: number, lat: number, alt: number) => {
+        x: number;
+        y: number;
+    } | null): boolean;
+}
+interface RouteAreaOptions extends MapObjectOptions {
+    /** Кольца: первое внешнее, остальные — дырки (замыкающая точка не обязательна). */
+    coordinates: LngLatLike[][];
+    /**
+     * Какие кромки сглаживать: `feather[r][i]` — кромка `i → i+1` кольца `r` (без замыкающей точки).
+     * Нет — все. Шов с соседним куском той же площади не сглаживается: там нет края.
+     */
+    feather?: boolean[][];
+    /**
+     * Прозрачность В ВЕРШИНЕ кольца: `alphas[r][i]` — множитель для точки `i` кольца `r` (форма — как у
+     * `coordinates`). Между вершинами GPU смешивает линейно. Нет — площадь одной прозрачности. Так лента
+     * по полосам растворяется у концов, где её сменяет линия маршрута (`fadeRibbonArea`).
+     */
+    alphas?: number[][];
+    /**
+     * МЕТР ТРАССЫ В ВЕРШИНЕ кольца (форма — как у `coordinates`): по нему площадь растворяется позади машины
+     * (`along`). Между вершинами GPU смешивает метр линейно, а гладкую ступеньку считает в каждом пикселе.
+     */
+    stations?: number[][];
+}
+/**
+ * ПЛОЩАДЬ, НАРИСОВАННАЯ ТАК ЖЕ, КАК ЛИНИЯ МАРШРУТА: та же программа (`OBJECT_LINE_*`), тот же проход,
+ * тот же тест и сдвиг глубины, та же высота вершин (`liftAt`), то же сглаживание края и тот же порядок
+ * (`zIndex`). Так рисуются лента по полосам и стрелки поворотов — они лежат с линией одной краской.
+ */
+declare class RouteArea extends MapObject {
+    private coordinates;
+    private feather;
+    private alphas;
+    private stations;
+    constructor(options: RouteAreaOptions);
+    setCoordinates(coordinates: LngLatLike[][], feather?: boolean[][] | null, alphas?: number[][] | null, stations?: number[][] | null): this;
+    rings(): LngLatLike[][];
+    build(): ObjectPart[];
+    hitTest(point: {
+        x: number;
+        y: number;
+    }, project: (lng: number, lat: number, alt: number) => {
+        x: number;
+        y: number;
+    } | null): boolean;
+}
+interface CircleOptions$1 extends MapObjectOptions {
+    center: LngLatLike;
+    /** Радиус в МЕТРАХ на земле. */
+    radius: number;
+    /** Число сегментов; по умолчанию подбирается по радиусу. */
+    segments?: number;
+}
+/**
+ * Круг заданного радиуса в метрах — зона доставки, точность позиции, радиус поиска.
+ *
+ * Считается прямо в меркаторе: проекция конформна, поэтому круг на местности
+ * остаётся кругом на карте, надо лишь взять масштаб на широте центра. Для радиусов
+ * городского масштаба (до десятков километров) расхождение с геодезической
+ * окружностью меньше толщины линии.
+ */
+declare class Circle extends Polygon {
+    constructor(options: CircleOptions$1);
+}
+type Projected = {
+    x: number;
+    y: number;
+};
+declare function distToSegment(p: Projected, a: Projected, b: Projected): number;
+/** Классический ray casting: считаем пересечения луча вправо от точки. */
+declare function pointInRing(p: Projected, ring: Projected[]): boolean;
+
 declare class ObjectManager {
     /**
      * Высота земли в точке нормализованного меркатора — её даёт рельеф.
@@ -5134,6 +8306,447 @@ declare class ObjectManager {
     destroy(): void;
 }
 
+/**
+ * Разбор GLB (двоичный glTF 2.0).
+ *
+ * Своё, а не готовая библиотека, по той же причине, что и всё остальное в этом
+ * движке: нам нужна ровно та часть формата, которая доедет до нашего рендера, —
+ * позиции, нормали, координаты текстуры, индексы, базовый цвет и его текстура.
+ * Полноценный загрузчик тащит за собой анимации, скиннинг, KHR-расширения и
+ * декодеры сжатия; всё это здесь пока некуда девать.
+ *
+ * meshopt (`EXT_meshopt_compression`) поддержан: именно в нём лежат ВСЕ наши
+ * боевые ассеты — сервис Objects3D прогоняет загруженный glTF через gltfpack
+ * (`-cc`, два уровня LOD), и без декодера с сервера не читается ни одна модель.
+ * Декодер берётся из библиотеки `meshoptimizer` (MIT, автор формата) — писать
+ * свой значит переписывать эталонную реализацию ради тех же байтов.
+ * Вместе с ним приходит и КВАНТИЗАЦИЯ (`KHR_mesh_quantization`): позиции едут
+ * целыми с масштабом в матрице узла, нормали и развёртка — нормализованными
+ * целыми, поэтому аксессоры обязаны знать про `normalized`.
+ *
+ * Чего сознательно НЕТ:
+ *  - Draco — свой декодер, а наши ассеты в него не пакуются;
+ *  - анимации и скиннинг;
+ *  - PBR сверх базового цвета: металличность и шероховатость движок пока не
+ *    использует, а рисовать их «наполовину» хуже, чем не рисовать.
+ *
+ * Иерархия узлов СХЛОПЫВАЕТСЯ на разборе: каждый примитив получает свою мировую
+ * матрицу и уезжает в общий буфер. Держать дерево незачем — анимации нет, а
+ * лишние вызовы отрисовки на узел дороже одного большого буфера.
+ */
+/** Байт на вершину: позиция 3×f32, нормаль 3×f32, текстура 2×f32. */
+declare const MODEL_VERTEX_STRIDE = 32;
+interface ModelPrimitive {
+    /** Смещение в общем индексном буфере и число индексов. */
+    indexOffset: number;
+    indexCount: number;
+    /** Базовый цвет материала, RGBA 0..1. */
+    baseColor: [number, number, number, number];
+    /**
+     * СОБСТВЕННОЕ свечение материала: `emissiveFactor` × `emissiveStrength`.
+     *
+     * Прибавляется к освещённому цвету и НЕ умножается на свет сцены — в этом весь
+     * смысл: поверхность светится сама. Художник задаёт им «нижний порог» яркости,
+     * чтобы объект не проваливался в черноту, а окна и вывески читались ночью.
+     *
+     * В наших моделях это заполнено осмысленно: у стены 0.22, у двери 0.5, у окна
+     * 0.12, у вывески 0.3. Раньше мы читали из материала только базовый цвет, и всё
+     * это терялось — модель выходила темнее задуманного, а ночью гасла совсем.
+     * Тот же приём у Mapbox называется `emissive-strength`.
+     */
+    emissive: [number, number, number];
+    /**
+     * Металличность и шероховатость — по ним считается отражение.
+     *
+     * ОТСТУПЛЕНИЕ ОТ СПЕЦИФИКАЦИИ, и оно намеренное. По стандарту оба значения по умолчанию равны
+     * ЕДИНИЦЕ, то есть материал без разметки — это «идеально шероховатый металл». На практике так
+     * не бывает: экспортёры просто не пишут поля, которых художник не трогал. В библиотеке карты у
+     * дворца два материала из трёх именно такие, и буквальное чтение стандарта делало из белого
+     * камня чёрный металл.
+     *
+     * Поэтому правило такое: если НЕ ЗАДАНО НИ ОДНО из полей — материал считается матовым
+     * диэлектриком (0 и 1), то есть ровно тем, чем он выглядит. Стоит указать хотя бы одно —
+     * работают умолчания стандарта, и автор получает ровно то, что записал.
+     */
+    metallic: number;
+    roughness: number;
+    /** Индекс изображения в `images` или -1. */
+    texture: number;
+    /** Двусторонний материал — отсечение граней выключается. */
+    doubleSided: boolean;
+    /**
+     * Полупрозрачный материал (`alphaMode: BLEND`).
+     *
+     * Различать обязательно: в моделях сплошь и рядом лежит «подложка-тень» —
+     * плоскость под объектом с полупрозрачной текстурой. Нарисованная непрозрачно,
+     * она выглядит чёрной кляксой (ровно это и было видно под машиной), а в карту
+     * теней такую плоскость пускать нельзя вовсе.
+     */
+    blend: boolean;
+    /** Порог отсечения для `alphaMode: MASK`. */
+    alphaCutoff: number;
+    /**
+     * Узел, который двигает этот примитив, или −1.
+     *
+     * У неподвижных примитивов преобразование узла ЗАПЕЧЕНО в позиции (так дешевле
+     * всего: один буфер, один вызов). У подвижных запечь нечего — их матрица
+     * меняется каждый кадр, — поэтому позиции хранятся в системе самого узла, а
+     * матрицу даёт `Model.nodeMatrix`.
+     */
+    node: number;
+}
+/** Дорожка одного свойства узла: когда и во что оно превращается. */
+interface AnimChannel {
+    path: 'translation' | 'rotation' | 'scale';
+    /** Моменты времени в секундах. */
+    times: Float32Array;
+    /** Значения подряд: 3 числа на кадр у сдвига и масштаба, 4 у кватерниона. */
+    values: Float32Array;
+    /** Ступенькой, а не линейно. */
+    step: boolean;
+}
+/** Подвижный узел: неизменная часть цепочки предков + его собственные дорожки. */
+interface AnimNode {
+    /**
+     * Ближайший подвижный ПРЕДОК или −1.
+     *
+     * Без него анимация предка теряется: у клипа с подъёмом и разворотом это два
+     * разных узла (верхний поднимает, нижний вертит), и запомни мы только
+     * статическую матрицу предков — объект остался бы вертеться на месте, не
+     * поднимаясь. Матрица подвижного узла поэтому собирается по цепочке.
+     */
+    parentNode: number;
+    /** Статическая часть цепочки — от подвижного предка (не включая) до этого узла. */
+    parent: Mat4;
+    /** Значения узла без анимации: тем, чего нет в клипе, остаётся своё. */
+    base: {
+        t: [number, number, number];
+        r: [number, number, number, number];
+        s: [number, number, number];
+    };
+    channels: AnimChannel[];
+}
+interface ModelAnimation {
+    /** Длительность клипа в секундах — по ней время заворачивается в цикл. */
+    duration: number;
+    nodes: Map<number, AnimNode>;
+}
+/**
+ * Источник света из `KHR_lights_punctual` — то, чем художник рисует ночную подсветку объекта.
+ *
+ * Координаты и радиус — В ПРОСТРАНСТВЕ МОДЕЛИ, там же, где лежат вершины. Это не мелочь: модель
+ * ставится на карту своей матрицей, и переводить светильники в мировые координаты пришлось бы на
+ * каждый экземпляр. В пространстве модели они общие для всех экземпляров одного файла, и шейдер
+ * считает освещение прямо там.
+ */
+interface ModelLight {
+    /** `directional` держим ради полноты: свет сцены у нас свой, и такой источник шейдер пропускает. */
+    type: 'point' | 'spot' | 'directional';
+    color: [number, number, number];
+    /** Кандела у точечного и прожектора, люкс у направленного — как в спецификации. */
+    intensity: number;
+    /** Радиус влияния в единицах модели; 0 — не ограничен. */
+    range: number;
+    position: [number, number, number];
+    /** Куда светит прожектор: −Z узла, приведённая к единичной длине. */
+    direction: [number, number, number];
+    /** Косинусы углов конуса: внутри `cosInner` светит в полную силу, за `cosOuter` не светит вовсе. */
+    cosInner: number;
+    cosOuter: number;
+}
+interface ModelMesh {
+    vertices: ArrayBuffer;
+    indices: Uint32Array;
+    primitives: ModelPrimitive[];
+    /** Картинки базового цвета в виде байтов файла (PNG/JPEG) — декодирует уже GPU-слой. */
+    images: Uint8Array[];
+    /** Габариты в единицах модели (обычно метры) — по ним считается масштаб на карте. */
+    min: [number, number, number];
+    max: [number, number, number];
+    /** Анимация узлов; null — модель неподвижна. */
+    animation: ModelAnimation | null;
+    /** Собственная подсветка объекта из `KHR_lights_punctual`. Пусто у моделей без неё. */
+    lights: ModelLight[];
+}
+/**
+ * Разбор GLB, в том числе meshopt-сжатого.
+ *
+ * Асинхронный, потому что декодер meshopt это WebAssembly: до первого разбора
+ * его надо инстанцировать. Ждём мы это ровно один раз на страницу.
+ */
+declare function parseGlbAsync(buffer: ArrayBuffer): Promise<ModelMesh>;
+declare function parseGlb(buffer: ArrayBuffer): ModelMesh;
+
+/**
+ * 3D-модель на карте: glTF/GLB по координате.
+ *
+ * Главное требование к этой подсистеме было не «уметь glTF», а **жить в одной
+ * сцене со зданиями**: модель обязана отбрасывать тень на дом и получать тень от
+ * него. Поэтому отдельного прохода теней у моделей нет — они идут в тот же
+ * `renderShadowMap`, что и экструзия. Второй shadow-map мы уже пробовали в
+ * `maps3d-web` и уронили этим кадр (память `maps3d-object-shadows`).
+ */
+interface ModelOptions {
+    /** Адрес .glb. Обычный glTF с внешними файлами не поддерживается. */
+    url: string;
+    /**
+     * Своя доставка байтов вместо простого `fetch(url)`.
+     *
+     * Нужна ассетам Objects3D: перед разбором у них кеш в IndexedDB, запрос
+     * ключа и расшифровка AES-GCM. Знание об этом сервисе модели ни к чему —
+     * ей нужен GLB, а откуда он взялся, решает вызывающий. `url` при этом
+     * остаётся: он идёт в сообщения об ошибках.
+     */
+    fetchBytes?: () => Promise<ArrayBuffer>;
+    coordinates: LngLatLike;
+    /** Высота над землёй, метры. */
+    altitude?: number;
+    /**
+     * Множитель к единицам модели.
+     *
+     * Единицы у моделей какие угодно: в наборе Khronos ToyCar имеет габарит 7 см,
+     * а Fox — 155 «метров». Приводить их к общему знаменателю на глаз бессмысленно,
+     * поэтому масштаб — обязанность приложения. Помогает `fitHeight`.
+     */
+    scale?: number;
+    /** Подогнать масштаб так, чтобы высота модели стала такой, метры. */
+    fitHeight?: number;
+    /** Разворот вокруг вертикали, градусы (0 — модель смотрит на север). */
+    rotation?: number;
+    /**
+     * Доборные наклоны в градусах — вокруг осей X и Z ПРОСТРАНСТВА МОДЕЛИ.
+     *
+     * Нужны размещениям из редактора: там у объекта три угла, и хотя в наших
+     * данных сейчас ненулевой только разворот, поворот лежащего набок объекта
+     * задаётся именно ими.
+     */
+    rotationTiltX?: number;
+    rotationTiltZ?: number;
+    /**
+     * Появляться ростом из земли, как здания.
+     *
+     * По умолчанию ВЫКЛЮЧЕНО: модель, добавленную приложением через `addModel`,
+     * оно ожидает увидеть на своём месте сразу. Включают его детальные
+     * 3D-объекты карты — там объект подъезжает сам, и рост объясняет, откуда он.
+     */
+    growIn?: boolean;
+    visible?: boolean;
+    userData?: Record<string, unknown>;
+    id?: string;
+}
+declare class Model {
+    readonly id: string;
+    visible: boolean;
+    userData: Record<string, unknown>;
+    coordinates: LngLatLike;
+    altitude: number;
+    /**
+     * ПОДЪЁМ РЕЛЬЕФОМ, метры: высота земли под моделью.
+     *
+     * Держится отдельно от `altitude`, а не складывается с ней при создании, по двум причинам: сама
+     * высота модели приходит из данных и не должна теряться, а рельеф догружается сетью и меняется
+     * уже после того, как модель поставлена.
+     */
+    groundZ: number;
+    rotation: number;
+    rotationTiltX: number;
+    rotationTiltZ: number;
+    scale: number;
+    fitHeight?: number;
+    /** Разобранная геометрия; null, пока грузится. */
+    mesh: ModelMesh | null;
+    /** Готовые картинки базового цвета — по индексу из `mesh.images`. */
+    bitmaps: (ImageBitmap | null)[];
+    error: string | null;
+    private loading;
+    /**
+     * Адрес меша — он же ключ ОБЩИХ ресурсов GPU.
+     *
+     * У замены по типу сотни копий одного файла (на замере 634 правила из 653 размещений), и меш у
+     * них буквально один объект: кеш ассетов отдаёт его по этому же адресу. Значит и буферы с
+     * текстурами обязаны быть общими, иначе каждая копия везёт в память свою.
+     */
+    readonly url: string;
+    private readonly fetchBytes?;
+    private matrix;
+    /**
+     * Появление: доля роста по вертикали, 0..1.
+     *
+     * Ровно то же, что у зданий (`u_height_scale`): объект вырастает из земли, а
+     * не возникает целиком. Для модели это не отдельный проход, а множитель к
+     * вертикальной оси базиса — та же матрица уходит и в карту теней, поэтому
+     * тень растёт вместе с объектом.
+     */
+    grow: number;
+    /** Куда идёт появление: 1 — вырастает, 0 — уходит в землю. */
+    growTarget: 0 | 1;
+    private animateIn;
+    private shrinkFrom;
+    private growStart;
+    /**
+     * Прозрачность, 0..1 — ею объект уступает место плану этажа и возвращается.
+     *
+     * Отдельно от `grow`, хотя оба про «появился/пропал». Рост — это ПОЯВЛЕНИЕ
+     * объекта на карте (он вырастает из земли, как здание), и он уместен, когда
+     * объект действительно приехал или уехал. А здесь объект никуда не девается:
+     * камера просто зашла внутрь дома, и модель обязана уйти, не привлекая к
+     * себе внимания, — вырастающая обратно из земли башня при выходе из плана
+     * читается как новое событие на карте, которого не было.
+     */
+    fade: number;
+    /**
+     * Непрозрачность из СТИЛЯ (`osmgl-model-opacity` слоя моделей), 0..1. Множится на `fade`: стиль
+     * задаёт облик, а `fade` — уступку плану этажа, и одно не должно перетирать другое.
+     */
+    styleOpacity: number;
+    /** Отбрасывает ли модель тень (`osmgl-model-cast-shadows`). Получает её в любом случае. */
+    castShadows: boolean;
+    /**
+     * ПОВЕРХ СЦЕНЫ — значок, а не предмет города (машина навигатора, `NavCarOverlay`).
+     *
+     * Такая модель не рисуется в проходе объёма: слой отдаёт её отдельному проходу в самом конце
+     * кадра (`renderOnTop`), после подписей и с ОЧИЩЕННОЙ глубиной. Дом впереди её не закрывает, а
+     * свои грани она по-прежнему прячет друг за другом. Так ведёт себя курсор Google: машина
+     * крупнее настоящей (держит размер значка), и в честной глубине она бы втыкалась в дома на
+     * каждом повороте. В карту теней и в пачку (`renderInstanced`) такие модели не идут.
+     */
+    onTop: boolean;
+    /** Итоговая непрозрачность в кадре. */
+    get alpha(): number;
+    private fadeTarget;
+    private fadeFrom;
+    private fadeStart;
+    private matrix32;
+    private nodeMatrix32;
+    private normal32;
+    constructor(options: ModelOptions);
+    get isLoaded(): boolean;
+    /** Скачивает и разбирает модель. Повторные вызовы возвращают ту же работу. */
+    load(onDone?: () => void): Promise<void>;
+    /**
+     * Продвинуть появление. Возвращает true, пока рост не закончен, — это сигнал
+     * карте просить следующий кадр.
+     *
+     * Отсчёт начинается с ПЕРВОГО кадра, где модель готова: до этого её ещё нет
+     * на экране, и стартуй мы от начала загрузки, объект просто возникал бы уже
+     * выросшим.
+     */
+    advanceGrow(durationSec: number): boolean;
+    /**
+     * Начать уход в землю. Повторный вызов ничего не сбрасывает — иначе объект
+     * на границе радиуса дёргался бы, начиная исчезновение заново каждый кадр.
+     */
+    retire(): void;
+    /**
+     * Спрятать или показать объект ПЛАВНО.
+     *
+     * Повторный вызов с той же целью ничего не сбрасывает: решение принимается
+     * каждый кадр (план этажа то открыт, то нет), и перезапуск отсчёта оставил бы
+     * прозрачность навсегда замершей у начального значения.
+     */
+    setHidden(hidden: boolean): void;
+    /**
+     * Продвинуть исчезновение. Возвращает true, пока оно идёт, — карте это сигнал
+     * просить следующий кадр.
+     */
+    advanceFade(durationSec: number): boolean;
+    /** Объект уже стоит: показать сразу, без повторного роста. */
+    markGrown(): void;
+    /** Вернуть к жизни объект, который уже начал уходить. */
+    revive(): void;
+    /** Эффективный масштаб с учётом `fitHeight`. */
+    effectiveScale(): number;
+    /**
+     * Радиус охватывающей сферы в МЕТРАХ — для отсечения по пирамиде видимости.
+     *
+     * Берём габарит из glTF и умножаем на действующий масштаб. Сфера заведомо больше настоящей формы,
+     * и это правильная сторона ошибки: лишний раз нарисовать дальнее дерево дешевле, чем срезать
+     * половину дворца, попавшую в кадр краем.
+     */
+    boundingRadiusM(): number;
+    /** Начало координат модели в нормализованном меркаторе. */
+    origin(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Матрица «единицы модели → локальные координаты объекта».
+     *
+     * Смена системы координат здесь и есть всё содержание: в glTF оси
+     * `x = вправо, y = вверх, z = на зрителя`, у нас — `x = восток, y = ЮГ,
+     * z = вверх`. Отсюда перестановка `(x, y, z) → (x, z, y)`: она же меняет
+     * рукость системы с правой на левую, а наша именно левая.
+     *
+     * Горизонталь переводится в нормализованный меркатор (делением на длину
+     * параллели), вертикаль остаётся В МЕТРАХ: матрица камеры сама домножит её на
+     * `pixelsPerMeter`. Перепутать эти две — классический способ получить модель,
+     * которая с зумом растёт или тонет в земле.
+     */
+    private localMatrix;
+    /**
+     * Матрица модели в ЗАДАННОМ пространстве объекта.
+     *
+     * Отдельный метод, потому что пространств два: камера и источник света. Обе
+     * матрицы обязаны строиться из одной локальной — иначе глубина, записанная в
+     * карту теней, разойдётся с той, по которой модель потом сравнивают, и модель
+     * начнёт затенять сама себя.
+     */
+    matrixInSpace(objectMatrix: Float32Array, out32?: Float32Array): Float32Array;
+    /**
+     * Позиция камеры В ЕДИНИЦАХ МОДЕЛИ — для отражений.
+     *
+     * Отражению нужен вектор взгляда, а вершины и собственные светильники модели живут в её
+     * собственном пространстве. Переводить их в мировые координаты пришлось бы на каждый экземпляр;
+     * дешевле перевести туда одну камеру.
+     *
+     * Общей инверсии матрицы здесь нет и не нужно. `localMatrix` — это перестановка осей
+     * (glTF x,y,z → восток, вверх, юг) с ОДНИМ масштабом плюс поворот, а такое обращается
+     * транспонированием: сначала снимаем масштаб, потом поворот, потом перестановку.
+     *
+     * Тонкость с единицами: по горизонтали объектное пространство измеряется в долях меркатора, по
+     * вертикали — в метрах. Поэтому горизонталь домножается на длину параллели, приводя всё к метрам,
+     * и только затем делится на масштаб модели.
+     */
+    cameraInModelSpace(tr: Transform): [number, number, number];
+    /** Полная матрица модели для камеры. */
+    matrixFor(tr: Transform): Float32Array;
+    /**
+     * Накрывает ли модель эту точку по горизонтали (нормализованный меркатор).
+     *
+     * Нужно маске заменённых зданий: модель дворца стоит не над одним домом, а
+     * над целым комплексом, и «спрятать дом под точкой привязки» оставляет на
+     * карте все его крылья. Пятно берём как ПОВЁРНУТЫЙ прямоугольник габарита:
+     * настоящий контур модели нам взять неоткуда, а прямоугольник её габарита
+     * ошибается наружу лишь на углах.
+     */
+    coversPoint(mercX: number, mercY: number): boolean;
+    /** Есть ли у модели клип — по нему карта решает, просить ли следующий кадр. */
+    get isAnimated(): boolean;
+    /**
+     * Матрица ПОДВИЖНОГО узла для камеры: та же модельная, домноженная справа на
+     * положение узла в этот момент.
+     *
+     * Отдельный метод, а не поле: узлов у клипа единицы, а считается это на
+     * каждый кадр и на каждую модель — держать кэш дороже, чем перемножить.
+     */
+    matrixForNode(tr: Transform, node: number, timeSec: number): Float32Array;
+    /**
+     * Матрица подвижного узла в ЗАДАННОМ пространстве объекта.
+     *
+     * Пространств два — камера и источник света, — и обе матрицы обязаны
+     * строиться из одной и той же позы узла: разойдись они, и анимированная
+     * часть начнёт отбрасывать тень от другого своего положения.
+     */
+    matrixInSpaceForNode(objectMatrix: Float32Array, node: number, timeSec: number, out32: Float32Array): Float32Array;
+    /**
+     * Матрица нормалей: те же оси, но без масштаба и без переноса.
+     * Масштаб у нас неравномерный (горизонталь в меркаторе, вертикаль в метрах),
+     * поэтому нормали нельзя гонять основной матрицей — они перестанут быть
+     * перпендикулярными, и свет поедет.
+     */
+    normalMatrix(): Float32Array;
+}
+
 /**
  * Слой 3D-моделей.
  *
@@ -13069,4 +16682,4 @@ declare class Map$1 extends Evented<MapEvents> {
     destroy(): void;
 }
 
-export { type AnimationOptions, type ArrowSize, AssetLoader, type AssetLoaderOptions, AttributionControl, type AxisChain, BASE_ICONS, BASE_SOURCE, BUILDING_HEIGHT_SCALE, BUILDING_POS_SCALE, BUILDING_VERTEX_STRIDE, BackgroundLayerSpec, BoxZoomHandler, type BridgeProfile, type BuildingCell, type BuildingCells, type BuildingHit, type BuildingsMesh, CELL_GRID, CIRCLE_PROPS, CIRCLE_VERTEX_STRIDE, CITY_STYLE, CLIP_END, CLIP_START, type CameraOptions, type CameraUpdate, type CircleOptions as CircleBucketOptions, type CircleMesh, type CollatorValue, ColorReliefLayerSpec, type ControlPosition, CooperativeGesturesHandler, type CoverOptions, type CustomLayer, DASH_MAX, DATA_PAINT_EXT_STRIDE, DATA_PAINT_STRIDE, DEFAULT_HEATMAP_COLOR, DEFAULT_ICONS, DEFAULT_SHADOWS, DEFAULT_STYLE, type DataPaintSpec, type DemCustomEncoding, type DemEncoding, DemLayerData, DemLayerSpec, DemLayers, DemSource, type DemSourceOptions, DemTile, DemTileEntry, DepthTarget, type DeviceHints, EXPRESSION_OPERATORS, type ExprContext, type ExprValue, type ExpressionIssue, type ExpressionOperatorRef, FACADE_FOCUS_RANGE_M, FACADE_GONE_MPP, FILL_VERTEX_STRIDE, FLIP_HOLD_DEG, FOG_FAR_MIN_M, FOG_NEAR_MIN_M, type FacadeView, FeaturePaint, type FeatureStateId, FeatureStatePainter, FeatureStateStore, Filter, type FitBoundsOptions, type FogPlanes, FogSpec, type FogWall, type FontFaceDeclaration, FontFaces, type FontFacesSpec, type FormatPiece, type FormatSectionData, type FormattedSection, type FormattedValue, FullscreenControl, GLOBAL_STATE, GLYPH_BORDER, GLYPH_SIZE, GRADIENT_SIZE, GRADIENT_STEP_SIZE, GROUND_SCALE, type GeoJSONData, type GeoJSONFeature, type GeoJSONFeatureCollection, type GeoJSONGeometry, type GeoJSONPosition, GeoJSONSource, GeolocateControl, GeomType, GestureHandler, type GestureOptions, GlobeControl, type Glyph, type GlyphMetric, GlyphSource, type GpuClass, GroundArrows, HEATMAP_LAYOUT, HEATMAP_PROPS, HEATMAP_VERTEX_STRIDE, HOST_SOURCE_KEY, type HeatmapMesh, type HeatmapOptions, HeatmapPass, HillshadeLayerSpec, ICON_ALIASES, ICON_SOURCES, type IControl, IconSource, ImageManager, type ImageValue, IndoorMask, Interpolated, type Junctions, LABEL_FOG_MAX, LD_DEFAULTS, LEVEL_LIMIT, LINE_PROGRESS_STRIDE, LINE_VERTEX_STRIDE, type LaneArrow, type LaneGuide, type LaneGuideOptions, LayerOpacityTarget, type LayerPlan, LayerRenderer, type LayerTypeName, type LayerTypeRef, type LdMesh, type LdMeshOptions, type LiftField, LightSpec, type LineGradientMesh, type LinePlacement, LngLat, LngLatBounds, LngLatBoundsLike, LngLatLike, type LoadStyleOptions, type LoadedStyle, LogoControl, MAPLIBRE_STYLES, MAPLIBRE_STYLE_BASE, MAPLIBRE_SUPPORT, MAPLIBRE_TRANSITION, MAX_GRADE, MESH_BOTTOM, MESH_ISLAND, MESH_KERB_SIDE, MESH_KERB_TOP, MESH_SIDE, MESH_TOP, MIN_PIER_HEIGHT_METERS, MITER_MAX_TURN, MLIGHT_CITY_STYLE, ML_EXTENT, MNIGHT_CITY_STYLE, Map$1 as Map, type MapCameraEvent, type MapEvents, type MapLayerEvent, type MapLayerEventType, type MapLibreImport, type MapLibreLayer, MapLibreLightSpec, type MapLibreSource, type MapLibreStyle, type MapLibreSupport, type MapLibreSupportStatus, MapObject, type MapOptions, Marker, type MarkerAnchor, type MarkerEvents, type MarkerOptions, type Marking, type MarkingKind, type MarkingOptions, type MarkingRing, type MediaCoordinates, type MediaKind, MediaSource, type MeteredPiece, MltTile, Model, ModelLayer, ModelMesh, NavigationControl, OCCLUSION_MAX_SAMPLES, OCCLUSION_NEAR_M, OCCLUSION_NEAR_SHARE, OCCLUSION_STEP_M, OCCLUSION_TOLERANCE_M, OSMGL_STYLES, ObjectManager, Objects3DLayout, Objects3DManager, type OverzoomPlan, PAINT_TRANSITIONS, PIER_SPACING_METERS, type Padding, PaintStamp, PaintTransitions, type Pier, type PierOptions, type PlacedGlyph, type PlacedSymbol, PointLike, type PolygonPiece, Popup, type PopupOptions, Projection, type PropRef, type PropType, type ProtocolHandler, type QualityChange, QualityGovernor, type QualityName, type QualityProfile, type QueriedFeature, type QueryGeometry, RELIEF_DARK_KEEP, RELIEF_DARK_LUMA, RELIEF_LIGHT_ALTITUDE, RELIEF_LIGHT_AZIMUTH, RELIEF_STYLE, ROAD_MESH_RADIUS_BY_CORNER, ROAD_SIGNS, type RampOptions, RasterSource, type RasterSourceOptions, RasterTile, type RenderedQueryOptions, type RoadAxis, type RoadChain, type RoadEdges, type RoadGraph, type RoadGraphOptions, type RoadHeightOptions, type RoadHeights, type RoadMesh, type RoadMeshOptions, type RoadNode, type RoadRay, type RoadSourceEdges, type RoadSurface, type RoadSurfaceOptions, type RoundOptions, SDF_EDGE, SDF_PX, SIGN_SIZE, SOFT_STYLE, SPLIT_SEP, STYLE_REFERENCE, STYLE_REFERENCE_EXPRESSIONS, STYLE_REFERENCE_EXPRESSION_GROUPS, STYLE_REFERENCE_V2_FLAGS, SURFACE_CUT_BLEED, SURFACE_LEVEL_SCALE, SURFACE_VERTEX_STRIDE, SYMBOL_DATA_FIELDS, ScaleControl, ScreenPoint$1 as ScreenPoint, SdfAtlas, type ShadowSettings, type ShapedImage, SkySpec, type SlitResult, SourceSpec, type StateIndex, StateIndexBuilder, Style, type StyleImage, type StyleImageData, type StyleImageOptions, type StyleIssue, type StyleLayerHit, StyleLayerSpec, type StyleReference, StyleSpec, StyleSpecV2, type StyleValidation, SymbolDataBuilder, type SymbolDataColumn, type SymbolDataColumns, type SymbolDataKind, type SymbolHit, SymbolRenderer, TAPER_METERS, TERRAIN_STYLE, THEMES, type TaperedWidth, TerrainControl, type ThemeInput, type ThemeSpec, ThemeSpecV2, type TileAddress, type TileEncoding, TileID, Transform, type TransformConstrain, type TransformRequest, TransitionSpec, VectorTileLayer, type ZoomCurve, abbreviateStreet, addGround, allowsVerticalWritingMode, anonymousParts, applyTheme, arrowLabelOffset, arrowVertices, asFormatted, asImage, bridgePiers, bridgeProfile, buildCells, buildRoadGraph, buildTile, buildZoomFor, builtinMapLibreStyle, builtinOsmglStyle, cellBeyondFocus, cellFacadeGone, cellGround, cellOutside, chainAxes, changedBuckets, circleValuesOf, clampPixelRatio, classifyRenderer, clipLineToRect, clipLineWithMetrics, clipPolygonParts, closeSlits, clusterProperties, colorsOf, contrastFactor, convertFilter as convertMapLibreFilter, convertValue as convertMapLibreValue, coordinateDigits, coveringTiles, createGround, cutMargin, dashArrayAt, dashRow, dataPaintT, Map$1 as default, densifyLine, deviceHints, easeCubicInOut, evaluateColor, evaluateExpression, evaluateNumber, evaluateVec2, expressionColor, expressionIssues, expressionNumber, extractFeature, facadeFocusBand, facadeGoneDepth, facadeLite, facadeView, featureContext, featureDrivenPaint, featureLevel, featureRuns, featureStateIdOf, fillFootprint, fillTileUrl, fitIconToText, fogCutoffOf, fogPlanes, fogRangeOf, fogWall, footprintOf, formatHash, formattedSections, generateBuildings, generateCircles, generateFill, generateGradientLine, generateHeatmap, generateLine, generateSurface, generateSymbols, groundAt, heatmapRamp, heatmapT, iconRotateOf, iconRotation, importMapLibreStyle, insideFootprint, isExpression, isMapLibreStyle, isStepGradient, isSupportedScript, junctionIndex, keptIndices, labelFogFade, labelReach, laneArrow, laneGuides, latRange, layerOpacityOf, layerZoomCeiling, layersToRebuild, layoutAtZoom, ldRoadMesh, liftFields, lineClipsOf, lineGradientRamp, loadMapLibreStyle, loadStyle, makeFeaturePaint, centerAnchor as mapLibreCenterAnchor, clipLine as mapLibreClipLine, mapLibreFogDepth, mapLibreFogOpacity, mapLibreHorizon, lineAnchors as mapLibreLineAnchors, mapLibreSpot, matchesFilter, meanWidth, mercFeaturesToGeometry, mercatorBounds, mergeBuild, modelLodFloor, needsAdjust, needsDataPaint, nextQualityDown, numbersOf, overzoomPlan, packDem, parseGlbOffThread, parseGlyphs, parseHash, parseLift, parseUnicodeRange, parseVectorTile, patchUV, patternNameAt, patternOrigin, pickBuilding, pickFill, pitchIntent, pixelAlignShift, placeAlongLine, placeMarking, polylineLength, primaryVectorSource, projectLine as projectSymbolLine, promoteName, qualityFor, qualityProfile, queryRendered, querySource, refineLine, relaxAngle, relaxCurvature, relaxForMiter, reliefLight, reliefStops, reliefTintOn, replaceGlobalState, resolveStyleUrls, resolveSymbolColor, resolveSymbolField, resolveSymbolItem, resolveSymbolNumber, resolveSymbolVec2, resolveTemplate, rewriteSymbolPaint, ribbonFromEdges, ribbonRing, ribbonShape, ringEdges, roadEdges, roadHeights, roadMarkings, roadMesh, roadSurfaces, roundLine, roundRing, roundRings, saturationFactor, sdfFromAlpha, shapeFormatted, shapeText, shapeTextCached, shapeVertical, snapCutsInward, snapRoadEnds, speedSign, spinWeights, splitBucketKey, splitByGround, squareClosed, stitchPieces, stopLine, stretchQuads, styleWithTheme, surfaceWritesDepth, symbolDataPlan, taperedWidth, terrainOccludes, tileInBounds, tileLayer, tileRingsToGeometry, tileUrl, toMercator, transitionOf, translateTileUnits, translatedMatrix, tryParseColor, unpackVector, usesFeatureState, validateStyle, validateTheme, variableOffset, verticalizePunctuation, waffle, wantsHostSource, withHostSource, worldAlongLine, writeCircleValues, yieldTargetsOf, zebra, zoomCeilingOf, zoomCurveOf };
+export { type AlongFade, type AnimationOptions, type ArrowSize, AssetLoader, type AssetLoaderOptions, AttributionControl, type AxisChain, BASE_ICONS, BASE_SOURCE, BUILDING_HEIGHT_SCALE, BUILDING_POS_SCALE, BUILDING_VERTEX_STRIDE, type BackgroundLayerSpec, BoxZoomHandler, type BridgeProfile, type BuildingCell, type BuildingCells, type BuildingHit, type BuildingsMesh, CELL_GRID, CIRCLE_PROPS, CIRCLE_VERTEX_STRIDE, CITY_STYLE, CLIP_END, CLIP_START, type CameraOptions, type CameraUpdate, Circle, type CircleOptions as CircleBucketOptions, type CircleLayerSpec, type CircleMesh, type CircleOptions$1 as CircleOptions, type CollatorValue, type ColorReliefLayerSpec, type ControlPosition, CooperativeGesturesHandler, type CoverOptions, type CustomLayer, DASH_MAX, DATA_PAINT_EXT_STRIDE, DATA_PAINT_STRIDE, DEFAULT_FOG, DEFAULT_HEATMAP_COLOR, DEFAULT_ICONS, DEFAULT_LIGHT, DEFAULT_MAPLIBRE_LIGHT, DEFAULT_SHADOWS, DEFAULT_SKY, DEFAULT_STYLE, type DataPaintSpec, type DemCustomEncoding, type DemEncoding, DemLayerData, type DemLayerSpec, DemLayers, DemSource, type DemSourceOptions, DemTile, DemTileEntry, DepthTarget, type DeviceHints, EARTH_CIRCUMFERENCE, EXPRESSION_OPERATORS, type ExprContext, type ExprValue, type ExpressionIssue, type ExpressionOperatorRef, FACADE_FOCUS_RANGE_M, FACADE_GONE_MPP, FILL_VERTEX_STRIDE, FLIP_HOLD_DEG, FOG_CUTOFF_MIN_M, FOG_FAR_MIN_M, FOG_NEAR_MIN_M, type FacadeView, FeaturePaint, type FeatureStateId, FeatureStatePainter, FeatureStateStore, type Filter, type FitBoundsOptions, type FitViewport, type FogPlanes, type FogSpec, type FogWall, type FontFaceDeclaration, FontFaces, type FontFacesSpec, type FormatPiece, type FormatSectionData, type FormattedSection, type FormattedValue, FullscreenControl, GLOBAL_STATE, GLOBE_MAX_PITCH, GLOBE_ZOOM_MAX, GLOBE_ZOOM_MIN, GLYPH_BORDER, GLYPH_SIZE, GRADIENT_SIZE, GRADIENT_STEP_SIZE, GROUND_SCALE, type GeoJSONData, type GeoJSONFeature, type GeoJSONFeatureCollection, type GeoJSONGeometry, type GeoJSONPosition, GeoJSONSource, GeolocateControl, GeomType, GestureHandler, type GestureOptions, GlobeControl, type Glyph, type GlyphMetric, GlyphSource, type GpuClass, GroundArrows, HEATMAP_LAYOUT, HEATMAP_PROPS, HEATMAP_VERTEX_STRIDE, HOST_SOURCE_KEY, type HeatmapLayerSpec, type HeatmapMesh, type HeatmapOptions, HeatmapPass, type HillshadeLayerSpec, ICON_ALIASES, ICON_SOURCES, type IControl, IconSource, ImageManager, type ImageValue, IndoorMask, type Interpolated, type Junctions, LABEL_FOG_MAX, LD_DEFAULTS, LEVEL_LIMIT, LINE_PROGRESS_STRIDE, LINE_VERTEX_STRIDE, type LaneArrow, type LaneGuide, type LaneGuideOptions, LayerOpacityTarget, type LayerPlan, LayerRenderer, type LayerSpecV2, type LayerTypeName, type LayerTypeRef, type LdMesh, type LdMeshOptions, type LiftAt, type LiftField, type LightSpec, type LineGradientMesh, type LinePlacement, type LngLat, LngLatBounds, type LngLatBoundsLike, type LngLatLike, type LoadStyleOptions, type LoadedStyle, LogoControl, MAPLIBRE_STYLES, MAPLIBRE_STYLE_BASE, MAPLIBRE_SUPPORT, MAPLIBRE_TRANSITION, MAX_GRADE, MAX_LATITUDE, MESH_BOTTOM, MESH_ISLAND, MESH_KERB_SIDE, MESH_KERB_TOP, MESH_SIDE, MESH_TOP, MIN_PIER_HEIGHT_METERS, MITER_MAX_TURN, MLIGHT_CITY_STYLE, ML_EXTENT, MNIGHT_CITY_STYLE, MODEL_VERTEX_STRIDE, Map$1 as Map, type MapCameraEvent, type MapEvents, type MapLayerEvent, type MapLayerEventType, type MapLibreImport, type MapLibreLayer, type MapLibreLightSpec, type MapLibreSource, type MapLibreStyle, type MapLibreSupport, type MapLibreSupportStatus, MapObject, type MapObjectOptions, type MapOptions, Marker, type MarkerAnchor, type MarkerEvents, type MarkerOptions, type Marking, type MarkingKind, type MarkingOptions, type MarkingRing, type MediaCoordinates, type MediaKind, MediaSource, type MeteredPiece, MltTile, Model, ModelLayer, type ModelLayerSpec, type ModelLayout, type ModelMesh, type ModelOptions, type ModelPrimitive, NavigationControl, OCCLUSION_MAX_SAMPLES, OCCLUSION_NEAR_M, OCCLUSION_NEAR_SHARE, OCCLUSION_STEP_M, OCCLUSION_TOLERANCE_M, OSMGL_FORMAT_VERSION, OSMGL_STYLES, OSMGL_VERSION_KEY, ObjectManager, type ObjectPaint, type ObjectPart, type Objects3DLayout, Objects3DManager, type OverzoomPlan, PAINT_TRANSITIONS, PIER_SPACING_METERS, PITCH_BY_ZOOM, type Padding, PaintStamp, PaintTransitions, type Pier, type PierOptions, type PlacedGlyph, type PlacedSymbol, type PointLike, Polygon, type PolygonOptions, type PolygonPiece, Polyline, type PolylineOptions, type PolylineSegment, Popup, type PopupOptions, type Projection, type PropRef, type PropType, type ProtocolHandler, type QualityChange, QualityGovernor, type QualityName, type QualityProfile, type QueriedFeature, type QueryGeometry, RELIEF_DARK_KEEP, RELIEF_DARK_LUMA, RELIEF_LIGHT_ALTITUDE, RELIEF_LIGHT_AZIMUTH, RELIEF_STYLE, ROAD_MESH_RADIUS_BY_CORNER, 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 RoadMesh, type RoadMeshOptions, type RoadNode, type RoadRay, type RoadSourceEdges, type RoadSurface, type RoadSurfaceOptions, type RoundOptions, RouteArea, type RouteAreaOptions, type RuntimeMesh, SDF_EDGE, SDF_PX, SIGN_SIZE, SOFT_STYLE, SPLIT_SEP, STYLE_REFERENCE, STYLE_REFERENCE_EXPRESSIONS, STYLE_REFERENCE_EXPRESSION_GROUPS, STYLE_REFERENCE_V2_FLAGS, SURFACE_CUT_BLEED, SURFACE_LEVEL_SCALE, SURFACE_VERTEX_STRIDE, SYMBOL_DATA_FIELDS, ScaleControl, type ScreenPoint$1 as ScreenPoint, SdfAtlas, type ShadowSettings, type ShapedImage, type SkySpec, type SlitResult, type SourceSpec, type StateIndex, StateIndexBuilder, Style, type StyleImage, type StyleImageData, type StyleImageOptions, type StyleIssue, type StyleLayerHit, type StyleLayerSpec, type StyleReference, type StyleSpec, type StyleSpecV2, type StyleValidation, SymbolDataBuilder, type SymbolDataColumn, type SymbolDataColumns, type SymbolDataKind, type SymbolHit, SymbolRenderer, TAPER_METERS, TERRAIN_STYLE, THEMES, TILE_SIZE, type TaperedWidth, TerrainControl, type ThemeInput, type ThemeSpec, type ThemeSpecV2, type TileAddress, type TileEncoding, TileID, Transform, type TransformConstrain, type TransformRequest, type TransitionSpec, VectorTile, VectorTileFeature, VectorTileLayer, type ZoomCurve, abbreviateStreet, addGround, allowsVerticalWritingMode, alongFadeFactor, altitudeFromMercatorZ, anonymousParts, applyTheme, arrowLabelOffset, arrowVertices, asFormatted, asImage, bridgePiers, bridgeProfile, buildCells, buildRoadGraph, buildRuntimeFill, buildRuntimeLine, buildTile, buildZoomFor, builtinMapLibreStyle, builtinOsmglStyle, cameraForBounds, cellBeyondFocus, cellFacadeGone, cellGround, cellOutside, chainAxes, changedBuckets, circleValuesOf, circumferenceAtLatitude, clampLat, clampPixelRatio, classifyRenderer, clipLineToRect, clipLineWithMetrics, clipPolygonParts, closeSlits, clusterProperties, colorsOf, contrastFactor, convertFilter as convertMapLibreFilter, convertValue as convertMapLibreValue, coordinateDigits, coveringTiles, createGround, cutMargin, dashArrayAt, dashRow, dataPaintT, Map$1 as default, densifyLine, deviceHints, distToSegment, easeCubicInOut, evaluateColor, evaluateExpression, evaluateNumber, evaluateVec2, expressionColor, expressionIssues, expressionNumber, extractFeature, facadeFocusBand, facadeGoneDepth, facadeLite, facadeView, featureContext, featureDrivenPaint, featureLevel, featureRuns, featureStateIdOf, fillFootprint, fillTileUrl, fitIconToText, fogCutoffOf, fogPlanes, fogRangeOf, fogWall, footprintOf, formatHash, formattedSections, generateBuildings, generateCircles, generateFill, generateGradientLine, generateHeatmap, generateLine, generateSurface, generateSymbols, globeBasis, globeFlatMix, globeRadius, globeToLocal, groundAt, heatmapRamp, heatmapT, iconRotateOf, iconRotation, importMapLibreStyle, insideFootprint, isDemLayer, isExpression, isMapLibreStyle, isOsmglV2, isStepGradient, isSupportedScript, junctionIndex, keptIndices, labelFogFade, labelReach, laneArrow, laneGuides, latFromMercatorY, latRange, layerOpacityOf, layerV1toV2, layerZoomCeiling, layersToRebuild, layoutAtZoom, ldRoadMesh, liftFields, lineClipsOf, lineGradientRamp, lngFromMercatorX, lngLatToUnit, loadMapLibreStyle, loadStyle, makeFeaturePaint, centerAnchor as mapLibreCenterAnchor, clipLine as mapLibreClipLine, mapLibreFogDepth, mapLibreFogOpacity, mapLibreHorizon, lineAnchors as mapLibreLineAnchors, mapLibreSpot, matchesFilter, meanWidth, mercFeaturesToGeometry, mercatorBounds, mercatorMetersPerTile, mercatorX, mercatorY, mercatorZFromAltitude, mergeBuild, metersPerPixel, metersPerTile, modelLodFloor, needsAdjust, needsDataPaint, nextQualityDown, numbersOf, overzoomPlan, packDem, parseGlb, parseGlbAsync, parseGlbOffThread, parseGlyphs, parseHash, parseLift, parseUnicodeRange, parseVectorTile, patchUV, patternNameAt, patternOrigin, pickBuilding, pickFill, pitchIntent, pitchLimitAt, pixelAlignShift, pixelsPerMeter, placeAlongLine, placeMarking, pointInRing, polylineLength, primaryVectorSource, projectLine as projectSymbolLine, promoteName, propertyV2toV1, qualityFor, qualityProfile, queryRendered, querySource, raySphere, refineLine, relaxAngle, relaxCurvature, relaxForMiter, reliefLight, reliefStops, reliefTintOn, replaceGlobalState, resolveStyleUrls, resolveSymbolColor, resolveSymbolField, resolveSymbolItem, resolveSymbolNumber, resolveSymbolVec2, resolveTemplate, rewriteSymbolPaint, ribbonFromEdges, ribbonRing, ribbonShape, ringEdges, roadEdges, roadHeights, roadMarkings, roadMesh, roadSurfaces, roundLine, roundRing, roundRings, saturationFactor, sdfFromAlpha, shapeFormatted, shapeText, shapeTextCached, shapeVertical, snapCutsInward, snapRoadEnds, speedSign, spinWeights, splitBucketKey, splitByGround, splitPolygons, squareClosed, stitchPieces, stopLine, stretchQuads, styleV1toV2, styleWithTheme, surfaceWritesDepth, symbolDataPlan, taperedWidth, terrainOccludes, themeToInternal, themeV1toV2, tileInBounds, tileLayer, tileOriginMeters, tileRingsToGeometry, tileUrl, toLngLat, toMapLibreStyle, toMercator, toPoint, transitionOf, translateTileUnits, translatedMatrix, tryParseColor, unitToLngLat, unpackVector, usesFeatureState, validateStyle, validateTheme, variableOffset, verticalizePunctuation, waffle, wantsHostSource, withHostSource, worldAlongLine, worldSize, writeCircleValues, yieldTargetsOf, zebra, zoomCeilingOf, zoomCurveOf };