osmgl 0.31.31 → 0.31.32

package/dist/nav-C8QvUodP.d.ts

@@ -1,2660 +0,0 @@
-import { bx as NavRoute, x as Model, a7 as StyleLayerSpec, a8 as StyleSpec, a6 as SourceSpec, ab as ThemeSpecV2, Y as PolylineOptions, A as AlongFade, Z as PolylineSegment } from './model-mshqbG69.js';
-import { Geom } from 'polygon-clipping';
-
-type LonLat$2 = [number, number];
-/** Фикс геолокации. `timeMs` — время самого фикса (монотонное у источника), не время приёма. */
-interface NavFix {
-    pos: LonLat$2;
-    timeMs: number;
-    /** Радиус ошибки, м; нет — неизвестно. */
-    accuracyM?: number | null;
-    speedMps?: number | null;
-    bearingDeg?: number | null;
-    /** Источник: Android знает его точно; веб — нет (тогда судим по точности). */
-    provider?: 'gps' | 'network' | 'fused' | null;
-    /**
-     * Сколько фиксу было в момент приёма, мс (Android: `elapsedRealtimeNanos` приёма минус фикса). Нет —
-     * свежий. Время самого фикса (`timeMs`) этого не говорит: часы источника с часами приёма не сравнить.
-     */
-    ageMs?: number | null;
-}
-/** Хуже этой точности фикс не берём вовсе, если GPS жив. */
-declare const FIX_ACC_MAX = 100;
-/** Хуже этой точности фикс не двигает машину по трассе (OsmAnd: 50 м). */
-declare const FIX_ACC_ROUTE = 50;
-/** Без явного источника: точность хуже — считаем фикс сетевым. */
-declare const FIX_NET_ACC = 30;
-/** Сколько после последнего GPS-фикса сетевые не принимаем (OsmAnd: 12 с). */
-declare const FIX_NET_HOLD_MS = 12000;
-/** Предел скорости между фиксами, м/с (≈216 км/ч), и запас к прошлой скорости. */
-declare const FIX_VMAX = 60;
-/**
- * Сколько ОТВЕРГНУТЫХ, но согласных между собой фиксов подряд нужно, чтобы поверить: машина и правда там
- * (туннель, долгий провал). Несогласные — разные выбросы — счёт начинают заново.
- */
-declare const FIX_REJECT_RESET = 3;
-/**
- * Фикс старше этого при приёме (мс) — не текущее место: последняя известная точка при подписке, пачка
- * после фона. OsmAnd считает кешированную точку устаревшей через 2 мин, мы для ведения строже: 10 с —
- * больше любой задержки доставки живого фикса и меньше, чем машина проедет незаметно.
- */
-declare const FIX_MAX_AGE_MS = 10000;
-/**
- * Живой поток одного источника: возраст соседних фиксов отличается не больше чем на это (мс) и не больше
- * половины шага между ними. У пачки старых фиксов, доставленных разом, возраст убывает ровно на шаг.
- */
-declare const FIX_STREAM_JITTER_MS = 1000;
-/** Меньший возраст живого потока больше этого (мс) — это сдвиг часов источника, а не задержка доставки. */
-declare const FIX_SKEW_MIN_MS = 2000;
-type NavFixVerdict = 'ok' | 'stale' | 'network' | 'inaccurate' | 'worse' | 'jump';
-/** Сетевой ли фикс: по источнику, а без него — по точности. */
-declare function isNetworkFix(f: NavFix): boolean;
-/** Устарел ли фикс к моменту приёма. */
-declare const isOldFix: (f: NavFix) => boolean;
-/**
- * Отбор фиксов. Первый свежий фикс берём всегда (хоть какой-то лучше никакого); дальше — по правилам выше.
- * Пока GPS не было (или он пропал дольше чем на 12 с), сетевые фиксы — единственный источник, их берём.
- * Не по порядку и устаревшие ('stale') не берём никогда и состояние ими не трогаем.
- */
-declare class NavFixFilter {
-    /** Последний принятый — приведённый к часам приёма (как `norm`). */
-    last: NavFix | null;
-    lastGpsMs: number;
-    rejects: number;
-    /** Последний отвергнутый (не 'stale', не 'network'): с ним сверяется следующий, подтверждая новое место. */
-    pending: NavFix | null;
-    /** Последний поданный фикс, приведённый к часам приёма: время плюс сдвиг часов источника, возраст без сдвига. */
-    norm: NavFix | null;
-    /** Свежие, но «не новее принятого» подряд (и по порядку между собой): `FIX_REJECT_RESET` — принятый из будущего. */
-    staleRun: number;
-    private staleLastMs;
-    /** Поток каждого источника: прошлый фикс (время и возраст), меньший возраст живого потока, сдвиг часов. */
-    private streams;
-    /** Сдвиг часов источника (мс), снятый по его живому потоку; 0 — часы согласны с часами приёма. */
-    skewMs(provider: string | null | undefined): number;
-    /**
-     * Привести фикс к часам приёма. Живой поток (возраст соседних почти не меняется) учит сдвиг часов источника —
-     * меньший возраст потока, если он больше `FIX_SKEW_MIN_MS`; сдвиг помнится и через разрывы потока. Фикс без
-     * возраста (веб) не трогаем.
-     */
-    private normalize;
-    accept(f0: NavFix): NavFixVerdict;
-    reset(): void;
-}
-/**
- * Окно поиска проекции: назад — max(80 м, точность), чтобы увидеть разворот (сам откат принимаем
- * только подтверждённым), вперёд — 150 м плюс путь за время. Дальше назад не смотрим: на петле
- * точку притянуло бы к другому её концу.
- */
-declare const PROG_BACK_MIN = 80;
-declare const PROG_AHEAD = 150;
-/** Откат назад, после которого (3 фикса подряд) верим, что развернулись (Mapbox iOS). */
-declare const PROG_BACK_CONFIRM = 3;
-declare const PROG_BACK_M = 50;
-/** Прыжок вперёд дальше правдоподобного — верим со второго фикса подряд. */
-declare const PROG_JUMP_CONFIRM = 2;
-/** Дальше этого (м) от проекции в окне — ищем по всей трассе (долгий провал, туннель, сход). */
-declare const PROG_WIDE_M = 60;
-/**
- * Дальнюю проекцию (по всей трассе) берём, только если фикс лежит на самой трассе: не дальше
- * max(этого, точности фикса), м. Иначе мы просто съехали, а у далёкого куска трассы, который проходит
- * рядом с объездом, машине делать нечего: перестроение всё равно заберёт её оттуда.
- */
-declare const PROG_WIDE_ON_M = 25;
-/**
- * Гистерезис выбора отрезка: проекция дальше правдоподобного пути вперёд берётся, только если она ближе
- * к фиксу хотя бы на столько, м. На параллельных проездах, развязках и эстакадах, где трасса идёт рядом
- * сама с собой, шум GPS в несколько метров иначе перекидывал метр на другой её кусок.
- */
-declare const PROG_SWITCH_M = 10;
-/**
- * Ближнее окно вперёд: путь за время по скорости фикса (не меньше `PROG_NEAR_MPS`) с запасом в полтора раза,
- * плюс точность и `PROG_NEAR_M`. Всё, что дальше, — только через гистерезис `PROG_SWITCH_M`.
- */
-declare const PROG_NEAR_MPS = 3;
-declare const PROG_NEAR_M = 15;
-/**
- * Грубый фикс (хуже `FIX_ACC_ROUTE`) держит метр, только пока точный был не раньше этого (мс, по времени фиксов).
- * Дальше грубые двигают метр вперёд в ближнем окне: спутник в руке в машине бывает грубее 50 м подолгу, и метка
- * стояла бы всю дорогу.
- */
-declare const PROG_COARSE_HOLD_MS = 5000;
-interface NavProgressOut {
-    /** Метр трассы, который принимаем. */
-    dist: number;
-    /** Сколько метров фикс от трассы (для `OffRouteWatch`); `Infinity` — фикс трассу не трогал. */
-    off: number;
-    /** Скорость вдоль трассы, м/с: из фикса, а без неё — по приросту метра. */
-    speedMps: number;
-    /** Подтверждён откат назад: развернулись — приложение перестраивает маршрут. */
-    reversed: boolean;
-}
-/** Ближайшая проекция точки на участок трассы [from, to] (в метрах); отступ — до точки внутри участка. */
-declare function snapWindow(r: NavRoute, p: LonLat$2, from: number, to: number): {
-    dist: number;
-    off: number;
-};
-/**
- * Прогресс по трассе. Ищем проекцию в окне вокруг принятого метра: назад `PROG_BACK_MIN`, вперёд — сперва
- * правдоподобный путь за время, дальше до `PROG_AHEAD` — только если там ближе на `PROG_SWITCH_M`; не нашли
- * близко (> `PROG_WIDE_M`) — по всей трассе (долгий провал), но берём её, только если фикс на ней (`PROG_WIDE_ON_M`). Дальше — монотонность: мелкий откат — дрожание, метр стоит; откат
- * от 50 м три фикса подряд — развернулись; прыжок вперёд дальше правдоподобного — верим со второго.
- * Фикс хуже 50 м по точности метр не двигает (только сообщает `off`).
- */
-declare class NavProgress {
-    dist: number | null;
-    last: NavFix | null;
-    back: number;
-    jumps: number;
-    /** Время последнего точного фикса (не грубее `FIX_ACC_ROUTE`). */
-    accurateMs: number;
-    update(r: NavRoute, f: NavFix): NavProgressOut;
-    reset(): void;
-}
-/**
- * Переезд точки к новому фиксу, мс: по интервалу между фиксами (точка едет непрерывно, а не прыгает раз в
- * секунду), но не короче `PUCK_GLIDE_MIN_MS` и не дольше `PUCK_GLIDE_MAX_MS` (Organic Maps: стрелка не
- * анимируется дольше 1.5 с; MapLibre `LocationAnimatorCoordinator`: длительность — интервал фиксов).
- */
-declare const PUCK_GLIDE_MIN_MS = 200;
-declare const PUCK_GLIDE_MAX_MS = 1500;
-/** Дальше этого (м) — переносим сразу: ехать полкилометра по экрану — не сглаживание, а ложное движение. */
-declare const PUCK_TELEPORT_M = 500;
-/**
- * СТОИМ — ТОЧКУ НЕ ДВИГАЕМ (22.10.2026). Спутник у неподвижного телефона дрожит на метры: Redmi Note 11 у окна —
- * точность 8.8 м, скорость 0.0, каждую секунду новая точка в паре метров от прежней. Каждый такой фикс вёл точку, а у OM
- * и камеру слежения (`easeTo` на время переезда ≈1 с), и неподвижная карта рисовала 25–57 кадров/с при 60–90 % ядра.
- * Фикс со скоростью ниже `PUCK_STILL_MPS` в пределах своей точности от ПОКАЗАННОЙ точки (не ближе `PUCK_STILL_MIN_M`, не
- * дальше `PUCK_STILL_MAX_M`) — то же место: `push` отвечает `false` и ставит `held`. Сравнение — с показанной точкой, а не
- * с прошлым фиксом: медленный дрейф не копится незаметно, а вывозит точку, как только уйдёт за порог. Без скорости
- * (сеть, веб) — не держим: идущего пешком не отличить от дрожания.
- */
-declare const PUCK_STILL_MPS = 0.5;
-declare const PUCK_STILL_MIN_M = 3;
-declare const PUCK_STILL_MAX_M = 15;
-/**
- * Точка «я здесь» без маршрута (свободная карта у обоих приложений). Раньше приложение двигало метку на
- * КАЖДЫЙ фикс подряд — спутниковый и сетевой вперемешку, и сетевой (Wi-Fi/сота, 20–500 м) уводил точку
- * в сторону, а следующий спутниковый возвращал: «прыгает и сразу назад». Теперь:
- *  - фикс проходит тот же `NavFixFilter`, что и в ведении (сеть при живом GPS, выбросы, порядок, возраст);
- *  - устаревший фикс показывается, только пока не показано ничего (последняя известная точка при
- *    запуске — «Моё место» не ждёт спутника), и следующий свежий берётся без сверки с ним;
- *  - точка не переносится, а ЕДЕТ от нарисованного места к новому фиксу (`at`), прерванный переезд
- *    продолжается с того места, где точка сейчас.
- * Время — часы приложения (мс), те же для `push` и `at`.
- */
-declare class NavPuck {
-    readonly filter: NavFixFilter;
-    /** Последний показанный фикс (цель переезда); `null` — показывать нечего. */
-    fix: NavFix | null;
-    /** Показан устаревший фикс («пока ничего лучше нет»). */
-    provisional: boolean;
-    private from;
-    private t0;
-    private dur;
-    private lastPushMs;
-    /** Последний `push` ответил `false`, потому что стоим (`PUCK_STILL_MPS`), а не потому что фикс отвергнут. */
-    held: boolean;
-    /** Фикс пришёл в `nowMs`: `true` — точку надо вести к нему (новая цель), `false` — отвергнут или стоим (`held`). */
-    push(f: NavFix, nowMs: number): boolean;
-    /** Где нарисовать точку в `nowMs`; `null` — ещё нечего. */
-    at(nowMs: number): LonLat$2 | null;
-    /** Длительность текущего переезда, мс (0 — перенос): камере слежения — та же, чтобы точка не уплывала из центра. */
-    get glideMs(): number;
-    /** Идёт ли переезд: приложению — крутить кадры, пока `true`. */
-    moving(nowMs: number): boolean;
-    reset(): void;
-}
-
-type LonLat$1 = [number, number];
-type NavCarKind = 'arrow' | 'arrow3d' | 'sedan' | 'pickup' | 'suv';
-/** Варианты, у которых есть 3D-модель (всё, кроме плоской стрелки — её рисуют фигуры курсора). */
-type NavCarModelKind = Exclude<NavCarKind, 'arrow'>;
-/** Порядок выбора в настройках: прежняя стрелка первой, объёмная — рядом с ней. */
-declare const NAV_CAR_KINDS: NavCarKind[];
-declare const NAV_CAR_LABELS: Record<NavCarKind, string>;
-/** Настройка → вариант; пусто и неизвестное — стрелка (так было до машин). */
-declare function navCarKind(id?: string | null): NavCarKind;
-declare const NAV_CAR: {
-    /**
-     * Наименьшая длина машины на экране, пиксели. Как у Google: на обзорных зумах машина не тает в
-     * точку, а держит размер значка (заметно крупнее круга курсора — 28.5 px); настоящие 4.5 м
-     * начинаются только вблизи (z20+).
-     */
-    minPx: number;
-    /** Зазор над линией маршрута, метры: колёса стоят на ленте, а не в ней (у курсора тоже +0.02). */
-    lift: number;
-    /** Высота фаски низа кузова, метры. */
-    chamfer: number;
-};
-/**
- * Кузов: сечения поперёк машины от носа к корме — `[s, w, belt, wt, top]`: расстояние от носа,
- * полуширина по борту, высота пояса (низ окон), полуширина и высота верха (крыша/капот). Между
- * сечениями — сегменты (`segs`, на один меньше), буква решает, чем покрыт верх и бока над поясом:
- *   B — кузов, W — стекло сверху и с боков (лобовое, заднее), R — крыша с боковыми окнами,
- *   P — стойка (весь сегмент кузовом), D — кузов пикапа (стенки и пол — тёмным пластиком).
- */
-interface NavCarBody {
-    length: number;
-    /** Полуширина по борту (наибольшая), метры. */
-    width: number;
-    /** Клиренс: низ кузова над землёй. */
-    clearance: number;
-    color: string;
-    sections: number[][];
-    segs: string;
-    /** Колёса: радиус, ширина, расстояния осей от носа. */
-    wheel: {
-        r: number;
-        w: number;
-        axles: [number, number];
-    };
-    /** Рейлинги на крыше: от и до (расстояние от носа), полуразнос, высота. */
-    rails?: [number, number, number, number];
-}
-declare const NAV_CAR_BODIES: Record<Exclude<NavCarKind, 'arrow' | 'arrow3d'>, NavCarBody>;
-/**
- * ОБЪЁМНАЯ СТРЕЛКА (`arrow3d`) — значок «как у Яндекс Навигатора»: скруглённый шеврон-«подушка» с
- * белой каймой, глянцем и мягкой тенью. Своя геометрия, не снятая с чужой модели.
- *
- *  • СИЛУЭТ — шеврон в плане (x вправо, z назад, остриё в −z): остриё, правое крыло, выемка, левое
- *    крыло. Каждый угол скруглён ДУГОЙ ОКРУЖНОСТИ — рациональной квадратичной кривой Безье (`corners`:
- *    доли входящего и исходящего ребра и вес = синус половины угла), `steps` отрезков на дугу. Только
- *    сложение, умножение и деление: тригонометрии нет, порты совпадают с вебом до байта. Формула
- *    записана симметрично (`t·u`, `(wa+wb)+wp`), поэтому левая половина — точное отражение правой.
- *  • ОБЪЁМ — кольца, отступающие от силуэта внутрь по нормали вершины: вертикальный борт (`base` →
- *    `wall`), белая скруглённая кайма (`rim`: ширина, высота — четверть эллипса) и синяя «подушка»
- *    (`dome`), над ней — крышка с подъёмом середины (`crown`). Профиль четверти — таблица точек
- *    единичной окружности с рациональными координатами (`arc`: 3-4-5, 7-24-25), нормали гладкие:
- *    по профилю и по силуэту, поэтому свет и блик текут по всей стрелке без граней.
- *  • ЦВЕТ И ГЛЯНЕЦ — без новых шейдеров, в материалах GLB: синий маршрута с градиентом по высоте
- *    (`low` у основания подушки → `top` → светлая крышка `high`), борт глубже, кайма белая; малая
- *    шероховатость даёт блик солнца и френелевское отражение неба у краёв (ветка `reflection`
- *    программы моделей). Ночью — свой набор (`NAV_ARROW_PALETTES.night`, модель `arrow3d-night`):
- *    ЯРКОСТЬ ДАЁТ СВЕЧЕНИЕ, А НЕ ЦВЕТ. Ночная тема гасит свет сцены (у NaviGram: рассеянный 0.34
- *    голубоватый, ключевой 0.3 против 0.48/0.6 днём) — освещённая часть синего падает на треть. Первый
- *    набор (цвет светлее дневного, свечение 0.05–0.3) под таким светом выходил ТЕМНЕЕ дневной стрелки
- *    (замер Redmi 23.10.2026: L 116 против 129); светлее она была только на стилях MapLibre с дневным
- *    светом. Поэтому ночью цвет темнее, а свечение крупное: под ночным светом стрелка заметно ярче
- *    дневной, и от света темы зависит слабо (оценка по граням: 135 ночью против 99 днём, на дневном
- *    свете 154). Проверка — тест `ночная стрелка ярче` в `tests/nav-car.test.mjs`.
- *  • ПРЕДЕЛ — отступ колец (`rim[0] + dome[0]`) меньше радиуса самой тугой дуги (остриё, крылья —
- *    ≈0.26 м): иначе внутренние кольца на углах завернулись бы.
- */
-declare const NAV_ARROW: {
-    /** Длина скруглённого силуэта от острия до концов крыльев, метры (по ней поза держит `minPx`, как у машин). */
-    length: number;
-    /** Опорный контур до скругления: остриё, правое крыло, выемка, левое крыло. */
-    outer: number[][];
-    /** Скругление углов: доля ребра к предыдущей вершине, доля ребра к следующей, вес дуги. */
-    corners: number[][];
-    /** Отрезков на дугу угла (чётное: середина дуги острия и выемки ложится точно на ось). */
-    steps: number;
-    /** Низ борта над подложкой-тенью, метры. */
-    base: number;
-    /** Верх борта. */
-    wall: number;
-    /** Белая кайма: ширина внутрь и высота скругления. */
-    rim: number[];
-    /** Синяя «подушка»: ширина внутрь и высота. */
-    dome: number[];
-    /** Подъём середины крышки над краем подушки. */
-    crown: number;
-    /** Центр крышки и подложки в плане (из него силуэт виден целиком). */
-    center: number[];
-    /** Четверть профиля: (cos, sin) от «наружу» до «вверх» — рациональные точки окружности. */
-    arc: number[][];
-};
-/** Цвета стрелки (`#rrggbb`): крышка, подушка, низ подушки, кайма, борт; свечение — RGB 0..1 (ночью). */
-interface NavArrowPalette {
-    high: string;
-    top: string;
-    low: string;
-    bevel: string;
-    side: string;
-    highGlow?: [number, number, number];
-    topGlow?: [number, number, number];
-    lowGlow?: [number, number, number];
-    bevelGlow?: [number, number, number];
-    sideGlow?: [number, number, number];
-}
-declare const NAV_ARROW_PALETTES: {
-    day: NavArrowPalette;
-    night: NavArrowPalette;
-};
-/** Материалы — в этом порядке и уходят в GLB (пустые пропускаются). */
-interface NavCarMaterial {
-    name: string;
-    color: [number, number, number, number];
-    metallic: number;
-    roughness: number;
-    emissive?: [number, number, number];
-    blend?: boolean;
-}
-/** `#rrggbb` → RGBA 0..1. */
-declare function navCarColor(hex: string): [number, number, number, number];
-/** Кусок меша одного материала: треугольники подряд, у каждого свои три вершины (плоские грани). */
-interface NavCarPart {
-    material: NavCarMaterial;
-    positions: number[];
-    normals: number[];
-}
-/**
- * Силуэт стрелки: точки по кругу (остриё → правое крыло → выемка → левое крыло, по `steps + 1` на угол;
- * между углами — прямые рёбра) и единичные нормали вершин наружу (средняя двух соседних рёбер).
- */
-declare function navArrowOutline(): {
-    points: number[][];
-    normals: number[][];
-};
-/** Меш значка кусками по материалам (пустые куски выброшены); `night` — ночные цвета (только у стрелки). */
-declare function navCarMesh(kind: NavCarModelKind, night?: boolean): NavCarPart[];
-/** Число с четырьмя знаками: округление к ближайшему (половина — вверх по модулю). */
-declare function fmt4(v: number): string;
-/** Число с одним знаком (пути превью). */
-declare function fmt1(v: number): string;
-/**
- * Имя модели в GLB и в адресе: вариант, у ночной стрелки — с `-night`. У машин ночного набора нет —
- * их GLB от `night` не зависит.
- */
-declare function navCarModelId(kind: NavCarModelKind, night?: boolean): string;
-/** GLB значка: одна сетка, примитив на материал, позиции и нормали Float32, индексы Uint32. */
-declare function navCarGlb(kind: NavCarModelKind, night?: boolean): Uint8Array;
-/** FNV-1a 32 бита — отпечаток GLB в фикстурах (строкой из восьми шестнадцатеричных цифр). */
-declare function navCarHash(bytes: Uint8Array): string;
-interface NavCarPose {
-    lng: number;
-    lat: number;
-    /** Высота колёс над землёй, метры: над линией маршрута и лентой, на эстакаде — с её отметкой. */
-    altitude: number;
-    /** Курс по часовой, градусы 0..360 (`rotation` модели). */
-    rotation: number;
-    /** Множитель к настоящему размеру: 1 вблизи, больше — чтобы машина не была мельче `minPx`. */
-    scale: number;
-}
-/**
- * Поза машины: точка и курс курсора (их сглаживает `NavTracker`), масштаб по метрам в пикселе
- * экрана на широте машины и высота полотна под ней (`roadLiftM` — эстакада по ленте, 0 на земле).
- * Для стрелки — `null`: её рисуют фигуры `navCursorShapes`.
- */
-declare function navCarPose(kind: NavCarKind, pos: LonLat$1, brgDeg: number, metersPerPixel: number, roadLiftM?: number): NavCarPose | null;
-/**
- * Отметка ленты на метре трассы `m`: профили — станции и высоты точек площадных кусков ленты
- * (`RibbonFeature.stations` + `heightAt` по уровню). Внутри куска — линейно между соседними
- * станциями; кусков на метре несколько (полосы рядом) — наибольшая; вне ленты — 0.
- */
-declare function navCarLiftAt(profiles: {
-    stations: number[];
-    heights: number[];
-}[], m: number): number;
-interface NavCarIcon {
-    width: number;
-    height: number;
-    /** Пути SVG с заливкой, снизу вверх. */
-    paths: {
-        d: string;
-        fill: string;
-    }[];
-}
-/** SVG-разметка превью целиком (для веба). */
-declare function navCarIconSvg(kind: NavCarKind): string;
-/**
- * Превью 48×24: машина сбоку (нос влево) по тем же сечениям, что модель, — силуэт цвета кузова,
- * окна по сегментам W/R, колёса с колпаками. Стрелка — синий круг с белой стрелкой курсора.
- */
-declare function navCarIcon(kind: NavCarKind): NavCarIcon;
-
-/** Что оверлею нужно от карты (`Map` движка подходит как есть). */
-interface NavCarHost {
-    addModel(model: Model): unknown;
-    removeModel(model: Model): unknown;
-    triggerRepaint(): unknown;
-    /**
-     * Фокус окон домов (`Map.setFacadeFocus`): в ведении окна стен рисуются только около машины (вариант A владельца,
-     * 22.10.2026). Необязателен — хозяину без домов он не нужен.
-     */
-    setFacadeFocus?(pos: [number, number] | null): unknown;
-}
-declare class NavCarOverlay {
-    private readonly map;
-    /** Модели по вариантам (`navCarModelId`) — создаются при первом выборе и живут, пока жив оверлей. */
-    private models;
-    /** Какая модель сейчас на карте (`null` — никакой). */
-    private shown;
-    private _kind;
-    private _night;
-    constructor(map: NavCarHost);
-    /**
-     * Вариант значка. `'arrow'` — машины нет (стрелку рисует приложение фигурами `navCursorShapes`).
-     * Смена варианта снимает прежнюю модель сразу, новая встаёт со следующего `update`.
-     */
-    get kind(): NavCarKind;
-    set kind(value: NavCarKind);
-    /**
-     * Ночные цвета значка (тёмная тема карты). Меняет только объёмную стрелку: её модель снимается сразу,
-     * ночная (или дневная) встаёт со следующего `update`.
-     */
-    get night(): boolean;
-    set night(value: boolean);
-    /** Видна ли машина сейчас (после `update` с вариантом-машиной). */
-    get visible(): boolean;
-    /**
-     * Поставить машину в точку `pos` (`[lon, lat]`) с курсом `bearing` (градусы по часовой) на зуме
-     * карты `zoom`; `roadLiftM` — отметка полотна под машиной (эстакада), 0 на земле. Возвращает
-     * `false`, если выбрана стрелка — тогда рисует приложение.
-     */
-    update(pos: [number, number], bearing: number, zoom: number, roadLiftM?: number): boolean;
-    /** Убрать машину с карты (выбор остаётся). */
-    clear(): void;
-    /** Снять все модели с карты — оверлей больше не нужен. */
-    destroy(): void;
-    /** Машину убрали — ведения нет: окна снова везде. */
-    private hide;
-    private hideModel;
-}
-
-/**
- * ЛЕНТА МАРШРУТА ПО ПОЛОСАМ — геометрия (как у Baidu: на детальной улице линия маршрута становится
- * полупрозрачной лентой по рекомендуемым полосам).
- *
- * Чистые функции без движка и сети (проверка — `lane-ribbon-geom.test.ts`). Вход — план полос
- * (`api/lanes.ts`, контракт `POST /tiles/ldroads/guidance`) и та же трасса, что ушла в запрос:
- * все метры плана считаются ВДОЛЬ неё.
- *
- * ★ ВСЁ ПАРАМЕТРИЗУЕТСЯ МЕТРОМ МАРШРУТА. Осевая полосы — своя ломаная (её даёт сервер, смещённую по
- * профилю), но каждая её точка получает «станцию» — проекцию на трассу. Тогда «полоса на метре s»
- * — интерполяция по станциям, и всё остальное становится сложением точек на одной станции:
- * лента на две соседние полосы — середина их осевых, S-переход из полосы в полосу — смесь двух
- * точек с весом smoothstep, стык с обычной линией маршрута — смесь с точкой самой трассы. Своего
- * смещения кривых для этого не нужно, и лента не «срезает» повороты осевой.
- *
- * ★ ПЛОСКАЯ СИСТЕМА МЕТРОВ вокруг трассы (равнопромежуточная): на маршруте в несколько километров
- * ошибка — доли процента, а разница с серверными метрами ровно такая же, как у любых двух
- * реализаций длины.
- */
-
-type LonLat = [number, number];
-interface XY {
-    x: number;
-    y: number;
-}
-/** Плоская система метров вокруг точки. */
-interface Frame {
-    toXY(p: LonLat): XY;
-    toLonLat(p: XY): LonLat;
-}
-declare function frameAt(origin: LonLat): Frame;
-/** Гладкая ступенька 0→1: нулевая производная на концах — S-переход без излома на входе и выходе. */
-declare const smoothstep: (t: number) => number;
-interface Measured {
-    pts: XY[];
-    /** Накопленная длина к каждой точке, метры. */
-    cum: number[];
-    length: number;
-}
-declare function measure(pts: XY[], lengths?: number[]): Measured;
-/**
- * Длина звена — ТОЙ ЖЕ ФОРМУЛОЙ, ЧТО У СЕРВЕРА (`LdLaneGraph.DistanceM`, `LD-LANE-GUIDANCE.md`,
- * «Метры»): плоская на каждом звене, косинус СРЕДНЕЙ широты звена. Все метры плана — вдоль трассы
- * этой мерой; гаверсинус или общий косинус дали бы расхождение до 10 м на 10 км.
- */
-declare function linkM(a: LonLat, b: LonLat): number;
-/** Трасса `[lon, lat]` в метрах: точки — в плоской системе, накопленная длина — мерой сервера. */
-declare function measureRoute(geometry: LonLat[], frame: Frame): Measured;
-/** Точка на метре `s` (за концами — продолжение крайнего отрезка). */
-declare function pointAt(m: Measured, s: number): XY;
-/** Курс на метре `s`: единичный вектор по ходу. */
-declare function tangentAt(m: Measured, s: number): XY;
-/** Курс в градусах по часовой от севера — для камеры. */
-declare function bearingAt(m: Measured, s: number, ahead?: number): number;
-/**
- * Метр трассы, ближайший к точке. `from`/`to` — окно поиска: трасса может пройти мимо одного
- * места дважды (разворот, петля), и полоса одного участка не должна «прилипнуть» к другому.
- */
-declare function project(m: Measured, p: XY, from?: number, to?: number): {
-    s: number;
-    d: number;
-};
-/** Дробление ломаной: точки не реже `step` метров. */
-declare function densify(pts: XY[], step: number): XY[];
-/** Кусок ломаной между метрами `from` и `to` её СОБСТВЕННОЙ длины. */
-declare function sliceLine(pts: XY[], from: number, to: number): XY[];
-/**
- * СМЕЩЁННАЯ КРИВАЯ: каждая точка сдвигается на свой `offsets[i]` метров вправо по ходу.
- *
- * Нормаль в вершине — биссектриса соседних отрезков, длина поправлена на угол (как у стыка
- * «miter»), но не больше чем вдвое: на остром изломе честный miter улетает на десятки метров.
- */
-declare function offsetLine(pts: XY[], offsets: number[] | number): XY[];
-/** Боковой сдвиг точки от трассы на метре `s`, метры вправо по ходу. */
-declare function lateralAt(route: Measured, s: number, p: XY): number;
-/** Осевая полосы со станциями: `s[i]` — метр трассы точки `pts[i]`, строго растёт. */
-interface Track {
-    s: number[];
-    pts: XY[];
-}
-/**
- * Осевая полосы → станции. Точки, станция которых не растёт (осевая шире трассы на развороте,
- * хвост за перекрёстком, загнутый назад), выкидываются: функция «точка по метру» обязана быть
- * однозначной.
- */
-declare function laneTrack(route: Measured, centre: XY[], window: [number, number]): Track | null;
-/**
- * Точка полосы на метре `s`. За концами осевой — тот же боковой сдвиг от трассы, что у крайней
- * точки: лента не обрывается и не загибается к оси, если осевая чуть короче участка.
- */
-declare function trackAt(route: Measured, tr: Track, s: number): XY;
-/** Точка, сдвинутая от трассы на метре `s` на `off` метров вправо. */
-declare function offsetPoint(route: Measured, s: number, off: number): XY;
-/** Отступ ленты от краёв полосы (на обе стороны вместе): лента не должна лечь на разметку. */
-declare const RIBBON_MARGIN_M = 0.7;
-/** Шаг ленты вдоль маршрута. */
-declare const RIBBON_STEP_M = 2;
-/** Длина стыка ленты с обычной линией маршрута на краях покрытия. */
-declare const JOIN_M = 25;
-/**
- * Скругление оси ленты на изломах (сигма гауссова окна, метры). Излом — поворот трассы на
- * перекрёстке или скачок между осевыми соседних отрезков улицы: без скругления контур ленты на
- * внутренней стороне угла выворачивался петлёй. Радиус дуги на повороте 90° — около 1.6 сигмы.
- */
-declare const CORNER_SMOOTH_M = 4.5;
-/** Излом — поворот направления в точке оси больше этого (градусы). */
-declare const CORNER_DEG = 8;
-/**
- * `band-passed`/`allowed-passed` — пройденная в ведении часть ленты (серая, `lib/route-progress.ts`);
- * `buildRibbon` их не строит.
- */
-type RibbonKind = 'band' | 'allowed' | 'chevron' | 'band-passed' | 'allowed-passed';
-/**
- * ФОРМА КОНЦА ЛЕНТЫ там, где она кончается без продолжения (начало и конец маршрута, края дыр в
- * плане; не стык с линией маршрута и не разрез в точке машины или по кускам):
- *  - `round` — полукруг радиусом полуширины, касательный к кромкам (как `line-cap: round`);
- *  - `flat` — прямой срез поперёк ленты в последней точке оси (как было до скруглений);
- *  - `arrow` — заострённый конец-стрелка на КОНЦЕ маршрута (как у Baidu на точке назначения):
- *    кромки сходятся в вершину впереди оси на `ARROW_TIP_K` полуширины; начало при этом — `round`.
- * Скругление и стрелка выходят за последнюю точку оси (на полуширину и `ARROW_TIP_K` полуширины).
- */
-type RibbonCap = 'round' | 'flat' | 'arrow';
-declare const RIBBON_CAPS: readonly RibbonCap[];
-declare const DEFAULT_RIBBON_CAP: RibbonCap;
-declare const isRibbonCap: (v: unknown) => v is RibbonCap;
-/** Отрезков на полукруг конца: излом на стыке кромки и полукруга — π/(2·N), 2.8°. */
-declare const CAP_SEGMENTS = 32;
-/** Длина острия стрелки за последней точкой оси, в полуширинах ленты (угол при вершине ≈ 67°). */
-declare const ARROW_TIP_K = 1.5;
-interface RibbonFeature {
-    kind: RibbonKind;
-    /** Осевая куска, `[lon, lat]` (у ленты — уже скруглённая на изломах). */
-    line: LonLat[];
-    /** Ширина, метры: у ленты — наибольшая по куску (сама форма — в `outline`). */
-    width: number;
-    /** Уровень (эстакада 1, земля 0, тоннель −1) у каждой точки `line` — по нему берётся высота. */
-    levels: number[];
-    /**
-     * Контур площадной фичи (`band`, `allowed`) — замкнутое кольцо `[lon, lat]` против
-     * часовой, без самопересечений. Рисуется готовым многоугольником: форму ленты считает клиент, а
-     * не движок из оси и ширины (у той сборки на изломе внутренняя кромка выворачивалась, и earcut
-     * заливал треугольник через квартал).
-     */
-    outline?: LonLat[];
-    /**
-     * Метр трассы у каждой точки `line` (не убывает) — по нему пройденная часть ленты отрезается в
-     * ведении (`lib/route-progress.ts`). У шеврона — метры его двух концов.
-     */
-    stations?: number[];
-    /** Ширина ленты у каждой точки `line`, метры (площадные фичи) — контур отрезанной части. */
-    widths?: number[];
-    /**
-     * Форма начала и конца (площадные фичи), `RibbonCap`: уже с учётом стыков — где лента переходит
-     * в линию маршрута, там `flat`. Куски ленты (ведение, резка по `CHUNK_M`) берут форму только у
-     * своих настоящих концов, на разрезах — прямо.
-     */
-    caps?: [RibbonCap, RibbonCap];
-}
-interface Ribbon {
-    features: RibbonFeature[];
-    /** Где обычная линия маршрута уступает ленте: метры вдоль трассы. */
-    hidden: [number, number][];
-    /**
-     * Ось ОСНОВНОЙ ленты для позы машины навигатора (`laneCarTrack` в `nav-car.ts`): те же точки и метры, что у её
-     * фич `band` (`line`, `stations`), и доля плана в позе машины. Нет основной ленты — поля нет.
-     */
-    car?: RibbonCar;
-}
-/**
- * МАШИНА ЕДЕТ ПО ЛЕНТЕ (этап 1 «как обычный режим полос Baidu/Amap», 23.10.2026): ось основной ленты — та самая, что
- * нарисована (`band.line` после скругления изломов), с метрами трассы и ВЕСОМ ПЛАНА в каждой точке:
- *  · 1 — на куске покрытия плана (машина на оси ленты, в том числе пока лента переходит в полосу из ленты вне
- *    покрытия по `RAMP_SLOPE`);
- *  · вне покрытия — `CAR_OUTSIDE_WEIGHT` = 1 (решение владельца 24.10.2026): лента там — догадка «полполосы справа»
- *    (`OUTSIDE_LANE_M`), и машина едет по ней же, а не по линии маршрута на 1,65 м левее. Плавность на краях куска
- *    даёт сама ось ленты: она входит в полосу и выходит из неё по `RAMP_SLOPE`;
- *  · при весе вне покрытия меньше 1 между ними — подъезд на `JOIN_M` до края куска (`carWeight`, smoothstep).
- * Метры не убывают; кусков основной ленты несколько (лента только на покрытии, `outside: false`) — они идут подряд.
- */
-interface RibbonCar {
-    stations: number[];
-    line: LonLat[];
-    weights: number[];
-}
-/**
- * Склеить пересекающиеся и близкие отрезки покрытия: щель меньше `gap` — это перекрёсток между
- * двумя участками, и лента через него идёт непрерывно, а не прыгает в линию маршрута и обратно.
- */
-declare function mergeRanges(ranges: [number, number][], gap?: number, limit?: [number, number]): [number, number][];
-/** Подряд идущие номера полос — группы ленты (две соседние полосы — одна лента во всю ширину). */
-declare function contiguousGroups(lanes: PlanLane[]): PlanLane[][];
-/**
- * ЛЕНТА ВНЕ ПОКРЫТИЯ: где детальных дорог нет, маршрут тоже идёт лентой — шириной в одну полосу,
- * в правой половине дороги по ходу (смещение от оси трассы на полполосы). Полос там никто не
- * знает; ширина и сторона — по умолчанию, свои можно передать (`BuildOptions.outside`).
- */
-declare const OUTSIDE_LANE_M = 3.3;
-/**
- * Переход между лентой по полосам и лентой вне покрытия: ширина и смещение меняются не круче
- * этого (метров на метр; с запасом до 5 см на метр — сглаживание оси добавляет свои доли) — длина
- * перехода `1.5 · Δ / RAMP_SLOPE` (у smoothstep наибольший наклон в полтора раза больше среднего;
- * разница ширин считается вдвое — `evenWidths` у порога ровняет ширину вдвое круче), но не короче
- * `JOIN_M` и не длиннее половины куска покрытия.
- */
-declare const RAMP_SLOPE = 0.045;
-interface OutsideOptions {
-    /** Ширина полосы вне покрытия, метры (лента — она минус `RIBBON_MARGIN_M`). */
-    laneM?: number;
-    /** Смещение оси ленты от оси трассы вправо по ходу, метры (односторонняя улица — 0). */
-    offsetM?: number;
-}
-interface BuildOptions {
-    /** Склеивать покрытие через щель не длиннее (метры). */
-    gapM?: number;
-    /**
-     * Лента и вне покрытия (по умолчанию — да, `OUTSIDE_LANE_M` справа от оси). `false` — как
-     * раньше: лента только на покрытии, на его краях сходится к линии маршрута.
-     */
-    outside?: OutsideOptions | false;
-    /**
-     * Форма концов ленты (`RibbonCap`, по умолчанию `round`). У основной ленты — начало (`arrow` там
-     * — `round`) и конец; прочие группы и разрешённые полосы — `round`, у `flat` — прямые.
-     */
-    cap?: RibbonCap;
-}
-/**
- * ЛЕНТА ИЗ ПЛАНА.
- *
- * Главный путь — одна непрерывная лента на каждый кусок покрытия: по участку — на группу
- * рекомендуемых полос (той, куда ведёт перестроение, иначе — на самую широкую), в `changes` —
- * S-переход из полосы в группу, между участками — плавная смесь конца одного с началом другого.
- * Вне покрытия (`BuildOptions.outside`, по умолчанию) лента продолжается шириной в одну полосу
- * справа от оси трассы, и линия маршрута уступает ей целиком; на краях покрытия ширина и смещение
- * переходят плавно (`RAMP_SLOPE`). С `outside: false` — по-старому: на краях покрытия ось ленты
- * сходится к оси трассы, дальше идёт линия маршрута. Остальные
- * группы рекомендуемых — своими лентами по участку, `allowed` — бледной лентой, `other` — ничего.
- * Все площадные фичи — готовым контуром (`outline`), шевроны — отдельными прямыми.
- */
-declare function buildRibbon(plan: LanePlan, geometry: LonLat[], opts?: BuildOptions): Ribbon;
-/**
- * ПОВОРОТ ЧЕРЕЗ УЗЕЛ — по графу полос, как скругление угла асфальта у стенда. Полоса приходящего
- * отрезка и полоса уходящего — две прямые (направления берутся за пределами узла, где осевые
- * чистые); ось ленты в окне `[lo, hi]` — прямая по приходящей полосе до точки их пересечения и
- * прямая по уходящей, а дугу на изломе делает `smoothCorners` (гауссово окно по длине: касательная
- * и кривизна непрерывны, кривизна — колоколом). Раньше ось в узле шла по осевым отрезков как
- * есть: конец приходящей полосы торчал за начало дуги (сервер ведёт осевую до середины узла, а
- * уходящая полоса начинается сбоку от неё), и кромки ленты выходили со ступенькой и горбом.
- *
- * Окно — до `TURN_WINDOW_M` в каждую сторону от стыка (не дальше половины отрезка), поворот
- * положе `TURN_MIN_DEG` не трогается: там стык отрезков — продолжение улицы. Точки окна
- * раскладываются по новой кривой пропорционально станциям; ширина переходит от приходящей к
- * уходящей плавно (smoothstep), уровень — прежний.
- */
-declare const TURN_WINDOW_M = 14;
-declare const TURN_MIN_DEG = 20;
-/** Функция нормального распределения (Абрамовиц — Стиган 7.1.26, ошибка < 1.5e-7). */
-declare function normalCdf(z: number): number;
-/**
- * ВЕС ПЛАНА ВНЕ ПОКРЫТИЯ (решение владельца 24.10.2026): 1 — машина и вне покрытия на оси ленты «полполосы справа»,
- * как в обычном режиме полос Baidu/Amap; 0 — на линии маршрута (так было в этапе 1, 23.10.2026).
- */
-declare const CAR_OUTSIDE_WEIGHT = 1;
-/**
- * ВЕС ПЛАНА В ПОЗЕ МАШИНЫ на метре `s` (`RibbonCar.weights`): на куске покрытия `[a, b]` — 1 (машина на ленте, в
- * том числе пока лента переходит из полосы в ленту вне покрытия), вне кусков — `CAR_OUTSIDE_WEIGHT`, за `JOIN_M` до
- * края куска — подъезд smoothstep к 1 (при весе вне покрытия меньше 1: машина съезжает на ленту по метрам).
- */
-declare function carWeight(s: number, runs: [number, number][]): number;
-/**
- * Значение на метре `s` по точкам с метрами `st` (не убывают): линейно между соседними, за концами — крайнее. На
- * повторе метра (окно поворота, `filletTurn`) берётся первая точка.
- */
-declare function valueAt(st: number[], v: number[], s: number): number;
-/** Станции от `a` до `b` через `step`, концы включены. */
-declare function stationsBetween(a: number, b: number, step: number): number[];
-/**
- * РОВНАЯ ШИРИНА: полосы соседних отрезков одной улицы расходятся на сантиметры (3.5 и 3.333 м), и
- * лента от этого шла бы ступеньками. Ширина, отличающаяся от средней по куску меньше чем на
- * `EVEN_WIDTH_M`, приравнивается к ней; настоящая смена (лента на две полосы) остаётся, а между
- * порогом и двумя порогами ширина непрерывно возвращается к своей.
- */
-declare const EVEN_WIDTH_M = 0.5;
-declare function evenWidths(widths: number[]): number[];
-/** Допуск прореживания оси шевронов, метры. */
-declare const CHEVRON_TOLERANCE_M = 0.1;
-/** Прямой кусок оси короче этого шевронов не получает (метры). */
-declare const CHEVRON_MIN_RUN_M = 6;
-/** Дуглас — Пойкер: номера оставленных точек (концы — всегда). */
-declare function simplifyIdx(pts: XY[], tol: number): number[];
-/** Шаг точек ленты после пересборки по собственной длине оси, метры. */
-declare const OUTLINE_STEP_M = 1;
-/**
- * Ломаная с атрибутами → точки через равный шаг ПО СОБСТВЕННОЙ ДЛИНЕ. Станции маршрута для этого не
- * годятся: на внутренней стороне поворота полоса короче трассы, и точки там сбивались в кучу —
- * окно сглаживания сжималось, дуга выходила с радиусом в пару метров.
- */
-declare function resampleLine(pts: XY[], attrs: number[][], step?: number): {
-    pts: XY[];
-    attrs: number[][];
-};
-/** Сглаживание ширины по точкам оси (сигма — в точках, т. е. метрах после `resampleLine`). */
-declare const WIDTH_SMOOTH_PTS = 2;
-/**
- * ШИРИНА БЕЗ ИЗЛОМОВ: ширина приходит по станциям через 2 м и после пересборки оси через метр
- * идёт ломаной — на переходе ширины (поворот на две полосы, `filletTurn`) кромка от этого шла
- * зубцами через точку. Гаусс по точкам; ровная ширина остаётся ровной (только там, где она
- * меняется, что-то и сглаживается), концы — на месте.
- */
-declare function smoothWidths(w: number[], sigma?: number): number[];
-/**
- * СКРУГЛЕНИЕ ИЗЛОМОВ ОСИ. Точки идут через равный шаг (`resampleLine`); у излома ось сглаживается
- * гауссовым окном, и только там: в пределах двух сигм от излома берётся сглаженная точка, дальше
- * за полторы сигмы — плавный возврат к исходной. Прямые участки и S-переходы (они и так гладкие)
- * остаются точно в полосе.
- *
- * Сигма — ПО УГЛУ ИЗЛОМА: поворот на перекрёстке (90°) — `CORNER_SMOOTH_M`, дуга радиусом около
- * 1.6 сигмы; пологий излом улицы (20–30°) — пропорционально меньше, иначе лента срезала бы его и
- * съезжала с полосы на кромку. Изломы ближе трёх метров друг к другу — один (на повороте осевые
- * соседних отрезков стыкуются двумя изломами со скачком между ними).
- *
- * За концами ломаная продолжается ЦЕНТРАЛЬНЫМ отражением (`2·p₀ − pₖ`): прямая остаётся прямой, а
- * крайние точки — на месте, то есть лента по-прежнему начинается ровно на конце линии маршрута.
- */
-declare function smoothCorners(pts: XY[], sigmaM?: number): XY[];
-/**
- * КОНТУР ЛЕНТЫ: правая кромка по ходу, форма конца (`caps[1]`), левая кромка обратно, форма начала
- * (`caps[0]`) — кольцо против часовой. Нормаль в точке — по хорде соседей (ось гладкая, «miter» не
- * нужен). Точка кромки, которая пошла бы назад относительно оси (кривизна круче полуширины),
- * выбрасывается: кромка не делает петлю. Концы кромок — ровно `centre ± normal · half` крайних
- * точек, от них и строится форма конца (`capPoints`).
- */
-declare function outlineOf(centre: XY[], half: number[], normals?: XY[], caps?: [RibbonCap, RibbonCap]): XY[];
-/**
- * ФОРМА КОНЦА — точки контура МЕЖДУ концами кромок (сами концы кромок — в `edgesOf`). `c` — крайняя
- * точка оси, `nrm` — нормаль вправо в ней, `h` — полуширина. Конец (`atEnd`) — от правой кромки
- * через переднюю точку к левой, начало — от левой через заднюю к правой: кольцо остаётся против
- * часовой. Полукруг `c + h·(±n·cos θ ± t·sin θ)`, θ = kπ/`CAP_SEGMENTS`: в θ = 0 касательная к
- * нему — направление оси, то есть кромка переходит в дугу без излома (ось у конца — крайний отрезок,
- * по нему и нормаль, `normalsOf`).
- */
-declare function capPoints(c: XY, nrm: XY, h: number, cap: RibbonCap, atEnd: boolean): XY[];
-/** Кромки ленты по ходу: правая и левая (то, из чего `outlineOf` собирает кольцо). */
-declare function edgesOf(centre: XY[], half: number[], normals?: XY[]): {
-    right: XY[];
-    left: XY[];
-};
-/**
- * Нормали оси вправо по ходу — по хорде соседей (у концов — по крайнему отрезку). Отдельно от
- * `outlineOf`: у двух половин ленты, разрезанной в точке машины (`lib/route-progress.ts`), нормаль
- * в точке разреза обязана быть одной — тогда кромки сходятся без щели и нахлёста.
- */
-declare function normalsOf(centre: XY[]): XY[];
-interface RoutePiece {
-    coords: LonLat[];
-    /** Для каждой точки куска — номер отрезка исходной трассы, на котором она лежит. */
-    source: number[];
-}
-/**
- * Трасса без скрытых отрезков (метры) — куски для обычной линии маршрута. На концах куска точка
- * ставится ровно на границу: линия упирается в начало ленты без щели и без нахлёста.
- */
-declare function routePieces(geometry: LonLat[], hidden: [number, number][]): RoutePiece[];
-/** Метры трассы до точек (манёвров): проекция по порядку, каждая не раньше предыдущей. */
-declare function metresAlong(geometry: LonLat[], points: LonLat[]): number[];
-/** Трасса в метрах — для ведения (точка и курс по метру). */
-declare function routeMeasure(geometry: LonLat[]): {
-    frame: Frame;
-    route: Measured;
-};
-/** Высота полотна в точке на уровне, метры. */
-type HeightAt = (p: LonLat, level: number) => number;
-/** Этаж эстакады стенда (`LEVEL_HEIGHT` у `vendor/city.js`) — запасная высота без сцены. */
-declare const LEVEL_HEIGHT_M = 8;
-declare const fallbackHeight: HeightAt;
-/**
- * Свойства высоты фичи — как у краски стенда: ровная — `lift`, со склоном — `liftPath`
- * (`lon,lat,h;…`, разбирает движок, `parseLift`). Нулевая высота — без свойства вовсе.
- */
-declare function liftProps(f: RibbonFeature, heightAt: HeightAt): Record<string, number | string>;
-/** То же по готовым отметкам точек `line` — ведение режет ленту, не спрашивая поле высот заново. */
-declare function liftPropsOf(line: LonLat[], hs: number[]): Record<string, number | string>;
-
-/**
- * ПЛАН ПОЛОС ВДОЛЬ МАРШРУТА — `POST /tiles/ldroads/guidance` (под общим ключом шлюза, как остальные
- * `/tiles/ldroads/*`; контракт — `docs/map-v2/LD-LANE-GUIDANCE.md` монорепозитория).
- *
- * Перенесено из веб-карты (`src/WebMap/src/api/lanes.ts` + `map/lane-plan.ts`) без изменения
- * поведения: типы, тело запроса (`lanePlanRequest`, как `requestFor` веба) и разбор ответа
- * (`parseLanePlan`). Пара у портов — `LanePlan.kt` / `LanePlan.swift`.
- *
- * ★ Сервис НЕОБЯЗАТЕЛЕН: нет ручки (404/405/501), ошибка, мусор в ответе, пустое покрытие — всё это
- * `null`, и карта рисует обычную линию маршрута. Сеть — у приложения: `fetchLanePlan` берёт функцию
- * `fetch` снаружи (и адрес — `Endpoints`/своя база), сам движок в сеть не ходит.
- *
- * ★ Заглушка веба `?laneMock=1` (план по опубликованным улицам на клиенте) — НЕ здесь: она про
- * отладку сайта и тянет его данные.
- */
-
-type LaneState = 'recommended' | 'allowed' | 'other';
-interface PlanLane {
-    laneId: string;
-    /** 0 — левая по ходу. */
-    index: number;
-    widthM: number;
-    /** Осевая полосы ПО ХОДУ, `[lon, lat]`. */
-    centre: [number, number][];
-    state: LaneState;
-    turns: string[];
-}
-interface PlanSegment {
-    fromM: number;
-    toM: number;
-    wayId: number | string;
-    dir: string;
-    /** 1 — эстакада, 0 — земля, −1 — тоннель. */
-    level: number;
-    /** В какой полосе лента в начале отрезка (добавочное поле сервера; у заглушки может не быть). */
-    ribbonLaneId?: string;
-    lanes: PlanLane[];
-}
-interface PlanChange {
-    fromLane: string;
-    toLane: string;
-    startM: number;
-    endM: number;
-}
-interface PlanManeuver {
-    atM: number;
-    kind: string;
-    /** Полосы, с которых манёвр выполняется по плану. */
-    laneIds: string[];
-    /** Стрелки полос подхода: что разрешено с каждой. */
-    arrows: {
-        laneId: string;
-        turns: string[];
-    }[];
-}
-interface LanePlan {
-    version: string;
-    /** Как сопоставлено: `edges` | `geometry` | `mixed` | `null` (покрытия нет). Добавочное поле. */
-    matchedBy?: string | null;
-    coverage: [number, number][];
-    segments: PlanSegment[];
-    changes: PlanChange[];
-    maneuvers: PlanManeuver[];
-}
-interface LanePlanRequest {
-    geometry: [number, number][];
-    edges?: (number | string)[];
-    graphVersion: number | null;
-    maneuvers: {
-        atM: number;
-        type: string;
-        modifier: string;
-    }[];
-}
-declare const GUIDANCE_URL = "/tiles/ldroads/guidance";
-/** Манёвр маршрута: где он и что это (как шаг `/route`: `type` + `modifier`). */
-interface RouteManeuver {
-    at: LonLat;
-    type: string;
-    modifier?: string;
-}
-/**
- * Маршрут для плана полос: трасса по ходу (`[lon, lat]`) и её манёвры. `edges` — `edgeId` шагов
- * `/route`, если они есть у приложения: с ними сервис сопоставляет точнее.
- */
-interface LaneRoute {
-    geometry: LonLat[];
-    maneuvers?: RouteManeuver[];
-    edges?: (number | string)[];
-    graphVersion?: number | null;
-}
-/**
- * Тело запроса плана: трасса и манёвры с метрами вдоль неё (как `requestFor` веб-карты). Рёбер
- * графа нет — поле опущено.
- */
-declare function lanePlanRequest(route: LaneRoute): LanePlanRequest;
-/** Ручки нет (404/405/501) — не спрашиваем снова столько времени. */
-declare const ABSENT_RETRY_MS: number;
-/** Минимум от `fetch`, который нужен запросу плана (подходит `globalThis.fetch`). */
-type FetchLike = (url: string, init: {
-    method: string;
-    headers: Record<string, string>;
-    body: string;
-    signal?: AbortSignal;
-}) => Promise<{
-    ok: boolean;
-    status: number;
-    json(): Promise<unknown>;
-}>;
-interface FetchLanePlanOptions {
-    /** Адрес ручки (по умолчанию — `GUIDANCE_URL` на своём сайте). */
-    url?: string;
-    /** Функция запроса (по умолчанию — `globalThis.fetch`). */
-    fetch?: FetchLike;
-    signal?: AbortSignal;
-}
-/**
- * Запрос плана у сервиса. Любая ошибка — `null`; нет ручки — `null` и `ABSENT_RETRY_MS` без
- * запросов (на каждый `url` свой счётчик).
- */
-declare function fetchLanePlan(req: LanePlanRequest, opts?: FetchLanePlanOptions): Promise<LanePlan | null>;
-/** Сбросить память об отсутствующей ручке (тесты, смена стенда). */
-declare function resetLanePlanAbsence(): void;
-/**
- * Ответ → план. Отбрасывается всё, что не описывает полосу или участок: рисовать по этому будет
- * движок, и мусор дешевле поймать здесь. Нет покрытия или участков — `null` (полос нет).
- */
-declare function parseLanePlan(raw: unknown): LanePlan | null;
-
-/** Зум тайлов источника ленты: `maxzoom` geojson-источника osmgl по умолчанию — 18. */
-declare const RIBBON_TILE_Z = 18;
-/** Единиц в тайле (`EXTENT` geojson-источника osmgl). */
-declare const TILE_EXTENT = 4096;
-/** Выдвиг вершины на разрезе, единиц тайла (`SURFACE_CUT_BLEED` osmgl). */
-declare const CUT_BLEED = 1;
-/** `[lon, lat]` → единицы тайла z18 во всём мире (та же меркаторская формула, что у движка). */
-declare function toUnits(p: LonLat): [number, number];
-declare function fromUnits(u: [number, number]): LonLat;
-/**
- * Отступ от границы тайла номер `k` (её координата — `k · 4096` единиц z18) у куска СПРАВА/СНИЗУ от
- * неё. Сосед слева/сверху касается границы, и движок выдвигает его на единицу своего тайла; кусок
- * справа обязан начаться ровно там же — после округления координат тайла (geojson-источник
- * округляет до целых) — и не лечь на границу сам (иначе выдвинется и он):
- *  - тайл z18: 1.2 и 0.6 округляются до 1 = выдвиг соседа;
- *  - тайл z17 (зум карты 17.5–18): у чётной границы (она же граница z17) 1.2 единицы z18 — это 0.6
- *    единицы z17, округляется до 1 = выдвиг соседа на его z17; нечётная граница лежит ВНУТРИ тайла
- *    z17, сосед там не выдвигается, и 0.6 единицы z18 = 0.3 единицы z17 округляются до нуля — кусок
- *    сходится с соседом в той же точке.
- */
-declare const cutInset: (k: number) => number;
-/**
- * Многоугольник (`[outer, ...holes]`, кольца `[lon, lat]`) → многоугольники по тайлам z18 с правилом
- * стыка `cutInset`. Целиком внутри тайла и далеко от его левой и верхней границ — как есть.
- */
-declare function tileParts(poly: LonLat[][]): LonLat[][][];
-/** Маска: многоугольники в единицах z18 с рамками — вычитаются только задетые. */
-interface Mask {
-    polys: {
-        box: [number, number, number, number];
-        geom: Geom;
-    }[];
-}
-declare function maskOf(rings: LonLat[][]): Mask;
-/** Кольцо минус маска → кольца-многоугольники (`[outer, ...holes]`). Не задето — как есть. */
-declare function minusMask(ring: LonLat[], mask: Mask): LonLat[][][];
-/** Длина куска ленты по станциям, метры: столько пересчитывается при движении машины. */
-declare const CHUNK_M = 40;
-/** Кусок площадной фичи: вид и дробный диапазон её точек; `cut` — один из концов в точке машины. */
-interface AreaSpan {
-    kind: RibbonKind;
-    from: number;
-    to: number;
-    cut?: boolean;
-}
-/**
- * Разбиение площадной фичи на куски: границы — станции, кратные `CHUNK_M` (от ведения не
- * зависят — куски без машины одни и те же, их можно хранить), и точка машины `s` (позади — `*-passed`).
- */
-declare function areaSpans(f: RibbonFeature, s: number | null, chunkM?: number): AreaSpan[];
-/**
- * Ось фичи в плоских метрах с нормалями — одна на фичу, общая для всех её кусков. `caps` — форма
- * её настоящих концов (`RibbonFeature.caps`): её получают только куски, доходящие до конца фичи.
- */
-interface AreaFrame {
-    frame: Frame;
-    xy: XY[];
-    normals: XY[];
-    widths: number[];
-    caps: [RibbonCap, RibbonCap];
-}
-declare function areaFrame(f: RibbonFeature): AreaFrame;
-/**
- * Контур куска `[from, to]` фичи: точки, нормали и ширины на концах — интерполяция соседних. Конец
- * куска на конце фичи — её формы (`AreaFrame.caps`: скругление, стрелка), на разрезе — прямой: там
- * кусок встык продолжает соседний. Форма конца — часть того же кольца, дальше — то же вычитание и
- * резка по тайлам, что у всей ленты.
- */
-declare function spanOutline(af: AreaFrame, from: number, to: number): LonLat[];
-/** Ось куска `[from, to]` — `[lon, lat]`, для свойств высоты. */
-declare const spanLine: (f: RibbonFeature, from: number, to: number) => LonLat[];
-
-/**
- * ПРОЙДЕННАЯ ЧАСТЬ МАРШРУТА — СЕРАЯ (как у Baidu: позади машины линия и лента по полосам серые,
- * впереди — синие или цветом пробок; граница — ровно в точке машины).
- *
- * Чистые функции без движка (проверка — `route-progress.test.ts` и общие фикстуры
- * `tests/fixtures/ld-lane-ribbon/`, их же гоняют порты Android и iOS). Метр прогресса — метр
- * трассы той же мерой, что у плана полос и ведения: плоская формула на звено (`linkM`).
- *
- * ★ ЛИНИЯ: синяя линия маршрута остаётся ЦЕЛОЙ, серая пройденная кладётся ПОВЕРХ неё (кусками вне
- * ленты по полосам). Резать синюю нельзя: шевроны движок ставит от начала линии, и у линии,
- * укорачиваемой с начала, стрелки ехали бы вместе с машиной. Под серой (непрозрачной) синие
- * шевроны не видны.
- *
- * ★ ЛЕНТА: площадные фичи (`band`, `allowed`) режутся в точке машины на две — пройденную
- * (`*-passed`, серая) и оставшуюся, с ОДНОЙ нормалью в точке разреза: кромки сходятся без щели и
- * нахлёста. Шевроны целиком позади выбрасываются; шеврон, на котором машина, остаётся целым (по той
- * же причине, что у линии) — его пройденную часть закрывает серая лента, слой которой выше
- * шевронов, — там стрелки бледные.
- */
-
-/** Трасса с накопленными метрами к каждой точке (мерой сервера, `linkM`). */
-interface RouteLine {
-    geometry: LonLat[];
-    cum: number[];
-    length: number;
-}
-declare function routeLine(geometry: LonLat[]): RouteLine;
-/**
- * Точка трассы на метре `s`. Доля по звену — по его длине мерой сервера, сама точка — в градусах:
- * плоская система метров аффинна градусам, так что это та же точка, что у `routePieces`.
- */
-declare function pointOn(line: RouteLine, s: number): LonLat;
-/** Кусок трассы между метрами (концы — точно на метрах). Короче `minM` — пусто. */
-declare function lineBetween(line: RouteLine, from: number, to: number, minM?: number): LonLat[];
-/** Пройденный кусок короче этого не рисуется (его и так закрывает метка машины). */
-declare const PASSED_MIN_M = 0.5;
-/**
- * Пройденные куски ОБЫЧНОЙ линии: трасса вне ленты по полосам (`hidden`, как у `routePieces`) от
- * начала до метра `s`. Пусто — ничего не пройдено (или всё пройденное — под лентой).
- */
-declare function passedPieces(line: RouteLine, hidden: [number, number][], s: number): LonLat[][];
-/**
- * Положение метра `s` среди станций (не убывают): дробный номер точки в `[0, n − 1]`. На ровном
- * месте (повтор станции) — первая точка после него.
- */
-declare function fracIndex(stations: number[], s: number): number;
-/**
- * Значения точек между дробными номерами `a` и `b`: значение на `a`, все целые строго между,
- * значение на `b`. Так режутся и ось, и атрибуты точек (ширина, уровень, станция, высота).
- */
-declare function sliceAt<T>(values: T[], a: number, b: number, mix: (x: T, y: T, t: number) => T): T[];
-declare const mixNum: (x: number, y: number, t: number) => number;
-declare const mixLevel: (x: number, y: number, t: number) => number;
-declare const mixLonLat: (x: LonLat, y: LonLat, t: number) => LonLat;
-/** Пройденный вид площадной фичи. */
-declare const passedKind: (k: RibbonKind) => RibbonKind;
-/** Кусок ленты на карте: фича и откуда она взята — номер исходной и дробный диапазон её точек. */
-interface RibbonPiece {
-    feature: RibbonFeature;
-    source: number;
-    from: number;
-    to: number;
-}
-/**
- * ЛЕНТА НА МЕТРЕ ВЕДЕНИЯ `s`: позади — серая, впереди — как была. `null` — ведения нет, лента
- * целиком цветная. Фичи без станций остаются как есть.
- */
-declare function ribbonAtProgress(features: RibbonFeature[], s: number | null): RibbonPiece[];
-/**
- * Что из данных ленты меняется на метре `s`: число фич целиком позади и есть ли фича, которую
- * режет точка машины. Пока это не меняется, данные источника заново не заливаются.
- */
-declare function ribbonProgressState(features: RibbonFeature[], s: number | null): {
-    passed: number;
-    cut: boolean;
-};
-
-/**
- * ВЕДЕНИЕ ПО ПОЛОСАМ — что показать на метре маршрута: следующий манёвр, ряд стрелок полос и
- * камеру (наклон и приближение у манёвра внутри покрытия, как у Baidu).
- *
- * Чистые функции (проверка — `lane-guidance.test.ts`). ★ Подсказка говорит, КУДА ВСТАТЬ, и никогда
- * — «вы в полосе N»: своей полосы карта не знает (точности приёмника на это не хватает).
- */
-
-/** Ближе этого к манёвру внутри покрытия камера наклоняется и приближается. */
-declare const CLOSE_M = 300;
-declare const FAR_VIEW: {
-    pitch: number;
-    zoom: number;
-};
-declare const CLOSE_VIEW: {
-    pitch: number;
-    zoom: number;
-};
-/** Ряд стрелок подсказки дальше этого не показывается: заранее он только отвлекает. */
-declare const HINT_M = 600;
-/** Манёвр плана впереди (или только что пройденный — пока не отъехали `AFTER_M`). */
-declare function upcoming(plan: LanePlan | null, s: number): PlanManeuver | null;
-/** Доля «близкого вида» 0..1 на метре `s`. */
-declare function closeness(plan: LanePlan | null, s: number): number;
-/** Наклон и зум камеры ведения на метре `s`. */
-declare function guidanceCamera(plan: LanePlan | null, s: number): {
-    pitch: number;
-    zoom: number;
-    close: number;
-};
-interface HintLane {
-    laneId: string;
-    turns: string[];
-    /** Сюда вставать: полоса из `laneIds` манёвра. */
-    recommended: boolean;
-    /** Тоже годится, но план её не выбрал (`allowed` на подходе). */
-    allowed: boolean;
-}
-interface LaneHint {
-    atM: number;
-    kind: string;
-    lanes: HintLane[];
-}
-/**
- * Ряд стрелок для манёвра: полосы подхода (участок, на котором стоит манёвр) слева направо,
- * стрелки — из `arrows` манёвра, иначе — у самой полосы.
- */
-declare function hintFor(plan: LanePlan | null, m: PlanManeuver | null): LaneHint | null;
-/** Подсказка на метре `s`: только если манёвр ближе `HINT_M`. */
-declare function hintAt(plan: LanePlan | null, s: number): (LaneHint & {
-    distanceM: number;
-}) | null;
-/**
- * Ряд стрелок у точки манёвра (шаг списка манёвров приложения): манёвр плана в 25 м от точки по трассе
- * `geometry` (`hintForStep` веб-карты, `laneHintAt` портов). `null` — у шага полос нет.
- */
-declare function hintNear(plan: LanePlan | null, geometry: LonLat[], at: LonLat): LaneHint | null;
-/** Кадр ведения: камера и что показать (`guideStep` веб-карты). */
-interface GuideFrame {
-    center: LonLat;
-    zoom: number;
-    pitch: number;
-    bearing: number;
-    /** Доля «близкого вида» 0..1. */
-    close: number;
-    /** Курс по маршруту, градусы, — для своей метки «я здесь». */
-    courseDeg: number;
-    /** Метр камеры (сглаженный метр ведения): до него линия и лента серые, на нём — значок. */
-    s: number;
-}
-/**
- * ВЕДЕНИЕ ПО ПЛАНУ — метр маршрута и камера, как `stores/lanes.ts` (`advance`, `locate`) и `guideStep`
- * (`MapView.vue`) веб-карты, одним классом без карты и часов: приложение зовёт `locate` на каждую
- * геолокацию или `advance` в демо-проезде, а на каждый кадр — `step(dt)` и ставит камеру из ответа.
- * Камера сглаживается по кадрам: скачок наклона на пороге читался бы рывком. Пара у портов — `LaneGuide`
- * (Kotlin) и `navigram/lane_guide` натива; сверка — `kmp/fixtures/lane-guide.json`.
- */
-declare class LaneGuide {
-    readonly plan: LanePlan | null;
-    readonly measure: {
-        frame: Frame;
-        route: Measured;
-    } | null;
-    /** Метр маршрута, на котором «мы». */
-    progressM: number;
-    private cam;
-    private started;
-    constructor(plan: LanePlan | null, geometry: LonLat[]);
-    get lengthM(): number;
-    /** Начать с текущей камеры (наклон, зум): вход в ведение плавный, курс — по ходу с упреждением 30 м. */
-    start(pitch: number, zoom: number, fromM?: number): void;
-    /** Демо-проезд: шаг времени (секунды); у манёвра притормаживает, как машина на повороте. false — доехали. */
-    advance(dt: number, speedMps?: number): boolean;
-    /** Геолокация → метр маршрута (окно вперёд: назад по трассе не прыгаем). false — дальше 60 м от трассы. */
-    locate(pos: LonLat): boolean;
-    /** Подсказка полос на метре ведения — для панели приложения. */
-    hint(): (LaneHint & {
-        distanceM: number;
-    }) | null;
-    /** Камера на кадр. `follow` — метр камеры догоняет метр ведения сразу (демо), иначе плавно. */
-    step(dtSec: number, follow?: boolean): GuideFrame | null;
-}
-
-/**
- * ПОЛОТНО ДОРОГ — ОТДЕЛЬНЫЙ НАБОР ТАЙЛОВ.
- *
- * Перенесено из `src/WebMap/src/lib/roadbed-layer.ts` (04.10.2026) — одно место на веб-карту и
- * редактор стилей админки: пресет «Карта navi.gram.tj» собирается этим же кодом, и асфальт в нём
- * ровно тот, что рисует публичная карта. Тот же код у Kotlin (`navigram/Roadbed.kt`) и Swift
- * (`Navigram/Roadbed.swift`); общий эталон — `kmp/fixtures/navigram.json`.
- *
- * В общих тайлах v3 дорога — линия: у неё есть класс, имя и ширина в пикселях, но нет ни кромки,
- * ни перекрёстка, ни разметки. Здесь же лежат готовые ФИГУРЫ: асфальт с бордюром, пятно
- * перекрёстка, скруглённый бордюром угол, краска по кромкам, эстакада с подходами.
- *
- * Считаются они не здесь и не по тайлам, а на сервере, один раз на весь регион
- * (`deploy/rebuild-roadbed-tiles.sh`). Иначе никак: полотно строится по ГРАФУ всей сети — куски
- * склеиваются в улицы, перекрёстки накрываются общим пятном, подход к эстакаде тянется на сотни
- * метров. В тайл это не помещается: на z16 тайл — полкилометра, а буфер вокруг него — метры, и с
- * двух сторон общей границы вышли бы разные перекрёстки и разорванная разметка.
- *
- * Линии дорог при этом никуда не деваются: на мелком плане полотно тоньше пикселя, и до z15 карта
- * рисует их как раньше. Выше они УСТУПАЮТ полотну (`yieldTo`, см. `REPLACED`), а не гаснут.
- */
-/**
- * Полотно приходит с потолка z16 и растягивается выше. Набор собран с z15, но берём его только с z16
- * (см. `BED_FROM`): тайлы z15 не нужны, раз полотно на этом зуме не рисуется.
- *
- * Ниже z15 полотна в наборе нет ВОВСЕ.
- *
- * Не «нет в стиле», а нет в тайлах: на z13 тайл — это пять километров, и слитый контур сети целого
- * города, обрезанный по нему, весит десятки мегабайт. Показывать его всё равно не на чем — до z15
- * карта рисует дороги линиями (см. `BED_FROM`), — поэтому такие тайлы просто не собираются.
- */
-declare function roadbedSource(url: string): {
-    url: string;
-    minzoom: number;
-    maxzoom: number;
-};
-/** Имя источника полотна. */
-declare const ROADBED_SOURCE = "roadbed";
-/** Адрес полотна относительно сайта (`Endpoints.roadbed` у пустой базы). */
-declare const ROADBED_URL = "/tileserver/data/roadbed/{z}/{x}/{y}.pbf";
-/**
- * КРАСКА ПОЛОТНА — БОЛЬШЕ НЕ РИСУЕТСЯ (решение владельца, 23.10.2026).
- *
- * В наборе полотна есть своя разметка (`roadmark`: осевые, полосы, кромки, стоп-линии, зебры;
- * `roadarrow`: стрелки), но она грубая — построена по графу OSM, а не нарисована. Разметку на карте
- * теперь даёт только сервис детальных дорог (`ldroads`, слои `ld-mark-*`), как веб-карта с `mark=0`:
- * там, где улицы нарисованы в редакторе, она точная, а где не нарисованы — асфальт без краски.
- *
- * Слоёв краски полотна в стиле нет вовсе — не «спрятаны», а не добавлены: спрятанный слой воркер всё
- * равно собирает (тайл кешируется на все случаи), а телефону это лишние вершины в каждом тайле z16.
- *
- * Список оставлен пустым для выключателя «Разметка» приложений и веб-карты: зебры набора точек
- * (`crossing`) он по-прежнему гасит, а краски полотна гасить больше нечего.
- */
-declare const ROADMARK_LAYER_IDS: string[];
-/**
- * РЕЖИМ ПОЛОТНА: «один уровень» или «с высотами» (переключатель в «Слоях»).
- *
- * Разница не только в высоте, но и в самих фигурах: в одном уровне вся сеть — плоская сетка стенда
- * (`roadMesh`), с высотами — наземная сетка без поднятых участков и сами поднятые участки с
- * профилем подъёма. Поэтому режим живёт В ДАННЫХ: генератор (`deploy/roadbed/build.mjs`) метит
- * фигуру свойством `mode` — `both` (общее), `flat` или `lift`, — а стиль берёт общее и своё.
- * Фигура без метки (набор, собранный до разделения) видна в обоих режимах.
- */
-type RoadbedMode = 'flat' | 'lift';
-/** Фильтры всех делящихся слоёв для режима — их ставит `setRoadbedMode` в движке карты. */
-declare function roadbedModeFilters(mode: RoadbedMode): Record<string, unknown[]>;
-/** Слои полотна — по ним переключатель растровой подложки понимает, что гасить. */
-declare const ROADBED_LAYER_IDS: string[];
-/**
- * ПРЕЖНИЕ ЦВЕТА ПОЛОТНА — СВОИМИ ХЕКСАМИ, ДЛЯ ТЕХ ПАЛИТР, КОМУ ССЫЛКА НЕ ИДЁТ.
- *
- * Обычно асфальт берёт цвет дорог у темы (см. `bedLayer`), и это правильно: улица не должна менять
- * масть на границе зумов. Но тема вольна ставить дорогам цвет, который годится ЛИНИИ и не годится
- * ПОЛОСЕ: у ледяной палитры дороги золотые (#ffd86b), и полотно по ним выходит песчаным полем
- * вместо асфальта.
- *
- * Такие палитры и получают этот набор — ровно то, чем полотно было до перехода на тему.
- * Накладывается он как обычная правка темы, по id слоя (`paint[id]` темы v2). Имена — формата v2
- * (osmgl 0.20): у слоя `surface` цвет асфальта — `osmgl-surface-color`, борт —
- * `osmgl-surface-side-color`; прежние `color`/`sideColor` движок ещё понимает, но с предупреждением.
- */
-declare const ROADBED_FIXED_PAINT: Record<string, Record<string, unknown>>;
-/**
- * Полотно поверх базового стиля.
- *
- * Слои встают СРАЗУ ЗА линиями дорог, а не в конец списка: выше них идут подписи, щиты и всё, что
- * дорога несёт на себе, — уехав в конец, асфальт накрыл бы их собой.
- */
-/**
- * `mode` — начальный режим полотна. Он входит в стиль сразу, а не ставится фильтрами после
- * создания карты: смена фильтров до первой загрузки заставляла движок начинать заново, и карта
- * с `lift=1` в адресе полминуты стояла пустой (прод, 28.09.2026).
- */
-/** Источники поверхностей земли: всё это под полотном, а не поверх него. */
-declare const GROUND_LAYERS: string[];
-/** Выше этого земля под полотном не поднимается: асфальт — 0.09 (метры; см. отметку полотна). */
-declare const GROUND_TOP = 0.05;
-/**
- * ЗЕМЛЯ — ПОД ПОЛОТНОМ, И ПОРЯДОК ВНУТРИ НЕЁ ТОТ ЖЕ.
- *
- * Городской стиль поднимает зелень и площадки ради рельефа: парковка 0.19 м, лес 0.175, парк 0.15.
- * Полотно дорог лежит на 0.15 (тогда и тротуар полотна — на 0.12), и всё, что выше, НАКРЫВАЛО асфальт там, где контур
- * парковки или леса заходит на проезжую часть, а парк стоял с асфальтом вровень и мерцал (телефон,
- * дорога вдоль парковки, 08.10.2026). Детальный асфальт (`ld-lift.mjs`, верх 0.25) при этом выше
- * обоих — его не трогаем.
- *
- * Чинится здесь, а не в базовом стиле: конфликт есть только там, где есть полотно, а базовый стиль
- * живёт и без него (и его эталоны у всех платформ). Поверхности земли сжимаются ОДНИМ множителем так,
- * чтобы самая высокая встала на `GROUND_TOP`: порядок и доли между ними сохраняются, рельеф остаётся
- * читаемым. Вместе с отметкой масштабируются основание и спуск фаски — иначе фаска выйдет выше верха.
- */
-declare function groundUnderBed(layers: StyleLayerSpec[]): StyleLayerSpec[];
-declare function roadbedStyle(base: StyleSpec, url?: string, mode?: RoadbedMode): StyleSpec;
-/**
- * Слои полотна в этом стиле — по ИСТОЧНИКУ.
- *
- * Их несколько (асфальт, тоннель), и список имён, набранный руками,
- * устаревал бы с каждой правкой раскладки.
- */
-declare function roadbedLayerIds(style: StyleSpec): string[];
-
-/**
- * Откуда берутся данные.
- *
- * `base` — адрес сайта без хвостового `/`. ПУСТАЯ база даёт адреса ОТНОСИТЕЛЬНЫЕ — так их пишет
- * веб-карта: в проде их разводит шлюз, в разработке — прокси Vite, и сборка не привязана к домену.
- * Приложению без шлюза база нужна полная. Ключ добавляется КО ВСЕМ адресам данных: шлюз проверяет
- * его и у тайлов, и у шрифтов, и у пробок.
- */
-declare class Endpoints {
-    readonly base: string;
-    readonly key: string;
-    constructor(base?: string, key?: string | null);
-    /** Есть ли вообще сеть. Пусто — у приложения (у веба база пустая, но шлюз есть всегда). */
-    get online(): boolean;
-    /**
-     * Наш ли это сервер — тот, которому положен ключ портала: происхождение адреса (схема, хост, порт)
-     * равно происхождению базы. Только целиком: по началу строки (`startsWith(base)`) ключ уходил и
-     * `https://navi.gram.tj.evil.com/…`, и `https://navi.gram.tjx/…`. Путь не сравнивается: ключ
-     * проверяет шлюз, а он у происхождения один.
-     */
-    owns(url: string): boolean;
-    url(path: string): string;
-    get apiKey(): string | null;
-    get tiles(): string;
-    get fonts(): string;
-    get roadbed(): string;
-    get traffic(): string;
-    get raster(): string;
-    get model3d(): string;
-    /** База сервиса моделей: ключ он подставляет во все свои адреса сам. */
-    get objects3d(): string;
-}
-/**
- * ПРОИСХОЖДЕНИЕ АДРЕСА — `схема://хост:порт` в нижнем регистре, порт по умолчанию числом (http 80,
- * https 443); не абсолютный адрес или сомнительный — `null`. По нему и только по нему решается, кому
- * уходит ключ портала (`Endpoints.owns`).
- *
- * Разбор свой, а не `new URL()`: тот же текст стоит в портах (`originOf` у Kotlin, Swift и натива),
- * и ответ обязан совпадать до символа. Поэтому всё, что разные разборщики понимают по-разному,
- * отбрасывается, а не угадывается: данные пользователя (`user@host` — у браузера хост ПОСЛЕ `@`),
- * обратная косая в имени хоста (у браузера это путь, у HTTP-клиента — как повезёт), `%`, пробелы,
- * не-ASCII. Чужому серверу при этом ключ точно не уйдёт, своему — только по чистому адресу.
- */
-declare function originOf(url: string): string | null;
-/** Адреса относительно сайта — то, что пишет веб-карта (и стиль, опубликованный с сайта). */
-declare const SITE_ENDPOINTS: Endpoints;
-/**
- * Дополнительные наборы тайлов.
- *
- * У основного потолок z14, поэтому мелкие зумы берутся из мирового набора, а планы этажей и точки
- * живут отдельно: они пересобираются на порядки чаще и по другому расписанию.
- *
- * Потолок точек 16, а не 14: точке хватало и четырнадцатого — её рисуют значком постоянного
- * размера, — а зебра перехода лежит НА асфальте, и её полоса в 0,6 м на z14 схлопывается в единицу
- * тайла (см. deploy/rebuild-navpoints-tiles.sh). Выше шестнадцатого движок растягивает сам.
- */
-declare function naviGramSources(at: Endpoints): Record<string, {
-    url: string;
-    minzoom: number;
-    maxzoom: number;
-}>;
-/**
- * Стиль карты: «объёмный город» + полотно дорог + пробки + растровая подложка (обе выключены).
- *
- * Основа — `CITY_STYLE`: рельеф (зелень приподнята, вода утоплена) со скруглёнными углами и
- * сплошными материалами. Он собран ПОД ТЕНИ, и включать их надо вместе с ним: без теней его уровни
- * и фаски видно только на просвет.
- *
- * ПОЛОТНО ДОРОГ добавляется ПЕРВЫМ, до пробок и подложки: оно гасит линейные слои проезжей части
- * выше своего зума, и делать это надо по исходному стилю, пока к нему не примешались чужие слои с
- * похожими именами.
- *
- * `mode` — начальный режим полотна. Он входит в стиль сразу, а не ставится фильтрами после
- * создания карты: смена фильтров до первой загрузки заставляла движок начинать заново, и карта с
- * `lift=1` в адресе полминуты стояла пустой (прод, 28.09.2026).
- */
-declare function cityStyle(at?: Endpoints, mode?: RoadbedMode): StyleSpec;
-/**
- * ТОТ ЖЕ НАБОР СЛОЁВ, НО НА РЕЛЬЕФЕ.
- *
- * Рельеф у движка — это не покраска, а другой способ рисовать землю: плоские слои уезжают в
- * текстуру тайла, и она натягивается на сетку высот. Поэтому это отдельный стиль, а не тумблер: в
- * нём нет объёмных поверхностей (они рисуются мимо драпировки и остались бы лежать на нуле) и есть
- * источник высот. Пробки и растровая подложка добавляются к нему так же, как к обычному.
- *
- * ПОЛОТНА ДОРОГ ЗДЕСЬ НЕТ по той же причине, по которой нет прочих объёмных поверхностей: оно
- * рисуется мимо драпировки и осталось бы лежать на нуле, пока земля под ним уходит в гору.
- */
-declare function terrainStyle(at?: Endpoints): StyleSpec;
-/**
- * Адреса тайлов стиля от корня сервера (`/tileserver/...`) — через `Endpoints.url`, как у остальных
- * источников NaviGram (пара — `withAbsoluteTiles` у Swift, там правка была раньше). В браузере такой
- * адрес достраивает сама страница, на телефоне его нужно достроить явно: иначе у стиля рельефа источник
- * высот не грузился вовсе, и решётка рельефа оставалась плоской — на Android рельефная тема была плоской
- * картой с голубой пеленой тона низин (15.10.2026). У веба база пустая и ключа нет — адреса те же.
- */
-declare function withAbsoluteTiles(style: StyleSpec, at: Endpoints): StyleSpec;
-/**
- * Светлая и тёмная темы карты.
- *
- * Светлая — «объёмная» палитра GramMaps: у неё дома и земля разведены по тону так, что тень от дома
- * ложится на видимую поверхность, а не на такое же пятно. Тёмная — ночная, с той же геометрией.
- */
-declare const THEME_LIGHT: string;
-declare const THEME_DARK: string;
-/**
- * Те же две темы, но СТЕКЛО В ТОН СТЕНЕ.
- *
- * Синее остекление задаёт фасаду второй цвет, и на плотной застройке город читается сеткой окон, а
- * не домами. Кому нужен спокойный фасад, тот включает эту пару: рельеф дому остаётся от откосов и
- * теней, а контраст уходит. Темы выведены движком из основных, поэтому палитра у них общая.
- */
-declare const THEME_LIGHT_TONE: string;
-declare const THEME_DARK_TONE: string;
-/**
- * Ледяная — ОТДЕЛЬНЫЙ стиль, а не вариант светлой: у неё своя палитра целиком (земля, дороги, вода,
- * зелень) и нет окон вовсе, поэтому и «окна в тон» ей нечего менять.
- */
-declare const THEME_ICE: string;
-/** Та же ледяная, но со стеклом в тон стене — как `3d-tone` у светлой. */
-declare const THEME_ICE_TONE: string;
-/**
- * АТЛАС — пара от дизайнера, перенесённая из его стиля MapLibre. Стоит особняком: в автоматическую
- * смену по солнцу не встаёт, палитру человек выбирает сам.
- */
-declare const THEME_ATLAS_DAY: string;
-declare const THEME_ATLAS_NIGHT: string;
-/** Атласная ли это палитра — обе её половины. */
-declare function isAtlasTheme(theme: string): boolean;
-/** Ледяная с учётом тумблера «окна в тон». */
-declare function iceThemeFor(inTone: boolean): string;
-/** Ледяной ли это стиль — оба его варианта. */
-declare function isIceTheme(theme: string): boolean;
-/** Тема с учётом тумблера «окна в тон»: пара выбирается по светлоте, вариант — по признаку. */
-declare function themeFor(dark: boolean, inTone: boolean): string;
-declare function themeV2(name: string): ThemeSpecV2 | null;
-/**
- * ТЕМА, ДОВЕДЁННАЯ ДЛЯ ПОЛОТНА.
- *
- * Асфальт красится цветом дорог темы, и почти везде это то, что нужно. У ледяной палитры — нет:
- * дороги в ней золотые, и полоса асфальта шириной в улицу читается песком, а не покрытием. Поэтому
- * ей возвращается прежний набор цветов полотна, обычной правкой темы по id слоя. Остальным темам —
- * их имя как есть.
- *
- * Правка живёт здесь, а не в самой теме движка: слоёв полотна нет в базовом стиле, они появляются
- * только у карты (`roadbedStyle`), и тема движка про них знать не должна.
- */
-declare function themeForRoadbed(theme: string): string | ThemeSpecV2;
-/**
- * Довести ПОСЧИТАННУЮ тему до варианта «окна в тон».
- *
- * Тема на момент суток получается смешиванием светлой с тёмной, готового варианта у неё нет.
- * Правится ровно то же, что и у самих вариантов: цвет стекла берётся у стены, свечение гасится.
- */
-declare function withWindowsInTone(theme: ThemeSpecV2, dark: number): ThemeSpecV2;
-/**
- * Тёмная ли тема карты — по её СОБСТВЕННОМУ фону, а не по имени.
- *
- * За этим идёт тема интерфейса: белая панель поверх ночной карты слепит. Имена сравнивать
- * бесполезно — тем два десятка, и «светлая» среди них не одна.
- */
-declare function isDarkTheme(theme: string, style: StyleSpec): boolean;
-/**
- * Детальные 3D-объекты: раскладка слоя размещений.
- *
- * С z17 — НА ЗУМ ПОЗЖЕ объёмных домов (30.09.2026, ради нагрузки на телефон). Дома встают объёмом
- * с z16, поэтому одинокого дворца посреди плоской карты не бывает: ниже порога модели нет, и на её
- * месте стоит обычный дом. И СРАЗУ В ПОЛНОЙ ГЕОМЕТРИИ: упрощённый lod1 у порога показа читается
- * как брак. БЮДЖЕТ оставлен движку: кадр сажает КОЛИЧЕСТВО объектов, а не их подробность.
- */
-declare const OBJECTS3D_LAYOUT: {
-    readonly minZoom: 17;
-    readonly fullDetail: true;
-};
-/** Источник размещений 3D-объектов и слой моделей в стиле карты. */
-declare const OBJECTS3D_SOURCE = "model3d";
-declare const OBJECTS3D_LAYER_ID = "objects3d";
-/**
- * Источник размещений: набор `model3d` собран ровно на z14 (`-Z14 -z14`), поэтому нижний зум равен
- * верхнему — с `minzoom: 0` на каждый покрывающий тайл ниже четырнадцатого уходил бы запрос-404.
- * Сервис моделей — свойство источника: номера файлов в тайле имеют смысл только у него.
- */
-declare function objects3dSource(at?: Endpoints): SourceSpec;
-/**
- * СТИЛЬ С ДЕТАЛЬНЫМИ 3D-ОБЪЕКТАМИ — слоем стиля, а не опцией карты (04.10.2026).
- *
- * Пока объекты задавались опцией `objects3d`, в редакторе стилей их не было вовсе: превью не рисовало
- * ни светофоров, ни фонарей, а спрятать или настроить их из стиля было нечем. Слой тот же, что прежде
- * собирала из опции карта (`objects3d` на источнике `model3d`), и с той же раскладкой
- * (`OBJECTS3D_LAYOUT`: порог z17 — порогом слоя, сразу полная геометрия), поэтому облик карты не
- * меняется; опция у карты, если она ещё задана, при таком слое как слой не действует.
- *
- * Ставится последним: модели рисует свой проход вместе со зданиями, и место в списке на облик не
- * влияет, а в дереве редактора слой оказывается сверху, где его и ищут.
- */
-declare function withObjects3D(style: StyleSpec, at?: Endpoints): StyleSpec;
-/**
- * Высота, на которой лежат объекты приложения поверх карты, метры.
- *
- * Земля в этом стиле не совсем плоская: дороги подняты на 0,18…0,225 м, лес — на 0,175, и всё это
- * рисуется в проходе объёма с записью глубины. Маршрут на нулевой высоте оказался бы ПОД дорогой,
- * по которой идёт. Четверть метра кладёт его поверх всей этой геометрии и ниже любого дома.
- */
-declare const OVERLAY_ALTITUDE = 0.28;
-
-/**
- * ДЕТАЛЬНЫЕ ДОРОГИ И ЛЕНТА ПОЛОС В СТИЛЕ КАРТЫ — чистая часть: разбор ответов сервиса
- * (`/tiles/ldroads/index`, `/tiles/ldroads/style.json`), вставка их слоёв в стиль карты, слои и
- * данные ленты по полосам. Пара у портов — `LdRoads.kt` / `LdRoads.swift` (те же имена).
- *
- * ★ СЦЕНА ЗДЕСЬ НЕ СТРОИТСЯ. Веб-карта (`src/WebMap/src/map/ld-roads.ts`) собирает полотно улиц
- * редактора у себя (воркер стенда) и режет асфальт своим протоколом — это остаётся у неё. Здесь —
- * контракт для приложений (`docs/map-v2/LD-MOBILE.md`): слои — `style.json` сервиса (формат osmgl
- * v1, id `ld-*`, источник `ld-roads`), данные — векторные тайлы z14–16, асфальт — уже обрезанный
- * под скрытыми дорогами (`/tiles/ldroads/roadbed/…` вместо URL источника `roadbed`). Сеть — у
- * приложения.
- *
- * ★ СЛОИ ВСТАЮТ СРАЗУ ЗА ПОЛОТНОМ КАРТЫ (за `roadbed`; до 23.10.2026 — за его краской `roadarrow`,
- * которой больше нет) — под дома, подписи и пробки; лента полос — сразу за ними (на их асфальте).
- * Разметка карты — ТОЛЬКО их (`ld-mark-*`): краски полотна в стиле нет (`ROADMARK_LAYER_IDS`).
- *
- * Слои ленты, `withLaneRibbon`, поле высот `heightsFromScene` и данные источника (`RibbonGeoJson`)
- * перенесены из `src/WebMap/src/map/lane-ribbon.ts` без изменения поведения.
- */
-
-type Layer = Record<string, unknown>;
-/** Источник детальных дорог. Слои `style.json` сервиса ссылаются на него. */
-declare const LD_SOURCE = "ld-roads";
-/** Приставка id слоёв детальных дорог. */
-declare const LD_LAYER_PREFIX = "ld-";
-/**
- * Слой полотна карты, за которым встают детальные дороги: асфальт (`roadbed`) — последний слой полотна.
- * Был `roadarrow` (стрелки краски полотна); краски в стиле больше нет. `style.json` сервиса по-прежнему
- * подсказывает `insertAfter: roadarrow` — клиенты это поле не читают.
- */
-declare const LD_AFTER = "roadbed";
-declare const LD_INDEX_PATH = "/tiles/ldroads/index";
-declare const ldStylePath: (version: string) => string;
-declare const ldRoadbedPath: (version: string) => string;
-/**
- * Адрес из ответа сервиса (как `Endpoints.resolve` портов): относительный (`/tiles/…`) — от базы и с
- * ключом, абсолютный на нашу базу — с ключом, если его там нет, чужой — как есть.
- *
- * «На нашу базу» — то же происхождение (`Endpoints.owns`), а не то же начало строки: по началу ключ
- * получал `https://navi.gram.tj.evil.com/…`. `//хост/…` — адрес БЕЗ схемы на чужой хост, а не путь
- * от корня: базу к нему не приставляем и ключ не даём.
- */
-declare function resolveUrl(at: Endpoints, pathOrUrl: string): string;
-/** Индекс участков: версия и сколько их. Пустой набор — детальных дорог нет нигде. */
-interface LdIndex {
-    version: string;
-    areas: number;
-}
-/** Индекс (текст или разобранный JSON) → версия и число участков; не наш ответ — `null`. */
-declare function parseLdIndex(json: string | unknown): LdIndex | null;
-/** Слои детальных дорог от сервиса: источник (адрес уже полный) и слои. */
-interface LdStyle {
-    version: string;
-    tiles: string;
-    minzoom: number;
-    maxzoom: number;
-    layers: Layer[];
-}
-/** Приставка слоёв разметки детальных дорог. */
-declare const LD_MARK_PREFIX = "ld-mark-";
-/**
- * ★ РАЗМЕТКА ДЕТАЛЬНЫХ ДОРОГ ПРОЯВЛЯЕТСЯ, А НЕ ВКЛЮЧАЕТСЯ (25.10.2026). У слоёв разметки сервиса (`ld-mark-*`: стрелки
- * полос, зебры, стоп-линии, линии полос) `minzoom` 17.5, а камера ведения у манёвра проходит этот зум туда и обратно
- * (`NAV_VIEW.ZOOM_MIN…ZOOM_MAX` 15.6–18.8): вся разметка, и прежде всего белые стрелки полос у перекрёстка, появлялась и
- * пропадала РАЗОМ за кадр — жалоба владельца «на поворотах мигают белые стрелки». Замер натива `ld_arrow_flicker_test`
- * (зум 17.5 ± 0.25, Худжанд): пикселей стрелок 136 → 0 за один кадр. Теперь ниже порога на `LD_MARK_FADE_ZOOM` уровня
- * разметка проявляется по зуму (`opacity` 0 → своя). Слой со своей прозрачностью-выражением не трогается.
- */
-declare const LD_MARK_FADE_ZOOM = 0.35;
-/**
- * `style.json` сервиса → слои. Адрес тайлов приводится к полному (`resolveUrl`: база и ключ). Нет
- * адреса или слоёв — `null`: стиль карты не трогаем.
- */
-declare function parseLdStyle(json: string | unknown, at: Endpoints): LdStyle | null;
-/** Источник детальных дорог для стиля. */
-declare function ldSource(ld: LdStyle): {
-    url: string;
-    minzoom: number;
-    maxzoom: number;
-};
-/**
- * Стиль карты с детальными дорогами: их источник и слои за полотном (`roadbed`), асфальт — с
- * обрезанного адреса (`roadbedUrl`). Стиль без полотна (рельеф) не трогается — возвращается тот же
- * объект: детальным улицам там не на чем лежать.
- */
-declare function withLdRoads(style: StyleSpec, ld: LdStyle, roadbedUrl?: string | null): StyleSpec;
-/** Id слоёв детальных дорог в стиле — для выключателей. */
-declare function ldLayerIds(style: StyleSpec): string[];
-/** Источник ленты (GeoJSON приложения). */
-declare const LANE_SOURCE = "lane-ribbon";
-/**
- * С этого зума линия маршрута уступает ленте. Ниже полоса (3–3.5 м) уже тоньше линии маршрута
- * (9 px ≈ 4 м на z18, 8 м на z17) — лента читалась бы бледной ниткой; у Baidu полосный вид тоже
- * включается только на крупных зумах (`docs/map-v2/ROUTE-LINE-BAIDU.md`).
- */
-declare const LANE_MIN_ZOOM = 17.5;
-/**
- * ПЛОЩАДЬ ЛЕНТЫ ОБЪЕКТАМИ КАРТЫ (`RibbonAreas`): цвет, прозрачность и порядок каждого вида. Порядок —
- * между невыбранными вариантами (10) и линией маршрута (20), над границей прохода (`ROUTE_OVERLAY_Z`, 15):
- * лента закрывает невыбранные варианты, линия, пройденная часть и стрелки поворотов лежат на ней.
- */
-declare const RIBBON_AREA_PAINT: Record<'band' | 'allowed' | 'band-passed' | 'allowed-passed', {
-    color: string;
-    opacity: number;
-    zIndex: number;
-}>;
-/** Данные ленты в ведении перезаливаются не чаще (мс) — ≤ 10 Гц, и только пока машина на ленте. */
-declare const LANE_PROGRESS_MIN_MS = 100;
-/** Пустой набор GeoJSON. */
-declare const EMPTY_GEOJSON: {
-    type: string;
-    features: unknown[];
-};
-/**
- * Слои ленты — как у Baidu в полосном виде: одна полупрозрачная синяя лента без контуров, белые
- * шевроны по ней и бледная лента разрешённых полос; в ведении пройденная часть — серая.
- */
-declare function laneRibbonLayers(): Record<string, unknown>[];
-/** Слой шевронов ленты — его гасят вместе со стрелками линии маршрута (`routeLineOptions(…, arrows)`). */
-declare const LANE_RIBBON_CHEVRON_LAYER = "lane-ribbon-chevron";
-/** Id слоёв ленты — для отладки и выключателей. */
-declare const laneRibbonLayerIds: () => string[];
-/**
- * Стиль карты с источником и слоями ленты — сразу за слоями детальных дорог (иначе за `roadbed`).
- * Повторный вызов слои заменяет, а не дублирует.
- *
- * `buffer: 0` — без поля за краем тайла: каждый тайл получает ровно свой квадрат (как этого добиться
- * при выдвиге вершин разреза движком — `tileParts` в `lane-ribbon-render.ts`). Зум тайлов — 18
- * (`maxzoom` по умолчанию), на нём и считается та резка: менять его без неё нельзя.
- */
-declare function withLaneRibbon(style: StyleSpec, data?: unknown): StyleSpec;
-/** Фича сцены детальных дорог (GeoJSON) — то, из чего берутся отметки полотна. */
-interface SceneFeature {
-    geometry: {
-        type: string;
-        coordinates: unknown;
-    };
-    properties: Record<string, unknown>;
-}
-/**
- * Поле высот по фичам сцены детальных дорог: отрезки с отметками (`liftPath`/`lift`), по уровням
- * (`layer`). Точка дальше 22 м от полотна своего уровня — этаж × 8 м (`fallbackHeight`).
- */
-declare function heightsFromScene(features: SceneFeature[]): HeightAt;
-/**
- * ВЫСОТА ТРАССЫ — ОДНА НА ВСЕХ: линия маршрута, лента по полосам, стрелки поворотов (и машина
- * навигатора) лежат на одной поверхности — `OVERLAY_ALTITUDE` над отметкой полотна НА МЕТРЕ ТРАССЫ.
- * Отметка по метру — `routeLiftAt`; лента берёт её по станциям своих точек (`RibbonGeoJson`), объекты
- * карты — по точке, приведённой к метру трассы (`routeLiftField`). Своей модели высоты ни у ленты, ни у
- * стрелок нет: на каждом метре трассы они на той же отметке, что и линия, — на земле на асфальте, на
- * эстакаде на настиле, на подходе по одному склону.
- */
-declare const ROUTE_TOP = 0.28;
-/** Отметка полотна на метре трассы, метры (0 — земля). */
-type RouteLiftAt = (m: number) => number;
-/** Отметка полотна в точке `(lng, lat)`, метры (`MapObjectOptions.liftAt` объектов карты). */
-type LiftField = (lng: number, lat: number) => number;
-/** Профиль отметок: метры трассы точек куска и их отметки. */
-interface LiftProfile {
-    stations: number[];
-    heights: number[];
-}
-/**
- * Профили отметок трассы — по ОСНОВНОЙ ленте (`band`: рекомендуемые полосы идут по самой трассе),
- * отметки — поле высот `heights` по уровням точек. Основной ленты нет — по всем площадным кускам.
- */
-declare function routeLiftProfiles(ribbon: Ribbon, heights?: HeightAt): LiftProfile[];
-/**
- * Отметка полотна на метре `m` трассы по профилям: внутри куска — линейно между станциями; кусков на
- * метре несколько — наибольшая; вне ленты — 0 (не на ленте — земля). Та же функция, что высота машины
- * навигатора (`navCarLiftAt`).
- */
-declare function routeLiftAt(ribbon: Ribbon, heights?: HeightAt): RouteLiftAt;
-/** Дальше этого от трассы точка объекта к ней не приводится (не на трассе — земля), метры. */
-declare const ROUTE_LIFT_REACH_M = 25;
-/**
- * Отметка трассы в точке для объектов карты (`liftAt` линии, пройденной части, стрелок поворотов):
- * точка приводится к ближайшему метру трассы `geometry` (мерой `routeLine`, той же, что станции ленты)
- * и берёт `liftAt` этого метра. Дальше `ROUTE_LIFT_REACH_M` от трассы — 0. `null` — у трассы нет
- * отметок (лента без эстакад и без ленты вовсе: все на земле).
- */
-declare function routeLiftField(geometry: LonLat[], liftAt: RouteLiftAt): LiftField | null;
-interface RibbonGeoJsonFeature {
-    type: 'Feature';
-    id: number;
-    geometry: {
-        type: 'Polygon';
-        coordinates: LonLat[][];
-    } | {
-        type: 'LineString';
-        coordinates: LonLat[];
-    };
-    properties: Record<string, unknown>;
-}
-interface RibbonGeoJsonData {
-    type: 'FeatureCollection';
-    features: RibbonGeoJsonFeature[];
-}
-/**
- * ДАННЫЕ ИСТОЧНИКА ЛЕНТЫ (то, что веб-карта заливала в `lane-ribbon` из `LaneRibbonLayer.push`):
- * `kind`, `width` (метры), `layer` (наибольший уровень), высота (`lift`/`liftPath`). Площадные
- * фичи — многоугольниками без нахлёста (`minusMask`) и разрезанными по сетке тайлов z18
- * (`tileParts`), в ведении — с серой пройденной частью (`areaSpans`); шевроны — осью, целиком
- * позади машины не рисуются.
- *
- * ★ У ПОРТОВ (`RibbonGeoJson` в `LdRoads.kt`) резки по тайлам и вычитания нет — там отдаются целые
- * контуры: шов полупрозрачной ленты по границе тайла — особенность веб-движка (`SURFACE_CUT_BLEED`).
- *
- * Кэширует всё, что не зависит от точки машины: на шаге ведения пересчитывается только кусок с ней.
- */
-declare class RibbonGeoJson {
-    readonly ribbon: Ribbon;
-    private heights;
-    private options;
-    /** Отметки точек каждой фичи ленты (по полю высот). */
-    private hs;
-    /** Свойства высоты кусков без точки машины: `номер:вид:от:до`. */
-    private props;
-    /** Многоугольники кусков без точки машины (после вычитания ленты и резки по тайлам). */
-    private shapes;
-    private frames;
-    private masks;
-    /**
-     * `options.areas: false` — без площадных фич: площадь ленты рисуется объектами карты единым
-     * полигоном (`RibbonAreas`, `lane-ribbon-mesh.ts`), в источнике остаются только шевроны.
-     * `options.lift` — высота полотна под точкой (`routeSurfaceField`): отметки точек берутся по ней, а
-     * не по метру трассы — тем же, чем стоят на полотне лента, линия и стрелки.
-     */
-    constructor(ribbon: Ribbon, heights?: HeightAt, options?: {
-        areas?: boolean;
-        lift?: LiftField | null;
-    });
-    /** Другая высота полотна под точкой (догрузилась сетка детальных дорог). */
-    setLift(lift: LiftField | null): void;
-    /** Другое поле высот (сцена детальных дорог перестроена) — отметки берутся заново. */
-    setHeights(heights: HeightAt): void;
-    /** Отметка трассы по метру (`routeLiftAt`) — общая с линией маршрута и стрелками. */
-    private routeLift;
-    /**
-     * Отметки точек фичи — ОТМЕТКА ТРАССЫ на станциях точек (`routeLiftAt`): лента лежит на той же
-     * высоте, что линия маршрута и стрелки на том же метре. Фича без станций — по полю высот.
-     */
-    private heightsOf;
-    /**
-     * Маска фичи `i`: контуры площадных фич главнее её — основная лента главнее разрешённых полос,
-     * среди равных — раньше построенная.
-     */
-    private maskFor;
-    private shapesOf;
-    /** GeoJSON на метре ведения (`null` — ведения нет, лента целиком цветная). */
-    at(progress: number | null): RibbonGeoJsonData;
-}
-/** Данные источника ленты без ведения (лента целиком цветная). */
-declare function ribbonGeoJson(ribbon: Ribbon, heightAt?: HeightAt): RibbonGeoJsonData;
-
-/**
- * ЛЕНТА ПО ПОЛОСАМ — ЕДИНЫМ ПОЛИГОНОМ, НА ВЫСОТЕ НАСТОЯЩЕГО ПОЛОТНА.
- *
- * Разбор и источники — `docs/lane-ribbon-mesh.md`. Коротко:
- *
- * ★ ОДИН ПИКСЕЛЬ — ОДНА КРАСКА. Лента полупрозрачная, и любой нахлёст двух кусков даёт пятно
- * двойной яркости. Поэтому краска не накладывается кусками, а строится НЕПЕРЕКРЫВАЮЩАЯСЯ геометрия:
- * куски одного вида и одной полосы метров (`CHUNK_M`) сливаются объединением (polygon-clipping —
- * Мартинес–Руэда в изводе Майка Фогеля), а из каждой группы вычитается всё, что нарисовано раньше
- * (основная лента главнее разрешённых полос, ближняя к началу трассы — дальней). Итог — набор
- * многоугольников, которые касаются, но не перекрываются; каждый — один объект карты, earcut
- * разбивает его на треугольники один раз. Сумма площадей треугольников равна площади ленты — это и
- * проверяют тесты (`tests/navigram-lane-ribbon-mesh.test.mjs`).
- *
- * ★ ВЕДЕНИЕ. Группа, которую режет точка машины, делится на пройденную (серую) и оставшуюся части
- * пересечением и разностью с пройденными кусками своей группы — две маленькие операции на шаг ведения;
- * остальные группы берутся из кэша как есть.
- *
- * ★ ВЫСОТА — ОТ НАСТОЯЩЕГО ПОЛОТНА ПОД ТОЧКОЙ (`meshSurface`, `routeSurfaceField`): каждая вершина
- * ленты, линии маршрута и стрелок поворотов берёт отметку верха сетки детальных дорог ровно под собой
- * (треугольник с нормалью вверх; из нескольких — ближайший к ожидаемой отметке трассы, чтобы дорога
- * под эстакадой не взлетела на настил). Там, где сетка загружена, но под точкой её нет, — земля;
- * где сетки нет вовсе — отметка трассы (`routeLiftField`).
- */
-
-/** Кусок ленты для отрисовки: вид, многоугольник (`[outer, ...holes]`, кольца `[lon, lat]`, замкнуты). */
-interface RibbonArea {
-    /** Постоянный ключ: тот же кусок на следующем шаге ведения — тот же объект карты. */
-    key: string;
-    kind: RibbonKind;
-    polygon: LonLat[][];
-    /**
-     * Какие кромки сглаживать (`RouteArea.feather`): `feather[r][i]` — кромка `i → i+1` кольца `r`
-     * (кольца — без замыкающей точки). Сглаживается только край ленты; шов с соседним куском ленты —
-     * нет: там с обеих сторон краска, и полоса сглаживания легла бы на соседа второй краской.
-     */
-    feather: boolean[][];
-}
-type Box = [number, number, number, number];
-/**
- * ПРОЙДЕННОЕ РАСТВОРЯЕТСЯ, А НЕ ОБРЫВАЕТСЯ (22.10.2026, просьба владельца «синий свет плавно уменьшался позади
- * машины»). Раньше группу с точкой машины резало пересечением: синяя кончалась ровно под машиной, а дальше шла
- * серая — ступенька на всю ширину ленты, и перекладывалась она шагом ведения (≤ 10 Гц). Теперь (`passAt`) группы
- * не режутся: у группы рядом с машиной рисуются ЦЕЛИКОМ и синяя, и серая, а какая где видна, решает шейдер по
- * метру трассы в вершине (`stationsFor`) и метру машины в униформе (`MapObject.along`): синяя гаснет на
- * `RIBBON_PASS_FADE_M` позади машины, серая на том же отрезке проявляется. Метр машины — каждым кадром, без
- * пересборки; набор объектов меняется, только когда группа входит в окно у машины или выходит из него.
- */
-/** Длина растворения синей ленты позади машины, метры. */
-declare const RIBBON_PASS_FADE_M = 20;
-/**
- * Запас окна у машины, метры: группа рисуется обеими красками, пока задевает [машина − длина − запас,
- * машина + запас]. На границе окна та краска, что уходит, уже погашена шейдером, — смена набора не видна.
- */
-declare const RIBBON_PASS_MARGIN_M = 5;
-/** Кусок ленты в ведении с растворением позади машины (`RibbonAreas.passAt`). */
-interface PassArea extends RibbonArea {
-    /** Номер группы — для метров в точках (`RibbonAreas.stationsFor`). */
-    group: number;
-    /**
-     * Сторона растворения (`AlongFade.dir`): +1 — синяя, гаснет позади машины; −1 — серая, проявляется позади
-     * машины; 0 — у группы нет метров трассы, рисуется как есть.
-     */
-    dir: 1 | -1 | 0;
-}
-/**
- * ПЛОЩАДЬ ЛЕНТЫ БЕЗ НАХЛЁСТОВ — по группам «категория × полоса метров `CHUNK_M`».
- *
- * Строится один раз на ленту; на шаге ведения пересчитывается только группа с точкой машины.
- */
-declare class RibbonAreas {
-    readonly ribbon: Ribbon;
-    private readonly chunkM;
-    /** Группы по порядку отрисовки: сначала основная лента, потом разрешённые полосы; внутри — по метрам. */
-    private groups;
-    private frames;
-    private built;
-    constructor(ribbon: Ribbon, chunkM?: number);
-    private frame;
-    /** Куски каждой фичи по полосам метров (без ведения) — сырьё групп. */
-    private build;
-    /** Лежит ли точка (единицы z18) внутри ленты — какой-нибудь группы. */
-    private inside;
-    /** Кромки многоугольника на краю ленты: с одной стороны лента, с другой — нет. */
-    private featherOf;
-    private featherCache;
-    /** Метры трассы группы `[lo, hi]` (`null` — у её фич метров нет). */
-    private spans;
-    private spanOf;
-    /** Что рисует группа на метре `progress`: `b` — синяя, `x` — синяя и серая (окно у машины), `g` — серая. */
-    private passMode;
-    /**
-     * Отпечаток набора кусков `passAt` на метре `progress`: тот же — объекты те же, менять нужно только метр машины
-     * у растворения (`MapObject.along`).
-     */
-    passKey(progress: number | null, fadeM?: number): string;
-    /**
-     * Куски ленты в ведении С РАСТВОРЕНИЕМ ПОЗАДИ МАШИНЫ: группы целиком (без резки по точке машины), синие —
-     * впереди и в окне у машины, серые — в окне и позади. Ключи — те же, что у целых групп `at` (`:whole`,
-     * `:passed`): группа, перешедшая из одного состояния в другое, остаётся тем же объектом карты.
-     */
-    passAt(progress: number | null, fadeM?: number): PassArea[];
-    /**
-     * МЕТР ТРАССЫ В ТОЧКАХ КУСКА группы `group` (кольца — как у `polygon`, в том числе после дробления кромок
-     * `fadeRibbonArea`): метр ближайшей точки оси её фич (`stations` по точкам оси, между ними — линейно). Ищется
-     * только по своей группе — трасса, вернувшаяся к тому же месту, чужого метра не даст. `null` — метров нет.
-     */
-    stationsFor(group: number, polygon: LonLat[][]): number[][] | null;
-    /** Куски ленты на метре ведения `progress` (`null` — ведения нет, лента целиком цветная). */
-    at(progress: number | null): RibbonArea[];
-}
-/**
- * ШЕВРОНЫ ЛЕНТЫ — линиями маршрута (`Polyline`, та же программа и тот же рисунок стрелок, что у
- * линии), размер — в метрах на земле (как прежний слой: 6 px на z18 и вдвое на каждый зум).
- */
-declare const RIBBON_CHEVRON: {
-    readonly COLOR: "rgba(255,255,255,0)";
-    readonly ARROW_COLOR: "rgba(255,255,255,0.95)";
-    readonly WIDTH_M: 2.75;
-    readonly PERIOD_M: 18.3;
-    readonly SIZE_M: 1.37;
-    /** Над лентой (16–17), под линией маршрута (20). */
-    readonly Z: 18;
-};
-/** Шеврон ленты: постоянный ключ и ось. */
-interface RibbonChevron {
-    key: string;
-    line: LonLat[];
-}
-/** Шеврон в ведении с растворением: метры его концов (`null` — метров нет). */
-interface PassChevron extends RibbonChevron {
-    stations: [number, number] | null;
-}
-/**
- * Шевроны в ведении С РАСТВОРЕНИЕМ (`passAt`): шеврон гаснет позади машины вместе с синей лентой (`MapObject.along`
- * с началом `chevronRunBase`), поэтому снимается, только когда целиком ушёл за окно растворения, — не на машине.
- */
-declare function ribbonPassChevrons(ribbon: Ribbon, progress: number | null, fadeM?: number): PassChevron[];
-/**
- * Метр трассы первой точки куска шеврона (`fadeRibbonLine` режет шеврон на куски): по доле пути вдоль оси шеврона
- * до ближайшей к ней точки, между метрами его концов. `null` — у шеврона метров нет.
- */
-declare function chevronRunBase(chevron: PassChevron, run: LonLat[]): number | null;
-/** Шевроны на метре ведения: целиком позади машины не рисуются, тот, на котором машина, — целый. */
-declare function ribbonChevrons(ribbon: Ribbon, progress: number | null): RibbonChevron[];
-/** Сетка детальных дорог (тайл `ldtiles` после `decodeMeshTile`): точки — абсолютные `[lon, lat]`. */
-interface SurfaceMesh {
-    lonlat: ArrayLike<number>;
-    z: ArrayLike<number>;
-    normals: ArrayLike<number>;
-    indices: ArrayLike<number>;
-}
-/**
- * Отметка верха полотна в точке: число — отметка сетки под точкой (метры, как в тайле сетки, без
- * подъёма отрисовки); `null` — сетка здесь загружена, но дороги из неё под точкой нет (земля);
- * `undefined` — сетки здесь нет вовсе (судить не по чему). `hint` — ожидаемая отметка: из нескольких
- * поверхностей одна над другой берётся ближайшая к ней.
- */
-type SurfaceAt = (lng: number, lat: number, hint?: number) => number | null | undefined;
-/**
- * Высота полотна по сеткам детальных дорог. `boxes` — рамки загруженных тайлов сетки `[w, s, e, n]`:
- * внутри них «нет треугольника» значит «земля», снаружи — «не знаю». Учитываются только грани, глядящие
- * вверх (верх плиты, а не борт и не низ).
- */
-declare function meshSurface(meshes: readonly SurfaceMesh[], boxes: readonly Box[]): SurfaceAt;
-/**
- * ВЫСОТА ПОЛОТНА ДЛЯ ВСЕГО МАРШРУТА (лента, линия, пройденная часть, стрелки поворотов — одна функция
- * на всех): отметка сетки под точкой (`surface`, ближайшая к отметке трассы), в зоне загруженной сетки
- * без дороги под точкой — земля (0), вне сетки — отметка трассы (`route`, по метру трассы).
- */
-declare function routeSurfaceField(surface: SurfaceAt | null, route: LiftField | null): LiftField | null;
-
-/**
- * ЛЕНТА ПО ПОЛОСАМ И ЛИНИЯ МАРШРУТА СМЕНЯЮТ ДРУГ ДРУГА ПЕРЕХОДОМ, А НЕ СТУПЕНЬКОЙ (22.10.2026, просьба
- * владельца «чтобы синий свет плавно уменьшался» и «лента пропадает, а линия не появляется»).
- *
- * Раньше смена «линия ↔ лента» была ступенькой, а по зуму — ещё и дырой:
- *  · объекты ленты гасли с `LANE_MIN_ZOOM` (`minZoom`), а линия уступала ей куски на ЛЮБОМ зуме — камера
- *    ведения на прямой держит z17.4, и на всём покрытии плана не было ни ленты, ни линии;
- *  · ВДОЛЬ ТРАССЫ на краю покрытия широкая синяя лента обрывалась, а с того же метра шла тонкая линия.
- *
- * Теперь:
- *  · ОДНО СОСТОЯНИЕ ВИДИМОСТИ (`RibbonBlend`): цель «лента / линия» по зуму с гистерезисом
- *    (`LANE_ON_ZOOM` / `LANE_OFF_ZOOM`) и значение, которое идёт к цели за `RIBBON_BLEND_MS` по гладкой
- *    кривой. Лента рисуется с множителем `ribbonAlpha`, а куски линии ПОД лентой — с `lineAlpha`
- *    (`MapObject.fade`): линия гаснет, пока лента проявляется, и обратно. Куски линии вне ленты не
- *    трогаются никогда. Карта будит кадры, только пока переход идёт (`animating`);
- *  · у концов ленты, где её сменяет линия (не у начала и конца трассы), лента на `RIBBON_FADE_M` гаснет
- *    гладкой ступенькой (прозрачность в вершине, `RouteArea.alphas`), а линия на том же отрезке лежит
- *    поверх всегда (`ribbonLineHidden` — куски под лентой без зон растворения).
- *
- * Метры здесь — мера трассы ленты (`measureRoute`, та же, что у `Ribbon.hidden`).
- */
-
-/** Длина растворения ленты у конца, где её сменяет линия маршрута, метры. */
-declare const RIBBON_FADE_M = 20;
-/** Длительность перехода «линия ↔ лента», мс. */
-declare const RIBBON_BLEND_MS = 300;
-/**
- * НАИБОЛЬШИЙ ШАГ ПЕРЕХОДА ЗА ОДИН КАДР, мс часов (24.10.2026). Переход меряется НАРИСОВАННЫМИ кадрами: долгий кадр
- * (включение ленты на пороге зума давало на Redmi 110–357 мс) двигает его не больше, чем на этот шаг, а не проматывает
- * целиком — иначе весь кросс-фейд и съезд машины в полосу (`laneCarPose`, доля `ribbonAlpha`) приходились на один кадр.
- * 34 мс — два периода развёртки при 60 Гц и один при 30 Гц: на ровных кадрах переход идёт как раньше, за 300 мс; хуже
- * 30 кадров/с — растягивается, но не меньше чем на 9 кадров (шаг доли ≤ 0.11, шаг съезда ≤ 0.17 сдвига полосы).
- */
-declare const RIBBON_BLEND_STEP_MAX_MS = 34;
-/** С этого зума лента включается (если была выключена). */
-declare const LANE_ON_ZOOM: number;
-/** Ниже этого зума лента выключается (если была включена). Между порогами состояние держится. */
-declare const LANE_OFF_ZOOM: number;
-/** Кромка в зоне растворения дробится не реже (метры): прозрачность GPU смешивает между вершинами. */
-declare const RIBBON_FADE_STEP_M = 2;
-/**
- * Дальше от оси трассы (метры) точка к концу ленты не относится: широкая лента разрешённых полос
- * отходит от оси на 10–15 м, а трасса, вернувшаяся к тому же месту (разворот), — не её конец.
- */
-declare const RIBBON_FADE_REACH_M = 30;
-/** Растворение концов ленты по трассе: куда и в какую сторону гаснет. */
-interface RibbonFade {
-    frame: Frame;
-    route: Measured;
-    /** Метр конца ленты и сторона ленты от него: +1 — лента дальше по трассе, −1 — ближе. */
-    ends: {
-        at: number;
-        dir: 1 | -1;
-    }[];
-    fadeM: number;
-}
-/**
- * Концы ленты, которые сменяет линия маршрута, — по кускам `hidden` трассы `geometry`. Нет таких концов
- * (или `fadeM` = 0) — `null`: лента рисуется как раньше.
- */
-declare function ribbonFade(geometry: LonLat[], hidden: [number, number][], fadeM?: number): RibbonFade | null;
-/** Прозрачность ленты в точке `[lon, lat]`. */
-declare function ribbonFadeAlpha(fade: RibbonFade, p: LonLat): number;
-/**
- * Кусок ленты (`RibbonArea`: кольца без замыкающей точки и отметки кромок) — с прозрачностью в
- * вершинах. Кромки рядом с концами дробятся через `RIBBON_FADE_STEP_M` (отметка кромки — та же у
- * всех её частей): полигон ленты после объединения держит вершины только на изломах и стыках
- * кусков, и без дробления 20 м растворения размазались бы на всю прямую кромку. Кусок, весь
- * видимый (альфа 1 везде), возвращается как есть и без `alphas`.
- */
-declare function fadeRibbonArea(fade: RibbonFade | null, polygon: LonLat[][], feather: boolean[][]): {
-    polygon: LonLat[][];
-    feather: boolean[][];
-    alphas: number[][] | null;
-};
-/**
- * Шевроны ленты (линия по оси полосы) — без частей в зоне растворения: белые стрелки над
- * погасшей лентой висели бы в воздухе. Части с прозрачностью ниже 0.999 выбрасываются, кромка
- * режется с шагом `RIBBON_FADE_STEP_M`. Ничего не осталось — пусто.
- */
-declare function fadeRibbonLine(fade: RibbonFade | null, line: LonLat[]): LonLat[][];
-/**
- * Куски трассы, что линия маршрута уступает ленте, — без зон растворения: у конца, где ленту
- * сменяет линия, линия заходит под гаснущую ленту на `fadeM` (и лежит поверх неё). У начала и конца
- * трассы куски не укорачиваются. Кусок, короче двух зон, пропадает: линия там цела.
- */
-declare function ribbonLineHidden(geometry: LonLat[], hidden: [number, number][], fadeM?: number): [number, number][];
-/**
- * Дополнение кусков до трассы `[0, length]`: где линия рисуется ВНЕ кусков. Куски — по возрастанию и не
- * пересекаются (`ribbonLineHidden`, `mergeRanges`).
- */
-declare function outsideRanges(ranges: [number, number][], length: number): [number, number][];
-/**
- * СОСТОЯНИЕ ВИДИМОСТИ «ЛЕНТА ↔ ЛИНИЯ» — одно на карту. `update` — каждым кадром (зум кадра, часы кадра,
- * есть ли лента); возвращает `true`, пока переход идёт (карте нужен следующий кадр).
- *
- *  · цель: лента есть и зум не ниже `LANE_ON_ZOOM` — включить; ниже `LANE_OFF_ZOOM` — выключить; между —
- *    как была (гистерезис: камера, стоящая на пороге, не мигает);
- *  · значение `t` идёт к цели с постоянной скоростью `1 / RIBBON_BLEND_MS`, но за кадр — не больше
- *    `RIBBON_BLEND_STEP_MAX_MS` часов: долгий кадр переход не проматывает; видимая доля — `smoothstep(t)`;
- *  · ленту сняли (новая трасса, план кончился) — цель «линия»: прежняя лента ГАСНЕТ тем же переходом (её объекты держит
- *    слой, пока `t` не дошло до 0 — `retiring`), а линия новой трассы уже целая;
- *  · первый кадр с лентой (и пропуск кадров дольше секунды, и часы назад) не двигает `t`: переход меряется
- *    только живыми кадрами — лента, пришедшая на крупном зуме, проявляется, а не встаёт сразу.
- */
-declare class RibbonBlend {
-    /** Цель: лента видна. */
-    on: boolean;
-    /** Значение перехода 0…1 (0 — линия, 1 — лента). */
-    t: number;
-    private at;
-    update(zoom: number, nowMs: number, hasRibbon: boolean): boolean;
-    /** Множитель прозрачности ленты. */
-    get ribbonAlpha(): number;
-    /** Множитель прозрачности кусков линии под лентой. */
-    get lineAlpha(): number;
-    /** Переход ещё идёт. */
-    get animating(): boolean;
-}
-
-/**
- * ЛИНИЯ МАРШРУТА КАК У BAIDU — параметры движка (`docs/map-v2/ROUTE-LINE-BAIDU.md` монорепозитория):
- * широкая насыщенная синяя линия (пробки — раскраской по участкам) с белой обводкой и белыми
- * шевронами направления через равный шаг; невыбранные варианты — бледные и ниже; в ведении
- * пройденная часть — серая линия ПОВЕРХ целой синей (`passedPieces`, `route-progress.ts`). Лента по
- * полосам (`ld-roads.ts`) — того же синего: она продолжает линию.
- *
- * Перенесено из веб-карты (`src/WebMap/src/map/overlays.ts`) без изменения поведения: константы,
- * `trafficSegments`, `spansForPiece`, опции `Polyline`. Пара у портов — `RouteLineStyle.kt` /
- * `RouteLineStyle.swift`; сверка — общие фикстуры `kmp/fixtures/route-line/*.json`
- * (`node scripts/export-route-line-fixture.mjs`).
- */
-
-/** Константы линии маршрута (цвета — CSS, ширины и шаги — пиксели). */
-declare const ROUTE_LINE: {
-    /** Выбранный вариант. */
-    readonly BLUE: "#2f6bff";
-    /**
-     * Линия 10 px и белая обводка по 2 px с каждой стороны — всего 14, как у `navigator-main`
-     * (`RouteMap.kt`: `LineLayer` 10.dp поверх обводки 14.dp, концы и стыки скруглены). Было 9 + 2.
-     */
-    readonly WIDTH: 10;
-    readonly STROKE_WIDTH: 2;
-    readonly STROKE_COLOR: "#ffffff";
-    /** Шевроны: шаг и размах в пикселях (движок вписывает стрелку в 0.72 полуширины линии). */
-    readonly ARROW_COLOR: "#ffffff";
-    readonly ARROW_PERIOD: 56;
-    readonly ARROW_SIZE: 7;
-    /** Насколько видна трасса там, где она за домом. */
-    readonly GHOST: 0.7;
-    /** Невыбранные варианты: бледные, уже и ниже. */
-    readonly DIM: "#98a2b3";
-    readonly DIM_WIDTH: 6;
-    readonly DIM_STROKE_COLOR: "#e6e9ef";
-    readonly DIM_OPACITY: 0.75;
-    /**
-     * Линия в режиме навигатора — НЕПРОЗРАЧНАЯ, как и в обычном (решение пользователя 07.10.2026:
-     * сквозь полупрозрачную трассу просвечивали подложка, полотно и разметка, а цвета пробок
-     * мутнели). Константа осталась — её читают веб-карта и приложение. Полупрозрачными остались
-     * намеренно только «призрак» за домами (`GHOST`) и невыбранные варианты (`DIM_OPACITY`).
-     */
-    readonly NAV_OPACITY: 1;
-    /**
-     * Пройденная часть в ведении — та же ширина и белая обводка, без шевронов. Цвет — `TRAVELED_COLOR`
-     * навигатора `navigator-main` (`map/RouteMap.kt`): тот же синий, но выцветший, — линия читается как
-     * «уже позади», а не как другая дорога.
-     */
-    readonly PASSED: "#6e7a8a";
-    /** Порядок среди объектов: невыбранные, выбранный, пройденная поверх выбранного. */
-    readonly Z_ACTIVE: 20;
-    readonly Z_DIM: 10;
-    readonly Z_PASSED: 21;
-    /** Чаще этого пройденная часть не перекладывается (мс): ≤ 10 Гц, метка машины прячет разницу. */
-    readonly PROGRESS_MIN_MS: 100;
-    /** Точки маршрута: старт (A), финиш (B), промежуточные. */
-    readonly POINT_START: "#12a150";
-    readonly POINT_FINISH: "#e5484d";
-    readonly POINT_VIA: "#f5a524";
-};
-declare const ROUTE_BLUE: "#2f6bff";
-declare const ROUTE_NAV_OPACITY: 1;
-declare const ROUTE_PASSED: "#6e7a8a";
-declare const ROUTE_POINT_COLORS: {
-    readonly start: "#12a150";
-    readonly finish: "#e5484d";
-    readonly via: "#f5a524";
-};
-/** Участок пробок: с точки `at` трассы — фактор скорости `factor` (как `trafficSpans` ответа `/route`). */
-interface TrafficSpan {
-    at: number;
-    factor: number;
-}
-/**
- * ЦВЕТА ПРОБОК НА ЛИНИИ МАРШРУТА — как у навигатора `navigator-main` (`map/RouteMap.kt`,
- * `trafficColor`; уровни — `congestionLevel` в `routing/RouterTraffic.kt`): уровень загруженности —
- * сколько порогов фактора (`LEVELS`: 1.15, 1.5, 2.3, 3.3) участок перешагнул; 0 — зелёный, 1 — жёлтый,
- * 2 — оранжевый, 3 и 4 — красный. Фактора нет (не число, не больше нуля) — синий линии: «данных нет»
- * не выдаём за «свободно».
- *
- * Свои цвета, а не ступени слоя пробок (`traffic.ts`): тот повторяет серверный растр и рисует улицы
- * города, а этот красит одну линию поверх них — ему нужен контраст с картой и с самим слоем.
- */
-declare const ROUTE_TRAFFIC: {
-    readonly LEVELS: readonly number[];
-    readonly COLORS: readonly string[];
-    /**
-     * ПЛАВНЫЕ СТЫКИ: ширина перехода цвета — доля длины трассы. У `navigator-main` линия красится
-     * `line-gradient` MapLibre Native по `line-progress`: выражение запекается в полоску текстуры
-     * в 256 текселей с линейной выборкой, и каждая ступень `step` расплывается на один тексель, то есть
-     * на 1/255 длины линии. Берём ту же ширину, но без квантования стыка на сетку текселей и в
-     * разумных пределах (`BLEND_MIN_M`…`BLEND_MAX_M`): на коротком маршруте стык не схлопывается в
-     * ступеньку, на длинном не размазывает квартал.
-     */
-    readonly BLEND_FRACTION: number;
-    readonly BLEND_MIN_M: 12;
-    readonly BLEND_MAX_M: 150;
-};
-/** Ширина плавного стыка пробок, метры, для трассы длиной `lengthM` (`Polyline.segmentBlend`). */
-declare function routeTrafficBlendM(lengthM: number): number;
-/** Уровень загруженности 0…4 по фактору (сколько порогов `ROUTE_TRAFFIC.LEVELS` он перешагнул); нет фактора — `null`. */
-declare function routeTrafficLevel(factor: number): number | null;
-/** Цвет участка линии маршрута по фактору (`ROUTE_TRAFFIC`); нет фактора — синий линии. */
-declare function routeTrafficColor(factor: number): string;
-/**
- * Отрезки маршрута со своим цветом — из факторов пробок (`routeTrafficColor`).
- *
- * Соседние отрезки одного цвета сливаются: сервис даёт границу на каждом ребре графа, а цветов у
- * нас четыре, и без слияния сотня рёбер превратилась бы в сотню отдельных линий вместо десятка.
- * Свободная от начала до конца трасса — ОДИН зелёный отрезок, а не синяя линия: как у `navigator-main`,
- * раз пробки известны, линия их показывает. Пусто — только когда пробок нет вовсе (красит `color`).
- */
-declare function trafficSegments(spans: readonly TrafficSpan[]): PolylineSegment[];
-/**
- * Отрезки пробок для куска трассы: `source[k]` — номер отрезка исходной трассы под точкой куска.
- * Первая точка получает цвет отрезка, на котором кусок начинается, дальше — смены по ходу.
- */
-declare function spansForPiece(spans: readonly TrafficSpan[], source: readonly number[]): TrafficSpan[];
-/** Кусок линии маршрута: точки и раскраска пробок по номерам ЕГО точек. */
-interface RouteLinePiece {
-    coords: LonLat[];
-    spans: TrafficSpan[];
-    /** Для каждой точки куска — номер отрезка исходной трассы (по нему — метры концов, `routeLineAlong`). */
-    source: number[];
-}
-/**
- * Куски линии варианта: при пустом `hidden` — трасса целиком; иначе — куски ВНЕ ленты по полосам,
- * каждый со своей раскраской пробок (номера точек в кусках другие — отрезки пересчитываются).
- */
-declare function routeLinePieces(coords: LonLat[], spans: readonly TrafficSpan[], hidden?: [number, number][]): RouteLinePiece[];
-/**
- * ПРОЙДЕННАЯ ЧАСТЬ ЛИНИИ — РАСТВОРЕНИЕМ, КАК У ЛЕНТЫ ПО ПОЛОСАМ (29.10.2026, просьба владельца «чтобы линии
- * маршрута тоже плавно сокращались, как лента»). Раньше серая линия резалась у машины ступенькой и
- * перекладывалась не чаще 10 раз в секунду. Теперь куски линии постоянны: синий гаснет позади машины на
- * `ROUTE_PASS_FADE_M` метров (`dir` +1), серый по тем же кускам проявляется (`dir` −1), а каждым кадром
- * меняется лишь метр машины в униформе (`MapObject.along`) — без пересборки геометрии.
- */
-declare const ROUTE_PASS_FADE_M = 20;
-/**
- * Растворение куска линии позади машины на метре `at` (мера `line` — та же, что у прогресса ведения).
- * Метры концов куска берутся из `line` по отрезкам `source`, а масштаб «метров на единицу длины» — как
- * их разность на меркаторную длину куска: шейдер считает метр точки по расстоянию вдоль линии, и без своего
- * масштаба (длина окружности на широте) на длинном куске серая зона уезжала бы от машины на десятки метров.
- */
-declare function routeLineAlong(line: RouteLine, piece: {
-    coords: LonLat[];
-    source: number[];
-}, at: number, dir: 1 | -1, length?: number): AlongFade;
-/** Опции `Polyline` линии маршрута без точек (`coordinates`) и раскраски (`segments`). */
-type RouteLineOptions = Omit<PolylineOptions, 'coordinates' | 'segments'>;
-/**
- * Опции линии варианта. Выбранный — синий, 9 px, белая обводка, шевроны, призрак за домами
- * (не ярче самой линии), zIndex 20; невыбранный — бледный, 6 px, без шевронов и призрака, zIndex 10.
- * `opacity` по умолчанию — 1 у выбранного (`ROUTE_NAV_OPACITY` в навигаторе), 0.75 у невыбранного.
- * `arrows: false` — без шевронов и у выбранного (как `arrows` у `RouteLineStyle.kt`/`RouteLineOverlay`).
- */
-declare function routeLineOptions(active: boolean, opacity?: number, arrows?: boolean): RouteLineOptions;
-/** Опции пройденной (серой) части: та же ширина и обводка, без шевронов, непрозрачная, над синей. */
-declare function passedLineOptions(): RouteLineOptions;
-/** Цвет метки точки маршрута по её номеру (0 — старт, последняя — финиш, между — промежуточные). */
-declare function routePointColor(i: number, count: number): string;
-
-/**
- * СКРУГЛЁННАЯ ТРАССА — одна геометрия на линию маршрута, стрелки поворотов и машину навигатора.
- *
- * Зачем. Сервер отдаёт ломаную: на перекрёстке — прямой угол. Стрелка поворота раньше сглаживалась
- * сама (своим ядром, с радиусом от ширины), а линия под ней оставалась углом — на повороте они
- * расходились (жалоба пользователя 07.10.2026). Теперь скругляется САМА ТРАССА, одним радиусом
- * `ROUTE_ROUND.RADIUS_M`, и всё, что лежит на линии, берёт эту же геометрию: линия, пройденная
- * часть, стрелки (их ось — кусок той же скруглённой трассы, без своего сглаживания), машина.
- *
- * Как. Каждый узел с изломом заменяется дугой окружности радиуса `RADIUS_M`, касательной к обоим
- * звеньям (сопряжение). Касательная длина `R·tg(θ/2)` не больше половины каждого из соседних звеньев
- * — дуги соседних узлов не наезжают друг на друга; где места мало, радиус уменьшается. Дуга — точками
- * через `ARC_STEP`, их число чётное: середина дуги — отдельная точка, «якорь» исходного узла.
- *
- * МЕТРЫ. Всё, что меряется по исходной трассе (метр ведения, манёвры, участки пробок, куски под
- * лентой по полосам), переводится на скруглённую через якоря: метр внутри исходного звена `i` —
- * та же доля пути между якорями `i` и `i+1` (`roundedMetre`). Перевод монотонный и непрерывный,
- * стыки пробок встают на середины дуг, пройденная часть кончается ровно под машиной.
- *
- * Чистые функции; порты — `RouteRound.kt`, `RouteRound.swift`, сверка — `kmp/fixtures/route-line/round.json`.
- */
-
-declare const ROUTE_ROUND: {
-    /** Радиус скругления поворота, метры: около радиуса, по которому машина проходит городской перекрёсток. */
-    readonly RADIUS_M: 15;
-    /** Излом меньше этого (градусы) не скругляется — это уже гладкая кривая. */
-    readonly MIN_TURN_DEG: 2;
-    /** Шаг точек дуги, радианы. */
-    readonly ARC_STEP: number;
-};
-/** Скруглённая трасса: точки, якоря исходных узлов и обе меры (исходная и скруглённая). */
-interface RoundedRoute {
-    coords: LonLat[];
-    /** Номер точки `coords` для каждого исходного узла (для узла с дугой — середина дуги). */
-    anchors: number[];
-    /** Скруглённая трасса с метрами. */
-    line: RouteLine;
-    /** Исходная трасса с метрами. */
-    src: RouteLine;
-}
-/** Трасса `coords`, скруглённая радиусом `radiusM` (0 — как есть). */
-declare function roundRoute(coords: LonLat[], radiusM?: number): RoundedRoute;
-/** Метр исходной трассы → метр скруглённой (через якоря узлов). */
-declare function roundedMetre(rr: RoundedRoute, m: number): number;
-/** Точка скруглённой трассы на метре `m` ИСХОДНОЙ трассы — где рисовать машину. */
-declare function roundedPoint(rr: RoundedRoute, m: number): LonLat;
-/** Половина хорды, по которой берётся курс касательной (метры): гладко на дуге из точек через 11°. */
-declare const ROUTE_POSE_SPAN_M = 3;
-/**
- * ПОЗА МАРКЕРА на метре `m` ИСХОДНОЙ трассы: точка скруглённой линии и курс ПО КАСАТЕЛЬНОЙ к ней
- * в этой точке (хорда ±`ROUTE_POSE_SPAN_M`), градусы по часовой от севера. Маркер на повороте
- * разворачивается вокруг своей точки по ходу дуги — без «заноса»: курс с упреждением (камеры) у
- * маркера смотрел бы в выход из поворота ещё до него, и машина ехала бы боком.
- */
-declare function roundedPose(rr: RoundedRoute, m: number): {
-    point: LonLat;
-    bearing: number;
-};
-/** Участки пробок исходной трассы → скруглённой: номер точки — якорь исходного узла. */
-declare function roundedSpans(rr: RoundedRoute, spans: readonly TrafficSpan[]): TrafficSpan[];
-/** Диапазоны метров исходной трассы (куски под лентой по полосам) → метры скруглённой. */
-declare function roundedRanges(rr: RoundedRoute, ranges: readonly [number, number][]): [number, number][];
-
-/**
- * МАШИНА ПО ЛЕНТЕ ПОЛОС — этап 1 «как обычный режим полос Baidu/Amap» (23.10.2026): в навигаторе машина едет не по оси
- * линии маршрута, а по оси РЕКОМЕНДОВАННОЙ полосы — той, по которой идёт лента (`buildRibbon`), и перестраивается
- * вместе с лентой.
- *
- * ★ ТА ЖЕ ГЕОМЕТРИЯ, ЧТО РИСУЕТ ЛЕНТУ. Сдвиг берётся не из плана заново, а из оси нарисованной основной ленты
- * (`Ribbon.car` — точки `band.line` с метрами `band.stations`): на прямой машина стоит ровно на оси ленты, на
- * перестроении идёт её же S-переходом (smoothstep на длине перестроения сервера, 40 м на полосу), на повороте через
- * узел — по её же дуге.
- *
- * ★ СДВИГ — ВЕКТОРОМ ОТ СКРУГЛЁННОЙ ЛИНИИ МАРШРУТА (`roundedPoint`): машина без ленты стоит на скруглённой трассе
- * (`roundedPose` — та же дуга, что у линии и стрелки поворота), и вектор «ось ленты − точка скруглённой трассы» на
- * том же метре, прибавленный к ней, ставит машину ровно на ось ленты и на дуге поворота. Боковой сдвиг по нормали
- * дал бы на повороте метры расхождения: дуга трассы (радиус 15 м) и дуга ленты (гаусс оси полосы) — разные кривые.
- * Вектор непрерывен по метру (обе точки непрерывны), поэтому рывков нет и на изломах трассы.
- *
- * ★ КУРС С БОКОВОЙ СОСТАВЛЯЮЩЕЙ: направление движения = касательная трассы + производная сдвига по метру
- * (центральная разность на ±`LANE_CAR_SLOPE_M`, непрерывна для кусочно-линейного сдвига). На перестроении машина
- * поворачивает носом в сторону новой полосы (до ≈7° на 40 м перестроения в полосу 3.5 м) и выпрямляется к его концу;
- * на дуге с постоянным сдвигом поворота не добавляется (касательная параллельной кривой та же).
- *
- * ★ ВЕС ПЛАНА (`RibbonCar.weights`, `carWeight`): 1 на куске покрытия (машина на ленте и там, где лента ещё
- * переходит из ленты вне покрытия в полосу) и `CAR_OUTSIDE_WEIGHT` вне покрытия — с 24.10.2026 тоже 1: машина едет
- * по ленте «полполосы справа», а не по линии маршрута левее неё (решение владельца; было 0 с подъездом smoothstep на
- * `JOIN_M`). Плавность на краях покрытия — у самой оси ленты (`RAMP_SLOPE`). Плана нет вовсе (сервис не ответил) —
- * нет и дорожки: машина на линии.
- *
- * ★ ВМЕСТЕ С ПЕРЕХОДОМ «ЛЕНТА ↔ ЛИНИЯ» (`RibbonBlend`): сдвиг умножается на `ribbonAlpha` — ниже зума ленты машина на
- * линии маршрута, на пороге съезжает в полосу (и обратно) за те же `RIBBON_BLEND_MS`, что идёт кросс-фейд. Гаснущая
- * прежняя лента (новый план) — своим слоем с `ribbonAlpha` своего перехода: сумма долей — 1, машина не прыгает.
- *
- * ★ КАМЕРА ИДЁТ ЗА ЛИНИЕЙ МАРШРУТА, А НЕ ЗА СДВИНУТОЙ МАШИНОЙ. Центр и курс камеры ведения считаются, как раньше, по
- * скруглённой трассе: на перестроении дорога на экране стоит, а машина переезжает в соседнюю полосу (как у Baidu и в
- * жизни). Камера за машиной рыскала бы вбок на каждом перестроении и на каждом входе в ленту — на 3–5 м за полсекунды.
- *
- * Метры — исходной трассы мерой сервера (`linkM`), те же, что у `Ribbon.hidden`, пройденной части и подъёма ленты.
- * Чистые функции; порты — `LaneCar.kt`, `LaneCar.swift`, `navigram/lane_car.cpp`, сверка —
- * `kmp/fixtures/nav-car/lane.json` (`scripts/gen-car-models.mjs`).
- */
-
-/** Половина шага центральной разности для курса, метры (шаг точек ленты — метр, оси перехода — 2 м). */
-declare const LANE_CAR_SLOPE_M = 2;
-/**
- * Шаг дорожки по метру трассы, метры (плюс сами метры точек ленты). Сдвиг между точками дорожки линеен, а скруглённая
- * линия на дуге — ломаная через 11° (`ROUTE_ROUND.ARC_STEP`): у точек ленты (через метр её собственной длины) метр
- * трассы на повороте шагает до 5 м, и линейный сдвиг по такому шагу уводил машину с ленты на 12 см; сетка через
- * полметра без точек ленты срезала излом оси на повороте через узел (9 см). Сетка с точками ленты — до 2 см.
- */
-declare const LANE_CAR_STEP_M = 0.5;
-/** Сдвиг машины от скруглённой линии маршрута по метрам трассы: метры на восток и на север, уже с весом плана. */
-interface LaneCarTrack {
-    stations: number[];
-    east: number[];
-    north: number[];
-}
-/**
- * МЕТРЫ ТОЧЕК ЛЕНТЫ — СТРОГО ПО ВОЗРАСТАНИЮ. На дуге поворота через узел (`filletTurn`) несколько точек оси получают
- * один метр (проекция точки дуги на трассу пошла бы назад, и метр держится): «точка ленты на метре» там скакала бы через
- * эти точки — машина прыгала бы на 2 м. Такой повтор раскладывается по длине оси между соседними метрами.
- */
-declare function spreadStations(stations: number[], line: LonLat[]): number[];
-/**
- * Дорожка машины из оси основной ленты (`Ribbon.car`) и скруглённой трассы `rr` той же геометрии (`roundRoute`): через
- * `LANE_CAR_STEP_M` по метру и в метрах точек ленты — вектор «точка ленты − точка скруглённой линии» с весом плана. Где сдвига нет (вне плана),
- * точки не хранятся — только нули на краях: дорожка весит столько, сколько покрытие. Нет основной ленты — `null`.
- */
-declare function laneCarTrack(car: RibbonCar | null | undefined, rr: RoundedRoute): LaneCarTrack | null;
-/** Сдвиг на метре `s` и его производная по метру (центральная разность на ±`LANE_CAR_SLOPE_M`). */
-declare function laneCarShift(track: LaneCarTrack, s: number): {
-    east: number;
-    north: number;
-    dEast: number;
-    dNorth: number;
-};
-/** Слой дорожки: дорожка ленты и её доля в позе (`RibbonBlend.ribbonAlpha`). */
-interface LaneCarLayer {
-    track: LaneCarTrack | null;
-    alpha: number;
-}
-/**
- * ПОЗА МАШИНЫ НА ЛЕНТЕ: `point`/`bearing` — поза на скруглённой линии маршрута на метре `s` (`roundedPose`), слои —
- * дорожки показанной и гаснущей лент с долями. Ни одна дорожка не участвует (нет ленты, доли нулевые, метр не число)
- * — поза как есть, бит в бит.
- */
-declare function laneCarPose(point: LonLat, bearing: number, s: number, layers: readonly LaneCarLayer[]): {
-    point: LonLat;
-    bearing: number;
-};
-
-/**
- * СТРЕЛКИ ПОВОРОТОВ НА ЛИНИИ МАРШРУТА — расположение и размеры как у навигатора `navigator-main`
- * (`sdk/.../map/RouteArrows.kt`, `RouteArrowLayers.kt`), а тот — по Organic Maps
- * (`libs/drape_frontend/route_renderer.cpp`, форма — `data/styles/default/light/symbols/route-arrow.svg`;
- * Apache-2.0, см. `porting/navigator-main.md`). Чистая геометрия, без GL: веб рисует её своими
- * многоугольниками (`Polygon`: тень, обводка, заливка), порты (`ManeuverArrows.kt`,
- * `ManeuverArrows.swift`) — так же; сверка — общие фикстуры `kmp/fixtures/maneuver-arrows`
- * (`node scripts/export-maneuver-arrows-fixture.mjs`).
- *
- * ★ РАСПОЛОЖЕНИЕ. Хвост — `BEFORE_M` (22 м) до узла манёвра, конец древка — `AFTER_M` (18 м) после
- * него: длина как у стрелки Яндекс.Навигатора (~40 м), по просьбе пользователя 08.10.2026 — стрелка
- * navigator-main / Organic Maps (36 + 54 = 90 м) на городских поворотах была слишком длинной. Близкие
- * манёвры (не дальше `NEARBY_M`, 50 м, друг от друга) — ОДНА стрелка от хвоста первого до головы
- * последнего: две короткие стрелки на одном перекрёстке читаются хуже одной изогнутой. Манёвр ближе
- * `END_MARGIN_M` к началу или концу трассы стрелки не получает.
- *
- * ★ РАЗМЕР — В ПИКСЕЛЯХ ЭКРАНА ПО ЗУМУ (как слои MapLibre у `navigator-main`), а не в метрах: древко
- * 5 → 10 → 12 px на z14/16/18, обводка 8 → 16 → 19 px, наконечник (треугольник 30×18 px с белым
- * 22×12 px внутри) — ×0.5 → ×1 → ×1.15; между узлами — линейно, за краями — край. Ниже `MIN_ZOOM` (14)
- * стрелок нет. Пиксели переводятся в метры по `metersPerPixel` на широте трассы; геометрию держит
- * кэш по ступени зума `ZOOM_STEP` (⅛: ширина прыгает не больше чем на 9 %).
- *
- * ★ ФОРМА. Древко идёт РОВНО ПО ТРАССЕ — своего сглаживания нет: скругляется сама трасса
- * (`route-round.ts`, радиус `ROUTE_ROUND.RADIUS_M`), и стрелка, построенная по скруглённой трассе,
- * лежит на линии маршрута по всей дуге (раньше ось сглаживалась своим ядром, и на повороте стрелка
- * уходила с угловатой линии). Сзади древко кончается полукругом, как круглый конец линии MapLibre. Наконечник —
- * прямой треугольник ЗА концом древка по его последнему направлению: основание обводки — ровно на
- * конце древка, белый — на `HEAD_FILL_INSET_PX` дальше (у `navigator-main` это значок с якорем
- * `bottom` в конце линии). Оформление: белая заливка, синяя обводка `#055FCD` и лёгкая тень (обводка,
- * раздутая на `SHADOW_PX`) — тень наша, на объёмной карте стрелка без неё «прилипает» к асфальту.
- *
- * ★ МЕТРЫ — МЕРОЙ ЛИНИИ МАРШРУТА (`routeLine`, `linkM`): манёвры приходят метрами той же трассы
- * (`metresAlong` по точкам шагов).
- *
- * ★ ГАСНЕТ ПЛАВНО, КАК ЛЕНТА (26.10.2026, просьба владельца «стрелки в поворотах исчезали плавно, как лента
- * маршрута»). Раньше стрелка снималась целиком на метре конца древка (`toM`): машина ещё не доехала до острия,
- * а стрелка пропадала ступенькой; смена трассы, вида (линия ↔ лента) и порог `MIN_ZOOM` — тоже ступенькой.
- * Теперь два закона, оба — общие с лентой:
- *  · ПРОЙДЕННОЕ РАСТВОРЯЕТСЯ ПОЗАДИ МАШИНЫ ПО МЕТРУ ТРАССЫ: у каждой точки колец — метр трассы
- *    (`fillStations`/`casingStations`/`shadowStations`, проекция на ось стрелки), площади рисуются с
- *    `MapObject.along` (метр машины, `PASS_FADE_M` = `RIBBON_PASS_FADE_M`, сторона +1) — тот же шейдер и тот же
- *    `alongFadeFactor`, что у ленты (`RibbonAreas.passAt`), без пересборки. Стрелка видна, пока её дальний край
- *    (`endM`, острие тени) не ушёл за длину растворения (`shownManeuverArrows(…, passFadeM)`) — к этому метру она
- *    уже прозрачна вся;
- *  · СНЯТИЕ ЦЕЛИКОМ — ПО ВРЕМЕНИ (`ArrowFades`): стрелка, ушедшая из набора (другая трасса, вид линия ↔ лента,
- *    порог зума, выключатель), гаснет за `RIBBON_BLEND_MS` тем же законом, что кросс-фейд «лента ↔ линия»
- *    (`RibbonBlend`: шаг за кадр не больше `RIBBON_BLEND_STEP_MAX_MS`, доля `smoothstep`), а новая так же
- *    проявляется. Смена СТУПЕНИ зума — тот же ключ: множитель переходит к стрелке новой ступени сразу (стрелки
- *    соседних ступеней стоят наготове, 1ddcb20a).
- */
-
-/** Константы стрелки: метры (`_M`), пиксели экрана (`_PX`) и узлы «зум → пиксели» (`[зум, px]`). */
-declare const MANEUVER_ARROW: {
-    /** Хвост — столько до узла (первого) манёвра. */
-    readonly BEFORE_M: 22;
-    /** Конец древка — столько после узла (последнего) манёвра; наконечник — за ним. */
-    readonly AFTER_M: 18;
-    /** Манёвры не дальше этого друг от друга — одна стрелка. */
-    readonly NEARBY_M: 50;
-    /** Ближе этого к началу или концу трассы манёвр стрелки не получает. */
-    readonly END_MARGIN_M: 3;
-    /** Ниже этого зума стрелок нет. */
-    readonly MIN_ZOOM: 14;
-    /** Ширина белого древка, px по зуму. */
-    readonly BODY_PX: ReadonlyArray<readonly [number, number]>;
-    /** Ширина синей обводки древка (вся, не кайма), px по зуму. */
-    readonly BORDER_PX: ReadonlyArray<readonly [number, number]>;
-    /** Множитель наконечника по зуму. */
-    readonly HEAD_SCALE: ReadonlyArray<readonly [number, number]>;
-    /** Наконечник обводки: полуширина основания и длина, px при множителе 1. */
-    readonly HEAD_BORDER_HALF_PX: 15;
-    readonly HEAD_BORDER_LEN_PX: 18;
-    /** Белый наконечник: полуширина, длина и отступ основания от конца древка, px при множителе 1. */
-    readonly HEAD_FILL_HALF_PX: 11;
-    readonly HEAD_FILL_LEN_PX: 12;
-    readonly HEAD_FILL_INSET_PX: 3;
-    /** Скругление углов (остриё остаётся острым) и тень, px. */
-    readonly ROUND_PX: 0.75;
-    readonly SHADOW_PX: 2.5;
-    /** Шаг дуги скругления, радианы. */
-    readonly ARC_STEP: number;
-    /** Шаг переразбивки оси, метры (своего сглаживания нет — ось = трасса). */
-    readonly STEP_M: 1;
-    /** Цвета и прозрачности: белая стрелка, синяя обводка (`navigator-main`), лёгкая тень. */
-    readonly FILL: "#ffffff";
-    readonly CASING: "#055fcd";
-    readonly SHADOW: "#0b1a3a";
-    readonly FILL_OPACITY: 1;
-    readonly CASING_OPACITY: 1;
-    readonly SHADOW_OPACITY: 0.18;
-    /**
-     * Высота над отметкой трассы — ТА ЖЕ, ЧТО У ЛИНИИ МАРШРУТА и ленты по полосам (`OVERLAY_ALTITUDE`,
-     * `ROUTE_TOP` в `ld-roads.ts`): стрелка лежит на одной с ними поверхности, на эстакаде — на настиле
-     * (отметка трассы под каждой вершиной, `routeLiftField`). Над линией её держит порядок (`Z_*`), над
-     * асфальтом — сдвиг глубины прохода объектов. Было 0.4 — над лентой на 0.34.
-     */
-    readonly LIFT_M: 0.28;
-    /** Порядок среди объектов: над пройденной линией (21). */
-    readonly Z_SHADOW: 23;
-    readonly Z_CASING: 24;
-    readonly Z_FILL: 25;
-    /** Ступень зума для кэша геометрии. */
-    readonly ZOOM_STEP: 0.125;
-    /** Длина растворения пройденной части позади машины, метры — та же, что у ленты (`RIBBON_PASS_FADE_M`). */
-    readonly PASS_FADE_M: 20;
-};
-/** Манёвр на трассе: метр (мерой линии маршрута) и вид шага (`type` + `modifier`, как у `/route`). */
-interface ManeuverAt {
-    atM: number;
-    type: string;
-    modifier?: string;
-}
-/** Стрелка манёвра (или группы близких манёвров). Кольца замкнуты (первая точка повторена в конце), против часовой. */
-interface ManeuverArrow {
-    /** Номер первого манёвра группы во входном списке. */
-    index: number;
-    /** Номера всех манёвров группы (по ходу). */
-    indices: number[];
-    /** Метр первого манёвра группы. */
-    atM: number;
-    /** Метры трассы, которые занимает древко: от хвоста до основания наконечника. */
-    fromM: number;
-    toM: number;
-    /** Сглаженная ось древка от хвоста до основания наконечника. */
-    line: LonLat[];
-    /** Сама стрелка (белая). */
-    fill: LonLat[];
-    /** Синяя обводка — шире древко и больше наконечник. */
-    casing: LonLat[];
-    /** Лёгкая тень — обводка, раздутая на `SHADOW_PX`. */
-    shadow: LonLat[];
-    /**
-     * Метр трассы в каждой точке колец (`fill`, `casing`, `shadow`; та же длина, замыкающая точка — тоже): проекция на
-     * ось стрелки, доля её длины — в метры `fromM…toM`, за концами оси — продолжение по прямой (хвост, острие). По ним
-     * площадь растворяется позади машины (`RouteArea.stations` + `MapObject.along`). Мера — та же, что у `fromM`/`toM`.
-     */
-    fillStations: number[];
-    casingStations: number[];
-    shadowStations: number[];
-    /** Дальний край стрелки по трассе — наибольший метр точек тени (острие с тенью). */
-    endM: number;
-}
-interface ManeuverArrowOptions {
-    /** Зум, под который строятся размеры (по умолчанию 16 — множитель наконечника 1). */
-    zoom?: number;
-    /** Метры в пикселе экрана; по умолчанию — `metersPerPixel` на широте начала трассы и зуме `zoom`. */
-    metersPerPixel?: number;
-}
-/** Размеры стрелки в метрах на зуме. */
-interface ManeuverArrowSize {
-    bodyHalfM: number;
-    borderHalfM: number;
-    headBorderHalfM: number;
-    headBorderLenM: number;
-    headFillHalfM: number;
-    headFillLenM: number;
-    headFillInsetM: number;
-    roundM: number;
-    shadowM: number;
-}
-/**
- * Нужна ли манёвру стрелка — `hasRouteArrow` у `navigator-main`: настоящие повороты, развилки, съезды
- * и кольцо — всегда; `continue`/`new name` — только если дорога меняет направление (модификатор не
- * «прямо»); старт, финиш, полосы, уведомления — нет.
- */
-declare function maneuverNeedsArrow(type: string, modifier?: string): boolean;
-/** Значение узлов `[зум, значение]` на зуме: между узлами — линейно, за краями — край (как `interpolate` MapLibre). */
-declare function zoomStops(stops: ReadonlyArray<readonly [number, number]>, zoom: number): number;
-/** Ступень зума для кэша геометрии (`ZOOM_STEP`); `Math.round` веба. */
-declare function maneuverArrowZoomStep(zoom: number): number;
-/** Размеры стрелки в метрах: пиксели узлов на зуме `zoom`, умноженные на метры в пикселе. */
-declare function maneuverArrowSize(zoom: number, metersPerPixel: number): ManeuverArrowSize;
-/**
- * Контур, раздутый наружу на `d` со СКРУГЛЁННЫМИ выпуклыми углами (сумма Минковского с кругом —
- * то же, что сдвиг порога знакового расстояния у шейдера пробок). Кольцо против часовой, без повтора
- * первой точки. Вогнутые углы — пересечением сдвинутых сторон.
- */
-declare function inflateRound(ring: XY[], d: number): XY[];
-/**
- * Стрелки манёвров на трассе `geometry` (`[lon, lat]` по ходу). `maneuvers` — метры манёвров мерой
- * линии маршрута (по возрастанию не обязательно). Стрелка — каждому, кому она нужна
- * (`maneuverNeedsArrow`); манёвры не дальше `NEARBY_M` друг от друга — одной стрелкой.
- */
-declare function maneuverArrows(geometry: LonLat[], maneuvers: ManeuverAt[], opts?: ManeuverArrowOptions): ManeuverArrow[];
-/**
- * СТРЕЛКА ЛЕНТЫ — доли ширины полосы ленты (как стрелки полосного вида Apple Maps и Google): белое
- * древко ≈ 60 % ширины ленты, синяя обводка ≈ 72 %, наконечник — почти во всю ширину, но внутри неё.
- */
-declare const RIBBON_ARROW: {
-    readonly BODY: 0.3;
-    readonly BORDER: 0.36;
-    readonly HEAD_FILL_HALF: 0.4;
-    readonly HEAD_BORDER_HALF: 0.47;
-    readonly HEAD_FILL_LEN: 0.9;
-    readonly HEAD_BORDER_LEN: 1.1;
-    readonly HEAD_FILL_INSET: 0.15;
-    readonly ROUND: 0.05;
-    readonly SHADOW: 0.04;
-    /** Лента должна идти за узлом манёвра хотя бы столько, чтобы у стрелки была голова на ленте. */
-    readonly MIN_AFTER_M: 8;
-    /**
-     * Голова — на выходе из поворота: если у конца древка лента ещё поворачивает (разворот, крутой
-     * поворот — направление на `SETTLE_PROBE_M` вперёд меняется больше `SETTLE_DEG`), конец сдвигается
-     * вперёд шагом `SETTLE_STEP_M`, но не дальше `SETTLE_MAX_M` за последним узлом.
-     */
-    readonly SETTLE_PROBE_M: 4;
-    /** Вперёд направление берётся на `SETTLE_AHEAD_M` — прямой кусок посреди разворота (через разделитель) не считается выходом. */
-    readonly SETTLE_AHEAD_M: 12;
-    readonly SETTLE_TAIL_M: 6;
-    readonly SETTLE_DEG: 15;
-    readonly SETTLE_STEP_M: 1;
-    readonly SETTLE_MAX_M: 40;
-};
-/**
- * СТРЕЛКИ МАНЁВРОВ НА ЛЕНТЕ ПО ПОЛОСАМ: ось — сама основная лента (`band`: та же дорожка по полосам,
- * что рисует лента, — с поворотом и разворотом), ширина — доли ширины ленты у узла манёвра (`RIBBON_ARROW`),
- * голова — у выхода, внутри ленты (ось не продлевается за её конец). Группы манёвров и длины — как у
- * стрелок линии (`BEFORE_M`, `AFTER_M`, `NEARBY_M`). `maneuvers` — метры мерой ИСХОДНОЙ трассы ленты
- * (как станции её фич). Манёвр, у которого ленты нет (узел вне основной ленты или лента кончается
- * раньше `MIN_AFTER_M` за ним), стрелки ленты не получает — у него остаётся стрелка линии.
- */
-declare function ribbonManeuverArrows(ribbon: Ribbon, maneuvers: ManeuverAt[]): ManeuverArrow[];
-/**
- * Какие стрелки показывать: ниже `MIN_ZOOM` — никакие; выше — все, кроме пройденных (`null` — ведения нет).
- * Пройденная без растворения (`passFadeM` = 0) — конец древка позади `progressM`; с растворением позади машины
- * (`passFadeM` > 0, обычно `PASS_FADE_M`) — дальний край стрелки (`endM`) позади `progressM − passFadeM`: там она
- * прозрачна вся, и снятие не видно. Возвращает номера в списке `arrows`.
- */
-declare function shownManeuverArrows(arrows: ManeuverArrow[], progressM: number | null, zoom: number, passFadeM?: number): number[];
-/**
- * ПОЯВЛЕНИЕ И СНЯТИЕ СТРЕЛОК ПО ВРЕМЕНИ — тем же законом, что кросс-фейд «лента ↔ линия» (`RibbonBlend`). Ключ —
- * стрелка в своём виде (слой решает сам: поколение трассы, вид линия/лента, первый манёвр группы; ступень зума в ключ
- * НЕ входит — смена ступени мгновенна). У ключа значение `t` 0…1 и цель (видна / снята):
- *  · `show(keys)` — видны ровно эти; новый ключ заводится с `t` = 0 и проявляется, прочие гаснут;
- *  · `tick(nowMs)` — кадр: `t` идёт к цели со скоростью `1 / RIBBON_BLEND_MS`, за кадр не больше
- *    `RIBBON_BLEND_STEP_MAX_MS` часов; первый кадр, пропуск дольше секунды и часы назад — без шага. Снятый ключ,
- *    дошедший до нуля, убирается (`gone` — их список за этот кадр: слою пора снять его объекты). true — переход идёт;
- *  · `settle()` — сразу к цели, без перехода (слой без часов: проверки);
- *  · `alpha(key)` — множитель прозрачности объектов ключа: `smoothstep(t)`; нет ключа — 0.
- */
-declare class ArrowFades {
-    private items;
-    private at;
-    /** Ключи, снятые до нуля последним `tick`/`settle`. */
-    gone: string[];
-    show(keys: Iterable<string>): void;
-    tick(nowMs: number): boolean;
-    settle(): void;
-    alpha(key: string): number;
-    has(key: string): boolean;
-    /** Переход идёт хоть у одного ключа. */
-    get animating(): boolean;
-}
-
-export { LD_MARK_PREFIX as $, ABSENT_RETRY_MS as A, type BuildOptions as B, CAP_SEGMENTS as C, DEFAULT_RIBBON_CAP as D, EMPTY_GEOJSON as E, FAR_VIEW as F, type Frame as G, GROUND_LAYERS as H, GROUND_TOP as I, GUIDANCE_URL as J, type GuideFrame as K, HINT_M as L, type HeightAt as M, type HintLane as N, JOIN_M as O, LANE_CAR_SLOPE_M as P, LANE_CAR_STEP_M as Q, LANE_MIN_ZOOM as R, LANE_OFF_ZOOM as S, LANE_ON_ZOOM as T, LANE_PROGRESS_MIN_MS as U, LANE_RIBBON_CHEVRON_LAYER as V, LANE_SOURCE as W, LD_AFTER as X, LD_INDEX_PATH as Y, LD_LAYER_PREFIX as Z, LD_MARK_FADE_ZOOM as _, ARROW_TIP_K as a, PUCK_GLIDE_MAX_MS as a$, LD_SOURCE as a0, LEVEL_HEIGHT_M as a1, type LaneCarLayer as a2, type LaneCarTrack as a3, LaneGuide as a4, type LaneHint as a5, type LanePlan as a6, type LanePlanRequest as a7, type LaneRoute as a8, type LaneState as a9, type NavCarPart as aA, type NavCarPose as aB, type NavFix as aC, NavFixFilter as aD, type NavFixVerdict as aE, NavProgress as aF, type NavProgressOut as aG, NavPuck as aH, OBJECTS3D_LAYER_ID as aI, OBJECTS3D_LAYOUT as aJ, OBJECTS3D_SOURCE as aK, OUTLINE_STEP_M as aL, OUTSIDE_LANE_M as aM, OVERLAY_ALTITUDE as aN, type OutsideOptions as aO, PASSED_MIN_M as aP, PROG_AHEAD as aQ, PROG_BACK_CONFIRM as aR, PROG_BACK_M as aS, PROG_BACK_MIN as aT, PROG_COARSE_HOLD_MS as aU, PROG_JUMP_CONFIRM as aV, PROG_NEAR_M as aW, PROG_NEAR_MPS as aX, PROG_SWITCH_M as aY, PROG_WIDE_M as aZ, PROG_WIDE_ON_M as a_, type LdIndex as aa, type LdStyle as ab, type LiftField as ac, type LiftProfile as ad, type LonLat as ae, MANEUVER_ARROW as af, type ManeuverArrow as ag, type ManeuverArrowOptions as ah, type ManeuverArrowSize as ai, type ManeuverAt as aj, type Mask as ak, type Measured as al, NAV_ARROW as am, NAV_ARROW_PALETTES as an, NAV_CAR as ao, NAV_CAR_BODIES as ap, NAV_CAR_KINDS as aq, NAV_CAR_LABELS as ar, type NavArrowPalette as as, type NavCarBody as at, type NavCarHost as au, type NavCarIcon as av, type NavCarKind as aw, type NavCarMaterial as ax, type NavCarModelKind as ay, NavCarOverlay as az, type AreaFrame as b, type RoutePiece as b$, PUCK_GLIDE_MIN_MS as b0, PUCK_STILL_MAX_M as b1, PUCK_STILL_MIN_M as b2, PUCK_STILL_MPS as b3, PUCK_TELEPORT_M as b4, type PassArea as b5, type PassChevron as b6, type PlanChange as b7, type PlanLane as b8, type PlanManeuver as b9, ROUTE_PASS_FADE_M as bA, ROUTE_POINT_COLORS as bB, ROUTE_POSE_SPAN_M as bC, ROUTE_ROUND as bD, ROUTE_TOP as bE, ROUTE_TRAFFIC as bF, type Ribbon as bG, type RibbonArea as bH, RibbonAreas as bI, RibbonBlend as bJ, type RibbonCap as bK, type RibbonCar as bL, type RibbonChevron as bM, type RibbonFade as bN, type RibbonFeature as bO, RibbonGeoJson as bP, type RibbonGeoJsonData as bQ, type RibbonGeoJsonFeature as bR, type RibbonKind as bS, type RibbonPiece as bT, type RoadbedMode as bU, type RoundedRoute as bV, type RouteLiftAt as bW, type RouteLine as bX, type RouteLineOptions as bY, type RouteLinePiece as bZ, type RouteManeuver as b_, type PlanSegment as ba, RAMP_SLOPE as bb, RIBBON_AREA_PAINT as bc, RIBBON_ARROW as bd, RIBBON_BLEND_MS as be, RIBBON_BLEND_STEP_MAX_MS as bf, RIBBON_CAPS as bg, RIBBON_CHEVRON as bh, RIBBON_FADE_M as bi, RIBBON_FADE_REACH_M as bj, RIBBON_FADE_STEP_M as bk, RIBBON_MARGIN_M as bl, RIBBON_PASS_FADE_M as bm, RIBBON_PASS_MARGIN_M as bn, RIBBON_STEP_M as bo, RIBBON_TILE_Z as bp, ROADBED_FIXED_PAINT as bq, ROADBED_LAYER_IDS as br, ROADBED_SOURCE as bs, ROADBED_URL as bt, ROADMARK_LAYER_IDS as bu, ROUTE_BLUE as bv, ROUTE_LIFT_REACH_M as bw, ROUTE_LINE as bx, ROUTE_NAV_OPACITY as by, ROUTE_PASSED as bz, type AreaSpan as c, lateralAt as c$, SITE_ENDPOINTS as c0, type SceneFeature as c1, type SurfaceAt as c2, type SurfaceMesh as c3, THEME_ATLAS_DAY as c4, THEME_ATLAS_NIGHT as c5, THEME_DARK as c6, THEME_DARK_TONE as c7, THEME_ICE as c8, THEME_ICE_TONE as c9, fetchLanePlan as cA, fmt1 as cB, fmt4 as cC, fracIndex as cD, frameAt as cE, fromUnits as cF, groundUnderBed as cG, guidanceCamera as cH, heightsFromScene as cI, hintAt as cJ, hintFor as cK, hintNear as cL, iceThemeFor as cM, inflateRound as cN, isAtlasTheme as cO, isDarkTheme as cP, isIceTheme as cQ, isNetworkFix as cR, isOldFix as cS, isRibbonCap as cT, laneCarPose as cU, laneCarShift as cV, laneCarTrack as cW, lanePlanRequest as cX, laneRibbonLayerIds as cY, laneRibbonLayers as cZ, laneTrack as c_, THEME_LIGHT as ca, THEME_LIGHT_TONE as cb, TILE_EXTENT as cc, TURN_MIN_DEG as cd, TURN_WINDOW_M as ce, type Track as cf, type TrafficSpan as cg, WIDTH_SMOOTH_PTS as ch, type XY as ci, areaFrame as cj, areaSpans as ck, bearingAt as cl, buildRibbon as cm, capPoints as cn, carWeight as co, chevronRunBase as cp, cityStyle as cq, closeness as cr, contiguousGroups as cs, cutInset as ct, densify as cu, edgesOf as cv, evenWidths as cw, fadeRibbonArea as cx, fadeRibbonLine as cy, fallbackHeight as cz, ArrowFades as d, ribbonProgressState as d$, ldLayerIds as d0, ldRoadbedPath as d1, ldSource as d2, ldStylePath as d3, liftProps as d4, liftPropsOf as d5, lineBetween as d6, linkM as d7, maneuverArrowSize as d8, maneuverArrowZoomStep as d9, normalsOf as dA, objects3dSource as dB, offsetLine as dC, offsetPoint as dD, originOf as dE, outlineOf as dF, outsideRanges as dG, parseLanePlan as dH, parseLdIndex as dI, parseLdStyle as dJ, passedKind as dK, passedLineOptions as dL, passedPieces as dM, pointAt as dN, pointOn as dO, project as dP, resampleLine as dQ, resetLanePlanAbsence as dR, resolveUrl as dS, ribbonAtProgress as dT, ribbonChevrons as dU, ribbonFade as dV, ribbonFadeAlpha as dW, ribbonGeoJson as dX, ribbonLineHidden as dY, ribbonManeuverArrows as dZ, ribbonPassChevrons as d_, maneuverArrows as da, maneuverNeedsArrow as db, maskOf as dc, measure as dd, measureRoute as de, mergeRanges as df, meshSurface as dg, metresAlong as dh, minusMask as di, mixLevel as dj, mixLonLat as dk, mixNum as dl, navArrowOutline as dm, navCarColor as dn, navCarGlb as dp, navCarHash as dq, navCarIcon as dr, navCarIconSvg as ds, navCarKind as dt, navCarLiftAt as du, navCarMesh as dv, navCarModelId as dw, navCarPose as dx, naviGramSources as dy, normalCdf as dz, CAR_OUTSIDE_WEIGHT as e, roadbedLayerIds as e0, roadbedModeFilters as e1, roadbedSource as e2, roadbedStyle as e3, roundRoute as e4, roundedMetre as e5, roundedPoint as e6, roundedPose as e7, roundedRanges as e8, roundedSpans as e9, stationsBetween as eA, tangentAt as eB, terrainStyle as eC, themeFor as eD, themeForRoadbed as eE, themeV2 as eF, tileParts as eG, toUnits as eH, trackAt as eI, trafficSegments as eJ, upcoming as eK, valueAt as eL, withAbsoluteTiles as eM, withLaneRibbon as eN, withLdRoads as eO, withObjects3D as eP, withWindowsInTone as eQ, zoomStops as eR, routeLiftAt as ea, routeLiftField as eb, routeLiftProfiles as ec, routeLine as ed, routeLineAlong as ee, routeLineOptions as ef, routeLinePieces as eg, routeMeasure as eh, routePieces as ei, routePointColor as ej, routeSurfaceField as ek, routeTrafficBlendM as el, routeTrafficColor as em, routeTrafficLevel as en, shownManeuverArrows as eo, simplifyIdx as ep, sliceAt as eq, sliceLine as er, smoothCorners as es, smoothWidths as et, smoothstep as eu, snapWindow as ev, spanLine as ew, spanOutline as ex, spansForPiece as ey, spreadStations as ez, CHEVRON_MIN_RUN_M as f, CHEVRON_TOLERANCE_M as g, CHUNK_M as h, CLOSE_M as i, CLOSE_VIEW as j, CORNER_DEG as k, CORNER_SMOOTH_M as l, CUT_BLEED as m, EVEN_WIDTH_M as n, Endpoints as o, FIX_ACC_MAX as p, FIX_ACC_ROUTE as q, FIX_MAX_AGE_MS as r, FIX_NET_ACC as s, FIX_NET_HOLD_MS as t, FIX_REJECT_RESET as u, FIX_SKEW_MIN_MS as v, FIX_STREAM_JITTER_MS as w, FIX_VMAX as x, type FetchLanePlanOptions as y, type FetchLike as z };