@tileflow/core 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/index.d.ts

@@ -1,170 +1,600 @@
-import { b as TileflowBaseColors, c as TileflowConfig, d as TileflowProjectConfig, V as ValidationResult, e as TileflowRoadsModuleOptions, f as TileflowRoadsModuleConfig, g as TileflowLabelsModuleOptions, h as TileflowLabelsModuleConfig, i as TileflowPoiModuleOptions, j as TileflowPoiModuleConfig } from './runtime-DroKDIuB.js';
-export { M as MapLibreSprite, k as MapLibreStyle, N as NormalizedTileflowCaptureScene, O as OpenMapTilesFieldBindings, l as OpenMapTilesLayerBindings, m as OpenMapTilesSchema, n as OpenMapTilesSchemaOptions, R as ResolvedTileflowData, o as ResolvedTileflowTypography, p as TileflowAerowaysModuleConfig, q as TileflowAerowaysModuleOptions, r as TileflowAlignment, T as TileflowAnalytics, s as TileflowAreaStyle, t as TileflowBackgroundPaint, u as TileflowBackgroundStyle, v as TileflowBoundariesModuleConfig, w as TileflowBoundariesModuleOptions, x as TileflowBoundaryColorConfig, y as TileflowBuildingColorConfig, z as TileflowBuildingMode, A as TileflowBuildingsModuleConfig, B as TileflowBuildingsModuleOptions, C as TileflowCaptureApplicationTarget, D as TileflowCaptureBoundsCamera, E as TileflowCaptureCamera, F as TileflowCaptureCenterCamera, G as TileflowCaptureMapTarget, H as TileflowCaptureScene, I as TileflowCaptureTarget, J as TileflowCaptureViewport, K as TileflowCirclePaint, L as TileflowCircleStyle, P as TileflowColor, Q as TileflowColorConfig, S as TileflowColors, U as TileflowDataConfig, W as TileflowDataIdentity, X as TileflowExpression, Y as TileflowExtrusionPaint, Z as TileflowExtrusionStyle, _ as TileflowFillPaint, $ as TileflowFillStyle, a0 as TileflowFilterExpression, a1 as TileflowFontWeight, a2 as TileflowHostedNotoSansWeight, a3 as TileflowHydroColorConfig, a4 as TileflowIconAnchor, a5 as TileflowIconLayout, a6 as TileflowIconPaint, a7 as TileflowIconSet, a8 as TileflowIconSetConfig, a9 as TileflowIconStyle, aa as TileflowLabelColorConfig, ab as TileflowLabelDetail, ac as TileflowLabelLanguage, ad as TileflowLabelStyles, ae as TileflowLandModuleConfig, af as TileflowLandModuleOptions, ag as TileflowLandcoverClass, ah as TileflowLandcoverColorConfig, ai as TileflowLanduseClass, aj as TileflowLanduseColorConfig, ak as TileflowLayerPlacement, al as TileflowLayerRange, am as TileflowLineCap, an as TileflowLineHatchStyle, ao as TileflowLineJoin, ap as TileflowLineLayout, aq as TileflowLinePaint, ar as TileflowLineStackStyle, as as TileflowLineStyle, at as TileflowManifest, au as TileflowManifestLoadOptions, av as TileflowMapConfig, aw as TileflowMapMarker, ax as TileflowMapMode, ay as TileflowMapModeOptions, az as TileflowMountainBikeScale, aA as TileflowPlaceLabelClass, aB as TileflowPoi, aC as TileflowPoiCategory, aD as TileflowPoiCategoryStyle, aE as TileflowPoiClassMapping, aF as TileflowPoiColorConfig, aG as TileflowPoiColorMode, aH as TileflowPoiDensity, aI as TileflowPoiIcons, aJ as TileflowPoiLabels, aK as TileflowProjectIconSets, aL as TileflowProjectThemes, aM as TileflowRawOverride, aN as TileflowRoadAreaStyle, aO as TileflowRoadClass, aP as TileflowRoadClassStyle, aQ as TileflowRoadColorConfig, aR as TileflowRoadDetail, aS as TileflowRoadExtras, aT as TileflowRoadHierarchy, aU as TileflowRoadLabelDetail, aV as TileflowRoadLayerStyle, aW as TileflowRoadModifier, aX as TileflowRoadOutline, aY as TileflowRoadRestriction, aZ as TileflowRoadServiceType, a_ as TileflowRoadShieldDetail, a$ as TileflowRoadShieldStyles, b0 as TileflowRoadStructure, b1 as TileflowRoadTreatmentLayerStyle, b2 as TileflowRoadTreatmentLineStyle, b3 as TileflowRoadTreatmentStyle, b4 as TileflowRoadWeight, b5 as TileflowRuntimeManifest, b6 as TileflowRuntimeManifestMap, b7 as TileflowRuntimeManifestMapEntry, b8 as TileflowRuntimeStyle, b9 as TileflowRuntimeStyleOptions, a as TileflowSessionController, ba as TileflowSessionGrantResponse, bb as TileflowStreetsBasemapConfig, bc as TileflowStreetsCompileOptions, bd as TileflowStreetsMapConfig, be as TileflowStreetsModules, bf as TileflowStreetsOptions, bg as TileflowStreetsVariant, bh as TileflowStyleOptions, bi as TileflowStyleValue, bj as TileflowSymbolPlacement, bk as TileflowSymbolPlacementStyle, bl as TileflowSymbolStyle, bm as TileflowSymbolZOrder, bn as TileflowTerrain, bo as TileflowTerrainConfig, bp as TileflowTerrainEncoding, bq as TileflowTerrainMode, br as TileflowTextAnchor, bs as TileflowTextJustify, bt as TileflowTextLayout, bu as TileflowTextPaint, bv as TileflowTextStyle, bw as TileflowTheme, bx as TileflowThemeConfig, by as TileflowThemeMode, bz as TileflowThemeModulesConfig, bA as TileflowThemeName, bB as TileflowTransitModuleConfig, bC as TileflowTransitModuleOptions, bD as TileflowTransitRailStyle, bE as TileflowTypography, bF as TileflowTypographyDomain, bG as TileflowTypographyStyle, bH as TileflowViewConfig, bI as TileflowWaterLabelClass, bJ as TileflowWaterModuleConfig, bK as TileflowWaterModuleOptions, bL as TileflowWaterwayClass, bM as TileflowWorldData, bN as TileflowZoomInterpolation, bO as TileflowZoomValue, bP as ValidationMessage, bQ as VectorTilesData, bR as addLayer, bS as aeroways, bT as boundaries, bU as buildings, bV as createManifest, bW as createStreetsStyle, bX as createStyle, bY as createStyleFromProject, bZ as createTileflowSessionController, b_ as createTileflowSessionId, b$ as defaultTileflowManifestUrl, c0 as defaultTileflowStyleBaseUrl, c1 as expression, c2 as filter, c3 as getDefaultTileflowStyleBaseUrl, c4 as getTileflowAnalyticsApiUrl, c5 as inferTileflowAnalyticsFromStyleUrl, c6 as isCanonicalOpenMapTilesSchema, c7 as isTileflowLocalDevHost, c8 as land, c9 as loadTileflowManifest, ca as mergeTileflowAnalytics, cb as moveLayer, cc as normalizeTileflowCaptureId, cd as normalizeTileflowCaptureScene, ce as normalizeTileflowStaticImageSize, cf as normalizeTileflowUrl, cg as openMapTiles, ch as openMapTilesContractVersion, ci as patchLayer, cj as removeLayer, ck as resolveTileflowAnalyticsRequestUrl, cl as resolveTileflowData, cm as resolveTileflowManifestMap, cn as resolveTileflowMapMode, co as resolveTileflowRuntimeStyle, cp as resolveTileflowStaticImageUrl, cq as resolveTileflowStyleUrl, cr as shouldLoadTileflowManifest, cs as startTileflowSession, ct as streets, cu as tileflowCaptureApplicationTargetSchema, cv as tileflowCaptureBoundsCameraSchema, cw as tileflowCaptureCameraSchema, cx as tileflowCaptureCenterCameraSchema, cy as tileflowCaptureIdSchema, cz as tileflowCaptureMapTargetSchema, cA as tileflowCaptureSceneLimits, cB as tileflowCaptureSceneNameSchema, cC as tileflowCaptureSceneSchema, cD as tileflowCaptureSceneSchemaVersion, cE as tileflowCaptureTargetSchema, cF as tileflowCaptureViewportSchema, cG as tileflowFontStack, cH as tileflowHostedNotoSansWeights, cI as tileflowPrimarySourceId, cJ as tileflowStreetsBasemapVersion, cK as tileflowStreetsPoiIconMapping, cL as tileflowWorld, cM as tileflowWorldRevision, cN as transit, cO as vectorTiles, cP as water, cQ as zoom } from './runtime-DroKDIuB.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';
 import { z } from 'zod';
 
