@tileflow/core 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/index.d.ts

@@ -1,11 +1,9 @@
-import { m as TileflowDerivedMap, n as TileflowMapScene, o as TileflowRootMap, T as TileflowMap, p as ResolveMapOptions, R as ResolvedTileflowMap } from './requirements-BV77ZVhR.js';
-export { q as ResolvedBathymetry, r as ResolvedBathymetryRelief, s as ResolvedMarine, t as ResolvedMarineSource, u as ResolvedTileflowTheme, w as ResolvedTileflowThemeTokens, x as TileflowBathymetryConfig, y as TileflowBathymetryDemSourceIdentity, z as TileflowBathymetryDisplay, A as TileflowBathymetryOptions, B as TileflowBathymetryReliefConfig, e as TileflowDataCompatibilityIssue, f as TileflowDataFieldRequirement, g as TileflowDataFieldType, h as TileflowDataLayerRequirement, a as TileflowDataRequirementsV1, C as TileflowFontDirectory, D as TileflowGlyphs, E as TileflowHostedDelivery, F as TileflowIconDirectory, G as TileflowLocalDirectory, H as TileflowMapDelivery, I as TileflowMapDesign, J as TileflowMapIdentity, K as TileflowMapRoot, L as TileflowMapTooling, M as TileflowMarine, N as TileflowMarineConfig, O as TileflowMarineMode, P as TileflowMarineSourceConfig, Q as TileflowMarineSourceIdentity, i as TileflowObservedDataContractV1, S as TileflowPackageDirectory, U as TileflowRasterDemSourceRequirementV1, V as TileflowResolvedThemeSelection, b as TileflowSourceRequirementsV1, c as TileflowStyleOptions, W as TileflowTheme, X as TileflowThemeAuditContext, Y as TileflowThemeAuditDiagnostic, Z as TileflowThemeAuditEffectKind, _ as TileflowThemeAuditError, $ as TileflowThemeAuditScope, a0 as TileflowThemeColorScheme, a1 as TileflowThemeDefinition, a2 as TileflowThemeLighting, a3 as TileflowThemeName, a4 as TileflowThemeTokens, a5 as TileflowThemeTypography, a6 as TileflowThemeTypographyStyle, a7 as assertTileflowMapThemeValues, a8 as auditTileflowMapThemeValues, a9 as auditTileflowThemeValues, aa as bathymetry, ab as createStyle, ac as defineTheme, k as inferTileflowDataRequirements, l as inferTileflowSourceRequirements, ad as isTileflowLocalDirectory, ae as parseTileflowMap, af as resolveMarine, ag as resolveThemeSelection, ah as resolveThemeValues, ai as resolveTileflowTheme, aj as tileflowBathymetryDemSourceId, ak as tileflowBathymetrySourceId, al as tileflowBathymetryV1Schema, am as tileflowLocalDirectoryMaximumLength, an as tileflowLocalDirectoryMessage, ao as tileflowMapIdSchema, ap as tileflowNauticalSourceId, aq as tileflowNauticalV1Schema, v as validateTileflowDataCompatibility, ar as validateTileflowMap } from './requirements-BV77ZVhR.js';
-import { n as ValidationMessage, M as MapLibreStyle, o as TileflowRoadsModuleOptions, p as TileflowRoadsModuleConfig, q as TileflowLabelsModuleOptions, r as TileflowLabelsModuleConfig, s as TileflowPoiModuleOptions, u as TileflowPoiModuleConfig } from './types-DlUGI6LC.js';
-export { v as MapLibreSprite, w as TileflowAerodromeCodeDetail, x as TileflowAlignment, y as TileflowAreaStyle, z as TileflowBackgroundPaint, A as TileflowBackgroundStyle, B as TileflowCirclePaint, C as TileflowCircleStyle, D as TileflowColor, E as TileflowColorStyleValue, F as TileflowExpression, G as TileflowExtrusionPaint, H as TileflowExtrusionStyle, I as TileflowFillPaint, a as TileflowFillStyle, J as TileflowFilterExpression, K as TileflowFixedValue, L as TileflowIconAnchor, N as TileflowIconLayout, O as TileflowIconPaint, P as TileflowIconStyle, Q as TileflowIconTextFit, S as TileflowImageStyleValue, U as TileflowLabelDetail, W as TileflowLabelLanguage, X as TileflowLabelStyles, Y as TileflowLayerRange, k as TileflowLight, Z as TileflowLineCap, _ as TileflowLineHatchStyle, $ as TileflowLineJoin, a0 as TileflowLineLayout, a1 as TileflowLinePaint, a2 as TileflowLineStackStyle, b as TileflowLineStyle, a3 as TileflowMountainBikeScale, a4 as TileflowNumberInsetsStyleValue, a5 as TileflowNumberStyleValue, a6 as TileflowPlaceLabelClass, a7 as TileflowPoiCategory, a8 as TileflowPoiCategoryStyle, a9 as TileflowPoiColorMode, aa as TileflowPoiDensity, l as TileflowProjection, ab as TileflowRoadAreaStyle, ac as TileflowRoadClass, ad as TileflowRoadClassStyle, ae as TileflowRoadCrossingStyle, af as TileflowRoadDetail, ag as TileflowRoadExtras, ah as TileflowRoadHierarchy, ai as TileflowRoadLabelDetail, aj as TileflowRoadLayerStyle, ak as TileflowRoadModifier, al as TileflowRoadOutline, am as TileflowRoadRestriction, an as TileflowRoadRoundaboutStyle, ao as TileflowRoadServiceType, ap as TileflowRoadShieldDetail, aq as TileflowRoadShieldStyles, ar as TileflowRoadSidewalkStyle, as as TileflowRoadStructure, at as TileflowRoadTreatmentLayerStyle, au as TileflowRoadTreatmentLineStyle, av as TileflowRoadTreatmentStyle, aw as TileflowRoadWeight, ax as TileflowStringStyleValue, ay as TileflowStructuralStyleValue, az as TileflowStyleValue, aA as TileflowSymbolPlacement, aB as TileflowSymbolPlacementStyle, c as TileflowSymbolStyle, aC as TileflowSymbolZOrder, m as TileflowTerrain, aD as TileflowTerrainConfig, aE as TileflowTerrainContourLabelStyle, aF as TileflowTerrainContourLineStyle, aG as TileflowTerrainContoursConfig, e as TileflowTerrainEncoding, d as TileflowTerrainHillshadeStyle, aH as TileflowTerrainLayerRange, aI as TileflowTerrainMode, aJ as TileflowTextAnchor, aK as TileflowTextJustify, aL as TileflowTextLayout, aM as TileflowTextPaint, aN as TileflowTextStyle, aO as TileflowThemeColorAlpha, aP as TileflowThemeColorMix, aQ as TileflowThemeColorOperation, g as TileflowThemeColorValue, h as TileflowThemeFontValue, i as TileflowThemeImageValue, f as TileflowThemeNumberValue, aR as TileflowThemeTokenCategory, aS as TileflowThemeTokenReference, aT as TileflowThemeValue, T as TileflowViewConfig, aU as TileflowWaterLabelClass, aV as TileflowZoomInterpolation, aW as TileflowZoomValue, V as ValidationResult, aX as color, aY as expression, aZ as filter, a_ as fixed, a$ as tileflowPoiCategories, b0 as token, b1 as zoom } from './types-DlUGI6LC.js';
+import { b as TileflowMap, r as TileflowMapScene, s as ResolveMapOptions, R as ResolvedTileflowMap, O as OpenMapTilesFieldBindings, u as TileflowLayerDomain, w as OpenMapTilesLayerBindings, x as tileflowCompilationPhases, y as tileflowCompilationPlannerStages, z as tileflowCompilationReportSchemaVersion, A as TileflowSemanticModuleName, B as tileflowHostedSourceLimit, C as tileflowOverlayPlacements } from './map-BHL_0Mkx.js';
+export { D as OpenMapTilesSchema, E as OpenMapTilesSchemaOptions, P as ParkLayerSemantics, F as ResolvedBathymetry, G as ResolvedBathymetryRelief, H as ResolvedMarine, I as ResolvedMarineSource, J as ResolvedTileflowData, K as ResolvedTileflowTheme, L as ResolvedTileflowThemeTokens, M as TileflowAddressesModuleConfig, N as TileflowAddressesModuleOptions, Q as TileflowAerowaysModuleConfig, S as TileflowAerowaysModuleOptions, U as TileflowAuthoringModules, V as TileflowBathymetryConfig, W as TileflowBathymetryDemSourceIdentity, X as TileflowBathymetryDisplay, Y as TileflowBathymetryOptions, Z as TileflowBathymetryReliefConfig, _ as TileflowBoundariesModuleConfig, $ as TileflowBoundariesModuleOptions, a0 as TileflowBuildingMode, a1 as TileflowBuildingsModuleConfig, a2 as TileflowBuildingsModuleOptions, a3 as TileflowCompilationDiagnostic, a4 as TileflowCompilationDomainReport, a5 as TileflowCompilationFailure, a6 as TileflowCompilationOptions, a7 as TileflowCompilationPhase, a8 as TileflowCompilationPlannerDecision, a9 as TileflowCompilationPlannerStage, aa as TileflowCompilationReport, ab as TileflowCompilationResult, ac as TileflowCompilationSuccess, f as TileflowDataCompatibilityIssue, ad as TileflowDataConfig, g as TileflowDataFieldRequirement, h as TileflowDataFieldType, ae as TileflowDataIdentity, i as TileflowDataLayerRequirement, T as TileflowDataRequirementsV1, af as TileflowDerivedMap, ag as TileflowDisableOperation, ah as TileflowFontDirectory, ai as TileflowGlyphs, aj as TileflowHostedSourceCollection, ak as TileflowHostedTilesetSource, al as TileflowHostedTilesetType, am as TileflowIconDirectory, an as TileflowLandModuleConfig, ao as TileflowLandModuleOptions, ap as TileflowLandcoverClass, aq as TileflowLandformClass, ar as TileflowLandformsModuleConfig, as as TileflowLandformsModuleOptions, at as TileflowLanduseClass, au as TileflowLocalDirectory, av as TileflowMapDesign, aw as TileflowMapIdentity, ax as TileflowMapLibreOverlay, ay as TileflowMapLibreOverlayLayer, az as TileflowMapTooling, aA as TileflowMarine, aB as TileflowMarineConfig, aC as TileflowMarineMode, aD as TileflowMarineSourceConfig, aE as TileflowMarineSourceIdentity, aF as TileflowModuleOperation, aG as TileflowModulePatch, aH as TileflowNauticalAreaLabelStyles, aI as TileflowNauticalModuleConfig, aJ as TileflowNauticalModuleOptions, j as TileflowObservedDataContractV1, aK as TileflowOverlayCollection, aL as TileflowOverlayPlacement, aM as TileflowPackageDirectory, aN as TileflowRasterDemSourceRequirementV1, aO as TileflowRefineOperation, aP as TileflowRemoveOperation, aQ as TileflowReset, aR as TileflowResolvedThemeSelection, aS as TileflowSemanticModules, a as TileflowSourceRequirementsV1, aT as TileflowStandaloneMap, c as TileflowStyleOptions, aU as TileflowTheme, aV as TileflowThemeAuditContext, aW as TileflowThemeAuditDiagnostic, aX as TileflowThemeAuditError, aY as TileflowThemeAuditScope, aZ as TileflowThemeColorScheme, a_ as TileflowThemeDefinition, a$ as TileflowThemeLighting, b0 as TileflowThemeName, b1 as TileflowThemeTokens, b2 as TileflowThemeTypography, b3 as TileflowThemeTypographyStyle, b4 as TileflowTransitModuleConfig, b5 as TileflowTransitModuleOptions, b6 as TileflowTransitRailStyle, b7 as TileflowVegetationMode, b8 as TileflowVegetationModuleConfig, b9 as TileflowVegetationModuleOptions, ba as TileflowVegetationThreeDimensionalStyle, bb as TileflowVisualValueCategory, bc as TileflowWaterModuleConfig, bd as TileflowWaterModuleOptions, be as TileflowWaterwayClass, bf as TileflowWorldData, bg as TileflowWorldReleaseReference, bh as TileflowWorldSelection, bi as TileflowWorldV1Schema, bj as VectorTilesData, bk as addresses, bl as aeroways, bm as assertTileflowMapThemeValues, bn as auditTileflowMapThemeValues, bo as auditTileflowThemeValues, bp as bathymetry, bq as boundaries, br as buildings, bs as classifyTileflowVisualProperty, bt as createStyle, bu as createStyleResult, bv as defineTheme, bw as disable, bx as hostedTileset, p as inferTileflowDataRequirements, q as inferTileflowSourceRequirements, by as isCanonicalOpenMapTilesSchema, bz as isSafeLocalPmtilesPath, bA as isTileflowCompilationPhase, bB as isTileflowLocalDirectory, bC as land, bD as landforms, bE as maplibreOverlay, bF as nautical, bG as openMapTiles, bH as openMapTilesContractVersion, bI as parseTileflowMap, bJ as refine, bK as remove, bL as reset, bM as resolveMarine, bN as resolveThemeSelection, bO as resolveThemeValues, bP as resolveTileflowData, bQ as resolveTileflowTheme, bR as tileflowBathymetryDemSourceId, bS as tileflowBathymetrySourceId, bT as tileflowBathymetryV1Schema, bU as tileflowLandformClasses, bV as tileflowLocalDirectoryMaximumLength, bW as tileflowLocalDirectoryMessage, bX as tileflowMapIdSchema, bY as tileflowNauticalSourceId, bZ as tileflowNauticalV1Schema, b_ as tileflowPrimarySourceId, b$ as tileflowThemeLimits, c0 as tileflowWorld, c1 as tileflowWorldGeneration, c2 as tileflowWorldTileJsonUrl, c3 as tileflowWorldV1Schema, c4 as transit, v as validateTileflowDataCompatibility, c5 as validateTileflowMap, c6 as validateTileflowWorldV1Tilejson, c7 as vectorTiles, c8 as vegetation, c9 as water } from './map-BHL_0Mkx.js';
+import { V as ValidationMessage, a as TileflowExpression, b as TileflowFixedValue, c as TileflowThemeTokenReference, d as TileflowThemeColorOperation, e as TileflowBackgroundStyle, f as TileflowCircleStyle, g as TileflowExtrusionStyle, h as TileflowFillStyle, i as TileflowLineStyle, j as TileflowSymbolStyle, M as MapLibreStyle, k as TileflowRoadsModuleOptions, l as TileflowRoadsModuleConfig, m as TileflowLabelsModuleOptions, n as TileflowLabelsModuleConfig, o as TileflowPoiModuleOptions, p as TileflowPoiModuleConfig } from './manifest-B5GKVMFE.js';
+export { q as MapLibreSprite, r as TileflowAerodromeCodeDetail, s as TileflowAlignment, t as TileflowAnalytics, u as TileflowAreaStyle, v as TileflowBackgroundPaint, w as TileflowCirclePaint, x as TileflowColor, y as TileflowColorStyleValue, z as TileflowExtrusionPaint, A as TileflowFillPaint, B as TileflowIconAnchor, C as TileflowIconLayout, D as TileflowIconPaint, E as TileflowIconStyle, F as TileflowIconTextFit, G as TileflowImageStyleValue, H as TileflowLabelDetail, I as TileflowLabelLanguage, J as TileflowLabelStyles, K as TileflowLayerRange, L as TileflowLight, N as TileflowLineCap, O as TileflowLineHatchStyle, P as TileflowLineJoin, Q as TileflowLineLayout, R as TileflowLinePaint, S as TileflowLineStackStyle, U as TileflowManifestFetchOptions, W as TileflowManifestLoadOptions, X as TileflowMapMode, Y as TileflowMapModeOptions, Z as TileflowMarkerSymbolStyle, _ as TileflowMountainBikeScale, $ as TileflowNumberInsetsStyleValue, a0 as TileflowNumberStyleValue, a1 as TileflowPlaceLabelClass, a2 as TileflowPoiCategory, a3 as TileflowPoiCategoryStyle, a4 as TileflowPoiColorMode, a5 as TileflowPoiDensity, a6 as TileflowPriorityOrder, a7 as TileflowProjection, a8 as TileflowResolvedRuntimeTheme, a9 as TileflowRoadAreaStyle, aa as TileflowRoadClass, ab as TileflowRoadClassStyle, ac as TileflowRoadCrossingStyle, ad as TileflowRoadDetail, ae as TileflowRoadExtras, af as TileflowRoadHierarchy, ag as TileflowRoadLabelDetail, ah as TileflowRoadLayerStyle, ai as TileflowRoadModifier, aj as TileflowRoadOutline, ak as TileflowRoadRestriction, al as TileflowRoadRoundaboutStyle, am as TileflowRoadServiceType, an as TileflowRoadShieldDetail, ao as TileflowRoadShieldStyles, ap as TileflowRoadSidewalkStyle, aq as TileflowRoadStructure, ar as TileflowRoadTreatmentLayerStyle, as as TileflowRoadTreatmentLineStyle, at as TileflowRoadTreatmentStyle, au as TileflowRoadWeight, av as TileflowRuntimeCenterLike, aw as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, ax as TileflowRuntimeManifestMap, ay as TileflowRuntimeManifestMapEntry, az as TileflowRuntimeManifestTheme, aA as TileflowRuntimeSource, aB as TileflowRuntimeSourceValidation, aC as TileflowRuntimeStyle, aD as TileflowRuntimeStyleOptions, aE as TileflowRuntimeSystemThemes, aF as TileflowRuntimeViewOptions, aG as TileflowSessionController, aH as TileflowSessionGrantResponse, aI as TileflowStringStyleValue, aJ as TileflowStructuralStyleValue, aK as TileflowStyleFontFace, aL as TileflowStyleValue, aM as TileflowSymbolPlacement, aN as TileflowSymbolPlacementStyle, aO as TileflowSymbolZOrder, aP as TileflowTerrain, aQ as TileflowTerrainConfig, aR as TileflowTerrainContourLabelStyle, aS as TileflowTerrainContourLineStyle, aT as TileflowTerrainContoursConfig, aU as TileflowTerrainEncoding, aV as TileflowTerrainHillshadeStyle, aW as TileflowTerrainLayerRange, aX as TileflowTerrainMode, aY as TileflowTextAnchor, aZ as TileflowTextJustify, a_ as TileflowTextLayout, a$ as TileflowTextPaint, b0 as TileflowTextStyle, b1 as TileflowThemeColorAlpha, b2 as TileflowThemeColorMix, b3 as TileflowThemeColorValue, b4 as TileflowThemeFontValue, b5 as TileflowThemeImageValue, b6 as TileflowThemeNumberValue, b7 as TileflowThemeSelection, b8 as TileflowThemeTokenCategory, b9 as TileflowThemeValue, ba as TileflowViewConfig, bb as TileflowWaterLabelClass, bc as TileflowZoomInterpolation, bd as TileflowZoomValue, be as ValidationResult, bf as assertValidTileflowRuntimeSource, bg as clearTileflowManifestCache, bh as color, bi as createTileflowSessionController, bj as createTileflowSessionId, bk as defaultTileflowManifestUrl, bl as defaultTileflowRuntimeView, bm as fixed, bn as getTileflowAnalyticsApiUrl, bo as getTileflowStyleFontFaces, bp as inferTileflowAnalyticsFromStyleUrl, bq as loadTileflowManifest, br as mergeTileflowAnalytics, bs as normalizeTileflowRuntimeCenter, bt as normalizeTileflowStaticImageSize, bu as normalizeTileflowUrl, bv as parseTileflowRuntimeManifest, bw as resolveTileflowAnalyticsRequestUrl, bx as resolveTileflowManifestMap, by as resolveTileflowMapMode, bz as resolveTileflowRuntimeStyle, bA as resolveTileflowRuntimeTheme, bB as resolveTileflowRuntimeView, bC as resolveTileflowStaticImageUrl, bD as safeParseTileflowRuntimeManifest, bE as shouldLoadTileflowManifest, bF as startTileflowSession, bG as tileflowPoiCategories, bH as tileflowRuntimeManifestLimits, bI as tileflowRuntimeManifestSchema, bJ as tileflowRuntimeManifestVersion, bK as tileflowStyleFontFaceLimits, bL as tileflowStyleFontFacesMetadataKey, bM as tileflowThemeTokenCategories, bN as token, bO as validateTileflowRuntimeSource, bP as validateTileflowThemeSelection, bQ as zoom } from './manifest-B5GKVMFE.js';
 export { N as NormalizedTileflowCaptureScene, a as TileflowCaptureApplicationTarget, b as TileflowCaptureBoundsCamera, c as TileflowCaptureCamera, d as TileflowCaptureCenterCamera, e as TileflowCaptureMapTarget, T as TileflowCaptureScene, f as TileflowCaptureTarget, g as TileflowCaptureViewport, n as normalizeTileflowCaptureId, h as normalizeTileflowCaptureScene, t as tileflowCaptureApplicationTargetSchema, i as tileflowCaptureBoundsCameraSchema, j as tileflowCaptureCameraSchema, k as tileflowCaptureCenterCameraSchema, l as tileflowCaptureIdSchema, m as tileflowCaptureMapTargetSchema, o as tileflowCaptureSceneLimits, p as tileflowCaptureSceneNameSchema, q as tileflowCaptureSceneSchema, r as tileflowCaptureSceneSchemaVersion, s as tileflowCaptureTargetSchema, u as tileflowCaptureViewportSchema } from './capture-scene-BK_0J2oR.js';
 export { tileflowPortableIdSchema, tileflowThemeNameSchema } from './capture.js';
