osmgl 0.19.0 → 0.20.0

package/dist/osmgl.d.cts

@@ -400,6 +400,8 @@ declare class Transform {
      */
     get projZOffset(): number;
     get projMatrix(): Mat4;
+    /** Мировые пиксели → экран в однородных координатах (x, y, z, w; делить на w). */
+    get pixelMatrix(): Mat4;
     get viewMatrix(): Mat4;
     /** Центр карты в мировых пикселях. */
     get centerPointPx(): {
@@ -681,6 +683,18 @@ declare class GestureManager {
     constructor(canvas: HTMLCanvasElement, tr: Transform, onChange: (reason: 'pan' | 'zoom' | 'rotate' | 'pitch') => void, onInteractionEnd: () => void, options?: Partial<GestureOptions>);
     setOptions(options: Partial<GestureOptions>): void;
     private bind;
+    /**
+     * ЖЕСТЫ С ЭЛЕМЕНТОВ ПОВЕРХ КАНВЫ (маркеры приложения), как у MapLibre (02.10.2026).
+     *
+     * Маркер — HTML-элемент со своими событиями, и жест, начатый на нём, или колесо над ним до канвы
+     * не доходили: карта останавливалась. У MapLibre обработчики висят на контейнере, и события с
+     * маркера всплывают к ним. Здесь — те же обработчики на слое маркеров. Щелчок по маркеру без
+     * движения остаётся щелчком: канва захватывает указатель только когда он сдвинулся больше 3 px,
+     * иначе событие `click` ушло бы с маркера на канву.
+     */
+    forwardFrom(el: HTMLElement, accepts?: (target: EventTarget | null) => boolean): void;
+    /** Указатели, начавшие жест на маркере: канва захватит их, как только они сдвинутся. */
+    private uncaptured;
     private point;
     private onContextMenu;
     private onPointerDown;
@@ -832,6 +846,11 @@ interface Capabilities {
     maxAnisotropy: number;
     timerQuery: boolean;
     rendererName: string;
+    /**
+     * Есть `KHR_parallel_shader_compile`: о готовности программы можно спросить, не дожидаясь её
+     * (см. `Shader.ready`). Без расширения такой вопрос сам ждёт конца компиляции.
+     */
+    parallelCompile: boolean;
 }
 type DepthFunc = 'less' | 'lequal' | 'always' | 'greater';
 type BlendMode = 'none' | 'alpha' | 'premultiplied' | 'add' | 'multiply';
@@ -882,6 +901,8 @@ declare class Context {
      * закрываются дырки в утопленных поверхностях — острова).
      */
     setColorMask(on: boolean): void;
+    /** Текущая функция глубины — чтобы проход, сменивший её на время, вернул прежнюю. */
+    get depthFunc(): DepthFunc;
     setDepthFunc(f: DepthFunc): void;
     setBlend(mode: BlendMode): void;
     setCull(mode: CullMode): void;
@@ -900,9 +921,20 @@ declare class Context {
 declare class Shader {
     private ctx;
     readonly name: string;
-    readonly program: WebGLProgram;
+    private readonly _program;
     private uniforms;
     private attribs;
+    /**
+     * Сборка ещё не проверена: шейдеры лежат здесь до первого обращения к программе.
+     *
+     * ★ ПРОВЕРКА ОТЛОЖЕНА НАМЕРЕННО (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
@@ -910,6 +942,18 @@ declare class Shader {
      * (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;
@@ -1063,6 +1107,8 @@ interface LayerBase {
     overlay?: boolean | 'roads' | 'volume';
     /** Выключить слой, не удаляя из стиля. */
     visible?: boolean;
+    /** Свободные данные приложения у слоя (`metadata` слоя MapLibre). Движок их не читает. */
+    metadata?: Record<string, unknown>;
     /**
      * Радиус скругления углов в МЕТРАХ (заливки и объём).
      *
@@ -1075,6 +1121,25 @@ interface LayerBase {
      * из соседних тайлов сошлись бы со ступенькой.
      */
     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';
     /**
      * Обрезать заливку по квадрату тайла.
      *
@@ -1133,6 +1198,8 @@ interface RasterLayerSpec {
     minzoom?: number;
     maxzoom?: number;
     visible?: boolean;
+    /** Свободные данные приложения у слоя (`metadata` слоя MapLibre). Движок их не читает. */
+    metadata?: Record<string, unknown>;
     /**
      * Рисовать ПОВЕРХ векторной карты, а не под ней.
      *
@@ -1148,7 +1215,8 @@ interface RasterLayerSpec {
 interface FillLayerSpec extends LayerBase {
     type: 'fill';
     paint: MaterialPaint & {
-        color: Interpolated<string>;
+        /** Цвет заливки; `{ from, property }` — «как у такого-то слоя» (плоские здания берут `roofColor`). */
+        color: Interpolated<string> | ColorFrom;
         opacity?: Interpolated<number>;
     };
 }
@@ -1254,6 +1322,23 @@ interface LineLayerSpec extends LayerBase {
          */
         widthExtra?: Interpolated<number>;
         dashArray?: [number, number];
+        /**
+         * Пунктир В ШИРИНАХ ЛИНИИ — как `line-dasharray` у MapLibre: [штрих, пробел] множителями
+         * текущей ширины. Толще линия — длиннее штрих, поэтому пунктир на любом зуме одинаков по виду.
+         */
+        dashWidths?: [number, number];
+        /**
+         * Зазор посередине линии в пикселях — `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;
         /**
          * ШИРИНА В МЕТРАХ вместо пикселей — для РАЗМЕТКИ.
          *
@@ -1314,7 +1399,14 @@ interface LineLayerSpec extends LayerBase {
 interface FillExtrusionLayerSpec extends LayerBase {
     type: 'fill-extrusion';
     paint: {
-        color: Interpolated<string>;
+        /** Цвет стен; `{ 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. */
@@ -1421,6 +1513,11 @@ interface FillExtrusionLayerSpec extends LayerBase {
         roofVariation?: Interpolated<number>;
         /** Множитель высоты (например, 0 — «сложить» здания). */
         heightScale?: Interpolated<number>;
+        /**
+         * Градиент стены по высоте — `fill-extrusion-vertical-gradient` MapLibre. Работает только со
+         * светом MapLibre (`lighting: 'maplibre'`); не задан — включён, как и у MapLibre.
+         */
+        verticalGradient?: boolean;
     };
 }
 /**
@@ -1431,6 +1528,8 @@ interface FillExtrusionLayerSpec extends LayerBase {
  * иконки силуэтные (одноцветные): раскрасить пиктограмму в несколько цветов
  * таким способом нельзя.
  */
+/** Якорь подписи или значка — какая точка бокса стоит на объекте (`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?: {
@@ -1447,6 +1546,16 @@ interface SymbolLayerSpec extends LayerBase {
          * занимает до половины строки. Так подписывают улицы Яндекс и 2ГИС — см. `text/abbreviate`.
          */
         abbreviate?: boolean;
+        /**
+         * Регистр подписи — как `text-transform` у MapLibre. Меняется в воркере вместе с сокращением:
+         * под этот текст раскладка и ищет место.
+         */
+        textTransform?: 'none' | 'uppercase' | 'lowercase';
+        /**
+         * Гарнитура подписи — имя набора глифов на сервере шрифтов, как `text-font` у MapLibre
+         * (`Noto Sans Bold`). Не задана — общий шрифт карты (`Noto Sans Regular`).
+         */
+        textFont?: string;
         /**
          * Разрядка букв в долях кегля — как `text-letter-spacing` у Mapbox.
          *
@@ -1483,6 +1592,15 @@ interface SymbolLayerSpec extends LayerBase {
          * приклеенным сбоку.
          */
         textPlacement?: 'point' | 'line';
+        /**
+         * Как подпись вдоль линии стоит относительно наклона карты.
+         *
+         * `viewport` (по умолчанию) — буквы обращены к экрану и при наклоне не сжимаются: читается
+         * лучше всего. `map` — буквы ЛЕЖАТ НА ДОРОГЕ и в наклоне сжимаются в перспективе вместе с ней,
+         * как `text-pitch-alignment: map` у MapLibre (у `symbol-placement: line` это его умолчание).
+         * Только для `textPlacement: 'line'`.
+         */
+        textPitchAlignment?: 'viewport' | 'map';
         /**
          * Шаг повторения подписи вдоль линии, экранные пиксели (`textPlacement:
          * 'line'`). По умолчанию 250 — как `symbol-spacing` у Mapbox.
@@ -1491,11 +1609,63 @@ interface SymbolLayerSpec extends LayerBase {
          * раз, находится только в одном месте, и на соседнем экране та же улица
          * снова безымянная. Ноль — ставить ровно один раз.
          */
-        symbolSpacing?: number;
+        symbolSpacing?: Interpolated<number>;
         /** Смещение подписи от точки привязки, CSS-пиксели. */
         offset?: [number, number];
         /** Максимум символов в строке до переноса. */
         maxLineChars?: number;
+        /**
+         * РАСКЛАДКА ПО ЯКОРЯМ, КАК У MapLibre. Заданный `textAnchor` или `iconAnchor` включает её вместо
+         * нашей блочной (`iconPlacement`): значок и подпись ставятся НЕЗАВИСИМО — каждый своим якорем к
+         * точке объекта, подпись ещё и со смещением `textOffset` в em (кеглях). Так устроены все стили
+         * MapLibre: значок POI стоит центром на объекте, подпись — верхним краем под ним.
+         */
+        textAnchor?: SymbolAnchor;
+        /** Смещение подписи от точки в em (× `textSize`), `text-offset` у MapLibre. */
+        textOffset?: [number, number];
+        iconAnchor?: SymbolAnchor;
+        /**
+         * Размер значка МНОЖИТЕЛЕМ его натурального размера — `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;
         /**
@@ -1564,7 +1734,7 @@ interface SymbolLayerSpec extends LayerBase {
          * Значок доворачивается на поворот камеры, поэтому стрелка у входа смотрит
          * внутрь дома при любом развороте карты.
          */
-        iconRotate?: string;
+        iconRotate?: string | number | unknown[];
         /**
          * Показывать слой ТОЛЬКО у выбранного здания (`highlight`).
          *
@@ -1634,6 +1804,10 @@ interface SymbolLayerSpec extends LayerBase {
         haloColor?: Interpolated<string> | ColorFrom;
         /** Толщина обводки в CSS-пикселях. Обводка обязательна поверх пёстрой карты. */
         haloWidth?: Interpolated<number>;
+        /** Размытие обводки текста в пикселях — `text-halo-blur` MapLibre. */
+        haloBlur?: Interpolated<number>;
+        /** Размытие обводки значка — `icon-halo-blur`. */
+        iconHaloBlur?: Interpolated<number>;
         /**
          * Свой цвет значка — иначе он красится цветом подписи (одна программа на
          * текст и иконки). Нужен плашкам: щит номера трассы это светлая заливка с
@@ -2075,6 +2249,8 @@ interface StyleSpec {
      */
     levelHeight?: number;
     light?: Partial<LightSpec>;
+    /** Свет объёма MapLibre — корневой `light` стиля MapLibre (см. `MapLibreLightSpec`). */
+    mapLibreLight?: Partial<MapLibreLightSpec>;
     /** Небо и дымка. */
     sky?: Partial<SkySpec>;
     /** Дополнительные источники тайлов помимо `base` (его задаёт карта опцией `tiles`). */
@@ -2088,8 +2264,52 @@ interface StyleSpec {
      * Менеджер моделей читает его отсюда после каждого `setStyle` и сам решает, что перезагрузить.
      */
     model3dKey?: string;
+    /**
+     * Свободные данные приложения — как `metadata` у MapLibre. Движок их не читает; хранит редактор
+     * стилей (своё состояние) и продукт (`maps3d:*` — облик SDK). Объявлено, чтобы проверка стиля не
+     * считала поле опечаткой.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * ШРИФТЫ СТИЛЯ — шаблон адреса SDF-глифов `…/{fontstack}/{range}.pbf`, ровно как `glyphs` у MapLibre.
+     *
+     * Нет поля — шрифты карты (опция `fonts`, `setGlyphs`). Есть — стиль ставит свои на время, пока он
+     * стоит, а стиль без них возвращает карте её собственные. Так стиль, сохранённый редактором или
+     * переведённый из MapLibre, не теряет шрифтов, с которыми его рисовали.
+     */
+    glyphs?: string;
+    /**
+     * СПРАЙТ СТИЛЯ — адрес без расширения (`…/sprite`, к нему дописываются `.json`/`.png`, а на
+     * плотном экране `@2x`) или список `{ id, url }` — форма та же, что у `sprite` MapLibre, чтобы
+     * редактор и импортёр переносили её как есть. Значки дополнительного спрайта зовутся `id:имя`;
+     * `id: 'default'` — основной, без приставки.
+     *
+     * Нет поля — значки карты (встроенные, `setSprite`/`addSprite`) не трогаются. Есть — правило то же,
+     * что у `glyphs`: на время стиля его спрайт, после — снова карты.
+     */
+    sprite?: string | {
+        id: string;
+        url: string;
+    }[];
     layers: StyleLayerSpec[];
 }
+/**
+ * СВЕТ ОБЪЁМА MapLibre — корневой `light` стиля MapLibre, как его читает `fill_extrusion_program`.
+ *
+ * Свой свет (`LightSpec`) им не заменить: у MapLibre другая модель — ОДИН источник, яркость по
+ * формуле от светлоты самого цвета и нижняя граница в оттенок света. Светит он только слоям с
+ * `lighting: 'maplibre'`; наши темы его не видят.
+ */
+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): на диагонали пары стен «восток/юг» и «запад/север» получают
@@ -2158,6 +2378,12 @@ interface LayerPlan {
     /** Скругление углов в метрах — геометрия, поэтому едет в воркер. */
     cornerRadius?: number;
     cornerSegments?: number;
+    /** Линии: данные стыков в вершине (`lineCap`/`lineJoin` заданы) — см. `generators/line`. */
+    joinData?: boolean;
+    /** Только плоские крыши (`fill-extrusion` из стиля MapLibre). */
+    flatRoofs?: boolean;
+    /** Плоские нормали стен на каждое ребро, без сглаживания изломов (свет MapLibre). */
+    flatNormals?: boolean;
     /** Резать заливку по тайлу — для полупрозрачных слоёв. */
     clipToTile?: boolean;
     /** Рельеф (тип `surface`): уровень и форма края, тоже геометрия. */
@@ -2198,14 +2424,23 @@ interface LayerPlan {
     /** Покраска на фиче: выражения, которые воркер посчитает и положит в вершину. */
     dataPaint?: DataPaintSpec;
     /** Только для symbol: шаблоны подставляются уже в воркере, чтобы не гонять свойства. */
-    textField?: string | string[];
-    iconImage?: string | string[];
-    /** Свойство фичи с поворотом значка (стрелка входа смотрит внутрь дома). */
-    iconRotate?: string;
+    textField?: string | unknown[];
+    iconImage?: string | unknown[];
+    /** Только для fill-extrusion: высота и низ стены выражением (метры), считаются на фиче. */
+    extrusionHeight?: unknown;
+    extrusionBase?: unknown;
+    /** Свойство фичи с поворотом значка (стрелка входа смотрит внутрь дома) или выражение. */
+    iconRotate?: string | number | unknown[];
     /** `line` — подпись изгибается по дороге: воркер тогда кладёт и геометрию линии. */
     textPlacement?: 'point' | 'line';
     /** Сокращать родовое слово в названии («улица» → «ул.») — см. `text/abbreviate`. */
     abbreviate?: boolean;
+    /** Вдоль линии — ВСЕ части составной линии, а не самая длинная (стиль MapLibre). */
+    allLineParts?: boolean;
+    /** Не склеивать куски линий с одной подписью — `line-center` у MapLibre (склеивает только `line`). */
+    noLineMerge?: boolean;
+    /** Регистр подписи (`text-transform`) — меняется в воркере вместе с сокращением. */
+    textTransform?: 'none' | 'uppercase' | 'lowercase';
 }
 /** Источник по умолчанию: основная карта. */
 declare const BASE_SOURCE = "base";
@@ -2420,6 +2655,30 @@ interface BuildingsOptions {
     metersPerUnit?: number;
     /** Покраска на фиче: цвет и прозрачность считаются здесь и ложатся в вершины. */
     paint?: FeaturePaint;
+    /** Только плоские крыши (`fill-extrusion` MapLibre). */
+    flatRoofs?: boolean;
+    /**
+     * Нормаль стены — нормаль СВОЕГО ребра, без сглаживания на пологих изломах: так их строит
+     * `fill_extrusion_bucket` MapLibre, и свет MapLibre (`lighting: 'maplibre'`) ждёт ровно их.
+     */
+    flatNormals?: boolean;
+    /** Высота и низ стены выражением MapLibre (метры); без них — свойства тайла. */
+    height?: unknown;
+    base?: unknown;
+    /** Зум тайла — для `['zoom']` в этих выражениях и в фильтре. */
+    zoom?: number;
+    /**
+     * Как резать дом по тайлу (02.10.2026).
+     *
+     * `'square'` (по умолчанию) — по квадрату тайла с нахлёстом `bleedRing`: так режется наш облик, у
+     * которого куски потом сшиваются.
+     *
+     * `'buffer'` — как MapLibre: БЛИЖНИЕ стороны (0) не режутся, кусок за ними — исходная геометрия
+     * буфера; ДАЛЬНИЕ (extent) режутся по пределу упаковки, внутрь. Нужно `fill-extrusion` из стиля
+     * MapLibre: сшивки у него нет, и стена, пересекающая стык, должна остаться ОДНОЙ прямой.
+     * Подробно — у `addBuilding`. Скругление углов с этим режимом не сочетается и его отключает.
+     */
+    tileClip?: 'square' | 'buffer';
 }
 declare function generateBuildings(layer: VectorTileLayer, extent: number, filter?: Filter, options?: BuildingsOptions, 
 /**
@@ -2449,6 +2708,145 @@ interface BuildingSeam {
     holeCuts: boolean[][];
 }
 
+/**
+ * ВЫРАЖЕНИЯ СТИЛЯ MapLibre.
+ *
+ * Стиль, написанный под MapLibre, почти целиком состоит из них: ширина дороги — `interpolate` по
+ * зуму, цвет — `match` по классу, видимость — `case`. Без интерпретатора такой стиль у нас не
+ * работает вовсе, а переписывать его на наши упрощённые формы (`stops`) для каждого приложения —
+ * это ровно та работа, которой перенос и должен избавить.
+ *
+ * ★ ИНТЕРПРЕТАТОР, А НЕ КОМПИЛЯТОР.
+ *
+ * MapLibre компилирует выражение в замыкания один раз и потом зовёт их. Мы считаем прямо по
+ * массиву, но КЕШИРУЕМ разбор (`compile`) — на зумовых свойствах это вызов на слой за кадр, и
+ * разница между подходами там неизмерима. На фильтрах, где вызовов десятки тысяч на тайл, кеш
+ * решает: разобранное выражение переиспользуется для каждой фичи.
+ *
+ * ★ ЧТО УМЕЕТ, А ЧТО НЕТ.
+ *
+ * Умеет всё, что встречается в стилях: данные (`get`, `has`, `id`, `geometry-type`,
+ * `feature-state`, `global-state`), решения (`case`, `match`, `coalesce`, логика, сравнения),
+ * шкалы (`interpolate` линейный, экспоненциальный и по кривой Безье, `step`), арифметику,
+ * строки, цвета, переменные (`let`/`var`), массивы (`at`, `length`, `slice`, `in`).
+ *
+ * Не умеет: `format` (богатый текст с разными шрифтами в одной подписи — у нас подпись
+ * однородная), `image` в значении «встроить картинку в текст», `distance`, `within` для линий и
+ * полигонов (точка проверяется, остальное — нет), `resolved-locale`. Всё перечисленное отмечено и
+ * в `porting/maplibre-api.md`.
+ */
+/** Значение выражения: то, чем оперирует язык. */
+type ExprValue = number | string | boolean | null | ExprValue[] | RGBAColor;
+/** Цвет как значение языка: четыре канала 0..1, как их отдаёт `parseColor`. */
+interface RGBAColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** Всё, что выражение может спросить об окружении. */
+interface ExprContext {
+    zoom?: number;
+    /** Свойства фичи (для фильтров и data-driven значений). */
+    properties?: Record<string, unknown>;
+    /** Номер фичи: `['id']`. */
+    id?: number | string | null;
+    /** Тип геометрии: `Point`, `LineString`, `Polygon`. */
+    geometryType?: string;
+    /** Состояние фичи (`map.setFeatureState`). */
+    featureState?: Record<string, unknown>;
+    /** Общее состояние стиля (`map.setGlobalStateProperty`). */
+    globalState?: Record<string, unknown>;
+    /** Точка фичи в координатах карты — нужна `within` для точечных фич. */
+    point?: [number, number];
+}
+/**
+ * ОБЩЕЕ СОСТОЯНИЕ СТИЛЯ (`map.setGlobalStateProperty`).
+ *
+ * Лежит модульной переменной, а не в карте: значения стиля считаются в десятках мест, и тащить
+ * через все них ещё один аргумент ради редкого случая значит переписать половину сигнатур. Карта
+ * на странице одна — то же допущение, что и у MapLibre, где состояние висит на стиле.
+ *
+ * ★ У ВОРКЕРА СВОЙ ЭКЗЕМПЛЯР МОДУЛЯ. Раньше состояние туда не доходило вовсе, и фильтры, значения по
+ * фиче и подписи (всё, что считается в воркере) видели пустое состояние. Теперь оно едет с каждым
+ * запросом тайла (`LoadRequest.globalState`) и ставится `replaceGlobalState` перед разбором.
+ */
+declare const GLOBAL_STATE: Record<string, unknown>;
+/** Заменить состояние целиком — воркеру перед разбором тайла. */
+declare function replaceGlobalState(state: Record<string, unknown>): void;
+/** Похоже ли значение на выражение: массив, первый элемент которого — имя операции. */
+declare function isExpression(value: unknown): value is ExprValue[];
+/**
+ * Посчитать выражение.
+ *
+ * Разбор кешируется на самом массиве: стиль живёт долго, а значения из него берут каждый кадр.
+ */
+declare function evaluateExpression(expr: unknown, ctx: ExprContext): ExprValue;
+/** Число из выражения; `fallback`, если получилось не число. */
+declare function expressionNumber(expr: unknown, ctx: ExprContext, fallback: number): number;
+/** Цвет из выражения в наш формат `[r, g, b, a]`. */
+declare function expressionColor(expr: unknown, ctx: ExprContext): [number, number, number, number] | null;
+/**
+ * ОПЕРАЦИИ, КОТОРЫЕ ПОНИМАЕТ `compile`. Ровно список его `case`, ни одной больше.
+ *
+ * Нужен проверке стиля (`style/validate.ts`): сам `compile` о незнакомой операции молчит до
+ * вычисления (см. его ветку `default`), а редактор обязан сказать о ней сразу, на вводе. Что список
+ * не разошёлся с `switch`, сверяет тест (`tests/style-reference.test.mjs`) — по исходнику.
+ */
+declare const EXPRESSION_OPERATORS: ReadonlySet<string>;
+/** Замечание к выражению: где (путь внутри него) и что не так. */
+interface ExpressionIssue {
+    /** Путь от корня выражения: `[2][1]` — второй аргумент первого аргумента. Пусто — само выражение. */
+    path: string;
+    message: string;
+}
+/**
+ * ЧТО В ВЫРАЖЕНИИ НЕ ТАК — статически, без вычисления.
+ *
+ * Идёт по тем же правилам разбора, что и `compile`: где у операции стоит не выражение, а ИМЯ или
+ * ЗНАЧЕНИЕ (вид кривой у `interpolate`, метки у `match`, имена у `let`, содержимое `literal`), туда
+ * не заходит — иначе `['linear']` и `['a', 'b']`-метка выглядели бы незнакомыми операциями.
+ *
+ * Проверяет то, на чём движок молча выдал бы пустое значение: незнакомую операцию, остановки шкалы
+ * не числом или не по возрастанию, нечётные пары, имя переменной не строкой. Типы аргументов не
+ * выводит: интерпретатор приводит их сам (`to-number` и т.п.), и ругань на каждое приведение была бы
+ * шумом.
+ */
+declare function expressionIssues(expr: unknown, path?: string): ExpressionIssue[];
+
+type PropBag = Record<string, string | number | boolean | null>;
+/** Окружение фичи для фильтра: номер, тип геометрии, зум тайла, состояние. */
+interface FilterContext {
+    id?: number | string | null;
+    geometryType?: string;
+    zoom?: number;
+    featureState?: Record<string, unknown>;
+}
+/** Окружение фичи тайла — то, что фильтр знает о ней помимо свойств. */
+declare function featureContext(feature: {
+    id?: number;
+    type: number;
+}, zoom?: number): FilterContext;
+/**
+ * Значение стиля на конкретном зуме.
+ *
+ * Между остановками интерполируем ЛИНЕЙНО по зуму, а не экспоненциально: для
+ * ширин дорог и прозрачностей так предсказуемее, а «экспоненту» при желании
+ * задают частыми остановками.
+ */
+declare function evaluateNumber(v: Interpolated<number> | undefined, zoom: number, fallback: number): number;
+
+type RGBA = [number, number, number, number];
+declare function evaluateColor(v: Interpolated<string> | undefined, zoom: number, fallback: RGBA): RGBA;
+/**
+ * Проверка фильтра. Отсутствующее свойство никогда не равно значению
+ * (кроме '!=' и '!in', где отсутствие считается несовпадением, — так же
+ * ведёт себя MapLibre).
+ */
+declare function matchesFilter(filter: Filter | undefined, props: PropBag, 
+/** Остальное окружение фичи: номер, тип геометрии, состояние. Нужно выражениям. */
+ctx?: FilterContext): boolean;
+
 /**
  * Сбор подписей из тайла.
  *
@@ -2497,16 +2895,28 @@ interface SymbolPlan {
     filter?: Filter;
     /** `line` — подпись изгибается по дороге; иначе стоит точкой у якоря. */
     textPlacement?: 'point' | 'line';
-    /** Шаблон подписи или список запасных: первый непустой побеждает. */
-    textField?: string | string[];
-    /** Шаблон имени иконки или список запасных. */
-    iconImage?: string | string[];
-    /** Свойство фичи с поворотом значка в градусах. */
-    iconRotate?: string;
+    /** Шаблон подписи, список запасных (первый непустой побеждает) или выражение MapLibre. */
+    textField?: string | unknown[];
+    /** Шаблон имени иконки, список запасных или выражение. */
+    iconImage?: string | unknown[];
+    /** Свойство фичи с поворотом значка в градусах, число или выражение. */
+    iconRotate?: string | number | unknown[];
+    /** Зум тайла: его спрашивают `['zoom']` в выражениях и фильтры. */
+    zoom?: number;
     /** Сокращать родовое слово в названии («улица» → «ул.») — см. `text/abbreviate`. */
     abbreviate?: boolean;
+    /** Вдоль линии — все части составной линии, как MapLibre (у нас по умолчанию — самая длинная). */
+    allLineParts?: boolean;
+    /** Не склеивать куски линий (MapLibre склеивает только при `symbol-placement: line`). */
+    noLineMerge?: boolean;
+    /** Регистр подписи, как `text-transform` у MapLibre. */
+    textTransform?: 'none' | 'uppercase' | 'lowercase';
 }
 declare function generateSymbols(layer: VectorTileLayer, plan: SymbolPlan): SymbolBucketData | null;
+/** Подпись или имя значка у фичи: шаблон, список запасных или выражение. */
+declare function resolveSymbolField(field: string | unknown[], props: Record<string, PropValue>, ctx: FilterContext): string;
+/** Поворот значка в градусах: имя свойства (наш формат), число или выражение (MapLibre). */
+declare function iconRotateOf(rotate: string | number | unknown[] | undefined, props: Record<string, PropValue>, ctx: FilterContext): number;
 /**
  * Подстановка `{prop}` в шаблон. Список шаблонов — это фолбэки: первый,
  * который раскрылся целиком, побеждает. Так `["{name:ru}", "{name}"]` даёт
@@ -2614,6 +3024,11 @@ interface LoadRequest {
     };
     /** Что строить из этого тайла — план из стиля. */
     plan: LayerPlan[];
+    /**
+     * Общее состояние стиля (`setGlobalStateProperty`) на момент запроса: у воркера свой экземпляр
+     * модуля, и без этого фильтры и значения по фиче видели бы пустое состояние.
+     */
+    globalState?: Record<string, unknown>;
 }
 interface LoadedResponse {
     type: 'loaded';
@@ -2724,29 +3139,271 @@ declare class WorkerPool {
     destroy(): void;
 }
 
-type PropBag = Record<string, string | number | boolean | null>;
+type MapLibreSupportStatus = '✅' | '🟡' | '❌';
+interface MapLibreSupport {
+    status: MapLibreSupportStatus;
+    /** Чем это свойство у osmgl (или «—»). */
+    osmgl: string;
+    /** Что не так или что сказать о нём. */
+    note: string;
+}
+declare const MAPLIBRE_SUPPORT: Record<string, MapLibreSupport>;
+
 /**
- * Значение стиля на конкретном зуме.
+ * СПРАВОЧНИК СТИЛЯ osmgl — машиночитаемый, для редактора стилей и для проверки (`validate.ts`).
+ *
+ * Один источник правды о том, какие поля есть у стиля, что они значат, чем заданы по умолчанию и
+ * как движок их читает. По нему строит формы редактор в админке (как Maputnik строит свои по
+ * `v8.json` MapLibre), по нему же проверяется стиль на каждом нажатии клавиши. В сборке он ложится
+ * ещё и файлом `dist/style-reference.json` — для тех, кто не тянет движок целиком.
+ *
+ * ★ СПРАВОЧНИК НЕ ДОЛЖЕН РАЗОЙТИСЬ СО `spec.ts`. Тест `tests/style-reference.test.mjs` разбирает
+ * `spec.ts` компилятором TypeScript и сверяет поля в обе стороны: новое поле в спеке без строки
+ * здесь (и наоборот) роняет `npm test`. Значения по умолчанию взяты из кода, который их применяет
+ * (`layers/renderer.ts`, `layers/symbols.ts`, `layers/ground-arrows.ts`, `worker/process.ts`,
+ * `generators/*`), а не из комментариев; где умолчание выводится из другого поля, это сказано в
+ * тексте, а `default` не задан.
+ *
+ * Что значат признаки:
+ *   `zoom`     — значение может меняться по зуму: остановки `{stops}` или выражение с `['zoom']`;
+ *   `data`     — значение может зависеть от ФИЧИ (`['get', …]`) и движок его на фиче ДЕЙСТВИТЕЛЬНО
+ *                считает. Таких полей мало: цвет, прозрачность и ширина у fill/line/fill-extrusion
+ *                (воркер кладёт их в вершины, `generators/data-paint.ts`), высота и низ дома, шаблоны
+ *                подписи и значка, поворот значка. Остальное считается раз на слой, и `['get']` в нём
+ *                даёт запасное значение;
+ *   `geometry` — правка пересобирает тайлы (поле едет в план воркера, `Style.workerPlan`). Цвет,
+ *                прозрачность и ширина, заданные ПО ФИЧЕ, тоже пересобирают — это отмечено
+ *                `geometryIfData`.
+ */
+
+/** Вид значения: по нему редактор выбирает поле ввода. */
+type PropType = 'number' | 'integer' | 'boolean' | 'string' | 'color' | 'enum' | 'array' | 'object' | 'filter' | 'expression' | 'colorFrom' | 'formatted' | 'resolvedImage' | 'padding' | 'sources' | 'light' | 'sky' | 'terrain' | 'sprite';
+interface PropRef {
+    type: PropType;
+    /** Что это, по-русски, одно-два предложения; единицы. */
+    doc: string;
+    /** Значение, которое движок берёт, когда поле не задано. */
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    step?: number;
+    /** Единицы: `px`, `m`, `em`, `deg`, `ms`, `×width`… */
+    units?: string;
+    /** Допустимые значения перечисления → что каждое значит. */
+    values?: Record<string, string>;
+    /** Элемент массива. */
+    items?: PropRef;
+    /** Точная длина массива. */
+    length?: number;
+    /** Поля объекта. */
+    properties?: Record<string, PropRef>;
+    /** Значения словаря с произвольными ключами (`groundBy`, `sources`). */
+    additionalProperties?: PropRef;
+    required?: boolean;
+    /** Может меняться по зуму. */
+    zoom: boolean;
+    /** Может зависеть от фичи — и движок действительно считает его на фиче. */
+    data: boolean;
+    /** Правка пересобирает тайлы (поле в плане воркера). */
+    geometry?: boolean;
+    /** Пересобирает тайлы, когда значение зависит от фичи (цвет/прозрачность/ширина по `get`). */
+    geometryIfData?: boolean;
+    /** Строка на месте числа — ИМЯ СВОЙСТВА фичи (`iconRotate: 'rotation'`). */
+    propertyName?: boolean;
+    /** К каким типам слоёв относится общее поле (нет — ко всем, у кого оно есть). */
+    appliesTo?: string[];
+    /** Раздел интерфейса (`groups`). */
+    group?: string;
+    since?: string;
+    deprecated?: string;
+    experimental?: boolean;
+    /** Свойство MapLibre, которое импортёр переводит в это поле. */
+    mapLibre?: string;
+    /**
+     * ИМЯ В ФОРМАТЕ v2 (`porting/unified-style-format.md`, §3): `раздел.имя`, где раздел у слоя —
+     * `layer` (рядом с `id`), `layout` или `paint`; у корня — `root`, `sky`, `light`, `osmgl-light`,
+     * `terrain`, `osmgl-tint`, `source`. Свойство MapLibre — его именем, своё — с приставкой `osmgl-`.
+     * Одна таблица на всё: по ней работают загрузчик v2, конвертер v1 → v2, API карты на именах v2,
+     * проверка стиля и редактор. Заполняется в конце файла (`V2_NAMES`), у КАЖДОЙ записи — тест.
+     */
+    v2?: string;
+    /** Цвет-ссылка `{ from }` в v2 лежит отдельным свойством рядом с цветом: здесь — каким. */
+    v2From?: string;
+    /** Поле v1 общее на два свойства v2 (`allowOverlap` → `text-allow-overlap` и `icon-allow-overlap`): второе. */
+    v2Also?: string[];
+    /** Как это свойство MapLibre рисует osmgl: ✅ / 🟡 / ❌ и примечание (§2 того же документа). */
+    support?: MapLibreSupport;
+}
+interface LayerTypeRef {
+    doc: string;
+    /** Какие поля `layerCommon` у слоя этого типа есть. Нет списка — все. */
+    common?: string[];
+    /** Свои поля верхнего уровня (рядом с `id`, вне `paint`/`layout`). */
+    fields: Record<string, PropRef>;
+    paint: Record<string, PropRef>;
+    layout: Record<string, PropRef>;
+}
+type LayerTypeName = 'fill' | 'line' | 'fill-extrusion' | 'surface' | 'symbol' | 'raster';
+interface StyleReference {
+    version: 1;
+    root: Record<string, PropRef>;
+    source: Record<string, PropRef>;
+    layerCommon: Record<string, PropRef>;
+    layers: Record<LayerTypeName, LayerTypeRef>;
+    groups: Record<string, string>;
+}
+interface ExpressionOperatorRef {
+    doc: string;
+    /** Аргументы, как их пишут: `['get', имя, объект?]`. */
+    args: string;
+    /** Тип результата. */
+    returns: string;
+    /** Раздел: данные, решения, шкалы, математика… */
+    group: string;
+}
+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[];
+/**
+ * СЛОЙ v1 → v2.
  *
- * Между остановками интерполируем ЛИНЕЙНО по зуму, а не экспоненциально: для
- * ширин дорог и прозрачностей так предсказуемее, а «экспоненту» при желании
- * задают частыми остановками.
+ * Подпись: слой, поставленный импортёром MapLibre (`placementMode: maplibre`), остаётся слоем
+ * MapLibre и получает явные значения там, где умолчания v1 и MapLibre расходятся; любой другой — это
+ * своя система подписей (`osmgl-symbol-layout: block`), и его поля переносятся одним
+ * переименованием: умолчания у этой системы свои, и пустое поле значит ровно то же, что в v1.
  */
-declare function evaluateNumber(v: Interpolated<number> | undefined, zoom: number, fallback: number): number;
-type RGBA = [number, number, number, number];
-declare function evaluateColor(v: Interpolated<string> | undefined, zoom: number, fallback: RGBA): RGBA;
+declare function layerV1toV2(layer: StyleLayerSpec, style: StyleSpec, report?: ConvertReport): LayerSpecV2;
 /**
- * Проверка фильтра. Отсутствующее свойство никогда не равно значению
- * (кроме '!=' и '!in', где отсутствие считается несовпадением, — так же
- * ведёт себя MapLibre).
+ * СТИЛЬ v1 → v2. Чистая функция: та же внутренняя модель получается обратно загрузчиком
+ * (`importMapLibreStyle`) — это и есть доказательство «без потерь» (`tests/style-v2.test.mjs`).
  */
-declare function matchesFilter(filter: Filter | undefined, props: PropBag, 
-/** Остальное окружение фичи: номер, тип геометрии, состояние. Нужно выражениям. */
-ctx?: {
-    id?: number | string | null;
-    geometryType?: string;
-    featureState?: Record<string, unknown>;
-}): boolean;
+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>[];
+};
 
 /**
  * Тема — набор правок поверх базового стиля, а не его копия.
@@ -2765,6 +3422,11 @@ interface ThemeSpec {
     sky?: Partial<SkySpec>;
     /** Правки paint-свойств по id слоя. Неизвестные id игнорируются. */
     paint?: Record<string, Record<string, unknown>>;
+    /**
+     * Правки layout-свойств по id слоя — то же, что `paint`, но для раскладки (кегль, выравнивание
+     * подписи). Нужны теме, которой подписи дорог положены на асфальт (`textPitchAlignment: 'map'`).
+     */
+    layout?: Record<string, Record<string, unknown>>;
     /** Слои, скрытые в этой теме. */
     hidden?: string[];
     /**
@@ -2778,12 +3440,26 @@ interface ThemeSpec {
      * пришлось бы держать синхронным в двух местах.
      */
     model3dKey?: string;
+    /**
+     * Правки полей слоя рядом с фильтром (`cornerRadius`, `visible: true`…) по id — их приносит тема v2
+     * (`layout["osmgl-corner-radius"]`, `visibility: visible`). Темы v1 полей слоя не правили.
+     */
+    fields?: Record<string, Record<string, unknown>>;
 }
+/**
+ * ТЕМА НА ВХОДЕ — v2 или v1.
+ *
+ * Внешний формат темы — v2: те же накладки, ключи — имена v2 (`paint[id]["line-color"]`,
+ * `osmgl-light`, `paint.background["background-color"]`, `layout[id].visibility: none`). Тема v1
+ * (`color`, `light`, `background`, `hidden`) принимается ещё два выпуска — с одним предупреждением
+ * на имя. Внутри движка тема всегда в именах v1: `ThemeSpec`.
+ */
+type ThemeInput = ThemeSpec | ThemeSpecV2;
 /**
  * Накладывает тему на базовый стиль. Базовый не мутируется — возвращается
  * новый объект, иначе переключение туда-обратно накапливало бы правки.
  */
-declare function applyTheme(base: StyleSpec, theme: ThemeSpec): StyleSpec;
+declare function applyTheme(base: StyleSpec, input: ThemeInput): StyleSpec;
 
 /**
  * Разобранный стиль. Держит порядок слоёв (он же порядок отрисовки: художника
@@ -2792,6 +3468,8 @@ declare function applyTheme(base: StyleSpec, theme: ThemeSpec): StyleSpec;
 declare class Style {
     readonly spec: StyleSpec;
     readonly light: LightSpec;
+    /** Свет объёма MapLibre — для слоёв с `lighting: 'maplibre'` (см. `MapLibreLightSpec`). */
+    readonly mapLibreLight: MapLibreLightSpec;
     readonly sky: SkySpec;
     readonly layers: StyleLayerSpec[];
     /**
@@ -2823,6 +3501,11 @@ declare class Style {
      * и должен оставаться пригодным, когда пользователь отъедет или приблизится.
      */
     workerPlan(source?: string): LayerPlan[];
+    /**
+     * План воркера для ОДНОГО слоя. Отдельно — ради правок на лету (`setPaintProperty` и соседи):
+     * по нему видно, задела ли правка геометрию, и пересобирать тайлы нужно только тогда.
+     */
+    layerPlan(l: Exclude<StyleLayerSpec, RasterLayerSpec>): LayerPlan;
     /** Источники, на которые ссылается хоть один слой. */
     usedSources(): string[];
     /**
@@ -2887,9 +3570,22 @@ declare const RELIEF_STYLE: StyleSpec;
  * читается шумом; вода осталась водой, её блики и есть смысл материала.
  */
 declare const CITY_STYLE: StyleSpec;
+/**
+ * ВСТРОЕННЫЕ СТИЛИ osmgl ПО ИМЕНИ — для `map.setStyle('osm-city')`, как `mlight-city` у стилей MapLibre.
+ *
+ * Имя — имя файла в `styles/` без расширения: тем же именем стиль публикуется и по ссылке
+ * (`/styles/{slug}.json`), и строка, годная для `setStyle`, не зависит от того, лежит стиль в пакете
+ * или на сервере. Встроенный за JSON в сеть не ходит.
+ */
+declare const OSMGL_STYLES: Record<string, {
+    name: string;
+    style: StyleSpec;
+}>;
+/** Встроенный стиль osmgl по имени; не встроенное имя (в том числе ссылка) — `null`. */
+declare function builtinOsmglStyle(name: string): StyleSpec | null;
 declare const THEMES: Record<string, ThemeSpec>;
 /** Стиль с наложенной темой. Имя неизвестной темы приводит к базовому стилю. */
-declare function styleWithTheme(theme: string | ThemeSpec, base?: StyleSpec): StyleSpec;
+declare function styleWithTheme(theme: string | ThemeInput, base?: StyleSpec): StyleSpec;
 
 interface CoverOptions {
     minzoom: number;
@@ -3182,7 +3878,16 @@ declare class TileSource extends Evented<TileSourceEvents> {
         maxTiles?: number;
     }): void;
     /** Новый план (сменился стиль): кеш геометрии устарел целиком. */
-    setPlan(plan: LayerPlan[]): void;
+    setPlan(plan: LayerPlan[], key?: string): void;
+    /**
+     * Слепок плана, которым воркер сейчас режет тайлы, — для сравнения при смене стиля.
+     *
+     * Сравнивать новый стиль надо с тем, ЧТО У ВОРКЕРА, и делать это дёшево: раньше на каждый
+     * `setStyle` сериализовались планы и прежнего стиля, и нового. Слепок текущего считается один раз
+     * на план (лениво, при первом вопросе) и приходит готовым вместе с новым (`setPlan(plan, key)`).
+     */
+    get planKey(): string;
+    private _planKey;
     reload(): void;
     destroy(): void;
 }
