@tileflow/core 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/browser.d.ts

@@ -0,0 +1,2281 @@
+import { T as TileflowSymbolStyle, a as TileflowThemeImageValue, b as TileflowThemeColorValue, c as TileflowMarkerSymbolStyle, d as TileflowAreaStyle, e as TileflowLineStackStyle, f as TileflowLineHatchStyle, g as TileflowIconStyle, h as TileflowLinePaint, i as TileflowThemeNumberValue, j as TileflowNumberStyleValue, k as TileflowCircleStyle, l as TileflowLineStyle, m as TileflowFillStyle, n as TileflowExtrusionStyle, o as TileflowThemeValue, p as TileflowBackgroundStyle, q as TileflowSymbolPlacement, r as TileflowVegetationModuleConfig, s as TileflowTileLayer, t as TileflowMap3DOptions, u as TileflowMap3D, v as TileflowViewMode, w as TileflowSun } from './3d-CzLTD0RK.js';
+export { x as TileflowBuildings3D, y as TileflowBuildings3DChange, z as TileflowBuildings3DMap, A as TileflowBuildings3DOptions, B as TileflowBuildings3DThemes, C as TileflowMap3DMap, D as TileflowStreetLights, E as TileflowStreetLightsMap, F as TileflowStreetLightsOptions, G as TileflowSunPreset, H as TileflowTile, I as TileflowTileAddress, J as TileflowTileAreaRequest, K as TileflowTileFeature, L as TileflowTileGeometryType, M as TileflowTileReader, N as TileflowTileReaderOptions, O as TileflowTileRequestTransform, P as TileflowTileSourceMap, Q as TileflowTreeFields, R as TileflowTreeForm, S as TileflowTreeFormMix, U as TileflowTreeFormRange, V as TileflowTreeLayers, W as TileflowTreePlacement, X as TileflowTreePlacementOptions, Y as TileflowTreeRange, Z as TileflowTreeRegion, _ as TileflowTrees3D, $ as TileflowTrees3DChange, a0 as TileflowTrees3DMap, a1 as TileflowTrees3DOptions, a2 as TileflowTrees3DThemes, a3 as TileflowVectorTileDecodeOptions, a4 as TileflowVegetation3D, a5 as TileflowVegetationController, a6 as TileflowVegetationDisplay, a7 as TileflowVegetationOptions, a8 as TileflowVegetationRepresentation, a9 as createTileflowBuildings3D, aa as createTileflowMap3D, ab as createTileflowStreetLights, ac as createTileflowTileReader, ad as createTileflowTrees3D, ae as createTileflowVegetation, af as decodeTileflowVectorTile, ag as mixTileflowSunPresets, ah as placeTileflowTrees, ai as readTileflowMapTileSource, aj as readTileflowSunPreset, ak as readTileflowVegetation3D, al as readTileflowVegetationDisplay, am as resolveTileflowSun, an as resolveTileflowVegetationRepresentation, ao as tileflowBuildings3DLayerId, ap as tileflowDefaultSunPreset, aq as tileflowStreetLightsLayerId, ar as tileflowStyleSunPreset, as as tileflowSunDirection, at as tileflowSunMetadataKey, au as tileflowSunPosition, av as tileflowTilePointToLngLat, aw as tileflowTilesForBounds, ax as tileflowTreeBytes, ay as tileflowTreeFormOf, az as tileflowTreeForms, aA as tileflowTrees3DLayerId, aB as tileflowVegetationDisplayMetadataKey, aC as tileflowVegetationMetadataKey } from './3d-CzLTD0RK.js';
+
+type TileflowColor = `#${string}`;
+type TileflowRoadDetail = 'none' | 'highways' | 'major' | 'streets' | 'all';
+type TileflowRoadClass = 'motorway' | 'trunk' | 'primary' | 'secondary' | 'tertiary' | 'minor' | 'service' | 'track' | 'pathway' | 'footway' | 'cycleway' | 'steps' | 'pedestrian';
+type TileflowRoadHierarchy = 'subtle' | 'clear' | 'strong';
+type TileflowRoadWeight = 'thin' | 'regular' | 'bold';
+type TileflowRoadOutline = 'none' | 'subtle' | 'strong';
+type TileflowRoadStructure = 'bridge' | 'surface' | 'tunnel';
+type TileflowRoadExtras = {
+    paths?: boolean;
+};
+type TileflowRoadLayerStyle = TileflowLineStackStyle & {
+    hatch?: TileflowLineHatchStyle;
+};
+type TileflowRoadTreatmentLineStyle = Pick<TileflowLinePaint, 'blur' | 'color' | 'dash' | 'gapWidth' | 'offset' | 'opacity' | 'width'>;
+type TileflowRoadTreatmentLayerStyle = {
+    casing?: TileflowRoadTreatmentLineStyle;
+    fill?: TileflowRoadTreatmentLineStyle;
+    shadow?: TileflowRoadTreatmentLineStyle;
+};
+type TileflowRoadTreatmentStyle = Partial<Record<TileflowRoadStructure, TileflowRoadTreatmentLayerStyle>> & {
+    enabled?: boolean;
+    widthScale?: TileflowThemeNumberValue;
+};
+type TileflowRoadModifier = 'construction' | 'expressway' | 'indoor' | 'official' | 'ramp' | 'unpaved';
+type TileflowRoadRestriction = 'access' | 'bicycle' | 'foot' | 'horse' | 'toll';
+type TileflowMountainBikeScale = '0' | '0+' | '1' | '1+' | '2' | '2+' | '3' | '3+' | '4' | '5' | '6';
+type TileflowRoadServiceType = 'alley' | 'crossover' | 'driveway' | 'parkingAisle' | 'yard';
+type TileflowRoadClassStyle = Partial<Record<TileflowRoadStructure, TileflowRoadLayerStyle>> & {
+    enabled?: boolean;
+};
+type TileflowRoadAreaStyle = {
+    pedestrian?: TileflowAreaStyle;
+    pier?: TileflowAreaStyle;
+    road?: TileflowAreaStyle;
+};
+type TileflowRoadCrossingStyle = Omit<TileflowIconStyle, 'image'> & Required<Pick<TileflowIconStyle, 'image'>>;
+type TileflowRoadRoundaboutStyle = {
+    /** Extra casing width in pixels, split equally across both edges; defaults to the road border. */
+    borderWidth?: TileflowNumberStyleValue;
+    casing?: TileflowCircleStyle;
+    /** Road width in pixels when metric radii are absent; defaults to the effective surface fill width. */
+    fallbackWidth?: TileflowNumberStyleValue;
+    fill?: TileflowCircleStyle;
+};
+/**
+ * How Core's street lights renderer lights the map's streets at night, from the lamps and lit
+ * streets its data holds.
+ */
+type TileflowRoadStreetLightStyle = {
+    /** The light of lamps whose data gives no colour; a warm white by default. */
+    color?: TileflowThemeColorValue;
+    /** Whether the map has street lights; defaults to false. Set true to opt in. */
+    enabled?: boolean;
+    /**
+     * Where light is estimated where the data maps no lamps: `lit` (the default) along streets and
+     * pavements mapped as lit; `streets` also along streets the data says nothing about, in tiles
+     * that map few lamps, which invents light; `none` nowhere.
+     */
+    estimate?: 'lit' | 'streets' | 'none';
+    /** How bright the lights shine, from 0 to 2; defaults to 1. */
+    intensity?: TileflowThemeNumberValue;
+};
+type TileflowRoadSidewalkStyle = {
+    outline?: TileflowLineStyle;
+    pattern?: TileflowFillStyle;
+    surface?: TileflowFillStyle;
+};
+type TileflowRoadsModuleConfig = {
+    type: 'roads';
+    areas?: TileflowRoadAreaStyle;
+    classes?: Partial<Record<TileflowRoadClass, TileflowRoadClassStyle>>;
+    crossings?: TileflowRoadCrossingStyle;
+    detail?: TileflowRoadDetail;
+    extras?: TileflowRoadExtras;
+    hierarchy?: TileflowRoadHierarchy;
+    modifiers?: Partial<Record<TileflowRoadModifier, TileflowRoadTreatmentStyle>>;
+    mountainBike?: Partial<Record<TileflowMountainBikeScale, TileflowRoadTreatmentStyle>>;
+    oneWayMarkers?: boolean;
+    outline?: TileflowRoadOutline;
+    /** Draw ramp fills below receiving roads by default; `by-class` keeps their class's order. */
+    rampOrder?: 'below-roads' | 'by-class';
+    restrictions?: Partial<Record<TileflowRoadRestriction, TileflowRoadTreatmentStyle>>;
+    roundabouts?: TileflowRoadRoundaboutStyle;
+    serviceTypes?: Partial<Record<TileflowRoadServiceType, TileflowRoadTreatmentStyle>>;
+    sidewalks?: TileflowRoadSidewalkStyle;
+    streetLights?: TileflowRoadStreetLightStyle;
+    structures?: Partial<Record<TileflowRoadStructure, TileflowRoadLayerStyle>>;
+    weight?: TileflowRoadWeight;
+    widthScale?: Partial<Record<TileflowRoadClass, TileflowThemeNumberValue>>;
+};
+type TileflowLabelDetail = 'none' | 'major' | 'all';
+type TileflowAerodromeCodeDetail = 'none' | 'iata' | 'all';
+type TileflowRoadLabelDetail = TileflowRoadDetail;
+type TileflowLabelLanguage = 'auto' | 'local' | 'en' | (string & {});
+type TileflowPlaceLabelClass = 'city' | 'continent' | 'country' | 'neighborhood' | 'other' | 'state' | 'town' | 'village';
+type TileflowWaterLabelClass = 'line' | 'ocean' | 'other' | 'waterway';
+type TileflowRoadShieldDetail = 'none' | 'major' | 'all';
+type TileflowLabelCollisionPriority = 'balanced' | 'navigation';
+type TileflowRoadShieldStyles = {
+    default?: TileflowSymbolStyle;
+    detail?: TileflowSymbolStyle;
+    kinds?: Record<string, {
+        image: TileflowThemeImageValue;
+    }>;
+    overview?: TileflowSymbolStyle;
+    textColors?: Record<string, {
+        color: TileflowThemeColorValue;
+    }>;
+};
+type TileflowLabelStyles = {
+    aerodrome?: TileflowSymbolStyle;
+    junctions?: TileflowSymbolStyle;
+    places?: Partial<Record<TileflowPlaceLabelClass, TileflowSymbolStyle>>;
+    roads?: Partial<Record<TileflowRoadClass, TileflowSymbolStyle>>;
+    shields?: TileflowRoadShieldStyles;
+    water?: Partial<Record<TileflowWaterLabelClass, TileflowSymbolStyle>>;
+};
+type TileflowLabelsModuleConfig = {
+    type: 'labels';
+    aerodromeCodes?: TileflowAerodromeCodeDetail;
+    collisionPriority?: TileflowLabelCollisionPriority;
+    junctions?: boolean;
+    language?: TileflowLabelLanguage;
+    places?: TileflowLabelDetail;
+    roadClasses?: readonly TileflowRoadClass[];
+    /** Share placement and repeated-name suppression across compatible road classes. */
+    roadGrouping?: 'class' | 'network';
+    /** Abbreviate recognized road-type words without translating the selected label language. */
+    roadNameFormat?: 'full' | 'compact';
+    /**
+     * Where street names draw. `foreground` (the default) keeps them above buildings and
+     * vegetation. `ground` places them above flat footprints and below raised buildings,
+     * with map-aligned text by default.
+     * Ground names retain their road-class collision order, but foreground symbols are offered
+     * first by the renderer; `collisionPriority` cannot make ground names outrank those symbols.
+     * Shields and junction numbers keep their foreground placement.
+     */
+    roadPlacement?: 'ground' | 'foreground';
+    /** Defaults to streets, including local street names where their geometry is enabled. */
+    roads?: TileflowRoadLabelDetail;
+    shields?: TileflowRoadShieldDetail;
+    styles?: TileflowLabelStyles;
+    water?: TileflowLabelDetail;
+};
+/** Closed editorial vocabulary emitted by Tileflow World's canonical POI projection. */
+declare const tileflowPoiCategories: readonly ["arts-entertainment", "education", "food-drink", "landmark", "lodging", "medical", "park-nature", "public-services", "religion", "retail", "sport-leisure", "transport", "visitor-amenity"];
+type TileflowPoiCategory = (typeof tileflowPoiCategories)[number];
+type TileflowPoiDensity = 1 | 2 | 3 | 4 | 5;
+type TileflowPoiColorMode = 'uniform' | 'category';
+/**
+ * How POI categories are placed against each other. `importance` places every category in one
+ * order, by World's ranks. `categories` gives each category its own layer and places the
+ * categories in the order they are listed, the first on top; ranks order each category only.
+ */
+type TileflowPoiPlacementOrder = 'categories' | 'importance';
+/**
+ * The appearance of one POI category. With the default `importance` order every category shares
+ * one placement layer, so categories may differ only in properties MapLibre evaluates per feature
+ * (image, size, colors, font, offsets); layer-wide properties such as zoom ranges, padding,
+ * overlap or `optional` must match, or the module uses `placement.order: 'categories'`.
+ */
+type TileflowPoiCategoryStyle = Omit<TileflowMarkerSymbolStyle, 'priority'>;
+type TileflowPoiModuleConfig = {
+    type: 'poi';
+    categories?: readonly TileflowPoiCategory[];
+    color?: TileflowPoiColorMode;
+    /** Defaults to 2. World's ranks decide which features are eligible at each zoom. */
+    density?: TileflowPoiDensity;
+    /** Category overrides of density, with the same zoom-dependent detail allowance. */
+    densityByCategory?: Partial<Record<TileflowPoiCategory, TileflowPoiDensity>>;
+    /** Zoom for the second extra rank of POI detail. Must exceed 16; defaults to 17. */
+    detailZoom?: number;
+    icons?: boolean;
+    labels?: boolean;
+    minZoom?: number;
+    placement?: {
+        /**
+         * Places each pictogram with its name as one unit that needs room for both. Defaults to
+         * `true`. Use false to place pictograms and names independently.
+         */
+        coupleIconAndLabel?: boolean;
+        iconPadding?: number;
+        /**
+         * World POI `type` values whose pictogram explains them. When pictograms and names are both
+         * drawn, every other POI needs a name, and these types are drawn as a pictogram alone.
+         * Defaults to parking and public toilets.
+         */
+        iconOnlyTypes?: readonly string[];
+        /** Defaults to `importance`. */
+        order?: TileflowPoiPlacementOrder;
+        /**
+         * With the `importance` order, POIs whose World `filter_rank` is at most this value are placed
+         * before the map's road and place labels, and the others after them. A map that gives street
+         * names priority over POIs (labels `collisionPriority: 'navigation'`) keeps its landmarks this
+         * way. Unset, every POI is placed at the module's own position.
+         */
+        prominentRank?: 0 | 1 | 2 | 3 | 4 | 5;
+        /** Collision margin around the name, in pixels. Defaults to 3. */
+        textPadding?: number;
+    };
+    styles?: Partial<Record<TileflowPoiCategory, TileflowPoiCategoryStyle>>;
+};
+type MapLibreSprite = string | Array<{
+    id: string;
+    url: string;
+}>;
+type TileflowProjection = 'globe' | 'mercator';
+type TileflowLight = {
+    anchor?: 'map' | 'viewport';
+    color?: TileflowColor;
+    intensity?: number;
+    position?: readonly [number, number, number];
+};
+type MapLibreStyle = {
+    sky?: Record<string, unknown>;
+    version: 8;
+    name: string;
+    glyphs?: string;
+    light?: TileflowLight;
+    projection?: {
+        type: TileflowProjection;
+    };
+    sprite?: MapLibreSprite;
+    sources: Record<string, Record<string, unknown>>;
+    layers: Array<Record<string, unknown>>;
+    terrain?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+
+type ShadowPoint = readonly number[];
+type ShadowBox = Readonly<{
+    min: ShadowPoint;
+    max: ShadowPoint;
+}>;
+type ShadowRange = readonly [number, number];
+/** The light-space ranges a light view covers: across and up the shadow map, and along the light. */
+type ShadowFit = Readonly<{
+    right: ShadowRange;
+    up: ShadowRange;
+    depth: ShadowRange;
+}>;
+type ShadowView = Readonly<{
+    /** Visible receiver points, in the caster box's metre frame. All casters still draw. */
+    receivers?: readonly ShadowPoint[];
+    /** Snap to world-aligned texels; omit for an unsnapped mathematical projection. */
+    resolution?: number;
+    origin?: ShadowPoint;
+    /** Metres per fixed world unit; keeps texel quantization independent of latitude scale. */
+    gridScale?: number;
+    /** A share of the focused span added on each side, so a moving view stays inside the fit. */
+    margin?: number;
+    /**
+     * A fit in the same frame and light, kept on each axis while it covers the view and is at most
+     * half again as wide as a new fit would be.
+     */
+    previous?: ShadowFit;
+}>;
+/**
+ * The sun's orthographic view, in metres, with room for each caster's shadow to reach the ground.
+ * Optional receivers concentrate XY resolution without dropping offscreen casters along a ray;
+ * quantized extents and a world-anchored texel grid keep stationary shadows stable during pans.
+ */
+declare function tileflowSunLightMatrix(direction: readonly number[], box: ShadowBox, view?: ShadowView): {
+    matrix: Float32Array;
+    depth: number;
+    extent: number;
+    fit: ShadowFit;
+};
+
+/** Inputs to one fixed-size, application-owned RGBA image. */
+type TileflowDynamicImageContext = Readonly<{
+    theme: string;
+    blend?: Readonly<{
+        position: number;
+        themes: readonly string[];
+    }>;
+    states: Readonly<Record<string, boolean | number | string | null | undefined>>;
+    /** Physical pixel dimensions, fixed for this registration. */
+    width: number;
+    height: number;
+    pixelRatio: number;
+}>;
+type TileflowDynamicImage = Readonly<{
+    /** Physical pixel dimensions, each from 1 through 2048. */
+    width: number;
+    height: number;
+    /** Physical pixels per logical pixel. Defaults to 1; fixed until disposal. */
+    pixelRatio?: number;
+    /** Controller states that invalidate this image, including interpolated values. */
+    states?: readonly string[];
+    /** Synchronous RGBA pixels; undefined keeps the previous pixels (initially transparent). */
+    render(context: TileflowDynamicImageContext): Uint8Array | Uint8ClampedArray | undefined;
+    /** Later render/restore failures retain good pixels. Defaults to console.error. */
+    onError?(error: Error): void;
+}>;
+type TileflowDynamicImageHandle = {
+    /** Refresh external inputs at the next frame. Repeated requests coalesce. */
+    refresh(): void;
+    /** Cancel queued work, release the name and remove only this resource's image. */
+    dispose(): void;
+};
+type TileflowDynamicImageMap = {
+    addImage?: unknown;
+    getCanvas?: unknown;
+    getImage?: unknown;
+    getStyle?: unknown;
+    removeImage?: unknown;
+    updateImage?: unknown;
+    on(event: string, listener: () => void): unknown;
+    off(event: string, listener: () => void): unknown;
+};
+
+/**
+ * `GRACE` and `MANAGED_REQUIRED` come from the site's fair-use state. `LIMITED` means Tileflow is
+ * temporarily limiting anonymous World delivery for everyone: cached areas keep loading while some
+ * uncached areas fail, and a managed map is not affected.
+ */
+type TileflowFairUseNoticeState = 'GRACE' | 'MANAGED_REQUIRED' | 'LIMITED';
+type TileflowFairUseNotice = Readonly<{
+    action: string;
+    helpUrl: string;
+    message: string;
+    state: TileflowFairUseNoticeState;
+}>;
+type TileflowWorldProtocolRequest = Readonly<{
+    type?: string;
+    url: string;
+}>;
+type TileflowWorldProtocolResponse = Readonly<{
+    cacheControl?: string;
+    data: ArrayBuffer;
+    etag?: string;
+    expires?: string;
+}>;
+type TileflowWorldProtocolHandler = (request: TileflowWorldProtocolRequest, abortController: AbortController) => Promise<TileflowWorldProtocolResponse>;
+type TileflowWorldRequestBridge = Readonly<{
+    dispose: () => void;
+    rewriteUrl: (url: string) => string;
+}>;
+type TileflowFairUseNoticeController = Readonly<{
+    dispose: () => void;
+    update: (notice: TileflowFairUseNotice | null) => void;
+}>;
+declare function registerTileflowWorldRequestBridge(input: {
+    addProtocol: (name: string, handler: TileflowWorldProtocolHandler) => void;
+    fetch?: typeof fetch;
+    now?: () => number;
+    onNotice: (notice: TileflowFairUseNotice | null) => void;
+}): TileflowWorldRequestBridge;
+declare function tileflowFairUseNoticeMessage(state: TileflowFairUseNoticeState): string;
+declare function attachTileflowFairUseNotice(container: HTMLElement): TileflowFairUseNoticeController;
+
+type TileflowAddressesModuleOptions = {
+    /** Styling for OpenMapTiles point house-number labels. */
+    labels?: TileflowSymbolStyle;
+};
+type TileflowAddressesModuleConfig = TileflowAddressesModuleOptions & {
+    type: 'addresses';
+};
+
+type TileflowAerowaysModuleOptions = {
+    area?: TileflowAreaStyle;
+    runway?: TileflowLineStackStyle;
+    runwayRef?: TileflowSymbolStyle;
+    taxiway?: TileflowLineStackStyle;
+};
+type TileflowAerowaysModuleConfig = TileflowAerowaysModuleOptions & {
+    type: 'aeroways';
+};
+
+type TileflowBoundariesModuleOptions = {
+    admin2?: TileflowLineStyle;
+    admin4?: TileflowLineStyle;
+    disputed?: TileflowLineStyle;
+    maritime?: TileflowLineStyle;
+};
+type TileflowBoundariesModuleConfig = TileflowBoundariesModuleOptions & {
+    type: 'boundaries';
+};
+
+/** Decorative finishes for ordinary extruded buildings; they do not describe surveyed materials. */
+type TileflowBuildingSurfaces<Numeric = number, Size = readonly [number, number]> = {
+    walls?: {
+        kind: 'brick';
+        /** Brick width and course height in metres; defaults to [6, 3]. */
+        size?: Size;
+        /** Recessed joint width in metres; defaults to 0.12. */
+        jointWidth?: Numeric;
+        /** Strength of the shaded joints, from 0 to 1; defaults to 0.2. */
+        contrast?: Numeric;
+    };
+    roof?: {
+        kind: 'tiles';
+        /** Square size in projected Mercator metres; defaults to 8. */
+        size?: Numeric;
+        /** Joint width in projected Mercator metres; defaults to 0.12. */
+        jointWidth?: Numeric;
+        contrast?: Numeric;
+    };
+    /** A painted light band and seam at the roof edge, without adding geometry. */
+    cornice?: {
+        height?: Numeric;
+        contrast?: Numeric;
+    };
+};
+type TileflowBuildingSurfaceDesign = {
+    walls?: Required<NonNullable<TileflowBuildingSurfaces['walls']>>;
+    roof?: Required<NonNullable<TileflowBuildingSurfaces['roof']>>;
+    cornice?: Required<NonNullable<TileflowBuildingSurfaces['cornice']>>;
+};
+
+/** The parts of a model, each coloured by the theme: the model's materials name them. */
+declare const tileflowModelParts: Readonly<{
+    surface: 0;
+    secondary: 1;
+    glass: 2;
+    accent: 3;
+    roof: 4;
+}>;
+type TileflowModelPart = keyof typeof tileflowModelParts;
+/** Architectural roles control lighting independently of the model's palette slots. */
+declare const tileflowModelLightingRoles: Readonly<{
+    unclassified: 0;
+    wall: 1;
+    door: 2;
+    roof: 3;
+    window: 4;
+    lamp: 5;
+    logo: 6;
+}>;
+type TileflowModelLightingRole = keyof typeof tileflowModelLightingRoles;
+
+type TileflowBuildingMode = '3d' | 'flat';
+/**
+ * How Core's 3D buildings renderer draws the map's buildings. Their colour is the map's own 3D
+ * building colour (its extrusion), else its roofs'.
+ */
+type TileflowBuildingsThreeDimensionalStyle = {
+    /** Use the scene sun (default), or the style's native extrusion light. */
+    lighting?: 'style' | 'sun';
+    /** Per-building brightness variation, from 0 to 1; defaults to 0 (authored colour). */
+    colorVariation?: TileflowThemeNumberValue;
+    /** How strongly roof outlines and outer corners catch the light, from 0 (default) to 1. */
+    edges?: TileflowThemeNumberValue;
+    /** Radius in metres for softened exterior corners and roof lighting, from 0 to 1; defaults to 0.8. */
+    edgeRadius?: number;
+    /** Their own colour, drawn unlit; without it they take the building's colour, lightened. */
+    edgeColor?: TileflowThemeColorValue;
+    /** How bright the buildings light the street at night, from 0 (none) to 2; defaults to 0. */
+    nightLight?: TileflowThemeNumberValue;
+    /** Height-selected architectural flood lighting. Off by default; follows scene darkness. */
+    floodLight?: {
+        intensity?: TileflowThemeNumberValue;
+        /** Compensates authored light-colour transforms during darkness evaluation; defaults to 1. */
+        brightnessScale?: TileflowThemeNumberValue;
+        color?: TileflowThemeColorValue;
+        /** Stable per-building ground radius range in metres; defaults to [30, 100]. */
+        groundRadius?: readonly [number, number];
+        /** Ground light starts at this height in metres; defaults to 30. */
+        minGroundHeight?: number;
+        /** Wall light starts above this height in metres; defaults to 200. */
+        minWallHeight?: number;
+        /** Wall radius as a fraction of building height; defaults to 1/3. */
+        wallHeightRatio?: number;
+    };
+    /** Per-role physical materials and emission, separate from palette slots and occlusion. */
+    modelLighting?: Partial<Record<TileflowModelLightingRole, {
+        emissiveStrength?: TileflowThemeNumberValue;
+        /** Stable per-model addition to emission, from zero to this amount. */
+        emissiveVariation?: TileflowThemeNumberValue;
+        emissiveColor?: TileflowThemeColorValue;
+        /** Height fractions, multipliers and curve exponent; defaults to a constant multiplier of one. */
+        emissiveHeight?: readonly [
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue
+        ];
+        /** Physical-material tint. Explicit modelColors take precedence. */
+        color?: TileflowThemeColorValue;
+        colorMix?: TileflowThemeNumberValue;
+        metallic?: TileflowThemeNumberValue;
+        roughness?: TileflowThemeNumberValue;
+        /** Independent HSL ranges, seeded by model identity; no window geometry is invented. */
+        colorVariation?: {
+            hue: readonly [TileflowThemeNumberValue, TileflowThemeNumberValue];
+            saturation: readonly [TileflowThemeNumberValue, TileflowThemeNumberValue];
+            lightness: readonly [TileflowThemeNumberValue, TileflowThemeNumberValue];
+            space?: 'srgb' | 'linear';
+        };
+    }>>;
+    /**
+     * The zoom bands the city comes in over: zooming in, across each band its part fades in and rises
+     * from the ground, and zooming out it sinks and fades again. Defaults to the 0.3 zooms from the
+     * renderer's `minzoom` (15) for the buildings, and to the 0.4 zooms from 0.8 before it for the
+     * placed models and landmarks, which stand first. With reduced motion they only fade.
+     */
+    entrance?: {
+        buildings?: readonly [number, number];
+        models?: readonly [number, number];
+    };
+    /** Contact shadow at the foot of the walls and in tight corners; defaults to true. */
+    occlusion?: boolean;
+    /** Prepared model ambient occlusion strength, from 0 to 1; defaults to 0.75. */
+    modelOcclusion?: TileflowThemeNumberValue;
+    /** Shadows from the sun, on the buildings and the flat map; defaults to true. */
+    shadows?: boolean;
+    /**
+     * Invented night windows, lit by rooms: decoration, not data. With World's `class`, none on sheds,
+     * barns, factories and churches, and homes lit apart from offices. Defaults to false.
+     */
+    windows?: boolean;
+    /** Decorative wall joints, roof tiles and painted cornices. Off by default; ordinary buildings only. */
+    surfaces?: TileflowBuildingSurfaces<TileflowThemeNumberValue, TileflowThemeValue<readonly [number, number]>>;
+    /**
+     * Building models the map places in its city, from the glTF binaries in its `models`
+     * directories. Each stands in for the buildings under its footprint.
+     */
+    models?: readonly TileflowBuildingModelPlacementConfig[];
+    /** The colours of the models' parts; a part without one takes it from the building colour. */
+    modelColors?: Partial<Record<TileflowBuildingModelPart, TileflowThemeColorValue>>;
+    /**
+     * Tileflow's landmarks, such as the Eiffel Tower, drawn as models in place of the buildings
+     * under them. On by default with Tileflow World data; `false` switches them off, and `url` names
+     * the TileJSON of another landmarks tileset. The map's own `models` come first: a landmark with
+     * the same id as one, or whose footprint meets one's, is not drawn.
+     */
+    landmarks?: boolean | {
+        url: string;
+    };
+};
+/** The parts of a building model, as its materials name them. */
+type TileflowBuildingModelPart = 'surface' | 'secondary' | 'glass' | 'accent' | 'roof';
+/** Where a building model stands. */
+type TileflowBuildingModelPlacementConfig = {
+    /** The model's id: the name of its `.glb` file in the map's `models` directories. */
+    model: string;
+    /**
+     * The HTTPS address of the model's prepared file when it is served elsewhere, such as a model
+     * Tileflow hosts for its own maps; the map then needs no `.glb` of its own for it.
+     */
+    url?: string;
+    /** Longitude and latitude of the model's origin, where it stands on the ground. */
+    at: readonly [number, number];
+    /** Degrees clockwise from north that the model's own north (its +y) is turned to; defaults to 0. */
+    heading?: number;
+};
+type TileflowBuildingsModuleOptions = {
+    businessCorridor?: TileflowAreaStyle;
+    extrusion?: TileflowExtrusionStyle;
+    flat?: TileflowAreaStyle;
+    mode?: TileflowBuildingMode;
+    threeDimensional?: TileflowBuildingsThreeDimensionalStyle;
+};
+type TileflowBuildingsModuleConfig = TileflowBuildingsModuleOptions & {
+    type: 'buildings';
+};
+
+type TileflowLanduseClass = 'cemetery' | 'civic' | 'commercial' | 'education' | 'government' | 'industrial' | 'medical' | 'military' | 'parking' | 'railway' | 'recreation' | 'residential';
+type TileflowLandcoverClass = 'farmland' | 'flowerbed' | 'grass' | 'ice' | 'meadow' | 'protected' | 'recreationGround' | 'rock' | 'sand' | 'scrub' | 'urbanPark' | 'villageGreen' | 'wetland' | 'wood';
+/** The barriers of the data's barrier layer (World's `traffic_control`) the land module draws. */
+type TileflowBarrierClass = 'fence' | 'hedge' | 'wall';
+/**
+ * A barrier's line, a shadow line drawn under it (usually offset with `translate`), and the fill of
+ * those mapped as areas, such as broad hedges.
+ */
+type TileflowBarrierStyle = {
+    area?: TileflowFillStyle;
+    shadow?: TileflowLineStyle;
+    line?: TileflowLineStyle;
+};
+type TileflowLandModuleOptions = {
+    background?: TileflowBackgroundStyle;
+    /**
+     * Hedges, fences and walls, drawn at the top of the land band with hedges uppermost. A barrier
+     * without a style is not drawn, and neither is any when the data has no barrier layer.
+     */
+    barriers?: Partial<Record<TileflowBarrierClass, TileflowBarrierStyle>>;
+    globalLandcover?: TileflowFillStyle;
+    landcover?: Partial<Record<TileflowLandcoverClass, TileflowAreaStyle>>;
+    landuse?: Partial<Record<TileflowLanduseClass, TileflowAreaStyle>>;
+};
+type TileflowLandModuleConfig = TileflowLandModuleOptions & {
+    type: 'land';
+};
+
+declare const tileflowLandformClasses: readonly ["peak", "volcano", "saddle", "ridge", "cliff", "arete"];
+type TileflowLandformClass = (typeof tileflowLandformClasses)[number];
+type TileflowLandformsModuleOptions = {
+    classes?: Partial<Record<TileflowLandformClass, TileflowSymbolStyle>>;
+    /** Append source elevation in metres when the feature provides it. */
+    elevation?: boolean;
+};
+type TileflowLandformsModuleConfig = TileflowLandformsModuleOptions & {
+    type: 'landforms';
+};
+
+/**
+ * Labels anchored inside polygon features, and the clearance labels of bridges and overhead cables;
+ * other point-feature labels remain on their feature style.
+ */
+type TileflowNauticalAreaLabelStyles = {
+    /**
+     * Vertical clearance of bridges, or their clearance closed and open, at bridge points and inside
+     * bridge polygons; bridge lines carry it at their centre.
+     */
+    bridges?: TileflowSymbolStyle;
+    /** Provider coverage cells; hidden unless a map makes this style visible. */
+    coverage?: TileflowSymbolStyle;
+    hazards?: TileflowSymbolStyle;
+    navigationAreas?: TileflowSymbolStyle;
+    /** Safe vertical clearance of overhead cables, at cable points and along cable lines. */
+    overheadCables?: TileflowSymbolStyle;
+    reefs?: TileflowSymbolStyle;
+    wrecks?: TileflowSymbolStyle;
+};
+/**
+ * One style per semantic group of `nautical-v1` objects. Point groups draw a circle `marker`, an
+ * `icon` from the theme's nautical image tokens, and `text`; area groups draw a `fill` and an
+ * `outline`; line groups draw one stroke. Every group respects each feature's `min_zoom`, and
+ * point groups place more important features (lower `rank`) first.
+ */
+type TileflowNauticalModuleOptions = {
+    /** Other aids: moorings, fog signals, racons, radio and signal stations, and virtual aids. */
+    aids?: TileflowMarkerSymbolStyle;
+    /**
+     * Flash each light in its rhythm where a browser runtime animates the map. Defaults to `true`.
+     * `false` keeps every light steady, as do reduced motion, capture, and native renderers.
+     */
+    animateLights?: boolean;
+    /** Fixed beacons and daymarks, coloured by their first colour. */
+    beacons?: TileflowMarkerSymbolStyle;
+    /** Berth polygons; the outline also strokes berth lines and emphasises guest berths. */
+    berths?: TileflowAreaStyle;
+    /** Bridge polygons; the outline also strokes bridge lines. */
+    bridges?: TileflowAreaStyle;
+    /** Buoys, light floats, and light vessels, coloured by their first colour. */
+    buoys?: TileflowMarkerSymbolStyle;
+    /** Submarine cable and pipeline lines. */
+    cables?: TileflowLineStyle;
+    /** Restrained indication of where a provider publishes marks. */
+    coverage?: TileflowAreaStyle;
+    /** Waterway distance marks with their distance and unit. */
+    distanceMarks?: TileflowMarkerSymbolStyle;
+    /**
+     * Small-craft facilities such as fuel, water, slipways, pump-out, visitor berths, boat hoists,
+     * and boatyards, at facility points, inside facility polygons, and at the centre of their lines.
+     */
+    facilities?: TileflowMarkerSymbolStyle;
+    /** Harbour and marina polygons. */
+    harbourAreas?: TileflowAreaStyle;
+    /** Harbour and marina points, and their symbol and name inside harbour polygons. */
+    harbours?: TileflowMarkerSymbolStyle;
+    /** Hazard areas; the outline also strokes linear hazards such as booms. */
+    hazardAreas?: TileflowAreaStyle;
+    /** Rocks by water level, obstructions, and offshore platforms. */
+    hazards?: TileflowMarkerSymbolStyle;
+    labels?: TileflowNauticalAreaLabelStyles;
+    lighthouses?: TileflowMarkerSymbolStyle;
+    /** Light flares coloured by the light's first colour, with the chart light label. */
+    lights?: TileflowMarkerSymbolStyle;
+    /** Restricted, military, anchorage, traffic-separation, and other navigation areas. */
+    navigationAreas?: TileflowAreaStyle;
+    /** Inland notice boards coloured by function, with the information they show. */
+    notices?: TileflowMarkerSymbolStyle;
+    /** Overhead cable lines. */
+    overheadCables?: TileflowLineStyle;
+    /** Ports, sized by `size` and placed by `rank` from low zooms. */
+    ports?: TileflowMarkerSymbolStyle;
+    reefs?: TileflowAreaStyle;
+    /** Traffic-separation lines and recommended routes, tracks, and ferry routes. */
+    routes?: TileflowLineStyle;
+    soundings?: TileflowMarkerSymbolStyle;
+    wreckAreas?: TileflowAreaStyle;
+    wrecks?: TileflowMarkerSymbolStyle;
+};
+type TileflowNauticalModuleConfig = TileflowNauticalModuleOptions & {
+    type: 'nautical';
+};
+
+type TileflowTransitModuleOptions = {
+    cableway?: TileflowLineStyle;
+    ferry?: TileflowLineStyle;
+    rail?: TileflowTransitRailStyle;
+    railHatching?: TileflowTransitRailStyle;
+    serviceRail?: TileflowTransitRailStyle;
+};
+type TileflowTransitRailStyle = {
+    bridge?: TileflowLineStyle;
+    surface?: TileflowLineStyle;
+    tunnel?: TileflowLineStyle;
+};
+type TileflowTransitModuleConfig = TileflowTransitModuleOptions & {
+    type: 'transit';
+};
+
+type TileflowWaterwayClass = 'canal' | 'other' | 'river' | 'stream';
+/** Explicit placement for every geometry family in a declared Bathymetry name layer. */
+type TileflowBathymetryNamePlacement = {
+    point: 'point';
+    line: TileflowSymbolPlacement;
+    polygon: TileflowSymbolPlacement;
+};
+type TileflowBathymetryNameStyle = TileflowSymbolStyle & {
+    /** Overrides scalar placement for these names; omission preserves scalar placement. */
+    placementByGeometry?: TileflowBathymetryNamePlacement;
+};
+type TileflowWaterModuleOptions = {
+    bathymetry?: TileflowFillStyle;
+    /** Contour lines when declared by Bathymetry; otherwise approximate polygon band edges. */
+    bathymetryContours?: TileflowLineStyle;
+    /** Contour-depth or legacy band-floor labels, not measured survey soundings. */
+    bathymetryLabels?: TileflowSymbolStyle;
+    /** Names from an explicitly declared seafloor_landform layer. */
+    bathymetryLandforms?: TileflowBathymetryNameStyle;
+    /** Names from an explicitly declared water_name layer. */
+    bathymetryWaterNames?: TileflowBathymetryNameStyle;
+    bodies?: TileflowAreaStyle;
+    intermittent?: {
+        bodies?: TileflowAreaStyle;
+        waterways?: TileflowLineStyle;
+    };
+    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
+};
+type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
+    type: 'water';
+};
+
+/**
+ * Layer metadata naming the semantic module that owns a compiled layer, such as `roads` or `water`.
+ * Runtime features that address a module, such as map emphasis, read it instead of physical layer
+ * IDs. Layers that a theme blend splits or copies keep it.
+ */
+declare const tileflowLayerDomainMetadataKey: "tileflow:domain";
+
+type TileflowLayerDomain = TileflowSemanticModuleName | 'terrain';
+
+type TileflowSemanticModules = {
+    addresses?: TileflowAddressesModuleConfig;
+    aeroways?: TileflowAerowaysModuleConfig;
+    boundaries?: TileflowBoundariesModuleConfig;
+    buildings?: TileflowBuildingsModuleConfig;
+    labels?: TileflowLabelsModuleConfig;
+    land?: TileflowLandModuleConfig;
+    landforms?: TileflowLandformsModuleConfig;
+    nautical?: TileflowNauticalModuleConfig;
+    poi?: TileflowPoiModuleConfig;
+    roads?: TileflowRoadsModuleConfig;
+    transit?: TileflowTransitModuleConfig;
+    vegetation?: TileflowVegetationModuleConfig;
+    water?: TileflowWaterModuleConfig;
+};
+type TileflowSemanticModuleName = keyof TileflowSemanticModules;
+
+type TileflowThemeColorScheme = 'dark' | 'light';
+
+declare const tileflowRouteMetadataKey = "tileflow:route";
+/** The resolved inks of a route, from its outer glow to its bright core. */
+type TileflowRouteInks = Readonly<{
+    /** The chosen route's line. */
+    line: string;
+    /** The edge on each side of the line, which sets it apart from the roads under it. */
+    casing: string;
+    /** A thin line along the middle of the route. */
+    core: string;
+    /** A soft halo around the route. */
+    glow: string;
+    /** Other routes offered beside the chosen one. */
+    alternative: string;
+    /** Opacity of the glow, from 0 (no glow) to 1. */
+    glowOpacity: number;
+    /** Opacity of the core, from 0 (no core) to 1. */
+    coreOpacity: number;
+}>;
+/** The inks of a theme that sets no route tokens: a blue that reads on either kind of map. */
+declare const tileflowDefaultRouteInks: Readonly<Record<TileflowThemeColorScheme, TileflowRouteInks>>;
+/**
+ * Reads the route inks a compiled style publishes, or undefined when its metadata has none (a
+ * style compiled before route inks, or not by Tileflow).
+ */
+declare function readTileflowRouteInks(metadata: unknown): TileflowRouteInks | undefined;
+/**
+ * The route inks of a compiled style: those it publishes, or the defaults of its colour scheme
+ * (from its `tileflow:colorScheme` metadata, else `fallbackScheme`).
+ */
+declare function tileflowStyleRouteInks(style: {
+    metadata?: unknown;
+} | undefined, fallbackScheme?: TileflowThemeColorScheme): TileflowRouteInks;
+/**
+ * Inks between two themes' inks, `t` of the way from `from` to `to`: colours mix in OKLab, as theme
+ * blends mix paint colours, and opacities linearly.
+ */
+declare function mixTileflowRouteInks(from: TileflowRouteInks, to: TileflowRouteInks, t: number): TileflowRouteInks;
+
+type TileflowRuntimeColorScheme = 'dark' | 'light';
+
+type TileflowAnalytics = {
+    apiUrl?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    mapId?: string;
+    metadata?: Record<string, unknown>;
+    projectId?: string;
+    sdkVersion?: string;
+    source?: string;
+    styleId?: string;
+    surfaceId?: string;
+};
+type TileflowSessionController = {
+    readonly sessionId: string;
+    resolveRequestUrl(url: string, analytics: TileflowAnalytics | undefined): Promise<string | undefined>;
+};
+type TileflowRuntimeStyle = {
+    analytics?: TileflowAnalytics;
+    colorScheme?: TileflowRuntimeColorScheme;
+    /** An explicit empty array means the manifest declares that no web fonts are required. */
+    fontFaces?: TileflowStyleFontFace[];
+    revision?: string;
+    style: MapLibreStyle | string;
+    theme?: string;
+};
+type TileflowStyleFontFace = {
+    family: string;
+    source: string;
+    style?: 'italic' | 'normal' | 'oblique';
+    weight?: '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+};
+/**
+ * A continuous blend of named themes of one Tileflow map. `position` places the map between
+ * neighbouring themes: 0 is the first, 1 the second, and 1.25 a quarter of the way from the second
+ * to the third.
+ */
+type TileflowThemeBlendSelection = Readonly<{
+    /** From 0 to `themes.length - 1`. */
+    position: number;
+    /** Two to eight concrete theme names of the map, in blend order. */
+    themes: readonly string[];
+}>;
+
+/**
+ * Map emphasis lets an application's own content read first: chosen modules of the map recede
+ * towards the map's ground colour, and the map's labels and icons fade, except inside an area the
+ * application keeps at full strength. It only touches layers that a Tileflow map compiled, which
+ * name their module in their metadata; an application's own layers are never changed.
+ *
+ * This module plans which paint values an emphasis changes and computes each value for a strength
+ * from 0 (the map as designed) to 1 (the full emphasis). The browser controller writes them.
+ */
+/** A module of a compiled Tileflow map, such as `roads`, `transit`, `boundaries`, or `water`. */
+type TileflowEmphasisModule = TileflowLayerDomain;
+/** A GeoJSON polygon or multipolygon, in longitude and latitude. */
+type TileflowEmphasisArea = Readonly<{
+    coordinates: readonly (readonly (readonly number[])[])[];
+    type: 'Polygon';
+}> | Readonly<{
+    coordinates: readonly (readonly (readonly (readonly number[])[])[])[];
+    type: 'MultiPolygon';
+}>;
+/** How the map steps back so an application's content reads first. */
+type TileflowEmphasis = Readonly<{
+    /**
+     * Modules whose ground recedes towards the map's ground colour, and how far, from 0 (as
+     * designed) to 1 (the ground colour itself). Artwork that cannot be recoloured, such as
+     * patterns, fades by the same amount instead.
+     */
+    recede?: Readonly<Partial<Record<TileflowEmphasisModule, number>>>;
+    /** The share of their opacity the map's labels and icons keep, from 0 to 1. */
+    labels?: number;
+    /** An area in which the map's labels and icons keep their full strength. */
+    keep?: TileflowEmphasisArea;
+}>;
+/** Why an emphasis cannot be shown, or undefined when it can. */
+declare function validateTileflowEmphasis(value: unknown): TypeError | undefined;
+
+/**
+ * Browser helpers for theme transitions and blends. They use only methods that MapLibre GL JS maps
+ * provide and check each one at runtime, so a map without them falls back to an immediate change.
+ */
+type TileflowThemeMotionMap = {
+    areTilesLoaded?: unknown;
+    getCanvas?: unknown;
+    getImage?: unknown;
+    getLayer?: unknown;
+    getStyle?: unknown;
+    isStyleLoaded?: unknown;
+    off(event: string, listener: (event?: unknown) => void): unknown;
+    on(event: string, listener: (event?: unknown) => void): unknown;
+    project?: unknown;
+    redraw?: unknown;
+    setLayoutProperty?: unknown;
+    setLight?: unknown;
+    setPaintProperty?: unknown;
+    setSky?: unknown;
+    unproject?: unknown;
+    updateImage?: unknown;
+};
+
+declare const tileflowSkyLayerId = "tileflow-sky";
+/** The MapLibre GL JS map capabilities the sky layer uses; importing this module loads no renderer. */
+type TileflowSkyMap = {
+    addLayer(layer: object, beforeId?: string): unknown;
+    getBearing(): number;
+    getLayer(id: string): unknown;
+    getPitch(): number;
+    getSky?(): unknown;
+    getStyle(): unknown;
+    getTerrain?(): unknown;
+    getVerticalFieldOfView?(): number;
+    isStyleLoaded(): boolean | void;
+    off(event: string, listener: () => void): unknown;
+    on(event: string, listener: () => void): unknown;
+    removeLayer(id: string): unknown;
+};
+/**
+ * Light in the sky above the horizon, for maps that declare a sky: a glow on the horizon towards
+ * a low sun, the sun's disc as it sets or rises, and stars as the sky darkens. The sun is the one
+ * a theme controller shows, so a sun an application places by date brings its glow; without a
+ * controller, the theme's own sun. The layer sits under every other layer and draws only where
+ * nothing else has, so buildings and trees stand in front. Follows style replacements; the
+ * returned function removes the layer.
+ */
+declare function attachTileflowSky(map: TileflowSkyMap): () => void;
+
+declare const tileflowSkyHazeLayerId = "tileflow-sky-haze";
+/** The MapLibre GL JS map capabilities the haze reads; importing this module loads no renderer. */
+type TileflowSkyHazeView = {
+    getBearing?(): number;
+    getCanvas?(): {
+        clientHeight: number;
+    };
+    getCenter?(): {
+        lat: number;
+        lng: number;
+    };
+    getPitch(): number;
+    getSky?(): unknown;
+    getVerticalFieldOfView?(): number;
+    getZoom?(): number;
+};
+/** The map capabilities the haze layer uses. */
+type TileflowSkyHazeMap = TileflowSkyHazeView & {
+    addLayer(layer: object, beforeId?: string): unknown;
+    getLayer(id: string): unknown;
+    getLayersOrder?(): string[];
+    getStyle(): unknown;
+    getTerrain?(): unknown;
+    moveLayer?(id: string, beforeId?: string): unknown;
+    off(event: string, listener: () => void): unknown;
+    on(event: string, listener: () => void): unknown;
+    removeLayer(id: string): unknown;
+};
+/**
+ * The distance haze over the flat map, for maps with a sky: a band of the sky's horizon colour from
+ * where the haze starts up to the horizon, thickening with the flat ground's distance, so the
+ * ground meets the sky in the colour the sky starts with. It sits under the first 3D layer (or,
+ * without one, the first label layer); Tileflow's 3D buildings, trees and models haze themselves
+ * in their own shaders, and labels drawn above it stay clear. It shows only above 45° of pitch,
+ * costs one quad, and follows style replacements; the returned function removes it.
+ */
+declare function attachTileflowSkyHaze(map: TileflowSkyHazeMap): () => void;
+
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowAtmosphereMap = {
+    getBearing(): number;
+    getCanvas(): HTMLCanvasElement;
+    getCenter(): {
+        lat: number;
+        lng: number;
+    };
+    getContainer(): HTMLElement;
+    getPitch(): number;
+    getZoom(): number;
+    getStyle(): {
+        metadata?: unknown;
+        projection?: {
+            type?: unknown;
+        };
+    } | undefined;
+    on(event: 'move' | 'resize' | 'style.load' | 'remove', listener: () => void): unknown;
+    off(event: 'move' | 'resize' | 'style.load' | 'remove', listener: () => void): unknown;
+} & Partial<TileflowSkyMap> & Partial<TileflowSkyHazeMap>;
+type TileflowAtmosphereRuntimeOptions = {
+    /** Camera-relative star speed multiplier. Negative values reverse direction. Default: 1. */
+    starParallaxScale?: number;
+};
+/**
+ * Render compiled globe atmosphere metadata, and the stars and distance haze of a sky. Call after
+ * constructing a browser map. Follows style replacements and releases its canvas, layer,
+ * listeners, and pending frame on disposal.
+ */
+declare function attachTileflowAtmosphere(map: TileflowAtmosphereMap, runtimeOptions?: TileflowAtmosphereRuntimeOptions): () => void;
+
+/**
+ * The steepest camera pitch Tileflow supports, in degrees from looking straight down. Every
+ * portable view admits pitch 0–85, and Tileflow's maps raise MapLibre's own default of 60 to this,
+ * so a street-level view looks along the street to the sky. A map's `mapOptions.maxPitch` lowers it.
+ */
+declare const tileflowMaxPitch = 85;
+
+declare const tileflowSkyMetadataKey = "tileflow:sky";
+/** One theme's sky colours, as a time of day lends them to a sky that follows the sun. */
+type TileflowSkyColours = Readonly<{
+    color: string;
+    horizonColor: string;
+    horizonBlend: number;
+    glowColor: string;
+}>;
+/** The skies of a theme's time-of-day family, from which a sky that follows the sun is mixed. */
+type TileflowSkyTimesOfDay = Readonly<Record<'day' | 'dawn' | 'dusk' | 'night', TileflowSkyColours>>;
+/**
+ * The versioned runtime payload: what the browser needs to draw the stars and the glow round the
+ * sun, and, for a theme in a time-of-day family, the family's skies, so that a sun an application
+ * places brings the sky of its hour.
+ */
+type TileflowSkyMetadata = Readonly<{
+    version: 1;
+    starIntensity: number;
+    glowColor: string;
+    timesOfDay?: TileflowSkyTimesOfDay;
+}>;
+/** Validate the runtime payload without loading authoring schemas. */
+declare function readTileflowSky(value: unknown): TileflowSkyMetadata | undefined;
+/**
+ * The sky of a sun at this height and direction, mixed from a time-of-day family's skies: the day
+ * sky above the golden hour, the dawn or dusk sky within two degrees of sunrise or sunset (dawn while the sun is in
+ * the eastern half of the sky), and the night sky once twilight ends. Every colour comes from the
+ * family's themes, so a monochrome or a client's own family keeps its palette.
+ */
+declare function tileflowSkyAtSun(times: TileflowSkyTimesOfDay, sun: Readonly<{
+    altitude: number;
+    azimuth: number;
+}>): TileflowSkyColours;
+
+/**
+ * The WebGL context a browser map asks for. Multisampling is on, so the thin edges of 3D models,
+ * buildings and trees resolve smoothly instead of breaking into stipple. Attributes the caller
+ * passes win, so `{antialias: false}` opts out.
+ */
+declare function tileflowCanvasContextAttributes<T extends object>(attributes?: T): T & {
+    antialias: boolean;
+};
+
+/**
+ * Boundaries families. Each one has its own license, attribution, TileJSON path and style source
+ * ID; families are never merged.
+ */
+declare const tileflowBoundaryFamilies: Readonly<{
+    boundaries: Readonly<{
+        attribution: "© OpenStreetMap contributors";
+        license: "ODbL-1.0";
+        path: "/tiles/boundaries/tiles.json";
+        sourceId: "tileflow-boundaries";
+    }>;
+}>;
+type TileflowBoundaryFamily = keyof typeof tileflowBoundaryFamilies;
+
+/** A value a choropleth can colour: a number for scales, a string for categories. */
+type TileflowBoundaryValue = number | string;
+/** One row of an application's data, keyed by a registry ID or an official code. */
+type TileflowBoundaryRow = Readonly<{
+    key: number | string;
+    /** `null` leaves the area without a value. */
+    value: TileflowBoundaryValue | null;
+}>;
+/** Keys present on every `boundary_area` polygon, usable without the lookup table. */
+type TileflowBoundaryFeatureKey = 'id' | 'iso_3166_1' | 'ref';
+/** Rows joined to areas by one polygon key. */
+type TileflowBoundaryValues = Readonly<{
+    joinBy: TileflowBoundaryFeatureKey;
+    rows: readonly TileflowBoundaryRow[];
+}>;
+
+type FeatureTarget$1 = {
+    id?: number | string;
+    source: string;
+    sourceLayer?: string;
+};
+/** The part of a MapLibre map the controller uses. */
+type TileflowFeatureStateMap = {
+    getSource(id: string): unknown;
+    getStyle?(): {
+        sources?: Record<string, unknown>;
+    } | undefined;
+    off(type: 'styledata', listener: () => void): unknown;
+    on(type: 'styledata', listener: () => void): unknown;
+    removeFeatureState(target: FeatureTarget$1, key?: string): void;
+    setFeatureState(target: FeatureTarget$1 & {
+        id: number | string;
+    }, state: Record<string, unknown>): void;
+};
+type CreateBoundaryFeatureStateOptions = Readonly<{
+    /** Defaults to `boundaries`. */
+    family?: TileflowBoundaryFamily;
+    /** Also set the values on `boundary_label` points, for labels styled by value. */
+    labels?: boolean;
+    /** Feature-state key; it must match the choropleth's `state`. Defaults to `value`. */
+    state?: string;
+}>;
+type TileflowBoundaryFeatureState = Readonly<{
+    /** Remove every value this controller set. */
+    clear: () => void;
+    /** Remove the values and stop following style reloads. */
+    dispose: () => void;
+    /**
+     * Replace the values. Rows must be keyed by the source's feature ID: `id` by default, or `ref`
+     * when the map declares `promoteId: 'ref'`. Rows with a `null` value are removed.
+     */
+    set: (values: TileflowBoundaryValues) => void;
+}>;
+/**
+ * Keep Boundaries feature-state in sync with application rows. Values survive a style reload: the
+ * controller sets them again once the source is back.
+ */
+declare function createBoundaryFeatureState(map: TileflowFeatureStateMap, options?: CreateBoundaryFeatureStateOptions): TileflowBoundaryFeatureState;
+
+type Layer = {
+    id: string;
+    type?: string;
+    renderingMode?: string;
+    metadata?: unknown;
+};
+/** Public renderer capabilities needed to place ground road names around the 3D scene. */
+type TileflowLabelPlacementMap = {
+    getLayer(id: string): unknown;
+    getLayersOrder?(): string[];
+    getPitch(): number;
+    getStyle(): {
+        layers: Layer[];
+        metadata?: unknown;
+    } | undefined;
+    moveLayer?(id: string, beforeId?: string): unknown;
+    on(event: string, listener: () => void): unknown;
+    off(event: string, listener: () => void): unknown;
+};
+/**
+ * Keep ground road names readable around solid buildings and vegetation. MapLibre owns
+ * distance selection, collisions and fading; this controller never changes feature filters.
+ * Explicit render-stack placement opts a road out of this automatic scene ordering.
+ */
+declare function attachTileflowLabelPlacement(map: TileflowLabelPlacementMap): () => void;
+
+/** The drawn stretch of a line and its highlights, as shares of the line's length from its start. */
+type TileflowLineProgressState = Readonly<{
+    /** Where the drawn stretch starts, from 0 (the default) to 1. */
+    start?: number;
+    /** Where the drawn stretch ends, from 0 to 1 (the default, the whole line). */
+    end?: number;
+    /** Where a light sits along the line, or undefined (the default) for none. */
+    light?: number;
+    /** The whole line's opacity, multiplied with each layer's own, from 0 to 1 (the default). */
+    opacity?: number;
+}>;
+type TileflowLineProgressGradientOptions = Readonly<{
+    /** The line's colour. */
+    color: string;
+    /** The colour at the head and in the light; defaults to `color`, which shows neither. */
+    highlight?: string;
+    /**
+     * Length of the head's highlight, as a share of the line. The head shows while the drawn stretch
+     * ends before the line does. Defaults to 0.04; 0 shows no head.
+     */
+    headLength?: number;
+    /** Length of the light, as a share of the line. Defaults to `headLength`. */
+    lightLength?: number;
+}>;
+/**
+ * The `line-gradient` of a line drawn from `state.start` to `state.end`. The source of the layer
+ * must be GeoJSON with `lineMetrics: true`.
+ */
+declare function tileflowLineProgressGradient(state: TileflowLineProgressState, options: TileflowLineProgressGradientOptions): unknown[];
+
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowLineProgressMap = {
+    getCanvas?: unknown;
+    getLayer(id: string): unknown;
+    setPaintProperty(layer: string, name: string, value: unknown): unknown;
+    on(event: 'styledata', listener: () => void): unknown;
+    off(event: 'styledata', listener: () => void): unknown;
+};
+/** One line layer of the group, over a GeoJSON source with `lineMetrics: true`. */
+type TileflowLineProgressLayer = Readonly<{
+    id: string;
+    /** The layer's colour along the drawn line. */
+    color: string;
+    /** The colour at the head and in the light; defaults to `color`. */
+    highlight?: string;
+    /** The layer's own opacity, from 0 to 1 (the default). */
+    opacity?: number;
+}>;
+type TileflowLineProgressOptions = Readonly<{
+    /** The layers drawn together, such as a route's glow, casing, line and core. */
+    layers: readonly TileflowLineProgressLayer[];
+    /** Length of the head's highlight, as a share of the line; defaults to 0.04. */
+    headLength?: number;
+    /** Length of the light, as a share of the line; defaults to `headLength`. */
+    lightLength?: number;
+    /** What the layers show at first; defaults to the whole line, without a light. */
+    initial?: TileflowLineProgressState;
+}>;
+type TileflowLineProgressAnimation = Readonly<{
+    /** The values to reach; values left out keep what they show. */
+    to: TileflowLineProgressState;
+    /** Milliseconds, from 0 to 60000. */
+    duration: number;
+    /** Maps elapsed time (0 to 1) to progress (0 to 1); defaults to an ease in and out. */
+    easing?: (t: number) => number;
+}>;
+/** What the layers show: `light` is absent when no light shows. */
+type TileflowLineProgressShown = Readonly<{
+    start: number;
+    end: number;
+    light?: number;
+    opacity: number;
+}>;
+type TileflowLineProgressController = {
+    /** What the layers show now, mid-animation included. */
+    get(): TileflowLineProgressShown;
+    /**
+     * Shows new values at once and stops a running animation. Values left out keep what they show;
+     * `light: undefined` takes the light off.
+     */
+    set(state: TileflowLineProgressState): void;
+    /**
+     * Moves to new values over a duration and resolves `true` when it gets there, or `false` when
+     * `set`, another animation, or `dispose` stops it first. A light that is not showing starts from
+     * the start of the drawn stretch. With reduced motion requested, it shows the values at once.
+     */
+    animate(animation: TileflowLineProgressAnimation): Promise<boolean>;
+    /** Changes the layers' colours or the highlight lengths, for example when the theme changes. */
+    configure(options: Partial<Omit<TileflowLineProgressOptions, 'initial'>>): void;
+    /** Stops writing to the map. The layers keep what they show. */
+    dispose(): void;
+};
+/**
+ * Draws a line on, a share of its length at a time, over a group of MapLibre line layers: their
+ * `line-gradient` shows the drawn stretch, a bright head where it is being drawn, and a light that
+ * can run along it. The controller owns each layer's `line-gradient` and `line-opacity`, writes
+ * only what changed, and paints a layer again when a style change re-creates it. Layers that are
+ * not on the map are skipped until they are.
+ */
+declare function createTileflowLineProgress(map: TileflowLineProgressMap, options: TileflowLineProgressOptions): TileflowLineProgressController;
+
+/** The renderer's tile units: MapLibre projects custom layers' tiles over 8192. */
+declare const tileflowBuildingExtent = 8192;
+/** Bytes per vertex; see `meshTileflowBuildings` for the layout. */
+declare const tileflowBuildingVertexBytes = 28;
+type TileflowBuildingMeshOptions = Readonly<{
+    /** The tile's width in metres, for the length of each wall. */
+    tileMetres: number;
+    /** Height used where a building has none, in metres; defaults to 5, World's own fallback. */
+    defaultHeight?: number;
+    /** Exterior corner radius in metres, up to 1; 0 leaves the footprint unchanged. */
+    edgeRadius?: number;
+    /** Maximum turn per rounded segment; defaults to 30 degrees for close views. */
+    cornerAngle?: number;
+    /**
+     * The tile's places (World's `poi` layer), for the night use of buildings when the tile's
+     * buildings do not carry World's `night_use`: a place inside a building, or on its facade, gives
+     * the building its use.
+     */
+    places?: TileflowTileLayer;
+    /**
+     * Footprints of the building models standing here, as rings of tile units (0 to 8192): a
+     * building whose centre falls inside one, or that reaches more than half a metre into one, is not
+     * raised, since the model stands in for it.
+     */
+    masks?: readonly (readonly number[])[];
+}>;
+type BuildingMeshGroup = {
+    /** Conservative tile-space x/y bounds and maximum height in metres. */
+    bounds: [number, number, number, number, number];
+    roofsFrom: number;
+    roofsCount: number;
+    wallsFrom: number;
+    wallsCount: number;
+};
+/** One tile's buildings, ready to upload. */
+type TileflowBuildingMesh = Readonly<{
+    groups?: readonly BuildingMeshGroup[];
+    vertices: Uint8Array;
+    indices: Uint32Array;
+    /** The first wall index: roofs come before it, walls from it. */
+    wallsFrom: number;
+    /** The tallest building, in metres. */
+    top: number;
+    /** Each vertex's building is an index into these feature properties. */
+    features: readonly Readonly<Record<string, string | number | boolean>>[];
+}>;
+/**
+ * Meshes the buildings of one decoded tile layer, or returns undefined when it has none. It reads
+ * World's `render_height`, `render_min_height`, `hide_3d`, `building_tone`, `class` and `night_use`.
+ * Vertex layout:
+ * 0 position in the tile, 0 to 8192 (uint16 ×2); 4 base and top in decimetres (uint16 ×2); 8 the
+ * wall's outward normal (int8 ×2, normalised); 10 raised to the top, part of a wall (uint8 ×2);
+ * 12 decimetres along the wall (uint16); 14 a per-building jitter and seed (uint8 ×2, normalised);
+ * 16 the building's centre in the tile (uint16 ×2); 20 tone plus four times its class group, and
+ * night use (uint8 ×2: none, dining, entertainment, nightlife); 22 the wall's
+ * tight corners, bit 0 at its start and bit 1 at its end, and bit 2 when it faces a courtyard, and
+ * its length in metres up to 255
+ * (uint8 ×2); 24 the building's feature index (uint16); 26 on a roof, the vertex's corner of its
+ * triangle (0 to 2), on a wall, 0 at its start and 1 at its end (uint8); 27 on a roof, the triangle's
+ * sides that are the roof's outline, bit n for the side facing corner n, on a wall, bit 0 when its
+ * start and bit 1 when its end lies on the tile's edge (uint8).
+ *
+ * A building's jitter is the same for every piece of it a tile edge cuts, so the renderer can vary
+ * buildings' brightness with it without a seam along the tile's edge.
+ */
+declare function meshTileflowBuildings(layer: TileflowTileLayer, options: TileflowBuildingMeshOptions): TileflowBuildingMesh | undefined;
+
+/** Begin/end height fractions, begin/end multipliers and the base-10 curve exponent. */
+type TileflowModelEmissionGradient = readonly [number, number, number, number, number];
+type TileflowModelRoleLighting = Readonly<{
+    emissiveStrength: number;
+    emissiveVariation?: number;
+    emissiveColor?: string;
+    emissiveHeight: TileflowModelEmissionGradient;
+    color?: string;
+    colorMix?: number;
+    metallic?: number;
+    roughness?: number;
+    colorVariation?: Readonly<{
+        hue: readonly [number, number];
+        saturation: readonly [number, number];
+        lightness: readonly [number, number];
+        /** Colour factors may be authored in linear light, as in glTF. Defaults to sRGB. */
+        space?: 'srgb' | 'linear';
+    }>;
+}>;
+type TileflowBuildingFloodLight = Readonly<{
+    intensity: number;
+    brightnessScale: number;
+    color: string;
+    groundRadius: readonly [number, number];
+    minGroundHeight: number;
+    minWallHeight: number;
+    wallHeightRatio: number;
+}>;
+
+/** The style metadata key under which a compiled map describes its 3D buildings. */
+declare const tileflowBuildingsMetadataKey = "tileflow:buildings";
+/** A compiled map's 3D buildings, resolved for one theme. */
+type TileflowBuildings3DDesign = Readonly<{
+    /** The vector source and its layers with the buildings and the places they hold. */
+    source: string;
+    layers: Readonly<{
+        building: string;
+        places?: string;
+    }>;
+    /**
+     * Each building's colour: a CSS colour, or a MapLibre expression over the building's
+     * properties that gives one, as the map colours its 3D buildings (or its roofs).
+     */
+    color: string | readonly unknown[];
+    /** How strongly roof outlines and outer corners catch the light, from 0 to 1. */
+    edges: number;
+    /** Exterior corner radius and roof lighting transition, in metres; 0 keeps sharp edges. */
+    edgeRadius?: number;
+    /** Scene sun lighting by default; `style` uses the native extrusion light. */
+    lighting: 'style' | 'sun';
+    /** Per-building brightness variation, from 0 to 1; 0 preserves the authored colour. */
+    colorVariation: number;
+    /** The authored extrusion's vertical wall gradient. */
+    verticalGradient: boolean;
+    /** Their own colour, drawn unlit; without it they take the building's colour, lightened. */
+    edgeColor?: string;
+    /** How bright the buildings light the street at night, from 0 to 2. */
+    nightLight: number;
+    /** Height-selected light on ordinary buildings and the ground, independent of shop windows. */
+    floodLight?: TileflowBuildingFloodLight;
+    /** Emission by architectural role, independent of model palette slots. */
+    modelLighting?: Readonly<Partial<Record<TileflowModelLightingRole, TileflowModelRoleLighting>>>;
+    /** Invented night windows, lit by rooms: decoration, not data. */
+    windows: boolean;
+    /** Optional decoration on ordinary walls and roofs, independent of model materials. */
+    surfaces?: TileflowBuildingSurfaceDesign;
+    /**
+     * The zoom bands, `[from, to]`, the buildings and the placed models and landmarks come in over:
+     * across its band each fades in and rises from the ground. The renderer's defaults stand for a
+     * band left out.
+     */
+    entrance?: Readonly<{
+        buildings?: readonly [number, number];
+        models?: readonly [number, number];
+    }>;
+    /** Shadows from the sun, and contact shadow at the foot of the walls. */
+    shadows: boolean;
+    occlusion: boolean;
+    /** Strength of prepared model ambient visibility; zero leaves the sky contribution unchanged. */
+    modelOcclusion?: number;
+    /** Building models the map places in its city, each replacing the buildings under it. */
+    models?: readonly TileflowBuildingModelPlacement[];
+    /** The colours of the models' parts; a part without one takes it from the building colour. */
+    modelColors?: Readonly<Partial<Record<TileflowModelPart, string>>>;
+    /**
+     * Tileflow's landmarks, drawn as models in place of the buildings under them: the TileJSON of
+     * their tileset. Without it, the map shows none.
+     */
+    landmarks?: Readonly<{
+        url: string;
+    }>;
+}>;
+/** A building model standing in the map's city. */
+type TileflowBuildingModelPlacement = Readonly<{
+    /** The model's id, its file's name in the map's `models` directories. */
+    model: string;
+    /** Where the prepared model file is served, absolute or relative to the page. */
+    url: string;
+    /** Longitude and latitude of the model's origin, where it stands on the ground. */
+    at: readonly [number, number];
+    /** Degrees clockwise from north that the model's own north is turned to. */
+    heading: number;
+}>;
+/**
+ * Reads the 3D buildings a compiled style describes, or undefined when its metadata has none or a
+ * version or shape this Core does not know.
+ */
+declare function readTileflowBuildings3D(metadata: unknown): TileflowBuildings3DDesign | undefined;
+/** The most models one map places. */
+declare const tileflowBuildingModelPlacementLimit = 256;
+/**
+ * The address a hosted build gives a placement of one of the map's own models: a placeholder that
+ * Tileflow replaces, when the map is deployed, with that model's address in the map's Team.
+ */
+declare function tileflowTeamModelUrl(model: string): string;
+/** The Team model a placement's address is the placeholder of, if it is one. */
+declare function readTileflowTeamModelName(url: string): string | undefined;
+
+/** Bytes per lamp; see `placeTileflowStreetLights` for the layout. */
+declare const tileflowStreetLightBytes = 12;
+/**
+ * Where light is estimated where the data maps no lamps: `lit` (the default) along the streets and
+ * pavements the data maps as lit; `streets` also along the streets the data says nothing about,
+ * wherever it maps few lamps, which invents light as night windows do; `none` nowhere, so only
+ * mapped lamps shine.
+ */
+type TileflowStreetLightEstimate = 'streets' | 'lit' | 'none';
+type TileflowStreetLightPlacementOptions = Readonly<{
+    /** The tile's width in metres. */
+    tileMetres: number;
+    /** Defaults to `lit`. */
+    estimate?: TileflowStreetLightEstimate;
+}>;
+/** A tile's layers the lamps come from, as World names them. */
+type TileflowStreetLightLayers = Readonly<{
+    /** Points with `subclass` `street_lamp` (World's `street_furniture`). */
+    streetFurniture?: TileflowTileLayer;
+    /** Streets by `class`, with `lit` where mapped (World's `transportation`). */
+    transportation?: TileflowTileLayer;
+    /** Pavements, as lines or areas, with `lit` where mapped (World's `sidewalk`). */
+    sidewalks?: TileflowTileLayer;
+}>;
+/** One tile's lamps, ready to upload. */
+type TileflowStreetLightPlacement = Readonly<{
+    lamps: Uint8Array;
+    /** Lamps from the data. */
+    mapped: number;
+    /** Points of soft light estimated along streets. */
+    estimated: number;
+}>;
+/**
+ * Places one tile's lamps and estimated light, or returns undefined when it has none. Each is a
+ * point of light, flagged as mapped or estimated. Layout: 0 position in the
+ * tile, 0 to 8192 (uint16 ×2); 4 height in decimetres (uint16); 6 the reach of its light on the
+ * ground in metres (uint8); 7 flags (uint8: bit 0 mapped, bit 1 its own colour); 8 its colour
+ * (uint8 ×3, sRGB); 11 a seed (uint8, normalised).
+ */
+declare function placeTileflowStreetLights(layers: TileflowStreetLightLayers, options: TileflowStreetLightPlacementOptions): TileflowStreetLightPlacement | undefined;
+/** The style metadata key under which a compiled map describes its street lights. */
+declare const tileflowStreetLightsMetadataKey = "tileflow:street-lights";
+/** A compiled map's street lights, as the roads module describes them, resolved for one theme. */
+type TileflowStreetLightsDesign = Readonly<{
+    /** The vector source and its layers with the lamps, the streets and the pavements. */
+    source: string;
+    layers: Readonly<{
+        streetFurniture: string;
+        transportation: string;
+        sidewalk?: string;
+    }>;
+    estimate: TileflowStreetLightEstimate;
+    /** The light of lamps whose data gives no colour, as a CSS colour. */
+    color: string;
+    /** How bright the lights shine, from 0 to 2. */
+    intensity: number;
+}>;
+/**
+ * Reads the street lights a compiled style describes, or undefined when its metadata has none or a
+ * version or shape this Core does not know.
+ */
+declare function readTileflowStreetLights(metadata: unknown): TileflowStreetLightsDesign | undefined;
+
+/** The capabilities `tileflowGroundBeforeId` reads; importing this module never loads a renderer. */
+type TileflowGroundOrderMap = {
+    getLayer(id: string): unknown;
+    getLayersOrder(): string[];
+    getStyle(): unknown;
+};
+/** Structural MapLibre capabilities of a map that holds a ground layer group. */
+type TileflowGroundLayersMap = TileflowGroundOrderMap & {
+    addLayer(layer: unknown, beforeId?: string): unknown;
+    getSource(id: string): unknown;
+    moveLayer(id: string, beforeId?: string): unknown;
+    removeLayer(id: string): unknown;
+    setPaintProperty(layer: string, name: string, value: unknown): unknown;
+    setLayoutProperty(layer: string, name: string, value: unknown): unknown;
+    getCanvas?(): unknown;
+    on(event: 'styledata', listener: () => void): unknown;
+    off(event: 'styledata', listener: () => void): unknown;
+};
+/**
+ * A layer of the group: a MapLibre style layer drawn in 2D, such as a line or a fill, or a custom
+ * layer whose `renderingMode` is `2d`.
+ */
+type TileflowGroundLayer = Readonly<Record<string, unknown> & {
+    id: string;
+    type: string;
+}> | Readonly<{
+    id: string;
+    type: 'custom';
+    renderingMode?: '2d' | '3d';
+}>;
+type TileflowGroundLayersOptions = Readonly<{
+    /** The layers, bottom to top, such as a route's glow, casing, line and core. */
+    layers: readonly TileflowGroundLayer[];
+    /**
+     * How much of each line layer shows where 3D content hides it, by layer id: from 0 (nothing, the
+     * default) to 1 (as much as where it shows). Only line layers whose `line-opacity` is a number
+     * can show through.
+     */
+    occludedOpacity?: Readonly<Record<string, number>>;
+}>;
+type TileflowGroundLayers = {
+    /** The group's layer ids, bottom to top. */
+    readonly ids: readonly string[];
+    /** The map's layer, so helpers that paint layers, such as line progress, can paint the group. */
+    getLayer(id: string): unknown;
+    /**
+     * Sets a paint property of one of the group's layers, and keeps it for when a style change brings
+     * the layer back. A layer that shows through 3D content passes it to its see-through copy too, at
+     * its `line-opacity` times its occluded opacity. Other layers' properties pass straight to the map.
+     */
+    setPaintProperty(layer: string, name: string, value: unknown): void;
+    /** Sets a layout property, such as `visibility`, the same way. */
+    setLayoutProperty(layer: string, name: string, value: unknown): void;
+    getCanvas(): unknown;
+    on(event: 'styledata', listener: () => void): void;
+    off(event: 'styledata', listener: () => void): void;
+    /** Takes the group's layers and their copies off the map and stops following style changes. */
+    dispose(): void;
+};
+/**
+ * The layer a layer lying on the ground goes before: the first 3D layer above the roads, or the
+ * start of the vegetation when the buildings are flat, so the layer covers the roads and the flat
+ * buildings, and every 3D layer hides it where it stands in front. A style without Tileflow's
+ * overlay placements uses its first 3D layer or its first symbol layer. Undefined means the top.
+ */
+declare function tileflowGroundBeforeId(map: TileflowGroundOrderMap): string | undefined;
+/**
+ * Keeps a group of application layers on the ground, under the map's 3D content, from bottom to
+ * top as given. Layers already on the map are moved into place; a layer whose source is not on the
+ * map yet is added when it is. The group follows the map: after a style change it brings back the
+ * layers the change dropped, and it moves its layers again when a 3D layer lands above them, so
+ * a layer added later in 3D hides them too. A line with an occluded opacity gets a see-through
+ * copy over the 3D content, painted through the group.
+ */
+declare function createTileflowGroundLayers(map: TileflowGroundLayersMap, options: TileflowGroundLayersOptions): TileflowGroundLayers;
+
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowDepthMarkerMap = {
+    addLayer(layer: unknown, beforeId?: string): unknown;
+    getLayer(id: string): unknown;
+    removeLayer(id: string): unknown;
+    getCanvas(): HTMLCanvasElement;
+    getPixelRatio?(): number;
+    triggerRepaint(): void;
+    on(event: 'styledata', listener: () => void): unknown;
+    off(event: 'styledata', listener: () => void): unknown;
+};
+type TileflowDepthMarker = Readonly<{
+    /** `[longitude, latitude]`. */
+    lngLat: readonly [number, number];
+    /** The marker's picture. Pass it again to `update` after drawing into it. */
+    image: TexImageSource;
+    /** Width and height: CSS pixels for a screen marker, metres for a ground marker. */
+    size: readonly [number, number];
+    /**
+     * `screen` (the default) faces the viewer at a fixed size in pixels, as a pin does; `ground`
+     * lies flat on the ground at a size in metres, as a ring or an arrow on the street does.
+     */
+    alignment?: 'screen' | 'ground';
+    /** The point of the image that sits on the position: `center` (the default) or `bottom`. */
+    anchor?: 'center' | 'bottom';
+    /** A screen marker's shift in CSS pixels, right and down. */
+    offset?: readonly [number, number];
+    /** Degrees clockwise: from the screen's up for a screen marker, from north for a ground one. */
+    rotation?: number;
+    /** Metres above the ground; defaults to 0. */
+    altitude?: number;
+    /** From 0 to 1 (the default). */
+    opacity?: number;
+    /** Whether nearer 3D content hides the marker; defaults to true. */
+    occlude?: boolean;
+}>;
+type TileflowDepthMarkerHandle = {
+    /** Changes the marker; an `image` passed again is uploaded again. */
+    update(change: Partial<TileflowDepthMarker>): void;
+    remove(): void;
+};
+type TileflowDepthMarkersOptions = Readonly<{
+    /** The custom layer's id; defaults to `tileflow-depth-markers`. */
+    id?: string;
+    /** The layer the markers are drawn under, or a function that finds it after a style change. */
+    beforeId?: string | (() => string | undefined);
+}>;
+type TileflowDepthMarkers = {
+    add(marker: TileflowDepthMarker): TileflowDepthMarkerHandle;
+    /** Removes the markers' layer and releases its GPU resources. */
+    dispose(): void;
+};
+/** Where a marker sits: its tile and its position there in tile units, and metres in tile units. */
+declare function tileflowDepthMarkerPlacement(lngLat: readonly [number, number]): {
+    tile: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    position: [number, number];
+    unitsPerMetre: number;
+};
+/**
+ * Draws markers in the map's 3D scene, hidden by nearer 3D buildings. Needs a MapLibre GL JS map
+ * on WebGL 2 (GL JS 5 or later). The layer puts itself back after a style change.
+ */
+declare function createTileflowDepthMarkers(map: TileflowDepthMarkerMap, options?: TileflowDepthMarkersOptions): TileflowDepthMarkers;
+
+/** A camera between keyframes: always the center form, with bearing and pitch resolved. */
+type TileflowShotCamera = {
+    type: 'center';
+    center: [number, number];
+    zoom: number;
+    bearing: number;
+    pitch: number;
+};
+type TileflowShotKeyframe = Readonly<{
+    /** Milliseconds from the start: the first keyframe is at 0, later ones rise strictly. */
+    at: number;
+    camera: Readonly<{
+        /** Shots committed on a map name the center camera form; the motion needs no other. */
+        type?: 'center';
+        center: readonly [number, number];
+        zoom: number;
+        bearing?: number;
+        pitch?: number;
+    }>;
+    blend?: Readonly<{
+        themes: readonly string[];
+        position: number;
+    }>;
+}>;
+type TileflowShotMotion = Readonly<{
+    keyframes: readonly TileflowShotKeyframe[];
+    /** `smooth` (the default) eases each segment in and out; `linear` does not. */
+    easing?: 'linear' | 'smooth';
+}>;
+/** The camera and blend position of a shot at a time. */
+type TileflowShotState = {
+    at: number;
+    camera: TileflowShotCamera;
+    /** Present when the shot blends themes. */
+    blendPosition?: number;
+};
+/**
+ * Where a shot is at `at` milliseconds, clamped to its first and last keyframes. Within each
+ * keyframe segment the center moves in Web Mercator coordinates along the shorter way around the
+ * world, zoom and pitch change linearly, bearing turns along the shorter arc, and the blend position
+ * changes linearly; `easing: 'smooth'` eases each segment in and out. A time on a keyframe shows
+ * that keyframe exactly.
+ */
+declare function tileflowShotStateAt(shot: TileflowShotMotion, at: number): TileflowShotState;
+
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowShotPlayerMap = {
+    getCanvas?: unknown;
+    jumpTo(camera: {
+        center: [number, number];
+        zoom: number;
+        bearing: number;
+        pitch: number;
+    }): unknown;
+};
+/** Something to do once the shot reaches a time, such as drawing a route or showing a title. */
+type TileflowShotCue = Readonly<{
+    at: number;
+    run: () => void;
+}>;
+type TileflowShotPlaybackOptions = Readonly<{
+    /**
+     * Receives the blend position at each frame of a shot that blends themes, to pass on to the
+     * theme controller: `(position) => controller.setBlend({themes, position})`.
+     */
+    blend?: (position: number) => void;
+    /** Run once each, in time order, as the shot reaches them. */
+    cues?: readonly TileflowShotCue[];
+    /** Receives the camera after each frame's move. */
+    onFrame?: (state: {
+        at: number;
+        camera: TileflowShotCamera;
+        blendPosition?: number;
+    }) => void;
+    /** Stops the shot where it is. */
+    signal?: AbortSignal;
+}>;
+type TileflowShotPlayback = {
+    /** True when the shot played to its last keyframe; false when it was stopped first. */
+    readonly finished: Promise<boolean>;
+    /** Milliseconds the shot has played. */
+    readonly at: number;
+    /** Stops the shot where it is. */
+    stop(): void;
+};
+/**
+ * Plays a timed shot live on a map: the camera follows the shot's keyframes frame by frame, the
+ * blend position goes to `blend`, and cues run as the shot reaches them. It moves as Capture renders
+ * the same shot to video, so the page and the film agree. With reduced motion requested, or without
+ * a browser window, it shows the last keyframe at once and runs every cue in order.
+ */
+declare function playTileflowShot(map: TileflowShotPlayerMap, shot: TileflowShotMotion, options?: TileflowShotPlaybackOptions): TileflowShotPlayback;
+
+type TileflowNoticeControlPosition = 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+/** A MapLibre control; its methods receive the map that owns it. */
+type TileflowNoticeControl = {
+    onAdd(map: unknown): HTMLElement;
+    onRemove(map: unknown): void;
+};
+type TileflowNoticeEvent = 'remove' | 'style.load' | 'styledata';
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowNoticesMap = {
+    addControl(control: TileflowNoticeControl, position?: TileflowNoticeControlPosition): unknown;
+    getContainer(): HTMLElement;
+    getStyle(): {
+        metadata?: unknown;
+    } | undefined;
+    off(event: TileflowNoticeEvent, listener: () => void): unknown;
+    on(event: TileflowNoticeEvent, listener: () => void): unknown;
+    removeControl(control: TileflowNoticeControl): unknown;
+};
+type TileflowNoticesOptions = {
+    /** Map corner for the notice. Defaults to the attribution corner, `bottom-right`. */
+    position?: TileflowNoticeControlPosition;
+};
+/**
+ * Render the notices a compiled style declares, such as "Not for navigation" for Nautical, as a
+ * compact always-visible map control. Call after constructing a browser map. Follows style
+ * replacements and removes its control, listeners, and pending read on disposal or map removal.
+ */
+declare function attachTileflowNotices(map: TileflowNoticesMap, options?: TileflowNoticesOptions): () => void;
+
+/** Style metadata key for notices that must stay visible whenever the map is displayed. */
+declare const tileflowNoticesMetadataKey: "tileflow:notices";
+/**
+ * A short plain-text notice the compiled style declares for the sources it names. Runtimes render
+ * it on the map, next to the attribution; it never replaces a source's own attribution.
+ */
+type TileflowMapNotice = Readonly<{
+    id: string;
+    sources: readonly string[];
+    text: string;
+}>;
+declare const tileflowNoticeLimits: Readonly<{
+    maxNotices: 8;
+    maxSources: 16;
+    maxTextLength: 120;
+}>;
+/** Read bounded notices from style metadata; malformed entries are ignored, never rendered. */
+declare function readTileflowNotices(metadata: unknown): readonly TileflowMapNotice[];
+
+type FeatureId = number | string;
+type FeatureTarget = {
+    id: FeatureId;
+    source: string;
+    sourceLayer: string;
+};
+type TileflowNauticalLightsEvent = 'idle' | 'moveend' | 'remove' | 'sourcedata' | 'style.load' | 'styledata';
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowNauticalLightsMap = {
+    getContainer(): HTMLElement;
+    getLayer(id: string): {
+        maxzoom?: number;
+        minzoom?: number;
+    } | undefined;
+    getLayoutProperty(id: string, name: 'visibility'): unknown;
+    getSource(id: string): unknown;
+    getStyle(): {
+        metadata?: unknown;
+    } | undefined;
+    getZoom(): number;
+    off(event: TileflowNauticalLightsEvent, listener: (event?: {
+        sourceId?: unknown;
+    }) => void): unknown;
+    on(event: TileflowNauticalLightsEvent, listener: (event?: {
+        sourceId?: unknown;
+    }) => void): unknown;
+    queryRenderedFeatures(options: {
+        layers: string[];
+    }): readonly {
+        id?: unknown;
+        properties?: Record<string, unknown> | null;
+    }[];
+    removeFeatureState(target: FeatureTarget, key?: string): unknown;
+    setFeatureState(target: FeatureTarget, state: Record<string, number>): unknown;
+};
+/**
+ * Flash the Nautical lights of a compiled style in their rhythms. The style's
+ * `tileflow:nautical-lights` metadata names the light layers; for each light drawn in them, the
+ * helper derives its rhythm (`tileflowLightRhythm`) and writes the light's intensity and colour as
+ * MapLibre feature state whenever its phase changes. Lights that are in the same phase change
+ * together, and the helper wakes only for the next change.
+ *
+ * Nothing is written, and no timer runs, while the page is hidden, while no light layer is
+ * visible at the current zoom, or when no drawn light has a rhythm. When the person viewing the
+ * map prefers reduced motion, or on disposal or map `remove`, every light returns to steady.
+ * Lights are identified by the feature ID their source promotes; the compiled Nautical source
+ * promotes each light's unique `provenance`. A light without an ID stays steady.
+ */
+declare function attachTileflowNauticalLights(map: TileflowNauticalLightsMap): () => void;
+
+/** Style metadata key that names the layers whose Nautical lights flash in their rhythm. */
+declare const tileflowNauticalLightsMetadataKey: "tileflow:nautical-lights";
+/**
+ * MapLibre feature-state keys the light layers read. A runtime writes them per light feature; a
+ * light without them shows steadily, exactly as a map that is not animated.
+ */
+declare const tileflowNauticalLightStates: Readonly<{
+    /** Index of the colour shown, into the light's comma-separated `color` list. */
+    colour: "tileflowLightColour";
+    /** `1` while the light shines, `0` while it is eclipsed, in between for a fixed part. */
+    intensity: "tileflowLightIntensity";
+}>;
+/** The light layers of a compiled style and the source features they draw. */
+type TileflowNauticalLights = Readonly<{
+    layers: readonly string[];
+    source: string;
+    sourceLayer: string;
+    version: 1;
+}>;
+/** Read the bounded light declaration of style metadata; a malformed one is ignored. */
+declare function readTileflowNauticalLights(metadata: unknown): TileflowNauticalLights | undefined;
+
+/** One phase of a light's cycle. */
+type TileflowLightPhase = Readonly<{
+    /** Index of the colour shown, into the light's comma-separated `color` list. */
+    colour: number;
+    /** Seconds, with millisecond precision. */
+    duration: number;
+    /**
+     * `1` while the light shines, `0` while it is eclipsed, and
+     * `tileflowLightRhythmConventions.fixedIntensity` for the steady part of a fixed-and-flashing light.
+     */
+    intensity: number;
+}>;
+/** A light's repeating cycle. Lights with the same `key` flash identically. */
+type TileflowLightRhythm = Readonly<{
+    /** A canonical description of the phases; equal rhythms have equal keys. */
+    key: string;
+    /** Seconds, the sum of the phase durations. */
+    period: number;
+    phases: readonly TileflowLightPhase[];
+}>;
+/** What the light shows at a moment, and for how many more seconds. */
+type TileflowLightState = Readonly<{
+    colour: number;
+    intensity: number;
+    /** Seconds until the next phase begins; always positive. */
+    remaining: number;
+}>;
+/** The `nautical-v1` light fields that define a rhythm; other properties are ignored. */
+type TileflowLightCharacteristic = Readonly<{
+    character?: unknown;
+    color?: unknown;
+    group?: unknown;
+    period_s?: unknown;
+    sequence?: unknown;
+}>;
+/**
+ * The conventions used when a light publishes no `sequence`. Durations are in seconds.
+ *
+ * - `Fl`: flashes of `min(flash, flashShare × period / flashes)`. Flashes of one group are
+ *   separated by an eclipse of at most twice the flash, groups of a composite group such as
+ *   `2+1` by twice that eclipse, and the remainder of the period is the final eclipse.
+ * - `LFl`: the same layout with flashes of `longFlash`, or `flashShare × period / flashes` when
+ *   the period is too short for them.
+ * - `Q`, `VQ`, `UQ`: one flash per `quickCycle` (60, 120 and 240 per minute), lit for
+ *   `quickDuty` of each cycle. Without a group they flash continuously; with a group of `n` they
+ *   flash `n` times, then stay eclipsed until the period ends.
+ * - `IQ`, `IVQ`, `IUQ`: quick flashes for `interruptedShare` of the period, then an eclipse.
+ * - `Iso`: light and eclipse of equal length.
+ * - `Oc`: eclipses of `occultingShare × period / eclipses`, laid out like `Fl` with light and
+ *   eclipse exchanged, so the light is always longer than the eclipse.
+ * - `Mo`: the Morse letters of `group`, with dots of `morseUnit` (shortened to fit the
+ *   period), dashes of three units, one unit between signals and three between letters; the
+ *   remainder of the period, or seven units without one, is the eclipse.
+ * - `FFl`: a fixed light at `fixedIntensity` with full-intensity flashes laid out like `Fl`;
+ *   `F+LFl` does the same with long flashes.
+ * - `Q+LFl`, `VQ+LFl`, `UQ+LFl`, `Fl+LFl`: the group of the first part (six quick flashes when
+ *   absent), then one long flash, then the eclipse.
+ * - `Oc+Fl`: drawn as its occulting part.
+ * - `Al.<character>`: the rhythm of that character, each lit phase taking the next colour of
+ *   `color`; `Al` alone shows each colour for an equal share of the period.
+ * - Grouped `Q`/`VQ` and `Q+LFl`/`VQ+LFl` without a period use the cardinal-mark periods of
+ *   `cardinalPeriods`.
+ *
+ * `F`, an absent or unknown character, a missing period where one is needed, or a layout that
+ * does not fit its period leaves the light steady.
+ */
+declare const tileflowLightRhythmConventions: Readonly<{
+    cardinalPeriods: Readonly<{
+        Q: Readonly<{
+            3: 10;
+            6: 15;
+            9: 15;
+        }>;
+        'Q+LFl': 15;
+        VQ: Readonly<{
+            3: 5;
+            6: 10;
+            9: 10;
+        }>;
+        'VQ+LFl': 10;
+    }>;
+    fixedIntensity: 0.5;
+    flash: 1;
+    flashShare: 0.3;
+    interruptedShare: 0.6;
+    longFlash: 2;
+    morseUnit: 0.5;
+    occultingShare: 0.25;
+    quickCycle: Readonly<{
+        Q: 1;
+        UQ: 0.25;
+        VQ: 0.5;
+    }>;
+    quickDuty: 0.3;
+}>;
+/**
+ * The rhythm of one light, or `undefined` when it shows steadily: a fixed light, or one without a
+ * usable characteristic. `sequence` wins when it is well formed; otherwise the rhythm follows
+ * `tileflowLightRhythmConventions`.
+ */
+declare function tileflowLightRhythm(light: TileflowLightCharacteristic): TileflowLightRhythm | undefined;
+/** What `rhythm` shows `seconds` after the shared epoch of every rhythm. */
+declare function tileflowLightStateAt(rhythm: TileflowLightRhythm, seconds: number): TileflowLightState;
+
+declare const tileflowMaplibreContourVersion: "0.1.0";
+type TileflowContourProtocolRequest = Readonly<{
+    url: string;
+}>;
+type TileflowContourProtocolResponse = Readonly<{
+    cacheControl?: string | null;
+    data: ArrayBuffer;
+    expires?: Date | string | null;
+}>;
+type TileflowContourProtocolHandler = (request: TileflowContourProtocolRequest, abortController: AbortController) => Promise<TileflowContourProtocolResponse>;
+type TileflowContourProtocolRegistry = {
+    addProtocol: (name: string, handler: TileflowContourProtocolHandler) => void;
+};
+type TileflowContourProtocolRegistrationOptions = {
+    /** Test/integration override; the default lazily initializes the pinned, bundled module. */
+    loadMaplibreContour?: () => Promise<unknown>;
+};
+/** Registers the one self-contained protocol emitted by every compiled contour source. */
+declare function registerTileflowContourProtocol(registry: TileflowContourProtocolRegistry, options?: TileflowContourProtocolRegistrationOptions): void;
+
+type TileflowPmtilesProtocolHandler = (request: Readonly<{
+    type?: string;
+    url: string;
+}>, abortController: AbortController) => Promise<Readonly<{
+    cacheControl?: string;
+    data: object | string;
+    expires?: string;
+}>>;
+type TileflowPmtilesProtocolRegistry = Readonly<{
+    addProtocol: (name: string, handler: TileflowPmtilesProtocolHandler) => void;
+}>;
+type TileflowPmtilesProtocolRegistrationOptions = Readonly<{
+    maximumDirectoryDepth?: number;
+}>;
+declare const tileflowPmtilesMaximumDirectoryDepth: 32;
+declare const tileflowPmtilesProtocol: "tileflow-pmtiles";
+/** Register only Tileflow's managed PMTiles namespace. Third-party `pmtiles://` remains untouched. */
+declare function registerTileflowPmtilesProtocol(registry: TileflowPmtilesProtocolRegistry, options?: TileflowPmtilesProtocolRegistrationOptions): void;
+
+/** The style metadata through which a compiled map declares its 3D scene. */
+declare const tileflowMap3DMetadataKeys: readonly ["tileflow:buildings", "tileflow:vegetation", "tileflow:vegetation-display", "tileflow:street-lights"];
+/** Where the 3D scene reads the style: the map, and the theme controller when there is one. */
+type TileflowMap3DSource = Readonly<{
+    map: {
+        getStyle(): unknown;
+    };
+    controller?: {
+        getThemeMetadata?(key: string): Readonly<{
+            values: readonly unknown[];
+            position: number;
+        }>;
+    };
+}>;
+/**
+ * The parts of a 3D scene the style on screen declares, as their metadata keys; during a theme
+ * blend, those any blended theme declares.
+ */
+declare function tileflowMap3DDeclarations(source: TileflowMap3DSource): ReadonlySet<string>;
+/** Whether the style on screen declares any part of a 3D scene: buildings, trees or lights. */
+declare function tileflowMapDeclares3D(source: TileflowMap3DSource): boolean;
+/** Loads the 3D renderers: a dynamic import of the `@tileflow/core/3d` entry. */
+type TileflowMap3DLoader = () => Promise<{
+    createTileflowMap3D(options: TileflowMap3DOptions): TileflowMap3D;
+}>;
+type AttachTileflowMap3DOptions = TileflowMap3DOptions & {
+    map: TileflowMap3DOptions['map'] & {
+        getStyle(): unknown;
+    };
+    /** Loads the renderers the first time the map's style declares 3D. */
+    load: TileflowMap3DLoader;
+    /** Receives a failure to load or mount the renderers; the 2D map keeps working. */
+    onError?: (error: unknown) => void;
+};
+type TileflowMap3DAttachment = {
+    /** The mounted scene, once a style that declares 3D has loaded the renderers. */
+    readonly scene: TileflowMap3D | undefined;
+    /** `3d` shows the scene; `2d` hides it and draws `auto` vegetation flat. */
+    setViewMode(mode: TileflowViewMode): void;
+    /** Overrides the map's vegetation visibility; undefined restores the authored default. */
+    setVegetation(visible: boolean | undefined): void;
+    dispose(): void;
+};
+/**
+ * Mounts the map's 3D scene when, and only when, its style declares one. Until then it loads
+ * nothing, so a 2D map does not pay for the 3D renderers. Requested state applies on mount.
+ */
+declare function attachTileflowMap3D(options: AttachTileflowMap3DOptions): TileflowMap3DAttachment;
+
+type TileflowMapReadinessState = 'error' | 'idle' | 'loading';
+/** Read the browser preference without persisting or mutating user state. */
+declare function getTileflowSystemColorScheme(): TileflowRuntimeColorScheme;
+/**
+ * Subscribe through one process-wide `matchMedia` listener, regardless of adapter or map count.
+ */
+declare function subscribeTileflowSystemColorScheme(listener: (scheme: TileflowRuntimeColorScheme) => void): () => void;
+type TileflowThemeTransitionPhase = 'applying' | 'error' | 'preloading' | 'ready';
+type TileflowThemeTransition = Readonly<{
+    currentTheme?: string;
+    error?: Error;
+    phase: TileflowThemeTransitionPhase;
+    targetTheme?: string;
+}>;
+type TileflowThemeTransitionResult = Readonly<{
+    error?: Error;
+    status: 'applied' | 'failed' | 'superseded';
+    theme?: string;
+}>;
+/**
+ * How a theme change appears. Compatible themes interpolate on the live map, including its sky
+ * and 3D lighting. Other styles use a stationary cover that clears when the camera moves.
+ * A browser preference for reduced motion changes at once.
+ */
+type TileflowThemeTransitionOptions = Readonly<{
+    /** Milliseconds from 0 (immediate) to 5000. Themes and blends default to 450; other changes to 0. */
+    duration?: number;
+}>;
+type TileflowThemeChangeOptions = Readonly<{
+    transition?: TileflowThemeTransitionOptions;
+}>;
+/**
+ * A continuous mix of two or more themes of the same map. `position` places the map between
+ * neighbouring themes: 0 is the first, 1 the second, and 1.25 a quarter of the way from the second
+ * to the third. Ground colours, patterns, the sky, and light follow the position; labels and icons
+ * cross-fade when the nearest theme changes.
+ */
+type TileflowThemeBlendRequest = Readonly<{
+    position: number;
+    /** Two to eight concrete themes of one map, in blend order. */
+    themes: readonly TileflowRuntimeStyle[];
+    /**
+     * Holds back what would make MapLibre lay tiles out again: the change of nearest theme, with
+     * the labels, icons, and values it switches, and mixed pattern artwork. Colours, numbers, the
+     * sky, and light keep following the position, so a camera move or a recording never waits on
+     * the blend. The next request without `hold` brings what was held back in at once.
+     */
+    hold?: boolean;
+}>;
+/**
+ * A blend of named themes as the React, Vue, and Svelte maps take it: `hold` holds back what
+ * would make MapLibre lay tiles out again, as `TileflowThemeBlendRequest.hold` does, and the next
+ * selection without it brings what waited in at once.
+ */
+type TileflowBrowserThemeBlendSelection = TileflowThemeBlendSelection & Readonly<{
+    hold?: boolean;
+}>;
+declare function validateTileflowBrowserThemeBlendSelection(value: unknown): value is TileflowBrowserThemeBlendSelection;
+type TileflowThemeBlendState = Readonly<{
+    /** Whether changes held back by `hold` are waiting for a request without it. */
+    held: boolean;
+    position: number;
+    /**
+     * Positions where the nearest theme changes over values that make MapLibre lay tiles out
+     * again, such as icon names, layout values, and values that read feature data or state. Plan
+     * a camera move or a recording around them, or pass `hold` across them.
+     */
+    relayoutAt: readonly number[];
+    themes: readonly string[];
+}>;
+type TileflowStyleSwitchMap = TileflowThemeMotionMap & TileflowDynamicImageMap & {
+    getCenter?: unknown;
+    getGlobalState?: unknown;
+    off(event: string, listener: (event?: unknown) => void): unknown;
+    on(event: string, listener: (event?: unknown) => void): unknown;
+    setGlobalStateProperty?: unknown;
+    setStyle: unknown;
+};
+/** A value an application sets for the whole style, which themes read with `expr.globalState`. */
+type TileflowStyleStateValue = boolean | number | string | null;
+/**
+ * Where an application places the sun. `azimuth` (degrees clockwise from north) and `altitude`
+ * (degrees above the horizon) place it directly; `date` places the real sun of that instant over
+ * `location` ([longitude, latitude]), the map's centre when it is left out.
+ */
+type TileflowSunRequest = Readonly<{
+    altitude: number;
+    azimuth: number;
+}> | Readonly<{
+    date: Date | number;
+    location?: readonly [number, number];
+}>;
+type TileflowThemeController = {
+    dispose(): void;
+    /** Own a fixed-size RGBA image with a stable name across themes, restored after style reloads. */
+    registerImage(name: string, image: TileflowDynamicImage): TileflowDynamicImageHandle;
+    /** The active blend, or undefined when the map shows one theme. */
+    getBlend(): TileflowThemeBlendState | undefined;
+    /** The theme the map shows; during a blend, the nearest theme. */
+    getCurrent(): TileflowRuntimeStyle;
+    /** The emphasis requested last, or undefined when the map is shown as designed. */
+    getEmphasis(): TileflowEmphasis | undefined;
+    /**
+     * The route inks of the theme on screen, for an application's own route layers. During a blend
+     * they are mixed between the neighbouring themes at the blend's position, as the map's colours
+     * are. Read them again after a theme change or a blend move.
+     */
+    getRouteInks(): TileflowRouteInks;
+    /** The value a style state was set to last, or undefined when it has not been set. */
+    getState(name: string): TileflowStyleStateValue | undefined;
+    /**
+     * What the compiled styles on screen hold under a metadata key, for an application's own layers
+     * drawn in the map's design (Core's 3D trees read their colours this way): one value outside a
+     * blend, and during a blend one per blended theme, in order, with the blend's position, so a layer
+     * can mix them as the map does. A style without the key gives undefined in its place.
+     */
+    getThemeMetadata(key: string): Readonly<{
+        values: readonly unknown[];
+        position: number;
+    }>;
+    /**
+     * The sun the map shows, for an application's own 3D layers: its direction, the light it and
+     * the sky give, and how dark its shadows fall. It is the theme's sun (`lighting.sun`), mixed
+     * between neighbouring themes during a blend, unless `setSun` placed it. Read it when drawing;
+     * the map redraws whenever it changes.
+     */
+    getSun(): TileflowSun;
+    /**
+     * Shows a blend of themes. The first request for a set of themes loads their styles and
+     * prepares one style that holds all of them; later requests for the same themes only move the
+     * position and take effect at once, so they can follow an animation or a slider.
+     */
+    setBlend(request: TileflowThemeBlendRequest, options?: TileflowThemeChangeOptions): Promise<TileflowThemeTransitionResult>;
+    /**
+     * Makes chosen modules of the map recede and its labels and icons fade, so an application's own
+     * content reads first; `undefined` returns the map to its design. The change eases over the
+     * transition, and the emphasis stays through later theme changes and blend positions. Values
+     * that MapLibre evaluates per feature change at once, under a cross-fade.
+     */
+    setEmphasis(emphasis: TileflowEmphasis | undefined, options?: TileflowThemeChangeOptions): Promise<TileflowThemeTransitionResult>;
+    /**
+     * Sets a style-wide state that the map's themes read with `expr.globalState(name)`. A number
+     * eases from the value it shows to the new one over the transition, so a colour or size that a
+     * theme interpolates on it moves smoothly; other values, and a number set for the first time,
+     * change at once. A value that also reads feature data or feature state is laid out again by
+     * MapLibre at each change, so it follows late and costs more. States stay through theme changes
+     * and blends. Needs a MapLibre map with global state (GL JS 5.6 or later).
+     */
+    setState(name: string, value: TileflowStyleStateValue, options?: TileflowThemeChangeOptions): Promise<TileflowThemeTransitionResult>;
+    /**
+     * Places the sun by direction or by the real sun of a date and place; `undefined` returns it to
+     * the themes' suns. The themes keep the sun's colours, strengths, and shadow strength, and the
+     * map's light turns to the new direction, anchored to the map. The sun turns the short way round
+     * over the transition; a request that follows an animation, such as a clock, passes none.
+     */
+    setSun(request: TileflowSunRequest | undefined, options?: TileflowThemeChangeOptions): Promise<TileflowThemeTransitionResult>;
+    setTheme(style: TileflowRuntimeStyle, options?: TileflowThemeChangeOptions): Promise<TileflowThemeTransitionResult>;
+};
+/**
+ * Transactionally changes a MapLibre style while preserving the map instance and camera.
+ * Independent font preloads start immediately; style application is serialized and last request wins.
+ */
+declare function createTileflowThemeController(options: {
+    initial: TileflowRuntimeStyle;
+    loadFonts?: (style: TileflowRuntimeStyle) => Promise<void>;
+    /** Loads a theme's style document for a blend; defaults to a same-origin-credentials fetch. */
+    loadStyle?: (url: string) => Promise<MapLibreStyle>;
+    map: TileflowStyleSwitchMap;
+    onTransition?: (transition: TileflowThemeTransition) => void;
+    timeoutMs?: number;
+    /** The default for every change; each change may pass its own. */
+    transition?: TileflowThemeTransitionOptions;
+}): TileflowThemeController;
+type TileflowMapLifecycleEvent = 'dataloading' | 'error' | 'idle' | 'load' | 'styledataloading';
+type TileflowFrameScheduler<TFrame> = {
+    cancelFrame: (frame: TFrame) => void;
+    requestFrame: (callback: () => void) => TFrame;
+};
+type TileflowMapLifecycleSubscriber<TMap> = (map: TMap, event: TileflowMapLifecycleEvent, listener: () => void) => () => void;
+type TileflowSessionSender = (analytics: TileflowAnalytics | undefined, input: {
+    mapId?: string;
+    sessionId: string;
+    source: string;
+    styleId?: string;
+}) => void;
+type TileflowSessionStarter = {
+    clear: () => void;
+    start: (analytics: TileflowAnalytics | undefined, styleId?: string) => boolean;
+};
+type TileflowMapLifecycleAttachment = {
+    dispose: () => void;
+    invalidate: (state?: TileflowMapReadinessState) => void;
+};
+type TileflowStyleFontLoadOptions = {
+    /** Already resolved manifest metadata. An explicit empty array avoids fetching the style. */
+    fontFaces?: readonly TileflowStyleFontFace[];
+    fetch?: typeof globalThis.fetch;
+};
+/** Loads content-addressed style font faces before MapLibre starts shaping labels. */
+declare function loadTileflowStyleFonts(style: MapLibreStyle | string, options?: TileflowStyleFontLoadOptions): Promise<void>;
+type TileflowTransformRequestParameters = {
+    url: string;
+};
+type TileflowComposedRequest<TRequest extends TileflowTransformRequestParameters> = Pick<TRequest, 'url'> & Partial<Omit<TRequest, 'url'>>;
+type TileflowTransformRequest<TRequest extends TileflowTransformRequestParameters, TResourceType> = (url: string, resourceType?: TResourceType) => Promise<TileflowComposedRequest<TRequest>> | TileflowComposedRequest<TRequest> | undefined;
+type TileflowUserTransformRequest<TRequest extends TileflowTransformRequestParameters, TResourceType> = (url: string, resourceType?: TResourceType) => Promise<TRequest> | TRequest | undefined;
+declare function createTileflowSessionStarter(options: {
+    getSessionId?: () => string;
+    sessionId: string;
+    source: string;
+    startSession?: TileflowSessionSender;
+}): TileflowSessionStarter;
+declare function attachTileflowMapLifecycle<TMap, TFrame>(options: {
+    getSession?: () => {
+        analytics: TileflowAnalytics | undefined;
+        styleId?: string;
+    };
+    map: TMap;
+    onLoad?: (map: TMap) => void;
+    scheduler: TileflowFrameScheduler<TFrame>;
+    sessionStarter?: TileflowSessionStarter;
+    setState: (state: TileflowMapReadinessState) => void;
+    subscribe: TileflowMapLifecycleSubscriber<TMap>;
+}): TileflowMapLifecycleAttachment;
+/**
+ * Compose the caller's request transform with Tileflow analytics, the Hosted session, and the
+ * World bridge. Analytics are read when each request starts, so an asynchronous user transform
+ * never attaches analytics that changed while it was pending.
+ */
+declare function createTileflowTransformRequest<TRequest extends TileflowTransformRequestParameters = TileflowTransformRequestParameters, TResourceType = unknown>(options: {
+    getAnalytics: () => TileflowAnalytics | undefined;
+    sessionController?: TileflowSessionController;
+    sessionId: string;
+    transformRequest?: TileflowUserTransformRequest<TRequest, TResourceType>;
+    worldRequestBridge?: TileflowWorldRequestBridge;
+}): TileflowTransformRequest<TRequest, TResourceType>;
+
+export { type AttachTileflowMap3DOptions, type CreateBoundaryFeatureStateOptions, type TileflowAtmosphereMap, type TileflowAtmosphereRuntimeOptions, type TileflowBoundaryFeatureState, type TileflowBrowserThemeBlendSelection, type TileflowBuildingMesh, type TileflowBuildingMeshOptions, type TileflowBuildingModelPlacement, type TileflowBuildings3DDesign, type TileflowComposedRequest, type TileflowContourProtocolHandler, type TileflowContourProtocolRegistrationOptions, type TileflowContourProtocolRegistry, type TileflowContourProtocolRequest, type TileflowContourProtocolResponse, type TileflowDepthMarker, type TileflowDepthMarkerHandle, type TileflowDepthMarkerMap, type TileflowDepthMarkers, type TileflowDepthMarkersOptions, type TileflowDynamicImage, type TileflowDynamicImageContext, type TileflowDynamicImageHandle, type TileflowEmphasis, type TileflowEmphasisArea, type TileflowEmphasisModule, type TileflowFairUseNotice, type TileflowFairUseNoticeController, type TileflowFairUseNoticeState, type TileflowFeatureStateMap, type TileflowFrameScheduler, type TileflowGroundLayer, type TileflowGroundLayers, type TileflowGroundLayersMap, type TileflowGroundLayersOptions, type TileflowGroundOrderMap, type TileflowLabelPlacementMap, type TileflowLightCharacteristic, type TileflowLightPhase, type TileflowLightRhythm, type TileflowLightState, type TileflowLineProgressAnimation, type TileflowLineProgressController, type TileflowLineProgressGradientOptions, type TileflowLineProgressLayer, type TileflowLineProgressMap, type TileflowLineProgressOptions, type TileflowLineProgressShown, type TileflowLineProgressState, TileflowMap3D, type TileflowMap3DAttachment, type TileflowMap3DLoader, TileflowMap3DOptions, type TileflowMap3DSource, type TileflowMapLifecycleAttachment, type TileflowMapLifecycleEvent, type TileflowMapLifecycleSubscriber, type TileflowMapNotice, type TileflowMapReadinessState, type TileflowNauticalLights, type TileflowNauticalLightsMap, type TileflowNoticeControl, type TileflowNoticeControlPosition, type TileflowNoticesMap, type TileflowNoticesOptions, type TileflowPmtilesProtocolHandler, type TileflowPmtilesProtocolRegistrationOptions, type TileflowPmtilesProtocolRegistry, type TileflowRouteInks, type TileflowSessionSender, type TileflowSessionStarter, type TileflowShotCamera, type TileflowShotCue, type TileflowShotKeyframe, type TileflowShotMotion, type TileflowShotPlayback, type TileflowShotPlaybackOptions, type TileflowShotPlayerMap, type TileflowShotState, type TileflowSkyColours, type TileflowSkyHazeMap, type TileflowSkyMap, type TileflowSkyMetadata, type TileflowSkyTimesOfDay, type TileflowStreetLightEstimate, type TileflowStreetLightLayers, type TileflowStreetLightPlacement, type TileflowStreetLightPlacementOptions, type TileflowStreetLightsDesign, type TileflowStyleFontLoadOptions, type TileflowStyleStateValue, type TileflowStyleSwitchMap, TileflowSun, type TileflowSunRequest, type TileflowThemeBlendRequest, type TileflowThemeBlendState, type TileflowThemeChangeOptions, type TileflowThemeController, type TileflowThemeTransition, type TileflowThemeTransitionOptions, type TileflowThemeTransitionPhase, type TileflowThemeTransitionResult, TileflowTileLayer, type TileflowTransformRequest, type TileflowTransformRequestParameters, type TileflowUserTransformRequest, TileflowViewMode, type TileflowWorldProtocolHandler, type TileflowWorldProtocolRequest, type TileflowWorldProtocolResponse, type TileflowWorldRequestBridge, attachTileflowAtmosphere, attachTileflowFairUseNotice, attachTileflowLabelPlacement, attachTileflowMap3D, attachTileflowMapLifecycle, attachTileflowNauticalLights, attachTileflowNotices, attachTileflowSky, attachTileflowSkyHaze, createBoundaryFeatureState, createTileflowDepthMarkers, createTileflowGroundLayers, createTileflowLineProgress, createTileflowSessionStarter, createTileflowThemeController, createTileflowTransformRequest, getTileflowSystemColorScheme, loadTileflowStyleFonts, meshTileflowBuildings, mixTileflowRouteInks, placeTileflowStreetLights, playTileflowShot, readTileflowBuildings3D, readTileflowNauticalLights, readTileflowNotices, readTileflowRouteInks, readTileflowSky, readTileflowStreetLights, readTileflowTeamModelName, registerTileflowContourProtocol, registerTileflowPmtilesProtocol, registerTileflowWorldRequestBridge, subscribeTileflowSystemColorScheme, tileflowBuildingExtent, tileflowBuildingModelPlacementLimit, tileflowBuildingVertexBytes, tileflowBuildingsMetadataKey, tileflowCanvasContextAttributes, tileflowDefaultRouteInks, tileflowDepthMarkerPlacement, tileflowFairUseNoticeMessage, tileflowGroundBeforeId, tileflowLayerDomainMetadataKey, tileflowLightRhythm, tileflowLightRhythmConventions, tileflowLightStateAt, tileflowLineProgressGradient, tileflowMap3DDeclarations, tileflowMap3DMetadataKeys, tileflowMapDeclares3D, tileflowMaplibreContourVersion, tileflowMaxPitch, tileflowNauticalLightStates, tileflowNauticalLightsMetadataKey, tileflowNoticeLimits, tileflowNoticesMetadataKey, tileflowPmtilesMaximumDirectoryDepth, tileflowPmtilesProtocol, tileflowRouteMetadataKey, tileflowShotStateAt, tileflowSkyAtSun, tileflowSkyHazeLayerId, tileflowSkyLayerId, tileflowSkyMetadataKey, tileflowStreetLightBytes, tileflowStreetLightsMetadataKey, tileflowStyleRouteInks, tileflowSunLightMatrix, tileflowTeamModelUrl, validateTileflowBrowserThemeBlendSelection, validateTileflowEmphasis };