@tileflow/core 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/icon-composition-BiOTwrvD.d.ts

@@ -0,0 +1,1331 @@
+import { b7 as TileflowThemeColorValue, o as TileflowSymbolStyle, A as TileflowAreaStyle, _ as TileflowLineStackStyle, n as TileflowLineStyle, l as TileflowExtrusionStyle, j as TileflowBackgroundStyle, m as TileflowFillStyle, a3 as TileflowMarkerSymbolStyle, k as TileflowCircleStyle, ba as TileflowThemeNumberValue, aX as TileflowTerrainHillshadeStyle, aW as TileflowTerrainEncoding, b8 as TileflowThemeFontValue, b9 as TileflowThemeImageValue, bU as TileflowTypographyStyle, S as TileflowLight, bV as ResolvedTileflowTypography, s as TileflowLabelsModuleConfig, v as TileflowPoiModuleConfig, q as TileflowRoadsModuleConfig, ad as TileflowProjection, aR as TileflowTerrain, be as TileflowViewConfig, M as MapLibreStyle, bi as ValidationResult } from './manifest-types-CTT2eLbp.js';
+import * as zod from 'zod';
+import { z } from 'zod';
+import { T as TileflowCaptureScene } from './capture-scene-D6soWztE.js';
+
+/** Optional globe atmosphere. Colors use theme tokens or explicit fixed values and must resolve to opaque colors. */
+type TileflowAtmosphereOptions = {
+    skyColor?: TileflowThemeColorValue;
+    horizonColor?: TileflowThemeColorValue;
+    fogColor?: TileflowThemeColorValue;
+    spaceColor?: TileflowThemeColorValue;
+    /** Star brightness from 0 (hidden) to 1. Default: 0.6. */
+    starIntensity?: number;
+    /** Camera-relative star movement from 0 (still) to 1. Default: 0.4. */
+    starParallax?: number;
+};
+type TileflowAtmosphere = boolean | TileflowAtmosphereOptions;
+
+type TileflowAddressesModuleOptions = {
+    /** Styling for OpenMapTiles point house-number labels. */
+    labels?: TileflowSymbolStyle;
+};
+type TileflowAddressesModuleConfig = TileflowAddressesModuleOptions & {
+    type: 'addresses';
+};
+declare function addresses(options?: TileflowAddressesModuleOptions): TileflowAddressesModuleConfig;
+
+type TileflowAerowaysModuleOptions = {
+    area?: TileflowAreaStyle;
+    runway?: TileflowLineStackStyle;
+    runwayRef?: TileflowSymbolStyle;
+    taxiway?: TileflowLineStackStyle;
+};
+type TileflowAerowaysModuleConfig = TileflowAerowaysModuleOptions & {
+    type: 'aeroways';
+};
+declare function aeroways(options?: TileflowAerowaysModuleOptions): TileflowAerowaysModuleConfig;
+
+type TileflowBoundariesModuleOptions = {
+    admin2?: TileflowLineStyle;
+    admin4?: TileflowLineStyle;
+    disputed?: TileflowLineStyle;
+    maritime?: TileflowLineStyle;
+};
+type TileflowBoundariesModuleConfig = TileflowBoundariesModuleOptions & {
+    type: 'boundaries';
+};
+declare function boundaries(options?: TileflowBoundariesModuleOptions): TileflowBoundariesModuleConfig;
+
+type TileflowBuildingMode = '3d' | 'flat';
+type TileflowBuildingsModuleOptions = {
+    businessCorridor?: TileflowAreaStyle;
+    extrusion?: TileflowExtrusionStyle;
+    flat?: TileflowAreaStyle;
+    mode?: TileflowBuildingMode;
+};
+type TileflowBuildingsModuleConfig = TileflowBuildingsModuleOptions & {
+    type: 'buildings';
+};
+declare function buildings(options?: TileflowBuildingsModuleOptions): TileflowBuildingsModuleConfig;
+
+type TileflowLanduseClass = 'cemetery' | 'civic' | 'commercial' | 'education' | 'government' | 'industrial' | 'medical' | 'military' | 'parking' | 'railway' | 'recreation' | 'residential';
+type TileflowLandcoverClass = 'farmland' | 'flowerbed' | 'grass' | 'ice' | 'meadow' | 'protected' | 'recreationGround' | 'rock' | 'sand' | 'scrub' | 'urbanPark' | 'villageGreen' | 'wetland' | 'wood';
+type TileflowLandModuleOptions = {
+    background?: TileflowBackgroundStyle;
+    globalLandcover?: TileflowFillStyle;
+    landcover?: Partial<Record<TileflowLandcoverClass, TileflowAreaStyle>>;
+    landuse?: Partial<Record<TileflowLanduseClass, TileflowAreaStyle>>;
+};
+type TileflowLandModuleConfig = TileflowLandModuleOptions & {
+    type: 'land';
+};
+declare function land(options?: TileflowLandModuleOptions): TileflowLandModuleConfig;
+
+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';
+};
+declare function landforms(options?: TileflowLandformsModuleOptions): TileflowLandformsModuleConfig;
+
+/** Labels anchored inside polygon features; point-feature labels remain on their feature style. */
+type TileflowNauticalAreaLabelStyles = {
+    coverage?: TileflowSymbolStyle;
+    hazards?: TileflowSymbolStyle;
+    navigationAreas?: TileflowSymbolStyle;
+    reefs?: TileflowSymbolStyle;
+    wrecks?: TileflowSymbolStyle;
+};
+type TileflowNauticalModuleOptions = {
+    aids?: TileflowMarkerSymbolStyle;
+    coverage?: TileflowAreaStyle;
+    hazardAreas?: TileflowAreaStyle;
+    hazards?: TileflowMarkerSymbolStyle;
+    labels?: TileflowNauticalAreaLabelStyles;
+    lighthouses?: TileflowMarkerSymbolStyle;
+    lights?: TileflowMarkerSymbolStyle;
+    navigationAreas?: TileflowAreaStyle;
+    reefs?: TileflowAreaStyle;
+    soundings?: TileflowMarkerSymbolStyle;
+    wreckAreas?: TileflowAreaStyle;
+    wrecks?: TileflowMarkerSymbolStyle;
+};
+type TileflowNauticalModuleConfig = TileflowNauticalModuleOptions & {
+    type: 'nautical';
+};
+/** Style the semantic objects published by the `nautical-v1` sidecar. */
+declare function nautical(options?: TileflowNauticalModuleOptions): TileflowNauticalModuleConfig;
+
+/** Compiler-only state produced by semantic module operations during map resolution. */
+type TileflowResolvedModuleConfig<TModule extends {
+    type: string;
+}> = TModule & {
+    readonly enabled?: boolean;
+};
+
+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';
+};
+declare function transit(options?: TileflowTransitModuleOptions): TileflowTransitModuleConfig;
+
+type TileflowVegetationMode = '3d' | 'flat';
+type TileflowVegetationThreeDimensionalStyle = {
+    barkColor?: TileflowThemeColorValue;
+    broadleafColors?: readonly TileflowThemeColorValue[];
+    coniferColors?: readonly TileflowThemeColorValue[];
+    crownScale?: TileflowThemeNumberValue;
+    heightScale?: TileflowThemeNumberValue;
+};
+type TileflowVegetationModuleOptions = {
+    flat?: TileflowCircleStyle;
+    minZoom?: number;
+    mode?: TileflowVegetationMode;
+    threeDimensional?: TileflowVegetationThreeDimensionalStyle;
+};
+type TileflowVegetationModuleConfig = TileflowVegetationModuleOptions & {
+    type: 'vegetation';
+};
+declare function vegetation(options?: TileflowVegetationModuleOptions): TileflowVegetationModuleConfig;
+
+type TileflowWaterwayClass = 'canal' | 'other' | 'river' | 'stream';
+type TileflowWaterModuleOptions = {
+    bathymetry?: TileflowFillStyle;
+    /** Opt-in approximate contours traced from discrete bathymetry polygon band edges. */
+    bathymetryContours?: TileflowLineStyle;
+    /** Opt-in labels for bathymetry polygon band floors, not measured survey soundings. */
+    bathymetryLabels?: TileflowSymbolStyle;
+    bodies?: TileflowAreaStyle;
+    intermittent?: {
+        bodies?: TileflowAreaStyle;
+        waterways?: TileflowLineStyle;
+    };
+    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
+};
+type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
+    type: 'water';
+};
+declare function water(options?: TileflowWaterModuleOptions): TileflowWaterModuleConfig;
+
+declare const tileflowWorldGeneration: "v1";
+/** Mutable discovery selector. The server resolves it once to an immutable release in TileJSON. */
+declare const tileflowWorldTileJsonUrl: "https://api.tileflow.dev/tiles/world/tiles.json";
+
+declare const tileflowPrimarySourceId = "tileflow";
+declare const openMapTilesContractVersion = 1;
+type ParkLayerSemantics = 'mixed' | 'protected-only';
+type OpenMapTilesLayerBindings = {
+    aerodromeLabel: string;
+    aeroway: string;
+    boundary: string;
+    building: string;
+    /** Required low-zoom GEBCO extension in the Tileflow World V1 schema. */
+    bathymetry?: string;
+    /** Optional derived commercial-activity polygons rendered below buildings. */
+    businessCorridor?: string;
+    /** Optional generated circle centers used for detailed roundabout rendering. */
+    circularFeature?: string;
+    /** Optional low-zoom global land-cover extension. Defaults to `globallandcover`. */
+    globalLandcover?: string;
+    houseNumber: string;
+    landcover: string;
+    landuse: string;
+    mountainPeak: string;
+    park: string;
+    place: string;
+    poi: string;
+    road: string;
+    roadName: string;
+    /** Optional generalized low-zoom route-shield points. Required by Tileflow World V1. */
+    roadShield?: string;
+    /** Optional detailed pedestrian-surface polygons. */
+    sidewalk?: string;
+    /** Optional point features such as pedestrian crossings. */
+    streetFurniture?: string;
+    /** Optional individual-tree point extension used by the vegetation module. */
+    tree?: string;
+    water: string;
+    waterName: string;
+    waterway: string;
+};
+type OpenMapTilesFieldBindings = {
+    access: string;
+    activityScore: string;
+    adminLevel: string;
+    bicycle: string;
+    /** GEBCO depth-band upper boundary in metres. */
+    bathymetryMinDepth?: string;
+    /** Stable shallow-to-deep ordering for GEBCO bands. */
+    bathymetrySortKey?: string;
+    brunnel: string;
+    buildingKind: string;
+    buildingTone: string;
+    capital: string;
+    /** Roundabout geometry kind in the optional circular-feature layer. */
+    circularKind?: string;
+    /** Precomputed roundabout radius in pixels at zoom 15. */
+    circularRadiusAtZoom15?: string;
+    /** Extra precomputed clearance on road approaches to a circular road at zoom 15. */
+    circularClearanceExtraAtZoom15?: string;
+    /** Roundabout radius in metres. */
+    circularRadiusMeters?: string;
+    /** Roundabout inner radius in metres. */
+    circularInnerRadiusMeters?: string;
+    /** Roundabout outer radius in metres. */
+    circularOuterRadiusMeters?: string;
+    class: string;
+    /** Crossing control classification on street-furniture points. */
+    crossing: string;
+    circumference: string;
+    classificationConfidence: string;
+    confidence: string;
+    diameterCrown: string;
+    disputed: string;
+    /** Direction in degrees for oriented street-furniture symbols. */
+    direction?: string;
+    elevation: string;
+    elevationFeet: string;
+    expressway: string;
+    foot: string;
+    height: string;
+    hide3d: string;
+    hasBusiness: string;
+    /** Whether a building footprint owns separately materialized building parts. */
+    hasParts?: string;
+    horse: string;
+    houseNumber: string;
+    /** Optional sparse 1–4 semantic and locally normalized urban-importance tier. */
+    importanceTier?: string;
+    iata: string;
+    icao: string;
+    indoor: string;
+    intermittent: string;
+    genus: string;
+    layer: string;
+    leafCycle: string;
+    leafType: string;
+    level: string;
+    maritime: string;
+    /** Physical crossing-marking classification on street-furniture points. */
+    markings: string;
+    minHeight: string;
+    minZoom: string;
+    mtbScale: string;
+    name: string;
+    nameEnglish: string;
+    nameLatin: string;
+    network: string;
+    official: string;
+    oneway: string;
+    /** Canonical editorial POI category. Never aliases OpenMapTiles `class`. */
+    poiCategory: string;
+    /** Per-zoom POI density tier from 0 (most selective) through 5. */
+    poiFilterRank: string;
+    /** Producer-selected POI icon key. */
+    poiIcon: string;
+    /** Physical-size tier from 0 (largest) through 16 (point-sized). */
+    poiSizeRank: string;
+    /** Canonical specific POI type. Never aliases OpenMapTiles `subclass`. */
+    poiType: string;
+    ramp: string;
+    rank: string;
+    ref: string;
+    refLength: string;
+    renderHeight: string;
+    renderMinZoom: string;
+    renderMinHeight: string;
+    /** Optional producer-normalized route-shield family. Required by Tileflow World V1. */
+    shieldKind?: string;
+    /** Optional merged line length used to bound detailed route-shield repetition. */
+    shieldLineLengthMeters?: string;
+    /** Optional producer-normalized route network identifier. */
+    shieldNetwork?: string;
+    /** Optional producer-normalized route-shield collision rank. */
+    shieldRank?: string;
+    /** Optional producer-normalized route-shield text. */
+    shieldText?: string;
+    /** Optional producer-normalized route-shield ink role. Required by Tileflow World V1. */
+    shieldTextColor?: string;
+    service: string;
+    species: string;
+    speciesWikidata: string;
+    subclass: string;
+    surface: string;
+    toll: string;
+};
+type OpenMapTilesSchemaOptions = {
+    capabilities?: {
+        businessCorridor?: boolean;
+        bathymetry?: boolean;
+        globalLandcover?: boolean;
+        tree?: boolean;
+    };
+    fields?: Partial<OpenMapTilesFieldBindings>;
+    layers?: Partial<OpenMapTilesLayerBindings>;
+    semantics?: {
+        /** Whether the bound park layer mixes ordinary parks with protected areas. */
+        parkLayer?: ParkLayerSemantics;
+    };
+};
+type OpenMapTilesSchema = {
+    type: 'openmaptiles';
+    contractVersion: typeof openMapTilesContractVersion;
+    fields: OpenMapTilesFieldBindings;
+    layers: OpenMapTilesLayerBindings;
+    semantics: {
+        parkLayer: ParkLayerSemantics;
+    };
+};
+type TileflowWorldV1Schema = Omit<OpenMapTilesSchema, 'fields' | 'layers'> & {
+    fields: OpenMapTilesFieldBindings & {
+        bathymetryMinDepth: string;
+        bathymetrySortKey: string;
+        circularClearanceExtraAtZoom15: string;
+        circularInnerRadiusMeters: string;
+        circularKind: string;
+        circularOuterRadiusMeters: string;
+        circularRadiusAtZoom15: string;
+        circularRadiusMeters: string;
+        direction: string;
+        hasParts: string;
+        shieldKind: string;
+        shieldLineLengthMeters: string;
+        shieldNetwork: string;
+        shieldRank: string;
+        shieldText: string;
+        shieldTextColor: string;
+    };
+    layers: OpenMapTilesLayerBindings & {
+        bathymetry: string;
+        circularFeature: string;
+        globalLandcover: string;
+        sidewalk: string;
+        streetFurniture: string;
+        roadShield: string;
+    };
+};
+type TileflowWorldReleaseReference = Readonly<{
+    descriptorSha256: string;
+    releaseId: string;
+}>;
+type TileflowWorldSelection = Readonly<{
+    kind: 'current';
+    product: 'world-v1';
+}> | Readonly<{
+    kind: 'release';
+    product: 'world-v1';
+    release: TileflowWorldReleaseReference;
+}>;
+type TileflowWorldData = {
+    generation: typeof tileflowWorldGeneration;
+    selection: TileflowWorldSelection;
+    type: 'tileflow-world';
+};
+type VectorTilesDataCommon = {
+    type: 'vector-tiles';
+    attribution: string;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+};
+type VectorTilesData = VectorTilesDataCommon & ({
+    bounds?: never;
+    maxzoom?: never;
+    minzoom?: never;
+    tiles?: never;
+    url: string;
+} | {
+    bounds?: [number, number, number, number];
+    maxzoom?: number;
+    minzoom?: number;
+    tiles: [string, ...string[]];
+    url?: never;
+});
+type TileflowDataConfig = TileflowWorldData | VectorTilesData;
+type TileflowDataIdentity = {
+    bindings?: {
+        fields: OpenMapTilesFieldBindings;
+        layers: OpenMapTilesLayerBindings;
+    };
+    capabilities?: {
+        businessCorridor: boolean;
+        bathymetry: boolean;
+        globalLandcover: boolean;
+        tree: boolean;
+    };
+    generation?: typeof tileflowWorldGeneration;
+    kind: TileflowDataConfig['type'];
+    /** External fixture identity. */
+    revision?: string;
+    schema: OpenMapTilesSchema['type'];
+    schemaVersion: number;
+    semantics: OpenMapTilesSchema['semantics'];
+    sourceId: typeof tileflowPrimarySourceId;
+    url?: string;
+    worldSelection?: TileflowWorldSelection;
+};
+type ResolvedTileflowData = {
+    attribution: string;
+    bounds?: [number, number, number, number];
+    generation?: typeof tileflowWorldGeneration;
+    identity: TileflowDataIdentity;
+    kind: TileflowDataConfig['type'];
+    maxzoom?: number;
+    minzoom?: number;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+    sourceId: typeof tileflowPrimarySourceId;
+    tiles?: string[];
+    url?: string;
+};
+declare function openMapTiles(options?: OpenMapTilesSchemaOptions): OpenMapTilesSchema;
+/** OpenMapTiles plus the required typed extensions emitted by Tileflow World V1. */
+declare function tileflowWorldV1Schema(options?: OpenMapTilesSchemaOptions): TileflowWorldV1Schema;
+declare function validateTileflowWorldV1Tilejson(tilejson: {
+    vector_layers?: readonly unknown[];
+} | null | undefined, schema?: TileflowWorldV1Schema): string[];
+declare function tileflowWorld(options?: {
+    release?: TileflowWorldReleaseReference;
+}): TileflowWorldData;
+declare function vectorTiles(options: {
+    attribution: string;
+    bounds?: [number, number, number, number];
+    maxzoom?: number;
+    minzoom?: number;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+    tiles?: readonly [string, ...string[]];
+    url?: string;
+}): VectorTilesData;
+declare function resolveTileflowData(data: TileflowDataConfig | undefined, options?: {
+    apiBaseUrl?: string;
+}): ResolvedTileflowData;
+declare function isCanonicalOpenMapTilesSchema(schema: OpenMapTilesSchema): boolean;
+
+declare const tileflowBathymetrySourceId: "tileflow-bathymetry";
+declare const tileflowBathymetryDemSourceId: "tileflow-bathymetry-dem";
+declare const tileflowNauticalSourceId: "tileflow-nautical";
+declare const tileflowBathymetryV1Schema: Readonly<{
+    fields: Readonly<{
+        minDepth: "min_depth";
+        sortKey: "sort_key";
+    }>;
+    layer: "bathymetry";
+    layers: Readonly<{
+        bands: "bathymetry";
+        contours: "bathymetry_contour";
+        coverage: "bathymetry_coverage";
+        landforms: "seafloor_landform";
+        waterNames: "water_name";
+    }>;
+    optionalLayers: readonly ["contours", "coverage", "landforms", "waterNames"];
+    product: "bathymetry-v1";
+    requiredLayers: readonly ["bands"];
+    schemaVersion: 1;
+    sources: Readonly<{
+        dem: Readonly<{
+            encoding: "terrarium";
+            sourceId: "tileflow-bathymetry-dem";
+            tileSize: 512;
+        }>;
+        vector: Readonly<{
+            sourceId: "tileflow-bathymetry";
+        }>;
+    }>;
+}>;
+declare const tileflowNauticalV1Schema: Readonly<{
+    fields: Readonly<{
+        cell: "cell";
+        character: "character";
+        class: "class";
+        color: "color";
+        coverage: "coverage";
+        depth: "depth";
+        direction: "direction";
+        edition: "edition";
+        licence: "licence";
+        name: "name";
+        provider: "provider";
+        provenance: "provenance";
+        quality: "quality";
+        rangeNm: "range_nm";
+        scale: "scale";
+        subclass: "subclass";
+        update: "update";
+    }>;
+    geometryTypes: Readonly<{
+        aids: readonly ["Point"];
+        coverage: readonly ["Polygon"];
+        hazards: readonly ["Point", "Polygon"];
+        lights: readonly ["Point"];
+        navigationAreas: readonly ["Polygon"];
+        reefs: readonly ["Polygon"];
+        soundings: readonly ["Point"];
+        wrecks: readonly ["Point", "Polygon"];
+    }>;
+    layers: Readonly<{
+        aids: "aid";
+        coverage: "coverage";
+        hazards: "hazard";
+        lights: "light";
+        navigationAreas: "navigation_area";
+        reefs: "reef";
+        soundings: "sounding";
+        wrecks: "wreck";
+    }>;
+    product: "nautical-v1";
+    schemaVersion: 1;
+}>;
+type TileflowMarineMode = 'none' | 'bathymetry' | 'nautical' | 'chart';
+/** One schema-compatible vector TileJSON source used by a marine sidecar. */
+type TileflowMarineSourceConfig = {
+    attribution?: string;
+    sourceId?: string;
+    url?: string;
+};
+type TileflowBathymetryDisplay = 'bands' | 'relief' | 'hybrid';
+/**
+ * Styling and physical-source overrides for the optional Bathymetry DEM.
+ * Terrarium and 512 px tiles are the hosted defaults; advanced compatible sources may override
+ * either. `opacity` applies to both the continuous color relief and the hillshade tint.
+ */
+type TileflowBathymetryReliefConfig = TileflowTerrainHillshadeStyle & {
+    attribution?: string;
+    encoding?: TileflowTerrainEncoding;
+    illuminationAltitude?: TileflowThemeNumberValue;
+    multidirectional?: boolean;
+    opacity?: TileflowThemeNumberValue;
+    sourceId?: string;
+    tileSize?: 256 | 512;
+    url?: string;
+};
+/** One logical Bathymetry product backed by vector bands and, when requested, a DEM. */
+type TileflowBathymetryConfig = TileflowMarineSourceConfig & {
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display?: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: false | TileflowBathymetryReliefConfig;
+    type: 'bathymetry';
+};
+type TileflowBathymetryOptions = Omit<TileflowBathymetryConfig, 'type'>;
+/** Configure Bathymetry as one product while loading only the physical sources its display needs. */
+declare function bathymetry(options?: TileflowBathymetryOptions): TileflowBathymetryConfig;
+/**
+ * Advanced marine selection. An omitted member selects Tileflow's current product; `false`
+ * disables only that member. Therefore `{}` is equivalent to `"chart"`.
+ */
+type TileflowMarineConfig = {
+    bathymetry?: false | TileflowBathymetryConfig | TileflowMarineSourceConfig;
+    nautical?: false | TileflowMarineSourceConfig;
+};
+type TileflowMarine = TileflowMarineMode | TileflowMarineConfig;
+type TileflowMarineSourceIdentity = Readonly<{
+    kind: 'tileflow-bathymetry' | 'tileflow-nautical';
+    product: 'bathymetry-v1' | 'nautical-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    url: string;
+}>;
+type TileflowBathymetryDemSourceIdentity = Readonly<{
+    encoding: TileflowTerrainEncoding;
+    kind: 'tileflow-bathymetry-dem';
+    product: 'bathymetry-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    tileSize: 256 | 512;
+    url: string;
+}>;
+type ResolvedMarineSource = Readonly<{
+    identity: TileflowMarineSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        type: 'vector';
+        url: string;
+    }>;
+    sourceId: string;
+}>;
+type ResolvedBathymetryRelief = Readonly<{
+    identity: TileflowBathymetryDemSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        encoding: TileflowTerrainEncoding;
+        tileSize: 256 | 512;
+        type: 'raster-dem';
+        url: string;
+    }>;
+    sourceId: string;
+    style: TileflowBathymetryReliefConfig;
+}>;
+type ResolvedBathymetry = Readonly<{
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: ResolvedBathymetryRelief;
+    vector?: ResolvedMarineSource;
+}>;
+type ResolvedMarine = Readonly<{
+    bathymetry?: ResolvedBathymetry;
+    nautical?: ResolvedMarineSource;
+}>;
+/** Resolve the optional marine sidecars without fetching their TileJSON documents. */
+declare function resolveMarine(marine: TileflowMarine | undefined, apiBaseUrl?: string): ResolvedMarine | undefined;
+
+type TileflowVisualValueCategory = 'color' | 'font' | 'image' | 'number';
+/** Return the semantic theme category for one visual property, or undefined for structure/data. */
+declare function classifyTileflowVisualProperty(property: string, _value?: unknown): TileflowVisualValueCategory | undefined;
+
+type TileflowThemeColorScheme = 'dark' | 'light';
+type TileflowThemeName = string;
+declare const tileflowThemeLimits: Readonly<{
+    readonly maxThemes: 64;
+}>;
+type TileflowThemeTokens = {
+    color: Readonly<Record<string, TileflowThemeColorValue>>;
+    font: Readonly<Record<string, TileflowThemeFontValue>>;
+    image: Readonly<Record<string, TileflowThemeImageValue>>;
+    number: Readonly<Record<string, TileflowThemeNumberValue>>;
+};
+type TileflowThemeTypographyStyle = {
+    fallbacks?: readonly TileflowThemeFontValue[];
+    font?: TileflowThemeFontValue;
+    letterSpacing?: TileflowThemeNumberValue;
+    transform?: TileflowTypographyStyle['transform'];
+};
+type TileflowThemeTypography = TileflowThemeTypographyStyle & {
+    places?: TileflowThemeTypographyStyle;
+    poi?: TileflowThemeTypographyStyle;
+    roads?: TileflowThemeTypographyStyle;
+    water?: TileflowThemeTypographyStyle;
+};
+type TileflowThemeLighting = {
+    anchor?: 'map' | 'viewport';
+    color?: TileflowThemeColorValue;
+    intensity?: TileflowThemeNumberValue;
+    position?: readonly [
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue
+    ];
+};
+/** A complete, inheritance-free appearance document. */
+type TileflowTheme = {
+    colorScheme: TileflowThemeColorScheme;
+    id: string;
+    lighting: TileflowThemeLighting;
+    tokens: TileflowThemeTokens;
+    typography: TileflowThemeTypography;
+    version: number;
+};
+type TileflowThemeTokenOverrides = {
+    [TCategory in keyof TileflowThemeTokens]?: Readonly<Partial<TileflowThemeTokens[TCategory]>>;
+};
+/** Input accepted by defineTheme. The returned theme is always fully materialized. */
+type TileflowThemeDefinition = Pick<TileflowTheme, 'colorScheme' | 'id' | 'version'> & {
+    lighting?: TileflowThemeLighting;
+    tokens?: TileflowThemeTokenOverrides;
+    typography?: TileflowThemeTypography;
+};
+type ResolvedTileflowThemeTokens = {
+    color: Readonly<Record<string, string>>;
+    font: Readonly<Record<string, string>>;
+    image: Readonly<Record<string, string>>;
+    number: Readonly<Record<string, number>>;
+};
+type ResolvedTileflowTheme = Omit<TileflowTheme, 'lighting' | 'tokens' | 'typography'> & {
+    lighting: TileflowLight;
+    tokens: ResolvedTileflowThemeTokens;
+    typography: ResolvedTileflowTypography;
+};
+type TileflowResolvedThemeSelection = {
+    name: TileflowThemeName;
+    theme: TileflowTheme;
+};
+type TileflowThemeAuditScope = 'module' | 'terrain' | 'value';
+type TileflowThemeAuditContext = {
+    owner?: string;
+    scope: TileflowThemeAuditScope;
+    target?: string;
+};
+type TileflowThemeAuditDiagnostic = {
+    category: TileflowVisualValueCategory;
+    code: 'THEME_IMPLICIT_FIXED';
+    message: string;
+    owner?: string;
+    path: string;
+    phase: 'theme-audit';
+    scope: TileflowThemeAuditScope;
+    severity: 'error' | 'warning';
+    suggestion: string;
+    target?: string;
+    value: number | string;
+};
+/** A deterministic, machine-readable failure for blocking theme-audit diagnostics. */
+declare class TileflowThemeAuditError extends Error {
+    readonly diagnostics: readonly TileflowThemeAuditDiagnostic[];
+    constructor(diagnostics: readonly TileflowThemeAuditDiagnostic[]);
+}
+declare function defineTheme(definition: TileflowThemeDefinition): TileflowTheme;
+declare function defineTheme(base: TileflowTheme, definition: TileflowThemeDefinition): TileflowTheme;
+declare function resolveTileflowTheme(theme: TileflowTheme): ResolvedTileflowTheme;
+/** Resolve every theme node in modules, terrain, zoom values and expression arrays. */
+declare function resolveThemeValues<T>(value: T, theme: TileflowTheme, path?: string): T;
+/** Select an explicit theme or the map's deterministic default. Browser "system" is external. */
+declare function resolveThemeSelection(map: {
+    defaultTheme: string;
+    themes: Readonly<Record<string, TileflowTheme>>;
+}, requested?: string): TileflowResolvedThemeSelection;
+/** Find visual literals whose permanence is otherwise invisible to an agent. */
+declare function auditTileflowThemeValues(value: unknown, path?: string, context?: TileflowThemeAuditContext): TileflowThemeAuditDiagnostic[];
+/** Audit every appearance-bearing branch of a resolved map. */
+declare function auditTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): TileflowThemeAuditDiagnostic[];
+/** Fail closed when a map contains implicit chromatic, font, or image literals. */
+declare function assertTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): void;
+
+type TileflowLayerDomain = TileflowSemanticModuleName | 'terrain';
+
+declare const tileflowLayerSlots: readonly ["background", "land", "terrain", "hydro", "building-areas", "transport-areas", "transport-tunnel-shadow", "transport-tunnel-casing", "transport-tunnel-fill", "transport-pedestrian-areas", "aeroways", "transport-surface-shadow", "transport-surface-casing", "transport-surface-fill", "transport-bridge-shadow", "transport-bridge-casing", "transport-bridge-fill", "transport-symbols", "boundaries", "buildings", "vegetation", "symbols"];
+type TileflowLayerSlot = (typeof tileflowLayerSlots)[number];
+/**
+ * Public paint bands: stable names for consecutive compiler slots. Render passes, target
+ * placements and overlays address band edges instead of physical slots.
+ */
+declare const tileflowLayerBands: readonly ["land", "relief", "water", "roads", "boundaries", "buildings", "vegetation", "labels"];
+type TileflowLayerBand = (typeof tileflowLayerBands)[number];
+/** A band edge: `below-roads` is the start of the roads band, `above-roads` its end. */
+type TileflowBandPlacement = `${'above' | 'below'}-${TileflowLayerBand}`;
+declare const tileflowBandPlacements: readonly TileflowBandPlacement[];
+
+type TileflowSemanticModules = {
+    addresses?: TileflowAddressesModuleConfig;
+    aeroways?: TileflowAerowaysModuleConfig;
+    boundaries?: TileflowBoundariesModuleConfig;
+    buildings?: TileflowBuildingsModuleConfig;
+    labels?: TileflowLabelsModuleConfig;
+    land?: TileflowLandModuleConfig;
+    landforms?: TileflowLandformsModuleConfig;
+    nautical?: TileflowNauticalModuleConfig;
+    poi?: TileflowPoiModuleConfig;
+    roads?: TileflowRoadsModuleConfig;
+    transit?: TileflowTransitModuleConfig;
+    vegetation?: TileflowVegetationModuleConfig;
+    water?: TileflowWaterModuleConfig;
+};
+type TileflowSemanticModuleName = keyof TileflowSemanticModules;
+type TileflowResolvedSemanticModuleOverrides = {
+    readonly [TName in TileflowSemanticModuleName]?: TileflowResolvedModuleConfig<NonNullable<TileflowSemanticModules[TName]>>;
+};
+
+/** A directory resolved relative to the selected executable tileflow.config.ts. */
+type TileflowLocalDirectory = `./${string}` | `../${string}`;
+declare const tileflowLocalDirectoryMaximumLength = 512;
+declare const tileflowLocalDirectoryMessage = "Expected a canonical relative directory beginning with ./ or ../; only leading .. segments are allowed and segments must be non-empty, without backslashes or controls";
+/** Exact portable syntax shared by config validation and Node filesystem resolution. */
+declare function isTileflowLocalDirectory(value: unknown): value is TileflowLocalDirectory;
+/**
+ * A package-owned asset directory. Applications normally import one of these
+ * descriptors from the package that owns the assets instead of constructing it.
+ */
+type TileflowPackageDirectory = Readonly<{
+    kind: 'package-directory';
+    package: string;
+    path: string;
+}>;
+/** One icon directory in the ordered map icon search path. */
+type TileflowIconDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/** One font directory in the ordered map font search path. */
+type TileflowFontDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/**
+ * An explicit MapLibre glyph provider. `fontStacks` lists the exact comma-joined request keys
+ * produced by each compiled `text-font` array. The map owns the URL; World never supplies fonts.
+ */
+type TileflowGlyphs = Readonly<{
+    fontStacks: readonly string[];
+    kind: 'url';
+    url: string;
+}>;
+
+declare const tileflowIconSourceLimit = 32;
+type TileflowIconSetReference = `@${string}/${string}`;
+declare const tileflowIconSetReferenceSchema: z.ZodString;
+declare const tileflowIconSetSourceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"icon-set">;
+    reference: z.ZodString;
+}, z.core.$strict>;
+type TileflowIconSetSource = Readonly<{
+    kind: 'icon-set';
+    reference: TileflowIconSetReference;
+}>;
+type TileflowIconSource = TileflowIconDirectory | TileflowIconSetSource;
+/** Declare a dependency. This function never resolves a version or performs I/O. */
+declare function iconSet(reference: TileflowIconSetReference): TileflowIconSetSource;
+declare function isTileflowIconSetSource(value: unknown): value is TileflowIconSetSource;
+declare const tileflowIconSetIdSchema: z.ZodString;
+declare const tileflowIconSetVersionIdSchema: z.ZodString;
+declare const tileflowIconSetPackageIdSchema: z.ZodString;
+declare const tileflowIconSetTeamIdSchema: z.ZodString;
+type TileflowIconSetErrorCode = 'ICON_SET_INVALID' | 'ICON_LOCK_INVALID' | 'ICON_LOCK_MISSING' | 'ICON_LOCK_CONFLICT' | 'ICON_CACHE_MISS' | 'ICON_CACHE_UNSAFE' | 'ICON_DOWNLOAD_FAILED' | 'ICON_PACKAGE_INTEGRITY' | 'ICON_COMPOSITION_INVALID';
+declare class TileflowIconSetError extends Error {
+    readonly code: TileflowIconSetErrorCode;
+    readonly phase: "icon-resolution";
+    constructor(code: TileflowIconSetErrorCode, message: string, options?: ErrorOptions);
+}
+/** Validate the dependency sequence without consulting a lock or registry. */
+declare function collectTileflowIconSetReferences(sources: readonly TileflowIconSource[]): TileflowIconSetReference[];
+
+declare const tileflowOverlayPlacements: readonly ["above-water", "below-roads", "above-roads", "above-buildings", "below-labels", "above-labels"];
+declare const tileflowHostedSourceLimit: 16;
+type TileflowOverlayPlacement = (typeof tileflowOverlayPlacements)[number];
+type TileflowHostedTilesetType = 'raster' | 'vector';
+type TileflowHostedTilesetSource = Readonly<{
+    attribution: string;
+    kind: 'hosted-tileset';
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type: TileflowHostedTilesetType;
+}>;
+type TileflowMapLibreOverlayLayer = Readonly<Record<string, unknown> & {
+    id: string;
+    source?: never;
+    type: string;
+}>;
+type TileflowMapLibreOverlay = Readonly<{
+    kind: 'maplibre-overlay';
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}>;
+type TileflowRemoveOperation = Readonly<{
+    op: 'remove';
+}>;
+type TileflowHostedSourceCollection = Readonly<Record<string, TileflowHostedTilesetSource | TileflowRemoveOperation>>;
+type TileflowOverlayCollection = Readonly<Record<string, TileflowMapLibreOverlay | TileflowRemoveOperation>>;
+/** Bind one logical Team tileset to an explicit account-free local PMTiles archive. */
+declare function hostedTileset(options: {
+    attribution: string;
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type?: TileflowHostedTilesetType;
+}): TileflowHostedTilesetSource;
+/** Group one or more ordinary MapLibre layers around one named Tileflow source. */
+declare function maplibreOverlay(options: {
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}): TileflowMapLibreOverlay;
+/** Remove one inherited keyed source or overlay. */
+declare function remove(): TileflowRemoveOperation;
+declare function isSafeLocalPmtilesPath(value: unknown): value is string;
+
+declare const tileflowResetBrand: unique symbol;
+/** Serializable sentinel that removes one inherited override during `refine()`. */
+type TileflowReset = Readonly<{
+    readonly $tileflow: 'reset';
+    readonly [tileflowResetBrand]: true;
+}>;
+type TileflowPatchValue<TValue> = TileflowReset | (TValue extends readonly unknown[] ? TValue : TValue extends object ? TileflowNestedPatch<TValue> : TValue);
+type TileflowNestedPatch<TValue extends object> = {
+    readonly [TKey in keyof TValue]?: TileflowPatchValue<TValue[TKey]>;
+};
+/**
+ * A recursive semantic patch. Records merge; arrays and scalar values replace.
+ * Module ownership and compiler visibility are immutable only at the patch root;
+ * nested domain options named `type` or `enabled` retain their ordinary meaning.
+ */
+type TileflowModulePatch<TModule extends object> = {
+    readonly [TKey in Exclude<keyof TModule, 'enabled' | 'type'>]?: TileflowPatchValue<TModule[TKey]>;
+};
+type TileflowRefineOperation<TPatch extends object = object> = Readonly<{
+    readonly op: 'refine';
+    readonly patches: readonly TPatch[];
+}>;
+type TileflowDisableOperation = Readonly<{
+    readonly op: 'disable';
+}>;
+type TileflowModuleOperation<TModule extends object> = TileflowDisableOperation | TileflowRefineOperation<TileflowModulePatch<TModule>>;
+type TileflowAuthoringModules = {
+    readonly [TName in keyof TileflowSemanticModules]?: NonNullable<TileflowSemanticModules[TName]> | TileflowModuleOperation<NonNullable<TileflowSemanticModules[TName]>>;
+};
+/** Deeply refine an inherited module; arrays and scalar values replace atomically. */
+declare function refine<const TPatch extends object>(...patches: readonly [TPatch, ...TPatch[]]): TileflowRefineOperation<TPatch>;
+/** Disable a complete semantic module while retaining an explicit compiler decision. */
+declare function disable(): TileflowDisableOperation;
+/** Remove an inherited override so the domain registry can supply its semantic default. */
+declare function reset(): TileflowReset;
+
+/** Portable, filesystem-safe identity shared by maps and their leaf-owned scenes. */
+declare const tileflowMapIdSchema: zod.ZodString;
+/** Identity is always owned by the map being resolved and never inherited. */
+type TileflowMapIdentity = {
+    id: string;
+    name?: string;
+    /** Editorial version of this map. */
+    version: number;
+};
+/** A capture scene owned by one singular map; its map id is implicit. */
+type TileflowMapScene = Omit<TileflowCaptureScene, 'map'>;
+/** Tooling metadata belongs to the leaf definition and is never inherited. */
+type TileflowMapTooling = {
+    scenes?: Record<string, TileflowMapScene>;
+};
+type TileflowMapTextAssets = {
+    fonts?: never;
+    glyphs?: never;
+} | {
+    fonts: readonly TileflowFontDirectory[];
+    glyphs?: never;
+} | {
+    fonts?: never;
+    glyphs: TileflowGlyphs;
+};
+/** Cartographic fields supported by the V1 semantic compiler. */
+type TileflowMapDesign = TileflowMapTextAssets & {
+    /** Optional atmosphere for globe projection. False disables an inherited atmosphere. */
+    atmosphere?: TileflowAtmosphere;
+    data?: TileflowDataConfig;
+    /** Name used whenever a concrete theme is not explicitly requested. */
+    defaultTheme?: TileflowThemeName;
+    /** Ordered icon contributors. Omission inherits; declaration replaces; [] means no icons. */
+    icons?: readonly TileflowIconSource[];
+    /** Independent Bathymetry and Nautical products composed by the compiler. */
+    marine?: TileflowMarine;
+    /** Semantic domains, expressed directly or with explicit refine/disable operations. */
+    modules?: TileflowAuthoringModules;
+    /** Keyed MapLibre overlay units. Omission inherits; entries replace atomically. */
+    overlays?: TileflowOverlayCollection;
+    projection?: TileflowProjection;
+    /** Keyed logical hosted sources. Omission inherits; entries replace atomically. */
+    sources?: TileflowHostedSourceCollection;
+    /** Browser color-scheme mapping. Runtime resolves "system" to one of these concrete names. */
+    systemThemes?: {
+        dark: TileflowThemeName;
+        light: TileflowThemeName;
+    };
+    terrain?: TileflowTerrain;
+    /** Complete named appearances. Omission inherits; declaration replaces the collection. */
+    themes?: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+    view?: TileflowViewConfig;
+};
+/** Complete semantic map at the base of a lineage. The compiler is implicit. */
+type TileflowStandaloneMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type TileflowDerivedMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    extends: TileflowMap;
+};
+/** Executable authoring definition using the one implicit semantic compiler. */
+type TileflowMap = TileflowDerivedMap | TileflowStandaloneMap;
+type ResolvedTileflowMapDesign<TDesign extends TileflowMapDesign = TileflowMapDesign> = TDesign extends TileflowMapDesign ? Omit<TDesign, 'defaultTheme' | 'modules' | 'overlays' | 'sources' | 'themes'> : never;
+/** A standalone map definition with inheritance removed. */
+type ResolvedTileflowMap = Omit<TileflowMapIdentity, 'name'> & ResolvedTileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    modules?: TileflowResolvedSemanticModuleOverrides;
+    name: string;
+    overlays?: Readonly<Record<string, TileflowMapLibreOverlay>>;
+    sources?: Readonly<Record<string, TileflowHostedTilesetSource>>;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type ResolveMapOptions = {
+    /** Maximum number of map definitions in a lineage, including its standalone base. */
+    maxDepth?: number;
+};
+
+type TileflowDataFieldType = 'Boolean' | 'Number' | 'String';
+type TileflowDataFieldRequirement = Readonly<{
+    name: string;
+    type?: TileflowDataFieldType;
+}>;
+type TileflowDataLayerRequirement = Readonly<{
+    fields: readonly TileflowDataFieldRequirement[];
+    id: string;
+}>;
+type TileflowDataRequirementsV1 = Readonly<{
+    complete: boolean;
+    dynamicAccesses: readonly string[];
+    schemaVersion: 1;
+    sourceId: string;
+    sourceLayers: readonly TileflowDataLayerRequirement[];
+}>;
+/** Per-source requirements for styles that compose independent vector and DEM products. */
+type TileflowSourceRequirementsV1 = Readonly<{
+    rasterDemSources?: Readonly<Record<string, TileflowRasterDemSourceRequirementV1>>;
+    schemaVersion: 1;
+    sources: Readonly<Record<string, TileflowDataRequirementsV1>>;
+}>;
+type TileflowRasterDemSourceRequirementV1 = Readonly<{
+    encoding: 'mapbox' | 'terrarium';
+    sourceId: string;
+    tileSize: 256 | 512;
+    type: 'raster-dem';
+}>;
+type TileflowObservedDataContractV1 = Readonly<{
+    sourceLayers: readonly Readonly<{
+        fields: readonly Readonly<{
+            name: string;
+            type: TileflowDataFieldType;
+        }>[];
+        id: string;
+    }>[];
+}>;
+type TileflowDataCompatibilityIssue = Readonly<{
+    code: 'dynamic-field-access' | 'field-missing' | 'field-type-mismatch' | 'source-layer-missing';
+    field?: string;
+    message: string;
+    sourceLayer?: string;
+}>;
+/**
+ * Infer the effective data surface from finalized MapLibre layers. Disabled modules contribute no
+ * requirements, and fields hidden by map inheritance never reach this compiler output.
+ */
+declare function inferTileflowDataRequirements(style: MapLibreStyle, options?: {
+    additional?: readonly TileflowDataLayerRequirement[];
+    sourceId?: string;
+}): TileflowDataRequirementsV1;
+/**
+ * Infer the V1 layer/field contract for every referenced vector source and the physical contract
+ * for each included raster DEM. The singular helper remains unchanged for World-only consumers.
+ */
+declare function inferTileflowSourceRequirements(style: MapLibreStyle): TileflowSourceRequirementsV1;
+/** Compare inferred use with producer-observed layers and fields; no editorial allowlist exists. */
+declare function validateTileflowDataCompatibility(requirements: TileflowDataRequirementsV1, contract: TileflowObservedDataContractV1): readonly TileflowDataCompatibilityIssue[];
+
+/** Version of the opt-in, read-only physical-output inspection sidecar. */
+declare const tileflowStyleInspectionSchemaVersion: 1;
+type TileflowStyleInspectionRenderOperation = {
+    readonly kind: 'pass' | 'refinement';
+    readonly owner: TileflowLayerDomain;
+    readonly target: string;
+};
+/** One semantic contribution represented by a compiled physical style layer. */
+type TileflowStyleInspectionContribution = {
+    readonly owner: TileflowLayerDomain;
+    readonly slot: TileflowLayerSlot;
+    readonly target: string;
+    /** Ordered semantic render operations represented by this contribution. */
+    readonly operations: readonly TileflowStyleInspectionRenderOperation[];
+};
+type TileflowStyleInspectionLayer = {
+    /** Opaque physical output identity for diagnostics; never a public authoring target. */
+    readonly id: string;
+    readonly index: number;
+    readonly type: string;
+    /** Multiple entries are expected when the physical planner combines semantic layers. */
+    readonly contributions: readonly TileflowStyleInspectionContribution[];
+};
+/**
+ * Opt-in, read-only cartographic provenance for diagnostics and build tooling.
+ * Physical IDs are output observations, not stable or addressable authoring APIs.
+ * This object is never embedded in Style JSON.
+ */
+type TileflowStyleInspection = {
+    readonly schemaVersion: typeof tileflowStyleInspectionSchemaVersion;
+    readonly map: string;
+    readonly theme: string;
+    readonly layers: readonly TileflowStyleInspectionLayer[];
+};
+type TileflowInspectedStyle = {
+    readonly style: MapLibreStyle;
+    readonly inspection: TileflowStyleInspection;
+};
+
+declare const tileflowCompilationReportSchemaVersion: 1;
+declare const tileflowCompilationPhases: readonly ["assembly", "assets", "config-validation", "data", "domain-ir", "domains", "finalization", "input", "lowering", "physical-planner", "render-stack", "theme", "theme-audit", "validation"];
+declare const tileflowCompilationPlannerStages: readonly ["domain-ir", "assembly", "render-stack", "physical-planner", "lowering"];
+type TileflowCompilationPhase = (typeof tileflowCompilationPhases)[number];
+type TileflowCompilationPlannerStage = (typeof tileflowCompilationPlannerStages)[number];
+type TileflowCompilationDiagnostic = Readonly<{
+    code: string;
+    domain?: TileflowSemanticModuleName;
+    message: string;
+    path?: string;
+    phase: TileflowCompilationPhase;
+    severity: 'error' | 'warning';
+    suggestion?: string;
+    target?: string;
+}>;
+type TileflowCompilationDomainReport = Readonly<{
+    contributionCount: number;
+    name: TileflowSemanticModuleName;
+    renderOperationCount: number;
+    status: 'emitted' | 'suppressed';
+    suppressionReason?: 'disabled' | 'no-contributions';
+    targets: readonly string[];
+}>;
+type TileflowCompilationPlannerDecision = Readonly<{
+    candidateCount?: number;
+    inputCount: number;
+    outputCount: number;
+    selectedCount?: number;
+    stage: TileflowCompilationPlannerStage;
+}>;
+type TileflowCompilationReport = Readonly<{
+    domains: readonly TileflowCompilationDomainReport[];
+    map: string;
+    planner: readonly TileflowCompilationPlannerDecision[];
+    /** Opt-in read-only physical diagnostics; its IDs are not addressable authoring targets. */
+    provenance?: TileflowStyleInspection;
+    requirements?: TileflowSourceRequirementsV1;
+    schemaVersion: typeof tileflowCompilationReportSchemaVersion;
+    targets: readonly string[];
+    theme?: string;
+}>;
+type TileflowCompilationSuccess = Readonly<{
+    diagnostics: readonly TileflowCompilationDiagnostic[];
+    ok: true;
+    report: TileflowCompilationReport;
+    style: MapLibreStyle;
+}>;
+type TileflowCompilationFailure = Readonly<{
+    diagnostics: readonly TileflowCompilationDiagnostic[];
+    ok: false;
+    report: TileflowCompilationReport;
+    style?: never;
+}>;
+type TileflowCompilationResult = TileflowCompilationFailure | TileflowCompilationSuccess;
+declare function isTileflowCompilationPhase(value: unknown): value is TileflowCompilationPhase;
+
+declare const tileflowIconAppearanceSchema: z.ZodObject<{
+    representation: z.ZodLiteral<"sdf">;
+    defaults: z.ZodObject<{
+        color: z.ZodString;
+        haloColor: z.ZodString;
+        haloWidth: z.ZodNumber;
+        haloBlur: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Absent metadata denotes unchanged fixed-color RGBA artwork. */
+type TileflowIconAppearance = z.infer<typeof tileflowIconAppearanceSchema>;
+/** Verify the generated representation from decoded pixels, independently of its declaration. */
+declare function assertTileflowSdfPixels(input: {
+    rgba: Uint8Array;
+    width: number;
+    height: number;
+    pixelRatio: 1 | 2;
+}): void;
+declare const tileflowIconMetadataFileName = "tileflow.icons.json";
+declare const tileflowIconAuthorMetadataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    icons: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        representation: z.ZodLiteral<"rgba">;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodDefault<z.ZodString>;
+            haloWidth: z.ZodDefault<z.ZodNumber>;
+            haloBlur: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+
+type TileflowPreparedIconCapabilities = {
+    ids: readonly string[];
+    appearances?: Readonly<Record<string, TileflowIconAppearance>>;
+};
+/** Admit a compiled style without repairing or changing its signed paint. */
+declare function validateTileflowCompiledIconCapabilities(style: MapLibreStyle, icons: TileflowPreparedIconCapabilities): void;
+
+type TileflowPreparedMapAssets = {
+    icons?: TileflowPreparedIconCapabilities & {
+        ids: readonly string[];
+        sprite: string;
+    };
+};
+type TileflowSemanticCompileOptions = {
+    apiBaseUrl?: string;
+    /** Resolved authoring identity. Internal build orchestration supplies this. */
+    map?: {
+        id: string;
+        lineage?: readonly string[];
+        version: number;
+    };
+    /** Build-owned assets prepared from the authoring directories. */
+    preparedAssets?: TileflowPreparedMapAssets;
+    /** Concrete named theme. Omission deterministically selects map.defaultTheme. */
+    theme?: string;
+};
+type TileflowSemanticCompilationOptions = TileflowSemanticCompileOptions & {
+    /** Include opt-in read-only physical diagnostics; emitted IDs are not authoring targets. */
+    inspection?: boolean;
+};
+
+type TileflowStyleOptions = TileflowSemanticCompileOptions;
+type TileflowCompilationOptions = TileflowSemanticCompilationOptions;
+declare function createStyle(config: TileflowMap, options?: TileflowStyleOptions): MapLibreStyle;
+/** Resolve and compile one map without throwing, returning deterministic compiler diagnostics. */
+declare function createStyleResult(config: TileflowMap, options?: TileflowCompilationOptions): TileflowCompilationResult;
+declare function collectMapLineage(map: TileflowMap): string[];
+/** Resolve and validate one public authoring map before asset preparation or compilation. */
+declare function parseTileflowMap(map: TileflowMap): ResolvedTileflowMap;
+/** Validate one singular authoring map, including its complete extends lineage. */
+declare function validateTileflowMap(input: unknown): ValidationResult;
+
+declare const tileflowIconCompositionMaximumBytes: number;
+declare const tileflowRenderedIconIdentitySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rendered-icon">;
+    id: z.ZodString;
+    appearance: z.ZodOptional<z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodString;
+            haloWidth: z.ZodNumber;
+            haloBlur: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    layout: z.ZodOptional<z.ZodObject<{
+        stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strict>>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    pixelSha256: z.ZodObject<{
+        oneX: z.ZodString;
+        twoX: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type TileflowRenderedIconIdentity = z.infer<typeof tileflowRenderedIconIdentitySchema>;
+declare const tileflowIconCompositionSchema: z.ZodObject<{
+    format: z.ZodEnum<{
+        'tileflow-icon-composition-v1': "tileflow-icon-composition-v1";
+        'tileflow-icon-composition-v2': "tileflow-icon-composition-v2";
+    }>;
+    compositionVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    packageHash: z.ZodString;
+    contributors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"local">;
+        iconIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"package">;
+        package: z.ZodString;
+        iconIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"icon-set">;
+        reference: z.ZodString;
+        teamId: z.ZodString;
+        setId: z.ZodString;
+        versionId: z.ZodString;
+        version: z.ZodNumber;
+        packageId: z.ZodString;
+        contentHash: z.ZodString;
+        iconIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+    winners: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+        appearance: z.ZodOptional<z.ZodObject<{
+            representation: z.ZodLiteral<"sdf">;
+            defaults: z.ZodObject<{
+                color: z.ZodString;
+                haloColor: z.ZodString;
+                haloWidth: z.ZodNumber;
+                haloBlur: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        pixelSha256: z.ZodObject<{
+            oneX: z.ZodString;
+            twoX: z.ZodString;
+        }, z.core.$strict>;
+        contributor: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type TileflowIconCompositionV1 = z.infer<typeof tileflowIconCompositionSchema>;
+type TileflowIconContributorIdentity = TileflowIconCompositionV1['contributors'][number];
+declare function parseTileflowIconComposition(input: unknown): TileflowIconCompositionV1;
+/** Dependency identity is separate from the generated artifact's content hash. */
+declare function hashTileflowIconComposition(input: TileflowIconCompositionV1): Promise<string>;
+
+export { type TileflowAuthoringModules as $, type OpenMapTilesLayerBindings as A, tileflowCompilationPhases as B, tileflowCompilationPlannerStages as C, tileflowCompilationReportSchemaVersion as D, type TileflowSemanticModuleName as E, tileflowHostedSourceLimit as F, tileflowOverlayPlacements as G, type TileflowIconSource as H, type OpenMapTilesSchema as I, type OpenMapTilesSchemaOptions as J, type ResolvedBathymetry as K, type ResolvedBathymetryRelief as L, type ResolvedMarine as M, type ResolvedMarineSource as N, type OpenMapTilesFieldBindings as O, type ParkLayerSemantics as P, type ResolvedTileflowData as Q, type ResolvedTileflowMap as R, type ResolvedTileflowTheme as S, type TileflowRenderedIconIdentity as T, type ResolvedTileflowThemeTokens as U, type TileflowAddressesModuleConfig as V, type TileflowAddressesModuleOptions as W, type TileflowAerowaysModuleConfig as X, type TileflowAerowaysModuleOptions as Y, type TileflowAtmosphere as Z, type TileflowAtmosphereOptions as _, type TileflowIconCompositionV1 as a, type TileflowRasterDemSourceRequirementV1 as a$, type TileflowBathymetryConfig as a0, type TileflowBathymetryDemSourceIdentity as a1, type TileflowBathymetryDisplay as a2, type TileflowBathymetryOptions as a3, type TileflowBathymetryReliefConfig as a4, type TileflowBoundariesModuleConfig as a5, type TileflowBoundariesModuleOptions as a6, type TileflowBuildingMode as a7, type TileflowBuildingsModuleConfig as a8, type TileflowBuildingsModuleOptions as a9, type TileflowLandModuleOptions as aA, type TileflowLandcoverClass as aB, type TileflowLandformClass as aC, type TileflowLandformsModuleConfig as aD, type TileflowLandformsModuleOptions as aE, type TileflowLanduseClass as aF, type TileflowLayerBand as aG, type TileflowLocalDirectory as aH, type TileflowMapDesign as aI, type TileflowMapIdentity as aJ, type TileflowMapLibreOverlay as aK, type TileflowMapLibreOverlayLayer as aL, type TileflowMapTooling as aM, type TileflowMarine as aN, type TileflowMarineConfig as aO, type TileflowMarineMode as aP, type TileflowMarineSourceConfig as aQ, type TileflowMarineSourceIdentity as aR, type TileflowModuleOperation as aS, type TileflowModulePatch as aT, type TileflowNauticalAreaLabelStyles as aU, type TileflowNauticalModuleConfig as aV, type TileflowNauticalModuleOptions as aW, type TileflowOverlayCollection as aX, type TileflowOverlayPlacement as aY, type TileflowPackageDirectory as aZ, type TileflowPreparedIconCapabilities as a_, type TileflowCompilationDiagnostic as aa, type TileflowCompilationDomainReport as ab, type TileflowCompilationFailure as ac, type TileflowCompilationOptions as ad, type TileflowCompilationPhase as ae, type TileflowCompilationPlannerDecision as af, type TileflowCompilationPlannerStage as ag, type TileflowCompilationReport as ah, type TileflowCompilationResult as ai, type TileflowCompilationSuccess as aj, type TileflowDataConfig as ak, type TileflowDataIdentity as al, type TileflowDerivedMap as am, type TileflowDisableOperation as an, type TileflowFontDirectory as ao, type TileflowGlyphs as ap, type TileflowHostedSourceCollection as aq, type TileflowHostedTilesetSource as ar, type TileflowHostedTilesetType as as, type TileflowIconContributorIdentity as at, type TileflowIconDirectory as au, TileflowIconSetError as av, type TileflowIconSetErrorCode as aw, type TileflowIconSetReference as ax, type TileflowIconSetSource as ay, type TileflowLandModuleConfig as az, type TileflowDataRequirementsV1 as b, parseTileflowIconComposition as b$, type TileflowRefineOperation as b0, type TileflowRemoveOperation as b1, type TileflowReset as b2, type TileflowResolvedThemeSelection as b3, type TileflowSemanticModules as b4, type TileflowStandaloneMap as b5, type TileflowTheme as b6, type TileflowThemeAuditContext as b7, type TileflowThemeAuditDiagnostic as b8, TileflowThemeAuditError as b9, assertTileflowMapThemeValues as bA, assertTileflowSdfPixels as bB, auditTileflowMapThemeValues as bC, auditTileflowThemeValues as bD, bathymetry as bE, boundaries as bF, buildings as bG, classifyTileflowVisualProperty as bH, collectTileflowIconSetReferences as bI, createStyle as bJ, createStyleResult as bK, defineTheme as bL, disable as bM, hashTileflowIconComposition as bN, hostedTileset as bO, iconSet as bP, isCanonicalOpenMapTilesSchema as bQ, isSafeLocalPmtilesPath as bR, isTileflowCompilationPhase as bS, isTileflowIconSetSource as bT, isTileflowLocalDirectory as bU, land as bV, landforms as bW, maplibreOverlay as bX, nautical as bY, openMapTiles as bZ, openMapTilesContractVersion as b_, type TileflowThemeAuditScope as ba, type TileflowThemeColorScheme as bb, type TileflowThemeDefinition as bc, type TileflowThemeLighting as bd, type TileflowThemeName as be, type TileflowThemeTokens as bf, type TileflowThemeTypography as bg, type TileflowThemeTypographyStyle as bh, type TileflowTransitModuleConfig as bi, type TileflowTransitModuleOptions as bj, type TileflowTransitRailStyle as bk, type TileflowVegetationMode as bl, type TileflowVegetationModuleConfig as bm, type TileflowVegetationModuleOptions as bn, type TileflowVegetationThreeDimensionalStyle as bo, type TileflowVisualValueCategory as bp, type TileflowWaterModuleConfig as bq, type TileflowWaterModuleOptions as br, type TileflowWaterwayClass as bs, type TileflowWorldData as bt, type TileflowWorldReleaseReference as bu, type TileflowWorldSelection as bv, type TileflowWorldV1Schema as bw, type VectorTilesData as bx, addresses as by, aeroways as bz, type TileflowSourceRequirementsV1 as c, parseTileflowMap as c0, refine as c1, remove as c2, reset as c3, resolveMarine as c4, resolveThemeSelection as c5, resolveThemeValues as c6, resolveTileflowData as c7, resolveTileflowTheme as c8, tileflowBandPlacements as c9, tileflowWorldGeneration as cA, tileflowWorldTileJsonUrl as cB, tileflowWorldV1Schema as cC, transit as cD, validateTileflowCompiledIconCapabilities as cE, validateTileflowMap as cF, validateTileflowWorldV1Tilejson as cG, vectorTiles as cH, vegetation as cI, water as cJ, tileflowBathymetryDemSourceId as ca, tileflowBathymetrySourceId as cb, tileflowBathymetryV1Schema as cc, tileflowIconAppearanceSchema as cd, tileflowIconAuthorMetadataSchema as ce, tileflowIconCompositionMaximumBytes as cf, tileflowIconCompositionSchema as cg, tileflowIconMetadataFileName as ch, tileflowIconSetIdSchema as ci, tileflowIconSetPackageIdSchema as cj, tileflowIconSetReferenceSchema as ck, tileflowIconSetSourceSchema as cl, tileflowIconSetTeamIdSchema as cm, tileflowIconSetVersionIdSchema as cn, tileflowIconSourceLimit as co, tileflowLandformClasses as cp, tileflowLayerBands as cq, tileflowLocalDirectoryMaximumLength as cr, tileflowLocalDirectoryMessage as cs, tileflowMapIdSchema as ct, tileflowNauticalSourceId as cu, tileflowNauticalV1Schema as cv, tileflowPrimarySourceId as cw, tileflowRenderedIconIdentitySchema as cx, tileflowThemeLimits as cy, tileflowWorld as cz, type TileflowMap as d, type TileflowStyleOptions as e, type TileflowInspectedStyle as f, type TileflowPreparedMapAssets as g, type TileflowDataCompatibilityIssue as h, type TileflowDataFieldRequirement as i, type TileflowDataFieldType as j, type TileflowDataLayerRequirement as k, type TileflowObservedDataContractV1 as l, type TileflowStyleInspection as m, type TileflowStyleInspectionContribution as n, type TileflowStyleInspectionLayer as o, type TileflowStyleInspectionRenderOperation as p, collectMapLineage as q, inferTileflowDataRequirements as r, inferTileflowSourceRequirements as s, tileflowStyleInspectionSchemaVersion as t, type TileflowMapScene as u, validateTileflowDataCompatibility as v, type ResolveMapOptions as w, type TileflowIconAppearance as x, type TileflowLayerDomain as y, type TileflowBandPlacement as z };