@@ -3438,6 +4143,8 @@ declare class GlyphSource {
     private glyphs;
     private loaded;
     private inflight;
+    /** Номер набора глифов: растёт на каждый догруженный диапазон и смену адреса (см. `shapeTextCached`). */
+    version: number;
     constructor(
     /** Шаблон вида /tileserver/fonts/{fontstack}/{range}.pbf */
     urlTemplate: string, fontstack?: string);
@@ -3505,6 +4212,11 @@ interface Box {
     y1: number;
     x2: number;
     y2: number;
+    /**
+     * Радиус, если это КРУГ (центр — середина бокса): так у MapLibre место занимает подпись вдоль
+     * линии — цепочкой кругов (`placeCollisionCircles`). Без поля — прямоугольник.
+     */
+    r?: number;
     /**
      * Чьё это место.
      *
@@ -3551,6 +4263,43 @@ interface Candidate {
     }[];
     /** Те же вершины линии в меркаторе (x, y парами) — по ним сетка мест отмеряется ПО ЗЕМЛЕ. */
     lineWorld?: number[];
+    /**
+     * Линия целиком в координатах СВОЕГО ТАЙЛА — для мест по алгоритму MapLibre
+     * (`lineAnchors: 'maplibre'`): он считает их в тайле, с переувеличением и срезом по квадрату.
+     */
+    tileLine?: TileLine;
+    /**
+     * Порядок раскладки MapLibre (`placementMode: 'maplibre'`): номер тайла по их сортировке
+     * (`getRenderableIds(true)`) × 1e6 + номер символа в тайле. Приоритет такого кандидата — только
+     * полоса слоя, ранг фичи не участвует.
+     */
+    mlOrder?: number;
+    /** Зум данных тайла кандидата — для единиц боксов MapLibre (см. `placeAnchored`). */
+    tileZ?: number;
+}
+interface TileLine {
+    /** x, y парами, единицы тайла (`extent`). */
+    pts: number[];
+    extent: number;
+    /** Зум данных тайла. */
+    z: number;
+    /** Тайл в меркаторе: левый верхний угол и сторона. */
+    minX: number;
+    minY: number;
+    span: number;
+    /** Ключ тайла — для «повтора той же подписи ближе полушага» в пределах тайла. */
+    key: string;
+    /** Номер линии в бакете и сам бакет: места MapLibre считаются сразу на весь бакет (см. `bucketAnchors`). */
+    index: number;
+    bucket: SymbolBucketView;
+}
+/** То, что нужно от бакета подписей для мест MapLibre: линии, их границы, тексты и значки. */
+interface SymbolBucketView {
+    lines: Int16Array;
+    starts: Uint32Array;
+    texts: string[];
+    icons: string[];
+    extent: number;
 }
 /**
  * Размещённая подпись: то, что реально видно на экране в этом кадре.
@@ -3569,7 +4318,27 @@ interface PlacedSymbol {
     box: Box;
     /** Позиция слоя в стиле: верхняя подпись выигрывает попадание. */
     order: number;
+    /** Ключ подписи — тот, под которым она стоит (после сверки с прошлой раскладкой, см. `stableKey`). */
+    key?: string;
 }