-declare function getDefaultColors(): TileflowBaseColors;
+declare const tileflowPortableIdMaximumLength: 64;
+declare function isTileflowPortableId(value: unknown): value is string;
+declare function isTileflowThemeName(value: unknown): value is string;
 
-declare const tileflowThemeSchema: z.ZodObject<{
-    colors: z.ZodOptional<z.ZodObject<{
-        background: z.ZodOptional<z.ZodString>;
-        boundary: z.ZodOptional<z.ZodString>;
-        building: z.ZodOptional<z.ZodString>;
-        land: z.ZodOptional<z.ZodString>;
-        park: z.ZodOptional<z.ZodString>;
-        road: z.ZodOptional<z.ZodString>;
-        roadCasing: z.ZodOptional<z.ZodString>;
-        roadMajor: z.ZodOptional<z.ZodString>;
-        text: z.ZodOptional<z.ZodString>;
-        textHalo: z.ZodOptional<z.ZodString>;
-        textMuted: z.ZodOptional<z.ZodString>;
-        water: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    extends: z.ZodOptional<z.ZodString>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        light: "light";
-        dark: "dark";
-    }>>;
-    modules: z.ZodOptional<z.ZodObject<{
-        boundaries: z.ZodOptional<z.ZodObject<{
-            major: z.ZodOptional<z.ZodString>;
-            disputed: z.ZodOptional<z.ZodString>;
-            admin: z.ZodOptional<z.ZodString>;
-            maritime: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        buildings: z.ZodOptional<z.ZodObject<{
-            fill: z.ZodOptional<z.ZodString>;
-            outline: z.ZodOptional<z.ZodString>;
-            extrusion: z.ZodOptional<z.ZodString>;
-            highRise: z.ZodOptional<z.ZodString>;
-            highRiseOutline: z.ZodOptional<z.ZodString>;
-            lowRise: z.ZodOptional<z.ZodString>;
-            lowRiseOutline: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        hydro: z.ZodOptional<z.ZodObject<{
-            water: z.ZodOptional<z.ZodString>;
-            waterway: z.ZodOptional<z.ZodString>;
-            ferry: z.ZodOptional<z.ZodString>;
-            label: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        labels: z.ZodOptional<z.ZodObject<{
-            water: z.ZodOptional<z.ZodString>;
-            road: z.ZodOptional<z.ZodString>;
-            poi: z.ZodOptional<z.ZodString>;
-            primary: z.ZodOptional<z.ZodString>;
-            country: z.ZodOptional<z.ZodString>;
-            neighborhood: z.ZodOptional<z.ZodString>;
-            halo: z.ZodOptional<z.ZodString>;
-            muted: z.ZodOptional<z.ZodString>;
-            settlement: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        landcover: z.ZodOptional<z.ZodObject<{
-            park: z.ZodOptional<z.ZodString>;
-            grass: z.ZodOptional<z.ZodString>;
-            ice: z.ZodOptional<z.ZodString>;
-            protected: z.ZodOptional<z.ZodString>;
-            sand: z.ZodOptional<z.ZodString>;
-            wood: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        landuse: z.ZodOptional<z.ZodObject<{
-            residential: z.ZodOptional<z.ZodString>;
-            cemetery: z.ZodOptional<z.ZodString>;
-            civic: z.ZodOptional<z.ZodString>;
-            commercial: z.ZodOptional<z.ZodString>;
-            industrial: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        poi: z.ZodOptional<z.ZodObject<{
-            food: z.ZodOptional<z.ZodString>;
-            coffee: z.ZodOptional<z.ZodString>;
-            culture: z.ZodOptional<z.ZodString>;
-            transit: z.ZodOptional<z.ZodString>;
-            shopping: z.ZodOptional<z.ZodString>;
-            lodging: z.ZodOptional<z.ZodString>;
-            health: z.ZodOptional<z.ZodString>;
-            education: z.ZodOptional<z.ZodString>;
-            services: z.ZodOptional<z.ZodString>;
-            halo: z.ZodOptional<z.ZodString>;
-            icon: z.ZodOptional<z.ZodString>;
-            label: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        roads: z.ZodOptional<z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            motorway: z.ZodOptional<z.ZodString>;
-            trunk: z.ZodOptional<z.ZodString>;
-            primary: z.ZodOptional<z.ZodString>;
-            secondary: z.ZodOptional<z.ZodString>;
-            minor: z.ZodOptional<z.ZodString>;
-            bridge: z.ZodOptional<z.ZodString>;
-            tunnel: z.ZodOptional<z.ZodString>;
-            casing: z.ZodOptional<z.ZodString>;
-            ferry: z.ZodOptional<z.ZodString>;
-            rail: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    typography: z.ZodOptional<z.ZodObject<{
-        font: z.ZodOptional<z.ZodString>;
-        weight: z.ZodOptional<z.ZodEnum<{
-            bold: "bold";
-            regular: "regular";
-            medium: "medium";
-            semibold: "semibold";
-        }>>;
-        places: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-        poi: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-        roads: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-        water: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-declare const tileflowMapSchema: z.ZodType<TileflowConfig>;
-declare const configSchema: z.ZodType<TileflowConfig>;
-declare const tileflowProjectSchema: z.ZodType<TileflowProjectConfig>;
-declare function parseTileflowMap(input: unknown): TileflowConfig;
-declare function parseTileflowProject(input: unknown): TileflowProjectConfig;
-declare function validateConfig(input: unknown): ValidationResult;
-declare const validateTileflowConfig: typeof validateConfig;
+/** Exact immutable release identity contract for the current World V1 product. */
+declare const tileflowWorldReleaseIdMinimumLength: 12;
+declare const tileflowWorldReleaseIdMaximumLength: 128;
+declare const tileflowWorldReleaseIdPatternSource: "^world-v1-[a-z0-9][a-z0-9._-]*[a-z0-9]$";
+declare const tileflowWorldReleaseIdPattern: RegExp;
+/** Validate without trimming, lowercasing, or otherwise normalizing an immutable release ID. */
+declare function isTileflowWorldReleaseId(value: unknown): value is string;
+
+declare const tileflowWorldReleaseIdSchema: z.ZodString;
+
+type ExactTileflowMap<TContract, TMap extends TContract> = TMap & Record<Exclude<keyof TMap, keyof TContract>, never>;
+type ExactTileflowMapScenes<TMap> = TMap extends {
+    scenes: infer TScenes extends Record<string, TileflowMapScene>;
+} ? {
+    scenes: {
+        [TName in keyof TScenes]: ExactTileflowMap<TileflowMapScene, TScenes[TName]>;
+    };
+} : unknown;
+/** 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;
+
+/** Structured schema failure preserved for CLI/editor diagnostics. */
+declare class TileflowResolvedMapValidationError extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly messages: ValidationMessage[];
+    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>;
 
-declare function defineTileflow<const TConfig extends TileflowProjectConfig>(config: TConfig): TConfig;
+/** 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;
+    sourceLayers: Record<string, number>;
+    styleLayerFamilies: number;
+    symbols: number;
+    zoom: number;
+};
+type TileflowStylePerformance = {
+    styleBytes: number;
+    totalLayers: number;
+    zooms: TileflowZoomPerformance[];
+};
+/** 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;
 
+/**
+ * Stable built-in POI image convention. A theme token with the declared role
+ * takes precedence; `fallback` is the invariant sprite ID used when omitted.
+ */
+declare const tileflowPoiImageRoles: Readonly<{
+    readonly 'arts-entertainment': {
+        readonly fallback: "culture";
+        readonly token: "poi.arts-entertainment";
+    };
+    readonly education: {
+        readonly fallback: "education";
+        readonly token: "poi.education";
+    };
+    readonly 'food-drink': {
+        readonly fallback: "food";
+        readonly token: "poi.food-drink";
+    };
+    readonly landmark: {
+        readonly fallback: "culture";
+        readonly token: "poi.landmark";
+    };
+    readonly lodging: {
+        readonly fallback: "lodging";
+        readonly token: "poi.lodging";
+    };
+    readonly medical: {
+        readonly fallback: "health";
+        readonly token: "poi.medical";
+    };
+    readonly 'park-nature': {
+        readonly fallback: "services";
+        readonly token: "poi.park-nature";
+    };
+    readonly 'public-services': {
+        readonly fallback: "services";
+        readonly token: "poi.public-services";
+    };
+    readonly religion: {
+        readonly fallback: "culture";
+        readonly token: "poi.religion";
+    };
+    readonly retail: {
+        readonly fallback: "shopping";
+        readonly token: "poi.retail";
+    };
+    readonly 'sport-leisure': {
+        readonly fallback: "culture";
+        readonly token: "poi.sport-leisure";
+    };
+    readonly transport: {
+        readonly fallback: "major-transit";
+        readonly token: "poi.transport";
+    };
+    readonly 'visitor-amenity': {
+        readonly fallback: "services";
+        readonly token: "poi.visitor-amenity";
+    };
+}>;
 declare function poi(options?: TileflowPoiModuleOptions): TileflowPoiModuleConfig;
 
 declare const tileflowIconPackageFileNames: readonly ["sprite.json", "sprite.png", "sprite@2x.json", "sprite@2x.png"];
 type TileflowIconPackageFileName = (typeof tileflowIconPackageFileNames)[number];
-declare const tileflowHostedIconIdPattern: RegExp;
+/** Canonical sprite ID shared by authoring, generated manifests, diffs, and runtime indexes. */
+declare const tileflowIconIdPattern: RegExp;
 declare const tileflowIconPackageLimits: {
     readonly decodeConcurrency: 4;
     readonly maxAtlasDimension: 2048;
@@ -184,10 +614,10 @@ declare const tileflowHostedAlphaCompatibility: {
         readonly maxGeneratedBytesPerProject: number;
         readonly maxRetainedPerProject: 24;
     };
-    readonly maxMapsPerDeploy: 1;
+    readonly maxMapsPerDeploy: 20;
 };
 declare const tileflowIconPackageContentHashSchema: z.ZodString;
-declare const tileflowHostedIconIdSchema: z.ZodString;
+declare const tileflowIconIdSchema: z.ZodString;
 declare const tileflowRenderedIconManifestEntrySchema: z.ZodObject<{
     name: z.ZodString;
     pixelSha256: z.ZodObject<{
@@ -262,6 +692,62 @@ declare function hashTileflowRenderedIconPixels(input: {
     width: number;
 }): Promise<string>;
 
+declare const tileflowFontBundleLimits: {
+    readonly maxFaceCount: 16;
+    readonly maxFileCount: 32;
+    readonly maxFontFileBytes: number;
+    readonly maxLicenseFileBytes: number;
+    readonly maxManifestBytes: number;
+    readonly maxPackageBytes: number;
+};
+declare const tileflowFontBundleContentHashSchema: z.ZodString;
+declare const tileflowFontBundleManifestSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodEnum<{
+            "font/otf": "font/otf";
+            "font/ttf": "font/ttf";
+            "font/woff2": "font/woff2";
+        }>;
+        kind: z.ZodLiteral<"font">;
+        name: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"text/plain; charset=utf-8">;
+        kind: z.ZodLiteral<"license">;
+        name: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    fontFaces: z.ZodArray<z.ZodObject<{
+        family: z.ZodString;
+        file: z.ZodString;
+        licenseFile: z.ZodString;
+        style: z.ZodEnum<{
+            italic: "italic";
+            normal: "normal";
+            oblique: "oblique";
+        }>;
+        weight: z.ZodEnum<{
+            100: "100";
+            200: "200";
+            300: "300";
+            400: "400";
+            500: "500";
+            600: "600";
+            700: "700";
+            800: "800";
+            900: "900";
+        }>;
+    }, z.core.$strict>>;
+    format: z.ZodLiteral<"tileflow-font-bundle-v1">;
+}, z.core.$strict>;
+type TileflowFontBundleManifest = z.infer<typeof tileflowFontBundleManifestSchema>;
+type TileflowFontBundleFile = TileflowFontBundleManifest['files'][number];
+type TileflowFontBundleFontFace = TileflowFontBundleManifest['fontFaces'][number];
+declare function serializeTileflowFontBundleManifest(input: TileflowFontBundleManifest): string;
+declare function hashTileflowFontBundleManifest(input: TileflowFontBundleManifest): Promise<string>;
+
 type TileflowIconManifestDiff = {
     added: string[];
     afterBytes: number;
@@ -270,31 +756,6 @@ type TileflowIconManifestDiff = {
     removed: string[];
     unchangedCount: number;
 };
-type TileflowIconMappingChange = {
-    after?: string;
-    before?: string;
-    key: string;
-};
-type TileflowIconMappingDiff = {
-    added: TileflowIconMappingChange[];
-    changed: TileflowIconMappingChange[];
-    removed: TileflowIconMappingChange[];
-};
-type TileflowIconReferenceAnalysis = {
-    analysisComplete: boolean;
-    dangling: Array<{
-        iconName: string;
-        kind: 'mapping' | 'style-override-literal';
-        path: string;
-    }>;
-    unanalyzable: Array<{
-        kind: 'style-override-expression';
-        path: string;
-    }>;
-};
 declare function diffTileflowIconPackageManifests(before: TileflowIconPackageManifest | null, after: TileflowIconPackageManifest | null): TileflowIconManifestDiff;
-declare function diffTileflowIconMappings(before: Record<string, string> | null, after: Record<string, string> | null): TileflowIconMappingDiff;
-declare function inspectTileflowIconReferences(project: TileflowProjectConfig, mapName: string, availableIconNames: readonly string[]): TileflowIconReferenceAnalysis;
-declare function resolveTileflowIconMapping(project: TileflowProjectConfig, mapName: string): Record<string, string>;
 
-export { TileflowBaseColors, TileflowConfig, type TileflowIconManifestDiff, type TileflowIconMappingChange, type TileflowIconMappingDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, type TileflowIconReferenceAnalysis, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, TileflowPoiModuleConfig, TileflowPoiModuleOptions, TileflowProjectConfig, type TileflowRenderedIconManifestEntry, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, ValidationResult, compareCodeUnits, configSchema, defineTileflow, diffTileflowIconMappings, diffTileflowIconPackageManifests, getDefaultColors, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, inspectTileflowIconReferences, labels, parseTileflowMap, parseTileflowProject, poi, resolveTileflowIconMapping, roads, serializeCanonicalJson, serializeTileflowIconPackageManifest, sha256Hex, tileflowHostedAlphaCompatibility, tileflowHostedIconIdPattern, tileflowHostedIconIdSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowMapSchema, tileflowProjectSchema, tileflowRenderedIconManifestEntrySchema, tileflowThemeSchema, validateConfig, validateTileflowConfig };
+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 };