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

package/dist/index.d.ts

@@ -1,172 +1,298 @@
-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;
-    /**
-     * 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.
-     */
-    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;
+import { m as TileflowDerivedMap, n as TileflowMapScene, o as TileflowRootMap, T as TileflowMap, p as ResolveMapOptions, R as ResolvedTileflowMap } from './requirements-BV77ZVhR.js';
+export { q as ResolvedBathymetry, r as ResolvedBathymetryRelief, s as ResolvedMarine, t as ResolvedMarineSource, u as ResolvedTileflowTheme, w as ResolvedTileflowThemeTokens, x as TileflowBathymetryConfig, y as TileflowBathymetryDemSourceIdentity, z as TileflowBathymetryDisplay, A as TileflowBathymetryOptions, B as TileflowBathymetryReliefConfig, e as TileflowDataCompatibilityIssue, f as TileflowDataFieldRequirement, g as TileflowDataFieldType, h as TileflowDataLayerRequirement, a as TileflowDataRequirementsV1, C as TileflowFontDirectory, D as TileflowGlyphs, E as TileflowHostedDelivery, F as TileflowIconDirectory, G as TileflowLocalDirectory, H as TileflowMapDelivery, I as TileflowMapDesign, J as TileflowMapIdentity, K as TileflowMapRoot, L as TileflowMapTooling, M as TileflowMarine, N as TileflowMarineConfig, O as TileflowMarineMode, P as TileflowMarineSourceConfig, Q as TileflowMarineSourceIdentity, i as TileflowObservedDataContractV1, S as TileflowPackageDirectory, U as TileflowRasterDemSourceRequirementV1, V as TileflowResolvedThemeSelection, b as TileflowSourceRequirementsV1, c as TileflowStyleOptions, W as TileflowTheme, X as TileflowThemeAuditContext, Y as TileflowThemeAuditDiagnostic, Z as TileflowThemeAuditEffectKind, _ as TileflowThemeAuditError, $ as TileflowThemeAuditScope, a0 as TileflowThemeColorScheme, a1 as TileflowThemeDefinition, a2 as TileflowThemeLighting, a3 as TileflowThemeName, a4 as TileflowThemeTokens, a5 as TileflowThemeTypography, a6 as TileflowThemeTypographyStyle, a7 as assertTileflowMapThemeValues, a8 as auditTileflowMapThemeValues, a9 as auditTileflowThemeValues, aa as bathymetry, ab as createStyle, ac as defineTheme, k as inferTileflowDataRequirements, l as inferTileflowSourceRequirements, ad as isTileflowLocalDirectory, ae as parseTileflowMap, af as resolveMarine, ag as resolveThemeSelection, ah as resolveThemeValues, ai as resolveTileflowTheme, aj as tileflowBathymetryDemSourceId, ak as tileflowBathymetrySourceId, al as tileflowBathymetryV1Schema, am as tileflowLocalDirectoryMaximumLength, an as tileflowLocalDirectoryMessage, ao as tileflowMapIdSchema, ap as tileflowNauticalSourceId, aq as tileflowNauticalV1Schema, v as validateTileflowDataCompatibility, ar as validateTileflowMap } from './requirements-BV77ZVhR.js';
+import { n as ValidationMessage, M as MapLibreStyle, o as TileflowRoadsModuleOptions, p as TileflowRoadsModuleConfig, q as TileflowLabelsModuleOptions, r as TileflowLabelsModuleConfig, s as TileflowPoiModuleOptions, u as TileflowPoiModuleConfig } from './types-DlUGI6LC.js';
+export { v as MapLibreSprite, w as TileflowAerodromeCodeDetail, x as TileflowAlignment, y as TileflowAreaStyle, z as TileflowBackgroundPaint, A as TileflowBackgroundStyle, B as TileflowCirclePaint, C as TileflowCircleStyle, D as TileflowColor, E as TileflowColorStyleValue, F as TileflowExpression, G as TileflowExtrusionPaint, H as TileflowExtrusionStyle, I as TileflowFillPaint, a as TileflowFillStyle, J as TileflowFilterExpression, K as TileflowFixedValue, L as TileflowIconAnchor, N as TileflowIconLayout, O as TileflowIconPaint, P as TileflowIconStyle, Q as TileflowIconTextFit, S as TileflowImageStyleValue, U as TileflowLabelDetail, W as TileflowLabelLanguage, X as TileflowLabelStyles, Y as TileflowLayerRange, k as TileflowLight, Z as TileflowLineCap, _ as TileflowLineHatchStyle, $ as TileflowLineJoin, a0 as TileflowLineLayout, a1 as TileflowLinePaint, a2 as TileflowLineStackStyle, b as TileflowLineStyle, a3 as TileflowMountainBikeScale, a4 as TileflowNumberInsetsStyleValue, a5 as TileflowNumberStyleValue, a6 as TileflowPlaceLabelClass, a7 as TileflowPoiCategory, a8 as TileflowPoiCategoryStyle, a9 as TileflowPoiColorMode, aa as TileflowPoiDensity, l as TileflowProjection, ab as TileflowRoadAreaStyle, ac as TileflowRoadClass, ad as TileflowRoadClassStyle, ae as TileflowRoadCrossingStyle, af as TileflowRoadDetail, ag as TileflowRoadExtras, ah as TileflowRoadHierarchy, ai as TileflowRoadLabelDetail, aj as TileflowRoadLayerStyle, ak as TileflowRoadModifier, al as TileflowRoadOutline, am as TileflowRoadRestriction, an as TileflowRoadRoundaboutStyle, ao as TileflowRoadServiceType, ap as TileflowRoadShieldDetail, aq as TileflowRoadShieldStyles, ar as TileflowRoadSidewalkStyle, as as TileflowRoadStructure, at as TileflowRoadTreatmentLayerStyle, au as TileflowRoadTreatmentLineStyle, av as TileflowRoadTreatmentStyle, aw as TileflowRoadWeight, ax as TileflowStringStyleValue, ay as TileflowStructuralStyleValue, az as TileflowStyleValue, aA as TileflowSymbolPlacement, aB as TileflowSymbolPlacementStyle, c as TileflowSymbolStyle, aC as TileflowSymbolZOrder, m as TileflowTerrain, aD as TileflowTerrainConfig, aE as TileflowTerrainContourLabelStyle, aF as TileflowTerrainContourLineStyle, aG as TileflowTerrainContoursConfig, e as TileflowTerrainEncoding, d as TileflowTerrainHillshadeStyle, aH as TileflowTerrainLayerRange, aI as TileflowTerrainMode, aJ as TileflowTextAnchor, aK as TileflowTextJustify, aL as TileflowTextLayout, aM as TileflowTextPaint, aN as TileflowTextStyle, aO as TileflowThemeColorAlpha, aP as TileflowThemeColorMix, aQ as TileflowThemeColorOperation, g as TileflowThemeColorValue, h as TileflowThemeFontValue, i as TileflowThemeImageValue, f as TileflowThemeNumberValue, aR as TileflowThemeTokenCategory, aS as TileflowThemeTokenReference, aT as TileflowThemeValue, T as TileflowViewConfig, aU as TileflowWaterLabelClass, aV as TileflowZoomInterpolation, aW as TileflowZoomValue, V as ValidationResult, aX as color, aY as expression, aZ as filter, a_ as fixed, a$ as tileflowPoiCategories, b0 as token, b1 as zoom } from './types-DlUGI6LC.js';
+export { N as NormalizedTileflowCaptureScene, a as TileflowCaptureApplicationTarget, b as TileflowCaptureBoundsCamera, c as TileflowCaptureCamera, d as TileflowCaptureCenterCamera, e as TileflowCaptureMapTarget, T as TileflowCaptureScene, f as TileflowCaptureTarget, g as TileflowCaptureViewport, n as normalizeTileflowCaptureId, h as normalizeTileflowCaptureScene, t as tileflowCaptureApplicationTargetSchema, i as tileflowCaptureBoundsCameraSchema, j as tileflowCaptureCameraSchema, k as tileflowCaptureCenterCameraSchema, l as tileflowCaptureIdSchema, m as tileflowCaptureMapTargetSchema, o as tileflowCaptureSceneLimits, p as tileflowCaptureSceneNameSchema, q as tileflowCaptureSceneSchema, r as tileflowCaptureSceneSchemaVersion, s as tileflowCaptureTargetSchema, u as tileflowCaptureViewportSchema } from './capture-scene-BK_0J2oR.js';
+export { tileflowPortableIdSchema, tileflowThemeNameSchema } from './capture.js';
+export { T as TileflowAnalytics, f as TileflowManifestFetchOptions, g as TileflowManifestLoadOptions, h as TileflowMapMarker, i as TileflowMapMode, j as TileflowMapModeOptions, k as TileflowResolvedRuntimeTheme, l as TileflowRuntimeCenterLike, d as TileflowRuntimeColorScheme, e as TileflowRuntimeManifest, m as TileflowRuntimeManifestMap, n as TileflowRuntimeManifestMapEntry, o as TileflowRuntimeManifestTheme, p as TileflowRuntimeSource, q as TileflowRuntimeSourceValidation, b as TileflowRuntimeStyle, r as TileflowRuntimeStyleOptions, s as TileflowRuntimeSystemThemes, t as TileflowRuntimeViewOptions, c as TileflowSessionController, u as TileflowSessionGrantResponse, a as TileflowStyleFontFace, v as TileflowThemeSelection, w as assertValidTileflowRuntimeSource, x as clearTileflowManifestCache, y as createTileflowSessionController, z as createTileflowSessionId, A as defaultTileflowManifestUrl, B as defaultTileflowRuntimeView, C as getTileflowAnalyticsApiUrl, D as getTileflowStyleFontFaces, E as inferTileflowAnalyticsFromStyleUrl, F as loadTileflowManifest, G as mergeTileflowAnalytics, H as normalizeTileflowRuntimeCenter, I as normalizeTileflowStaticImageSize, J as normalizeTileflowUrl, K as parseTileflowRuntimeManifest, L as resolveTileflowAnalyticsRequestUrl, M as resolveTileflowManifestMap, N as resolveTileflowMapMode, O as resolveTileflowRuntimeStyle, P as resolveTileflowRuntimeTheme, Q as resolveTileflowRuntimeView, R as resolveTileflowStaticImageUrl, S as safeParseTileflowRuntimeManifest, U as shouldLoadTileflowManifest, V as startTileflowSession, W as tileflowRuntimeManifestLimits, X as tileflowRuntimeManifestSchema, Y as tileflowRuntimeManifestVersion, Z as tileflowStyleFontFaceLimits, _ as tileflowStyleFontFacesMetadataKey, $ as validateTileflowRuntimeSource, a0 as validateTileflowThemeSelection } from './runtime-C4MtSzkB.js';
+export { O as OpenMapTilesFieldBindings, a as OpenMapTilesLayerBindings, f as OpenMapTilesSchema, g as OpenMapTilesSchemaOptions, P as ParkLayerSemantics, R as ResolvedTileflowData, h as TileflowAddressesModuleConfig, i as TileflowAddressesModuleOptions, j as TileflowAerowaysModuleConfig, k as TileflowAerowaysModuleOptions, l as TileflowBoundariesModuleConfig, m as TileflowBoundariesModuleOptions, n as TileflowBuildingMode, o as TileflowBuildingsModuleConfig, p as TileflowBuildingsModuleOptions, d as TileflowDataConfig, q as TileflowDataIdentity, r as TileflowLandModuleConfig, s as TileflowLandModuleOptions, t as TileflowLandcoverClass, u as TileflowLandformClass, v as TileflowLandformsModuleConfig, w as TileflowLandformsModuleOptions, x as TileflowLanduseClass, y as TileflowNauticalAreaLabelStyles, z as TileflowNauticalModuleConfig, A as TileflowNauticalModuleOptions, e as TileflowStreetsModules, B as TileflowTransitModuleConfig, C as TileflowTransitModuleOptions, D as TileflowTransitRailStyle, E as TileflowVegetationMode, F as TileflowVegetationModuleConfig, G as TileflowVegetationModuleOptions, H as TileflowVegetationThreeDimensionalStyle, b as TileflowVisualValueCategory, I as TileflowWaterModuleConfig, J as TileflowWaterModuleOptions, K as TileflowWaterwayClass, L as TileflowWorldData, M as TileflowWorldReleaseReference, N as TileflowWorldSelection, Q as TileflowWorldV1Schema, V as VectorTilesData, S as addresses, U as aeroways, W as boundaries, X as buildings, c as classifyTileflowVisualProperty, Y as isCanonicalOpenMapTilesSchema, Z as land, _ as landforms, $ as nautical, a0 as openMapTiles, a1 as openMapTilesContractVersion, a2 as resolveTileflowData, a3 as tileflowLandformClasses, a4 as tileflowPrimarySourceId, a5 as tileflowWorld, a6 as tileflowWorldGeneration, a7 as tileflowWorldTileJsonUrl, a8 as tileflowWorldV1Schema, a9 as transit, aa as validateTileflowWorldV1Tilejson, ab as vectorTiles, ac as vegetation, ad as water } from './visual-semantics-DTC-8Hsb.js';
+import { z } from 'zod';
+
+declare const tileflowPortableIdMaximumLength: 64;
+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 compiler-root map. */
+declare function defineRootMap<const TMap extends TileflowRootMap>(map: ExactTileflowMap<TileflowRootMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
+/** Preserve the exact inferred type of a map that extends another map object. */
+declare function defineMap<const TMap extends TileflowDerivedMap>(map: ExactTileflowMap<TileflowDerivedMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
+
+declare const tileflowMapDefaultMaxDepth = 64;
+/** 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[]);
+}
+
+type TileflowZoomPerformance = {
+    activeLayers: number;
+    /** @deprecated Use styleLayerFamilies. This is not a count of runtime tile buckets. */
+    estimatedBuckets: number;
+    sourceLayers: Record<string, number>;
+    styleLayerFamilies: number;
+    symbols: number;
+    zoom: number;
 };
-type ValidationResult = {
-    valid: boolean;
-    messages: ValidationMessage[];
+type TileflowStylePerformance = {
+    styleBytes: number;
+    totalLayers: number;
+    zooms: TileflowZoomPerformance[];
 };
-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;
+/** A deterministic, network-free structural sweep of a compiled style. */
+declare function analyzeTileflowStylePerformance(style: MapLibreStyle, zooms?: readonly number[]): TileflowStylePerformance;
 
-declare function validateConfig(input: unknown): ValidationResult;
+declare function roads(options?: TileflowRoadsModuleOptions): TileflowRoadsModuleConfig;
 
-declare function defineTileflow(config: TileflowProjectConfig): TileflowProjectConfig;
+declare function labels(options?: TileflowLabelsModuleOptions): TileflowLabelsModuleConfig;
 
-declare function osm(options?: TileflowOsmBasemapOptions): TileflowOsmBasemapConfig;
+/**
+ * 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 function roads(options?: TileflowRoadsModuleOptions): TileflowRoadsModuleConfig;
+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: 256;
+    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;
+    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.ZodLiteral<"tileflow-icon-package-v1">;
+    iconNames: z.ZodArray<z.ZodString>;
+    renderedIcons: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        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;
 
-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 };
+export { MapLibreStyle, ResolveMapOptions, ResolvedTileflowMap, TileflowDerivedMap, type TileflowFontBundleFile, type TileflowFontBundleFontFace, type TileflowFontBundleManifest, type TileflowIconManifestDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, TileflowMap, TileflowMapScene, TileflowPoiModuleConfig, TileflowPoiModuleOptions, type TileflowRenderedIconManifestEntry, TileflowResolvedMapValidationError, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, type TileflowStylePerformance, type TileflowZoomPerformance, ValidationMessage, analyzeTileflowStylePerformance, compareCodeUnits, defineMap, defineRootMap, diffTileflowIconPackageManifests, hashTileflowFontBundleManifest, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, isTileflowPortableId, isTileflowThemeName, isTileflowWorldReleaseId, labels, poi, resolveMap, roads, serializeCanonicalJson, serializeTileflowFontBundleManifest, serializeTileflowIconPackageManifest, sha256Hex, tileflowFontBundleContentHashSchema, tileflowFontBundleLimits, tileflowFontBundleManifestSchema, tileflowHostedAlphaCompatibility, tileflowIconIdPattern, tileflowIconIdSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowMapDefaultMaxDepth, tileflowPoiImageRoles, tileflowPortableIdMaximumLength, tileflowRenderedIconManifestEntrySchema, tileflowWorldReleaseIdMaximumLength, tileflowWorldReleaseIdMinimumLength, tileflowWorldReleaseIdPattern, tileflowWorldReleaseIdPatternSource, tileflowWorldReleaseIdSchema };