+/**
+ * ★ МЕСТО ВДОЛЬ ЛИНИИ В СТИЛЕ MapLibre — СО СВОИМ РЕШЕНИЕМ И СВОЕЙ ПРОЗРАЧНОСТЬЮ (03.10.2026).
+ *
+ * У MapLibre каждое место линии (стрелка направления, щит) — отдельный символ со своим
+ * `crossTileID`: решение «стоит / не стоит» принимает расстановка раз в `fadeDuration`, а между
+ * расстановками каждое место держит своё решение и плавно идёт к нему (`JointOpacityState`).
+ *
+ * У нас решение было на ЛИНИЮ целиком: между расстановками решённая линия рисовала ВСЕ свои места
+ * без проверки — и те, которым расстановка отказала (стрелка под названием улицы). На каждой
+ * расстановке такая стрелка пропадала на кадр и тут же возвращалась: мигание с периодом 300 мс
+ * (замер на зуме 20→17, наклон 46°: 56 возвратов у нас против 18 у MapLibre, серии «+17 −1 +17 −1»).
+ * Теперь решение — на МЕСТО:
+ *   - на расстановке (`following = false`) место проверяется; встало — `show`, не встало, а прежде
+ *     стояло или ещё гаснет — `ghost` (гаснет без занятия места), иначе `none`;
+ *   - между расстановками — только прежнее решение: решённое `show` (без проверки), гаснущее `ghost`,
+ *     остальное `none` — новое место ждёт следующую расстановку, как у MapLibre.
+ */
+declare function mapLibreSpot(following: boolean, decided: boolean, fits: boolean, wasShown: boolean, fadingOut: boolean): 'show' | 'ghost' | 'none';
 declare class SymbolRenderer {
     private shader;
     private locations;
@@ -3586,6 +4355,17 @@ declare class SymbolRenderer {
     private pendingIcons;
     /** Сменить адрес шрифтов: `map.setGlyphs`. Разложенные подписи пересоберутся сами. */
     setGlyphsUrl(url: string): void;
+    /**
+     * ГАРНИТУРЫ СЛОЁВ (`textFont`, 02.10.2026). Свой набор глифов на каждую — как `text-font` у
+     * MapLibre: жирная подпись дороги берёт `Noto Sans Bold` с того же сервера шрифтов. Основной
+     * шрифт карты — `glyphs`; в атласе глифы других гарнитур лежат под своим префиксом.
+     */
+    private fonts;
+    private fontUrl;
+    private pendingFonts;
+    private glyphsFor;
+    /** Ключ глифа в атласе: у основной гарнитуры — прежний, у остальных — с её именем. */
+    private glyphKey;
     /**
      * Кого звать, когда стиль просит картинку, которой нет (`map.setMissingStyleImageResolver`).
      *
@@ -3613,6 +4393,7 @@ declare class SymbolRenderer {
      * Ставит рендерер; на обычной карте возвращает ноль, и проекция идёт как раньше.
      */
     elevationAt: ((mercX: number, mercY: number) => number) | null;
+    private readonly mainFont;
     constructor(fontUrl: string, fontstack?: string);
     init(ctx: Context): void;
     /**
@@ -3668,13 +4449,66 @@ declare class SymbolRenderer {
         text: string;
         mercX: number;
         mercY: number;
+        key?: string;
     }): string;
+    /**
+     * Вставшие в прошлой раскладке по «слой|текст»: тройки (mercX, mercY, ключ) — см. `stableKey`.
+     */
+    private placedByName;
+    /** Решённые подписи, которые в этом кадре не легли: не рисуются, но и не проигрывают. */
+    private heldNow;
+    /** Вставшие в этом кадре экземпляры подписей вдоль линии (ключ — слой, текст, точка земли). */
+    private placedInstances;
+    /**
+     * ТОЧНЫЕ места вставших экземпляров этого кадра (меркатор) — для сверки с MapLibre на странице
+     * примера. Ключи `placedInstances` для неё не годятся: точка в них квантована шагом
+     * `INSTANCE_QUANT` (≈4 м), а это на z20 уже 27 px — больше допуска сверки (12 px), и сверка
+     * насчитывала «пропавшие» стрелки там, где они стояли (z19.98: 4 из 16 при фактических 16 из 16).
+     */
+    private placedMarks;
+    /** Экземпляры, уже разобранные в этом кадре: улица приезжает несколькими кусками. */
+    private drawnInstances;
+    /** Призраки этой раскладки: их ключ тоже сверяется — вернувшаяся подпись обязана его узнать. */
+    private ghostsNow;
+    /**
+     * КЛЮЧ — ПО ДОПУСКУ, А НЕ ПО КЛЕТКЕ ОКРУГЛЕНИЯ (02.10.2026, как `CrossTileSymbolIndex` у MapLibre).
+     *
+     * Округление режет пространство на клетки, и объект у границы клетки получал в тайлах соседних
+     * уровней РАЗНЫЕ ключи: при зуме подпись пропадала и тут же проявлялась с нуля — моргала (замер
+     * на одном отдалении: 6 таких). Если в прошлой раскладке стояла подпись того же слоя и текста в
+     * пределах `KEY_TOLERANCE`, берём её ключ.
+     */
+    /**
+     * `nameKey` — «слой|текст», `ownKey` — собственный ключ места (`keyOf`). Обе строки приходят готовыми
+     * из `anchorStatics`: собирать их заново на каждый кадр и каждую подпись стоило больше самой сверки.
+     */
+    private stableKey;
+    /**
+     * НЕИЗМЕННОЕ У МЕСТА ПОДПИСИ — НА БАКЕТ, А НЕ НА КАДР (03.10.2026).
+     *
+     * Сбор кандидатов шёл каждый кадр и каждый раз заново строил строки ключей (шаблон из слоя, текста
+     * и координат) и копировал линию тайла. Хуже самой сборки — то, что СВЕЖАЯ строка в `Set.has`
+     * хешируется заново по всей длине: на стиле MapLibre в 315 слоёв проверки ключей в цикле раскладки
+     * были самой горячей строкой кадра (замер: `decidedKeys.has`, `placedKeys.has` — больше, чем вся
+     * расстановка). Готовая строка хеш помнит. Записи живут с бакетом (`WeakMap`) и заполняются
+     * лениво — по тем местам, что дошли до раскладки.
+     */
+    private anchorStaticsCache;
+    private anchorStatics;
     setHover(key: string | null): boolean;
     setHidden(key: string | null): boolean;
     /**
      * Подпись под точкой экрана. Идём СВЕРХУ ВНИЗ по порядку стиля: под курсором
      * оказывается то, что человек видит верхним, а не то, что нарисовано первым.
      */
+    /**
+     * ВСЕ подписи под точкой, сверху вниз — для редактора стилей («какие слои здесь нарисованы»).
+     * Одна подпись (`querySymbol`) нужна клику; редактору нужны и те, что легли под ней.
+     */
+    querySymbols(point: {
+        x: number;
+        y: number;
+    }, tolerance?: number): PlacedSymbol[];
     querySymbol(point: {
         x: number;
         y: number;
@@ -3715,16 +4549,6 @@ declare class SymbolRenderer {
     /** Дымка этого кадра и камера — по ним считается затухание подписи вдаль. */
     private fog;
     private tr;
-    /**
-     * ГДЕ ПОДПИСЬ СТОЯЛА — переведённое в расстояние вдоль СЕГОДНЯШНЕЙ линии.
-     *
-     * Место запоминается точкой на земле, а не расстоянием от начала линии. Расстояние не годится:
-     * при наклоне камера срезает у ломаной начало (точку за собой спроецировать нельзя), и с каждым
-     * сдвигом карты отсчёт ведётся от другой вершины — сетка мест уезжает вдоль улицы, а с ней и
-     * название. Точка на асфальте не зависит ни от камеры, ни от обрезки: её достаточно спроецировать
-     * заново и померить, на каком она расстоянии сейчас.
-     */
-    private rememberedAt;
     /**
      * Запомнить места этого кадра точками на земле.
      *
@@ -3733,7 +4557,25 @@ declare class SymbolRenderer {
      * предыдущих: на следующем кадре они оказывались без памяти и выбирали место заново. Это и было
      * остаточное «ползание» на части улиц.
      */
-    private rememberAt;
+    /** Вид сверху на той же камере (наклон 0) — по нему раскладывается подпись на асфальте. */
+    private flatCam;
+    private flatCamFor;
+    private flatCamKey;
+    private flatCamera;
+    /**
+     * Последний квад буквы — с плоского вида на экран. Пикселей на тексель у каждого угла свой
+     * (ближний край буквы крупнее дальнего): его берёт шейдер для ширины сглаживания.
+     * `false` — угол ушёл за камеру, квад снят.
+     */
+    private toGround;
+    /**
+     * Запомненные экземпляры подписи на этой линии: где начинается строка и точка земли её середины.
+     *
+     * Точка земли — середина строки при первой постановке; она же ключ экземпляра. Переписывать её
+     * тем, что нарисовалось, нельзя: перевод «экран → земля → экран» каждый раз даёт доли пикселя, и
+     * подпись медленно, но безостановочно ползла бы по улице.
+     */
+    private rememberedMarks;
     /**
      * Попадает ли бокс в область раскладки — кадр, расширенный на `LAYOUT_MARGIN`.
      *
@@ -3760,6 +4602,45 @@ declare class SymbolRenderer {
     private shownAt;
     /** Есть ли в кадре подпись, которая ещё проявляется — по ней решается, нужен ли следующий кадр. */
     private fading;
+    /**
+     * Длительность проявления и угасания этого кадра: у своих тем `FADE_MS`, у стиля MapLibre — их
+     * `ML_FADE_MS`. Решается по стилю в начале раскладки (`render`).
+     */
+    private fadeMs;
+    /**
+     * ★ ЗАТУХАНИЕ УШЕДШИХ ПОДПИСЕЙ — КАК У MAPLIBRE (02.10.2026).
+     *
+     * Подпись, проигравшая место (сосед важнее, карту сдвинули), раньше пропадала в тот же кадр, а
+     * появлялась плавно — на глаз это читалось как мигание. MapLibre держит прозрачность на каждую
+     * подпись и гасит невставшую за то же время, за которое проявляет (`symbolFadeChange`). Здесь —
+     * «призрак»: стоявшая в прошлой раскладке подпись, которой места не нашлось, рисуется ещё
+     * `FADE_MS` по своему последнему месту БЕЗ проверки и без занятия места — соседям она не мешает.
+     * Запись: когда начала гаснуть и с какой прозрачности (гаснуть могла и недопроявившаяся).
+     */
+    private hiddenAt;
+    /** Прозрачность призрака, которого сейчас раскладывают; `-1` — обычная раскладка. */
+    private ghostOpacity;
+    /**
+     * ★ РЕШЕНИЕ «КТО ВИДЕН» — НЕ ЧАЩЕ РАЗА В 300 МС, КАК У MAPLIBRE (02.10.2026).
+     *
+     * Веб раскладывал подписи заново в КАЖДОМ кадре зума, и решение «помещается ли» перещёлкивалось
+     * туда-обратно на долях пикселя: за один зум 14–26 подписей «встала — пропала — встала», каждый раз
+     * с проявлением с нуля. Это и было мигание. MapLibre расставляет раз в 300 мс (чаще при отдалении,
+     * `zoomAdjustment`), а между расстановками двигает уже выбранные. Здесь так же: пока камера едет,
+     * между полными расстановками раскладываются ТОЛЬКО решённые подписи, без проверки столкновений, —
+     * место у них и так своё.
+     */
+    private decidedKeys;
+    private decidedAt;
+    private decidedZoom;
+    /** Камера прошлой раскладки: изменилась — значит, едем. */
+    private lastCamera;
+    /** Раскладывается решённая подпись между расстановками: место не проверяется. */
+    private following;
+    /** Текущая прозрачность проявления — без побочных эффектов, в отличие от `fadeOf`. */
+    private fadeInOf;
+    /** Текущая прозрачность гаснущей подписи; `0` — погасла. */
+    private fadeOutOf;
     /**
      * ГОТОВЫЙ КАДР ПОДПИСЕЙ — ПОВТОРЯЕМ, ЕСЛИ НИЧЕГО НЕ МЕНЯЛОСЬ (30.09.2026).
      *
@@ -3780,6 +4661,20 @@ declare class SymbolRenderer {
     private styleIds;
     private nextStyleId;
     private idOf;
+    /**
+     * ★ ПРАВКА ПОКРАСКИ НЕ ПЕРЕСОБИРАЕТ РАСКЛАДКУ (03.10.2026).
+     *
+     * В подписи кадра стоял номер ОБЪЕКТА стиля, а редактор на каждую правку ставит новый стиль: смена
+     * одного цвета заливки стоила полной расстановки подписей — 100–250 мс при CPU ×4 на стиле MapLibre в
+     * 315 слоёв. Теперь в подпись идёт только то, от чего раскладка зависит: слои подписей с их
+     * фильтрами, зумами и `layout`, из покраски — обводка (от неё считается разрядка букв,
+     * `letterSpacingFor`) и наличие тени значка, плюс дымка (за ней подписи не ставятся). Цвета и
+     * прозрачности читаются при отрисовке (`drawRanges`) у слоёв НОВОГО стиля — см. `render`.
+     */
+    private layoutStamps;
+    private layoutStamp;
+    /** Стиль, по слоям которого собраны `lastRanges`: покраска берётся у его слоёв. */
+    private rangesStyle;
     private frameSignature;
     /** Прозрачность подписи: только что появилась — проявляется, стоит давно — единица. */
     private fadeOf;
@@ -3805,11 +4700,137 @@ declare class SymbolRenderer {
      * повезло оказаться раньше в списке после сдвига камеры на пиксель.
      */
     order(candidates: Candidate[]): void;
+    /**
+     * Стиль сменился, а раскладка та же (см. `layoutStamp`): диапазоны переводятся на слои НОВОГО стиля
+     * — по ним `drawRanges` берёт покраску, — и ссылки на чужой цвет тоже.
+     */
+    private adoptStyle;
     /** Запомнить, что встало, — на этом держится липкость следующего кадра. */
     private rememberPlaced;
     render(ctx: Context, tr: Transform, sources: Map<string, TileSource>, style: Style): void;
     private collect;
     private place;
+    /**
+     * РАСКЛАДКА ПО ЯКОРЯМ (MapLibre): значок и подпись — каждый своим якорем к точке объекта.
+     *
+     * Отличие от блочной раскладки не косметическое. У нас значок с подписью — один блок, и на объекте
+     * стоит СЕРЕДИНА блока; у MapLibre на объекте стоит то, что назвал якорь: у POI — центр значка, а
+     * подпись висит под ним на `text-offset`. Стиль MapLibre, разложенный блоком, съезжает вверх на
+     * полподписи, и подписи соседей сталкиваются не там, где у MapLibre.
+     *
+     * Место в сетке коллизий — общий охват значка и подписи: раздельные боксы у MapLibre нужны только
+     * для `*-optional`, которого у нас пока нет.
+     */
+    private placeAnchored;
+    /**
+     * Размер значка в раскладке по якорям: у картинки спрайта — натуральный × `iconScale`; у
+     * встроенного силуэта натурального нет — тогда `iconSize` в пикселях (16 × `iconScale`).
+     */
+    private anchoredIconSize;
+    /** Перспектива у точки экрана — как `getPerspectiveRatio` MapLibre: 0.5 + 0.5 · до центра / до точки. */
+    private perspectiveAt;
+    /**
+     * Отметить вставшее МЕСТО символа (для сверки с MapLibre и учёта экземпляров): ключ тот же, что у
+     * подписей вдоль линии, — слой, текст, точка в меркаторе с шагом `INSTANCE_QUANT`.
+     */
+    private notePlaced;
+    /** Ключ места символа: слой, текст и точка земли (квантованная `INSTANCE_QUANT`). */
+    private instanceKey;
+    /**
+     * ★ КЛЮЧ МЕСТА ЛИНИИ В СТИЛЕ MapLibre — ПО ДОПУСКУ, КАК `CrossTileSymbolIndex` (03.10.2026).
+     *
+     * Места вдоль линии считаются в тайле с переувеличением по ЦЕЛОМУ зуму кадра (`bucketAnchors`), и
+     * на каждом переходе через целый зум точная точка стрелки сдвигается на доли метра — ключ по
+     * точной точке менялся, решение «стоит» терялось, и стрелка пропадала до следующей расстановки
+     * (замер на 18→21: у всех стрелок разом серия «+16 −4»). MapLibre такие места сводит в один
+     * символ: ключ по сетке в 2 пикселя тайла ДАННЫХ (`roundingFactor`), допуск одна клетка, и одно
+     * прежнее место не достаётся двум новым (`zoomCrossTileIDs`). Здесь так же: ищем ближайшее место
+     * того же слоя и текста из прошлого кадра в пределах `2⁻⁸ / 2^z` меркатора (2 px тайла z).
+     */
+    private mlSpotKey;
+    /**
+     * Места линий стиля MapLibre прошлого и этого кадра — «слой|текст» → клетка `ML_SPOT_CELL` (номером) →
+     * места (см. `mlSpotKey`). Двухуровневые, а не строкой «слой|текст|x|y»: поиск смотрит девять клеток,
+     * и девять свежих строк на каждое место каждой линии каждый кадр были заметной частью раскладки.
+     */
+    private mlSpotsPrev;
+    private mlSpotsNow;
+    /** Ключи мест, уже отданные в этом кадре: одно прежнее место — одному новому. */
+    private mlSpotsUsed;
+    /**
+     * ★ ПРОПАВШЕЕ МЕСТО ГАСНЕТ, А НЕ ИСЧЕЗАЕТ (03.10.2026).
+     *
+     * На переходе через целый зум места линии пересчитываются с новым переувеличением, и часть прежних
+     * мест перестаёт существовать вовсе: новых точек рядом нет. Такая стрелка исчезала в тот же кадр, а
+     * её замена ждала расстановки (до 300 мс) и проявлялась с нуля — провал, который на экране и есть
+     * мигание (замер на 16→20, наклон 46°: у 8 стрелок серия «+12 −27 +…» на переходе через z17).
+     * MapLibre держит старый тайл до загрузки нового и ещё `fadeDuration` после (`holdingForFade`), так
+     * что пропавший символ у них гаснет на своём месте. Здесь так же: стоявшее в прошлом кадре место,
+     * которого в этом кадре нет ни в одной линии, гаснет по запомненной точке без занятия места.
+     */
+    private mlShownNow;
+    private mlShownPrev;
+    private mlOrphans;
+    /** Прозрачность осиротевшего места: только угасание; `null` — погасло. */
+    private mapLibreOrphanAlpha;
+    /**
+     * Осиротевшие места этого кадра: стояли (или гасли сиротами) в прошлом, а в этом их не посетила ни
+     * одна линия. Собираются по кандидату, чтобы раскладка шла тем же путём, что и у живых мест.
+     */
+    private collectOrphans;
+    /**
+     * Решение и прозрачность места линии в стиле MapLibre (см. `mapLibreSpot`). `fits` — прошло ли
+     * место проверку (спрашивается только на расстановке). Возвращает прозрачность или `null`, если
+     * место не рисуется. Гаснущее место получает запись в `hiddenAt`, вставшее — возраст в `shownAt`.
+     */
+    private mapLibreSpotAlpha;
+    /** Вид бакета для мест MapLibre — один объект на бакет, чтобы по нему держать кеш мест. */
+    private bucketViews;
+    private bucketView;
+    /** Места MapLibre по бакету: слой·целый зум·версия картинок → места каждой линии (единицы ML_EXTENT). */
+    private mlAnchorCache;
+    /**
+     * МЕСТА ВДОЛЬ ЛИНИЙ — СРАЗУ НА ВЕСЬ БАКЕТ ТАЙЛА, в его порядке, как `performSymbolLayout` MapLibre.
+     *
+     * Иначе нельзя из-за отсева повторов (`anchorIsTooClose`: тот же текст в тайле ближе полушага шага
+     * второй раз не ставится). Он идёт по ВСЕМ линиям бакета по порядку — и линия, ушедшая за камеру,
+     * тоже глушит свои повторы у соседей. Считая места по кандидатам в кадре, мы теряли эти линии, и
+     * у соседних вставали лишние щиты. От камеры места не зависят, поэтому и кешируются до смены
+     * целого зума; кеш не ставится, пока не приехали глифы и картинки — по недостающим ширины не те.
+     */
+    private bucketAnchors;
+    /**
+     * МЕСТА ВДОЛЬ ЛИНИИ ПО АЛГОРИТМУ MapLibre (`text/maplibre-anchors.ts`), в меркаторе.
+     *
+     * Переувеличение — по ЦЕЛОМУ зуму кадра против зума данных тайла, как у тайлов MapLibre с
+     * `overscaledZ`: между целыми зумами места не переезжают, на целом — пересчитываются. Угол — в
+     * координатах тайла (вдоль звена); экранный угол раскладка берёт сама, проецируя точку чуть дальше.
+     */
+    private mapLibreAnchors;
+    /** Места MapLibre для изогнутой строки — как начала строки на экранной линии `screen`. */
+    private mapLibreTextAts;
+    /** Якоря MapLibre (меркатор, парами) к последнему `mapLibreTextAts` — по ним ключи экземпляров. */
+    private mlTextMarks;
+    /**
+     * ЗНАЧКИ, ЛЕЖАЩИЕ НА ДОРОГЕ (`icon-pitch-alignment: map`) — стрелки направления у MapLibre.
+     *
+     * Значок стоящий и значок лежащий отличаются не поворотом, а ПЛОСКОСТЬЮ: лежащий сплющивается
+     * наклоном камеры, как сам асфальт, и дальние стрелки мельче ближних. Раскладка поэтому идёт в
+     * плоском виде сверху (`flatCamera`) — там значок обычный прямоугольник, повёрнутый по звену, — а
+     * его углы переносятся на экран через землю (`toGround`), тем же приёмом, что буквы названий улиц
+     * «по карте». Бокс коллизий — охват перенесённых углов: место значок занимает там, где виден.
+     */
+    private placeIconsOnGround;
+    /**
+     * ЗНАЧКИ И ПОДПИСИ «СТОЯ» ВДОЛЬ ЛИНИИ — как `symbol-placement: line` у MapLibre для стрелок
+     * одностороннего движения и щитов трасс.
+     *
+     * Узлы — та же сетка мест на земле, что у названий улиц (`groundGrid`): через `symbolSpacing`
+     * пикселей целого зума, поэтому при панораме стрелки едут вместе с асфальтом, а не скользят по нему.
+     * В каждом узле ставится обычная раскладка по якорям; значок при `iconAlongLine` повёрнут по
+     * звену (плюс свой `iconRotate`), подпись всегда горизонтальна.
+     */
+    private placePointsOnLine;
     /**
      * Подпись вдоль линии: по квадру на глиф, каждый со своим поворотом.
      *
@@ -3853,6 +4874,26 @@ declare class SymbolRenderer {
     private requestMissing;
     destroy(ctx: Context): void;
 }
+/**
+ * Линия объекта из тайла в экранные координаты.
+ *
+ * Обрывается на первой точке за камерой: дальше ломаная не имеет смысла, а
+ * оставшегося куска подписи может хватить. Пустой результат — объект не виден.
+ */
+declare function projectLine(tr: Transform, lines: Int16Array, starts: Uint32Array, index: number, originX: number, originY: number, scale: number, 
+/** Высота земли под точкой, метры — на рельефе название улицы идёт по склону вместе с дорогой. */
+elevationAt?: ((mercX: number, mercY: number) => number) | null, 
+/** Сюда — те же вершины в меркаторе, парами: по ним сетка мест отмеряется по земле. */
+world?: number[], 
+/**
+ * Стиль MapLibre: пропускать НАЧАЛО линии за камерой, а не бросать линию целиком (на наклоне улица
+ * часто начинается за спиной, а видна дальше — у MapLibre её места стоят, у нас линия выпадала),
+ * и звено, пересекающее плоскость камеры, РЕЗАТЬ по ближней плоскости, а не терять с вершиной.
+ */
+skipLeading?: boolean): {
+    x: number;
+    y: number;
+}[] | undefined;
 /**
  * Куда ставить подпись у слоя со стрелкой на земле.
  *
@@ -4081,8 +5122,23 @@ declare class IndoorMask {
      * Берётся из бакета оболочки (`class = level`) — это и есть след здания на
      * уровне. Пересчитывается при смене этажа или набора тайлов, а не каждый кадр:
      * разбор бакета стоит заметно дороже отрисовки.
+     *
+     * ★ ПЕРЕСЧЁТ — ИЗ КЕША, А НЕ ЗАНОВО (03.10.2026). Набор тайлов меняется на каждом шаге панорамы, и
+     * каждая смена разбирала заново ВСЁ: контуры планов всех тайлов, рамки всех зданий всех тайлов
+     * (перебор треугольников) и урезанные индексы каждого тайла с заливкой в видеопамять. На стиле osmgl в
+     * 304 слоя это была треть работы кадра при панораме — до 0.6 с длинной задачей при CPU ×4 (замер
+     * редактора стилей: `collectHidden` + `prepare` + `cutHidden`). Теперь контур тайла плана и центры
+     * домов тайла считаются один раз на меш (`footprintOf`, `centersOf`), проверка «внутри плана» идёт
+     * по сетке треугольников контура, а урезанные индексы пересобираются, только если сменился набор
+     * скрытых домов ЭТОГО тайла (`indicesFor`).
      */
     sync(sources: Map<string, TileSource>, style: Style, zoom: number): void;
+    /** Сетки контуров планов текущей маски — по ним идёт проверка «внутри» (см. `inside`). */
+    private grids;
+    /** Номер состава `hidden`: растёт на каждое изменение (см. `indicesFor`). */
+    private hiddenVersion;
+    /** Лежит ли точка в контуре плана: то же, что `insideFootprint(parts, x, y, 0)`, но по сеткам. */
+    private inside;
     /**
      * Отметить дома этого тайла, попавшие под план.
      *
@@ -4091,13 +5147,7 @@ declare class IndoorMask {
      */
     private collectHidden;
     destroy(): void;
-    private free;
-    /**
-     * Индексы здания без тех фич, что стоят под открытым этажом.
-     *
-     * Считается ОДИН раз на тайл и на маску: перебор треугольников с проверкой
-     * принадлежности — работа для загрузки, а не для кадра.
-     */
+    private free;
     /**
      * Отметить дома под планом по ВСЕМ видимым тайлам сразу.
      *
@@ -4105,8 +5155,15 @@ declare class IndoorMask {
      * просмотренном тайле, в этом кадре останется наполовину видимым.
      */
     prepare(source: TileSource, layerId: string): void;
-    /** Геометрия зданий тайла без тех, что стоят под открытым этажом. */
-    indicesFor(ctx: Context, tile: Tile, layerId: string, id: TileID, vbo: VertexBuffer, locations: Map<string, number>): {
+    /**
+     * Геометрия зданий тайла без тех, что стоят под открытым этажом.
+     *
+     * Считается ОДИН раз на тайл и на состав скрытого В ЭТОМ ТАЙЛЕ: перебор треугольников и заливка
+     * индексов — работа для загрузки, а не для кадра. Подпись — номера скрытых домов тайла.
+     */
+    indicesFor(ctx: Context, tile: Tile, layerId: string, id: TileID, vbo: VertexBuffer, locations: Map<string, number>, 
+    /** Цвет из данных: без него урезанный дом рисовался бы чёрным (см. `cutHidden`). */
+    dataBuffer?: VertexBuffer | null): {
         vao: VertexArray;
         count: number;
     } | null;
@@ -5537,6 +6594,11 @@ declare class LayerRenderer {
     private materialTime;
     /** Хоть один материал в кадре анимируется — значит нужен следующий кадр. */
     private materialAnimating;
+    /**
+     * Следующий кадр нужен ТОЛЬКО ради материала (бегущей воды): карта может рисовать его реже
+     * (`MATERIAL_IDLE_MS` у `Map`) — так же, как натив.
+     */
+    onlyMaterialsAnimating: boolean;
     /**
      * Материал ТЕКУЩЕГО слоя анимирован (бегущая вода) — но кадр просим, только если слой что-то
      * нарисовал.
@@ -5614,6 +6676,12 @@ declare class LayerRenderer {
         featureId: number;
         color: string;
         opacity: number;
+        /**
+         * Куски БЕЗЫМЯННОГО дома: ключ тайла → номер куска в нём (см. `anonymousParts`). Задан —
+         * подсвечиваются только эти тайлы и каждый своим номером: номер такого дома свой в каждом
+         * тайле, и «по номеру во всех тайлах» покрасил бы у соседа чужой дом.
+         */
+        parts?: ReadonlyMap<string, number>;
     } | null;
     /** Куски подсветки по тайлам: `null` — в этом тайле такой фичи нет. */
     private highlightGpu;
@@ -5750,8 +6818,9 @@ declare class LayerRenderer {
     /**
      * Какие фичи ЕСТЬ в бакете. Живёт до перезагрузки тайла и переживает смену набора замен.
      *
-     * Ограничен по размеру грубо, сбросом целиком: записи вытесненных тайлов сами по себе не уходят,
-     * а точный учёт стоил бы больше, чем пересчёт пары сотен списков раз в долгую сессию.
+     * Держится на самом буфере номеров фич (`WeakMap`): уходит вместе с тайлом, и ограничивать его
+     * размер сбросом целиком не нужно. Строится по отрезкам фич (`featureRuns`), а не по номеру на
+     * каждый треугольник: у тайла домов их сотни тысяч, отрезков — тысячи.
      */
     private bucketIdCache;
     /** Разобранные поверхности без заменённых фигур. Сбрасывается вместе с `hiddenCut`. */
@@ -5812,6 +6881,27 @@ declare class LayerRenderer {
     /** Места атрибутов у шейдера пачки: и вершинные, и на экземпляр. */
     private modelInstLocs;
     init(ctx: Context): void;
+    /** Программы из `init`, о готовности которых ещё не спрашивали; пусто — `finishInit` пройден. */
+    private initShaders;
+    private initCtx;
+    /**
+     * Программы карты ещё собираются: кадр рисовать нечем.
+     *
+     * ★ КАРТА НЕ ЖДЁТ КОМПИЛЯТОР (03.10.2026). Создание карты было одной задачей главного потока на
+     * 0.8–0.9 с: два десятка программ собирались по очереди, и каждую ждали. Теперь `init` только
+     * отправляет их компилятору, а кадр, пока он работает (`KHR_parallel_shader_compile`), спрашивает
+     * готовность БЕЗ ожидания и пропускает отрисовку — тайлы тем временем уже грузятся. Без расширения
+     * ответ «готово» приходит сразу, и первый кадр подождёт сборку, как раньше.
+     */
+    get programsPending(): boolean;
+    /**
+     * ВОПРОСЫ К ПРОГРАММАМ — ТОЛЬКО ПОСЛЕ ТОГО, КАК ЗАКАЗАНЫ ВСЕ.
+     *
+     * Номер атрибута, юниформ — любой вопрос к программе ждёт конца её сборки (см. `Shader.pending`).
+     * Стоял такой вопрос между созданием программ — и следующие уходили компилятору только после того,
+     * как была собрана эта: потоки компилятора простаивали, а главный поток ждал по очереди.
+     */
+    private finishInit;
     /** true, если что-то ещё анимируется и нужен следующий кадр. */
     render(ctx: Context, tr: Transform, sources: Map<string, TileSource>, style: Style, now: number, rasterSources?: Map<string, RasterSource>): boolean;
     /**
@@ -5860,6 +6950,24 @@ declare class LayerRenderer {
      * нужно знать, какому куску мира она принадлежит, — отсюда `u_tile_merc`.
      * На плоской карте всё наоборот: матрица своя у каждого тайла.
      */
+    /**
+     * СЛОЙ, УПАВШИЙ ПРИ ОТРИСОВКЕ, ПРОПУСКАЕТСЯ, А НЕ ГАСИТ КАДР.
+     *
+     * Исключение из одного слоя раньше выходило из `render` целиком: кадр обрывался на полпути, и
+     * так каждый следующий — карта становилась пустой из-за одного поля одного слоя (поймано в
+     * редакторе стилей: строка в прозрачности заливки). Значения не того типа теперь отсекает разбор
+     * стиля (`style/sanitize.ts`), а это — вторая линия: любая другая беда в слое стоит только этого
+     * слоя. Во всех проходах, перебирающих слои, тело цикла обёрнуто в `try`; в V8 он бесплатен, пока
+     * ничего не бросают, — покадровый путь не дорожает (замер — README, «Справочник стиля и проверка»).
+     *
+     * Сказано ОДИН раз на слой и причину: слой бросает каждый кадр, а консоль — не журнал кадров.
+     * Пропуск не запоминается: правка, починившая слой, видна сразу, без смены стиля.
+     */
+    private readonly reported;
+    /** Обработчик падений слоёв (карта превращает их в событие `error`). */
+    onLayerError: ((what: string, error: unknown) => void) | null;
+    private reportFailure;
+    private layerFailed;
     /**
      * ПЛОСКИЙ ПРОХОД: земля в порядке стиля, без теста глубины.
      *
@@ -6088,11 +7196,21 @@ declare class LayerRenderer {
      * переключение теней соберёт свой набор один раз. Фасад зависит от зума — перебираем зумы слоя.
      */
     private warmVariants;
+    /** Варианты программ, нужные стилю из `warmVariants`: по ним кадр решает, можно ли его рисовать. */
+    private styleShaders;
+    /** Стиль последнего кадра, нарисованного целиком, — его показываем, пока собираются программы нового. */
+    private drawnStyle;
+    /** С какого кадра ждём программы нового стиля; -1 — не ждём. */
+    private styleWaitSince;
+    /** Хоть один вариант стиля ещё собирается — спрашивается без ожидания (см. `Shader.ready`). */
+    private variantsPending;
     /** Рисунок вдоль линии: 0 сплошная, 1 штрих, 2 шевроны, 3 стрелки, 4 только стрелки, 5 стрелки-штрих. */
     private linePatternOf;
     /** Программа линий под этот слой и кадр — тот же приём, что у поверхности (см. surfaceShader). */
     private lineShader;
     private applyMaterial;
+    /** Метров на аппаратный пиксель у самого близкого к камере края земли — на кадр (см. `applyMaterial`). */
+    private finestMeters;
     private drawFill;
     private drawLine;
     /**
@@ -6203,6 +7321,15 @@ declare class LayerRenderer {
      */
     private growScale;
     private applyLight;
+    /**
+     * СВЕТ MapLibre — юниформы ровно как у `fillExtrusionUniformValues` (`fill_extrusion_program.ts`).
+     *
+     * Положение `[r, азимут, полярный]` переводится `sphericalToCartesian` (азимут +90°, длина r НЕ
+     * нормируется — у MapLibre вектор длиной 1.15, и крыша получает dot = 0.996, а не 0.866). При
+     * `anchor: viewport` вектор поворачивается курсом камеры (`mat3.fromRotation`), и свет остаётся
+     * на месте относительно экрана. Оси те же, что у тайла: x на восток, y на юг.
+     */
+    private applyMapLibreLight;
     /** Буферы GPU создаются лениво и живут в Tile.buckets — источник их и уничтожит. */
     /**
      * Собрана ли поверхность этого слоя как ПЛОСКАЯ заливка.
@@ -6390,6 +7517,124 @@ declare class Objects3DManager {
     clear(drop: (m: Model) => void): void;
 }
 
+/**
+ * ИМПОРТ СТИЛЯ MapLibre v8 В osmgl.
+ *
+ * Стиль MapLibre подключается как есть (`map.setStyle(url)`), а не переписывается заранее руками:
+ * такие стили приходят по ссылке во время работы и меняются без нас. Разбор соответствия всех
+ * полей и план — `porting/maplibre-style-import.md`.
+ *
+ * Импортёр — ЧИСТЫЙ ПЕРЕВОД: переименование полей, перевод единиц, старые функции → выражения,
+ * старые фильтры → наша форма. Он ничего не «приближает»: если движок чего-то не умеет, свойство
+ * попадает в отчёт (`unsupported`), а не заменяется похожим. Пробел движка закрывается в движке.
+ *
+ * Сеть здесь не нужна: TileJSON-источники разворачивает `loadMapLibreStyle`, а сюда приходит
+ * уже готовый стиль. Так перевод проверяется тестами без сервера.
+ */
+/** Стиль MapLibre — в том объёме, в каком его читает импортёр. */
+interface MapLibreStyle {
+    version: 8;
+    name?: string;
+    metadata?: unknown;
+    center?: [number, number];
+    zoom?: number;
+    bearing?: number;
+    pitch?: number;
+    sources: Record<string, MapLibreSource>;
+    sprite?: string | {
+        id: string;
+        url: string;
+    }[];
+    glyphs?: string;
+    layers: MapLibreLayer[];
+    [key: string]: unknown;
+}
+interface MapLibreSource {
+    type: string;
+    url?: string;
+    tiles?: string[];
+    minzoom?: number;
+    maxzoom?: number;
+    scheme?: 'xyz' | 'tms';
+    tileSize?: number;
+    encoding?: 'mapbox' | 'terrarium';
+    data?: unknown;
+    coordinates?: unknown;
+    [key: string]: unknown;
+}
+interface MapLibreLayer {
+    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>;
+}
+interface MapLibreImport {
+    style: StyleSpec;
+    /** Шаблон глифов (`{fontstack}`/`{range}`), если стиль его задал. */
+    glyphs?: string;
+    /** Спрайты: основной — с пустым `id`, дополнительные — со своим (имена значков `id:имя`). */
+    sprites: {
+        id: string;
+        url: string;
+    }[];
+    /** Камера стиля — применяется только при первой загрузке, как у MapLibre. */
+    camera: {
+        center?: [number, number];
+        zoom?: number;
+        bearing?: number;
+        pitch?: number;
+        roll?: number;
+        /** Высота центра над уровнем моря, м (`centerAltitude`). */
+        centerAltitude?: number;
+    };
+    /** Проекция стиля (`projection.type`): у движка есть меркатор и глобус. */
+    projection?: 'mercator' | 'globe';
+    /** Умолчания общего состояния (`state`): имя → значение `default`. */
+    state?: Record<string, unknown>;
+    /** Стиль с признаком v2 (`metadata["osmgl:version"]: 2`) — свой, а не чужой стиль MapLibre. */
+    osmgl: boolean;
+    /** Что не перенесено: «тип.свойство» → число слоёв. Пусто — стиль перенесён целиком. */
+    unsupported: Record<string, number>;
+}
+declare function isMapLibreStyle(value: unknown): value is MapLibreStyle;
+/**
+ * Перевести стиль MapLibre в стиль osmgl.
+ *
+ * У источников `url` уже должен быть шаблоном тайлов (`.../{z}/{x}/{y}.pbf`): TileJSON
+ * разворачивает `loadMapLibreStyle`. Источник с `tiles[]` годится как есть.
+ */
+declare function importMapLibreStyle(ml: MapLibreStyle): MapLibreImport;
+/**
+ * Значение свойства: старая функция (`{stops, base, type, property}`) → выражение, остальное как есть.
+ *
+ * Правила — `function/convert.ts` из maplibre-style-spec. Вид функции по умолчанию: у числа и
+ * цвета — `exponential` (интерполяция), у всего прочего — `interval` (ступенька).
+ */
+declare function convertValue(value: unknown): unknown;
+/**
+ * Старый фильтр остаётся старым — `matchesFilter` его понимает, включая `$type` и `$id`. Переводим
+ * только `none`, которого у нас нет, и проходим вглубь `all`/`any`. Фильтр-выражение — как есть.
+ */
+declare function convertFilter(filter: unknown): Filter;
+/**
+ * Загрузить стиль MapLibre по ссылке (или взять готовый объект) и перевести его.
+ *
+ * Разворачивает TileJSON-источники (`url` без `{z}`) в шаблон тайлов и зумы, относительные адреса
+ * приводит к абсолютным по адресу стиля — как это делает MapLibre.
+ *
+ * Строка — это ссылка ЛИБО имя встроенного стиля (`mlight-city`, `mnight-city`, см.
+ * `style/maplibre-styles.ts`). Встроенный стиль за JSON в сеть не ходит, а относительные адреса в
+ * нём разрешаются по адресу, с которого снят снимок, — как если бы его скачали. У готового объекта
+ * адреса нет, и тогда его можно передать третьим аргументом (`baseUrl`).
+ */
+declare function loadMapLibreStyle(input: string | MapLibreStyle, fetcher?: (url: string) => Promise<unknown>, baseUrl?: string | null): Promise<MapLibreImport>;
+
 /**
  * ЧТО НАРИСОВАНО ПОД ТОЧКОЙ — с теми же именами полей, что у MapLibre.
  *
@@ -6536,6 +7781,20 @@ declare function pickFill(tr: Transform, source: TileSource, layerIds: string[],
 }, 
 /** Высота земли, метры: план этажа на рельефе лежит на склоне, как и всё остальное. */
 groundAtMerc?: (mx: number, my: number) => number): BuildingHit | null;
+/**
+ * КУСКИ БЕЗЫМЯННОГО ДОМА ПО ТАЙЛАМ: ключ тайла → номер куска в нём (02.10.2026).
+ *
+ * Номер дома без `osm_id` свой в каждом тайле (−1, −2, … по порядку фич), и подсветка «по номеру во
+ * всех тайлах сразу», которой выделяется обычный дом, покрасила бы в соседнем тайле чужой дом, а
+ * свою половину оставила бы серой. Сшить номера заранее нечем: воркер видит один тайл.
+ *
+ * Связываем по ГЕОМЕТРИИ, в момент выбора. Кусок, разрезанный границей, кладёт вершины крыши на
+ * линию разреза — по одной на каждый конец каждого разреза, — и у продолжения в соседнем тайле они
+ * стоят там же (с поправкой на нахлёст `bleedRing`, до единицы вдоль стены). Продолжением считаем
+ * безымянный кусок соседа, у которого совпали ДВЕ такие точки и больше: у дома, лишь касающегося
+ * нашего углом, общая точка одна. Обход идёт дальше от найденных кусков — дом бывает и на три тайла.
+ */
+declare function anonymousParts(source: TileSource, layerId: string, tile: TileID, featureId: number): Map<string, number>;
 /**
  * Треугольники одной фичи — из них строится подсветка.
  *
@@ -6869,6 +8128,8 @@ interface LinePlacement {
     path: ScreenPoint[];
     /** Где строка начинается — расстояние от начала куска линии, пиксели. */
     at: number;
+    /** Множитель кегля этого экземпляра (стиль MapLibre на наклоне, см. `scalesAt`); нет — 1. */
+    scale?: number;
 }
 /** Настройки раскладки; всё необязательное — по умолчанию как у Mapbox. */
 interface LinePlacementOptions {
@@ -6882,6 +8143,8 @@ interface LinePlacementOptions {
     fontSize?: number;
     /** Предельная сумма изломов в окне, градусы. */
     maxAngle?: number;
+    /** Не раздвигать буквы на поворотах (MapLibre этого не делает: буквы стоят ровно по смещениям). */
+    noCurveGap?: boolean;
     /**
      * Годится ли конкретная раскладка — коллизии, поля экрана, что угодно вызывающего.
      *
@@ -7148,6 +8411,11 @@ declare function sdfFromAlpha(alpha: Uint8Array | Uint8ClampedArray, width: numb
  */
 interface GlyphLookup {
     get(code: number): Glyph | undefined;
+    /**
+     * Меняется, когда меняется набор глифов (догрузился диапазон, сменился адрес). По нему
+     * `shapeTextCached` понимает, что прежняя раскладка устарела. Нет поля — кеша нет.
+     */
+    readonly version?: number;
 }
 /** Один разложенный символ: где стоит и какой глиф рисовать. */
 interface ShapedGlyph {
@@ -7162,6 +8430,7 @@ interface Shaped {
     width: number;
     height: number;
 }
+declare function shapeTextCached(text: string, source: GlyphLookup, maxLineChars?: number, letterSpacing?: number, wrapWidth?: number): Shaped | null;
 /**
  * Раскладка строки в позиции глифов.
  *
@@ -7173,7 +8442,12 @@ interface Shaped {
 /**
  * @param letterSpacing разрядка между буквами в единицах кегля 24 — см. `letterSpacingFor`
  */
-declare function shapeText(text: string, source: GlyphLookup, maxLineChars?: number, letterSpacing?: number): Shaped | null;
+declare function shapeText(text: string, source: GlyphLookup, maxLineChars?: number, letterSpacing?: number, 
+/**
+ * Перенос ПО ШИРИНЕ вместо числа знаков — `text-max-width` у MapLibre, в единицах кегля 24
+ * (em × 24). Ноль/не задано — прежний перенос по знакам.
+ */
+wrapWidth?: number): Shaped | null;
 
 /**
  * Сокращение родового слова в названии улицы: «улица Истаравшан» → «ул. Истаравшан».
@@ -7340,6 +8614,35 @@ declare function footprintOf(picked: {
     indices: Uint32Array;
 }, extent: number, id: TileID): Float64Array;
 
+/**
+ * ИНДЕКСЫ МЕША БЕЗ ЧАСТИ ФИЧ — копированием ОТРЕЗКОВ, а не по треугольнику.
+ *
+ * Резка скрытых домов (замена 3D-моделью, сшитые по границе тайла, план этажа) шла по каждому
+ * треугольнику: проверка по множеству и `push` в массив чисел. В тайле плотного центра у слоя домов
+ * около 400 тысяч треугольников, и сборка швов при панораме пересобирает такой тайл на каждый новый
+ * сшитый дом, причём для каждого объёмного слоя отдельно: 3–12 мс на резку при CPU ×1, треть работы
+ * кадра при ×4 (замер: стиль osmgl в 304 слоя, `cutHidden`).
+ *
+ * Треугольники фичи в буфере лежат подряд (генератор пишет фичу целиком), поэтому меш один раз
+ * раскладывается на отрезки «фича → треугольники [от, до)», и резка проверяет по множеству фичу, а не
+ * треугольник, а копирует индексы целыми отрезками. Порядок треугольников прежний — ответ совпадает с
+ * перебором один в один, и если фича почему-то лежит в нескольких местах, это просто несколько отрезков.
+ */
+interface FeatureRuns {
+    /** Фича отрезка. */
+    fids: Float64Array;
+    /** Первый треугольник отрезка; конец — начало следующего (у последнего — `triangles`). */
+    starts: Uint32Array;
+    triangles: number;
+}
+/** Отрезки фич меша; считаются один раз на буфер номеров фич (он живёт, пока жив меш). */
+declare function featureRuns(featureIds: ArrayBuffer, indexCount: number): FeatureRuns;
+/**
+ * Индексы без треугольников фич из `hidden`. `null` — выбрасывать нечего (все фичи остаются).
+ * Совпадает с перебором `for t: if (!hidden.has(ids[t])) kept.push(...)`.
+ */
+declare function keptIndices(indices: Uint32Array, featureIds: ArrayBuffer, hidden: ReadonlySet<number>): Uint32Array | null;
+
 declare class GroundArrows {
     private vbo;
     private ibo;
@@ -7561,6 +8864,12 @@ interface LineOptions {
      * целый и один на бакет, а подход к эстакаде набирает высоту непрерывно.
      */
     liftAt?: (properties: Record<string, unknown>) => LiftField | null;
+    /**
+     * ФОРМА КОНЦОВ И СТЫКОВ (line-cap / line-join MapLibre): в вершину вместо ширины из данных и
+     * подъёма идут направление предыдущего звена и признаки «начало/конец линии» — по ним шейдер
+     * (`LINE_SHAPE`) режет торцы и строит острые стыки. Ширины из данных и подъёма у таких слоёв нет.
+     */
+    joinData?: boolean;
 }
 declare function generateLine(layer: VectorTileLayer, filter: Filter | undefined, maxSegment?: number, 
 /** Уровни поверхностей тайла: по ним дорога ложится на то, по чему идёт. Нет — лежит на нуле. */
@@ -8738,6 +10047,35 @@ interface PierOptions {
  */
 declare function bridgePiers(axis: Ring | number[], profile: BridgeProfile, opts: PierOptions): Pier[];
 
+/**
+ * СТИЛЬ ПО ССЫЛКЕ — ЛЮБОГО ИЗ ДВУХ ФОРМАТОВ.
+ *
+ * Редактор стилей публикует по адресу `/styles/{slug}.json` и стили MapLibre (v8), и наши (v1), и
+ * обёртки вокруг JSON нет намеренно: файл годится для прямой передачи в `map.setStyle(url)`.
+ * Формат определяется по полю `version` самого JSON — ровно так же его определяет сервер
+ * (`docs/map-v2/STYLE-EDITOR.md`, §2), поэтому разногласия «сервер принял, карта не поняла» нет.
+ *
+ * Строка — это ссылка ЛИБО имя встроенного стиля: `mlight-city`/`mnight-city` (MapLibre) или
+ * `osm-3d`/`osm-city`/… (наши, `OSMGL_STYLES`). Встроенный за JSON в сеть не ходит.
+ */
+type LoadedStyle = {
+    format: 'maplibre';
+    imported: MapLibreImport;
+} | {
+    format: 'osmgl';
+    style: StyleSpec;
+    url: string | null;
+    /** Перевод стиля v2: его проекция, состояние и камера (у стиля v1 их нет). */
+    imported?: MapLibreImport;
+};
+declare function loadStyle(input: string | StyleSpec | MapLibreStyle, fetcher?: (url: string) => Promise<unknown>): Promise<LoadedStyle>;
+/**
+ * Относительные адреса источников — по адресу стиля, как у MapLibre: стиль, лежащий рядом со
+ * своими тайлами, пишет `/tiles/{z}/{x}/{y}.pbf`, и подключённый с чужой страницы обязан ходить
+ * туда же, а не на сервер этой страницы. Адрес данных `geojson` строкой — туда же.
+ */
+declare function resolveStyleUrls(style: StyleSpec, styleUrl: string): StyleSpec;
+
 /**
  * Положение камеры в адресе страницы.
  *
@@ -8995,69 +10333,51 @@ declare class LogoControl implements IControl {
 }
 
 /**
- * ВЫРАЖЕНИЯ СТИЛЯ MapLibre.
- *
- * Стиль, написанный под MapLibre, почти целиком состоит из них: ширина дороги — `interpolate` по
- * зуму, цвет — `match` по классу, видимость — `case`. Без интерпретатора такой стиль у нас не
- * работает вовсе, а переписывать его на наши упрощённые формы (`stops`) для каждого приложения —
- * это ровно та работа, которой перенос и должен избавить.
- *
- * ★ ИНТЕРПРЕТАТОР, А НЕ КОМПИЛЯТОР.
- *
- * MapLibre компилирует выражение в замыкания один раз и потом зовёт их. Мы считаем прямо по
- * массиву, но КЕШИРУЕМ разбор (`compile`) — на зумовых свойствах это вызов на слой за кадр, и
- * разница между подходами там неизмерима. На фильтрах, где вызовов десятки тысяч на тайл, кеш
- * решает: разобранное выражение переиспользуется для каждой фичи.
+ * ПРОВЕРКА СТИЛЯ osmgl — по справочнику (`reference.ts`), без карты и без сети.
  *
- * ★ ЧТО УМЕЕТ, А ЧТО НЕТ.
- *
- * Умеет всё, что встречается в стилях: данные (`get`, `has`, `id`, `geometry-type`,
- * `feature-state`, `global-state`), решения (`case`, `match`, `coalesce`, логика, сравнения),
- * шкалы (`interpolate` линейный, экспоненциальный и по кривой Безье, `step`), арифметику,
- * строки, цвета, переменные (`let`/`var`), массивы (`at`, `length`, `slice`, `in`).
+ * Делит находки на две кучи, и граница между ними — «что увидит человек»:
+ *   ОШИБКА — движок нарисует не то или не нарисует вовсе: незнакомый тип слоя, цвет, который не
+ *            разобрался (это фуксин на карте), выражение с незнакомой операцией (пустое значение),
+ *            ссылка на несуществующий слой или источник, число вне допустимого;
+ *   ПРЕДУПРЕЖДЕНИЕ — движок тихо обойдётся: незнакомое поле (опечатка или поле MapLibre, которого у
+ *            нас нет — оно просто не читается), значение по фиче там, где движок считает раз на
+ *            слой (возьмётся запасное), поле общего вида у слоя, которому оно ни к чему.
  *
- * Не умеет: `format` (богатый текст с разными шрифтами в одной подписи — у нас подпись
- * однородная), `image` в значении «встроить картинку в текст», `distance`, `within` для линий и
- * полигонов (точка проверяется, остальное — нет), `resolved-locale`. Всё перечисленное отмечено и
- * в `porting/maplibre-api.md`.
+ * Работает на каждом нажатии клавиши в редакторе, поэтому без вычисления выражений и без копий:
+ * один проход по дереву стиля. Замер — в `tests/style-validate.test.mjs` (300 слоёв).
  */
-/** Значение выражения: то, чем оперирует язык. */
-type ExprValue = number | string | boolean | null | ExprValue[] | RGBAColor;
-/** Цвет как значение языка: четыре канала 0..1, как их отдаёт `parseColor`. */
-interface RGBAColor {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
+interface StyleIssue {
+    /** Путь к значению: `layers[3].paint.color`, `sources.indoor.type`, `sky.fogRange[1]`. */
+    path: string;
+    /** Идентификатор слоя, если находка внутри слоя. */
+    layer?: string;
+    message: string;
 }
-/** Всё, что выражение может спросить об окружении. */
-interface ExprContext {
-    zoom?: number;
-    /** Свойства фичи (для фильтров и data-driven значений). */
-    properties?: Record<string, unknown>;
-    /** Номер фичи: `['id']`. */
-    id?: number | string | null;
-    /** Тип геометрии: `Point`, `LineString`, `Polygon`. */
-    geometryType?: string;
-    /** Состояние фичи (`map.setFeatureState`). */
-    featureState?: Record<string, unknown>;
-    /** Общее состояние стиля (`map.setGlobalStateProperty`). */
-    globalState?: Record<string, unknown>;
-    /** Точка фичи в координатах карты — нужна `within` для точечных фич. */
-    point?: [number, number];
+interface StyleValidation {
+    errors: StyleIssue[];
+    warnings: StyleIssue[];
 }
-/** Похоже ли значение на выражение: массив, первый элемент которого — имя операции. */
-declare function isExpression(value: unknown): value is ExprValue[];
 /**
- * Посчитать выражение.
+ * Проверить стиль osmgl.
  *
- * Разбор кешируется на самом массиве: стиль живёт долго, а значения из него берут каждый кадр.
+ * Принимает что угодно — то, что пришло из редактора, бывает не стилем вовсе. Стиль MapLibre (v8)
+ * не проверяет: для него есть официальный валидатор, а здесь сказано об этом одной ошибкой.
  */
-declare function evaluateExpression(expr: unknown, ctx: ExprContext): ExprValue;
-/** Число из выражения; `fallback`, если получилось не число. */
-declare function expressionNumber(expr: unknown, ctx: ExprContext, fallback: number): number;
-/** Цвет из выражения в наш формат `[r, g, b, a]`. */
-declare function expressionColor(expr: unknown, ctx: ExprContext): [number, number, number, number] | null;
+declare function validateStyle(spec: unknown, ref?: StyleReference): StyleValidation;
+/**
+ * Проверить ТЕМУ относительно стиля: что её правки попадают в существующие слои и в поля, которые у
+ * этих слоёв есть. Тема о незнакомом id молчит (`applyTheme` пишет в консоль и пропускает), и
+ * перекрашенный «в никуда» слой иначе не найти.
+ */
+declare function validateTheme(theme: unknown, style: unknown, ref?: StyleReference): StyleValidation;
+
+/**
+ * То же, что `parseColor`, но неразобранное — `null`, а не фуксин.
+ *
+ * Нужно проверке стиля (`style/validate.ts`): по фуксину не отличить опечатку от честного
+ * `magenta`, а редактор обязан сказать про опечатку сразу, а не после того, как дорога порозовеет.
+ */
+declare function tryParseColor(input: string): [number, number, number, number] | null;
 
 interface RibbonOptions {
     /** Полуширина полотна в единицах тайла. */
@@ -9305,6 +10625,50 @@ declare function generateSurface(layer: VectorTileLayer, extent: number, filter:
  * векторных тайлах нет — так записано и в их спецификации.
  */
 declare const cutMargin: (extent: number) => number;
+/**
+ * ОБРЕЗКА ЗДАНИЯ ПО ТАЙЛУ — на выходе НАСТОЯЩИЕ многоугольники, сколько бы их ни вышло (02.10.2026).
+ *
+ * Покольцевая обрезка (`clipPolygonToTile`) режет внешний контур и дыры порознь, и в двух случаях
+ * выдаёт не многоугольник, а вырожденную фигуру:
+ *   • ДЫРА, ЗАДЕТАЯ РАЗРЕЗОМ (двор, открытый к границе тайла), остаётся дырой, чья сторона лежит на
+ *     том же разрезе, что и сторона внешнего контура. Дальше `bleedRing` отодвигает разрез наружу у
+ *     обоих колец по их собственным рёбрам, и дыра вылезает за внешний контур. earcut на таком входе
+ *     строит мусор: на карте двор накрыт огромным косым треугольником, вокруг — щепки. Замер на доме
+ *     во дворе Худжанда (14/11360/6185): площадь крыши 869 единиц против 714 настоящих;
+ *   • ВОГНУТЫЙ КОНТУР, ДВАЖДЫ ПЕРЕСЁКШИЙ ГРАНИЦУ (П-образный корпус, ушедший перемычкой в соседний
+ *     тайл), склеивается перемычкой нулевой ширины вдоль разреза. После того же сдвига перемычка
+ *     получает площадь и ложится крышей поперёк двора.
+ *
+ * Такие случаи режутся булевым пересечением с квадратом (`clipShapeToSquare`): двор, вскрытый
+ * разрезом, становится вырезом в контуре, разделённые части — отдельными фигурами. Это та же
+ * геометрия, что у MapLibre: его тайл приходит обрезанным тайлсервером — тоже честной операцией над
+ * многоугольником, а не покольцево.
+ *
+ * Остальным (подавляющему большинству) хватает покольцевой обрезки, и они идут прежним путём —
+ * без булевой операции и с тем же результатом, что и раньше.
+ */
+declare function clipPolygonParts(poly: {
+    outer: Ring;
+    holes: Ring[];
+}, extent: number, margin?: number): {
+    outer: Ring;
+    holes: Ring[];
+}[];
+/**
+ * ВЕРШИНЫ РАЗРЕЗА — НА СЕТКУ УПАКОВКИ, И ТОЛЬКО ВНУТРЬ ДОМА (02.10.2026).
+ *
+ * Точка, где разрез пересёк стену, по второй координате лежит где придётся (1200.9412), а вершина
+ * пишется на сетку `1 / scale` единицы. Округление «к ближайшему» сдвигает её с линии стены в
+ * любую сторону — и у соседнего тайла в другую: половинки одной прямой стены на стыке расходятся
+ * ступенькой (на z22 одна восьмая единицы — это два пикселя).
+ *
+ * Здесь вершина сдвигается ВДОЛЬ РАЗРЕЗА к соседней вершине того же разреза — и только до ближайшего
+ * узла сетки. Угол многоугольника при вершине на разрезе не больше развёрнутого (весь кусок лежит по
+ * одну сторону прямой разреза), поэтому такой сдвиг уводит ребро стены внутрь дома, а не наружу:
+ * кусок остаётся ВНУТРИ настоящего контура. Наружу его линию тогда задаёт сосед, у которого эта часть
+ * дома лежит в буфере целиком, из исходных вершин (см. `generateBuildings`, `tileClip: 'buffer'`).
+ */
+declare function snapCutsInward(ring: Ring, lo: number, hi: number, scale: number): Ring;
 
 /**
  * Объединение полигонов слоя в один контур — до построения меша.
@@ -9390,6 +10754,8 @@ interface PolygonPiece {
      * Длина — на одну меньше числа точек замкнутого кольца, то есть по числу рёбер.
      */
     cut: boolean[];
+    /** Ложные рёбра дыр, по дыре на массив. Не заданы — концы стен у дыр не выправляются. */
+    holeCuts?: boolean[][];
 }
 /**
  * Собрать полигон из кусков.
@@ -9401,6 +10767,107 @@ interface PolygonPiece {
  */
 declare function stitchPieces(pieces: PolygonPiece[], minWidth?: number): Shape[] | null;
 
+/**
+ * МЕСТА СИМВОЛОВ ВДОЛЬ ЛИНИИ — КАК У MapLibre, один в один.
+ *
+ * Перенос `symbol/get_anchors.ts`, `clip_line.ts` и `check_max_angle.ts` из maplibre-gl-js (BSD-3).
+ * Нужен стилям MapLibre: стрелки направления и щиты трасс у них стоят там, где их ставит ЭТОТ
+ * алгоритм, и любая своя сетка мест (наша `groundGrid`) даёт другую картину — стрелок вдвое меньше,
+ * щиты не на тех перекрёстках.
+ *
+ * Чем он отличается от нашей сетки:
+ * - места считаются в координатах ТАЙЛА, с переувеличением (`overscaling` — во сколько раз зум
+ *   кадра больше зума данных тайла, по целому зуму), а не по экрану;
+ * - линия режется по квадрату тайла, место за ним отдаётся соседнему тайлу;
+ * - первое место — на смещении `(половина подписи + 2 em) · масштаб · переувеличение % шаг`, у линии,
+ *   пришедшей из соседнего тайла, — `шаг/2 · переувеличение % шаг`; не нашлось ни одного — одно
+ *   посередине линии;
+ * - подпись (не значок) не ставится на изломе круче `text-max-angle` в окне 3/5 кегля.
+ *
+ * Координаты тайла — в единицах MapLibre (`EXTENT` = 8192): от них зависят округления и смещения.
+ */
+/** Размер тайла в единицах MapLibre. */
+declare const ML_EXTENT = 8192;
+interface Pt {
+    x: number;
+    y: number;
+}
+interface LineAnchor {
+    x: number;
+    y: number;
+    /** Номер звена линии, на котором стоит место. */
+    segment: number;
+    /** Угол звена, радианы (как `b.angleTo(a)` у MapLibre). */
+    angle: number;
+}
+/** Разрезать линию по прямоугольнику — `clipLine` MapLibre (с округлением точек среза). */
+declare function clipLine(line: Pt[], x1: number, y1: number, x2: number, y2: number): Pt[][];
+/**
+ * Одно место в середине линии — `getCenterAnchor` MapLibre (`symbol-placement: line-center`).
+ * Линия берётся ЦЕЛИКОМ, без среза по тайлу; излом под подписью проверяется так же.
+ */
+declare function centerAnchor(line: Pt[], maxAngle: number, hasText: boolean, shapedLabelLength: number, boxScale: number): LineAnchor | null;
+/**
+ * Места вдоль одной линии тайла — `getAnchors` MapLibre.
+ *
+ * @param line точки в единицах `ML_EXTENT`, уже разрезанные по тайлу (`clipLine`)
+ * @param spacing шаг в единицах тайла (`symbol-spacing · tilePixelRatio`)
+ * @param shapedLabelLength длина подписи: max(ширина текста в единицах кегля 24, ширина значка в px)
+ * @param boxScale `tilePixelRatio · textMaxSize / 24`
+ * @param hasText есть ли текст — у значка без текста угол излома не проверяется
+ * @param maxAngle `text-max-angle`, радианы
+ */
+declare function lineAnchors(line: Pt[], spacing: number, maxAngle: number, hasText: boolean, shapedLabelLength: number, boxScale: number, overscaling: number, extent?: number): LineAnchor[];
+
+/**
+ * Адрес, с которого снят снимок. Относительные ссылки внутри встроенного стиля разрешаются по нему
+ * — так же, как если бы стиль скачали по ссылке `MAPLIBRE_STYLE_BASE + имя + '.json'`. В нынешних
+ * снимках все адреса абсолютные, но правка стиля на сервере вправе это изменить.
+ */
+declare const MAPLIBRE_STYLE_BASE = "https://navi.gram.tj/styles/";
+/** Светлый «город» — снимок `https://navi.gram.tj/styles/mlight-city.json`. */
+declare const MLIGHT_CITY_STYLE: MapLibreStyle;
+/** Ночной «город» — снимок `https://navi.gram.tj/styles/mnight-city.json`. */
+declare const MNIGHT_CITY_STYLE: MapLibreStyle;
+/**
+ * Имя → встроенный стиль MapLibre и показываемое название.
+ *
+ * Название своё, а не поле `name` стиля: у обоих снимков там «MapTiler 3D» (наследство шаблона
+ * Maputnik), и в меню два одинаковых пункта ничего бы не сказали.
+ */
+declare const MAPLIBRE_STYLES: Record<string, {
+    name: string;
+    style: MapLibreStyle;
+}>;
+/**
+ * Встроенный стиль по имени — с адресом, по которому разрешаются его относительные ссылки.
+ * Не встроенное имя (в том числе любая ссылка) — `null`: такую строку грузят по сети.
+ */
+declare function builtinMapLibreStyle(name: string): {
+    style: MapLibreStyle;
+    url: string;
+} | null;
+
+/**
+ * СБОРКА ГЕОМЕТРИИ ТАЙЛА — отдельно от его загрузки.
+ *
+ * Отделено ради источника `geojson`: данные там приходят не тайлами с сервера, а целым набором от
+ * приложения, и режет их на тайлы сам движок (`source/geojson-source.ts`). Загрузка у них разная,
+ * а сборка обязана быть одна и та же — иначе слой из GeoJSON рисовался бы иначе, чем такой же слой
+ * из тайлов.
+ *
+ * `tile` — что угодно с полем `layers`: настоящий разобранный MVT или набор, собранный из GeoJSON.
+ */
+declare function buildTile(tile: {
+    layers: Record<string, VectorTileLayer>;
+}, req: Pick<LoadRequest, 'zoom' | 'metersPerTile' | 'sourceMaxZoom' | 'plan' | 'tile' | 'globalState'>): {
+    buckets: Record<string, BucketMesh>;
+    seams: BuildingSeam[];
+    splits: Record<string, (string | number)[]>;
+    levels: number[];
+    failed: string[];
+};
+
 /**
  * Цель рендера с одной только глубиной — карта теней.
  *
@@ -9599,10 +11066,19 @@ interface MapOptions {
      * они на порядки дольше.
      */
     sources?: Record<string, SourceSpec>;
-    /** Стиль: объект спецификации. По умолчанию — встроенный `styles/osm-3d.json`. */
-    style?: StyleSpec;
-    /** Тема оформления: `day` | `night` | `mono` | `pale` либо своя накладка. */
-    theme?: string | ThemeSpec;
+    /**
+     * Стиль: объект спецификации. По умолчанию — встроенный `styles/osm-3d.json`.
+     *
+     * Годится и стиль MapLibre v8 — объектом или ссылкой: он переводится импортёром
+     * (`style/maplibre-import.ts`) и подключается вместе со своими источниками, шрифтами и спрайтом.
+     * Ссылка может вести и на НАШ стиль (`"version": 1`) — формат решает поле `version` самого JSON
+     * (так публикует стили редактор: `/styles/{slug}.json`). Встроенные — по имени, без загрузки JSON:
+     * стили MapLibre `'mlight-city'`, `'mnight-city'` (`Map.mapLibreStyleList`) и наши `'osm-3d'`,
+     * `'osm-city'`, … (`Map.styleList`).
+     */
+    style?: StyleSpec | MapLibreStyle | StyleSpecV2 | string;
+    /** Тема оформления: `day` | `night` | `mono` | `pale` либо своя накладка (v2; v1 — синоним на время переезда). */
+    theme?: string | ThemeInput;
     /** Шаблон адреса SDF-глифов (формат Mapbox, его отдаёт наш tileserver-gl). */
     fonts?: string;
     /** Начертание из набора шрифтов тайлсервера. */
@@ -9673,6 +11149,16 @@ interface MapOptions {
     highlightColor?: string;
 }
 /** Подпись или значок карты под курсором. */
+/** Слой стиля под точкой экрана (`layersAt`): подпись ИЛИ фича геометрии. */
+interface StyleLayerHit {
+    /** Идентификатор слоя стиля. */
+    layer: string;
+    type: StyleLayerSpec['type'];
+    /** Фича заливки, линии, объёма или поверхности — с её свойствами из тайла. */
+    feature?: QueriedFeature;
+    /** Подпись или значок, как их разместила раскладка этого кадра. */
+    symbol?: SymbolHit;
+}
 interface SymbolHit {
     /** Слой стиля: по нему понятно, что это — POI, дом, остановка. */
     layerId: string;
@@ -9810,6 +11296,39 @@ declare class Map$1 extends Evented<MapEvents> {
     /** Стиль разобран и первый кадр показан. Имя `loaded` занято методом MapLibre. */
     private ready;
     private destroyed;
+    /** Стиль по ссылке или стиль MapLibre из опций: подключается, когда у карты уже есть источники. */
+    private pendingMapLibre;
+    /** Проекция и общее состояние своего стиля v2, переданного объектом в опциях: ставятся после разбора камеры. */
+    private pendingStyleExtras;
+    /** Камера стиля применена: у MapLibre она берётся только при первой загрузке. */
+    private styleCameraApplied;
+    /**
+     * Номер последнего запроса ВНЕШНЕГО стиля (по ссылке или MapLibre): ответ на устаревший запрос
+     * отбрасывается. Общий у обоих форматов: две быстрые смены стиля по ссылке не должны закончиться
+     * первой, какого бы формата ни был каждый.
+     */
+    private mapLibreSeq;
+    /** Источники, поставленные стилем osmgl по ссылке, — чтобы не пересоздавать неизменившиеся. */
+    private urlStyleSources;
+    /** Источники, поставленные стилем MapLibre, — чтобы не пересоздавать неизменившиеся. */
+    private mapLibreSources;
+    /** Итог последнего импорта стиля MapLibre (что не перенесено, камера стиля). */
+    private lastImport;
+    /**
+     * Основа карты ДО первого стиля MapLibre: импорт её подменяет, и возврат к своему стилю обязан
+     * вернуть и её, иначе наш стиль остался бы на чужих тайлах. Шрифты и спрайт живут отдельно — их
+     * приносит любой стиль, не только MapLibre (см. `syncStyleAssets`).
+     */
+    private beforeMapLibre;
+    /**
+     * Шрифты и спрайт КАРТЫ, отложенные на время стиля со своими (`glyphs`/`sprite` стиля); `null` —
+     * стоят собственные карты. Запоминаются при первом таком стиле и возвращаются первым стилем без них.
+     */
+    private mapAssets;
+    /** Что поставил стиль в последний раз: смена темы и правка слоя не должны перекачивать спрайт. */
+    private styleAssetsKey;
+    /** Номер последней смены спрайта стилем: догрузка дополнительных спрайтов устаревшей смены бросается. */
+    private styleAssetsSeq;
     private background;
     private maxPixelRatio;
     /** Шаг прилипания зума у кнопок (`zoomIn`/`zoomOut`). Ноль — не липнет. */
@@ -10173,8 +11692,78 @@ declare class Map$1 extends Evented<MapEvents> {
      * фильтры, источники). Смена одних цветов — а это ровно случай переключения
      * темы — обходится сменой юниформов: тайлы не перекачиваются и не
      * перемалываются заново, картинка меняется в том же кадре.
+     *
+     * Строка — ССЫЛКА на стиль любого из двух форматов (решает поле `version` JSON: 8 — MapLibre,
+     * 1 — наш) либо имя встроенного: `'mlight-city'`, `'mnight-city'` (MapLibre) или `'osm-3d'`,
+     * `'osm-city'`, … (наши). Встроенный лежит в пакете, и за его JSON карта в сеть не ходит.
+     *
+     * Стиль по ссылке (и встроенный по имени) становится ОСНОВОЙ для тем — как `setBaseStyle`, — и
+     * приносит свои источники. Объект спецификации ставится «на один раз», как и прежде.
+     *
+     * `keepEdits: false` — для редактора стилей: спецификация и есть вся правда, и правки, сделанные
+     * на лету (`setPaintProperty`, `addLayer`, `setFilter`, …), сбрасываются, а не накладываются
+     * поверх неё заново. По умолчанию они переживают смену стиля — ради тем (см. `layerOverrides`).
+     */
+    setStyle(spec: StyleSpec | MapLibreStyle | StyleSpecV2 | string, opts?: {
+        keepEdits?: boolean;
+    }): this;
+    /** Внутренняя модель (v1) — в карту: план воркера, правки на лету, шрифты, рельеф. */
+    private installSpec;
+    /**
+     * СТИЛЬ MapLibre: перевод, затем источники, шрифты и спрайт самого стиля.
+     *
+     * Порядок важен. Сначала стиль — у уже подключённых источников меняется план; потом источники —
+     * новые сразу заводятся под новый план, а неизменившиеся не трогаются (пересоздание сбросило бы
+     * загруженные тайлы). Ответ на устаревший запрос отбрасывается: две быстрые смены стиля не
+     * должны закончиться первым из них.
+     */
+    private applyExternalStyle;
+    /**
+     * ТО, ЧТО СТИЛЬ v8/v2 ГОВОРИТ О КАРТЕ, А НЕ О СЛОЯХ: проекция, умолчания общего состояния и
+     * камера. Камера — только при первой загрузке и только там, где приложение не задало своё в
+     * опциях (так у MapLibre); состояние — только ключи, которых приложение ещё не ставило.
+     */
+    private applyStyleExtras;
+    /**
+     * НАШ СТИЛЬ ПО ССЫЛКЕ (или встроенный по имени): основа для тем плюс его собственные источники.
+     *
+     * Основа — потому что ссылку ставят ВМЕСТО стиля карты, а не поверх: следующий `setTheme` должен
+     * лечь на неё, а не вернуть стиль из опций. Источники стиля по ссылке заводятся, изменившиеся —
+     * пересоздаются, неизменившиеся не трогаются (пересоздание сбросило бы загруженные тайлы).
+     * Источник, принесённый прошлым стилем по ссылке и пропавший из нового, снимается: иначе он
+     * продолжал бы качать тайлы, которые никто не рисует. Встроенный стиль заводит только недостающие
+     * источники — как `setBaseStyle`: они те же, что из опций карты.
+     */
+    private installOsmglStyle;
+    /** СТИЛЬ MapLibre, уже переведённый (см. `applyExternalStyle`): стиль (с его шрифтами и спрайтом) и источники. */
+    private installMapLibreStyle;
+    /** Итог последнего перевода стиля MapLibre: что не перенесено и камера стиля. */
+    getMapLibreImport(): MapLibreImport | null;
+    /** Идёт ли сейчас установка переведённого стиля (тогда это не возврат к своему). */
+    private applyingMapLibre;
+    /**
+     * ВОЗВРАТ СО СТИЛЯ MapLibre НА СВОЙ: источники, шрифты и спрайт — как были до импорта.
+     *
+     * Источник, который поставил импорт, заменяется тем, что объявил новый стиль; нет его там — для
+     * основы берётся адрес из опций карты, остальные снимаются. Запрос импорта, ещё летящий по сети,
+     * отменяется: иначе он пришёл бы позже и вернул чужой стиль поверх своего.
+     */
+    private leaveMapLibre;
+    /**
+     * ШРИФТЫ И СПРАЙТ СТИЛЯ: свои у стиля — ставятся, нет их — у карты собственные.
+     *
+     * Одно правило на все пути: наш стиль объектом, по ссылке, основа для тем и перевод MapLibre (он
+     * кладёт `glyphs`/`sprite` в сам стиль). Свои карты (опция `fonts`, встроенные значки, `setSprite`)
+     * запоминаются при первом стиле со своими и возвращаются первым стилем без них — так стиль,
+     * сохранённый редактором, рисуется теми значками, с которыми его делали, а переход на наш стиль не
+     * оставляет карту с чужими. Поля по отдельности: стиль только со спрайтом берёт шрифты карты.
+     *
+     * Повторная установка того же (смена темы, правка слоя — это тоже `setStyle`) ничего не делает:
+     * спрайт перекачивался бы на каждое движение ползунка в редакторе.
      */
-    setStyle(spec: StyleSpec): this;
+    private syncStyleAssets;
+    /** Поставить шрифты и набор спрайтов, не трогая то, что уже стоит как надо. */
+    private applyAssets;
     /**
      * Добавить слой. `beforeId` — перед каким слоем встать; без него слой ложится поверх всех.
      *
@@ -10201,8 +11790,17 @@ declare class Map$1 extends Evented<MapEvents> {
      * `setPaintProperty`, который меняет только юниформы.
      */
     setFilter(id: string, filter: Filter | null): this;
-    /** Спецификация стиля целиком — копией, чтобы правки снаружи не меняли живой стиль. */
-    getStyle(): StyleSpec;
+    /**
+     * Спецификация стиля целиком — В ФОРМАТЕ v2 (MapLibre v8 + `osmgl-*`) и копией, чтобы правки
+     * снаружи не меняли живой стиль. Её можно отдать обратно в `setStyle` и получить ту же карту, а
+     * срезанную `toMapLibreStyle` — открыть в MapLibre.
+     */
+    getStyle(): StyleSpecV2;
+    /**
+     * Внутренняя модель движка (формат v1) — для отладки и старого кода; формат обмена — `getStyle()`.
+     * Слои — ЖИВЫЕ, с правками на лету (`setPaintProperty`, `setLayerVisible`), как у `getStyle` MapLibre.
+     */
+    getStyleV1(): StyleSpec;
     /**
      * Стиль разобран.
      *
@@ -10242,6 +11840,22 @@ declare class Map$1 extends Evented<MapEvents> {
      * и правки надо уметь применить заново — в том же порядке, в каком их сделали.
      */
     private applyLayerEdits;
+    /**
+     * КАКИЕ СЛОИ СТИЛЯ НАРИСОВАЛИ ТО, ЧТО ПОД ТОЧКОЙ ЭКРАНА — для редактора стилей («инспектор»:
+     * щёлкнул по карте — увидел список слоёв и выбрал нужный).
+     *
+     * Сверху вниз: сначала подписи и значки (они над всем), потом геометрия в обратном порядке
+     * стиля. Подпись берётся у того, кто её разместил (`querySymbol` — экранная раскладка этого
+     * кадра), геометрия — из нарисованных мешей (`queryRenderedFeatures`). Слои, погашенные зумом или
+     * `visible: false`, в ответ не попадают: их на экране нет, хотя меш в тайле и лежит.
+     *
+     * Слой может прийти несколько раз — по разу на каждую фичу под точкой (две пересекающиеся
+     * дороги одного слоя). Подложку (`raster`) и `background` не возвращает: под любой точкой они
+     * есть всегда.
+     */
+    layersAt(point: ScreenPoint$1, opts?: {
+        tolerance?: number;
+    }): StyleLayerHit[];
     /**
      * ЧТО НАРИСОВАНО В ЭТОЙ ТОЧКЕ (или в этом прямоугольнике) ЭКРАНА.
      *
@@ -10437,12 +12051,19 @@ declare class Map$1 extends Evented<MapEvents> {
      * выбранный маршрут». Значение живёт у стиля, а не у слоя, — поэтому и имя общее.
      */
     setGlobalStateProperty(key: string, value: unknown): this;
+    /**
+     * СОСТОЯНИЕ ДОЛЖНО ДОЙТИ ДО ВОРКЕРА. Фильтры, значения по фиче и подписи считаются там, у
+     * воркера свой экземпляр модуля, и состояние уходит к нему с каждым запросом тайла
+     * (`LoadRequest.globalState`). Тайлы, уже разобранные по старому состоянию, пересобираются — но
+     * только у источников, чей план вообще смотрит на `global-state`.
+     */
+    private replanForGlobalState;
     getGlobalState(): Record<string, unknown>;
     /** Повторять ли мир по горизонтали при отъезде. */
     getRenderWorldCopies(): boolean;
     setRenderWorldCopies(render: boolean): this;
     /** Переключить тему оформления поверх текущей структуры слоёв. */
-    setTheme(theme: string | ThemeSpec): this;
+    setTheme(theme: string | ThemeInput): this;
     /**
      * СМЕНИТЬ ОСНОВУ, на которую ложатся темы.
      *
@@ -10451,7 +12072,7 @@ declare class Map$1 extends Evented<MapEvents> {
      * рельефная) нужно заменить саму основу — этим и занимается этот метод. Тема применяется сразу,
      * чтобы палитра не слетала на время переключения.
      */
-    setBaseStyle(style: StyleSpec, theme?: string | ThemeSpec): this;
+    setBaseStyle(input: StyleSpec | StyleSpecV2, theme?: string | ThemeInput): this;
     /** Имена доступных тем. */
     static get themes(): string[];
     /**
@@ -10465,16 +12086,61 @@ declare class Map$1 extends Evented<MapEvents> {
         id: string;
         name: string;
     }[];
+    /**
+     * Встроенные стили MapLibre — для того же выпадающего списка: имя для `setStyle` и название.
+     *
+     * Отдельно от тем: тема — накладка на НАШ стиль и меняет только цвета, а это другой стиль целиком
+     * (свои тайлы, шрифты и спрайт), и `setTheme` с него возвращает карту на нашу основу.
+     */
+    static get mapLibreStyleList(): {
+        id: string;
+        name: string;
+    }[];
+    /** Встроенные стили osmgl — имя для `setStyle` (`'osm-city'`) и название. */
+    static get styleList(): {
+        id: string;
+        name: string;
+    }[];
     /**
      * Правка layout-свойств слоя на лету: размер кегля, зазор до значка, шаг
      * разрежения, расположение иконки.
      *
      * Отдельно от `setPaintProperty` не для симметрии: paint — это юниформы, а
      * layout влияет на РАЗМЕЩЕНИЕ, и его правка пересобирает раскладку подписей
-     * (но не геометрию). Исключение — `textField`, `iconImage` и `splitBy`: они
-     * читаются в воркере, поэтому тянут за собой новый план и перекачку разбора.
+     * (но не геометрию). Исключение — то, что читает воркер (`textField`, `iconImage`,
+     * `iconRotate`, `textPlacement`, `abbreviate`, `textTransform`, …): такая правка тянет
+     * за собой новый план и пересборку тайлов, но только источника этого слоя.
      */
     setLayoutProperty(layerId: string, prop: string, value: unknown): this;
+    /**
+     * ПРАВКА СВОЙСТВА СЛОЯ ПО ИМЕНИ v2 — общее у `setPaintProperty` и `setLayoutProperty`.
+     *
+     * Имя v2 (`line-color`, `osmgl-corner-radius`, `visibility`) переводится по той же таблице, что и
+     * стиль целиком, — в поле внутренней модели, где бы оно ни лежало: `line-cap` у нас в `paint`,
+     * `osmgl-corner-radius` — рядом с фильтром. Имя v1 (`color`, `textSize`) принимается как синоним
+     * с одним предупреждением: два выпуска приложения переезжают на новые имена. Незнакомое имя
+     * кладётся как есть, тоже с предупреждением, — так было и раньше.
+     */
+    private setLayerProperty;
+    /** Имя свойства (v2 или v1) → правки полей внутренней модели. */
+    private v1Ops;
+    /**
+     * Значение свойства слоя по имени v2 (`line-color`, `osmgl-corner-radius`) — как его отдал бы
+     * `getStyle()`. `undefined` — не задано (у MapLibre — умолчание спецификации).
+     */
+    getPaintProperty(layerId: string, prop: string): unknown;
+    getLayoutProperty(layerId: string, prop: string): unknown;
+    private layerV2;
+    /** Слепок плана воркера для слоя: по нему видно, задела ли правка геометрию. */
+    private planKeyOf;
+    /**
+     * ПЕРЕСОБРАТЬ ТАЙЛЫ, ТОЛЬКО ЕСЛИ ПРАВКА ДОШЛА ДО ВОРКЕРА — и только у источника этого слоя.
+     *
+     * Раньше решение принималось по имени свойства (три имени у раскладки, «значение по фиче» у
+     * покраски), и правка, о которой список не знал, — `lineCap`, `textPlacement`, `height` дома —
+     * молча не доезжала до геометрии. Сравнение планов знает всё, что знает воркер.
+     */
+    private replanIfChanged;
     /**
      * Правка paint-свойств слоя на лету. Геометрия НЕ пересобирается — меняются
      * только юниформы, поэтому цвет и ширину можно крутить хоть каждый кадр.
@@ -10772,7 +12438,15 @@ declare class Map$1 extends Evented<MapEvents> {
         data: Float32Array;
         format: string;
     } | null;
+    /** Кадр упал вне слоёв (тени, отражение, небо): сказать один раз на причину, цикл не рвать. */
+    private frameFailures;
+    private reportFrameFailure;
     private renderFrame;
+    /** Будильник следующего кадра ряби (см. конец `renderFrame`). */
+    private materialTimer;
+    /** Следующий кадр заказан паузой ряби, а не потоком кадров (см. `renderFrame`). */
+    private pacedWake;
+    private scheduleMaterialFrame;
     /** Поставить будильник на ближайший повтор; уже стоящий на более ранний срок не трогается. */
     private scheduleRetryWake;
     private stopFrameLoop;
@@ -10780,4 +12454,4 @@ declare class Map$1 extends Evented<MapEvents> {
     destroy(): void;
 }
 
-export { type AnimationOptions, type ArrowSize, AssetLoader, type AssetLoaderOptions, AttributionControl, type AxisChain, BASE_SOURCE, BUILDING_HEIGHT_SCALE, BUILDING_POS_SCALE, BUILDING_VERTEX_STRIDE, BoxZoomHandler, type BridgeProfile, type BuildingHit, type BuildingsMesh, CITY_STYLE, type CameraOptions, type CameraUpdate, Circle, type CircleOptions, type ControlPosition, CooperativeGesturesHandler, type CoverOptions, type CustomLayer, DATA_PAINT_STRIDE, DEFAULT_ICONS, DEFAULT_LIGHT, DEFAULT_SHADOWS, DEFAULT_SKY, DEFAULT_STYLE, type DataPaintSpec, type DemEncoding, DemSource, type DemSourceOptions, DemTile, DemTileEntry, DepthTarget, type DeviceHints, EARTH_CIRCUMFERENCE, type ExprContext, type ExprValue, FILL_VERTEX_STRIDE, FeaturePaint, type Filter, type FitBoundsOptions, type FitViewport, type FogPlanes, FullscreenControl, GLOBE_MAX_PITCH, GLOBE_ZOOM_MAX, GLOBE_ZOOM_MIN, GLYPH_BORDER, GLYPH_SIZE, GROUND_SCALE, type GeoJSONData, type GeoJSONFeature, type GeoJSONFeatureCollection, type GeoJSONGeometry, GeoJSONSource, GeolocateControl, GeomType, GestureHandler, type GestureOptions, GlobeControl, type Glyph, type GlyphMetric, GlyphSource, type GpuClass, GroundArrows, type IControl, IconSource, ImageManager, IndoorMask, type Interpolated, type Junctions, LEVEL_LIMIT, LINE_VERTEX_STRIDE, type LaneArrow, type LaneGuide, type LaneGuideOptions, type LayerPlan, LayerRenderer, type LiftField, type LightSpec, type LinePlacement, type LngLat, LngLatBounds, type LngLatLike, LogoControl, MAX_GRADE, MAX_LATITUDE, MESH_BOTTOM, MESH_ISLAND, MESH_KERB_SIDE, MESH_KERB_TOP, MESH_SIDE, MESH_TOP, MIN_PIER_HEIGHT_METERS, MODEL_VERTEX_STRIDE, Map$1 as Map, type MapEvents, MapObject, type MapObjectOptions, type MapOptions, Marker, type MarkerOptions, type Marking, type MarkingKind, type MarkingOptions, type MarkingRing, type MediaCoordinates, type MediaKind, MediaSource, Model, ModelLayer, type ModelMesh, type ModelOptions, type ModelPrimitive, NavigationControl, ObjectManager, type ObjectPaint, type ObjectPart, PIER_SPACING_METERS, type Padding, type Pier, type PierOptions, type PlacedGlyph, type PlacedSymbol, Polygon, type PolygonOptions, type PolygonPiece, Polyline, type PolylineOptions, type PolylineSegment, Popup, type PopupOptions, type Projection, type ProtocolHandler, type QualityChange, QualityGovernor, type QualityName, type QualityProfile, type QueriedFeature, type QueryGeometry, RELIEF_STYLE, ROAD_SIGNS, RUNTIME_FILL_STRIDE, RUNTIME_LINE_STRIDE, type RampOptions, RasterSource, type RasterSourceOptions, RasterTile, type RenderedQueryOptions, type RoadAxis, type RoadChain, type RoadEdges, type RoadGraph, type RoadGraphOptions, type RoadHeightOptions, type RoadHeights, type RoadMesh, type RoadMeshOptions, type RoadNode, type RoadRay, type RoadSourceEdges, type RoadSurface, type RoadSurfaceOptions, type RoundOptions, type RuntimeMesh, SDF_EDGE, SDF_PX, SIGN_SIZE, SOFT_STYLE, SPLIT_SEP, SURFACE_CUT_BLEED, SURFACE_LEVEL_SCALE, SURFACE_VERTEX_STRIDE, ScaleControl, type ScreenPoint$1 as ScreenPoint, SdfAtlas, type ShadowSettings, type SkySpec, Style, type StyleImage, type StyleImageData, type StyleImageOptions, type StyleLayerSpec, type StyleSpec, type SymbolHit, SymbolRenderer, TAPER_METERS, TERRAIN_STYLE, THEMES, TILE_SIZE, type TaperedWidth, TerrainControl, type ThemeSpec, type TileAddress, TileID, Transform, type TransformConstrain, type TransformRequest, VectorTile, VectorTileFeature, VectorTileLayer, abbreviateStreet, addGround, altitudeFromMercatorZ, applyTheme, arrowLabelOffset, arrowVertices, bridgePiers, bridgeProfile, buildRoadGraph, buildRuntimeFill, buildRuntimeLine, cameraForBounds, chainAxes, circumferenceAtLatitude, clampLat, clampPixelRatio, classifyRenderer, clipLineToRect, coordinateDigits, coveringTiles, createGround, cutMargin, Map$1 as default, densifyLine, deviceHints, distToSegment, evaluateColor, evaluateExpression, evaluateNumber, expressionColor, expressionNumber, extractFeature, featureDrivenPaint, featureLevel, fillFootprint, fogPlanes, footprintOf, formatHash, generateBuildings, generateFill, generateLine, generateSurface, generateSymbols, globeBasis, globeFlatMix, globeRadius, globeToLocal, groundAt, iconRotation, insideFootprint, isExpression, junctionIndex, laneArrow, laneGuides, latFromMercatorY, liftFields, lngFromMercatorX, lngLatToUnit, makeFeaturePaint, matchesFilter, mercatorMetersPerTile, mercatorX, mercatorY, mercatorZFromAltitude, metersPerPixel, metersPerTile, needsDataPaint, nextQualityDown, parseGlb, parseGlbAsync, parseGlyphs, parseHash, parseLift, patchUV, pickBuilding, pickFill, pitchIntent, pixelsPerMeter, placeAlongLine, placeMarking, pointInRing, qualityFor, qualityProfile, queryRendered, querySource, raySphere, refineLine, relaxAngle, relaxCurvature, resolveTemplate, ribbonFromEdges, ribbonRing, ribbonShape, ringEdges, roadEdges, roadHeights, roadMarkings, roadMesh, roadSurfaces, roundLine, roundRing, roundRings, sdfFromAlpha, shapeText, snapRoadEnds, speedSign, splitBucketKey, splitByGround, splitPolygons, squareClosed, stitchPieces, stopLine, styleWithTheme, taperedWidth, tileOriginMeters, tileUrl, toLngLat, unitToLngLat, unpackVector, waffle, worldSize, yieldTargetsOf, zebra };
+export { type AnimationOptions, type ArrowSize, AssetLoader, type AssetLoaderOptions, AttributionControl, type AxisChain, BASE_SOURCE, BUILDING_HEIGHT_SCALE, BUILDING_POS_SCALE, BUILDING_VERTEX_STRIDE, BoxZoomHandler, type BridgeProfile, type BuildingHit, type BuildingsMesh, CITY_STYLE, type CameraOptions, type CameraUpdate, Circle, type CircleOptions, type ControlPosition, CooperativeGesturesHandler, type CoverOptions, type CustomLayer, DATA_PAINT_STRIDE, DEFAULT_ICONS, DEFAULT_LIGHT, DEFAULT_MAPLIBRE_LIGHT, DEFAULT_SHADOWS, DEFAULT_SKY, DEFAULT_STYLE, type DataPaintSpec, type DemEncoding, DemSource, type DemSourceOptions, DemTile, DemTileEntry, DepthTarget, type DeviceHints, EARTH_CIRCUMFERENCE, EXPRESSION_OPERATORS, type ExprContext, type ExprValue, type ExpressionIssue, type ExpressionOperatorRef, FILL_VERTEX_STRIDE, FeaturePaint, type Filter, type FitBoundsOptions, type FitViewport, type FogPlanes, FullscreenControl, GLOBAL_STATE, GLOBE_MAX_PITCH, GLOBE_ZOOM_MAX, GLOBE_ZOOM_MIN, GLYPH_BORDER, GLYPH_SIZE, GROUND_SCALE, type GeoJSONData, type GeoJSONFeature, type GeoJSONFeatureCollection, type GeoJSONGeometry, GeoJSONSource, GeolocateControl, GeomType, GestureHandler, type GestureOptions, GlobeControl, type Glyph, type GlyphMetric, GlyphSource, type GpuClass, GroundArrows, type IControl, IconSource, ImageManager, IndoorMask, type Interpolated, type Junctions, LEVEL_LIMIT, LINE_VERTEX_STRIDE, type LaneArrow, type LaneGuide, type LaneGuideOptions, type LayerPlan, LayerRenderer, type LayerSpecV2, type LayerTypeName, type LayerTypeRef, type LiftField, type LightSpec, type LinePlacement, type LngLat, LngLatBounds, type LngLatLike, type LoadedStyle, LogoControl, MAPLIBRE_STYLES, MAPLIBRE_STYLE_BASE, MAPLIBRE_SUPPORT, MAX_GRADE, MAX_LATITUDE, MESH_BOTTOM, MESH_ISLAND, MESH_KERB_SIDE, MESH_KERB_TOP, MESH_SIDE, MESH_TOP, MIN_PIER_HEIGHT_METERS, MLIGHT_CITY_STYLE, ML_EXTENT, MNIGHT_CITY_STYLE, MODEL_VERTEX_STRIDE, Map$1 as Map, type MapEvents, type MapLibreImport, type MapLibreLayer, type MapLibreLightSpec, type MapLibreSource, type MapLibreStyle, type MapLibreSupport, type MapLibreSupportStatus, MapObject, type MapObjectOptions, type MapOptions, Marker, type MarkerOptions, type Marking, type MarkingKind, type MarkingOptions, type MarkingRing, type MediaCoordinates, type MediaKind, MediaSource, Model, ModelLayer, type ModelMesh, type ModelOptions, type ModelPrimitive, NavigationControl, OSMGL_FORMAT_VERSION, OSMGL_STYLES, OSMGL_VERSION_KEY, ObjectManager, type ObjectPaint, type ObjectPart, PIER_SPACING_METERS, type Padding, type Pier, type PierOptions, type PlacedGlyph, type PlacedSymbol, Polygon, type PolygonOptions, type PolygonPiece, Polyline, type PolylineOptions, type PolylineSegment, Popup, type PopupOptions, type Projection, type PropRef, type PropType, type ProtocolHandler, type QualityChange, QualityGovernor, type QualityName, type QualityProfile, type QueriedFeature, type QueryGeometry, RELIEF_STYLE, ROAD_SIGNS, RUNTIME_FILL_STRIDE, RUNTIME_LINE_STRIDE, type RampOptions, RasterSource, type RasterSourceOptions, RasterTile, type RenderedQueryOptions, type RoadAxis, type RoadChain, type RoadEdges, type RoadGraph, type RoadGraphOptions, type RoadHeightOptions, type RoadHeights, type RoadMesh, type RoadMeshOptions, type RoadNode, type RoadRay, type RoadSourceEdges, type RoadSurface, type RoadSurfaceOptions, type RoundOptions, 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, ScaleControl, type ScreenPoint$1 as ScreenPoint, SdfAtlas, type ShadowSettings, type SkySpec, Style, type StyleImage, type StyleImageData, type StyleImageOptions, type StyleIssue, type StyleLayerHit, type StyleLayerSpec, type StyleReference, type StyleSpec, type StyleSpecV2, type StyleValidation, type SymbolHit, SymbolRenderer, TAPER_METERS, TERRAIN_STYLE, THEMES, TILE_SIZE, type TaperedWidth, TerrainControl, type ThemeInput, type ThemeSpec, type ThemeSpecV2, type TileAddress, TileID, Transform, type TransformConstrain, type TransformRequest, VectorTile, VectorTileFeature, VectorTileLayer, abbreviateStreet, addGround, altitudeFromMercatorZ, anonymousParts, applyTheme, arrowLabelOffset, arrowVertices, bridgePiers, bridgeProfile, buildRoadGraph, buildRuntimeFill, buildRuntimeLine, buildTile, builtinMapLibreStyle, builtinOsmglStyle, cameraForBounds, chainAxes, circumferenceAtLatitude, clampLat, clampPixelRatio, classifyRenderer, clipLineToRect, clipPolygonParts, convertFilter as convertMapLibreFilter, convertValue as convertMapLibreValue, coordinateDigits, coveringTiles, createGround, cutMargin, Map$1 as default, densifyLine, deviceHints, distToSegment, evaluateColor, evaluateExpression, evaluateNumber, expressionColor, expressionIssues, expressionNumber, extractFeature, featureContext, featureDrivenPaint, featureLevel, featureRuns, fillFootprint, fogPlanes, footprintOf, formatHash, generateBuildings, generateFill, generateLine, generateSurface, generateSymbols, globeBasis, globeFlatMix, globeRadius, globeToLocal, groundAt, iconRotateOf, iconRotation, importMapLibreStyle, insideFootprint, isExpression, isMapLibreStyle, isOsmglV2, junctionIndex, keptIndices, laneArrow, laneGuides, latFromMercatorY, layerV1toV2, liftFields, lngFromMercatorX, lngLatToUnit, loadMapLibreStyle, loadStyle, makeFeaturePaint, centerAnchor as mapLibreCenterAnchor, clipLine as mapLibreClipLine, lineAnchors as mapLibreLineAnchors, mapLibreSpot, matchesFilter, mercatorMetersPerTile, mercatorX, mercatorY, mercatorZFromAltitude, metersPerPixel, metersPerTile, needsDataPaint, nextQualityDown, parseGlb, parseGlbAsync, parseGlyphs, parseHash, parseLift, patchUV, pickBuilding, pickFill, pitchIntent, pixelsPerMeter, placeAlongLine, placeMarking, pointInRing, projectLine as projectSymbolLine, propertyV2toV1, qualityFor, qualityProfile, queryRendered, querySource, raySphere, refineLine, relaxAngle, relaxCurvature, replaceGlobalState, resolveStyleUrls, resolveSymbolField, resolveTemplate, ribbonFromEdges, ribbonRing, ribbonShape, ringEdges, roadEdges, roadHeights, roadMarkings, roadMesh, roadSurfaces, roundLine, roundRing, roundRings, sdfFromAlpha, shapeText, shapeTextCached, snapCutsInward, snapRoadEnds, speedSign, splitBucketKey, splitByGround, splitPolygons, squareClosed, stitchPieces, stopLine, styleV1toV2, styleWithTheme, taperedWidth, themeToInternal, themeV1toV2, tileOriginMeters, tileUrl, toLngLat, toMapLibreStyle, tryParseColor, unitToLngLat, unpackVector, validateStyle, validateTheme, waffle, worldSize, yieldTargetsOf, zebra };