-export { T as TileflowAnalytics, f as TileflowManifestFetchOptions, g as TileflowManifestLoadOptions, h as TileflowMapMarker, i as TileflowMapMode, j as TileflowMapModeOptions, k as TileflowResolvedRuntimeTheme, l as TileflowRuntimeCenterLike, d as TileflowRuntimeColorScheme, e as TileflowRuntimeManifest, m as TileflowRuntimeManifestMap, n as TileflowRuntimeManifestMapEntry, o as TileflowRuntimeManifestTheme, p as TileflowRuntimeSource, q as TileflowRuntimeSourceValidation, b as TileflowRuntimeStyle, r as TileflowRuntimeStyleOptions, s as TileflowRuntimeSystemThemes, t as TileflowRuntimeViewOptions, c as TileflowSessionController, u as TileflowSessionGrantResponse, a as TileflowStyleFontFace, v as TileflowThemeSelection, w as assertValidTileflowRuntimeSource, x as clearTileflowManifestCache, y as createTileflowSessionController, z as createTileflowSessionId, A as defaultTileflowManifestUrl, B as defaultTileflowRuntimeView, C as getTileflowAnalyticsApiUrl, D as getTileflowStyleFontFaces, E as inferTileflowAnalyticsFromStyleUrl, F as loadTileflowManifest, G as mergeTileflowAnalytics, H as normalizeTileflowRuntimeCenter, I as normalizeTileflowStaticImageSize, J as normalizeTileflowUrl, K as parseTileflowRuntimeManifest, L as resolveTileflowAnalyticsRequestUrl, M as resolveTileflowManifestMap, N as resolveTileflowMapMode, O as resolveTileflowRuntimeStyle, P as resolveTileflowRuntimeTheme, Q as resolveTileflowRuntimeView, R as resolveTileflowStaticImageUrl, S as safeParseTileflowRuntimeManifest, U as shouldLoadTileflowManifest, V as startTileflowSession, W as tileflowRuntimeManifestLimits, X as tileflowRuntimeManifestSchema, Y as tileflowRuntimeManifestVersion, Z as tileflowStyleFontFaceLimits, _ as tileflowStyleFontFacesMetadataKey, $ as validateTileflowRuntimeSource, a0 as validateTileflowThemeSelection } from './runtime-C4MtSzkB.js';
-export { O as OpenMapTilesFieldBindings, a as OpenMapTilesLayerBindings, f as OpenMapTilesSchema, g as OpenMapTilesSchemaOptions, P as ParkLayerSemantics, R as ResolvedTileflowData, h as TileflowAddressesModuleConfig, i as TileflowAddressesModuleOptions, j as TileflowAerowaysModuleConfig, k as TileflowAerowaysModuleOptions, l as TileflowBoundariesModuleConfig, m as TileflowBoundariesModuleOptions, n as TileflowBuildingMode, o as TileflowBuildingsModuleConfig, p as TileflowBuildingsModuleOptions, d as TileflowDataConfig, q as TileflowDataIdentity, r as TileflowLandModuleConfig, s as TileflowLandModuleOptions, t as TileflowLandcoverClass, u as TileflowLandformClass, v as TileflowLandformsModuleConfig, w as TileflowLandformsModuleOptions, x as TileflowLanduseClass, y as TileflowNauticalAreaLabelStyles, z as TileflowNauticalModuleConfig, A as TileflowNauticalModuleOptions, e as TileflowStreetsModules, B as TileflowTransitModuleConfig, C as TileflowTransitModuleOptions, D as TileflowTransitRailStyle, E as TileflowVegetationMode, F as TileflowVegetationModuleConfig, G as TileflowVegetationModuleOptions, H as TileflowVegetationThreeDimensionalStyle, b as TileflowVisualValueCategory, I as TileflowWaterModuleConfig, J as TileflowWaterModuleOptions, K as TileflowWaterwayClass, L as TileflowWorldData, M as TileflowWorldReleaseReference, N as TileflowWorldSelection, Q as TileflowWorldV1Schema, V as VectorTilesData, S as addresses, U as aeroways, W as boundaries, X as buildings, c as classifyTileflowVisualProperty, Y as isCanonicalOpenMapTilesSchema, Z as land, _ as landforms, $ as nautical, a0 as openMapTiles, a1 as openMapTilesContractVersion, a2 as resolveTileflowData, a3 as tileflowLandformClasses, a4 as tileflowPrimarySourceId, a5 as tileflowWorld, a6 as tileflowWorldGeneration, a7 as tileflowWorldTileJsonUrl, a8 as tileflowWorldV1Schema, a9 as transit, aa as validateTileflowWorldV1Tilejson, ab as vectorTiles, ac as vegetation, ad as water } from './visual-semantics-DTC-8Hsb.js';
 import { z } from 'zod';
 
 declare const tileflowPortableIdMaximumLength: 64;
