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

package/dist/index.d.ts

@@ -1,172 +1,1124 @@
-type TileflowDensity = 'clean' | 'balanced' | 'dense';
-type TileflowRoads = 'hidden' | 'soft' | 'standard' | 'detailed';
-type TileflowLabels = 'none' | 'essential' | 'balanced' | 'full';
-type TileflowPoi = 'none' | 'minimal' | 'balanced' | 'full';
-type TileflowTheme = 'standard' | 'light' | 'dark' | 'minimal' | 'osm-bright-2';
-type TileflowBuildings = 'hidden' | 'flat' | '3d';
-type TileflowTerrainMode = 'none' | 'hillshade' | '3d';
-type TileflowTerrainEncoding = 'mapbox' | 'terrarium';
-type TileflowThemeMode = 'light' | 'dark';
-type TileflowColors = {
-    canvas: string;
-    land: string;
-    water: string;
-    nature: string;
-    road: string;
-    text: string;
-    accent: string;
-};
-type LegacyTileflowColorAliases = {
-    background?: string;
-    park?: string;
-    building?: string;
-    roadCasing?: string;
-};
-type TileflowColorConfig = Partial<TileflowColors> & LegacyTileflowColorAliases;
-type TileflowFontWeight = 'regular' | 'medium' | 'semibold' | 'bold';
-type TileflowTypography = {
-    font?: string;
-    weight?: TileflowFontWeight;
-};
-type TileflowThemeConfig = {
-    mode?: TileflowThemeMode;
-    colors?: TileflowColorConfig;
-    typography?: TileflowTypography;
-};
-type TileflowSourceLayers = {
-    landuse?: string;
-    park?: string;
-    water?: string;
-    road?: string;
-    building?: string;
-    boundary?: string;
-    place?: string;
-    poi?: string;
-};
-type TileflowTiles = {
-    sourceId?: string;
-    tileset?: string;
-    url?: string;
-    attribution?: string;
-    sourceLayers?: TileflowSourceLayers;
-};
-type TileflowTerrainConfig = {
-    attribution?: string;
-    encoding?: TileflowTerrainEncoding;
-    exaggeration?: number;
-    mode?: TileflowTerrainMode;
-    sourceId?: string;
-    tileset?: string;
-    url?: string;
-};
-type TileflowTerrain = TileflowTerrainMode | TileflowTerrainConfig;
-type TileflowViewConfig = {
-    bearing?: number;
-    center?: readonly [number, number];
-    zoom?: number;
-};
-type TileflowOsmBasemapConfig = {
-    type: 'osm';
-    attribution?: string;
-    glyphs?: string;
-    sourceId?: string;
-    sourceLayers?: TileflowSourceLayers;
-    sprite?: string;
-    tileset?: string;
-    url?: string;
-};
-type TileflowBasemapConfig = TileflowOsmBasemapConfig;
-type TileflowOsmBasemapOptions = Omit<TileflowOsmBasemapConfig, 'type'>;
-type TileflowRoadsModulePreset = 'modern' | 'minimal';
-type TileflowRoadsModuleConfig = {
-    type: 'roads';
-    density?: TileflowDensity;
-    preset?: TileflowRoadsModulePreset;
-};
-type TileflowRoadsModuleOptions = Omit<TileflowRoadsModuleConfig, 'type'>;
-type TileflowModuleConfig = TileflowRoadsModuleConfig;
-type TileflowConfig = {
-    basemap?: TileflowBasemapConfig;
-    name?: string;
-    tileset?: string;
-    theme?: TileflowTheme | string | TileflowThemeConfig;
-    modules?: readonly TileflowModuleConfig[];
-    colors?: TileflowColorConfig;
-    typography?: TileflowTypography;
-    density?: TileflowDensity;
-    roads?: TileflowRoads;
-    labels?: TileflowLabels;
-    poi?: TileflowPoi;
-    buildings?: TileflowBuildings;
-    terrain?: TileflowTerrain;
-    glyphs?: string;
-    sprite?: string;
-    tiles?: TileflowTiles;
-    view?: TileflowViewConfig;
+import { d as TileflowMap, u as TileflowMapScene, w as ResolveMapOptions, R as ResolvedTileflowMap, x as TileflowIconAppearance, O as OpenMapTilesFieldBindings, y as TileflowLayerDomain, z as TileflowBandPlacement, A as OpenMapTilesLayerBindings, B as tileflowCompilationPhases, C as tileflowCompilationPlannerStages, D as tileflowCompilationReportSchemaVersion, E as TileflowSemanticModuleName, F as tileflowHostedSourceLimit, G as tileflowOverlayPlacements, H as TileflowIconSource } from './icon-composition-BiOTwrvD.js';
+export { I as OpenMapTilesSchema, J as OpenMapTilesSchemaOptions, P as ParkLayerSemantics, K as ResolvedBathymetry, L as ResolvedBathymetryRelief, M as ResolvedMarine, N as ResolvedMarineSource, Q as ResolvedTileflowData, S as ResolvedTileflowTheme, U as ResolvedTileflowThemeTokens, V as TileflowAddressesModuleConfig, W as TileflowAddressesModuleOptions, X as TileflowAerowaysModuleConfig, Y as TileflowAerowaysModuleOptions, Z as TileflowAtmosphere, _ as TileflowAtmosphereOptions, $ as TileflowAuthoringModules, a0 as TileflowBathymetryConfig, a1 as TileflowBathymetryDemSourceIdentity, a2 as TileflowBathymetryDisplay, a3 as TileflowBathymetryOptions, a4 as TileflowBathymetryReliefConfig, a5 as TileflowBoundariesModuleConfig, a6 as TileflowBoundariesModuleOptions, a7 as TileflowBuildingMode, a8 as TileflowBuildingsModuleConfig, a9 as TileflowBuildingsModuleOptions, aa as TileflowCompilationDiagnostic, ab as TileflowCompilationDomainReport, ac as TileflowCompilationFailure, ad as TileflowCompilationOptions, ae as TileflowCompilationPhase, af as TileflowCompilationPlannerDecision, ag as TileflowCompilationPlannerStage, ah as TileflowCompilationReport, ai as TileflowCompilationResult, aj as TileflowCompilationSuccess, h as TileflowDataCompatibilityIssue, ak as TileflowDataConfig, i as TileflowDataFieldRequirement, j as TileflowDataFieldType, al as TileflowDataIdentity, k as TileflowDataLayerRequirement, b as TileflowDataRequirementsV1, am as TileflowDerivedMap, an as TileflowDisableOperation, ao as TileflowFontDirectory, ap as TileflowGlyphs, aq as TileflowHostedSourceCollection, ar as TileflowHostedTilesetSource, as as TileflowHostedTilesetType, a as TileflowIconCompositionV1, at as TileflowIconContributorIdentity, au as TileflowIconDirectory, av as TileflowIconSetError, aw as TileflowIconSetErrorCode, ax as TileflowIconSetReference, ay as TileflowIconSetSource, az as TileflowLandModuleConfig, aA as TileflowLandModuleOptions, aB as TileflowLandcoverClass, aC as TileflowLandformClass, aD as TileflowLandformsModuleConfig, aE as TileflowLandformsModuleOptions, aF as TileflowLanduseClass, aG as TileflowLayerBand, aH as TileflowLocalDirectory, aI as TileflowMapDesign, aJ as TileflowMapIdentity, aK as TileflowMapLibreOverlay, aL as TileflowMapLibreOverlayLayer, aM as TileflowMapTooling, aN as TileflowMarine, aO as TileflowMarineConfig, aP as TileflowMarineMode, aQ as TileflowMarineSourceConfig, aR as TileflowMarineSourceIdentity, aS as TileflowModuleOperation, aT as TileflowModulePatch, aU as TileflowNauticalAreaLabelStyles, aV as TileflowNauticalModuleConfig, aW as TileflowNauticalModuleOptions, l as TileflowObservedDataContractV1, aX as TileflowOverlayCollection, aY as TileflowOverlayPlacement, aZ as TileflowPackageDirectory, a_ as TileflowPreparedIconCapabilities, a$ as TileflowRasterDemSourceRequirementV1, b0 as TileflowRefineOperation, b1 as TileflowRemoveOperation, T as TileflowRenderedIconIdentity, b2 as TileflowReset, b3 as TileflowResolvedThemeSelection, b4 as TileflowSemanticModules, c as TileflowSourceRequirementsV1, b5 as TileflowStandaloneMap, e as TileflowStyleOptions, b6 as TileflowTheme, b7 as TileflowThemeAuditContext, b8 as TileflowThemeAuditDiagnostic, b9 as TileflowThemeAuditError, ba as TileflowThemeAuditScope, bb as TileflowThemeColorScheme, bc as TileflowThemeDefinition, bd as TileflowThemeLighting, be as TileflowThemeName, bf as TileflowThemeTokens, bg as TileflowThemeTypography, bh as TileflowThemeTypographyStyle, bi as TileflowTransitModuleConfig, bj as TileflowTransitModuleOptions, bk as TileflowTransitRailStyle, bl as TileflowVegetationMode, bm as TileflowVegetationModuleConfig, bn as TileflowVegetationModuleOptions, bo as TileflowVegetationThreeDimensionalStyle, bp as TileflowVisualValueCategory, bq as TileflowWaterModuleConfig, br as TileflowWaterModuleOptions, bs as TileflowWaterwayClass, bt as TileflowWorldData, bu as TileflowWorldReleaseReference, bv as TileflowWorldSelection, bw as TileflowWorldV1Schema, bx as VectorTilesData, by as addresses, bz as aeroways, bA as assertTileflowMapThemeValues, bB as assertTileflowSdfPixels, bC as auditTileflowMapThemeValues, bD as auditTileflowThemeValues, bE as bathymetry, bF as boundaries, bG as buildings, bH as classifyTileflowVisualProperty, bI as collectTileflowIconSetReferences, bJ as createStyle, bK as createStyleResult, bL as defineTheme, bM as disable, bN as hashTileflowIconComposition, bO as hostedTileset, bP as iconSet, r as inferTileflowDataRequirements, s as inferTileflowSourceRequirements, bQ as isCanonicalOpenMapTilesSchema, bR as isSafeLocalPmtilesPath, bS as isTileflowCompilationPhase, bT as isTileflowIconSetSource, bU as isTileflowLocalDirectory, bV as land, bW as landforms, bX as maplibreOverlay, bY as nautical, bZ as openMapTiles, b_ as openMapTilesContractVersion, b$ as parseTileflowIconComposition, c0 as parseTileflowMap, c1 as refine, c2 as remove, c3 as reset, c4 as resolveMarine, c5 as resolveThemeSelection, c6 as resolveThemeValues, c7 as resolveTileflowData, c8 as resolveTileflowTheme, c9 as tileflowBandPlacements, ca as tileflowBathymetryDemSourceId, cb as tileflowBathymetrySourceId, cc as tileflowBathymetryV1Schema, cd as tileflowIconAppearanceSchema, ce as tileflowIconAuthorMetadataSchema, cf as tileflowIconCompositionMaximumBytes, cg as tileflowIconCompositionSchema, ch as tileflowIconMetadataFileName, ci as tileflowIconSetIdSchema, cj as tileflowIconSetPackageIdSchema, ck as tileflowIconSetReferenceSchema, cl as tileflowIconSetSourceSchema, cm as tileflowIconSetTeamIdSchema, cn as tileflowIconSetVersionIdSchema, co as tileflowIconSourceLimit, cp as tileflowLandformClasses, cq as tileflowLayerBands, cr as tileflowLocalDirectoryMaximumLength, cs as tileflowLocalDirectoryMessage, ct as tileflowMapIdSchema, cu as tileflowNauticalSourceId, cv as tileflowNauticalV1Schema, cw as tileflowPrimarySourceId, cx as tileflowRenderedIconIdentitySchema, cy as tileflowThemeLimits, cz as tileflowWorld, cA as tileflowWorldGeneration, cB as tileflowWorldTileJsonUrl, cC as tileflowWorldV1Schema, cD as transit, cE as validateTileflowCompiledIconCapabilities, v as validateTileflowDataCompatibility, cF as validateTileflowMap, cG as validateTileflowWorldV1Tilejson, cH as vectorTiles, cI as vegetation, cJ as water } from './icon-composition-BiOTwrvD.js';
+import { z } from 'zod';
+import { V as ValidationMessage, f as TileflowExpression, g as TileflowFixedValue, h as TileflowThemeTokenReference, i as TileflowThemeColorOperation, j as TileflowBackgroundStyle, k as TileflowCircleStyle, l as TileflowExtrusionStyle, m as TileflowFillStyle, n as TileflowLineStyle, o as TileflowSymbolStyle, M as MapLibreStyle, p as TileflowRoadsModuleOptions, q as TileflowRoadsModuleConfig, r as TileflowLabelsModuleOptions, s as TileflowLabelsModuleConfig, u as TileflowPoiModuleOptions, v as TileflowPoiModuleConfig } from './manifest-types-CTT2eLbp.js';
+export { w as MapLibreSprite, x as TileflowAerodromeCodeDetail, y as TileflowAlignment, z as TileflowAnalytics, A as TileflowAreaStyle, B as TileflowBackgroundPaint, C as TileflowCirclePaint, D as TileflowColor, E as TileflowColorStyleValue, F as TileflowExtrusionPaint, G as TileflowFillPaint, H as TileflowIconAnchor, I as TileflowIconLayout, J as TileflowIconPaint, K as TileflowIconStyle, L as TileflowIconTextFit, N as TileflowImageStyleValue, O as TileflowLabelDetail, P as TileflowLabelLanguage, Q as TileflowLabelStyles, R as TileflowLayerRange, S as TileflowLight, U as TileflowLineCap, W as TileflowLineHatchStyle, X as TileflowLineJoin, Y as TileflowLineLayout, Z as TileflowLinePaint, _ as TileflowLineStackStyle, $ as TileflowManifestFetchOptions, a0 as TileflowManifestLoadOptions, a1 as TileflowMapMode, a2 as TileflowMapModeOptions, a3 as TileflowMarkerSymbolStyle, a4 as TileflowMountainBikeScale, a5 as TileflowNumberInsetsStyleValue, a6 as TileflowNumberStyleValue, a7 as TileflowPlaceLabelClass, a8 as TileflowPoiCategory, a9 as TileflowPoiCategoryStyle, aa as TileflowPoiColorMode, ab as TileflowPoiDensity, ac as TileflowPriorityOrder, ad as TileflowProjection, ae as TileflowResolvedRuntimeTheme, af as TileflowRoadAreaStyle, ag as TileflowRoadClass, ah as TileflowRoadClassStyle, ai as TileflowRoadCrossingStyle, aj as TileflowRoadDetail, ak as TileflowRoadExtras, al as TileflowRoadHierarchy, am as TileflowRoadLabelDetail, an as TileflowRoadLayerStyle, ao as TileflowRoadModifier, ap as TileflowRoadOutline, aq as TileflowRoadRestriction, ar as TileflowRoadRoundaboutStyle, as as TileflowRoadServiceType, at as TileflowRoadShieldDetail, au as TileflowRoadShieldStyles, av as TileflowRoadSidewalkStyle, aw as TileflowRoadStructure, ax as TileflowRoadTreatmentLayerStyle, ay as TileflowRoadTreatmentLineStyle, az as TileflowRoadTreatmentStyle, aA as TileflowRoadWeight, aB as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, aC as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, aD as TileflowRuntimeSource, aE as TileflowRuntimeSourceValidation, aF as TileflowRuntimeStyle, aG as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, aH as TileflowRuntimeViewOptions, aI as TileflowSessionController, aJ as TileflowSessionGrantResponse, aK as TileflowStringStyleValue, aL as TileflowStructuralStyleValue, aM as TileflowStyleFontFace, aN as TileflowStyleValue, aO as TileflowSymbolPlacement, aP as TileflowSymbolPlacementStyle, aQ as TileflowSymbolZOrder, aR as TileflowTerrain, aS as TileflowTerrainConfig, aT as TileflowTerrainContourLabelStyle, aU as TileflowTerrainContourLineStyle, aV as TileflowTerrainContoursConfig, aW as TileflowTerrainEncoding, aX as TileflowTerrainHillshadeStyle, aY as TileflowTerrainLayerRange, aZ as TileflowTerrainMode, a_ as TileflowTextAnchor, a$ as TileflowTextBackground, b0 as TileflowTextJustify, b1 as TileflowTextLayout, b2 as TileflowTextPaint, b3 as TileflowTextStyle, b4 as TileflowThemeBlendSelection, b5 as TileflowThemeColorAlpha, b6 as TileflowThemeColorMix, b7 as TileflowThemeColorValue, b8 as TileflowThemeFontValue, b9 as TileflowThemeImageValue, ba as TileflowThemeNumberValue, bb as TileflowThemeSelection, bc as TileflowThemeTokenCategory, bd as TileflowThemeValue, be as TileflowViewConfig, bf as TileflowWaterLabelClass, bg as TileflowZoomInterpolation, bh as TileflowZoomValue, bi as ValidationResult, bj as assertValidTileflowRuntimeSource, bk as clearTileflowManifestCache, bl as color, bm as createTileflowSessionController, bn as createTileflowSessionId, bo as defaultTileflowManifestUrl, bp as defaultTileflowRuntimeView, bq as fixed, br as getTileflowAnalyticsApiUrl, bs as getTileflowStyleFontFaces, bt as inferTileflowAnalyticsFromStyleUrl, bu as loadTileflowManifest, bv as mergeTileflowAnalytics, bw as nearestTileflowBlendTheme, bx as normalizeTileflowRuntimeCenter, by as normalizeTileflowStaticImageSize, bz as normalizeTileflowUrl, bA as resolveTileflowAnalyticsRequestUrl, bB as resolveTileflowManifestMap, bC as resolveTileflowMapMode, bD as resolveTileflowRuntimeStyle, bE as resolveTileflowRuntimeTheme, bF as resolveTileflowRuntimeThemeBlend, bG as resolveTileflowRuntimeView, bH as resolveTileflowStaticImageUrl, bI as shouldLoadTileflowManifest, bJ as startTileflowSession, bK as tileflowPoiCategories, t as tileflowRuntimeManifestLimits, e as tileflowRuntimeManifestVersion, bL as tileflowStyleFontFaceLimits, bM as tileflowStyleFontFacesMetadataKey, bN as tileflowThemeBlendLimits, bO as tileflowThemeTokenCategories, bP as token, bQ as validateTileflowRuntimeSource, bR as validateTileflowThemeBlendSelection, bS as validateTileflowThemeSelection, bT as zoom } from './manifest-types-CTT2eLbp.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-D6soWztE.js';
+export { tileflowPortableIdSchema, tileflowThemeNameSchema } from './capture.js';
+export { parseTileflowRuntimeManifest, safeParseTileflowRuntimeManifest, tileflowRuntimeManifestSchema } from './manifest.js';
+
+declare const tileflowPortableIdMaximumLength: 64;
+declare function isTileflowPortableId(value: unknown): value is string;
+declare function isTileflowThemeName(value: unknown): value is string;
+
+/** 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;
+
+/** Portable generated-index shape; geometry and pixel integrity require paired artifact verification. */
+declare const tileflowIconSpriteIndexEntrySchema: z.ZodObject<{
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    pixelRatio: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    sdf: z.ZodOptional<z.ZodLiteral<true>>;
+    tileflow: z.ZodOptional<z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodString;
+            haloWidth: z.ZodNumber;
+            haloBlur: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>;
+declare const tileflowIconSpriteIndexSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    pixelRatio: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    sdf: z.ZodOptional<z.ZodLiteral<true>>;
+    tileflow: z.ZodOptional<z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodString;
+            haloWidth: z.ZodNumber;
+            haloBlur: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>>;
+type TileflowIconSpriteIndexEntry = z.infer<typeof tileflowIconSpriteIndexEntrySchema>;
+type TileflowIconSpriteIndex = z.infer<typeof tileflowIconSpriteIndexSchema>;
+
+type PremultipliedColor = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+type TileflowIconPreviewPaint = {
+    color: PremultipliedColor;
+    haloColor: PremultipliedColor;
+    haloWidth: number;
+    haloBlur: number;
+};
+declare function resolveTileflowIconPreviewPaint(appearance: TileflowIconAppearance): TileflowIconPreviewPaint;
+/** Self-contained runtime for default-appearance previews and static canvas composition. */
+declare function createTileflowIconPreviewRuntime(): {
+    render: (rgba: Uint8Array, pixelRatio: number, paint: TileflowIconPreviewPaint) => Uint8ClampedArray;
+};
+/** Preserve RGBA cells and replace only SDF rectangles with their default appearance. */
+declare function renderTileflowIconAtlasPixels(rgba: Uint8Array, width: number, height: number, index: TileflowIconSpriteIndex): Uint8ClampedArray;
+
+/** 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>;
+
+/** 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 id(): TileflowExpression<string | number | null>;
+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 globalState(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 modulo(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;
+    id: typeof id;
+    featureState: typeof featureState;
+    globalState: typeof globalState;
+    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;
+    modulo: typeof modulo;
+    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 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;
+}>;
+/**
+ * Where a render pass draws, or where a refinement moves its target: at a band edge, or
+ * immediately above or below one semantic target. Operations sharing a placement paint in
+ * declaration order, the first lowest.
+ */
+type TileflowRenderPlacement = TileflowBandPlacement | {
+    readonly above: string;
+    readonly below?: never;
+} | {
+    readonly above?: never;
+    readonly below: string;
+};
+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 = {
     /**
-     * Domains allowed to load this map in production (e.g. "example.com" or
-     * "*.example.com"). When set, tile and session requests from other
-     * websites are rejected. Local development (localhost, private network
-     * addresses) is always allowed. Leave unset to allow any domain.
+     * A band edge, or above/below one semantic target. Passes placed beside a target take its
+     * band and, without their own `feature`, its vector data.
      */
-    allowedOrigins?: string[];
-};
-type TileflowMapConfig = TileflowConfig;
-type TileflowTilesetConfig = {
-    id?: string;
-    name?: string;
-    attribution?: string;
-    sourceLayers?: TileflowSourceLayers;
-};
-type TileflowProjectConfig = {
-    themes?: Record<string, TileflowThemeConfig>;
-    tilesets?: Record<string, TileflowTilesetConfig>;
-    maps: Record<string, TileflowMapConfig>;
-};
-type TileflowStyleOptions = {
-    themes?: Record<string, TileflowThemeConfig>;
-    tileBaseUrl?: string;
-    tileset?: string;
-};
-type TileflowManifest = {
-    version: 1;
-    tileBaseUrl: string;
-    styles: Record<string, string>;
-    maps: Record<string, string>;
-};
-type MapLibreStyle = {
-    version: 8;
-    name: string;
-    glyphs?: string;
-    sprite?: string;
-    sources: Record<string, Record<string, unknown>>;
-    layers: Array<Record<string, unknown>>;
-    terrain?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-};
-type ValidationMessage = {
-    level: 'error' | 'warning';
-    path: string;
-    message: string;
+    readonly placement: TileflowRenderPlacement;
+    /** 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> = {
+    /** Moves the target, with every pass placed beside it, to another position. */
+    readonly placement?: TileflowRenderPlacement;
+    /** 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;
+};
+/** A refinement that only moves its target, keeping its style and selection. */
+type TileflowPlacementRefinement = {
+    readonly placement: TileflowRenderPlacement;
+    readonly renderer?: never;
+    readonly requirements?: readonly TileflowLayerDomain[];
+    readonly selector?: never;
+    readonly style?: never;
+    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> | TileflowPlacementRefinement;
+type TileflowRenderTargetRefinement = TileflowRenderTargetRefinementInput & {
+    readonly kind: 'refine-render-target';
 };
-type ValidationResult = {
-    valid: boolean;
-    messages: ValidationMessage[];
+type TileflowRenderStackOperation = TileflowRenderPass | TileflowRenderTargetRefinement;
+type TileflowNamedRenderStack = Readonly<Record<string, TileflowRenderStackOperation>>;
+type TileflowModuleWithRenderStack<TModule extends {
+    readonly type: TileflowLayerDomain;
+}, TStack extends TileflowNamedRenderStack> = TModule & {
+    readonly renderStack: TStack;
 };
-declare function createStyle(input?: TileflowConfig, options?: TileflowStyleOptions): MapLibreStyle;
-declare function createStyleFromProject(projectConfig: TileflowProjectConfig, mapName: string, options?: TileflowStyleOptions): MapLibreStyle;
-declare function createManifest(projectConfig: TileflowProjectConfig, options?: {
-    styleBaseUrl?: string;
-    tileBaseUrl?: string;
-}): TileflowManifest;
-declare function getDefaultColors(): TileflowColors;
+/** 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>;
 
-declare function validateConfig(input: unknown): ValidationResult;
+/** Internal compiler identity. Authoring maps never select or version this implementation. */
+declare const tileflowSemanticCompilerIdentity: Readonly<{
+    readonly name: "tileflow-semantic";
+    readonly version: 1;
+}>;
 
-declare function defineTileflow(config: TileflowProjectConfig): TileflowProjectConfig;
+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;
+        placements: Readonly<{
+            bands: readonly string[];
+            targets: 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 function osm(options?: TileflowOsmBasemapOptions): TileflowOsmBasemapConfig;
+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;
 
-export { type MapLibreStyle, type TileflowBasemapConfig, type TileflowBuildings, type TileflowColorConfig, type TileflowColors, type TileflowConfig, type TileflowDensity, type TileflowFontWeight, type TileflowLabels, type TileflowManifest, type TileflowMapConfig, type TileflowModuleConfig, type TileflowOsmBasemapConfig, type TileflowOsmBasemapOptions, type TileflowPoi, type TileflowProjectConfig, type TileflowRoads, type TileflowRoadsModuleConfig, type TileflowRoadsModuleOptions, type TileflowRoadsModulePreset, type TileflowSourceLayers, type TileflowStyleOptions, type TileflowTerrain, type TileflowTerrainConfig, type TileflowTerrainEncoding, type TileflowTerrainMode, type TileflowTheme, type TileflowThemeConfig, type TileflowThemeMode, type TileflowTiles, type TileflowTilesetConfig, type TileflowTypography, type TileflowViewConfig, type ValidationMessage, type ValidationResult, createManifest, createStyle, createStyleFromProject, defineTileflow, getDefaultColors, osm, roads, validateConfig };
+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;
+
+/**
+ * Line-fitted text backgrounds through derived glyph stacks.
+ *
+ * MapLibre paints an SDF text halo wherever a glyph's distance value lies between the halo edge,
+ * `(6 - haloWidth / fontScale) / 8`, and the fill edge at 0.75. A derived glyph keeps its source
+ * advance and distance field, and also carries a rectangular cell encoded at distance 0.5. With
+ * `text-halo-width` equal to `text-size / 6`, the halo edge sits at 0.25, so the halo pass paints
+ * exactly those cells: every shaped line receives one strip fitted to its own width. Shaping, line
+ * breaking, collision, anchors and fading remain the renderer's, and no renderer change is needed.
+ *
+ * Cells overlap their neighbours, which keeps strips seamless but requires an opaque colour.
+ *
+ * Glyph units are MapLibre's 24px em. x is relative to a glyph's pen position and y to the line
+ * origin before MapLibre's -17 shaping offset; bitmap row 0, including the 3px border, sits at
+ * y = -20 - top.
+ */
+/** Metrics a derived stack bakes into its glyphs. Every value is in ems. */
+type TileflowLineBackgroundMetrics = {
+    /** Must equal the layer's constant `text-letter-spacing`. */
+    letterSpacing: number;
+    /** Must equal the layer's constant `text-line-height`; rows are exactly this tall. */
+    lineHeight: number;
+    /** Strip extension beyond the first and last glyph of each line. */
+    padding: number;
+};
+type TileflowLineBackgroundFontStack = {
+    metrics: TileflowLineBackgroundMetrics;
+    source: string;
+};
+declare const tileflowLineBackgroundDefaults: Readonly<TileflowLineBackgroundMetrics>;
+declare const tileflowLineBackgroundLimits: Readonly<{
+    letterSpacing: Readonly<{
+        max: 0.5;
+        min: 0;
+    }>;
+    lineHeight: Readonly<{
+        max: 3;
+        min: 0.8;
+    }>;
+    padding: Readonly<{
+        max: 1;
+        min: 0;
+    }>;
+}>;
+/** `text-halo-width` per unit of `text-size` that places the halo edge on the derived cells. */
+declare const tileflowLineBackgroundHaloRatio: number;
+/** Rounds metrics to the thousandths a stack name encodes and checks their ranges. */
+declare function normalizeTileflowLineBackgroundMetrics(metrics?: Partial<TileflowLineBackgroundMetrics>): TileflowLineBackgroundMetrics;
+/** Names the derived stack for one source stack: `<source> lines-v1-t<ls>-l<lh>-p<pad>`. */
+declare function createTileflowLineBackgroundFontStack(source: string, metrics?: Partial<TileflowLineBackgroundMetrics>): string;
+/** Recognizes a derived stack name; returns undefined for ordinary or out-of-range names. */
+declare function parseTileflowLineBackgroundFontStack(stack: string): TileflowLineBackgroundFontStack | undefined;
+/**
+ * Scales a lowered MapLibre `text-size` value to the matching `text-halo-width`. Zoom curves keep
+ * their stops, because `zoom` may only be the input of a top-level `interpolate` or `step`.
+ */
+declare function scaleTileflowTextSizeForLineBackground(size: unknown): unknown;
+/**
+ * Derives one MapLibre glyph PBF range. Every glyph keeps its id, advance and distance field and
+ * gains the background cell; the range and stack names are preserved.
+ */
+declare function deriveTileflowLineBackgroundGlyphs(range: Uint8Array, metrics?: Partial<TileflowLineBackgroundMetrics>): Uint8Array;
+
+declare const tileflowIconPackageFileNames: readonly ["sprite.json", "sprite.png", "sprite@2x.json", "sprite@2x.png"];
+type TileflowIconPackageFileName = (typeof tileflowIconPackageFileNames)[number];
+/** 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;
+    readonly maxDecodedPixelsPerIcon: 4194304;
+    readonly maxGeneratedFileBytes: number;
+    readonly maxGeneratedPackageBytes: number;
+    readonly maxIconCount: 1000;
+    readonly maxSourceBytes: number;
+    readonly maxSourceFileBytes: number;
+};
+/**
+ * Portable compatibility values shared by the public CLI and hosted policy.
+ * Commercial entitlements still belong to the database package.
+ */
+declare const tileflowHostedAlphaCompatibility: {
+    readonly iconPackages: {
+        readonly maxGeneratedBytesPerProject: number;
+        readonly maxRetainedPerProject: 24;
+    };
+    readonly maxMapsPerDeploy: 20;
+};
+declare const tileflowIconPackageContentHashSchema: z.ZodString;
+declare const tileflowIconIdSchema: z.ZodString;
+declare const tileflowRenderedIconManifestEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    appearance: z.ZodOptional<z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodString;
+            haloWidth: z.ZodNumber;
+            haloBlur: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    layout: z.ZodOptional<z.ZodObject<{
+        stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strict>>;
+    pixelSha256: z.ZodObject<{
+        oneX: z.ZodString;
+        twoX: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const tileflowIconPackageLabelSchema: z.ZodString;
+declare const tileflowIconPackageManifestSchema: z.ZodObject<{
+    files: z.ZodTuple<[z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>], null>;
+    format: z.ZodEnum<{
+        "tileflow-icon-package-v1": "tileflow-icon-package-v1";
+        "tileflow-icon-package-v2": "tileflow-icon-package-v2";
+    }>;
+    iconNames: z.ZodArray<z.ZodString>;
+    renderedIcons: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        appearance: z.ZodOptional<z.ZodObject<{
+            representation: z.ZodLiteral<"sdf">;
+            defaults: z.ZodObject<{
+                color: z.ZodString;
+                haloColor: z.ZodString;
+                haloWidth: z.ZodNumber;
+                haloBlur: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+        pixelSha256: z.ZodObject<{
+            oneX: z.ZodString;
+            twoX: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    sprites: z.ZodObject<{
+        oneX: z.ZodObject<{
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+            pixelRatio: z.ZodLiteral<1>;
+        }, z.core.$strict>;
+        twoX: z.ZodObject<{
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+            pixelRatio: z.ZodLiteral<2>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type TileflowIconPackageManifest = z.infer<typeof tileflowIconPackageManifestSchema>;
+type TileflowRenderedIconManifestEntry = z.infer<typeof tileflowRenderedIconManifestEntrySchema>;
+declare function compareCodeUnits(left: string, right: string): number;
+declare function serializeCanonicalJson(value: unknown): string;
+declare function serializeTileflowIconPackageManifest(input: TileflowIconPackageManifest): string;
+declare function sha256Hex(input: string | Uint8Array): Promise<string>;
+declare function hashTileflowIconPackageManifest(input: TileflowIconPackageManifest): Promise<string>;
+/**
+ * Hashes the delivered pixels of one rendered icon without including its name.
+ *
+ * The v1 binary frame is the UTF-8 domain `tileflow-rendered-icon-pixels-v1\0`, followed by one
+ * byte for the pixel ratio, unsigned 32-bit big-endian width and height, then row-major RGBA.
+ * Fully transparent pixels have their RGB channels zeroed in a copy before hashing so invisible
+ * decoder data cannot create a visual difference.
+ */
+declare function hashTileflowRenderedIconPixels(input: {
+    height: number;
+    pixelRatio: 1 | 2;
+    rgba: Uint8Array;
+    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;
+    beforeBytes: number;
+    modified: string[];
+    removed: string[];
+    unchangedCount: number;
+};
+declare function diffTileflowIconPackageManifests(before: TileflowIconPackageManifest | null, after: TileflowIconPackageManifest | null): TileflowIconManifestDiff;
+
+declare const tileflowIconsLockfileName = "tileflow.icons.lock.json";
+declare const tileflowIconsLockfileMaximumBytes: number;
+declare const tileflowIconSetPinSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    setId: z.ZodString;
+    versionId: z.ZodString;
+    version: z.ZodNumber;
+    packageId: z.ZodString;
+    contentHash: z.ZodString;
+    manifest: z.ZodObject<{
+        files: z.ZodTuple<[z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>], null>;
+        format: z.ZodEnum<{
+            "tileflow-icon-package-v1": "tileflow-icon-package-v1";
+            "tileflow-icon-package-v2": "tileflow-icon-package-v2";
+        }>;
+        iconNames: z.ZodArray<z.ZodString>;
+        renderedIcons: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            appearance: z.ZodOptional<z.ZodObject<{
+                representation: z.ZodLiteral<"sdf">;
+                defaults: z.ZodObject<{
+                    color: z.ZodString;
+                    haloColor: z.ZodString;
+                    haloWidth: z.ZodNumber;
+                    haloBlur: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            layout: z.ZodOptional<z.ZodObject<{
+                stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>;
+            pixelSha256: z.ZodObject<{
+                oneX: z.ZodString;
+                twoX: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        sprites: z.ZodObject<{
+            oneX: z.ZodObject<{
+                height: z.ZodNumber;
+                width: z.ZodNumber;
+                pixelRatio: z.ZodLiteral<1>;
+            }, z.core.$strict>;
+            twoX: z.ZodObject<{
+                height: z.ZodNumber;
+                width: z.ZodNumber;
+                pixelRatio: z.ZodLiteral<2>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    spriteUrl: z.ZodString;
+}, z.core.$strict>;
+declare const tileflowIconsLockfileSchema: z.ZodObject<{
+    lockfileVersion: z.ZodLiteral<1>;
+    sets: z.ZodRecord<z.ZodString, z.ZodObject<{
+        teamId: z.ZodString;
+        setId: z.ZodString;
+        versionId: z.ZodString;
+        version: z.ZodNumber;
+        packageId: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            files: z.ZodTuple<[z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>], null>;
+            format: z.ZodEnum<{
+                "tileflow-icon-package-v1": "tileflow-icon-package-v1";
+                "tileflow-icon-package-v2": "tileflow-icon-package-v2";
+            }>;
+            iconNames: z.ZodArray<z.ZodString>;
+            renderedIcons: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                appearance: z.ZodOptional<z.ZodObject<{
+                    representation: z.ZodLiteral<"sdf">;
+                    defaults: z.ZodObject<{
+                        color: z.ZodString;
+                        haloColor: z.ZodString;
+                        haloWidth: z.ZodNumber;
+                        haloBlur: z.ZodNumber;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                layout: z.ZodOptional<z.ZodObject<{
+                    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strict>>;
+                pixelSha256: z.ZodObject<{
+                    oneX: z.ZodString;
+                    twoX: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            sprites: z.ZodObject<{
+                oneX: z.ZodObject<{
+                    height: z.ZodNumber;
+                    width: z.ZodNumber;
+                    pixelRatio: z.ZodLiteral<1>;
+                }, z.core.$strict>;
+                twoX: z.ZodObject<{
+                    height: z.ZodNumber;
+                    width: z.ZodNumber;
+                    pixelRatio: z.ZodLiteral<2>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        spriteUrl: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type TileflowIconSetPin = z.infer<typeof tileflowIconSetPinSchema>;
+type TileflowIconsLockfileV1 = z.infer<typeof tileflowIconsLockfileSchema>;
+/** Parse a complete snapshot; no credentials, originals or floating versions belong in a lock. */
+declare function parseTileflowIconsLockfile(input: unknown, sources?: readonly TileflowIconSource[]): Promise<TileflowIconsLockfileV1>;
+declare function serializeTileflowIconsLockfile(input: TileflowIconsLockfileV1): Promise<string>;
+
+/** Bounded JSON parser which rejects duplicate keys, including escaped equivalents. */
+declare function parseTileflowIconJson(text: string, maximumBytes: number): unknown;
+
+declare const tileflowIconLayoutFields: {
+    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+};
+/** Asset-owned geometry in logical pixels; sprite indexes scale it by pixelRatio. */
+declare const tileflowIconLayoutSchema: z.ZodObject<{
+    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strict>;
+type TileflowIconLayoutMetadata = z.infer<typeof tileflowIconLayoutSchema>;
+declare function assertTileflowIconLayoutBounds(layout: TileflowIconLayoutMetadata, width: number, height: number): void;
+/** Read only native layout fields; other sprite fields retain their own validation. */
+declare function readTileflowIconLayout(entry: Partial<TileflowIconLayoutMetadata>): TileflowIconLayoutMetadata | undefined;
+declare function scaleTileflowIconLayout(layout: TileflowIconLayoutMetadata, scale: number): TileflowIconLayoutMetadata;
+
+export { MapLibreStyle, OpenMapTilesFieldBindings, OpenMapTilesLayerBindings, ResolveMapOptions, ResolvedTileflowMap, type TileflowAuthoringCommand, type TileflowAuthoringCommandName, type TileflowAuthoringCommandOutputKind, type TileflowAuthoringExpressionBuilder, type TileflowAuthoringManifest, type TileflowAuthoringManifestDomain, type TileflowAuthoringOperation, TileflowBackgroundStyle, TileflowBandPlacement, 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, TileflowIconAppearance, type TileflowIconLayoutMetadata, type TileflowIconManifestDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, type TileflowIconPreviewPaint, type TileflowIconSetPin, TileflowIconSource, type TileflowIconSpriteIndex, type TileflowIconSpriteIndexEntry, type TileflowIconsLockfileV1, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, type TileflowLineBackgroundFontStack, type TileflowLineBackgroundMetrics, 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 TileflowRenderPlacement, type TileflowRenderScalar, type TileflowRenderSelector, type TileflowRenderStackOperation, 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, assertTileflowIconLayoutBounds, compareCodeUnits, createTileflowIconPreviewRuntime, createTileflowLineBackgroundFontStack, defineMap, deriveTileflowLineBackgroundGlyphs, diffTileflowIconPackageManifests, diffTileflowMaps, expr, field, hashTileflowFontBundleManifest, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, isTileflowPortableId, isTileflowThemeName, isTileflowWorldReleaseId, labels, normalizeTileflowLineBackgroundMetrics, parseResolvedTileflowMap, parseTileflowIconJson, parseTileflowIconsLockfile, parseTileflowLineBackgroundFontStack, poi, readTileflowIconLayout, refineRenderTarget, renderPass, renderTileflowIconAtlasPixels, resolveMap, resolveTileflowIconPreviewPaint, roads, scaleTileflowIconLayout, scaleTileflowTextSizeForLineBackground, serializeCanonicalJson, serializeTileflowFontBundleManifest, serializeTileflowIconPackageManifest, serializeTileflowIconsLockfile, sha256Hex, tileflowAuthoringManifest, tileflowAuthoringManifestSchemaVersion, tileflowCompilationPhases, tileflowCompilationPlannerStages, tileflowCompilationReportSchemaVersion, tileflowFontBundleContentHashSchema, tileflowFontBundleLimits, tileflowFontBundleManifestSchema, tileflowHostedAlphaCompatibility, tileflowHostedSourceLimit, tileflowIconIdPattern, tileflowIconIdSchema, tileflowIconLayoutFields, tileflowIconLayoutSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowIconSetPinSchema, tileflowIconSpriteIndexEntrySchema, tileflowIconSpriteIndexSchema, tileflowIconsLockfileMaximumBytes, tileflowIconsLockfileName, tileflowIconsLockfileSchema, tileflowLineBackgroundDefaults, tileflowLineBackgroundHaloRatio, tileflowLineBackgroundLimits, tileflowMapDefaultMaxDepth, tileflowOverlayPlacements, tileflowPoiImageRoles, tileflowPortableIdMaximumLength, tileflowRenderSelectorComparisons, tileflowRenderSelectorGeometries, tileflowRenderSelectorKinds, tileflowRenderStackLimits, tileflowRenderStackRenderers, tileflowRenderedIconManifestEntrySchema, tileflowRoadClasses, tileflowSemanticDiffSchemaVersion, tileflowWorldReleaseIdMaximumLength, tileflowWorldReleaseIdMinimumLength, tileflowWorldReleaseIdPattern, tileflowWorldReleaseIdPatternSource, tileflowWorldReleaseIdSchema, withRenderStack };