@tileflow/core 0.1.0-alpha.37 → 0.1.0-alpha.39

package/dist/browser.d.ts

@@ -1,3 +1,264 @@
+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 TileflowBackgroundStyle, p as TileflowSymbolPlacement, q as TileflowVegetationModuleConfig, r as TileflowTileLayer, s as TileflowMap3DOptions, t as TileflowMap3D, u as TileflowViewMode, v as TileflowSun } from './3d-BkaJjwfk.js';
+export { w as TileflowBuildings3D, x as TileflowBuildings3DChange, y as TileflowBuildings3DMap, z as TileflowBuildings3DOptions, A as TileflowBuildings3DThemes, B as TileflowMap3DMap, C as TileflowStreetLights, D as TileflowStreetLightsMap, E as TileflowStreetLightsOptions, F as TileflowSunPreset, G as TileflowTile, H as TileflowTileAddress, I as TileflowTileAreaRequest, J as TileflowTileFeature, K as TileflowTileGeometryType, L as TileflowTileReader, M as TileflowTileReaderOptions, N as TileflowTileRequestTransform, O as TileflowTileSourceMap, P as TileflowTreeFields, Q as TileflowTreeForm, R as TileflowTreeFormMix, S as TileflowTreeFormRange, U as TileflowTreeLayers, V as TileflowTreePlacement, W as TileflowTreePlacementOptions, X as TileflowTreeRange, Y as TileflowTreeRegion, Z as TileflowTrees3D, _ as TileflowTrees3DChange, $ as TileflowTrees3DMap, a0 as TileflowTrees3DOptions, a1 as TileflowTrees3DThemes, a2 as TileflowVectorTileDecodeOptions, a3 as TileflowVegetation3D, a4 as TileflowVegetationController, a5 as TileflowVegetationDisplay, a6 as TileflowVegetationOptions, a7 as TileflowVegetationRepresentation, a8 as createTileflowBuildings3D, a9 as createTileflowMap3D, aa as createTileflowStreetLights, ab as createTileflowTileReader, ac as createTileflowTrees3D, ad as createTileflowVegetation, ae as decodeTileflowVectorTile, af as mixTileflowSunPresets, ag as placeTileflowTrees, ah as readTileflowMapTileSource, ai as readTileflowSunPreset, aj as readTileflowVegetation3D, ak as readTileflowVegetationDisplay, al as resolveTileflowSun, am as resolveTileflowVegetationRepresentation, an as tileflowBuildings3DLayerId, ao as tileflowDefaultSunPreset, ap as tileflowStreetLightsLayerId, aq as tileflowStyleSunPreset, ar as tileflowSunDirection, as as tileflowSunMetadataKey, at as tileflowSunPosition, au as tileflowTilePointToLngLat, av as tileflowTilesForBounds, aw as tileflowTreeBytes, ax as tileflowTreeFormOf, ay as tileflowTreeForms, az as tileflowTrees3DLayerId, aA as tileflowVegetationDisplayMetadataKey, aB as tileflowVegetationMetadataKey } from './3d-BkaJjwfk.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[];
+    /**
+     * Where street names draw. `foreground` (the default) keeps them above buildings and
+     * vegetation. `ground` places them below 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';
+    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;
+    /** One density for the whole module: World's ranks decide what each category shows. */
+    density?: TileflowPoiDensity;
+    icons?: boolean;
+    labels?: boolean;
+    minZoom?: number;
+    placement?: {
+        /**
+         * Places each pictogram with its name as one unit that needs room for both. Defaults to
+         * `false`.
+         */
+        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;
+        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;
@@ -41,7 +302,12 @@ type TileflowDynamicImageMap = {
     off(event: string, listener: () => void): unknown;
 };
 
-type TileflowFairUseNoticeState = 'GRACE' | 'MANAGED_REQUIRED';
+/**
+ * `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;
@@ -70,316 +336,12 @@ type TileflowFairUseNoticeController = Readonly<{
 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;
 
-declare const expressionBrand: unique symbol;
-declare const themeValueBrand: unique symbol;
-declare const zoomBrand: unique symbol;
-declare const tileflowThemeTokenCategories: readonly ["color", "font", "image", "number"];
-type TileflowThemeTokenCategory = (typeof tileflowThemeTokenCategories)[number];
-type TileflowThemeTokenPrimitive = {
-    color: string;
-    font: string;
-    image: string;
-    number: number;
-};
-/** A JSON-safe semantic reference. The category is carried at runtime as well as in its type. */
-type TileflowThemeTokenReference<TCategory extends TileflowThemeTokenCategory = TileflowThemeTokenCategory> = {
-    readonly category: TCategory;
-    readonly kind: 'theme-token';
-    readonly token: string;
-    readonly [themeValueBrand]: TileflowThemeTokenPrimitive[TCategory];
-};
-/** An explicit opt-out from theme substitution. A reason is mandatory for auditability. */
-type TileflowFixedValue<T> = {
-    readonly kind: 'theme-fixed';
-    readonly reason: string;
-    readonly value: T;
-    readonly [themeValueBrand]: T;
-};
-type TileflowThemeColorMix = {
-    readonly amount: TileflowThemeNumberValue;
-    readonly from: TileflowThemeColorValue;
-    readonly kind: 'theme-color';
-    readonly operation: 'mix';
-    readonly space: 'oklch';
-    readonly to: TileflowThemeColorValue;
-    readonly [themeValueBrand]: string;
-};
-type TileflowThemeColorAlpha = {
-    readonly color: TileflowThemeColorValue;
-    readonly kind: 'theme-color';
-    readonly opacity: TileflowThemeNumberValue;
-    readonly operation: 'alpha';
-    readonly [themeValueBrand]: string;
-};
-type TileflowThemeColorOperation = TileflowThemeColorAlpha | TileflowThemeColorMix;
-type TileflowThemeNumberValue = number | TileflowFixedValue<number> | TileflowThemeTokenReference<'number'>;
-type TileflowThemeColorValue = string | TileflowFixedValue<string> | TileflowThemeColorOperation | TileflowThemeTokenReference<'color'>;
-type TileflowThemeFontValue = string | TileflowFixedValue<string> | TileflowThemeTokenReference<'font'>;
-type TileflowThemeImageValue = string | TileflowFixedValue<string> | TileflowThemeTokenReference<'image'>;
-type TileflowExpression<T> = {
-    readonly kind: 'expression';
-    readonly value: readonly unknown[];
-    /** Opaque result type. Only Tileflow's closed `expr.*` builders expose this brand publicly. */
-    readonly [expressionBrand]: T;
-};
-type TileflowZoomValueCommon<T> = {
-    readonly kind: 'zoom';
-    readonly stops: readonly (readonly [number, T])[];
-    readonly [zoomBrand]?: T;
-};
-type TileflowZoomValue<T> = TileflowZoomValueCommon<T> & ({
-    readonly base: number;
-    readonly interpolation: 'exponential';
-} | {
-    readonly base?: never;
-    readonly interpolation: 'linear' | 'step';
-});
-
-/** A color literal, semantic color token, color operation, expression, or zoom ramp. */
-type TileflowColorStyleValue = TileflowExpression<string> | TileflowThemeColorValue | TileflowZoomValue<TileflowThemeColorValue>;
-/** An image name, semantic image token, expression, or zoom ramp. */
-type TileflowImageStyleValue = TileflowExpression<string> | TileflowThemeImageValue | TileflowZoomValue<TileflowThemeImageValue>;
-/** A number, semantic number token, expression, or zoom ramp. */
-type TileflowNumberStyleValue = TileflowExpression<number> | TileflowThemeNumberValue | TileflowZoomValue<TileflowThemeNumberValue>;
-/** A visual numeric array whose components may be themed, or whose full shape is fixed. */
-type TileflowThemeNumberArrayValue = readonly TileflowThemeNumberValue[] | TileflowFixedValue<readonly number[]>;
-/** A visual numeric array, expression, or zoom ramp with explicit theme intent. */
-type TileflowNumberArrayStyleValue = TileflowExpression<readonly number[]> | TileflowThemeNumberArrayValue | TileflowZoomValue<TileflowThemeNumberArrayValue>;
-/** A two-dimensional visual offset with category-safe numeric components. */
-type TileflowNumberOffsetStyleValue = readonly [TileflowThemeNumberValue, TileflowThemeNumberValue] | TileflowFixedValue<readonly number[]> | TileflowExpression<readonly number[]> | TileflowZoomValue<readonly [TileflowThemeNumberValue, TileflowThemeNumberValue] | TileflowFixedValue<readonly number[]>>;
-/** Top, right, bottom, and left visual insets with category-safe numeric components. */
-type TileflowNumberInsetsStyleValue = readonly [
-    TileflowThemeNumberValue,
-    TileflowThemeNumberValue,
-    TileflowThemeNumberValue,
-    TileflowThemeNumberValue
-] | TileflowFixedValue<readonly [number, number, number, number]> | TileflowExpression<readonly number[]> | TileflowZoomValue<readonly [
-    TileflowThemeNumberValue,
-    TileflowThemeNumberValue,
-    TileflowThemeNumberValue,
-    TileflowThemeNumberValue
-] | TileflowFixedValue<readonly [number, number, number, number]>>;
-/** A structural value that does not participate in semantic theme-token substitution. */
-type TileflowStructuralStyleValue<T> = T | TileflowExpression<T> | TileflowZoomValue<T>;
-/** Structural text, including expressions and zoom-dependent literal strings. */
-type TileflowStringStyleValue = TileflowStructuralStyleValue<string>;
-type TileflowLineCap = 'butt' | 'round' | 'square';
-type TileflowLineJoin = 'bevel' | 'miter' | 'round';
-type TileflowSymbolPlacement = 'line' | 'line-center' | 'point';
-type TileflowSymbolZOrder = 'auto' | 'source' | 'viewport-y';
-type TileflowPriorityOrder = 'higher-first' | 'lower-first';
-type TileflowTextAnchor = 'bottom' | 'bottom-left' | 'bottom-right' | 'center' | 'left' | 'right' | 'top' | 'top-left' | 'top-right';
-type TileflowTextJustify = 'auto' | 'center' | 'left' | 'right';
-type TileflowIconAnchor = TileflowTextAnchor;
-type TileflowAlignment = 'auto' | 'map' | 'viewport';
-type TileflowIconTextFit = 'both' | 'height' | 'none' | 'width';
-/**
- * How a symbol part treats collisions with symbols placed before it. `never` hides it, `always`
- * shows it, and `cooperative` shows it unless the earlier symbol was placed with `never`.
- */
-type TileflowSymbolOverlap = 'always' | 'cooperative' | 'never';
-/** Visibility and zoom bounds shared by every visual primitive. */
-type TileflowLayerRange = {
-    maxZoom?: number;
-    minZoom?: number;
-    visible?: boolean;
-};
-type TileflowBackgroundPaint = {
-    color?: TileflowColorStyleValue;
-    opacity?: TileflowNumberStyleValue;
-    pattern?: TileflowImageStyleValue;
-};
-type TileflowBackgroundStyle = TileflowLayerRange & TileflowBackgroundPaint;
-type TileflowFillPaint = {
-    antialias?: boolean;
-    color?: TileflowColorStyleValue;
-    opacity?: TileflowNumberStyleValue;
-    pattern?: TileflowImageStyleValue;
-    translate?: TileflowNumberOffsetStyleValue;
-    translateAnchor?: 'map' | 'viewport';
-};
-type TileflowFillStyle = TileflowLayerRange & TileflowFillPaint;
-type TileflowLinePaint = {
-    blur?: TileflowNumberStyleValue;
-    color?: TileflowColorStyleValue;
-    dash?: TileflowNumberArrayStyleValue;
-    gapWidth?: TileflowNumberStyleValue;
-    offset?: TileflowNumberStyleValue;
-    opacity?: TileflowNumberStyleValue;
-    pattern?: TileflowImageStyleValue;
-    translate?: TileflowNumberOffsetStyleValue;
-    translateAnchor?: 'map' | 'viewport';
-    width?: TileflowNumberStyleValue;
-};
-type TileflowLineLayout = {
-    cap?: TileflowStructuralStyleValue<TileflowLineCap>;
-    join?: TileflowStructuralStyleValue<TileflowLineJoin>;
-    miterLimit?: TileflowNumberStyleValue;
-    roundLimit?: TileflowNumberStyleValue;
-};
-type TileflowLineStyle = TileflowLayerRange & TileflowLinePaint & TileflowLineLayout;
-/** Repeated diagonal marks placed along a stroked geographic feature. */
-type TileflowLineHatchStyle = TileflowLayerRange & {
-    angle?: TileflowNumberStyleValue;
-    color?: TileflowColorStyleValue;
-    opacity?: TileflowNumberStyleValue;
-    /** Sprite pattern clipped to the line deck; when set, it replaces glyph hatching. */
-    pattern?: TileflowImageStyleValue;
-    /**
-     * Intrinsic pixel heights available as `${pattern}-${width}` sprites. Tileflow
-     * selects the closest height to the rendered line width so marks retain a
-     * nearly fixed screen-pixel thickness instead of stretching with the road.
-     * Requires `pattern` to be a literal sprite-name prefix.
-     */
-    patternWidths?: TileflowThemeNumberArrayValue;
-    size?: TileflowNumberStyleValue;
-    spacing?: TileflowNumberStyleValue;
-};
-type TileflowTextPaint = {
-    color?: TileflowColorStyleValue;
-    haloBlur?: TileflowNumberStyleValue;
-    haloColor?: TileflowColorStyleValue;
-    haloWidth?: TileflowNumberStyleValue;
-    opacity?: TileflowNumberStyleValue;
-};
-/**
- * One opaque strip behind each shaped line of a label. Tileflow lowers it to a derived glyph stack
- * whose cells MapLibre's text halo paints, so placement, wrapping and collision stay native.
- */
-type TileflowTextBackground = {
-    /** Strip colour. Cells overlap at their joins, so the colour must be opaque. */
-    color: TileflowColorStyleValue;
-    /** `lines` fits one strip to each shaped line. */
-    fit: 'lines';
-    /** Strip extension beyond the first and last glyph of each line, in ems. Defaults to 0.33. */
-    padding?: TileflowThemeNumberValue;
-};
-type TileflowTextLayout = {
-    allowOverlap?: boolean;
-    anchor?: TileflowTextAnchor;
-    /**
-     * Replaces the text halo with line-fitted strips. Requires a map `glyphs` provider that serves
-     * derived stacks, one font without fallbacks, and constant `letterSpacing` and `lineHeight`.
-     */
-    background?: TileflowTextBackground;
-    field?: TileflowStringStyleValue;
-    font?: TileflowThemeFontValue;
-    fallbacks?: readonly TileflowThemeFontValue[];
-    ignorePlacement?: boolean;
-    justify?: TileflowTextJustify;
-    keepUpright?: boolean;
-    letterSpacing?: TileflowNumberStyleValue;
-    lineHeight?: TileflowNumberStyleValue;
-    maxAngle?: TileflowNumberStyleValue;
-    maxWidth?: TileflowNumberStyleValue;
-    offset?: TileflowNumberOffsetStyleValue;
-    optional?: boolean;
-    /**
-     * Overlap mode. Takes precedence over `allowOverlap`, so the compiled layer carries only the mode.
-     * Native artifacts, whose renderer has no overlap modes, use `allowOverlap: false` for `never`
-     * and `true` otherwise.
-     */
-    overlap?: TileflowSymbolOverlap;
-    padding?: TileflowNumberStyleValue;
-    pitchAlignment?: TileflowAlignment;
-    radialOffset?: TileflowNumberStyleValue;
-    rotate?: TileflowNumberStyleValue;
-    rotationAlignment?: TileflowAlignment;
-    size?: TileflowNumberStyleValue;
-    transform?: 'lowercase' | 'none' | 'uppercase';
-    variableAnchors?: readonly TileflowTextAnchor[];
-};
-type TileflowTextStyle = TileflowLayerRange & TileflowTextPaint & TileflowTextLayout;
-type TileflowIconPaint = {
-    color?: TileflowColorStyleValue;
-    haloBlur?: TileflowNumberStyleValue;
-    haloColor?: TileflowColorStyleValue;
-    haloWidth?: TileflowNumberStyleValue;
-    opacity?: TileflowNumberStyleValue;
-};
-type TileflowIconLayout = {
-    allowOverlap?: boolean;
-    anchor?: TileflowIconAnchor;
-    image?: TileflowImageStyleValue;
-    ignorePlacement?: boolean;
-    keepUpright?: boolean;
-    offset?: TileflowNumberOffsetStyleValue;
-    optional?: boolean;
-    /**
-     * Overlap mode. Takes precedence over `allowOverlap`, so the compiled layer carries only the mode.
-     * Native artifacts, whose renderer has no overlap modes, use `allowOverlap: false` for `never`
-     * and `true` otherwise.
-     */
-    overlap?: TileflowSymbolOverlap;
-    padding?: TileflowNumberStyleValue;
-    pitchAlignment?: TileflowAlignment;
-    rotate?: TileflowNumberStyleValue;
-    rotationAlignment?: TileflowAlignment;
-    size?: TileflowNumberStyleValue;
-    textFit?: TileflowIconTextFit;
-    textFitPadding?: TileflowNumberInsetsStyleValue;
-};
-type TileflowIconStyle = TileflowLayerRange & TileflowIconPaint & TileflowIconLayout;
-type TileflowSymbolPlacementStyle = TileflowLayerRange & {
-    placement?: TileflowSymbolPlacement;
-    priority?: TileflowStructuralStyleValue<number>;
-    /** Collision order for the semantic priority value. Defaults to `higher-first`. */
-    priorityOrder?: TileflowPriorityOrder;
-    spacing?: TileflowNumberStyleValue;
-    zOrder?: TileflowSymbolZOrder;
-};
-type TileflowCirclePaint = {
-    blur?: TileflowNumberStyleValue;
-    color?: TileflowColorStyleValue;
-    opacity?: TileflowNumberStyleValue;
-    pitchAlignment?: 'map' | 'viewport';
-    pitchScale?: 'map' | 'viewport';
-    priority?: TileflowStructuralStyleValue<number>;
-    /** Drawing order for the semantic priority value. Defaults to `higher-first`. */
-    priorityOrder?: TileflowPriorityOrder;
-    radius?: TileflowNumberStyleValue;
-    strokeColor?: TileflowColorStyleValue;
-    strokeOpacity?: TileflowNumberStyleValue;
-    strokeWidth?: TileflowNumberStyleValue;
-    translate?: TileflowNumberOffsetStyleValue;
-    translateAnchor?: 'map' | 'viewport';
-};
-type TileflowCircleStyle = TileflowLayerRange & TileflowCirclePaint;
-type TileflowExtrusionPaint = {
-    base?: TileflowNumberStyleValue;
-    color?: TileflowColorStyleValue;
-    height?: TileflowNumberStyleValue;
-    opacity?: TileflowNumberStyleValue;
-    pattern?: TileflowImageStyleValue;
-    verticalGradient?: boolean;
-};
-type TileflowExtrusionStyle = TileflowLayerRange & TileflowExtrusionPaint;
-/** A polygon rendered as a fill and, when requested, a separate line layer. */
-type TileflowAreaStyle = {
-    fill?: TileflowFillStyle;
-    outline?: TileflowLineStyle;
-};
-/** The canonical ordered phases used for roads, aeroways, and other stroked paths. */
-type TileflowLineStackStyle = {
-    casing?: TileflowLineStyle;
-    fill?: TileflowLineStyle;
-    shadow?: TileflowLineStyle;
-};
-/** A symbol layer composed from one placement policy and optional text/icon parts. */
-type TileflowSymbolStyle = TileflowSymbolPlacementStyle & {
-    icon?: TileflowIconStyle;
-    text?: TileflowTextStyle;
-};
-/** A symbol style that may also materialize a separate circle marker layer. */
-type TileflowMarkerSymbolStyle = TileflowSymbolStyle & {
-    marker?: TileflowCircleStyle;
-};
-
 type TileflowAddressesModuleOptions = {
     /** Styling for OpenMapTiles point house-number labels. */
     labels?: TileflowSymbolStyle;
@@ -489,6 +451,16 @@ type TileflowBuildingsThreeDimensionalStyle = {
             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. */
@@ -565,597 +537,153 @@ type TileflowLandModuleOptions = {
      */
     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; point-feature labels remain on their feature style. */
-type TileflowNauticalAreaLabelStyles = {
-    /** Provider coverage cells; hidden unless a map makes this style visible. */
-    coverage?: TileflowSymbolStyle;
-    hazards?: TileflowSymbolStyle;
-    navigationAreas?: 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;
-    /** Fixed beacons and daymarks, coloured by their first colour. */
-    beacons?: TileflowMarkerSymbolStyle;
-    /** 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;
-    /** Harbour and marina points. */
-    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;
-    /** 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';
-};
-
-/** A prepared model, near and optionally far, as the style's tree description carries it. */
-type TileflowTreeModel = Readonly<{
-    near: string;
-    far?: string;
-}>;
-
-type TileflowTileGeometryType = 'Point' | 'LineString' | 'Polygon';
-type TileflowTileFeature = Readonly<{
-    /** The feature's id in the tile, when it has one. */
-    id?: number;
-    type: TileflowTileGeometryType;
-    properties: Readonly<Record<string, string | number | boolean>>;
-    /**
-     * One flat `[x0, y0, x1, y1, …]` array per point set, line or ring, in tile units from 0 to the
-     * layer's extent (coordinates in a tile's buffer fall outside that range). Polygon rings follow
-     * the MVT winding: an exterior ring is clockwise in tile units, a hole anticlockwise.
-     */
-    geometry: readonly (readonly number[])[];
-}>;
-type TileflowTileLayer = Readonly<{
-    /** Tile units across the tile, usually 4096. */
-    extent: number;
-    features: readonly TileflowTileFeature[];
-}>;
-type TileflowVectorTileDecodeOptions = Readonly<{
-    /** The layers to decode; others are skipped without decoding. Defaults to every layer. */
-    layers?: readonly string[];
-}>;
-/** Decodes a Mapbox Vector Tile's layers. Throws on bytes that are not a vector tile. */
-declare function decodeTileflowVectorTile(bytes: Uint8Array, options?: TileflowVectorTileDecodeOptions): Readonly<Record<string, TileflowTileLayer>>;
-
-/** The forms a 3D tree takes. */
-declare const tileflowTreeForms: readonly ["round", "open", "tall", "conifer", "columnar", "palm"];
-type TileflowTreeForm = (typeof tileflowTreeForms)[number];
-/** How a tree's surfaces take the light: facets, a smooth round shape, or bands as drawn. */
-declare const tileflowTreeFinishes: readonly ["faceted", "smooth", "toon"];
-type TileflowTreeFinish = (typeof tileflowTreeFinishes)[number];
-/** A form's own scales, on top of the map's, and the map's own models it draws. */
-type TileflowTreeFormStyle = Readonly<{
-    heightScale?: number;
-    crownScale?: number;
-    /** Ids of the map's own models, one to four; each tree draws one by its stable seed. */
-    models?: readonly string[];
-}>;
-/** Relative weights of the forms given to trees whose data gives none. */
-type TileflowTreeFormMix = Readonly<Partial<Record<TileflowTreeForm, number>>>;
-/** A region whose trees without a form in the data take their own mix. */
-type TileflowTreeRegion = Readonly<{
-    /** `[west, south, east, north]` in degrees. */
-    bounds: readonly [number, number, number, number];
-    unknownForms: TileflowTreeFormMix;
-}>;
-/** The fields of the tree and canopy layers, as World names them. */
-type TileflowTreeFields = Readonly<{
-    height: string;
-    diameterCrown: string;
-    circumference: string;
-    genus: string;
-    species: string;
-    leafType: string;
-    /** The tree's taxon at any rank, such as `Arecaceae` for palms or a genus or species. */
-    taxon: string;
-    canopyRank: string;
-    canopyClearance: string;
-    canopyCover: string;
-    /** A canopy point's measured canopy height, in metres. */
-    canopyHeight: string;
-    /** The kind of barrier in the hedge layer: hedges are `hedge`. */
-    subclass: string;
-    /** A hedge's kind: `hedge_bank` when it stands on an earth bank. */
-    hedge: string;
-}>;
-type TileflowTreePlacementOptions = Readonly<{
-    /** The tile's address, for regions and for a stable look per tree. */
-    tile: Readonly<{
-        x: number;
-        y: number;
-        z: number;
-    }>;
-    /** The tile's width in metres. */
-    tileMetres: number;
-    fields?: Partial<TileflowTreeFields>;
-    unknownForms?: TileflowTreeFormMix;
-    regions?: readonly TileflowTreeRegion[];
-    /** Metres between the trees of a row; defaults to 8. */
-    rowSpacing?: number;
-    /** How many models each form draws from, 1 to 4; each tree draws one by its seed. */
-    variants?: Readonly<Partial<Record<TileflowTreeForm, number>>>;
-}>;
-/** A tile's layers trees come from, as World names them. */
-type TileflowTreeLayers = Readonly<{
-    /**
-     * World's `tree`: trees mapped one by one as points, and rows of trees as lines, planted every
-     * `rowSpacing` metres.
-     */
-    trees?: TileflowTileLayer;
-    /** Decorative canopy points in parks and gardens (World's `canopy`). */
-    canopy?: TileflowTileLayer;
-    /**
-     * World's `traffic_control`: its hedges, lines and areas of `subclass=hedge`, stand as clipped
-     * pieces along each line and round each area. Other barriers are left out.
-     */
-    hedges?: TileflowTileLayer;
-}>;
-/** Where some trees are in a placement, and how many of them have each rank or a lower one. */
-type TileflowTreeRange = Readonly<{
-    start: number;
-    count: number;
-    /** `upTo[r]`: trees of the range with a rank of `r` or lower, from 0 to 15. */
-    upTo: readonly number[];
-}>;
-/** Where a form's trees are in a placement, and those of each of its models in turn. */
-type TileflowTreeFormRange = TileflowTreeRange & Readonly<{
-    /** One range per model the form draws from, in order; one when it draws Core's own tree. */
-    variants: readonly TileflowTreeRange[];
-}>;
-/** One tile's trees, ready to upload. */
-type TileflowTreePlacement = Readonly<{
-    /** `tileflowTreeBytes` bytes per tree, ordered by form, model, then rank; see the layout below. */
-    trees: Uint8Array;
-    forms: Readonly<Record<TileflowTreeForm, TileflowTreeFormRange>>;
-    /**
-     * `tileflowTreeBytes` bytes per piece of hedge, as a tree's: its middle, its height, its length
-     * as the crown, and its turn along the hedge.
-     */
-    hedges: Uint8Array;
-    /** The tallest tree or hedge, in metres. */
-    tallest: number;
-    /** Trees from the data's trees and rows, and trees from canopy points. */
-    mapped: number;
-    canopy: number;
-}>;
-/**
- * Bytes per tree: x and y in tile units of 8192 (uint16 each), height and crown diameter in
- * decimetres (uint16 each), then one byte each for its turn (of a full turn), its shade among the
- * theme's colours, its form, its rank (0–15, lower shows first), a seed, whether it stands for a
- * canopy point (1) or a mapped tree (0), the model of its form it draws, and a byte of padding.
- */
-declare const tileflowTreeBytes = 16;
-/**
- * The form a tree's data gives it, or undefined when its data says nothing about its form: a palm
- * by `leaf_type` or genus, a column, a conifer by `leaf_type` or genus, or one of the broadleaf
- * forms by genus. `broadleaf` means the data says broadleaved without a known genus.
- */
-declare function tileflowTreeFormOf(properties: Readonly<Record<string, unknown>>, fields?: Partial<TileflowTreeFields>): TileflowTreeForm | 'broadleaf' | undefined;
-/** Places a tile's trees. Points in the tile's buffer belong to the neighbouring tile. */
-declare function placeTileflowTrees(layers: TileflowTreeLayers, options: TileflowTreePlacementOptions): TileflowTreePlacement;
-/** The style metadata key under which a compiled map describes its 3D trees. */
-declare const tileflowVegetationMetadataKey = "tileflow:vegetation";
-/** How a compiled map's 3D trees look and where their data is, resolved for one theme. */
-type TileflowVegetation3D = Readonly<{
-    /** The vector source and its layers with the trees, the canopy points and the hedges. */
-    source: string;
-    layers: Readonly<{
-        tree: string;
-        canopy?: string;
-        hedge?: string;
-    }>;
-    fields: TileflowTreeFields;
-    /**
-     * Sunlit colours: bark, the leaves of each kind of tree from darkest to lightest, and those of
-     * hedges.
-     */
-    colors: Readonly<{
-        bark: string;
-        broadleaf: readonly string[];
-        conifer: readonly string[];
-        palm: readonly string[];
-        hedge: readonly string[];
-    }>;
-    heightScale: number;
-    crownScale: number;
-    /** Each form's own scales and models. */
-    forms: Readonly<Partial<Record<TileflowTreeForm, TileflowTreeFormStyle>>>;
-    /** The map's own models its forms draw, by id, prepared from its `models` directories. */
-    models: Readonly<Record<string, TileflowTreeModel>>;
-    finish: TileflowTreeFinish;
-    /** How strongly an outline rings each tree, from 0 (none) to 1, and its colour. */
-    edges: number;
-    edgeColor?: string;
-    unknownForms: TileflowTreeFormMix;
-    regions: readonly TileflowTreeRegion[];
-    /** The style's layers that draw the trees flat, which the 3D trees stand in for while shown. */
-    flatLayers: readonly string[];
-}>;
-/**
- * Reads the 3D trees a compiled style describes, or undefined when its metadata has none or holds
- * a version or shape this Core does not know.
- */
-declare function readTileflowVegetation3D(metadata: unknown): TileflowVegetation3D | undefined;
-
-type TileflowVegetationMode = '3d' | 'flat' | 'auto';
-type TileflowVegetationThreeDimensionalStyle = {
-    barkColor?: TileflowThemeColorValue;
-    /** Sunlit leaf colours of broadleaf trees, from darkest to lightest; up to four are used. */
-    broadleafColors?: readonly TileflowThemeColorValue[];
-    /** Sunlit needle colours of conifers and columns, from darkest to lightest. */
-    coniferColors?: readonly TileflowThemeColorValue[];
-    /** Sunlit frond colours of palms, from darkest to lightest; the broadleaf colours by default. */
-    palmColors?: readonly TileflowThemeColorValue[];
-    /**
-     * Whether the data's hedges stand as clipped green walls beside the trees, at their height or
-     * 1.3 m, a metre higher on an earth bank. Defaults to true where the data has hedges.
-     */
-    hedges?: boolean;
-    /** Sunlit colours of hedges, from darkest to lightest; the two darkest broadleaf colours by default. */
-    hedgeColors?: readonly TileflowThemeColorValue[];
-    crownScale?: TileflowThemeNumberValue;
-    heightScale?: TileflowThemeNumberValue;
-    /**
-     * How trees take the light: `faceted` (the default), low-poly facets softened towards a round
-     * crown; `smooth`, round crowns; or `toon`, three bands of light and a crisp shadow, as a drawn
-     * tree has them.
-     */
-    finish?: TileflowTreeFinish;
-    /** How strongly an outline rings each tree, from 0 (none, the default) to 1. */
-    edges?: TileflowThemeNumberValue;
-    /** The outline's colour; the crown's darkest colour, deepened, by default. */
-    edgeColor?: TileflowThemeColorValue;
-    /**
-     * Each form's own scales, on top of `heightScale` and `crownScale`, such as taller palms, and the
-     * map's own models it draws: ids of `.glb` files in the map's `models` directories, one to four,
-     * each tree drawing one. A model's materials named `bark`, `leaves`, `fronds` or `stem` take
-     * those parts' colours.
-     */
-    forms?: Partial<Record<TileflowTreeForm, {
-        heightScale?: TileflowThemeNumberValue;
-        crownScale?: TileflowThemeNumberValue;
-        models?: readonly string[];
-    }>>;
-    /**
-     * The forms of trees whose data gives none, as relative weights: `round`, `open` and `tall`
-     * (broadleaf), `conifer`, `columnar` and `palm`. Each tree draws one from a stable hash, so it
-     * keeps its form everywhere. Defaults to the three broadleaf forms, evenly. A tree the data calls
-     * broadleaved keeps to the broadleaf forms of the mix.
-     */
-    unknownForms?: TileflowTreeFormMix;
-    /**
-     * Regions whose trees without a form in the data take their own mix, such as palms along a
-     * subtropical coast. Bounds are `[west, south, east, north]` in degrees; the first region holding
-     * a tree applies. At most 16.
-     */
-    regions?: readonly TileflowTreeRegion[];
-};
-type TileflowVegetationModuleOptions = {
-    flat?: TileflowCircleStyle;
-    /** `3d` uses models at every pitch; `auto` follows the runtime's explicit 2D/3D view mode. */
-    mode?: TileflowVegetationMode;
-    /** Representation when a renderer cannot draw models. Defaults to `flat`. */
-    fallback?: 'flat' | 'none';
-    /** Initial visibility; a runtime control may override it. Defaults to true. */
-    visible?: boolean;
-    threeDimensional?: TileflowVegetationThreeDimensionalStyle;
-};
-type TileflowVegetationModuleConfig = TileflowVegetationModuleOptions & {
-    type: 'vegetation';
-};
-
-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';
-};
-
-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[];
-    /**
-     * Where street names draw. `foreground` (the default) keeps them above buildings and
-     * vegetation. `ground` places them below 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';
-    roads?: TileflowRoadLabelDetail;
-    shields?: TileflowRoadShieldDetail;
-    styles?: TileflowLabelStyles;
-    water?: TileflowLabelDetail;
+    landcover?: Partial<Record<TileflowLandcoverClass, TileflowAreaStyle>>;
+    landuse?: Partial<Record<TileflowLanduseClass, TileflowAreaStyle>>;
 };
-/** 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';
+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';
+};
+
 /**
- * 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.
+ * Labels anchored inside polygon features, and the clearance labels of bridges and overhead cables;
+ * other point-feature labels remain on their feature style.
  */
-type TileflowPoiPlacementOrder = 'categories' | 'importance';
+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;
+};
 /**
- * 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'`.
+ * 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 TileflowPoiCategoryStyle = Omit<TileflowMarkerSymbolStyle, 'priority'>;
-type TileflowPoiModuleConfig = {
-    type: 'poi';
-    categories?: readonly TileflowPoiCategory[];
-    color?: TileflowPoiColorMode;
-    /** One density for the whole module: World's ranks decide what each category shows. */
-    density?: TileflowPoiDensity;
-    icons?: boolean;
-    labels?: boolean;
-    minZoom?: number;
-    placement?: {
-        /**
-         * Places each pictogram with its name as one unit that needs room for both. Defaults to
-         * `false`.
-         */
-        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;
-        textPadding?: number;
-    };
-    styles?: Partial<Record<TileflowPoiCategory, TileflowPoiCategoryStyle>>;
+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 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 TileflowNauticalModuleConfig = TileflowNauticalModuleOptions & {
+    type: 'nautical';
 };
-type MapLibreStyle = {
-    sky?: Record<string, unknown>;
-    version: 8;
-    name: string;
-    glyphs?: string;
-    light?: TileflowLight;
-    projection?: {
-        type: TileflowProjection;
+
+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;
     };
-    sprite?: MapLibreSprite;
-    sources: Record<string, Record<string, unknown>>;
-    layers: Array<Record<string, unknown>>;
-    terrain?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
+    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
+};
+type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
+    type: 'water';
 };
 
 /**
@@ -1184,97 +712,6 @@ type TileflowSemanticModules = {
 };
 type TileflowSemanticModuleName = keyof TileflowSemanticModules;
 
-declare const tileflowSunMetadataKey = "tileflow:sun";
-/** A theme's sun and sky light with every value resolved; see `TileflowThemeSun`. */
-type TileflowSunPreset = Readonly<{
-    /** Degrees clockwise from north, from 0 to 360. */
-    azimuth: number;
-    /** Degrees above the horizon, from -90 to 90. */
-    altitude: number;
-    /** The direct light's colour. */
-    color: string;
-    /** The direct light's strength, from 0 to 1. */
-    intensity: number;
-    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
-    shadowIntensity: number;
-    /** The light from the sky, which reaches every surface and fills the shadows. */
-    ambient: Readonly<{
-        color: string;
-        intensity: number;
-    }>;
-}>;
-/** The sun as the map shows it, ready for an application's own layers. */
-type TileflowSun = Readonly<{
-    /** Degrees clockwise from north, from 0 to 360. */
-    azimuth: number;
-    /** Degrees above the horizon, from -90 to 90. */
-    altitude: number;
-    /** A unit vector towards the sun: x east, y north, z up. */
-    direction: readonly [number, number, number];
-    /** The direct light's colour, as a CSS colour. */
-    color: string;
-    /** The direct light's colour as sRGB channels from 0 to 1. */
-    rgb: readonly [number, number, number];
-    /**
-     * The direct light's strength, from 0 to 1. It fades to 0 as the sun sets: a sun below the
-     * horizon lights nothing and casts no shadow.
-     */
-    intensity: number;
-    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
-    shadowIntensity: number;
-    /** The light from the sky, which reaches every surface and fills the shadows. */
-    ambient: Readonly<{
-        color: string;
-        rgb: readonly [number, number, number];
-        intensity: number;
-    }>;
-    /**
-     * How bright flat, open ground is under this light, from 0 (dark) to 1: the sky's light plus the
-     * sun's at its height, each weighted by its colour's luminance. Use it to switch lamps or windows
-     * on as a scene darkens, whatever theme or sun lights it.
-     */
-    brightness: number;
-    /** Where the direction comes from: the themes, angles, or a date and place. */
-    source: 'theme' | 'direction' | 'date';
-}>;
-/** Unset sun values: high in the south-south-west, with soft white daylight and ambient fill. */
-declare const tileflowDefaultSunPreset: TileflowSunPreset;
-/**
- * Where the sun stands for an instant and a place ([longitude, latitude] in degrees): its azimuth
- * in degrees clockwise from north and its apparent altitude above the horizon, with atmospheric
- * refraction. It follows NOAA's solar equations, accurate to about a hundredth of a degree for
- * years 1800 to 2200.
- */
-declare function tileflowSunPosition(date: Date | number, location: readonly [number, number]): Readonly<{
-    azimuth: number;
-    altitude: number;
-}>;
-/** A unit vector towards a direction in the sky: x east, y north, z up. */
-declare function tileflowSunDirection(azimuth: number, altitude: number): readonly [number, number, number];
-/**
- * The sun as the map shows it: a preset's light from a direction. Direct light fades out over the
- * sun's last degrees above the horizon and is gone below it.
- */
-declare function resolveTileflowSun(preset: TileflowSunPreset, direction?: Readonly<{
-    azimuth: number;
-    altitude: number;
-}>, source?: TileflowSun['source']): TileflowSun;
-/**
- * A preset `t` of the way from `from` to `to`: the azimuth turns the short way round, colours mix
- * in OKLab, as theme blends mix paint colours, and numbers linearly.
- */
-declare function mixTileflowSunPresets(from: TileflowSunPreset, to: TileflowSunPreset, t: number): TileflowSunPreset;
-/** Reads the sun a compiled style publishes, or undefined when its metadata has none. */
-declare function readTileflowSunPreset(metadata: unknown): TileflowSunPreset | undefined;
-/**
- * The sun of a compiled style: the one it publishes, else one read from its light (a style whose
- * theme describes no sun lights its extrusions from `light.position`), else the default.
- */
-declare function tileflowStyleSunPreset(style: {
-    light?: unknown;
-    metadata?: unknown;
-} | undefined): TileflowSunPreset;
-
 type TileflowThemeColorScheme = 'dark' | 'light';
 
 declare const tileflowRouteMetadataKey = "tileflow:route";
@@ -1396,27 +833,91 @@ type TileflowEmphasis = Readonly<{
 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.
+ * 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.
  */
-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 function attachTileflowSkyHaze(map: TileflowSkyHazeMap): () => void;
 
 /** Structural MapLibre capabilities; importing this module never loads a renderer. */
 type TileflowAtmosphereMap = {
@@ -1437,13 +938,64 @@ type TileflowAtmosphereMap = {
     } | 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>;
 /**
- * Render compiled globe atmosphere metadata. Call after constructing a browser map.
- * Follows style replacements and releases its canvas, listeners, and pending frame on disposal.
+ * 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): () => 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.
@@ -1474,7 +1026,7 @@ type TileflowBoundaryValues = Readonly<{
     rows: readonly TileflowBoundaryRow[];
 }>;
 
-type FeatureTarget = {
+type FeatureTarget$1 = {
     id?: number | string;
     source: string;
     sourceLayer?: string;
@@ -1487,8 +1039,8 @@ type TileflowFeatureStateMap = {
     } | undefined;
     off(type: 'styledata', listener: () => void): unknown;
     on(type: 'styledata', listener: () => void): unknown;
-    removeFeatureState(target: FeatureTarget, key?: string): void;
-    setFeatureState(target: FeatureTarget & {
+    removeFeatureState(target: FeatureTarget$1, key?: string): void;
+    setFeatureState(target: FeatureTarget$1 & {
         id: number | string;
     }, state: Record<string, unknown>): void;
 };
@@ -1618,213 +1170,6 @@ type TileflowLineProgressController = {
  */
 declare function createTileflowLineProgress(map: TileflowLineProgressMap, options: TileflowLineProgressOptions): TileflowLineProgressController;
 
-/** Bounded, read-only mesh snapshot for developer tooling. Positions are x east, y north, z up. */
-type TileflowModelInspection = Readonly<{
-    id: string;
-    module: string;
-    format: string;
-    vertices: number;
-    triangles: number;
-    bytes: number;
-    lods: number;
-    instances?: number;
-    positions: number[];
-    indices: number[];
-    colors?: string[];
-}>;
-
-type TileflowTileAddress = Readonly<{
-    z: number;
-    x: number;
-    y: number;
-}>;
-/** A decoded tile: its address and the chosen layers it holds. */
-type TileflowTile = TileflowTileAddress & Readonly<{
-    layers: Readonly<Record<string, TileflowTileLayer>>;
-}>;
-/** Rewrites a tile request as a MapLibre map's `transformRequest` does. */
-type TileflowTileRequestTransform = (url: string, resourceType: 'Tile') => Promise<Readonly<{
-    url: string;
-    headers?: Readonly<Record<string, string>>;
-    credentials?: RequestCredentials;
-}> | undefined> | Readonly<{
-    url: string;
-    headers?: Readonly<Record<string, string>>;
-    credentials?: RequestCredentials;
-}> | undefined;
-type TileflowTileReaderOptions = Readonly<{
-    /** The tile address with `{z}`, `{x}` and `{y}`, such as a MapLibre vector source's `tiles[0]`. */
-    tiles: string;
-    /** The lowest zoom the source has tiles for; defaults to 0. */
-    minzoom?: number;
-    /** The highest zoom the source has tiles for; deeper reads use its tiles. Defaults to 14. */
-    maxzoom?: number;
-    /** The layers to decode; defaults to every layer. */
-    layers?: readonly string[];
-    /** Decoded tiles kept for later reads, from 0 to 4096; defaults to 128. */
-    cacheSize?: number;
-    /** Requests in flight at once, from 1 to 32; defaults to 6. */
-    concurrency?: number;
-    /** The map's request rules, applied to every tile request. */
-    transformRequest?: TileflowTileRequestTransform;
-    /**
-     * Defaults to the global `fetch`, and to Core's PMTiles protocol for a source served from a
-     * Tileflow PMTiles archive (`tileflow-pmtiles://`).
-     */
-    fetch?: (url: string, init: RequestInit) => Promise<Response>;
-}>;
-type TileflowTileAreaRequest = Readonly<{
-    /** `[west, south, east, north]` in degrees. */
-    bounds: readonly [number, number, number, number];
-    /** The zoom to read at, clamped to the source's zooms. */
-    zoom: number;
-    /** The most tiles the area may take; a larger area is refused. Defaults to 64. */
-    maxTiles?: number;
-    signal?: AbortSignal;
-}>;
-type TileflowTileReader = {
-    /** A tile's chosen layers, or undefined when the source has no tile there (404 or 204). */
-    readTile(address: TileflowTileAddress, options?: {
-        signal?: AbortSignal;
-    }): Promise<TileflowTile | undefined>;
-    /** The tiles covering an area at a zoom, without the absent ones, nearest the centre first. */
-    readArea(request: TileflowTileAreaRequest): Promise<TileflowTile[]>;
-    /** Forgets every cached tile. */
-    clear(): void;
-};
-/** The tiles at `zoom` covering `[west, south, east, north]`, nearest the centre first. */
-declare function tileflowTilesForBounds(bounds: readonly [number, number, number, number], zoom: number): TileflowTileAddress[];
-/** The longitude and latitude of a point in a tile, given in tile units of an `extent`. */
-declare function tileflowTilePointToLngLat(tile: TileflowTileAddress, x: number, y: number, extent?: number): [number, number];
-/**
- * Reads a vector source's tiles in an application: for example a MapLibre map's World source, with
- * `tiles`, `minzoom` and `maxzoom` taken from `map.getSource(id)`, and the map's `transformRequest`.
- */
-declare function createTileflowTileReader(options: TileflowTileReaderOptions): TileflowTileReader;
-/** Structural MapLibre capability; importing this module never loads a renderer. */
-type TileflowTileSourceMap = {
-    getSource(id: string): unknown;
-};
-/**
- * The tile address and zooms of a map's vector source once the map has loaded it, ready for
- * `createTileflowTileReader`; undefined while the source is not loaded or has no tile address.
- */
-declare function readTileflowMapTileSource(map: TileflowTileSourceMap, sourceId: string): {
-    tiles: string;
-    minzoom: number;
-    maxzoom: number;
-} | undefined;
-
-type ShadowPoint = readonly number[];
-type ShadowBox = Readonly<{
-    min: ShadowPoint;
-    max: ShadowPoint;
-}>;
-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;
-}>;
-/**
- * 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;
-};
-
-/** The MapLibre GL JS map capabilities the renderer uses. */
-type TileflowBuildings3DMap = {
-    addLayer(layer: object, beforeId?: string): unknown;
-    getCenter(): {
-        lat: number;
-        lng: number;
-    };
-    getBearing(): number;
-    getCanvas?(): {
-        clientHeight: number;
-    };
-    getVerticalFieldOfView?(): number;
-    getLight?(): unknown;
-    getLayer(id: string): unknown;
-    getPaintProperty(layer: string, name: string): unknown;
-    getPitch(): number;
-    getSource(id: string): unknown;
-    getStyle(): unknown;
-    getZoom(): number;
-    isStyleLoaded(): boolean | void;
-    off(event: string, listener: () => void): unknown;
-    on(event: string, listener: () => void): unknown;
-    removeLayer(id: string): unknown;
-    triggerRepaint(): unknown;
-};
-/** Where the renderer reads the sun and the map's design: a Tileflow theme controller. */
-type TileflowBuildings3DThemes = {
-    getSun?(): TileflowSun;
-    getThemeMetadata?(key: string): Readonly<{
-        values: readonly unknown[];
-        position: number;
-    }>;
-};
-type TileflowBuildings3DOptions = Readonly<{
-    map: TileflowBuildings3DMap;
-    /** The theme controller, for the sun and the buildings' design in every theme. */
-    controller?: TileflowBuildings3DThemes;
-    /** The zoom where buildings start fading in, reaching full opacity 0.25 zoom later. Defaults to 15. */
-    minzoom?: number;
-    /** The most tiles raised round the camera, from 1 to 64; defaults to 25. */
-    maxTiles?: number;
-    /** The layer to draw before; defaults to the style's `above-buildings` placement. */
-    beforeId?: string;
-    /** The map's request rules, for the tiles the renderer reads. */
-    transformRequest?: TileflowTileRequestTransform;
-}>;
-type TileflowBuildings3DChange = Readonly<{
-    transition?: Readonly<{
-        duration?: number;
-        mode?: 'grow' | 'fade';
-    }>;
-}>;
-type TileflowBuildings3D = {
-    /** Read-only, bounded snapshots of resident prepared model meshes. */
-    inspectModels(): TileflowModelInspection[];
-    /** Shows buildings immediately; pass a transition duration to animate their rise. */
-    show(options?: TileflowBuildings3DChange): Promise<void>;
-    /** Hides buildings immediately; pass a transition duration to animate their descent. */
-    hide(options?: TileflowBuildings3DChange): Promise<void>;
-    /** Sets the height scale, from 0 (flat) to 1; animation requires a transition duration. */
-    grow(scale: number, options?: TileflowBuildings3DChange): Promise<void>;
-    /** The height scale shown now. */
-    readonly scale: number;
-    /**
-     * Whether the map's style describes its 3D buildings (the buildings module's
-     * `threeDimensional`), tiles raised, buildings and vertices, and the placed models standing, for
-     * diagnostics.
-     */
-    readonly stats: Readonly<{
-        declared: boolean;
-        tiles: number;
-        buildings: number;
-        vertices: number;
-        models: number;
-    }>;
-    /** Takes the layer off the map and lets go of its buffers. */
-    dispose(): void;
-};
-declare const tileflowBuildings3DLayerId = "tileflow-buildings-3d";
-/**
- * Creates the renderer, showing buildings automatically above zoom 15 unless hidden. It reads the source's
- * z15 tiles round the camera, the zoom at which World's buildings carry their heights.
- */
-declare function createTileflowBuildings3D(options: TileflowBuildings3DOptions): TileflowBuildings3D;
-
 /** The renderer's tile units: MapLibre projects custom layers' tiles over 8192. */
 declare const tileflowBuildingExtent = 8192;
 /** Bytes per vertex; see `meshTileflowBuildings` for the layout. */
@@ -1892,76 +1237,6 @@ type TileflowBuildingMesh = Readonly<{
  */
 declare function meshTileflowBuildings(layer: TileflowTileLayer, options: TileflowBuildingMeshOptions): TileflowBuildingMesh | undefined;
 
-/** The MapLibre GL JS map capabilities the street lights use. */
-type TileflowStreetLightsMap = {
-    addLayer(layer: object, beforeId?: string): unknown;
-    getBearing(): number;
-    getCenter(): {
-        lat: number;
-        lng: number;
-    };
-    getLayer(id: string): unknown;
-    getPitch(): number;
-    getSource(id: string): unknown;
-    getStyle(): unknown;
-    getZoom(): number;
-    isStyleLoaded(): boolean | void;
-    off(event: string, listener: () => void): unknown;
-    on(event: string, listener: () => void): unknown;
-    removeLayer(id: string): unknown;
-    triggerRepaint(): unknown;
-};
-type TileflowStreetLightsOptions = Readonly<{
-    map: TileflowStreetLightsMap;
-    /**
-     * By default, only a map that enables roads.streetLights supplies lights. Set true to opt in
-     * with the fallback design when metadata is absent, or false to keep every theme's lights off.
-     */
-    enabled?: boolean;
-    /**
-     * The theme controller, whose sun switches the lights on and off and whose themes hold the map's
-     * street lights (the roads module's `streetLights`).
-     */
-    controller?: {
-        getSun?(): TileflowSun;
-        getThemeMetadata?(key: string): Readonly<{
-            values: readonly unknown[];
-            position: number;
-        }>;
-    };
-    /** The zoom from which the lights shine. Defaults to 14. */
-    minzoom?: number;
-    /** The most tiles lit round the camera, from 1 to 64; defaults to 25. */
-    maxTiles?: number;
-    /** The layer to draw before; defaults to the style's `above-buildings` placement. */
-    beforeId?: string;
-    /** The map's request rules, for the tiles the layer reads. */
-    transformRequest?: TileflowTileRequestTransform;
-}>;
-type TileflowStreetLights = {
-    /** How far the lights have switched on, from 0 by day to 1 at night. */
-    readonly on: number;
-    /**
-     * Whether the map's style describes its street lights, tiles lit, lamps, and how many of them the
-     * data maps or the layer estimates.
-     */
-    readonly stats: Readonly<{
-        declared: boolean;
-        tiles: number;
-        lamps: number;
-        mapped: number;
-        estimated: number;
-    }>;
-    /** Takes the layer off the map and lets go of its buffers. */
-    dispose(): void;
-};
-declare const tileflowStreetLightsLayerId = "tileflow-street-lights";
-/**
- * Creates the street lights and puts their layer on the map. They read the source's z15 tiles round
- * the camera once the controller's sun darkens the map, and shine from `minzoom`.
- */
-declare function createTileflowStreetLights(options: TileflowStreetLightsOptions): TileflowStreetLights;
-
 /** Begin/end height fractions, begin/end multipliers and the base-10 curve exponent. */
 type TileflowModelEmissionGradient = readonly [number, number, number, number, number];
 type TileflowModelRoleLighting = Readonly<{
@@ -2026,6 +1301,15 @@ type TileflowBuildings3DDesign = Readonly<{
     modelLighting?: Readonly<Partial<Record<TileflowModelLightingRole, TileflowModelRoleLighting>>>;
     /** Invented night windows, lit by rooms: decoration, not data. */
     windows: boolean;
+    /**
+     * 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;
@@ -2069,92 +1353,6 @@ 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;
 
-/** The MapLibre GL JS map capabilities the trees use. */
-type TileflowTrees3DMap = {
-    addLayer(layer: object, beforeId?: string): unknown;
-    getBearing(): number;
-    getCenter(): {
-        lat: number;
-        lng: number;
-    };
-    getLayer(id: string): unknown;
-    getLayoutProperty?(layer: string, name: string): unknown;
-    getPitch(): number;
-    getSource(id: string): unknown;
-    getStyle(): unknown;
-    getZoom(): number;
-    isStyleLoaded(): boolean | void;
-    off(event: string, listener: () => void): unknown;
-    on(event: string, listener: () => void): unknown;
-    removeLayer(id: string): unknown;
-    setLayoutProperty?(layer: string, name: string, value: unknown): unknown;
-    triggerRepaint(): unknown;
-};
-/** Where the trees read the sun and the map's design: a Tileflow theme controller. */
-type TileflowTrees3DThemes = {
-    getSun?(): TileflowSun;
-    getThemeMetadata?(key: string): Readonly<{
-        values: readonly unknown[];
-        position: number;
-    }>;
-};
-type TileflowTrees3DOptions = Readonly<{
-    map: TileflowTrees3DMap;
-    /** The theme controller, for the sun and the trees' colours in every theme. */
-    controller?: TileflowTrees3DThemes;
-    /** The vector source with the canopy points, when not the map's World source. */
-    canopySource?: string;
-    /** The zoom from which trees stand; they reach full opacity 0.25 zoom later. Defaults to 15. */
-    minzoom?: number;
-    /** The most tiles of trees round the camera, from 1 to 64; defaults to 25. */
-    maxTiles?: number;
-    /** The layer to draw before; defaults to the style's `above-buildings` placement. */
-    beforeId?: string;
-    /** The map's request rules, for the tiles the layer reads. */
-    transformRequest?: TileflowTileRequestTransform;
-    /** Let a vegetation controller own flat-layer visibility. Defaults to true. */
-    manageFlatLayers?: boolean;
-}>;
-type TileflowTrees3DChange = Readonly<{
-    transition?: Readonly<{
-        duration?: number;
-    }>;
-}>;
-type TileflowTrees3D = {
-    /** Read-only snapshots of the meshes used by the active vegetation palette. */
-    inspectModels(): TileflowModelInspection[];
-    /** Grows the trees out of the ground; resolves once they stand. */
-    show(options?: TileflowTrees3DChange): Promise<void>;
-    /** Sinks the trees back into the ground; resolves once they are gone. */
-    hide(options?: TileflowTrees3DChange): Promise<void>;
-    /** Eases the trees to `scale` of their size, from 0 (none) to 1. */
-    grow(scale: number, options?: TileflowTrees3DChange): Promise<void>;
-    /** The size scale shown now. */
-    readonly scale: number;
-    /**
-     * Whether the map's style describes 3D trees (`vegetation({mode: '3d'})`), tiles of trees,
-     * trees placed (mapped and from canopy points), pieces of hedge placed and trees drawn in the
-     * last frame.
-     */
-    readonly stats: Readonly<{
-        declared: boolean;
-        tiles: number;
-        trees: number;
-        mapped: number;
-        canopy: number;
-        hedges: number;
-        drawn: number;
-    }>;
-    /** Takes the layer off the map and lets go of its buffers. */
-    dispose(): void;
-};
-declare const tileflowTrees3DLayerId = "tileflow-trees-3d";
-/**
- * Creates the trees and puts their layer on the map, sunk in the ground until `show()`. They read
- * the source's z15 tiles round the camera, where World carries its trees and canopy points.
- */
-declare function createTileflowTrees3D(options: TileflowTrees3DOptions): TileflowTrees3D;
-
 /** Bytes per lamp; see `placeTileflowStreetLights` for the layout. */
 declare const tileflowStreetLightBytes = 12;
 /**
@@ -2503,6 +1701,182 @@ declare const tileflowNoticeLimits: Readonly<{
 /** 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;
@@ -2542,49 +1916,54 @@ 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;
 
-type TileflowViewMode = '2d' | '3d';
-type TileflowVegetationRepresentation = 'none' | 'flat' | '3d';
-declare const tileflowVegetationDisplayMetadataKey = "tileflow:vegetation-display";
-/** Display policy, separate from the models' design and the camera's pitch. */
-type TileflowVegetationDisplay = Readonly<{
-    version: 1;
-    mode: TileflowVegetationMode;
-    fallback: 'flat' | 'none';
-    visible: boolean;
-    /** Authored visibility before the compiler applies the static fallback. */
-    flatLayers: readonly Readonly<{
-        id: string;
-        visible: boolean;
-    }>[];
-}>;
-declare function readTileflowVegetationDisplay(metadata: unknown): TileflowVegetationDisplay | undefined;
-declare function resolveTileflowVegetationRepresentation(policy: TileflowVegetationDisplay | undefined, options: {
-    visible?: boolean | undefined;
-    viewMode?: TileflowViewMode;
-    supports3D: boolean;
-}): TileflowVegetationRepresentation;
-
-type TileflowVegetationOptions = Omit<TileflowTrees3DOptions, 'manageFlatLayers' | 'map'> & {
-    map: TileflowTrees3DOptions['map'] & {
-        getCanvas?(): HTMLCanvasElement;
+/** 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;
     };
-    /** Overrides the map's visibility. Undefined restores the authored default. */
-    visible?: boolean | undefined;
-    /** Explicit application view mode, independent of pitch and building visibility. Defaults to 2d. */
-    viewMode?: TileflowViewMode;
-};
-type TileflowVegetationController = {
-    inspectModels: TileflowTrees3D['inspectModels'];
-    setVisible(visible: boolean | undefined): void;
+    /** 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;
-    /** Reapplies the policy after application layer controls change. */
-    refresh(): void;
-    readonly representation: TileflowVegetationRepresentation;
-    readonly stats: TileflowTrees3D['stats'] | undefined;
+    /** Overrides the map's vegetation visibility; undefined restores the authored default. */
+    setVegetation(visible: boolean | undefined): void;
     dispose(): void;
 };
-/** Mount once per map. OFF hides every representation; mode selects how enabled trees are drawn. */
-declare function createTileflowVegetation(options: TileflowVegetationOptions): TileflowVegetationController;
+/**
+ * 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. */
@@ -2823,4 +2202,4 @@ declare function createTileflowTransformRequest<TRequest extends TileflowTransfo
     worldRequestBridge?: TileflowWorldRequestBridge;
 }): TileflowTransformRequest<TRequest, TResourceType>;
 
-export { type CreateBoundaryFeatureStateOptions, type TileflowAtmosphereMap, type TileflowBoundaryFeatureState, type TileflowBrowserThemeBlendSelection, type TileflowBuildingMesh, type TileflowBuildingMeshOptions, type TileflowBuildingModelPlacement, type TileflowBuildings3D, type TileflowBuildings3DChange, type TileflowBuildings3DDesign, type TileflowBuildings3DMap, type TileflowBuildings3DOptions, type TileflowBuildings3DThemes, 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 TileflowLineProgressAnimation, type TileflowLineProgressController, type TileflowLineProgressGradientOptions, type TileflowLineProgressLayer, type TileflowLineProgressMap, type TileflowLineProgressOptions, type TileflowLineProgressShown, type TileflowLineProgressState, type TileflowMapLifecycleAttachment, type TileflowMapLifecycleEvent, type TileflowMapLifecycleSubscriber, type TileflowMapNotice, type TileflowMapReadinessState, 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 TileflowStreetLightEstimate, type TileflowStreetLightLayers, type TileflowStreetLightPlacement, type TileflowStreetLightPlacementOptions, type TileflowStreetLights, type TileflowStreetLightsDesign, type TileflowStreetLightsMap, type TileflowStreetLightsOptions, type TileflowStyleFontLoadOptions, type TileflowStyleStateValue, type TileflowStyleSwitchMap, type TileflowSun, type TileflowSunPreset, type TileflowSunRequest, type TileflowThemeBlendRequest, type TileflowThemeBlendState, type TileflowThemeChangeOptions, type TileflowThemeController, type TileflowThemeTransition, type TileflowThemeTransitionOptions, type TileflowThemeTransitionPhase, type TileflowThemeTransitionResult, type TileflowTile, type TileflowTileAddress, type TileflowTileAreaRequest, type TileflowTileFeature, type TileflowTileGeometryType, type TileflowTileLayer, type TileflowTileReader, type TileflowTileReaderOptions, type TileflowTileRequestTransform, type TileflowTileSourceMap, type TileflowTransformRequest, type TileflowTransformRequestParameters, type TileflowTreeFields, type TileflowTreeForm, type TileflowTreeFormMix, type TileflowTreeFormRange, type TileflowTreeLayers, type TileflowTreePlacement, type TileflowTreePlacementOptions, type TileflowTreeRange, type TileflowTreeRegion, type TileflowTrees3D, type TileflowTrees3DChange, type TileflowTrees3DMap, type TileflowTrees3DOptions, type TileflowTrees3DThemes, type TileflowUserTransformRequest, type TileflowVectorTileDecodeOptions, type TileflowVegetation3D, type TileflowVegetationController, type TileflowVegetationDisplay, type TileflowVegetationOptions, type TileflowVegetationRepresentation, type TileflowViewMode, type TileflowWorldProtocolHandler, type TileflowWorldProtocolRequest, type TileflowWorldProtocolResponse, type TileflowWorldRequestBridge, attachTileflowAtmosphere, attachTileflowFairUseNotice, attachTileflowMapLifecycle, attachTileflowNotices, createBoundaryFeatureState, createTileflowBuildings3D, createTileflowDepthMarkers, createTileflowGroundLayers, createTileflowLineProgress, createTileflowSessionStarter, createTileflowStreetLights, createTileflowThemeController, createTileflowTileReader, createTileflowTransformRequest, createTileflowTrees3D, createTileflowVegetation, decodeTileflowVectorTile, getTileflowSystemColorScheme, loadTileflowStyleFonts, meshTileflowBuildings, mixTileflowRouteInks, mixTileflowSunPresets, placeTileflowStreetLights, placeTileflowTrees, playTileflowShot, readTileflowBuildings3D, readTileflowMapTileSource, readTileflowNotices, readTileflowRouteInks, readTileflowStreetLights, readTileflowSunPreset, readTileflowTeamModelName, readTileflowVegetation3D, readTileflowVegetationDisplay, registerTileflowContourProtocol, registerTileflowPmtilesProtocol, registerTileflowWorldRequestBridge, resolveTileflowSun, resolveTileflowVegetationRepresentation, subscribeTileflowSystemColorScheme, tileflowBuildingExtent, tileflowBuildingModelPlacementLimit, tileflowBuildingVertexBytes, tileflowBuildings3DLayerId, tileflowBuildingsMetadataKey, tileflowDefaultRouteInks, tileflowDefaultSunPreset, tileflowDepthMarkerPlacement, tileflowFairUseNoticeMessage, tileflowGroundBeforeId, tileflowLayerDomainMetadataKey, tileflowLineProgressGradient, tileflowMaplibreContourVersion, tileflowNoticeLimits, tileflowNoticesMetadataKey, tileflowPmtilesMaximumDirectoryDepth, tileflowPmtilesProtocol, tileflowRouteMetadataKey, tileflowShotStateAt, tileflowStreetLightBytes, tileflowStreetLightsLayerId, tileflowStreetLightsMetadataKey, tileflowStyleRouteInks, tileflowStyleSunPreset, tileflowSunDirection, tileflowSunLightMatrix, tileflowSunMetadataKey, tileflowSunPosition, tileflowTeamModelUrl, tileflowTilePointToLngLat, tileflowTilesForBounds, tileflowTreeBytes, tileflowTreeFormOf, tileflowTreeForms, tileflowTrees3DLayerId, tileflowVegetationDisplayMetadataKey, tileflowVegetationMetadataKey, validateTileflowBrowserThemeBlendSelection, validateTileflowEmphasis };
+export { type AttachTileflowMap3DOptions, type CreateBoundaryFeatureStateOptions, type TileflowAtmosphereMap, 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 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, 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 };