osmgl 0.31.31 → 0.31.32

package/dist/nav.d.ts

@@ -1,3 +1,3591 @@
-export { aU as ARROW_ICONS, aV as ARROW_ICON_STROKE, aW as ARROW_PATHS, aX as CLASS_LIMIT, aY as CURSOR, aZ as CURSOR_SCALE, a_ as FOLLOW_BACK_MS, a$ as LANG_TAG, b0 as ManeuverAnnouncer, b1 as NAV_ARRIVE_M, b2 as NAV_BACK_M, b3 as NAV_BEARING_TAU, b4 as NAV_CAR_CLEAR, b5 as NAV_COAST_TAU, b6 as NAV_COLORS, b7 as NAV_DEMO, b8 as NAV_LOOK_AHEAD_M, b9 as NAV_MAX_DT, ba as NAV_MIN_VISIBLE, bb as NAV_PITCH, bc as NAV_PREDICT_MAX, bd as NAV_PULL_TAU, be as NAV_ROUTE_PULL_TAU, bf as NAV_SPEED_FALL_TAU, bg as NAV_SPEED_RISE_TAU, bh as NAV_SPOKEN_GRID, bi as NAV_STILL_MPS, bj as NAV_THRESHOLD_GRID, bk as NAV_TILT, bl as NAV_TOP_PAD, bm as NAV_TRAFFIC_COLORS, bn as NAV_TRAFFIC_LEVELS, bo as NAV_VIA_SAY_M, bp as NAV_VIEW, bq as NAV_VOICE, br as NAV_ZOOM_STICK, bs as NavAim, bt as NavBestRoute, bu as NavFeature, bv as NavFollowMode, bw as NavLang, bx as NavRoute, by as NavSayKey, bz as NavStep, bA as NavTracker, bB as NavTrafficBand, bC as NavTrip, bD as NavUpcoming, bE as NavUtterance, bF as NavViewCamera, bG as NavViewTarget, bH as NavVoiceCue, bI as NavZoomStick, bJ as OffRouteWatch, bK as SPEED_AROUND_TOLERANCE, bL as SPEED_LIMIT_HOLD_MS, bM as SPEED_QUERY_TOLERANCES, aT as SpeedLimit, bN as SpeedLimitHold, bO as SpeedVerdict, bP as SpeedWatch, bQ as ZOOM_BY_SPEED, bR as arrowPath, bS as bearing, bT as cameraCenterShift, bU as demoSpeedKmh, bV as demoTargetKmh, bW as distM, bX as distParts, bY as farThreshold, bZ as fmtDist, b_ as fmtDur, b$ as maneuverArrow, c0 as navAdvanceM, c1 as navAheadPx, c2 as navCameraCenter, c3 as navCameraShiftPx, c4 as navCarScreenY, c5 as navCursorShapes, c6 as navDemoStep, c7 as navDt, c8 as navFarText, c9 as navFarThreshold, ca as navFollowAim, cb as navFollowModeOf, cc as navFollowPitch, cd as navFollowShiftPx, ce as navHasFar, cf as navHasSpokenDistance, cg as navIsTurn, ch as navLockedCenter, ci as navManeuverPhrase, cj as navNearThreshold, ck as navPhrase, cl as navRoundedForSpeech, cm as navSay, cn as navSnapSpoken, co as navSpeechText, cp as navSpeeding, cq as navSpokenDistance, cr as navStartingLowercase, cs as navStepSpeed, ct as navStepText, cu as navTargetZoom, cv as navThen, cw as navTiltForZoom, cx as navTrafficLevel, cy as navTurnWeight, cz as navViewTarget, cA as navVoicePhrases, cB as navVoicePlan, cC as navWithDistance, cD as navZoomForAhead, cE as parseMaxspeed, cF as projectOnSegment, cG as roundDist, cH as speedLimitFromFeatures, cI as turnTo } from './model-mshqbG69.js';
-export { A as ABSENT_RETRY_MS, a as ARROW_TIP_K, b as AreaFrame, c as AreaSpan, d as ArrowFades, B as BuildOptions, C as CAP_SEGMENTS, e as CAR_OUTSIDE_WEIGHT, f as CHEVRON_MIN_RUN_M, g as CHEVRON_TOLERANCE_M, h as CHUNK_M, i as CLOSE_M, j as CLOSE_VIEW, k as CORNER_DEG, l as CORNER_SMOOTH_M, m as CUT_BLEED, D as DEFAULT_RIBBON_CAP, n as EVEN_WIDTH_M, F as FAR_VIEW, p as FIX_ACC_MAX, q as FIX_ACC_ROUTE, r as FIX_MAX_AGE_MS, s as FIX_NET_ACC, t as FIX_NET_HOLD_MS, u as FIX_REJECT_RESET, v as FIX_SKEW_MIN_MS, w as FIX_STREAM_JITTER_MS, x as FIX_VMAX, y as FetchLanePlanOptions, z as FetchLike, G as Frame, J as GUIDANCE_URL, K as GuideFrame, L as HINT_M, M as HeightAt, N as HintLane, O as JOIN_M, P as LANE_CAR_SLOPE_M, Q as LANE_CAR_STEP_M, S as LANE_OFF_ZOOM, T as LANE_ON_ZOOM, a1 as LEVEL_HEIGHT_M, a2 as LaneCarLayer, a3 as LaneCarTrack, a4 as LaneGuide, a5 as LaneHint, a6 as LanePlan, a7 as LanePlanRequest, a8 as LaneRoute, a9 as LaneState, ae as LonLat, af as MANEUVER_ARROW, ag as ManeuverArrow, ah as ManeuverArrowOptions, ai as ManeuverArrowSize, aj as ManeuverAt, ak as Mask, al as Measured, am as NAV_ARROW, an as NAV_ARROW_PALETTES, ao as NAV_CAR, ap as NAV_CAR_BODIES, aq as NAV_CAR_KINDS, ar as NAV_CAR_LABELS, as as NavArrowPalette, at as NavCarBody, au as NavCarHost, av as NavCarIcon, aw as NavCarKind, ax as NavCarMaterial, ay as NavCarModelKind, az as NavCarOverlay, aA as NavCarPart, aB as NavCarPose, aC as NavFix, aD as NavFixFilter, aE as NavFixVerdict, aF as NavProgress, aG as NavProgressOut, aH as NavPuck, aL as OUTLINE_STEP_M, aM as OUTSIDE_LANE_M, aO as OutsideOptions, aP as PASSED_MIN_M, aQ as PROG_AHEAD, aR as PROG_BACK_CONFIRM, aS as PROG_BACK_M, aT as PROG_BACK_MIN, aU as PROG_COARSE_HOLD_MS, aV as PROG_JUMP_CONFIRM, aW as PROG_NEAR_M, aX as PROG_NEAR_MPS, aY as PROG_SWITCH_M, aZ as PROG_WIDE_M, a_ as PROG_WIDE_ON_M, a$ as PUCK_GLIDE_MAX_MS, b0 as PUCK_GLIDE_MIN_MS, b1 as PUCK_STILL_MAX_M, b2 as PUCK_STILL_MIN_M, b3 as PUCK_STILL_MPS, b4 as PUCK_TELEPORT_M, b5 as PassArea, b6 as PassChevron, b7 as PlanChange, b8 as PlanLane, b9 as PlanManeuver, ba as PlanSegment, bb as RAMP_SLOPE, bd as RIBBON_ARROW, be as RIBBON_BLEND_MS, bf as RIBBON_BLEND_STEP_MAX_MS, bg as RIBBON_CAPS, bh as RIBBON_CHEVRON, bi as RIBBON_FADE_M, bj as RIBBON_FADE_REACH_M, bk as RIBBON_FADE_STEP_M, bl as RIBBON_MARGIN_M, bm as RIBBON_PASS_FADE_M, bn as RIBBON_PASS_MARGIN_M, bo as RIBBON_STEP_M, bp as RIBBON_TILE_Z, bG as Ribbon, bH as RibbonArea, bI as RibbonAreas, bJ as RibbonBlend, bK as RibbonCap, bL as RibbonCar, bM as RibbonChevron, bN as RibbonFade, bO as RibbonFeature, bS as RibbonKind, bT as RibbonPiece, bX as RouteLine, b_ as RouteManeuver, b$ as RoutePiece, c2 as SurfaceAt, c3 as SurfaceMesh, cc as TILE_EXTENT, cd as TURN_MIN_DEG, ce as TURN_WINDOW_M, cf as Track, ch as WIDTH_SMOOTH_PTS, ci as XY, cj as areaFrame, ck as areaSpans, cl as bearingAt, cm as buildRibbon, cn as capPoints, co as carWeight, cp as chevronRunBase, cr as closeness, cs as contiguousGroups, ct as cutInset, cu as densify, cv as edgesOf, cw as evenWidths, cx as fadeRibbonArea, cy as fadeRibbonLine, cz as fallbackHeight, cA as fetchLanePlan, cB as fmt1, cC as fmt4, cD as fracIndex, cE as frameAt, cF as fromUnits, cH as guidanceCamera, cJ as hintAt, cK as hintFor, cL as hintNear, cN as inflateRound, cR as isNetworkFix, cS as isOldFix, cT as isRibbonCap, cU as laneCarPose, cV as laneCarShift, cW as laneCarTrack, cX as lanePlanRequest, c_ as laneTrack, c$ as lateralAt, d4 as liftProps, d5 as liftPropsOf, d6 as lineBetween, d7 as linkM, d8 as maneuverArrowSize, d9 as maneuverArrowZoomStep, da as maneuverArrows, db as maneuverNeedsArrow, dc as maskOf, dd as measure, de as measureRoute, df as mergeRanges, dg as meshSurface, dh as metresAlong, di as minusMask, dj as mixLevel, dk as mixLonLat, dl as mixNum, dm as navArrowOutline, dn as navCarColor, dp as navCarGlb, dq as navCarHash, dr as navCarIcon, ds as navCarIconSvg, dt as navCarKind, du as navCarLiftAt, dv as navCarMesh, dw as navCarModelId, dx as navCarPose, dz as normalCdf, dA as normalsOf, dC as offsetLine, dD as offsetPoint, dF as outlineOf, dG as outsideRanges, dH as parseLanePlan, dK as passedKind, dM as passedPieces, dN as pointAt, dO as pointOn, dP as project, dQ as resampleLine, dR as resetLanePlanAbsence, dT as ribbonAtProgress, dU as ribbonChevrons, dV as ribbonFade, dW as ribbonFadeAlpha, dY as ribbonLineHidden, dZ as ribbonManeuverArrows, d_ as ribbonPassChevrons, d$ as ribbonProgressState, ed as routeLine, eh as routeMeasure, ei as routePieces, ek as routeSurfaceField, eo as shownManeuverArrows, ep as simplifyIdx, eq as sliceAt, er as sliceLine, es as smoothCorners, et as smoothWidths, eu as smoothstep, ev as snapWindow, ew as spanLine, ex as spanOutline, ez as spreadStations, eA as stationsBetween, eB as tangentAt, eG as tileParts, eH as toUnits, eI as trackAt, eK as upcoming, eL as valueAt, eR as zoomStops } from './nav-C8QvUodP.js';
-import 'polygon-clipping';
+import { Geom } from 'polygon-clipping';
+
+/** Константы расписания объявлений (метры, секунды, м/с). */
+declare const NAV_VOICE: {
+    /** Запас на произнесение реплики: `m_startBeforeSecondsVehicle` Organic Maps и его зажим. */
+    readonly ADVANCE_SECONDS: 8;
+    readonly ADVANCE_MIN_M: 35;
+    readonly ADVANCE_MAX_M: 150;
+    /** Предупреждение с дистанцией: `m_timeSeconds` и зажим метрической системы. */
+    readonly FAR_SECONDS: 30;
+    readonly FAR_MIN_M: 200;
+    readonly FAR_MAX_M: 2000;
+    /** Шаг короче — предупреждения нет (`m_minDistToSayNotificationMeters`). */
+    readonly TOO_CLOSE_M: 170;
+    /** Наименьший разрыв между предупреждением и командой. */
+    readonly MIN_GAP_M: 40;
+    /** Следующий манёвр не дальше этого И не дольше этого — одной фразой («…, затем налево»). */
+    readonly MERGE_MAX_M: 120;
+    readonly MERGE_MAX_S: 8;
+    /** Скорость шага, когда сервер не дал длительности (30 км/ч). */
+    readonly FALLBACK_SPEED_MPS: 8.33;
+    /** Порог прошёл не дальше этого — говорим фразу плана как есть; дальше — дистанцию пересчитываем. */
+    readonly FRESH_M: 30;
+};
+/** Произносимые дистанции — `GetAllSoundedDistMeters()` Organic Maps. */
+declare const NAV_SPOKEN_GRID: number[];
+/** Пороги, к которым округляется вверх дистанция объявления, — `GetSoundedDistMeters()` Organic Maps. */
+declare const NAV_THRESHOLD_GRID: number[];
+/** Дистанция словами есть только для ru и en: tg/uz говорят шаблоном с цифрой (`navPhrase`). */
+declare function navHasSpokenDistance(lang: string): boolean;
+/** Порог объявления → что сказать: округление ВВЕРХ до `NAV_THRESHOLD_GRID` (выше сетки — её край). */
+declare function navRoundedForSpeech(meters: number): number;
+/**
+ * Слово сетки произносимых дистанций — `DistToTextId` Organic Maps: первое не меньшее, но предыдущее,
+ * если до него вдвое ближе («130 → 100, 135 → 200»).
+ */
+declare function navSnapSpoken(meters: number): number;
+/** «Через триста метров» / «In three hundred meters»; для других языков — `null`. */
+declare function navSpokenDistance(lang: string, meters: number): string | null;
+/** Первая буква строчная (фраза приклеивается к дистанции одним выдохом); аббревиатуру не трогаем. */
+declare function navStartingLowercase(text: string): string;
+/** «Через триста метров поверните направо» — без запятой; нет слов для языка — фраза как есть. */
+declare function navWithDistance(lang: string, meters: number, phrase: string): string;
+/**
+ * Текст сервера к синтезу (только ru): `27мкр` → «микрорайон 27» — синтез читает «двадцать семь
+ * эм-ка-эр». Словаря сокращений улиц нет сознательно: «на ул. Фирдавси» → «на улица Фирдавси» хуже.
+ */
+declare function navSpeechText(text: string, lang: string): string;
+/**
+ * Короткая фраза манёвра (ru/en — строки Organic Maps, tg/uz — свои) или `null` — своими словами сказать нечего
+ * (тогда звучит фраза сервера). `approaching` — фраза пойдёт с дистанцией (у прибытия она другая).
+ */
+declare function navManeuverPhrase(lang: string, type?: string | null, modifier?: string | null, exit?: number | null, approaching?: boolean): string | null;
+/** Связка «, затем налево» для близкого следующего манёвра; `null` — сливать нечего. */
+declare function navThen(lang: string, type?: string | null, modifier?: string | null): string | null;
+/** Скорость на шаге (м/с): длина / время сервера (с пробками); нет — `FALLBACK_SPEED_MPS`. */
+declare function navStepSpeed(step: NavStep | null | undefined): number;
+/** Запас на реплику, м. */
+declare function navAdvanceM(speed: number): number;
+/** Порог команды (без дистанции), м до манёвра. */
+declare function navNearThreshold(legM: number, speed: number): number;
+/** Порог предупреждения с дистанцией, м до манёвра. */
+declare function navFarThreshold(legM: number, speed: number): number;
+/** Есть ли у шага длиной `legM` предупреждение с дистанцией (`TooCloseForFisrtNotification` и разрыв). */
+declare function navHasFar(legM: number, speed: number): boolean;
+/** Одно объявление плана: о манёвре шага `idx`, на остатке `atM` метров до него. */
+interface NavVoiceCue {
+    idx: number;
+    kind: 'far' | 'near';
+    atM: number;
+    /** Что сказать. Пусто — сказать нечего (манёвр всё равно считается объявленным). */
+    text: string;
+    /** Произнесённая дистанция (только `far`), м. */
+    spokenM?: number;
+    /** Запас на реплику на этом шаге, м — для пересчёта дистанции, если порог проехали. */
+    advanceM: number;
+    /** Приклеенная связка «, затем …» (только `far`). */
+    then?: string;
+}
+/** Текст предупреждения: дистанция словами (ru/en) или шаблоном с цифрой (tg/uz — `navPhrase`), плюс связка. */
+declare function navFarText(lang: string, step: NavStep, spokenM: number, then: string | undefined, textOf: (s: NavStep) => string, phraseWithDistance: (lang: string, text: string, dist: number) => string): string;
+/**
+ * План объявлений трассы: для каждого манёвра (кроме старта) — команда и, если хватает места,
+ * предупреждение. Индексы — шаги `route.steps`: манёвр шага `idx` стоит в его начале, едем к нему по
+ * шагу `idx − 1` (его длина — «плечо», его скорость — скорость объявления). `textOf` — текст
+ * сервера шага на языке (`navStepText`); `phraseWithDistance` — шаблон с цифрой для tg/uz (`navPhrase`).
+ */
+declare function navVoicePlan(route: NavRoute, lang: string, textOf: (s: NavStep) => string, phraseWithDistance: (lang: string, text: string, dist: number) => string): NavVoiceCue[];
+/**
+ * На каком расстоянии ДО промежуточной точки сказать «Вы прибыли в промежуточную точку», м.
+ *
+ * Обычная «ближняя» команда звучит за 35–150 м — для прибытия это рано: человек ещё едет, а ему уже сказали, что он на
+ * месте. У финиша эту роль играет `NAV_ARRIVE_M` приложения; у промежуточной точки приложения своей проверки нет,
+ * поэтому команду ставит план — на том же расстоянии.
+ */
+declare const NAV_VIA_SAY_M = 25;
+/** Все фразы плана без повторов — для заранее синтезированных файлов (сетевые голоса). */
+declare function navVoicePhrases(plan: NavVoiceCue[]): string[];
+
+type LonLat$3 = [number, number];
+declare function distM(a: LonLat$3, b: LonLat$3): number;
+declare function bearing(a: LonLat$3, b: LonLat$3): number;
+/** Поворот курса к нужному кратчайшей дугой: без этого камера на переходе через 360° крутится назад. */
+declare function turnTo(cur: number | null, want: number, k: number): number;
+/**
+ * Шаг времени кадра, с: нечисловой или отрицательный (часы назад, первый кадр без прошлого) — ноль, то есть «стоим».
+ * Сглаживание `1 − exp(−dt/τ)` от NaN дало бы NaN, а он, попав в зум или метр, остаётся там навсегда — камера с NaN
+ * рисует пустую карту.
+ */
+declare function navDt(dt: number): number;
+/** Расстояние от точки до отрезка и доля вдоль него. */
+declare function projectOnSegment(p: LonLat$3, a: LonLat$3, b: LonLat$3, lat0: number): {
+    t: number;
+    off: number;
+};
+declare const fmtDist: (m: number) => string;
+declare const fmtDur: (s: number) => string;
+/** Расстояние крупной цифрой и мелкой единицей — так число читается быстрее. */
+declare function distParts(m: number): [string, string];
+interface NavStep {
+    type?: string;
+    modifier?: string;
+    name?: string;
+    text?: Record<string, string>;
+    distanceMeters?: number;
+    durationSeconds?: number;
+    /** Номер съезда с кольца (`maneuver.exit` OSRM), если сервер его дал. */
+    exit?: number;
+    /** Номер дороги шага («M41», несколько — через « / ») — щит в карточке манёвра; нет — пусто. */
+    ref?: string | null;
+    /** Накопленная длина до начала шага — точка, где манёвр выполняется. */
+    at: number;
+    end: number;
+}
+interface NavUpcoming {
+    idx: number;
+    step: NavStep;
+    toM: number;
+    next: NavStep | null;
+}
+interface NavTrafficBand {
+    from: number;
+    to: number;
+    length: number;
+    level: number;
+    color: string;
+}
+/** Ответ `/route/taxi/best` (уже разобранный JSON) — то, из чего строится трасса. */
+interface NavBestRoute {
+    engine?: string;
+    geometryGeoJson: string;
+    distanceMeters?: number;
+    durationSeconds?: number;
+    durationFreeflowSeconds?: number;
+    steps?: Omit<NavStep, 'at' | 'end'>[];
+    /**
+     * Пробки по трассе: с точки `at` геометрии (номер в `coordinates`) — фактор задержки `factor`
+     * (время с пробками / свободное). Нет — пробок по участкам нет, полоса считается по шагам.
+     */
+    trafficSpans?: {
+        at: number;
+        factor: number;
+    }[];
+}
+/**
+ * Загруженность — как у навигатора `navigator-main` (`congestionLevel` в `routing/RouterTraffic.kt`,
+ * цвета — `map/RouteMap.kt`): уровень 0…4 — сколько порогов `NAV_TRAFFIC_LEVELS` перешагнул фактор
+ * задержки; 0 — зелёный, 1 — жёлтый, 2 — оранжевый, 3 и 4 — красный. Те же цвета у линии маршрута
+ * (`route-line.ts`, `ROUTE_TRAFFIC`) и у полосы загруженности на панели — одна дорога, один цвет.
+ */
+declare const NAV_TRAFFIC_LEVELS: number[];
+declare const NAV_TRAFFIC_COLORS: string[];
+/** Уровень загруженности 0…4 по фактору задержки (не число — 0). */
+declare function navTrafficLevel(factor: number): number;
+/**
+ * Трасса с манёврами.
+ *
+ * Важное про шаги: у OSRM манёвр шага стоит В НАЧАЛЕ шага, а `distance` — длина дороги ПОСЛЕ него,
+ * до следующего манёвра. Поэтому «at» (накопленная длина до начала шага) — это точка, где манёвр
+ * выполняется, и пока едем по шагу i, впереди нас ждёт манёвр шага i+1. Если перепутать, карточка
+ * и голос будут называть уже пройденный поворот.
+ */
+declare class NavRoute {
+    readonly engine: string;
+    readonly coords: LonLat$3[];
+    readonly distanceM: number;
+    readonly etaSec: number;
+    readonly freeflowSec: number;
+    readonly lat0: number;
+    readonly cum: number[];
+    readonly total: number;
+    readonly steps: NavStep[];
+    /** Пробки по участкам геометрии (`at` — номер точки `coords`), по возрастанию `at`; пусто — нет. */
+    readonly trafficSpans: {
+        at: number;
+        factor: number;
+    }[];
+    constructor(best: NavBestRoute);
+    /** Индекс вершины перед точкой d (двоичным поиском — трасса может быть в тысячи вершин). */
+    private seg;
+    positionAt(d: number): LonLat$3;
+    /** Курс с упреждением: камера должна поворачивать вместе с машиной, а не после неё. */
+    headingAt(d: number, aheadM?: number): number;
+    /**
+     * Разбивка трассы по загруженности — для полосы маршрута. Есть пробки по участкам
+     * (`trafficSpans`) — по ним, метрами геометрии: ровно то, чем раскрашена линия. Нет — по шагам:
+     * темп шага (с/м) против среднего темпа этого же маршрута БЕЗ пробок. Пороги и цвета —
+     * `NAV_TRAFFIC_LEVELS`/`NAV_TRAFFIC_COLORS`.
+     */
+    trafficBands(): NavTrafficBand[];
+    /** Ближайший ещё не выполненный манёвр. */
+    upcoming(d: number): NavUpcoming | null;
+    /** Пройденная часть трассы — для «съеденной» линии под машиной. */
+    passed(d: number): LonLat$3[];
+    /**
+     * Проекция точки на трассу: сколько проехали и на сколько метров ушли в сторону. Рядом с известной
+     * позицией смотрим только окрестность — иначе на маршруте-петле точку притянет к другому концу.
+     */
+    snap(p: LonLat$3, nearD: number | null): {
+        dist: number;
+        off: number;
+    };
+}
+type NavLang = 'ru' | 'tg' | 'uz' | 'en';
+declare const LANG_TAG: Record<NavLang, string>;
+/** Текст инструкции шага на языке озвучки; нет перевода — русский. */
+declare function navStepText(s: NavStep | null, lang: string): string;
+/** Инструкция с расстоянием, по правилам каждого языка. */
+declare function navPhrase(lang: string, text: string, dist: number): string;
+declare function navSpeeding(lang: string, limit: number): string;
+type NavSayKey = 'rerouting' | 'rerouted' | 'arrived' | 'started';
+declare function navSay(lang: string, key: string): string;
+/**
+ * Прежняя схема порогов (по длине перегона) и округления. `ManeuverAnnouncer` ими больше не
+ * пользуется — расписание теперь по скорости, как у Organic Maps (`nav-voice.ts`); функции оставлены
+ * для внешних вызовов и их фикстур.
+ */
+declare function farThreshold(legM: number): number;
+/** Прежнее округление дистанции (см. `farThreshold`); озвучка теперь округляет `navRoundedForSpeech`. */
+declare function roundDist(m: number): number;
+/** Что сказать: срочное (`urgent`) говорится сразу, обрывая предыдущее; обычное — в очередь за текущим. */
+interface NavUtterance {
+    text: string;
+    urgent: boolean;
+}
+/**
+ * Голосовое сопровождение манёвров: само решает, что и когда сказать; повторов нет. Говорит не само —
+ * возвращает фразы (`say`), а синтез (браузерный, Android TTS, AVSpeech) — у приложения.
+ *
+ * Расписание — план трассы `navVoicePlan` (`nav-voice.ts`, как у навигатора `navigator-main` и Organic
+ * Maps): предупреждение с дистанцией на пороге по скорости шага и команда без дистанции на «запасе».
+ * Предупреждение идёт в очередь (не обрывает «Маршрут построен» на старте), команда — срочная.
+ * Проехали порог предупреждения дальше `NAV_VOICE.FRESH_M` (пересчёт, скачок) — дистанция
+ * пересчитывается от того, что осталось; осталось меньше разрыва до команды — предупреждения нет.
+ */
+declare class ManeuverAnnouncer {
+    lang: string;
+    private spoken;
+    private plan;
+    private planFor;
+    private planLang;
+    constructor(lang?: string);
+    reset(): void;
+    /** План объявлений трассы на текущем языке (кэш по трассе и языку). */
+    planOf(route: NavRoute, textOf: (s: NavStep | null) => string): NavVoiceCue[];
+    update(route: NavRoute, dist: number, textOf: (s: NavStep | null) => string): {
+        upcoming: NavUpcoming | null;
+        say: NavUtterance[];
+    };
+}
+/** Значения — по ПДД Таджикистана: в городе 60, в жилой зоне 20, вне города 90, на магистрали 110. */
+declare const CLASS_LIMIT: Record<string, number>;
+declare function parseMaxspeed(v: unknown): number;
+interface SpeedLimit {
+    kmh: number;
+    source: 'osm' | 'class';
+    cls?: string;
+    urban?: boolean;
+}
+/** Найденная запросом карты фича — ровно то, что ядру нужно знать о ней. */
+interface NavFeature {
+    sourceLayer?: string;
+    properties?: Record<string, unknown> | null;
+}
+/**
+ * Ограничение по фичам под машиной — чистая часть `speedLimitAt` веба (запрос карты — у приложения).
+ *
+ * `road` — фичи запроса ТОЧКОЙ с растущим допуском (3, 7, 12 px), подряд: первая проезжая дорога и
+ * есть та, по которой едем. `around` — фичи вокруг (допуск 12 px): по ним решается «в городе ли».
+ * Ничего не нашли — `null`, вызывающий оставит прежнее значение, чтобы знак не мигал.
+ */
+declare function speedLimitFromFeatures(road: NavFeature[], around: NavFeature[], exact?: boolean): SpeedLimit | null;
+/**
+ * ЗНАК НАВИГАТОРА БЕЗ МИГАНИЯ: новое значение ограничения принимается, только когда оно держится
+ * `holdMs` подряд (по всем запросам за это время). Короткий кусок другого класса на стыке, перекрёсток,
+ * съезд не перекрашивают знак туда-обратно. Первое значение — сразу; «не нашли» (`null`) знак не трогает.
+ * Время — явным `now` (мс).
+ */
+declare const SPEED_LIMIT_HOLD_MS = 4000;
+declare class SpeedLimitHold {
+    readonly holdMs: number;
+    value: SpeedLimit | null;
+    private candidate;
+    private since;
+    constructor(holdMs?: number);
+    update(limit: SpeedLimit | null, now: number): SpeedLimit | null;
+    reset(): void;
+}
+/** Допуски запроса точкой, по которым приложение собирает `road` для `speedLimitFromFeatures`. */
+declare const SPEED_QUERY_TOLERANCES: number[];
+declare const SPEED_AROUND_TOLERANCE = 12;
+interface SpeedVerdict {
+    over: boolean;
+    started: boolean;
+    shouldSpeak: boolean;
+}
+/**
+ * Контроль скорости: короткий выброс GPS не включает сирену, непрерывное превышение — включает и
+ * повторяется, пока не сбросят. Время — явным `now` (мс), ноль зарезервирован под «не начато».
+ */
+declare class SpeedWatch {
+    over: boolean;
+    private since;
+    private lastSaid;
+    private o;
+    constructor(o?: Partial<{
+        toleranceKmh: number;
+        holdMs: number;
+        repeatMs: number;
+    }>);
+    update(speedKmh: number, limitKmh: number, now: number): SpeedVerdict;
+    reset(): void;
+}
+/**
+ * Ушли от трассы дальше 45 м дольше 5 с — пора перестраивать от текущего места. `update` получает
+ * отступ от `snap` на каждом фиксе GPS; `true` — перестраивать (счётчик при этом сброшен). Звать
+ * только пока есть точка назначения: без неё навигатор страницы водителя таймер не трогал.
+ */
+declare class OffRouteWatch {
+    readonly thresholdM: number;
+    readonly holdMs: number;
+    private since;
+    constructor(thresholdM?: number, holdMs?: number);
+    update(offM: number, now: number): boolean;
+    reset(): void;
+}
+/**
+ * Прежний постоянный наклон ведения. Камера навигатора теперь берёт наклон по зуму
+ * (`navTiltForZoom`); константа осталась для тех, кто ставит камеру сам.
+ */
+declare const NAV_PITCH = 62;
+/** Отступ сверху при слежении: машина — в нижней части экрана, впереди видно больше дороги. */
+declare const NAV_TOP_PAD = 0.42;
+/** Масштаб по скорости — как в автомобильных навигаторах (км/ч → зум). */
+declare const ZOOM_BY_SPEED: [number, number][];
+/** Тронул карту — слежение выключается и возвращается само через столько миллисекунд. */
+declare const FOLLOW_BACK_MS = 12000;
+/** Шаг кадра больше этого не бывает: после паузы вкладки машина не должна прыгать. */
+declare const NAV_MAX_DT = 0.1;
+/** Сколько метров до финиша считается «прибыли». */
+declare const NAV_ARRIVE_M = 25;
+/** Целевой масштаб по скорости; манёвр ближе 150 м — приближаем ещё немного (но не ближе z18.6). */
+declare function navTargetZoom(speedKmh: number, toManeuverM: number | null): number;
+/**
+ * Наклон камеры по зуму — как у навигатора `navigator-main` (`map/NavPitch.kt`), а тот — кривая
+ * Organic Maps `ScreenBase::CalculateAutoPerspectiveAngle` (Apache-2.0). Масштаб у Organic Maps —
+ * градусы долготы на пиксель; зум osmgl, как у MapLibre, — мир в 512 px. Дальше z15.3 карта плоская,
+ * к z17.8 наклон растёт до 45°, к z19.1 — до 55°, ближе — 54.45°. На зумах ведения (16…18.6) это
+ * 28…52°: карта заваливается, когда приближается к манёвру, и выпрямляется на скорости.
+ */
+declare const NAV_TILT: {
+    readonly START_SCALE: 0.000017;
+    readonly MIDDLE_SCALE: 0.000003;
+    readonly END_SCALE: 0.0000013;
+    readonly FIRST: 45;
+    readonly MAX: 55;
+};
+declare function navTiltForZoom(zoom: number): number;
+/**
+ * Зазор между машиной и верхом нижней панели приложения, доля ВСЕЙ высоты карты. Доля, а не пиксели:
+ * сдвиг линеен по единицам (`navCameraShiftPx(px) / density` = сдвиг в dp), и постоянный зазор в
+ * пикселях это бы сломал. 6 % — центр машины на ≈48 dp выше панели у телефона в портрете (800 dp)
+ * и на ≈25 dp в альбоме (411 dp): значок машины (≈40 dp) панель не задевает.
+ */
+declare const NAV_CAR_CLEAR = 0.06;
+/** Меньше этой доли высоты видимая часть не бывает (`navInsets`). */
+declare const NAV_MIN_VISIBLE = 0.2;
+/** Строка экрана (от верха карты), на которой стоит машина ведения; см. `navCameraShiftPx`. */
+declare function navCarScreenY(heightPx: number, topPx?: number, bottomPx?: number): number;
+/**
+ * На сколько пикселей машина ниже центра карты высотой `heightPx`. Без отступов — доля всей высоты
+ * (отступ сверху 42 %, машина на 0.71 высоты). С отступами панелей (`topPx`, `bottomPx` — в тех же
+ * единицах) машина остаётся в видимой части: не ниже `NAV_CAR_CLEAR` над нижней панелью и не выше
+ * середины видимого (`navCarScreenY`). Портрет с обычной панелью поездки от этого не меняется
+ * (машина и так выше панели), альбом — меняется: панель там в нижней четверти и закрывала машину.
+ * Камера ставится так: центр — на машину, `q = unproject(w/2, h/2 + dy)`, затем центр = 2·машина − q
+ * (`navCameraCenter`) — при тех же зуме, наклоне и повороте это ровно переносит машину в q.
+ */
+declare function navCameraShiftPx(heightPx: number, topPx?: number, bottomPx?: number): number;
+/** Синоним `navCameraShiftPx` — имя из первого плана переноса. */
+declare const cameraCenterShift: typeof navCameraShiftPx;
+/** Центр камеры, при котором машина `pos` окажется там, где сейчас точка `q` (см. `navCameraShiftPx`). */
+declare function navCameraCenter(pos: LonLat$3, q: LonLat$3): LonLat$3;
+/**
+ * РЕЖИМ КАМЕРЫ ВЕДЕНИЯ (26.10.2026, просьба владельца «машина стоит на месте, двигается карта — как в Яндексе»).
+ *  • `smooth` — как было и по умолчанию: камера идёт за ЛИНИЕЙ маршрута своим сглаженным курсом с упреждением
+ *    (`NavViewCamera`, доворот к выходу из поворота до `PRE_ROTATE_MAX`). Машина на экране поворачивается на
+ *    поворотах, на перестроении переезжает в соседнюю полосу (`laneCarPose`), а её экранная точка немного гуляет
+ *    со сменой наклона (сдвиг вперёд у приложений приближённый — `navCameraAhead`/`navCameraPosition`).
+ *  • `locked` — «машина на месте»: опора камеры — ПОЗА МАШИНЫ ЭТОГО КАДРА (та же точка и тот же курс, что
+ *    нарисованы, вместе со сдвигом в полосу ленты). Машина стоит в точке якоря (`navCarScreenY`, с учётом панелей)
+ *    носом строго вверх; повороты, перестроения и съезд в полосу отрабатывает карта. Зум и наклон — те же, что в
+ *    `smooth` (`navViewTarget` + `NavViewCamera`): кадр дороги по-прежнему растёт и сжимается у манёвра.
+ * ★ ВТОРОГО СГЛАЖИВАНИЯ НЕТ. Поза машины уже сглажена `NavTracker`ом (счисление, подтяжка, курс τ 0,3 с), и камера
+ * берёт РОВНО её, в том же кадре: своё сглаживание поверх отставало бы от машины, и машина гуляла бы по экрану, а
+ * привязка к сырому фиксу дала бы дрожь.
+ *  • `north` — «север вверх» (28.10.2026, `FollowNorthUp` камеры TomTom, компас в ведении Google Maps): карта не
+ *    вращается и лежит плашмя, машина — в ЦЕНТРЕ экрана (курс у неё любой, и якорь внизу увёл бы её под край, когда
+ *    едем на юг), стрелка машины поворачивается сама. Опора — поза машины, как в `locked`; зум — тот же.
+ */
+type NavFollowMode = 'smooth' | 'locked' | 'north';
+/**
+ * Режим из настройки или ключа запуска: `locked` (`1`, `true`, `on`) — «машина на месте», `north` (`north-up`,
+ * `northup`) — «север вверх», остальное — `smooth`.
+ */
+declare function navFollowModeOf(v: unknown): NavFollowMode;
+/** Опора камеры ведения: точка, которую камера ставит в якорь, и курс камеры. */
+interface NavAim {
+    pos: LonLat$3;
+    bearing: number;
+}
+/**
+ * Опора камеры в кадре: `smooth` — точка линии маршрута и свой (сглаженный) курс камеры, как было; `locked` — поза
+ * машины, нарисованной в этом кадре. Нечисловая поза машины в `locked` — опора `smooth` (камера не уходит в NaN).
+ */
+declare function navFollowAim(mode: NavFollowMode, line: NavAim, car: NavAim): NavAim;
+/** Наклон камеры ведения в режиме `mode`: `north` — плашмя (0), иначе — `pitch` как есть. */
+declare function navFollowPitch(mode: NavFollowMode, pitch: number): number;
+/** Сдвиг машины ниже середины карты в режиме `mode`: `north` — 0 (машина в центре), иначе — `shiftPx` как есть. */
+declare function navFollowShiftPx(mode: NavFollowMode, shiftPx: number): number;
+/**
+ * Центр камеры «машина на месте»: при зуме `zoom`, наклоне `pitchDeg` и курсе `bearing` машина `car` встаёт ровно на
+ * `shiftPx` ниже середины карты высотой `heightPx` (те же единицы, что у `navCameraShiftPx`: CSS px / dp), то есть в
+ * точку якоря. ТОЧНО по проекции движка (`Transform`: камера на `0,5·h/tan(FOV/2)` от центра, угол `NAV_VIEW.FOV`,
+ * плоская земля), а не приближённо (`navCameraAhead` приложений: `сдвиг·м/px / cos(наклон)` расходится с проекцией на
+ * 15–20 px при наклоне 30–50°, и машина гуляла бы по экрану со сменой наклона у манёвра). Счёт — в мировых пикселях
+ * меркатора, в которых движок и проецирует. Веб ставит якорь обратной проекцией карты (`navCameraCenter`) — это то же.
+ * Нечисловые или неположительные `shiftPx`/`heightPx` — без сдвига (центр — машина).
+ */
+declare function navLockedCenter(car: LonLat$3, bearing: number, zoom: number, pitchDeg: number, shiftPx: number, heightPx: number): LonLat$3;
+/**
+ * КАМЕРА ВЕДЕНИЯ КАДРИРУЕТ ДОРОГУ, А НЕ ДЕРЖИТ ЗУМ ПО СКОРОСТИ.
+ *
+ * Образец — камера ведения Mapbox Navigation SDK (`FollowingFrameOptions`: кадр по геометрии до
+ * манёвра и чуть после, `pitchNearManeuvers`, сглаживание курса по трассе впереди); так же ведут
+ * себя Google Maps и Яндекс.Навигатор:
+ *   • ЗУМ — такой, чтобы от машины до точки `FRAME_AFTER_M` за поворотом всё влезло в экран выше
+ *     машины; поворот издалека виден целиком, вблизи камера приближается, а за поворотом кадр снова
+ *     растёт с тех же метров (без рывка зума на выходе). На прямой кадр смотрит
+ *     вперёд на скорость × `LOOK_S` (не ближе `LOOK_MIN_M`, не дальше `LOOK_MAX_M`) — быстрее едешь,
+ *     дальше видишь. Это заменяет таблицу «зум по скорости»: она не знала, где поворот;
+ *   • НАКЛОН — на прямой `CRUISE_PITCH` (дорога уходит далеко), в зоне поворота плавно к
+ *     `TURN_PITCH`: сверху круче, и рисунок перекрёстка читается, а не прячется за домами;
+ *   • КУРС — по трассе с упреждением, а в зоне поворота заранее доворачивается к выходу из него, но
+ *     не больше `PRE_ROTATE_MAX` от курса машины: дорога, на которую сворачиваем, видна до поворота,
+ *     а машина не встаёт поперёк экрана.
+ * Зона поворота — `TURN_ZONE_S` секунд хода до манёвра (`TURN_ZONE_MIN_M`…`TURN_ZONE_MAX_M`), вход и
+ * выход плавные (smoothstep), после манёвра режим держится `AFTER_M` и отпускается за `RELEASE_M`.
+ * Манёвры «прямо» (выезд, продолжение, смена имени) поворотом не считаются.
+ */
+declare const NAV_VIEW: {
+    readonly CRUISE_PITCH: 50;
+    readonly TURN_PITCH: 30;
+    readonly TURN_ZONE_S: 7;
+    readonly TURN_ZONE_MIN_M: 90;
+    readonly TURN_ZONE_MAX_M: 260;
+    /** Длина плавного входа в зону поворота, м. */
+    readonly TURN_RAMP_M: 60;
+    readonly AFTER_M: 35;
+    readonly RELEASE_M: 40;
+    readonly FRAME_AFTER_M: 40;
+    readonly LOOK_S: 20;
+    readonly LOOK_MIN_M: 200;
+    readonly LOOK_MAX_M: 900;
+    readonly ZOOM_MIN: 15.6;
+    readonly ZOOM_MAX: 18.8;
+    readonly PRE_ROTATE_MAX: 30;
+    /** Над точкой кадра остаётся столько экрана (доля высоты) — край не упирается в панель. */
+    readonly TOP_MARGIN: 0.14;
+    /** Угол обзора камеры движка по вертикали, градусы (`Transform._fov`). */
+    readonly FOV: 36.87;
+    /** Постоянные сглаживания, с. */
+    readonly ZOOM_TAU: 1.2;
+    readonly PITCH_TAU: 0.9;
+    readonly BEARING_TAU: 0.45;
+};
+/** Цель камеры ведения и доля «режима поворота» (0 — прямая, 1 — у самого манёвра). */
+interface NavViewTarget {
+    zoom: number;
+    pitch: number;
+    bearing: number;
+    turn: number;
+}
+/** Манёвр, при котором камера готовит поворот: всё, кроме движения прямо. */
+declare function navIsTurn(step: NavStep | null | undefined): boolean;
+/** Доля режима поворота на метре `d` трассы при скорости `speedMps`. */
+declare function navTurnWeight(route: NavRoute, d: number, speedMps: number): number;
+/**
+ * Сколько метров земли видно от машины до точки на доле `TOP_MARGIN` ниже верха видимой части, на
+ * пиксель масштаба (то есть в пикселях мира). Плоская земля, камера движка: машина ниже центра на
+ * `navCameraShiftPx(h, topPx, bottomPx)`, угол обзора `FOV`, наклон `pitchDeg`. Верхняя точка кадра —
+ * на `TOP_MARGIN` высоты ниже верхнего отступа, но не ниже середины между ним и машиной: иначе при
+ * больших панелях она оказалась бы под машиной.
+ */
+declare function navAheadPx(heightPx: number, pitchDeg: number, topPx?: number, bottomPx?: number): number;
+/**
+ * Зум, при котором `meters` впереди машины влезают в экран высотой `heightPx` на широте `lat`
+ * (`topPx`/`bottomPx` — отступы панелей, см. `navCameraShiftPx`).
+ */
+declare function navZoomForAhead(meters: number, heightPx: number, pitchDeg: number, lat: number, topPx?: number, bottomPx?: number): number;
+/**
+ * Цель камеры на метре `d`: зум, наклон и курс (см. `NAV_VIEW`). `heightPx` — высота карты в
+ * пикселях масштаба (CSS px / dp), `carBearing` — курс машины по трассе, `topPx`/`bottomPx` —
+ * отступы панелей в тех же единицах (те же, что у `navCameraShiftPx` этого кадра).
+ */
+declare function navViewTarget(route: NavRoute, d: number, speedMps: number, heightPx: number, carBearing: number, topPx?: number, bottomPx?: number): NavViewTarget;
+/**
+ * ЗУМ ВЕДЕНИЯ С ЗАЛИПАНИЕМ (26.10.2026; натив — `NAV_ZOOM_STICK`, `native/src/navigram/nav_follow.h`, Kotlin —
+ * `NavZoomStick.kt`). Зум ведения идёт к цели экспонентой (τ = 1,2 с), и хвост экспоненты — сдвиги в тысячные
+ * уровня — будил петлю ведения и перекладывал подписи ещё секунды после того, как глаз перестал что-либо видеть
+ * (у NaviGram — после закрытия поездки, у веба — после прибытия и в ровной езде). Изменение меньше порога кадр не
+ * показывает (масштаб 0,07 %, у края экрана — доли пикселя); переход зума у манёвра (сотые за кадр) идёт как шёл.
+ */
+declare const NAV_ZOOM_STICK: number;
+/** Показанный зум ведения с залипанием (`NavFollow::stickZoom` натива). */
+declare class NavZoomStick {
+    /** Показанный зум; NaN — ещё не было. */
+    shown: number;
+    /** Зум, который показать кадру: прежний, пока просимый отличается от него меньше чем на `NAV_ZOOM_STICK`. */
+    stick(zoom: number): number;
+    /** Ведение кончилось (или водитель тронул карту): следующий показанный зум — как есть. */
+    reset(): void;
+}
+/** Сглаженная камера ведения: зум, наклон и курс плавно идут к цели `navViewTarget`. */
+declare class NavViewCamera {
+    zoom: number | null;
+    pitch: number | null;
+    bearing: number | null;
+    step(dt: number, t: NavViewTarget): {
+        zoom: number;
+        pitch: number;
+        bearing: number;
+    };
+    reset(): void;
+}
+/** Цель кадра: что знает поездка (GPS или демо) в этот момент. */
+interface NavTrip {
+    route: NavRoute | null;
+    /** Метр трассы последнего фикса (после `snap`). */
+    tripDist: number;
+    speedKmh: number;
+    /** Сырая точка GPS — нужна, только пока маршрута нет. */
+    tripPos: LonLat$3 | null;
+    tripBrg: number | null;
+    /**
+     * Сколько секунд назад снят фикс `tripDist` (с учётом задержки доставки). Метр фикса упреждаем на
+     * скорость × возраст (полностью — до `NAV_PREDICT_MAX`, дальше вера гаснет), иначе машина вечно
+     * «догоняет» прошлое и её дёргает назад к каждому новому фиксу. Нет — 0 (демо, старые вызовы).
+     */
+    fixAgeSec?: number;
+}
+/**
+ * Горизонт упреждения: столько секунд после фикса машина едет с его скоростью в полную веру. Дальше
+ * вера гаснет с постоянной `NAV_COAST_TAU` — GPS пропал, и машина плавно докатывается, а не уезжает.
+ */
+declare const NAV_PREDICT_MAX = 2;
+/** Постоянная гашения веры в скорость за горизонтом: без фиксов машина проезжает не больше скорость × 2.5 с. */
+declare const NAV_COAST_TAU = 0.5;
+/**
+ * Фильтр скорости фикса — несимметричный: растущей верим за `NAV_SPEED_RISE_TAU`, падающей — почти
+ * сразу. Обгон машины не исправить (назад не едем), отставание подтяжка исправит сама.
+ */
+declare const NAV_SPEED_RISE_TAU = 1;
+declare const NAV_SPEED_FALL_TAU = 0.2;
+/** Постоянные подтяжки к цели (метр) и поворота курса, с. */
+declare const NAV_PULL_TAU = 0.45;
+/**
+ * Подтяжка метра машины к упреждённому фиксу на маршруте, с (17.10.2026: было `NAV_PULL_TAU` = 0.45). Фикс приходит раз
+ * в секунду с ошибкой вдоль трассы 1–3 м; при 0.45 с почти вся поправка выбиралась за первые полсекунды после фикса, и
+ * скорость машины, а с ней и камеры, пульсировала раз в секунду (модель: шаг кадра против среднего за 0.5 с — p99 30 %,
+ * разброс скорости 18.7 % против 10.9 % без шума; с 1.0 с — 13 % и 14.0 %). Секунда — длина анимации курсора у Mapbox
+ * Navigation (`NavigationLocationProvider`, 1000 мс по умолчанию — интервал фиксов). Скорость при этом не отстаёт:
+ * её ведёт счисление, подтяжка правит только ошибку положения. Без маршрута — прежняя `NAV_PULL_TAU`: там счисления нет,
+ * и длинная подтяжка значила бы отставание на скорость × постоянную.
+ */
+declare const NAV_ROUTE_PULL_TAU = 1;
+declare const NAV_BEARING_TAU = 0.3;
+/** Курс берётся с упреждением: камера поворачивает вместе с машиной, а не после неё. */
+declare const NAV_LOOK_AHEAD_M = 25;
+/** Отставание от упреждённого фикса, после которого машина может и поехать назад (разворот, перестроение). */
+declare const NAV_BACK_M = 40;
+/** Медленнее этого (м/с) — стоим: счисление выключено, дрожание точки машину не двигает. */
+declare const NAV_STILL_MPS = 0.5;
+/**
+ * Что нарисовано прямо сейчас — счисление пути навигатора `navigator-main` (`map/DeadReckoning.kt`).
+ * GPS и демо задают только цель; как до неё доехать, решает кадр:
+ *   • скорость фикса сглаживается несимметрично (`NAV_SPEED_RISE_TAU`/`NAV_SPEED_FALL_TAU`): доплер
+ *     шумит, и шум попадал в позицию дважды — интегрированием и упреждением; медленнее
+ *     `NAV_STILL_MPS` — сразу ноль (наше дополнение: на стоянке машина не ползёт);
+ *   • цель — метр фикса, упреждённый на его возраст скоростью × возраст до горизонта
+ *     `NAV_PREDICT_MAX`, дальше вера гаснет (`NAV_COAST_TAU`). ТЕМ ЖЕ числом двигается и машина:
+ *     раньше за горизонтом цель замирала, а машина ехала дальше, и стояла только потому, что подтяжка
+ *     тянула назад, — рывок раз в секунду и отставание;
+ *   • между фиксами машина едет со скоростью (× вера) и плавно подтягивается к цели (`NAV_PULL_TAU`),
+ *     но назад не едет — отстали от цели, значит, притормаживаем, пока фиксы не догонят (так у Mapbox
+ *     и OsmAnd). Назад — только при отставании больше `NAV_BACK_M` (развернулись, перестроили);
+ *   • курс — по трассе с упреждением `NAV_LOOK_AHEAD_M` и сглаживанием `NAV_BEARING_TAU`: на повороте
+ *     машина и камера поворачивают вместе по дуге, а не рывком на узле.
+ * Без маршрута тянемся прямо к точке GPS — вести по трассе нечего.
+ */
+declare class NavTracker {
+    dist: number | null;
+    pos: LonLat$3 | null;
+    brg: number | null;
+    zoom: number | null;
+    /** Сглаженная скорость, м/с; `null` — ещё не с чего сглаживать. */
+    speed: number | null;
+    tick(dtIn: number, trip: NavTrip): void;
+    /** Масштаб плавно идёт к цели (`navTargetZoom`); первый кадр — сразу в цель. */
+    zoomStep(dt: number, target: number): number;
+    reset(): void;
+}
+/**
+ * Скорость демо-поездки: обычно чуть медленнее знака, а в средней трети маршрута сознательно
+ * нарушаем — проверяется и тревога, и её снятие. Знака нет — считаем 60.
+ */
+declare function demoSpeedKmh(share: number, limitKmh: number): number;
+/**
+ * ЖИВАЯ СКОРОСТЬ ДЕМО (29.10.2026, просьба владельца: «в демо скорость не меняется»). Прежняя модель (`demoSpeedKmh`)
+ * держала ровно 85 % знака и меняла скорость только со сменой знака — на улице с одним знаком демо шло минутами на одной
+ * цифре, а нарочное превышение было лишь в средней трети пути. Теперь — как у водителя:
+ *  • обычный ход — `CRUISE` от знака с плавным колебанием ±`WOBBLE` по пути (волна `WOBBLE_M` метров);
+ *  • каждые `SPEED_EVERY_M` метров — отрезок `SPEED_LEN_M` с нарочным превышением `SPEED_K` (проверяются плашка, голос
+ *    и вибрация; `SpeedWatch` берёт превышение больше 5 км/ч дольше 2.5 с — отрезка хватает и на знаке 20);
+ *  • за `TURN_M` до поворота — сброс до `TURN_KMH` (линейно по расстоянию);
+ *  • разгон не круче `ACCEL`, торможение не круче `BRAKE` (м/с²) — когда известна прежняя скорость.
+ * Всё — от метра пути, без случайности: эталоны и платформы совпадают кадр в кадр.
+ */
+declare const NAV_DEMO: {
+    readonly CRUISE: 0.85;
+    readonly WOBBLE: 0.08;
+    readonly WOBBLE_M: 260;
+    readonly SPEED_EVERY_M: 1500;
+    readonly SPEED_FROM_M: 1100;
+    readonly SPEED_LEN_M: 350;
+    readonly SPEED_K: 1.3;
+    readonly TURN_M: 150;
+    readonly TURN_KMH: 22;
+    readonly ACCEL: 2.2;
+    readonly BRAKE: 3.2;
+};
+/** Желанная скорость демо в метре `dist` (без разгона и торможения); знака нет — 60. */
+declare function demoTargetKmh(route: NavRoute, dist: number, limitKmh: number): number;
+/**
+ * Шаг демо: новая скорость, метр и точка поездки (`dt` в секундах). `prevKmh` — скорость прошлого шага: с ней скорость
+ * идёт к желанной не круче `NAV_DEMO.ACCEL`/`BRAKE`; без неё (NaN) — сразу желанная.
+ */
+declare function navDemoStep(route: NavRoute, dist: number, limitKmh: number, dt: number, prevKmh?: number): {
+    speedKmh: number;
+    dist: number;
+    pos: LonLat$3;
+};
+/**
+ * ЗНАЧКИ МАНЁВРОВ «КАК У ORGANIC MAPS, СО СКРУГЛЕНИЕМ» (29.10.2026, просьба владельца для NaviGram): толстый ствол с
+ * изгибом по дуге и крупный треугольный наконечник, как у растровых значков OM, — но концы и углы скруглены. Внутренность
+ * SVG 24×24 (без `<svg>`): ствол — линия, наконечник — залитый многоугольник с выемкой у основания и СВОЕЙ тонкой обводкой (`stroke-width` у элемента); рисовать с
+ * `stroke-width = ARROW_ICON_STROKE`, `stroke-linecap/linejoin = round` (обводка и даёт скругление углов наконечника).
+ * Скругление — по правилам системных значков Material: радиус углов 0…4 на сетке 24 (концы ствола 1.9, углы наконечника 0.8 — острый читается лучше), внутренние
+ * углы прямые, всё нарисованное — с учётом обводки — внутри живой области 2…22 (поля по 2).
+ * Ключи и отражение — как у `ARROW_PATHS`/`maneuverArrow`: левые повороты — правые, отражённые по горизонтали.
+ */
+declare const ARROW_ICON_STROKE = 3.8;
+declare const ARROW_ICONS: Record<string, string>;
+declare const ARROW_PATHS: Record<string, string>;
+/** Какая стрелка у манёвра: ключ `ARROW_PATHS` и отражение по горизонтали (левые повороты). */
+declare function maneuverArrow(type?: string | null, modifier?: string | null): {
+    key: string;
+    flip: boolean;
+};
+/** Внутренность SVG стрелки (24×24) по type/modifier — без внешнего тега. */
+declare function arrowPath(type?: string | null, modifier?: string | null): string;
+declare const NAV_COLORS: {
+    ROUTE_BLUE: string;
+    /** Тёмный кант под белым кольцом: на светлом асфальте одно белое кольцо теряется. */
+    CURSOR_RIM: string;
+    CURSOR_RIM_OPACITY: number;
+    CURSOR_CONE_OPACITY: number;
+    /** Насколько виден курсор за домом — как у призрачных слоёв страницы водителя. */
+    CURSOR_GHOST: number;
+};
+/** Курсор в пикселях экрана — те же размеры, что у картинки курсора страницы водителя (128 px, ×0.95/2). */
+declare const CURSOR_SCALE: number;
+declare const CURSOR: {
+    cone: number;
+    coneHalf: number;
+    body: number;
+    ring: number;
+    rim: number;
+    arrow: number[][];
+};
+/**
+ * Фигуры курсора на земле: конус направления (замкнут), круг корпуса (41 точка, замкнут; он же
+ * кольцо и кант — линиями шириной `CURSOR.ring`/`CURSOR.rim` px) и стрелка (4 точки, НЕ замкнута —
+ * полигону добавить первую в конец). Размеры заданы в пикселях экрана и переводятся в метры через
+ * `metersPerPixel` (широта машины, текущий зум), поэтому курсор одного размера на любом зуме.
+ */
+declare function navCursorShapes(pos: LonLat$3, brgDeg: number, metersPerPixel: number): {
+    cone: LonLat$3[];
+    ring: LonLat$3[];
+    arrow: LonLat$3[];
+};
+
+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;
+
+interface LngLat {
+    lng: number;
+    lat: number;
+}
+type LngLatLike = LngLat | [number, number];
+
+type Mat4 = Float64Array;
+type Vec3 = [number, number, number];
+
+/**
+ * Прямоугольник по координатам.
+ *
+ * Нужен ровно для одного — «покажи это целиком»: маршрут, выдачу поиска,
+ * границу района. Имена методов те же, что у Mapbox и MapLibre (`extend`,
+ * `getCenter`, `contains`), чтобы чужой код переносился без переписывания.
+ *
+ * Через 180-й меридиан прямоугольник НЕ переносится: у нас нет данных по обе
+ * стороны океана, а поддержка переноса тянет за собой особый случай в каждом
+ * методе. Если понадобится — добавлять его надо вместе с тестами на склейку.
+ */
+/**
+ * Рамка любым из видов MapLibre: `LngLatBounds`, пара углов `[юго-запад, северо-восток]` или `[запад, юг, восток, север]`
+ * (02.11.2026).
+ */
+type LngLatBoundsLike = LngLatBounds | readonly [LngLatLike, LngLatLike] | readonly [number, number, number, number];
+declare class LngLatBounds {
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    constructor(sw?: LngLatLike, ne?: LngLatLike);
+    /** Рамка по набору точек. Пустой набор даёт пустую рамку, а не ошибку. */
+    /** Рамка из любого вида `LngLatBoundsLike`; `LngLatBounds` возвращается как есть. */
+    static convert(input: LngLatBoundsLike): LngLatBounds;
+    static from(points: Iterable<LngLatLike>): LngLatBounds;
+    extend(point: LngLatLike | LngLatBounds): this;
+    isEmpty(): boolean;
+    getCenter(): LngLat;
+    getWest(): number;
+    getSouth(): number;
+    getEast(): number;
+    getNorth(): number;
+    getNorthWest(): LngLat;
+    getSouthEast(): LngLat;
+    /** `[[запад, юг], [восток, север]]`, как `toArray` MapLibre. */
+    toArray(): [[number, number], [number, number]];
+    getSouthWest(): LngLat;
+    getNorthEast(): LngLat;
+    contains(point: LngLatLike): boolean;
+    /** Расширить на долю своего размера — «немного воздуха» вокруг объекта. */
+    pad(fraction: number): this;
+    /** Углы в нормализованном меркаторе — в этих единицах и считается вписывание. */
+    toMercator(): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+
+/**
+ * Идентификатор тайла. wrap — номер копии мира по X (карта повторяется при панораме
+ * через антимеридиан): данные у копий одни и те же, а матрица разная, поэтому
+ * ключ кеша данных (dataKey) и ключ отрисовки (key) — разные вещи.
+ */
+declare class TileID {
+    readonly z: number;
+    readonly x: number;
+    readonly y: number;
+    readonly wrap: number;
+    private dataKeyOrNull;
+    private keyOrNull;
+    constructor(z: number, x: number, y: number, wrap?: number);
+    get dataKey(): string;
+    get key(): string;
+    parent(): TileID | null;
+    children(): TileID[];
+    /** Предок на заданном зуме (или сам тайл). */
+    scaledTo(z: number): TileID;
+    isAncestorOf(other: TileID): boolean;
+    /** Границы тайла в нормализованном меркаторе, с учётом копии мира. */
+    bounds(): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    toString(): string;
+}
+
+interface GlobeBasis {
+    /** Восток, юг, вверх в точке центра карты — колонки перехода в локальные координаты. */
+    east: Vec3;
+    south: Vec3;
+    up: Vec3;
+}
+
+type Projection = 'mercator' | 'globe';
+interface ScreenPoint {
+    x: number;
+    y: number;
+}
+declare class Transform {
+    width: number;
+    height: number;
+    minZoom: number;
+    maxZoom: number;
+    /**
+     * Рамка, за которую не выпускается ЦЕНТР карты. `null` — ограничения нет.
+     *
+     * Прижимается в сеттере центра, а не при отрисовке: центр ставят и жесты, и анимация, и
+     * приложение, и проверить это в одном месте — единственный способ не забыть ни одного из них.
+     */
+    maxBounds: LngLatBounds | null;
+    /**
+     * Повторять ли мир по горизонтали при отъезде.
+     *
+     * На мелком зуме в кадр помещается больше одного оборота Земли, и копии закрывают пустоту по
+     * краям. Приложению это иногда мешает — например, когда по карте водят выделение и вторая копия
+     * ловит тот же клик, — поэтому повтор выключается (`map.setRenderWorldCopies`).
+     */
+    renderWorldCopies: boolean;
+    minPitch: number;
+    maxPitch: number;
+    private _fogCutoff;
+    /**
+     * ДАЛЬНОСТЬ ОТСЕЧЕНИЯ ТУМАНА (`fog` стиля): глубина по оси взгляда в расстояниях до центра кадра.
+     *
+     * Становится ДАЛЬНЕЙ ПЛОСКОСТЬЮ камеры: за ней GPU не рисует ничего, а отбор тайлов (та же пирамида
+     * видимости в `isTileVisible`) их не выбирает и не грузит — как и 3D-модели (`isSphereVisible`).
+     * Туман в шейдере меряет ту же глубину, поэтому на кромке он уже сплошной. `Infinity` — не режем.
+     */
+    get fogCutoff(): number;
+    /**
+     * Дальняя плоскость тумана в мировых пикселях по оси взгляда: `fogCutoff` в долях расстояния до
+     * центра, но НЕ БЛИЖЕ `FOG_CUTOFF_MIN_M` метров. Доли на крупном зуме — десятки метров (z22: ~32 м), и
+     * камера обрезала дорогу прямо перед собой. `Infinity` — не режем.
+     */
+    fogCutoffDepth(): number;
+    set fogCutoff(k: number);
+    /**
+     * КРЕН камеры, градусы: поворот вокруг оси взгляда.
+     *
+     * Наклон (`pitch`) кладёт камеру вперёд, поворот (`bearing`) вращает карту под ней, а крен
+     * заваливает сам кадр — как накренившийся самолёт. Нужен полётам и панорамам; на обычной карте
+     * остаётся нулём. Порядок сборки тот же, что у MapLibre: крен идёт МЕЖДУ отъездом камеры и
+     * наклоном, иначе он начал бы вращать не кадр, а землю под ним.
+     *
+     * Свойство, а не поле: присваивание обязано пометить камеру грязной, иначе матрицы останутся
+     * прежними и крен не доедет до кадра.
+     */
+    private _roll;
+    private _center;
+    /**
+     * ВЫСОТА ЗЕМЛИ ПОД ЦЕНТРОМ КАРТЫ, метры. Ставится рельефом каждый кадр; без рельефа — ноль.
+     *
+     * Камера у нас стоит на фиксированном расстоянии от ТОЧКИ ЦЕНТРА, а точка эта лежала на нулевой
+     * высоте. Над горой в 2 км это значит, что камера оказывается внутри горы: земля поднялась, а
+     * она — нет. Поднимаем всю связку камера-центр на высоту земли — ровно так же поступает MapLibre
+     * (`transform.elevation`), и по той же причине: иначе рельеф нельзя даже осмотреть.
+     */
+    private _centerElevation;
+    private _zoom;
+    private _bearing;
+    private _pitch;
+    /** Наклон, который просили (`pitch =`); на экране — он же, урезанный пределом по зуму. */
+    private _wantedPitch;
+    /** Предел наклона по зуму. У голой математики камеры выключен; карта включает его опцией `pitchByZoom`. */
+    private _pitchByZoom;
+    private _fov;
+    private _worldSize;
+    private _pixelsPerMeter;
+    private _cameraToCenterDistance;
+    private _centerX;
+    private _centerY;
+    private _projMatrix;
+    /** Элемент [14] перспективы: z клипа = A·z + B (см. `projZOffset`). */
+    private _projZ;
+    private _viewProjPx;
+    private _viewMatrix;
+    private _pixelMatrix;
+    private _pixelMatrixInverse;
+    private _cameraPosPx;
+    private _frustumPlanes;
+    private _dirty;
+    /**
+     * Проекция. `globe` действует только до GLOBE_ZOOM_MAX — выше карта всё равно
+     * плоская, и держать сферу там значило бы платить за неё зря.
+     */
+    projection: Projection;
+    /**
+     * ЗУМЫ ПЕРЕХОДА ШАР → ПЛОСКОСТЬ ИЗ СТИЛЯ (этап y, `porting/unified-style-format.md` §15): `projection.type`
+     * MapLibre по зуму (`["interpolate", …, ["zoom"], z0, "vertical-perspective", z1, "mercator"]`, сахар
+     * `globe` — z11 → z12). Доля плоскости между ними — кривой `interpolate` (у MapLibre — линейная смесь
+     * положений, `GlobeProjection.transitionState`); `max: Infinity` — шар на любом зуме (`vertical-perspective`).
+     * `null` — свои зумы глобуса (`GLOBE_ZOOM_MIN`–`GLOBE_ZOOM_MAX`, гладкая ступенька).
+     */
+    globeZooms: {
+        min: number;
+        max: number;
+        base?: number;
+    } | null;
+    /** Зум, с которого шар уже не нужен. */
+    private get globeTop();
+    /** Доля плоской карты на зуме: из стиля — кривой `interpolate`, иначе своя гладкая ступенька. */
+    private flatMixAt;
+    private _f32;
+    private _tileMatrix;
+    private _localView;
+    private _localProj;
+    private _localPixel;
+    private _localPixelInverse;
+    private _localF32;
+    private _globeBasis;
+    private _objectF32;
+    private _objectMatrix;
+    private _shadowView;
+    private _shadowProj;
+    private _shadowVP;
+    /** То же, но принимает высоту в метрах — как projMatrix. */
+    private _shadowVPm;
+    private _shadowTile;
+    private _shadowObject;
+    private _shadowTile32;
+    private _shadowObject32;
+    private _shadowValid;
+    constructor();
+    get center(): LngLat;
+    set center(v: LngLat);
+    /** Высота земли под центром, метры (ставит рельеф). */
+    get centerElevation(): number;
+    set centerElevation(v: number);
+    /**
+     * Нижняя граница зума на глобусе: дальше шар становится точкой в углу экрана.
+     *
+     * Считается от размера кадра, а не числом: радиус сферы в мировых пикселях
+     * растёт с зумом, и «достаточно крупно» — это доля меньшей стороны экрана.
+     */
+    globeMinZoom(): number;
+    /** Нижняя граница зума с учётом проекции. */
+    effectiveMinZoom(): number;
+    get zoom(): number;
+    set zoom(z: number);
+    get bearing(): number;
+    set bearing(b: number);
+    get pitch(): number;
+    set pitch(p: number);
+    /** Наклон, который просили; на экране может быть меньше — по пределу зума (`pitchByZoom`). */
+    get wantedPitch(): number;
+    /**
+     * Наклон по высоте камеры (`PITCH_BY_ZOOM`). У карты по умолчанию включён (`MapOptions.pitchByZoom`).
+     * Выключают его те, кто ставит камеру сам и знает, зачем: ведение навигатора держит свой наклон.
+     */
+    get pitchByZoom(): boolean;
+    set pitchByZoom(on: boolean);
+    /** Предел наклона на текущем зуме: `maxPitch`, глобус и высота камеры. */
+    pitchLimit(): number;
+    private applyPitch;
+    /** Вертикальный угол обзора в градусах. */
+    get roll(): number;
+    set roll(deg: number);
+    get fov(): number;
+    set fov(deg: number);
+    resize(width: number, height: number): void;
+    get worldSize(): number;
+    get pixelsPerMeter(): number;
+    get cameraToCenterDistance(): number;
+    get cameraPositionPx(): [number, number, number];
+    /**
+     * Свободный член глубины перспективы (B в z клипа = A·z + B).
+     *
+     * Нужен, чтобы сдвинуть глубину точки к камере, не сдвигая её на экране: приблизить точку на долю
+     * `k` её расстояния — то же самое, что прибавить к z клипа `B·k/(1−k)`, одну постоянную на кадр
+     * (см. `LineLayerSpec.depthTest`).
+     */
+    get projZOffset(): number;
+    get projMatrix(): Mat4;
+    /** Мировые пиксели → экран в однородных координатах (x, y, z, w; делить на w). */
+    get pixelMatrix(): Mat4;
+    get viewMatrix(): Mat4;
+    /** Центр карты в мировых пикселях. */
+    get centerPointPx(): {
+        x: number;
+        y: number;
+    };
+    clone(): Transform;
+    /** Географическая точка (+ высота в метрах) → пиксели экрана. */
+    project(lngLat: LngLat, altitudeMeters?: number): ScreenPoint;
+    /**
+     * Мировые пиксели → экран. null, если точка за камерой: при наклоне 70°
+     * половина мира оказывается позади, и без этой проверки подписи «отражаются»
+     * в верхнюю часть экрана.
+     */
+    worldPxToPoint(wx: number, wy: number, altitudeMeters?: number): ScreenPoint | null;
+    /** Пиксели экрана → география на уровне земли (луч сквозь плоскость z=0). */
+    unproject(point: ScreenPoint): LngLat;
+    /**
+     * ВЫСОТА ЗЕМЛИ В ТОЧКЕ, метры — её ставит рельеф.
+     *
+     * Без неё обратный перевод «экран → место» считает землю плоскостью на нуле. На рельефе земля
+     * лежит на своей высоте, и на городском зуме при наклоне промах доходит до полутора километров:
+     * клик по дому открывал карточку соседнего квартала, а перетаскивание карты уезжало из-под
+     * пальца. Ровно это же (и ровно так же, итерациями) делает MapLibre в `pointCoordinate3D`.
+     */
+    elevationAt: ((mx: number, my: number) => number) | null;
+    /** Пиксели экрана → мировые пиксели на плоскости земли. */
+    pointToWorldPx(point: ScreenPoint): {
+        x: number;
+        y: number;
+    };
+    /** Сдвигает центр так, чтобы координата lngLat оказалась под точкой экрана. */
+    setLocationAtPoint(lngLat: LngLat, point: ScreenPoint): void;
+    /**
+     * Центр, посчитанный жестом или инерцией (минуя сеттер, без рамки `maxBounds` — её держит карта). Точка экрана
+     * за горизонтом или нечисловое касание дают NaN — такой шаг пропускается, как и в сеттере.
+     */
+    private placeCenter;
+    /**
+     * Сдвигает карту на (dx, dy) пикселей экрана В МАСШТАБЕ ЦЕНТРА: содержимое у центра уезжает ровно на
+     * столько же.
+     *
+     * Нужен инерции броска. Сдвиг здесь ЛИНЕЕН по дельте (пиксель центра переводится в мировые пиксели
+     * один раз, разностью по полпикселя в обе стороны), поэтому сумма шагов равна одному большому шагу
+     * — путь броска не зависит от частоты кадров, в том числе при наклоне. `setLocationAtPoint` вокруг
+     * центра этого не даёт: при перспективе он нелинеен, и десять мелких шагов уводят не туда, куда один
+     * крупный. На шаре линейного сдвига нет — там тот же поворот, что у жеста.
+     */
+    panByScreenDelta(dx: number, dy: number): void;
+    /**
+     * Матрица тайла: локальные координаты MVT [0..extent] + высота в метрах → клип.
+     * Возвращает переиспользуемый Float32Array — грузить в юниформ сразу, не хранить.
+     */
+    tileMatrix(tile: TileID, extent: number): Float32Array;
+    /** Та же матрица, но в Float64 — для расчётов на CPU (пикинг, отладка). */
+    tileMatrix64(tile: TileID, extent: number, out?: Mat4): Mat4;
+    /**
+     * Матрица рантайм-объекта: локальные координаты — нормализованный меркатор
+     * ОТНОСИТЕЛЬНО origin, Z — метры над землёй.
+     *
+     * Отличается от тайловой только тем, откуда берётся начало и масштаб: у тайла
+     * они продиктованы сеткой, у объекта их выбирает он сам по своей рамке. Смысл
+     * переноса тот же — увести из Float32 огромные мировые координаты.
+     */
+    objectMatrix(originX: number, originY: number, altitudeMeters?: number): Float32Array;
+    /**
+     * КВАДРАТ ДРАПИРОВКИ, в который сейчас рисуется плоская карта (15.10.2026). `null` — рисуем на экран.
+     *
+     * На рельефе плоский проход уходит в текстуры тайлов рельефа (`Renderer.drapeTerrain`), и всё, что в
+     * нём рисуется, обязано класть себя в КВАДРАТ ТАЙЛА, а не в кадр. Слои стиля так и делают (матрица
+     * тайла), а свои слои приложения и стрелки входов берут матрицу у `objectMatrix` — и получали
+     * экранную камеру. Полотно детальных дорог (`ld-pascal-mesh` на вебе, `LdMesh` на Android/iOS)
+     * рисовалось в каждую текстуру тайла по проекции кадра и легло на рельеф обрывками тёмных полос
+     * поперёк реки (жалоба с navi.gram.tj, Худжанд, z17, наклон 65°). Пока квадрат задан, `objectMatrix`
+     * переводит меркатор в квадрат рельефа, а высоту в метрах обнуляет: в текстуре земля плоская, рельеф
+     * ей даст решётка.
+     */
+    drapeSquare: {
+        z: number;
+        x: number;
+        y: number;
+    } | null;
+    /**
+     * `objectMatrix` в драпировке: локальный меркатор (от `origin`) → клип квадрата `drapeSquare`.
+     *
+     *   x = 2ⁿ⁺¹·lx + (2ⁿ⁺¹·ox − 2·T.x − 1),  y = −2ⁿ⁺¹·ly + (−2ⁿ⁺¹·oy + 2·T.y + 1),  z = 0
+     *
+     * Та же раскладка, что у тайла карты в драпировке (`Renderer.applyTileMatrix`): ось Y перевёрнута, её
+     * возвращает шейдер рельефа. Перенос считается в двойной точности — как у обычной `objectMatrix`.
+     */
+    private drapeObjectMatrix;
+    /**
+     * Экранная координата Y линии горизонта (сверху вниз, CSS-пиксели).
+     *
+     * Крена у нашей камеры нет, поэтому горизонт — всегда ГОРИЗОНТАЛЬНАЯ линия, и
+     * небо можно рисовать вертикальным градиентом в экранных координатах. Это и
+     * точно, и на порядок дешевле, чем считать направление луча в каждом фрагменте.
+     *
+     * Значение может быть отрицательным: при малом наклоне горизонт уходит выше
+     * кадра, и неба на экране просто нет.
+     */
+    horizonScreenY(): number;
+    /** Сфера сейчас активна: режим включён и зум ещё не перевалил за переход. */
+    get globeActive(): boolean;
+    /** Доля плоской карты в смеси: 0 — чистая сфера, 1 — чистый меркатор. */
+    get globeFlatMix(): number;
+    get globeRadiusPx(): number;
+    /**
+     * Радиус шара в мировых пикселях. Свой — по экватору (`globeRadius`); у стиля MapLibre (зумы перехода
+     * из стиля, этап y) — как у `GlobeTransform` MapLibre: делённый на косинус широты центра, чтобы масштаб
+     * в центре кадра совпадал с меркатором и переход шар → плоскость не менял размера карты.
+     */
+    private globeRadiusOf;
+    get globeBasis(): GlobeBasis;
+    /** Та же матрица в Float64 — для расчётов на CPU. */
+    get localProjMatrix(): Mat4;
+    /**
+     * Камера относительно ЦЕНТРА ШАРА, в локальных координатах: направление и
+     * косинус угла до горизонта.
+     *
+     * Считать горизонт от вертикали в центре карты нельзя — это верно только при
+     * наклоне 0. При наклоне камера уходит вбок, настоящий горизонт наклоняется
+     * вместе с ней, а плоскость, перпендикулярная вертикали, срезает шар по
+     * прямой: ровно это и было видно как «часть глобуса скрывается».
+     */
+    globeCamera(): {
+        dir: Vec3;
+        horizonCos: number;
+    };
+    /**
+     * Направления лучей через углы кадра, в локальных координатах.
+     *
+     * Нужны небу: чтобы посчитать, на каком угловом расстоянии от края планеты
+     * находится пиксель, нужен его луч. Считать обратную проекцию в каждом
+     * фрагменте дорого и незачем — направления линейны по экрану, поэтому хватает
+     * четырёх углов и интерполяции. Так же делает Mapbox (u_frustum_tl/tr/br/bl).
+     *
+     * Порядок: левый верх, правый верх, левый низ, правый низ.
+     */
+    localRayCorners(): Vec3[];
+    /**
+     * Базис камеры в МИРОВЫХ осях движка (X восток, Y юг, Z вверх) и фокус в пикселях вида.
+     *
+     * По ним из пикселя восстанавливается луч: dir = normalize(fwd*focal + right*dx + up*dy). Небу
+     * этого хватает, чтобы считаться от УГЛА ЛУЧА, а не от экранной высоты, — только так у горизонта
+     * получается настоящая воздушная масса, а не нарисованная полоса.
+     */
+    cameraRay(): {
+        right: Vec3;
+        up: Vec3;
+        fwd: Vec3;
+        focal: number;
+        axisElev: number;
+    };
+    /** Направление на центр планеты и её угловой радиус — для каймы атмосферы. */
+    globeDisc(): {
+        dir: Vec3;
+        angle: number;
+    };
+    /** Матрица камеры для ЛОКАЛЬНЫХ координат (глобус их и отдаёт). */
+    localMatrix(): Float32Array;
+    /**
+     * Нормализованный меркатор → локальные координаты. Повторяет формулу
+     * вершинного шейдера один в один: разойдись они — и подписи, размещаемые на
+     * CPU, поедут относительно геометрии.
+     */
+    globeLocal(mx: number, my: number): Vec3;
+    /** Локальные координаты → экран. null, если точка за камерой. */
+    localToPoint(local: Vec3): ScreenPoint | null;
+    /**
+     * Обратная проекция на сфере: луч из камеры до пересечения с шаром.
+     *
+     * Центр шара в локальных координатах — (0, 0, −R): начало там, где сфера
+     * касается касательной плоскости, а центр на радиус ниже.
+     */
+    globeUnproject(point: ScreenPoint): LngLat | null;
+    /**
+     * Видна ли точка сферы: и по горизонту, и по кадру.
+     *
+     * Горизонт считается от ВЫСОТЫ камеры, а не «передней полусферы»: с конечной
+     * высоты видно заметно меньше половины шара, и без этого дальняя сторона
+     * рисовалась бы поверх ближней (тест глубины у плоских слоёв выключен).
+     */
+    isOnGlobeFront(lng: number, lat: number, slack?: number): boolean;
+    /**
+     * Пересчитывает матрицы карты теней под текущую камеру.
+     *
+     * Объём источника подгоняется под ВИДИМУЮ землю, а не задаётся раз и навсегда:
+     * при наклоне 70° видимая площадь больше, чем при взгляде сверху, в десятки
+     * раз, и фиксированный объём либо обрежет тени спереди, либо размажет их в
+     * кашу сзади (весь бюджет текселей уйдёт на пустоту).
+     *
+     * @param dir   куда ЛЕТИТ свет (та же система, что у `u_key_dir`)
+     * @param maxHeightMeters потолок сцены: выше него теней не бывает
+     */
+    updateShadow(dir: Vec3, maxHeightMeters: number, groundMin?: number, groundMax?: number): void;
+    /** Матрицы теней посчитаны и пригодны. */
+    get shadowReady(): boolean;
+    /**
+     * Матрица тени для рантайм-объекта: локальные координаты (нормализованный
+     * меркатор относительно origin) → клип источника света.
+     */
+    shadowObjectMatrix(originX: number, originY: number, altitudeMeters?: number): Float32Array;
+    /** Матрица тайла для прохода глубины: локальные координаты MVT → клип источника. */
+    shadowTileMatrix(tile: TileID, extent: number): Float32Array;
+    /**
+     * Сколько единиц глубины карты теней приходится на МЕТР высоты.
+     *
+     * Нужно, чтобы задавать смещение против самозатенения в метрах, а не в долях
+     * диапазона глубины. Диапазон зависит от объёма источника, а тот — от зума и
+     * наклона: одно и то же «0.0015» означало 49 метров на z16 и 15 на z19, и
+     * тени обычных домов просто съедались смещением.
+     *
+     * Матрица источника ортографическая, то есть аффинная, поэтому производная
+     * глубины по высоте — это просто её коэффициент при z.
+     */
+    shadowDepthPerMeter(): number;
+    /** Размер текселя карты теней в мировых пикселях — для наклонного bias. */
+    shadowTexelWorldSize(mapSize: number): number;
+    /**
+     * AABB тайла (мировые пиксели, Z тоже пиксели) против пирамиды видимости.
+     * Классический тест «полностью снаружи одной из плоскостей»: даёт ложные
+     * попадания на углах, но не теряет видимое — для отбора тайлов этого достаточно.
+     */
+    isTileVisible(tile: TileID): boolean;
+    /**
+     * Видна ли сфера: центр задан в нормализованном меркаторе, высота и радиус — в метрах.
+     *
+     * Тем же набором плоскостей, что и у тайлов ([[isTileVisible]]). Нужна отсечению 3D-моделей: их
+     * отбирают по расстоянию от ЦЕНТРА КАРТЫ, а не по кадру, и при наклонной камере заметная часть
+     * радиуса приходится за спину — рисовать её незачем.
+     */
+    isSphereVisible(mercX: number, mercY: number, heightM: number, radiusM: number): boolean;
+    /**
+     * Лежит ли точка ЗА КРОМКОЙ ТУМАНА (`fogCutoff`): её глубина по оси взгляда дальше дальней плоскости.
+     * Мировые пиксели по X/Y, высота в метрах. Нужна тому, что рисуется не GPU, — DOM-маркерам.
+     */
+    beyondFog(x: number, y: number, altitudeM?: number): boolean;
+    /** Расстояние от камеры до ближайшей точки AABB тайла (мировые пиксели). */
+    distanceToTile(tile: TileID): number;
+    /**
+     * Самая дальняя точка земли у НЕНАКЛОНЁННОЙ карты — точка отсчёта для слова «далеко».
+     *
+     * Смотрим сверху вниз: дальше всех от камеры угол экрана. Всё, что дальше этого, на плоской карте
+     * не встречается вовсе и появляется только от наклона.
+     */
+    get flatFarDistance(): number;
+    /**
+     * Зум, на который тайл ТЯНЕТ с такого расстояния.
+     *
+     * При наклоне карта одним кадром показывает и двор под ногами, и город за несколько километров, а
+     * зум у неё один на всех. Дальние тайлы от этого рисуются со всей мелочью ближнего плана: номера
+     * домов, тропинки, дворовые проезды — всё то, что на таком расстоянии сливается в грязь, но честно
+     * стоит вершин и вызовов отрисовки. Здесь считается, во сколько раз тайл дальше самого дальнего
+     * угла плоской карты, и на столько же зум-уровней он «отодвигается»: слой со своим `minzoom` сам
+     * пропадёт там, где стал бы неразличим. Ровно это происходит у Mapbox, где дальние тайлы физически
+     * берутся с меньшего зума.
+     *
+     * На ненаклонённой карте не меняет ничего: там дальше отсчётной точки ничего и нет.
+     *
+     * @param distancePx расстояние от камеры до тайла в мировых пикселях (`distanceToTile`)
+     */
+    detailZoom(distancePx: number): number;
+    private _ensure;
+    private _calc;
+    private _calcCameraPosition;
+    /**
+     * Плоскости пирамиды видимости из обратной view-projection: берём 8 углов клипа,
+     * переводим в мир и строим 6 плоскостей с нормалями внутрь.
+     */
+    private _calcFrustum;
+    /** Размер тайла зума z в пикселях экрана на расстоянии dist — критерий дробления. */
+    tileScreenSize(z: number, dist: number): number;
+    /** Сколько копий мира по X видно (панорама через антимеридиан). */
+    visibleWrapRange(): {
+        min: number;
+        max: number;
+    };
+}
+
+interface ModelPrimitive {
+    /** Смещение в общем индексном буфере и число индексов. */
+    indexOffset: number;
+    indexCount: number;
+    /** Базовый цвет материала, RGBA 0..1. */
+    baseColor: [number, number, number, number];
+    /**
+     * СОБСТВЕННОЕ свечение материала: `emissiveFactor` × `emissiveStrength`.
+     *
+     * Прибавляется к освещённому цвету и НЕ умножается на свет сцены — в этом весь
+     * смысл: поверхность светится сама. Художник задаёт им «нижний порог» яркости,
+     * чтобы объект не проваливался в черноту, а окна и вывески читались ночью.
+     *
+     * В наших моделях это заполнено осмысленно: у стены 0.22, у двери 0.5, у окна
+     * 0.12, у вывески 0.3. Раньше мы читали из материала только базовый цвет, и всё
+     * это терялось — модель выходила темнее задуманного, а ночью гасла совсем.
+     * Тот же приём у Mapbox называется `emissive-strength`.
+     */
+    emissive: [number, number, number];
+    /**
+     * Металличность и шероховатость — по ним считается отражение.
+     *
+     * ОТСТУПЛЕНИЕ ОТ СПЕЦИФИКАЦИИ, и оно намеренное. По стандарту оба значения по умолчанию равны
+     * ЕДИНИЦЕ, то есть материал без разметки — это «идеально шероховатый металл». На практике так
+     * не бывает: экспортёры просто не пишут поля, которых художник не трогал. В библиотеке карты у
+     * дворца два материала из трёх именно такие, и буквальное чтение стандарта делало из белого
+     * камня чёрный металл.
+     *
+     * Поэтому правило такое: если НЕ ЗАДАНО НИ ОДНО из полей — материал считается матовым
+     * диэлектриком (0 и 1), то есть ровно тем, чем он выглядит. Стоит указать хотя бы одно —
+     * работают умолчания стандарта, и автор получает ровно то, что записал.
+     */
+    metallic: number;
+    roughness: number;
+    /** Индекс изображения в `images` или -1. */
+    texture: number;
+    /** Двусторонний материал — отсечение граней выключается. */
+    doubleSided: boolean;
+    /**
+     * Полупрозрачный материал (`alphaMode: BLEND`).
+     *
+     * Различать обязательно: в моделях сплошь и рядом лежит «подложка-тень» —
+     * плоскость под объектом с полупрозрачной текстурой. Нарисованная непрозрачно,
+     * она выглядит чёрной кляксой (ровно это и было видно под машиной), а в карту
+     * теней такую плоскость пускать нельзя вовсе.
+     */
+    blend: boolean;
+    /** Порог отсечения для `alphaMode: MASK`. */
+    alphaCutoff: number;
+    /**
+     * Узел, который двигает этот примитив, или −1.
+     *
+     * У неподвижных примитивов преобразование узла ЗАПЕЧЕНО в позиции (так дешевле
+     * всего: один буфер, один вызов). У подвижных запечь нечего — их матрица
+     * меняется каждый кадр, — поэтому позиции хранятся в системе самого узла, а
+     * матрицу даёт `Model.nodeMatrix`.
+     */
+    node: number;
+}
+/** Дорожка одного свойства узла: когда и во что оно превращается. */
+interface AnimChannel {
+    path: 'translation' | 'rotation' | 'scale';
+    /** Моменты времени в секундах. */
+    times: Float32Array;
+    /** Значения подряд: 3 числа на кадр у сдвига и масштаба, 4 у кватерниона. */
+    values: Float32Array;
+    /** Ступенькой, а не линейно. */
+    step: boolean;
+}
+/** Подвижный узел: неизменная часть цепочки предков + его собственные дорожки. */
+interface AnimNode {
+    /**
+     * Ближайший подвижный ПРЕДОК или −1.
+     *
+     * Без него анимация предка теряется: у клипа с подъёмом и разворотом это два
+     * разных узла (верхний поднимает, нижний вертит), и запомни мы только
+     * статическую матрицу предков — объект остался бы вертеться на месте, не
+     * поднимаясь. Матрица подвижного узла поэтому собирается по цепочке.
+     */
+    parentNode: number;
+    /** Статическая часть цепочки — от подвижного предка (не включая) до этого узла. */
+    parent: Mat4;
+    /** Значения узла без анимации: тем, чего нет в клипе, остаётся своё. */
+    base: {
+        t: [number, number, number];
+        r: [number, number, number, number];
+        s: [number, number, number];
+    };
+    channels: AnimChannel[];
+}
+interface ModelAnimation {
+    /** Длительность клипа в секундах — по ней время заворачивается в цикл. */
+    duration: number;
+    nodes: Map<number, AnimNode>;
+}
+/**
+ * Источник света из `KHR_lights_punctual` — то, чем художник рисует ночную подсветку объекта.
+ *
+ * Координаты и радиус — В ПРОСТРАНСТВЕ МОДЕЛИ, там же, где лежат вершины. Это не мелочь: модель
+ * ставится на карту своей матрицей, и переводить светильники в мировые координаты пришлось бы на
+ * каждый экземпляр. В пространстве модели они общие для всех экземпляров одного файла, и шейдер
+ * считает освещение прямо там.
+ */
+interface ModelLight {
+    /** `directional` держим ради полноты: свет сцены у нас свой, и такой источник шейдер пропускает. */
+    type: 'point' | 'spot' | 'directional';
+    color: [number, number, number];
+    /** Кандела у точечного и прожектора, люкс у направленного — как в спецификации. */
+    intensity: number;
+    /** Радиус влияния в единицах модели; 0 — не ограничен. */
+    range: number;
+    position: [number, number, number];
+    /** Куда светит прожектор: −Z узла, приведённая к единичной длине. */
+    direction: [number, number, number];
+    /** Косинусы углов конуса: внутри `cosInner` светит в полную силу, за `cosOuter` не светит вовсе. */
+    cosInner: number;
+    cosOuter: number;
+}
+interface ModelMesh {
+    vertices: ArrayBuffer;
+    indices: Uint32Array;
+    primitives: ModelPrimitive[];
+    /** Картинки базового цвета в виде байтов файла (PNG/JPEG) — декодирует уже GPU-слой. */
+    images: Uint8Array[];
+    /** Габариты в единицах модели (обычно метры) — по ним считается масштаб на карте. */
+    min: [number, number, number];
+    max: [number, number, number];
+    /** Анимация узлов; null — модель неподвижна. */
+    animation: ModelAnimation | null;
+    /** Собственная подсветка объекта из `KHR_lights_punctual`. Пусто у моделей без неё. */
+    lights: ModelLight[];
+}
+
+/**
+ * 3D-модель на карте: glTF/GLB по координате.
+ *
+ * Главное требование к этой подсистеме было не «уметь glTF», а **жить в одной
+ * сцене со зданиями**: модель обязана отбрасывать тень на дом и получать тень от
+ * него. Поэтому отдельного прохода теней у моделей нет — они идут в тот же
+ * `renderShadowMap`, что и экструзия. Второй shadow-map мы уже пробовали в
+ * `maps3d-web` и уронили этим кадр (память `maps3d-object-shadows`).
+ */
+interface ModelOptions {
+    /** Адрес .glb. Обычный glTF с внешними файлами не поддерживается. */
+    url: string;
+    /**
+     * Своя доставка байтов вместо простого `fetch(url)`.
+     *
+     * Нужна ассетам Objects3D: перед разбором у них кеш в IndexedDB, запрос
+     * ключа и расшифровка AES-GCM. Знание об этом сервисе модели ни к чему —
+     * ей нужен GLB, а откуда он взялся, решает вызывающий. `url` при этом
+     * остаётся: он идёт в сообщения об ошибках.
+     */
+    fetchBytes?: () => Promise<ArrayBuffer>;
+    coordinates: LngLatLike;
+    /** Высота над землёй, метры. */
+    altitude?: number;
+    /**
+     * Множитель к единицам модели.
+     *
+     * Единицы у моделей какие угодно: в наборе Khronos ToyCar имеет габарит 7 см,
+     * а Fox — 155 «метров». Приводить их к общему знаменателю на глаз бессмысленно,
+     * поэтому масштаб — обязанность приложения. Помогает `fitHeight`.
+     */
+    scale?: number;
+    /** Подогнать масштаб так, чтобы высота модели стала такой, метры. */
+    fitHeight?: number;
+    /** Разворот вокруг вертикали, градусы (0 — модель смотрит на север). */
+    rotation?: number;
+    /**
+     * Доборные наклоны в градусах — вокруг осей X и Z ПРОСТРАНСТВА МОДЕЛИ.
+     *
+     * Нужны размещениям из редактора: там у объекта три угла, и хотя в наших
+     * данных сейчас ненулевой только разворот, поворот лежащего набок объекта
+     * задаётся именно ими.
+     */
+    rotationTiltX?: number;
+    rotationTiltZ?: number;
+    /**
+     * Появляться ростом из земли, как здания.
+     *
+     * По умолчанию ВЫКЛЮЧЕНО: модель, добавленную приложением через `addModel`,
+     * оно ожидает увидеть на своём месте сразу. Включают его детальные
+     * 3D-объекты карты — там объект подъезжает сам, и рост объясняет, откуда он.
+     */
+    growIn?: boolean;
+    visible?: boolean;
+    userData?: Record<string, unknown>;
+    id?: string;
+}
+declare class Model {
+    readonly id: string;
+    visible: boolean;
+    userData: Record<string, unknown>;
+    coordinates: LngLatLike;
+    altitude: number;
+    /**
+     * ПОДЪЁМ РЕЛЬЕФОМ, метры: высота земли под моделью.
+     *
+     * Держится отдельно от `altitude`, а не складывается с ней при создании, по двум причинам: сама
+     * высота модели приходит из данных и не должна теряться, а рельеф догружается сетью и меняется
+     * уже после того, как модель поставлена.
+     */
+    groundZ: number;
+    rotation: number;
+    rotationTiltX: number;
+    rotationTiltZ: number;
+    scale: number;
+    fitHeight?: number;
+    /** Разобранная геометрия; null, пока грузится. */
+    mesh: ModelMesh | null;
+    /** Готовые картинки базового цвета — по индексу из `mesh.images`. */
+    bitmaps: (ImageBitmap | null)[];
+    error: string | null;
+    private loading;
+    /**
+     * Адрес меша — он же ключ ОБЩИХ ресурсов GPU.
+     *
+     * У замены по типу сотни копий одного файла (на замере 634 правила из 653 размещений), и меш у
+     * них буквально один объект: кеш ассетов отдаёт его по этому же адресу. Значит и буферы с
+     * текстурами обязаны быть общими, иначе каждая копия везёт в память свою.
+     */
+    readonly url: string;
+    private readonly fetchBytes?;
+    private matrix;
+    /**
+     * Появление: доля роста по вертикали, 0..1.
+     *
+     * Ровно то же, что у зданий (`u_height_scale`): объект вырастает из земли, а
+     * не возникает целиком. Для модели это не отдельный проход, а множитель к
+     * вертикальной оси базиса — та же матрица уходит и в карту теней, поэтому
+     * тень растёт вместе с объектом.
+     */
+    grow: number;
+    /** Куда идёт появление: 1 — вырастает, 0 — уходит в землю. */
+    growTarget: 0 | 1;
+    private animateIn;
+    private shrinkFrom;
+    private growStart;
+    /**
+     * Прозрачность, 0..1 — ею объект уступает место плану этажа и возвращается.
+     *
+     * Отдельно от `grow`, хотя оба про «появился/пропал». Рост — это ПОЯВЛЕНИЕ
+     * объекта на карте (он вырастает из земли, как здание), и он уместен, когда
+     * объект действительно приехал или уехал. А здесь объект никуда не девается:
+     * камера просто зашла внутрь дома, и модель обязана уйти, не привлекая к
+     * себе внимания, — вырастающая обратно из земли башня при выходе из плана
+     * читается как новое событие на карте, которого не было.
+     */
+    fade: number;
+    /**
+     * Непрозрачность из СТИЛЯ (`osmgl-model-opacity` слоя моделей), 0..1. Множится на `fade`: стиль
+     * задаёт облик, а `fade` — уступку плану этажа, и одно не должно перетирать другое.
+     */
+    styleOpacity: number;
+    /** Отбрасывает ли модель тень (`osmgl-model-cast-shadows`). Получает её в любом случае. */
+    castShadows: boolean;
+    /**
+     * ПОВЕРХ СЦЕНЫ — значок, а не предмет города (машина навигатора, `NavCarOverlay`).
+     *
+     * Такая модель не рисуется в проходе объёма: слой отдаёт её отдельному проходу в самом конце
+     * кадра (`renderOnTop`), после подписей и с ОЧИЩЕННОЙ глубиной. Дом впереди её не закрывает, а
+     * свои грани она по-прежнему прячет друг за другом. Так ведёт себя курсор Google: машина
+     * крупнее настоящей (держит размер значка), и в честной глубине она бы втыкалась в дома на
+     * каждом повороте. В карту теней и в пачку (`renderInstanced`) такие модели не идут.
+     */
+    onTop: boolean;
+    /** Итоговая непрозрачность в кадре. */
+    get alpha(): number;
+    private fadeTarget;
+    private fadeFrom;
+    private fadeStart;
+    private matrix32;
+    private nodeMatrix32;
+    private normal32;
+    constructor(options: ModelOptions);
+    get isLoaded(): boolean;
+    /** Скачивает и разбирает модель. Повторные вызовы возвращают ту же работу. */
+    load(onDone?: () => void): Promise<void>;
+    /**
+     * Продвинуть появление. Возвращает true, пока рост не закончен, — это сигнал
+     * карте просить следующий кадр.
+     *
+     * Отсчёт начинается с ПЕРВОГО кадра, где модель готова: до этого её ещё нет
+     * на экране, и стартуй мы от начала загрузки, объект просто возникал бы уже
+     * выросшим.
+     */
+    advanceGrow(durationSec: number): boolean;
+    /**
+     * Начать уход в землю. Повторный вызов ничего не сбрасывает — иначе объект
+     * на границе радиуса дёргался бы, начиная исчезновение заново каждый кадр.
+     */
+    retire(): void;
+    /**
+     * Спрятать или показать объект ПЛАВНО.
+     *
+     * Повторный вызов с той же целью ничего не сбрасывает: решение принимается
+     * каждый кадр (план этажа то открыт, то нет), и перезапуск отсчёта оставил бы
+     * прозрачность навсегда замершей у начального значения.
+     */
+    setHidden(hidden: boolean): void;
+    /**
+     * Продвинуть исчезновение. Возвращает true, пока оно идёт, — карте это сигнал
+     * просить следующий кадр.
+     */
+    advanceFade(durationSec: number): boolean;
+    /** Объект уже стоит: показать сразу, без повторного роста. */
+    markGrown(): void;
+    /** Вернуть к жизни объект, который уже начал уходить. */
+    revive(): void;
+    /** Эффективный масштаб с учётом `fitHeight`. */
+    effectiveScale(): number;
+    /**
+     * Радиус охватывающей сферы в МЕТРАХ — для отсечения по пирамиде видимости.
+     *
+     * Берём габарит из glTF и умножаем на действующий масштаб. Сфера заведомо больше настоящей формы,
+     * и это правильная сторона ошибки: лишний раз нарисовать дальнее дерево дешевле, чем срезать
+     * половину дворца, попавшую в кадр краем.
+     */
+    boundingRadiusM(): number;
+    /** Начало координат модели в нормализованном меркаторе. */
+    origin(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Матрица «единицы модели → локальные координаты объекта».
+     *
+     * Смена системы координат здесь и есть всё содержание: в glTF оси
+     * `x = вправо, y = вверх, z = на зрителя`, у нас — `x = восток, y = ЮГ,
+     * z = вверх`. Отсюда перестановка `(x, y, z) → (x, z, y)`: она же меняет
+     * рукость системы с правой на левую, а наша именно левая.
+     *
+     * Горизонталь переводится в нормализованный меркатор (делением на длину
+     * параллели), вертикаль остаётся В МЕТРАХ: матрица камеры сама домножит её на
+     * `pixelsPerMeter`. Перепутать эти две — классический способ получить модель,
+     * которая с зумом растёт или тонет в земле.
+     */
+    private localMatrix;
+    /**
+     * Матрица модели в ЗАДАННОМ пространстве объекта.
+     *
+     * Отдельный метод, потому что пространств два: камера и источник света. Обе
+     * матрицы обязаны строиться из одной локальной — иначе глубина, записанная в
+     * карту теней, разойдётся с той, по которой модель потом сравнивают, и модель
+     * начнёт затенять сама себя.
+     */
+    matrixInSpace(objectMatrix: Float32Array, out32?: Float32Array): Float32Array;
+    /**
+     * Позиция камеры В ЕДИНИЦАХ МОДЕЛИ — для отражений.
+     *
+     * Отражению нужен вектор взгляда, а вершины и собственные светильники модели живут в её
+     * собственном пространстве. Переводить их в мировые координаты пришлось бы на каждый экземпляр;
+     * дешевле перевести туда одну камеру.
+     *
+     * Общей инверсии матрицы здесь нет и не нужно. `localMatrix` — это перестановка осей
+     * (glTF x,y,z → восток, вверх, юг) с ОДНИМ масштабом плюс поворот, а такое обращается
+     * транспонированием: сначала снимаем масштаб, потом поворот, потом перестановку.
+     *
+     * Тонкость с единицами: по горизонтали объектное пространство измеряется в долях меркатора, по
+     * вертикали — в метрах. Поэтому горизонталь домножается на длину параллели, приводя всё к метрам,
+     * и только затем делится на масштаб модели.
+     */
+    cameraInModelSpace(tr: Transform): [number, number, number];
+    /** Полная матрица модели для камеры. */
+    matrixFor(tr: Transform): Float32Array;
+    /**
+     * Накрывает ли модель эту точку по горизонтали (нормализованный меркатор).
+     *
+     * Нужно маске заменённых зданий: модель дворца стоит не над одним домом, а
+     * над целым комплексом, и «спрятать дом под точкой привязки» оставляет на
+     * карте все его крылья. Пятно берём как ПОВЁРНУТЫЙ прямоугольник габарита:
+     * настоящий контур модели нам взять неоткуда, а прямоугольник её габарита
+     * ошибается наружу лишь на углах.
+     */
+    coversPoint(mercX: number, mercY: number): boolean;
+    /** Есть ли у модели клип — по нему карта решает, просить ли следующий кадр. */
+    get isAnimated(): boolean;
+    /**
+     * Матрица ПОДВИЖНОГО узла для камеры: та же модельная, домноженная справа на
+     * положение узла в этот момент.
+     *
+     * Отдельный метод, а не поле: узлов у клипа единицы, а считается это на
+     * каждый кадр и на каждую модель — держать кэш дороже, чем перемножить.
+     */
+    matrixForNode(tr: Transform, node: number, timeSec: number): Float32Array;
+    /**
+     * Матрица подвижного узла в ЗАДАННОМ пространстве объекта.
+     *
+     * Пространств два — камера и источник света, — и обе матрицы обязаны
+     * строиться из одной и той же позы узла: разойдись они, и анимированная
+     * часть начнёт отбрасывать тень от другого своего положения.
+     */
+    matrixInSpaceForNode(objectMatrix: Float32Array, node: number, timeSec: number, out32: Float32Array): Float32Array;
+    /**
+     * Матрица нормалей: те же оси, но без масштаба и без переноса.
+     * Масштаб у нас неравномерный (горизонталь в меркаторе, вертикаль в метрах),
+     * поэтому нормали нельзя гонять основной матрицей — они перестанут быть
+     * перпендикулярными, и свет поедет.
+     */
+    normalMatrix(): Float32Array;
+}
+
+/** Что оверлею нужно от карты (`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;
+}
+
+/**
+ * ДЕТАЛЬНЫЕ ДОРОГИ И ЛЕНТА ПОЛОС В СТИЛЕ КАРТЫ — чистая часть: разбор ответов сервиса
+ * (`/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` без изменения поведения.
+ */
+
+/** Отметка полотна в точке `(lng, lat)`, метры (`MapObjectOptions.liftAt` объектов карты). */
+type LiftField = (lng: number, lat: number) => number;
+
+/**
+ * ЛЕНТА ПО ПОЛОСАМ — ЕДИНЫМ ПОЛИГОНОМ, НА ВЫСОТЕ НАСТОЯЩЕГО ПОЛОТНА.
+ *
+ * Разбор и источники — `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;
+}
+
+/**
+ * СКРУГЛЁННАЯ ТРАССА — одна геометрия на линию маршрута, стрелки поворотов и машину навигатора.
+ *
+ * Зачем. Сервер отдаёт ломаную: на перекрёстке — прямой угол. Стрелка поворота раньше сглаживалась
+ * сама (своим ядром, с радиусом от ширины), а линия под ней оставалась углом — на повороте они
+ * расходились (жалоба пользователя 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`.
+ */
+
+/** Скруглённая трасса: точки, якоря исходных узлов и обе меры (исходная и скруглённая). */
+interface RoundedRoute {
+    coords: LonLat[];
+    /** Номер точки `coords` для каждого исходного узла (для узла с дугой — середина дуги). */
+    anchors: number[];
+    /** Скруглённая трасса с метрами. */
+    line: RouteLine;
+    /** Исходная трасса с метрами. */
+    src: RouteLine;
+}
+
+/**
+ * МАШИНА ПО ЛЕНТЕ ПОЛОС — этап 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 { ABSENT_RETRY_MS, ARROW_ICONS, ARROW_ICON_STROKE, ARROW_PATHS, ARROW_TIP_K, type AreaFrame, type AreaSpan, ArrowFades, type BuildOptions, CAP_SEGMENTS, CAR_OUTSIDE_WEIGHT, CHEVRON_MIN_RUN_M, CHEVRON_TOLERANCE_M, CHUNK_M, CLASS_LIMIT, CLOSE_M, CLOSE_VIEW, CORNER_DEG, CORNER_SMOOTH_M, CURSOR, CURSOR_SCALE, CUT_BLEED, DEFAULT_RIBBON_CAP, EVEN_WIDTH_M, FAR_VIEW, FIX_ACC_MAX, FIX_ACC_ROUTE, FIX_MAX_AGE_MS, FIX_NET_ACC, FIX_NET_HOLD_MS, FIX_REJECT_RESET, FIX_SKEW_MIN_MS, FIX_STREAM_JITTER_MS, FIX_VMAX, FOLLOW_BACK_MS, type FetchLanePlanOptions, type FetchLike, type Frame, GUIDANCE_URL, type GuideFrame, HINT_M, type HeightAt, type HintLane, JOIN_M, LANE_CAR_SLOPE_M, LANE_CAR_STEP_M, LANE_OFF_ZOOM, LANE_ON_ZOOM, LANG_TAG, LEVEL_HEIGHT_M, type LaneCarLayer, type LaneCarTrack, LaneGuide, type LaneHint, type LanePlan, type LanePlanRequest, type LaneRoute, type LaneState, type LonLat, MANEUVER_ARROW, ManeuverAnnouncer, type ManeuverArrow, type ManeuverArrowOptions, type ManeuverArrowSize, type ManeuverAt, type Mask, type Measured, NAV_ARRIVE_M, NAV_ARROW, NAV_ARROW_PALETTES, NAV_BACK_M, NAV_BEARING_TAU, NAV_CAR, NAV_CAR_BODIES, NAV_CAR_CLEAR, NAV_CAR_KINDS, NAV_CAR_LABELS, NAV_COAST_TAU, NAV_COLORS, NAV_DEMO, NAV_LOOK_AHEAD_M, NAV_MAX_DT, NAV_MIN_VISIBLE, NAV_PITCH, NAV_PREDICT_MAX, NAV_PULL_TAU, NAV_ROUTE_PULL_TAU, NAV_SPEED_FALL_TAU, NAV_SPEED_RISE_TAU, NAV_SPOKEN_GRID, NAV_STILL_MPS, NAV_THRESHOLD_GRID, NAV_TILT, NAV_TOP_PAD, NAV_TRAFFIC_COLORS, NAV_TRAFFIC_LEVELS, NAV_VIA_SAY_M, NAV_VIEW, NAV_VOICE, NAV_ZOOM_STICK, type NavAim, type NavArrowPalette, type NavBestRoute, type NavCarBody, type NavCarHost, type NavCarIcon, type NavCarKind, type NavCarMaterial, type NavCarModelKind, NavCarOverlay, type NavCarPart, type NavCarPose, type NavFeature, type NavFix, NavFixFilter, type NavFixVerdict, type NavFollowMode, type NavLang, NavProgress, type NavProgressOut, NavPuck, NavRoute, type NavSayKey, type NavStep, NavTracker, type NavTrafficBand, type NavTrip, type NavUpcoming, type NavUtterance, NavViewCamera, type NavViewTarget, type NavVoiceCue, NavZoomStick, OUTLINE_STEP_M, OUTSIDE_LANE_M, OffRouteWatch, type OutsideOptions, PASSED_MIN_M, PROG_AHEAD, PROG_BACK_CONFIRM, PROG_BACK_M, PROG_BACK_MIN, PROG_COARSE_HOLD_MS, PROG_JUMP_CONFIRM, PROG_NEAR_M, PROG_NEAR_MPS, PROG_SWITCH_M, PROG_WIDE_M, PROG_WIDE_ON_M, PUCK_GLIDE_MAX_MS, PUCK_GLIDE_MIN_MS, PUCK_STILL_MAX_M, PUCK_STILL_MIN_M, PUCK_STILL_MPS, PUCK_TELEPORT_M, type PassArea, type PassChevron, type PlanChange, type PlanLane, type PlanManeuver, type PlanSegment, RAMP_SLOPE, RIBBON_ARROW, RIBBON_BLEND_MS, RIBBON_BLEND_STEP_MAX_MS, RIBBON_CAPS, RIBBON_CHEVRON, RIBBON_FADE_M, RIBBON_FADE_REACH_M, RIBBON_FADE_STEP_M, RIBBON_MARGIN_M, RIBBON_PASS_FADE_M, RIBBON_PASS_MARGIN_M, RIBBON_STEP_M, RIBBON_TILE_Z, type Ribbon, type RibbonArea, RibbonAreas, RibbonBlend, type RibbonCap, type RibbonCar, type RibbonChevron, type RibbonFade, type RibbonFeature, type RibbonKind, type RibbonPiece, type RouteLine, type RouteManeuver, type RoutePiece, SPEED_AROUND_TOLERANCE, SPEED_LIMIT_HOLD_MS, SPEED_QUERY_TOLERANCES, type SpeedLimit, SpeedLimitHold, type SpeedVerdict, SpeedWatch, type SurfaceAt, type SurfaceMesh, TILE_EXTENT, TURN_MIN_DEG, TURN_WINDOW_M, type Track, WIDTH_SMOOTH_PTS, type XY, ZOOM_BY_SPEED, areaFrame, areaSpans, arrowPath, bearing, bearingAt, buildRibbon, cameraCenterShift, capPoints, carWeight, chevronRunBase, closeness, contiguousGroups, cutInset, demoSpeedKmh, demoTargetKmh, densify, distM, distParts, edgesOf, evenWidths, fadeRibbonArea, fadeRibbonLine, fallbackHeight, farThreshold, fetchLanePlan, fmt1, fmt4, fmtDist, fmtDur, fracIndex, frameAt, fromUnits, guidanceCamera, hintAt, hintFor, hintNear, inflateRound, isNetworkFix, isOldFix, isRibbonCap, laneCarPose, laneCarShift, laneCarTrack, lanePlanRequest, laneTrack, lateralAt, liftProps, liftPropsOf, lineBetween, linkM, maneuverArrow, maneuverArrowSize, maneuverArrowZoomStep, maneuverArrows, maneuverNeedsArrow, maskOf, measure, measureRoute, mergeRanges, meshSurface, metresAlong, minusMask, mixLevel, mixLonLat, mixNum, navAdvanceM, navAheadPx, navArrowOutline, navCameraCenter, navCameraShiftPx, navCarColor, navCarGlb, navCarHash, navCarIcon, navCarIconSvg, navCarKind, navCarLiftAt, navCarMesh, navCarModelId, navCarPose, navCarScreenY, navCursorShapes, navDemoStep, navDt, navFarText, navFarThreshold, navFollowAim, navFollowModeOf, navFollowPitch, navFollowShiftPx, navHasFar, navHasSpokenDistance, navIsTurn, navLockedCenter, navManeuverPhrase, navNearThreshold, navPhrase, navRoundedForSpeech, navSay, navSnapSpoken, navSpeechText, navSpeeding, navSpokenDistance, navStartingLowercase, navStepSpeed, navStepText, navTargetZoom, navThen, navTiltForZoom, navTrafficLevel, navTurnWeight, navViewTarget, navVoicePhrases, navVoicePlan, navWithDistance, navZoomForAhead, normalCdf, normalsOf, offsetLine, offsetPoint, outlineOf, outsideRanges, parseLanePlan, parseMaxspeed, passedKind, passedPieces, pointAt, pointOn, project, projectOnSegment, resampleLine, resetLanePlanAbsence, ribbonAtProgress, ribbonChevrons, ribbonFade, ribbonFadeAlpha, ribbonLineHidden, ribbonManeuverArrows, ribbonPassChevrons, ribbonProgressState, roundDist, routeLine, routeMeasure, routePieces, routeSurfaceField, shownManeuverArrows, simplifyIdx, sliceAt, sliceLine, smoothCorners, smoothWidths, smoothstep, snapWindow, spanLine, spanOutline, speedLimitFromFeatures, spreadStations, stationsBetween, tangentAt, tileParts, toUnits, trackAt, turnTo, upcoming, valueAt, zoomStops };