@@ -30,12 +28,17 @@ type ExactTileflowMapScenes<TMap> = TMap extends {
         [TName in keyof TScenes]: ExactTileflowMap<TileflowMapScene, TScenes[TName]>;
     };
 } : unknown;
-/** Preserve the exact inferred type of a compiler-root map. */
-declare function defineRootMap<const TMap extends TileflowRootMap>(map: ExactTileflowMap<TileflowRootMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
-/** Preserve the exact inferred type of a map that extends another map object. */
-declare function defineMap<const TMap extends TileflowDerivedMap>(map: ExactTileflowMap<TileflowDerivedMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
+/** Preserve the exact inferred type of a standalone or inherited semantic map. */
+declare function defineMap<const TMap extends TileflowMap>(map: ExactTileflowMap<TileflowMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
 
 declare const tileflowMapDefaultMaxDepth = 64;
+/** Structured authoring failure surfaced unchanged by validate/explain JSON commands. */
+declare class TileflowMapResolutionError extends Error {
+    readonly code: string;
+    readonly mapId: string;
+    readonly path: string;
+    constructor(code: string, mapId: string, path: string, message: string);
+}
 /** Resolve an imported map lineage to one standalone authoring map. */
 declare function resolveMap(map: TileflowMap, options?: ResolveMapOptions): ResolvedTileflowMap;
 
@@ -46,11 +49,469 @@ declare class TileflowResolvedMapValidationError extends Error {
     readonly phase: "config-validation";
     constructor(name: string, messages: ValidationMessage[]);
 }
+declare function parseResolvedTileflowMap(input: unknown): ResolvedTileflowMap;
+
+/** A schema-bound data field whose physical name is assigned only during compilation. */
+type TileflowDataFieldReference<TName extends keyof OpenMapTilesFieldBindings = keyof OpenMapTilesFieldBindings> = Readonly<{
+    kind: 'tileflow-data-field';
+    name: TName;
+}>;
+type TileflowNumericDataFieldName = 'activityScore' | 'adminLevel' | 'bathymetryMinDepth' | 'bathymetrySortKey' | 'circularClearanceExtraAtZoom15' | 'circularInnerRadiusMeters' | 'circularOuterRadiusMeters' | 'circularRadiusAtZoom15' | 'circularRadiusMeters' | 'classificationConfidence' | 'confidence' | 'circumference' | 'diameterCrown' | 'elevation' | 'elevationFeet' | 'hasBusiness' | 'hasParts' | 'height' | 'hide3d' | 'importanceTier' | 'minHeight' | 'minZoom' | 'oneway' | 'poiFilterRank' | 'poiSizeRank' | 'ramp' | 'rank' | 'refLength' | 'renderHeight' | 'renderMinHeight' | 'renderMinZoom' | 'shieldLineLengthMeters' | 'shieldRank';
+/** Runtime value implied by one registered semantic field, independent of its physical name. */
+type TileflowDataFieldValue<TName extends keyof OpenMapTilesFieldBindings> = TName extends TileflowNumericDataFieldName ? number : string;
+/**
+ * Reference a semantic field in a typed expression without capturing an
+ * OpenMapTiles property name. The active data schema supplies the physical
+ * binding at the final lowering boundary.
+ */
+declare function field<const TName extends keyof OpenMapTilesFieldBindings>(name: TName): TileflowDataFieldReference<TName>;
+
+/** The value a themed authoring node produces after theme resolution. */
+type TileflowDataExpressionResult<T> = T extends TileflowFixedValue<infer TValue> ? TValue : T extends TileflowThemeTokenReference<infer TCategory> ? TCategory extends 'number' ? number : string : T extends TileflowThemeColorOperation ? string : T;
+type TileflowDataExpressionInput<T> = TileflowDataFieldReference | TileflowExpression<T> | T;
+type TileflowDataMatchBranch<TInput extends boolean | number | string, TOutput> = Readonly<{
+    labels: TInput | readonly TInput[];
+    value: TileflowDataExpressionInput<TOutput>;
+}>;
+type TileflowDataCaseBranch<T> = Readonly<{
+    value: TileflowDataExpressionInput<T>;
+    when: TileflowDataExpressionInput<boolean>;
+}>;
+type TileflowDataInterpolation = Readonly<{
+    kind: 'linear';
+}> | Readonly<{
+    base: number;
+    kind: 'exponential';
+}> | Readonly<{
+    kind: 'cubic-bezier';
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+}>;
+type TileflowDataStop<T> = readonly [number, TileflowDataExpressionInput<T>];
+declare const tileflowDataExpressionLimits: Readonly<{
+    readonly maxBranches: 16;
+    readonly maxOperands: 16;
+    readonly maxStops: 16;
+}>;
+declare function get<TName extends TileflowDataFieldReference['name']>(reference: TileflowDataFieldReference<TName>): TileflowExpression<TileflowDataFieldValue<TName>>;
+declare function literal<T>(value: T): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function zoom(): TileflowExpression<number>;
+declare function coalesce<T>(first: TileflowDataExpressionInput<T>, ...rest: readonly TileflowDataExpressionInput<T>[]): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function toNumber(value: TileflowDataExpressionInput<unknown>, fallback?: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function toBoolean(value: TileflowDataExpressionInput<unknown>, fallback?: TileflowDataExpressionInput<boolean>): TileflowExpression<boolean>;
+declare function toString(value: TileflowDataExpressionInput<unknown>): TileflowExpression<string>;
+declare function featureState(name: string): TileflowExpression<unknown>;
+declare function variable<T>(name: string): TileflowExpression<T>;
+declare function letValue<TBinding, TResult>(name: string, value: TileflowDataExpressionInput<TBinding>, body: TileflowDataExpressionInput<TResult>): TileflowExpression<TileflowDataExpressionResult<TResult>>;
+declare function abs(value: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function add(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function subtract(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function divide(dividend: TileflowDataExpressionInput<number>, divisor: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function multiply(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function minimum(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function maximum(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function concat(first: TileflowDataExpressionInput<string>, ...rest: readonly TileflowDataExpressionInput<string>[]): TileflowExpression<string>;
+declare function all(first: TileflowDataExpressionInput<boolean>, ...rest: readonly TileflowDataExpressionInput<boolean>[]): TileflowExpression<boolean>;
+declare function any(first: TileflowDataExpressionInput<boolean>, ...rest: readonly TileflowDataExpressionInput<boolean>[]): TileflowExpression<boolean>;
+declare function not(value: TileflowDataExpressionInput<boolean>): TileflowExpression<boolean>;
+declare function has(reference: TileflowDataFieldReference): TileflowExpression<boolean>;
+declare function match<TInput extends boolean | number | string, TOutput>(input: TileflowDataExpressionInput<TInput>, branches: readonly [
+    TileflowDataMatchBranch<TInput, TOutput>,
+    ...TileflowDataMatchBranch<TInput, TOutput>[]
+], fallback: TileflowDataExpressionInput<TOutput>): TileflowExpression<TileflowDataExpressionResult<TOutput>>;
+declare function caseValue<T>(branches: readonly [TileflowDataCaseBranch<T>, ...TileflowDataCaseBranch<T>[]], fallback: TileflowDataExpressionInput<T>): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function step<T>(input: TileflowDataExpressionInput<number>, fallback: TileflowDataExpressionInput<T>, stops: readonly [TileflowDataStop<T>, ...TileflowDataStop<T>[]]): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function interpolate<T>(interpolation: TileflowDataInterpolation, input: TileflowDataExpressionInput<number>, stops: readonly [TileflowDataStop<T>, ...TileflowDataStop<T>[]]): TileflowExpression<TileflowDataExpressionResult<T>>;
+/**
+ * Closed, typed data-expression builders. They preserve semantic field refs
+ * and lower to byte-equivalent MapLibre expressions only inside the compiler.
+ */
+declare const expr: Readonly<{
+    abs: typeof abs;
+    add: typeof add;
+    all: typeof all;
+    any: typeof any;
+    case: typeof caseValue;
+    coalesce: typeof coalesce;
+    concat: typeof concat;
+    divide: typeof divide;
+    eq: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    get: typeof get;
+    gt: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    gte: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    has: typeof has;
+    featureState: typeof featureState;
+    interpolate: typeof interpolate;
+    let: typeof letValue;
+    literal: typeof literal;
+    lt: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    lte: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    match: typeof match;
+    max: typeof maximum;
+    min: typeof minimum;
+    multiply: typeof multiply;
+    ne: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    not: typeof not;
+    step: typeof step;
+    subtract: typeof subtract;
+    toBoolean: typeof toBoolean;
+    toNumber: typeof toNumber;
+    toString: typeof toString;
+    var: typeof variable;
+    zoom: typeof zoom;
+}>;
+
+declare const tileflowRenderStackPhases: readonly ["underlay", "overlay", "postRelief", "annotation", "finish"];
+declare const tileflowRenderStackRenderers: readonly ["background", "circle", "extrusion", "fill", "line", "symbol"];
+declare const tileflowRenderSelectorKinds: readonly ["all", "any", "compare", "geometry", "has", "in", "literal", "match", "not", "step"];
+declare const tileflowRenderSelectorComparisons: readonly ["eq", "gt", "gte", "lt", "lte", "ne"];
+declare const tileflowRenderSelectorGeometries: readonly ["line", "point", "polygon"];
+declare const tileflowRenderStackLimits: Readonly<{
+    readonly maxMatchBranches: 16;
+    readonly maxOperations: 64;
+    readonly maxRequirements: number;
+    readonly maxScalarValues: 16;
+    readonly maxSelectorChildren: 16;
+    readonly maxSelectorDepth: 64;
+    readonly maxSelectorNodes: 256;
+    readonly maxStepStops: 16;
+}>;
+type TileflowRenderStackPhase = (typeof tileflowRenderStackPhases)[number];
+type TileflowRenderFeature = keyof OpenMapTilesLayerBindings;
+type TileflowRenderField = keyof OpenMapTilesFieldBindings;
+type TileflowRenderScalar = boolean | number | string;
+type TileflowRenderGeometry = (typeof tileflowRenderSelectorGeometries)[number];
+type TileflowRenderComparison = (typeof tileflowRenderSelectorComparisons)[number];
+type TileflowNormalizedRenderField = {
+    /** Convert the bound field before comparing it. */
+    readonly coerce?: 'number';
+    /** Coalesced value, or the numeric conversion fallback when `coerce` is `number`. */
+    readonly fallback?: TileflowRenderScalar;
+    readonly field: TileflowRenderField;
+};
+type TileflowRenderSelector = {
+    readonly kind: 'all' | 'any';
+    readonly selectors: readonly TileflowRenderSelector[];
+} | (TileflowNormalizedRenderField & {
+    readonly kind: 'compare';
+    readonly operator: TileflowRenderComparison;
+    readonly value: TileflowRenderScalar;
+}) | {
+    readonly geometry: TileflowRenderGeometry;
+    readonly kind: 'geometry';
+} | {
+    readonly field: TileflowRenderField;
+    readonly kind: 'has';
+} | (TileflowNormalizedRenderField & {
+    readonly kind: 'in';
+    readonly values: readonly TileflowRenderScalar[];
+}) | {
+    readonly kind: 'literal';
+    readonly value: boolean;
+} | (TileflowNormalizedRenderField & {
+    readonly branches: readonly {
+        readonly result: boolean;
+        readonly values: readonly TileflowRenderScalar[];
+    }[];
+    readonly kind: 'match';
+    readonly otherwise: boolean;
+}) | {
+    readonly kind: 'not';
+    readonly selector: TileflowRenderSelector;
+} | {
+    readonly fallback: TileflowRenderSelector;
+    readonly kind: 'step';
+    readonly stops: readonly {
+        readonly selector: TileflowRenderSelector;
+        readonly zoom: number;
+    }[];
+};
+type TileflowRenderVisibilityGroup = 'building';
+type TileflowRenderStyle<TStyle> = TStyle & {
+    /** Runtime-controlled group; hidden initially and toggled without raw metadata authoring. */
+    readonly visibilityGroup?: TileflowRenderVisibilityGroup;
+};
+type TileflowRenderPassCommon = {
+    readonly attachTo: string;
+    readonly phase: TileflowRenderStackPhase;
+    /** Additional rendered domains required by this pass. Data `feature` bindings are independent. */
+    readonly requirements?: readonly TileflowLayerDomain[];
+};
+type TileflowVectorRenderPass<TRenderer extends string, TStyle> = TileflowRenderPassCommon & {
+    readonly feature?: TileflowRenderFeature;
+    readonly renderer: TRenderer;
+    readonly selector?: TileflowRenderSelector;
+    readonly style: TileflowRenderStyle<TStyle>;
+};
+type TileflowRenderPassInput = (TileflowRenderPassCommon & {
+    readonly feature?: never;
+    readonly renderer: 'background';
+    readonly selector?: never;
+    readonly style: TileflowRenderStyle<TileflowBackgroundStyle>;
+}) | TileflowVectorRenderPass<'circle', TileflowCircleStyle> | TileflowVectorRenderPass<'extrusion', TileflowExtrusionStyle> | TileflowVectorRenderPass<'fill', TileflowFillStyle> | TileflowVectorRenderPass<'line', TileflowLineStyle> | TileflowVectorRenderPass<'symbol', TileflowSymbolStyle>;
+type TileflowRenderPass = TileflowRenderPassInput & {
+    readonly kind: 'render-pass';
+};
+type TileflowRefinementCommon<TRenderer extends string, TStyle> = {
+    /** Rendered domains required for this refinement's semantic target to exist. */
+    readonly requirements?: readonly TileflowLayerDomain[];
+    readonly renderer: TRenderer;
+    readonly selector?: TileflowRenderSelector;
+    readonly style: TileflowRenderStyle<TStyle>;
+    readonly target: string;
+};
+type TileflowRenderTargetRefinementInput = (Omit<TileflowRefinementCommon<'background', TileflowBackgroundStyle>, 'selector'> & {
+    readonly selector?: never;
+}) | TileflowRefinementCommon<'circle', TileflowCircleStyle> | TileflowRefinementCommon<'extrusion', TileflowExtrusionStyle> | TileflowRefinementCommon<'fill', TileflowFillStyle> | TileflowRefinementCommon<'line', TileflowLineStyle> | TileflowRefinementCommon<'symbol', TileflowSymbolStyle>;
+type TileflowRenderTargetRefinement = TileflowRenderTargetRefinementInput & {
+    readonly kind: 'refine-render-target';
+};
+type TileflowRenderStackOperation = TileflowRenderPass | TileflowRenderTargetRefinement;
+type TileflowNamedRenderStack = Readonly<Record<string, TileflowRenderStackOperation>>;
+type TileflowModuleWithRenderStack<TModule extends {
+    readonly type: TileflowLayerDomain;
+}, TStack extends TileflowNamedRenderStack> = TModule & {
+    readonly renderStack: TStack;
+};
+/** Define one ownerless render pass. Its owner and stable name are assigned by `withRenderStack`. */
+declare function renderPass(input: TileflowRenderPassInput): TileflowRenderPass;
+/** Define an owner-local refinement without exposing a raw layer patch. */
+declare function refineRenderTarget(input: TileflowRenderTargetRefinementInput): TileflowRenderTargetRefinement;
+/** Attach a named render stack while retaining the module's exact inferred owner and options. */
+declare function withRenderStack<const TModule extends {
+    readonly type: TileflowLayerDomain;
+}, const TStack extends TileflowNamedRenderStack>(module: TModule & {
+    readonly renderStack?: never;
+}, namedRecord: TStack): TileflowModuleWithRenderStack<TModule, TStack>;
+
+/** Internal compiler identity. Authoring maps never select or version this implementation. */
+declare const tileflowSemanticCompilerIdentity: Readonly<{
+    readonly name: "tileflow-semantic";
+    readonly version: 1;
+}>;
+
+declare const tileflowAuthoringManifestSchemaVersion: 2;
+type TileflowAuthoringCommandName = 'explain' | 'inspect' | 'language-manifest' | 'language-schema' | 'semantic-diff' | 'validate';
+type TileflowAuthoringCommandOutputKind = 'command-envelope' | 'raw-authoring-manifest' | 'raw-config-reference';
+type TileflowAuthoringCommand = Readonly<{
+    command: string;
+    name: TileflowAuthoringCommandName;
+    output: string;
+    outputKind: TileflowAuthoringCommandOutputKind;
+    /** Stable identifier for the exact versioned JSON contract emitted on success. */
+    outputSchemaRef: string;
+    outputVersion: 1 | 2 | 4;
+    purpose: string;
+    writes: false;
+}>;
+type TileflowAuthoringExpressionBuilder = Readonly<{
+    arguments: readonly string[];
+    name: keyof typeof expr;
+    returns: string;
+    serializedOperator: string;
+}>;
+type TileflowAuthoringOperation = Readonly<{
+    api: string;
+    description: string;
+    name: 'define-map' | 'data-expression' | 'disable-domain' | 'hosted-source' | 'maplibre-overlay' | 'remove-resource' | 'extend-map' | 'refine-domain' | 'refine-render-target' | 'render-pass' | 'reset-value' | 'replace-domain';
+    scope: 'domain' | 'expression' | 'map' | 'render-stack' | 'resource';
+}>;
+type TileflowAuthoringManifestDomain = Readonly<{
+    api: string;
+    authoringSchemaRef: string;
+    dependencies: Readonly<{
+        modules: readonly TileflowSemanticModuleName[];
+        services: readonly string[];
+    }>;
+    name: TileflowSemanticModuleName;
+    optionsSchemaRef: string;
+    order: number;
+    patchSchemaRef: string;
+    provides: readonly string[];
+    resolvedSchemaRef: string;
+    targetDiscovery: Readonly<{
+        command: 'tileflow explain --json';
+        domain: TileflowSemanticModuleName;
+        reportPath: 'compilation.report.domains[].targets';
+    }>;
+}>;
+type TileflowAuthoringManifest = Readonly<{
+    compilation: Readonly<{
+        diagnostic: Readonly<{
+            optional: readonly ['domain', 'path', 'suggestion', 'target'];
+            phases: typeof tileflowCompilationPhases;
+            required: readonly ['code', 'message', 'phase', 'severity'];
+            severities: readonly ['error', 'warning'];
+        }>;
+        report: Readonly<{
+            domain: Readonly<{
+                optional: readonly ['suppressionReason'];
+                required: readonly [
+                    'contributionCount',
+                    'name',
+                    'renderOperationCount',
+                    'status',
+                    'targets'
+                ];
+                statuses: readonly ['emitted', 'suppressed'];
+                suppressionReasons: readonly ['disabled', 'no-contributions'];
+            }>;
+            optional: readonly ['provenance', 'requirements', 'theme'];
+            planner: Readonly<{
+                optional: readonly ['candidateCount', 'selectedCount'];
+                required: readonly ['inputCount', 'outputCount', 'stage'];
+                stages: typeof tileflowCompilationPlannerStages;
+            }>;
+            required: readonly ['domains', 'map', 'planner', 'schemaVersion', 'targets'];
+            schemaVersion: typeof tileflowCompilationReportSchemaVersion;
+        }>;
+        physicalInspection: Readonly<{
+            addressable: false;
+            command: 'tileflow explain --inspection --json';
+            mode: 'opt-in-read-only';
+            reportPath: 'compilation.report.provenance';
+            stability: 'physical-output-only';
+        }>;
+        result: Readonly<{
+            discriminator: 'ok';
+            failure: Readonly<{
+                forbidden: readonly ['style'];
+                ok: false;
+                required: readonly ['diagnostics', 'ok', 'report'];
+            }>;
+            success: Readonly<{
+                ok: true;
+                required: readonly ['diagnostics', 'ok', 'report', 'style'];
+            }>;
+        }>;
+    }>;
+    compiler: Readonly<{
+        name: typeof tileflowSemanticCompilerIdentity.name;
+        version: typeof tileflowSemanticCompilerIdentity.version;
+    }>;
+    commands: readonly TileflowAuthoringCommand[];
+    domains: readonly TileflowAuthoringManifestDomain[];
+    expressions: Readonly<{
+        builders: readonly TileflowAuthoringExpressionBuilder[];
+        categorySchemaRefs: Readonly<{
+            color: '#/$defs/TileflowDataExpressionColor';
+            image: '#/$defs/TileflowDataExpressionImage';
+            number: '#/$defs/TileflowDataExpressionNumber';
+            structural: '#/$defs/TileflowDataExpressionStructural';
+        }>;
+        limits: typeof tileflowDataExpressionLimits;
+        fieldReference: 'field(name)';
+    }>;
+    language: 'tileflow-semantic-v1';
+    operations: readonly TileflowAuthoringOperation[];
+    renderStack: Readonly<{
+        comparisons: readonly string[];
+        features: readonly string[];
+        fields: readonly string[];
+        geometries: readonly string[];
+        limits: typeof tileflowRenderStackLimits;
+        operationNamePattern: string;
+        phases: readonly string[];
+        renderers: readonly string[];
+        selectorKinds: readonly string[];
+        targetPattern: string;
+    }>;
+    resources: Readonly<{
+        hostedSources: Readonly<{
+            api: 'hostedTileset({ tileset, local, attribution, type?, tileSize? })';
+            localResolution: 'explicit-relative-pmtiles';
+            maxPerMap: typeof tileflowHostedSourceLimit;
+            identity: 'keyed-source-id-and-team-local-tileset';
+        }>;
+        overlays: Readonly<{
+            api: 'maplibreOverlay({ source, placement, layers })';
+            layers: 'ordered-maplibre-style-layers-without-source';
+            placement: typeof tileflowOverlayPlacements;
+            replacement: 'atomic-by-overlay-id';
+        }>;
+        removal: 'remove()';
+    }>;
+    resolution: Readonly<{
+        arrays: 'replace';
+        domains: 'replace-refine-disable-reset';
+        identity: 'leaf-owned';
+        inheritance: Readonly<{
+            maxDepth: typeof tileflowMapDefaultMaxDepth;
+        }>;
+        keyedResources: 'merge-replace-remove';
+        namedRecords: 'merge-by-key';
+        records: 'deep-merge';
+        scalars: 'replace';
+        themes: 'replace-collection';
+        view: 'deep-merge';
+    }>;
+    schemaVersion: typeof tileflowAuthoringManifestSchemaVersion;
+    schemas: Readonly<{
+        authoring: '#/$defs/TileflowAuthoringMap';
+        document: 'https://tileflow.dev/schemas/tileflow-config-reference-v4.json';
+        modules: '#/$defs/TileflowAuthoringModules';
+        resolved: '#/$defs/ResolvedTileflowMap';
+    }>;
+    workflows: Readonly<{
+        author: readonly ['validate', 'inspect', 'explain'];
+        discover: readonly ['language-manifest', 'language-schema'];
+        review: readonly ['semantic-diff', 'validate', 'explain'];
+    }>;
+}>;
+/**
+ * Stable, JSON-serializable description of the complete public V1 authoring surface.
+ * Domain order and dependencies come directly from the closed compiler registry.
+ */
+declare const tileflowAuthoringManifest: TileflowAuthoringManifest;
+
+declare const tileflowSemanticDiffSchemaVersion: 1;
+type TileflowSemanticMapIdentity = Readonly<{
+    id: string;
+    version: number;
+}>;
+type TileflowSemanticJsonValue = boolean | null | number | string | readonly TileflowSemanticJsonValue[] | Readonly<{
+    [key: string]: TileflowSemanticJsonValue;
+}>;
+type TileflowSemanticAdd = Readonly<{
+    after: TileflowSemanticJsonValue;
+    kind: 'add';
+    path: string;
+}>;
+type TileflowSemanticRemove = Readonly<{
+    before: TileflowSemanticJsonValue;
+    kind: 'remove';
+    path: string;
+}>;
+type TileflowSemanticChange = Readonly<{
+    after: TileflowSemanticJsonValue;
+    before: TileflowSemanticJsonValue;
+    kind: 'change';
+    path: string;
+}>;
+type TileflowSemanticDifference = TileflowSemanticAdd | TileflowSemanticChange | TileflowSemanticRemove;
+type TileflowSemanticDiff = Readonly<{
+    changes: readonly TileflowSemanticDifference[];
+    from: TileflowSemanticMapIdentity;
+    schemaVersion: typeof tileflowSemanticDiffSchemaVersion;
+    summary: Readonly<{
+        add: number;
+        change: number;
+        remove: number;
+        total: number;
+    }>;
+    to: TileflowSemanticMapIdentity;
+}>;
+/**
+ * Compare the resolved semantic designs of two maps. Identity metadata identifies the endpoints
+ * but is intentionally not reported as a cartographic change. Arrays are atomic because map
+ * inheritance replaces them rather than merging their members.
+ */
+declare function diffTileflowMaps(from: TileflowMap | ResolvedTileflowMap, to: TileflowMap | ResolvedTileflowMap): TileflowSemanticDiff;
 
 type TileflowZoomPerformance = {
     activeLayers: number;
-    /** @deprecated Use styleLayerFamilies. This is not a count of runtime tile buckets. */
-    estimatedBuckets: number;
     sourceLayers: Record<string, number>;
     styleLayerFamilies: number;
     symbols: number;
@@ -64,6 +525,8 @@ type TileflowStylePerformance = {
 /** A deterministic, network-free structural sweep of a compiled style. */
 declare function analyzeTileflowStylePerformance(style: MapLibreStyle, zooms?: readonly number[]): TileflowStylePerformance;
 
+declare const tileflowRoadClasses: readonly ["motorway", "trunk", "primary", "secondary", "tertiary", "minor", "service", "track", "pathway", "footway", "cycleway", "steps", "pedestrian"];
+
 declare function roads(options?: TileflowRoadsModuleOptions): TileflowRoadsModuleConfig;
 
 declare function labels(options?: TileflowLabelsModuleOptions): TileflowLabelsModuleConfig;
@@ -295,4 +758,4 @@ type TileflowIconManifestDiff = {
 };
 declare function diffTileflowIconPackageManifests(before: TileflowIconPackageManifest | null, after: TileflowIconPackageManifest | null): TileflowIconManifestDiff;
 
-export { MapLibreStyle, ResolveMapOptions, ResolvedTileflowMap, TileflowDerivedMap, type TileflowFontBundleFile, type TileflowFontBundleFontFace, type TileflowFontBundleManifest, type TileflowIconManifestDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, TileflowMap, TileflowMapScene, TileflowPoiModuleConfig, TileflowPoiModuleOptions, type TileflowRenderedIconManifestEntry, TileflowResolvedMapValidationError, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, type TileflowStylePerformance, type TileflowZoomPerformance, ValidationMessage, analyzeTileflowStylePerformance, compareCodeUnits, defineMap, defineRootMap, diffTileflowIconPackageManifests, hashTileflowFontBundleManifest, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, isTileflowPortableId, isTileflowThemeName, isTileflowWorldReleaseId, labels, poi, resolveMap, roads, serializeCanonicalJson, serializeTileflowFontBundleManifest, serializeTileflowIconPackageManifest, sha256Hex, tileflowFontBundleContentHashSchema, tileflowFontBundleLimits, tileflowFontBundleManifestSchema, tileflowHostedAlphaCompatibility, tileflowIconIdPattern, tileflowIconIdSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowMapDefaultMaxDepth, tileflowPoiImageRoles, tileflowPortableIdMaximumLength, tileflowRenderedIconManifestEntrySchema, tileflowWorldReleaseIdMaximumLength, tileflowWorldReleaseIdMinimumLength, tileflowWorldReleaseIdPattern, tileflowWorldReleaseIdPatternSource, tileflowWorldReleaseIdSchema };
+export { MapLibreStyle, OpenMapTilesFieldBindings, OpenMapTilesLayerBindings, ResolveMapOptions, ResolvedTileflowMap, type TileflowAuthoringCommand, type TileflowAuthoringCommandName, type TileflowAuthoringCommandOutputKind, type TileflowAuthoringExpressionBuilder, type TileflowAuthoringManifest, type TileflowAuthoringManifestDomain, type TileflowAuthoringOperation, TileflowBackgroundStyle, TileflowCircleStyle, type TileflowDataCaseBranch, type TileflowDataExpressionInput, type TileflowDataExpressionResult, type TileflowDataFieldReference, type TileflowDataFieldValue, type TileflowDataInterpolation, type TileflowDataMatchBranch, type TileflowDataStop, TileflowExtrusionStyle, TileflowFillStyle, TileflowFixedValue, type TileflowFontBundleFile, type TileflowFontBundleFontFace, type TileflowFontBundleManifest, type TileflowIconManifestDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, TileflowLineStyle, TileflowMap, TileflowMapResolutionError, TileflowMapScene, type TileflowModuleWithRenderStack, type TileflowNamedRenderStack, type TileflowNumericDataFieldName, TileflowPoiModuleConfig, TileflowPoiModuleOptions, type TileflowRenderComparison, type TileflowRenderFeature, type TileflowRenderField, type TileflowRenderGeometry, type TileflowRenderPass, type TileflowRenderPassInput, type TileflowRenderScalar, type TileflowRenderSelector, type TileflowRenderStackOperation, type TileflowRenderStackPhase, type TileflowRenderTargetRefinement, type TileflowRenderTargetRefinementInput, type TileflowRenderVisibilityGroup, type TileflowRenderedIconManifestEntry, TileflowResolvedMapValidationError, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, type TileflowSemanticAdd, type TileflowSemanticChange, type TileflowSemanticDiff, type TileflowSemanticDifference, type TileflowSemanticJsonValue, type TileflowSemanticMapIdentity, type TileflowSemanticRemove, type TileflowStylePerformance, TileflowSymbolStyle, TileflowThemeColorOperation, TileflowThemeTokenReference, type TileflowZoomPerformance, ValidationMessage, analyzeTileflowStylePerformance, compareCodeUnits, defineMap, diffTileflowIconPackageManifests, diffTileflowMaps, expr, field, hashTileflowFontBundleManifest, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, isTileflowPortableId, isTileflowThemeName, isTileflowWorldReleaseId, labels, parseResolvedTileflowMap, poi, refineRenderTarget, renderPass, resolveMap, roads, serializeCanonicalJson, serializeTileflowFontBundleManifest, serializeTileflowIconPackageManifest, sha256Hex, tileflowAuthoringManifest, tileflowAuthoringManifestSchemaVersion, tileflowCompilationPhases, tileflowCompilationPlannerStages, tileflowCompilationReportSchemaVersion, tileflowFontBundleContentHashSchema, tileflowFontBundleLimits, tileflowFontBundleManifestSchema, tileflowHostedAlphaCompatibility, tileflowHostedSourceLimit, tileflowIconIdPattern, tileflowIconIdSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowMapDefaultMaxDepth, tileflowOverlayPlacements, tileflowPoiImageRoles, tileflowPortableIdMaximumLength, tileflowRenderSelectorComparisons, tileflowRenderSelectorGeometries, tileflowRenderSelectorKinds, tileflowRenderStackLimits, tileflowRenderStackPhases, tileflowRenderStackRenderers, tileflowRenderedIconManifestEntrySchema, tileflowRoadClasses, tileflowSemanticDiffSchemaVersion, tileflowWorldReleaseIdMaximumLength, tileflowWorldReleaseIdMinimumLength, tileflowWorldReleaseIdPattern, tileflowWorldReleaseIdPatternSource, tileflowWorldReleaseIdSchema, withRenderStack };