@massif-maps/style-tools 6.1.0-rc.1

package/dist/mapbox2css/index.js

@@ -0,0 +1,3599 @@
+import { isContourLayer, rewriteContourFields, rewriteContourFilter } from './contour.js';
+import { foldCasings } from './casing.js';
+import { Coverage } from './coverage.js';
+import { Untranslatable, expandTokens, setTileDrawSize, translateExpression, zoomInput, zoomOffsetLevels } from './expression.js';
+import { translateFilter, zoomPredicates } from './filter.js';
+import { HANDLED_ELSEWHERE, followsLine, repeatsAlongLine, resolvePlacement } from './placement.js';
+import { KNOWN_GAPS, LAYER_SYMBOLIZER, PROPERTY_MAP, VALUE_MAP } from './properties.js';
+import { PLATE_MAP, asShieldDeclaration, isShieldLayer, plateRadius } from './shield.js';
+import { describeFlatPlate, extractAllIconPlates, extractAllIcons, extractIcon, extractIconPlate } from './sprite.js';
+import { ICON_ALIASES, detectSourceSchema, mapSourceLayer, retargetLayer } from './schema.js';
+import { narrowLayer } from './narrow.js';
+import { collapseBranches, expandSetFilter, expandSortKey, splitLayer } from './split.js';
+import { hoistVariables, paletteHeader } from './variables.js';
+import { LIGHT_PRESET, importOnly, liveConfig, presetsOf, resolveConfig, sceneBrightness } from './config.js';
+import { ICON_PARAMS, ICON_PARAM_SCOPE, RECOLOURABLE_ICON, foldConfig, foldLayer, isPitch, toHsla } from './fold.js';
+import { applyLighting, emissiveDefault, emissiveForLayerType, emissiveProperty, groundRadiance, lightingFactor } from './emissive.js';
+/** The palette is a stylesheet of its own, and has to be listed before the rules that read it. */
+export const VARIABLES_FILE = 'variables.mss';
+/** Two passes share a stylesheet only if they emitted the same rules with the same properties. */
+function aligns(a, b) {
+    if (a.blocks.length !== b.blocks.length || a.mapBlock.length !== b.mapBlock.length)
+        return false;
+    const property = (declaration) => declaration.slice(0, declaration.indexOf(':'));
+    const same = (x, y) => x.length === y.length && x.every((d, i) => property(d) === property(y[i]));
+    if (!same(a.mapBlock, b.mapBlock))
+        return false;
+    return a.blocks.every((block, i) => block.selector === b.blocks[i].selector && same(block.declarations, b.blocks[i].declarations));
+}
+/** MapBox text-anchor -> the CartoCSS (horizontal, vertical) alignment pair. */
+const TEXT_ANCHOR = {
+    center: ['middle', 'middle'],
+    left: ['left', 'middle'],
+    right: ['right', 'middle'],
+    top: ['middle', 'top'],
+    bottom: ['middle', 'bottom'],
+    'top-left': ['left', 'top'],
+    'top-right': ['right', 'top'],
+    'bottom-left': ['left', 'bottom'],
+    'bottom-right': ['right', 'bottom'],
+};
+/**
+ * The `lights` block resolved to the five numbers the ground radiance is a function of. An
+ * intensity may be a zoom ramp, so it takes its representative constant - the top of the ramp,
+ * which is what every zoom a building is drawn at gets.
+ */
+export function sceneLights(lights, fold) {
+    const folded = fold(lights);
+    if (!Array.isArray(folded))
+        return null;
+    const of = (type) => {
+        const light = folded.find((l) => !!l && typeof l === 'object'
+            && l.type === type);
+        return (light?.properties ?? undefined);
+    };
+    const ambient = of('ambient');
+    if (!ambient)
+        return null;
+    // The DIRECTIONAL one is optional: a style may state an ambient alone, and MapBox's radiance
+    // simply has no directional term then. Requiring both left such a style unlit at every preset.
+    const directional = of('directional') ?? {};
+    const number = (value, fallback) => {
+        const reduced = representativeConstant(value);
+        return typeof reduced === 'number' ? reduced : fallback;
+    };
+    const direction = (() => {
+        const value = directional.direction;
+        const list = Array.isArray(value) && value[0] === 'literal' ? value[1] : value;
+        return Array.isArray(list) && list.length === 2 && list.every((v) => typeof v === 'number')
+            ? list : null;
+    })();
+    if (!ambient || typeof ambient.color !== 'string')
+        return null;
+    const lit = typeof directional.color === 'string' && direction !== null;
+    return {
+        ambientColour: ambient.color,
+        ambientIntensity: number(ambient.intensity, 1),
+        directionalColour: lit ? directional.color : 'hsl(0, 0%, 0%)',
+        directionalIntensity: lit ? number(directional.intensity, 1) : 0,
+        directionalPolar: lit ? direction[1] : 0,
+    };
+}
+/**
+ * One constant out of a value that branches, for the properties where a per-feature answer is not
+ * available: an anchor and an offset are baked into the label's layout when the rule is built.
+ *
+ * The branch taken is the LAST - the highest step key, a case's fallback. That is the detailed end
+ * of the ramp and what most features get: Standard anchors a POI by
+ * `step(sizerank, "center", 5, "top")` and every POI in a Paris tile has sizerank 16.
+ */
+function representativeConstant(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string' || typeof value === 'number')
+        return value;
+    if (!Array.isArray(value))
+        return null;
+    const head = value[0];
+    if (head === 'literal')
+        return (value[1] ?? null);
+    // `step` and `interpolate` both end on a value; `interpolate` carries a curve and an input
+    // first, which changes nothing about where the last one is.
+    if ((head === 'step' || head === 'interpolate') && value.length >= 4) {
+        return representativeConstant(value[value.length - 1]);
+    }
+    if ((head === 'case' || head === 'match') && value.length >= 4) {
+        return representativeConstant(value[value.length - 1]);
+    }
+    // A plain array of scalars is already the value - an offset pair.
+    if (value.every((v) => typeof v === 'number'))
+        return value;
+    return null;
+}
+/** Attachment names are identifiers in the CartoCSS grammar. */
+function attachmentName(layerId) {
+    const cleaned = layerId.replace(/[^A-Za-z0-9_]/g, '_');
+    return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
+}
+/**
+ * Which emissive property a translated declaration carries its light on, LONGEST PREFIX FIRST.
+ *
+ * A pattern is its own symbolizer, and a property alone is enough to CREATE one: emitting
+ * `polygon-emissive-strength` on a rule whose only fill is a `polygon-pattern-file` would raise a
+ * second, grey polygon under the pattern. The background is a Map setting rather than a symbolizer
+ * but takes the same term - and it is the largest surface on the map, so leaving it out left a lit
+ * map on an unlit sheet of paper.
+ */
+/** The label emissive properties `--label-emissive` caps, and their halo counterparts. */
+const LABEL_EMISSIVE = new Set(['text-emissive-strength', 'icon-emissive-strength']);
+const HALO_TARGETS = {
+    'text-emissive-strength': 'text-halo-emissive-strength',
+    'shield-emissive-strength': 'shield-halo-emissive-strength',
+    'marker-emissive-strength': 'marker-halo-emissive-strength',
+};
+/** The emissive properties `--geometry-emissive` floors: everything that is not a label. */
+const GEOMETRY_EMISSIVE = new Set(['fill-emissive-strength', 'line-emissive-strength',
+    'background-emissive-strength', 'circle-emissive-strength']);
+/** MapBox's own default for unstated GEOMETRY is 0; a floor lifts it off the floor. */
+function geometryFloor(source, value, floor) {
+    if (floor === undefined || source === null || !GEOMETRY_EMISSIVE.has(source))
+        return value;
+    return Math.max(value ?? 0, floor);
+}
+function haloTargetOf(target) {
+    return HALO_TARGETS[target] ?? null;
+}
+/**
+ * A label's emissive, never above `cap`.
+ *
+ * A stated RAMP is reduced to its representative value first and then capped, so the ramp's shape
+ * is lost - the label dims by the scene light rather than by its own curve over it. That is the
+ * trade the cap makes: Standard states a flat 1 on its shields, and nothing short of overriding
+ * that makes them follow the light at all.
+ */
+function capStops(stated, cap, lookup) {
+    const value = stated === undefined ? 1
+        : typeof stated === 'number' ? stated
+            : representativeEmissive(stated, representativeScale(stated, 1), lookup) ?? 1;
+    const capped = Math.max(0, Math.min(cap, value));
+    return capped >= 1 ? null : String(round(capped));
+}
+const EMISSIVE_TARGETS = [
+    ['polygon-pattern-', 'polygon-pattern-emissive-strength'],
+    ['line-pattern-', 'line-pattern-emissive-strength'],
+    ['polygon-', 'polygon-emissive-strength'],
+    ['line-', 'line-emissive-strength'],
+    ['background-', 'background-emissive-strength'],
+    // An EXTRUSION states its own, and until `building-emissive-strength` existed there was nowhere
+    // to put it: the value was looked up (EMISSIVE_SOURCE maps `building-` to
+    // fill-extrusion-emissive-strength) and then dropped, leaving every building on the Map block's
+    // one global. Standard lights a lit window and a plain facade differently, and both came out
+    // the same.
+    ['building-', 'building-emissive-strength'],
+    // A shield's icon and its text are one symbolizer here, so they take one value - mapbox's
+    // text-emissive-strength, which is the one its own shields state.
+    ['shield-', 'shield-emissive-strength'],
+    ['marker-', 'marker-emissive-strength'],
+    ['text-', 'text-emissive-strength'],
+];
+/**
+ * Targets the SDK already has a FALLBACK for, so an unstated value must stay unstated rather than
+ * take mapbox's property default.
+ *
+ * Everywhere else the default has to be written down, because this SDK draws an unstated colour as
+ * authored where mapbox would light it. An extrusion is the exception: it falls back to the Map
+ * block's `building-emissive-strength`, so emitting mapbox's default 0 here would pin every
+ * converted building to 0 and the global would stop working.
+ */
+const EMISSIVE_NO_DEFAULT = new Set(['building-emissive-strength']);
+export function convert(style, table, options = {}) {
+    options = { ...options, styleParams: options.styleParams ?? new Map() };
+    // Module state, so it has to be set on every call and not only the first - the tests convert
+    // many styles in one process.
+    setTileDrawSize(options.tileDrawSize ?? 256);
+    const coverage = new Coverage();
+    const allowed = new Map(table.properties.map((p) => [p.cartocss, p]));
+    // A style may be configurable (Mapbox Standard). Its config is resolved to constants BEFORE
+    // anything is translated: CartoCSS has no `let`/`to-hsla`/`at`, so a colour left reading its
+    // config converts to nothing at all. See fold.ts.
+    const importsOnly = importOnly(style);
+    if (importsOnly)
+        coverage.drop('the whole style', importsOnly, 'imports');
+    // Which vocabulary the style's own source layers are in. Only read when retargeting, and only
+    // guessed at when the caller did not say - a wrong table draws the wrong features everywhere.
+    const detected = options.schema
+        ? detectSourceSchema((style.layers ?? []).map((l) => l['source-layer'] ?? ''))
+        : null;
+    if (options.schema && !options.sourceSchema) {
+        if (!detected) {
+            throw new Error('cannot tell which schema this style is written against; ' +
+                'pass --source-schema mapbox or --source-schema maptiler');
+        }
+        coverage.approximate(`source layers read as the ${detected} schema`);
+    }
+    const sourceSchema = options.sourceSchema ?? detected ?? 'maptiler';
+    options = { ...options, sourceSchema };
+    const { parameters, undeclared } = resolveConfig(style);
+    for (const name of undeclared) {
+        coverage.approximate(`config "${name}" is read but declared in no schema; took what it was read as`);
+    }
+    const configValues = new Map([...parameters].map(([name, spec]) => [name, spec.default]));
+    for (const [name, value] of Object.entries(options.config ?? {}))
+        configValues.set(name, value);
+    for (const name of liveConfig(style)) {
+        const spec = parameters.get(name);
+        if (!spec) {
+            coverage.approximate(`config "${name}" is asked to stay live but the style never reads it`);
+            continue;
+        }
+        configValues.delete(name);
+        options.styleParams.set(name, spec.values ? { default: spec.default, values: spec.values } : spec.default);
+        coverage.note(`config "${name}" stays a style parameter, settable on a running map`);
+    }
+    if (configValues.size > 0) {
+        coverage.approximate(`${configValues.size} config values baked in` +
+            (configValues.has(LIGHT_PRESET) ? ` (${LIGHT_PRESET} = ${String(configValues.get(LIGHT_PRESET))})` : ''));
+    }
+    // The scene's brightness is a style value here, not a runtime one - see config.ts.
+    const lights = style.lights;
+    // Set while emitting, so the parameter is only declared when there is a building to gate.
+    let usesBuildings = false;
+    // The brightness of the style's OWN default preset, which the emissive fold measures against.
+    // sceneBrightness is an ambient-only proxy, so its absolute value is not a light level - but
+    // the RATIO between two presets of the same style is meaningful, and that is all this needs:
+    // the default preset comes out unlit (factor 1) and every darker one follows it down.
+    const defaultBrightness = lights === undefined ? null
+        : sceneBrightness(lights, (node) => foldConfig(node, new Map([...parameters].map(([name, spec]) => [name, spec.default]))));
+    // Emitting is a function of the config, because a configurable style is converted ONCE PER
+    // PRESET: folding preserves structure (see fold.ts), so the runs line up block for block and
+    // only their literals differ - which is what lets one style.mss carry a palette per preset.
+    function emitAll(values, coverage) {
+        const brightness = lights === undefined ? null : sceneBrightness(lights, (node) => foldConfig(node, values));
+        // MapBox's own light, resolved for THIS preset - what a flat surface facing up receives.
+        const radiance = groundRadiance(lights === undefined ? null
+            : sceneLights(lights, (node) => foldConfig(node, values)));
+        // Under --live-light the SDK resolves the brightness itself, per frame (view::brightness), so
+        // the ramps over it stay live instead of freezing at the preset the conversion was run for.
+        const scene = brightness === null ? {} : { brightness, liveBrightness: options.liveLight === true };
+        // Always, even for a style with no config of its own: the viewport terms fold here too, and a
+        // filter left testing the pitch is untranslatable, which drops the whole LAYER.
+        // Which side of MapBox's 3D switch each layer is on, read BEFORE the fold: folded with the
+        // default config the flat pair resolves to `visibility: none` and is dropped (buildings3DGate).
+        const buildings3D = new Map();
+        for (const layer of style.layers ?? []) {
+            const gate = buildings3DGate(layer);
+            if (gate)
+                buildings3D.set(layer.id, gate);
+        }
+        const layers = (style.layers ?? []).map((raw) => {
+            const layer = applyMassifExtras(raw);
+            const folded = foldLayer(layer, values, scene);
+            if (!buildings3D.has(layer.id))
+                return folded;
+            // The `buildings` parameter carries the switch now, so the visibility must not.
+            const { visibility, ...layout } = folded.layout ?? {};
+            return { ...folded, layout };
+        });
+        if (options.foldCasings) {
+            const { layers: merged, folded, skipped } = foldCasings(layers);
+            if (skipped.length > 0) {
+                coverage.approximate(`${skipped.length} casing layer(s) left unfolded because their fill ` +
+                    `states a line-sort-key (${skipped.map((f) => f.fill).join(', ')}); folded, the casing ` +
+                    'would draw per class and land on the fill of the road beside it');
+            }
+            layers.splice(0, layers.length, ...merged);
+            if (folded.length > 0) {
+                coverage.approximate(`${folded.length} casing layer(s) folded into their fill as line-border-* ` +
+                    `(${folded.map((f) => f.casing).join(', ')}); the casing now draws per class, not under every fill`);
+            }
+        }
+        const mapBlock = [];
+        // Kept as selector + declarations rather than joined text: the palette pass rewrites the
+        // declarations after every layer is in, when it can tell a shared colour from a layer's own.
+        const blocks = [];
+        // Source-layer name -> every MapBox layer index that draws it. One project entry pulls ALL of
+        // them, so the whole source-layer has to sit at one depth and the question is which.
+        const positions = new Map();
+        const drawOrder = [];
+        // The TARGET source layer of every layer that made it through, in style order. Kept separately
+        // because --schema renames them, and the interleaving check has to see what was emitted.
+        const emitted = [];
+        // One map has one answer for each building setting; the first layer to state it wins.
+        const buildingSettingsSeen = new Set();
+        layers.forEach((layer, index) => {
+            if (layer.type === 'background') {
+                mapBlock.push(...light(layer, backgroundProperties(layer, coverage)));
+                return;
+            }
+            // A fill-extrusion's LOOK is a Map setting here, not a symbolizer property: the SDK lights
+            // and bevels every building at once. Taken from the layers that draw the BUILDING source
+            // layer only - Standard's indoor walls state their own ambient occlusion and come first,
+            // so reading every extrusion gave the whole map the shading of an indoor floor plan.
+            if (layer.type === 'fill-extrusion' && BUILDING_LAYER.test(layer['source-layer'] ?? '')) {
+                mapBlock.push(...buildingMapSettings(layer, buildingSettingsSeen, coverage, options.buildingHeightRamp, options.aoFollowsHeight, lights !== undefined));
+            }
+            // The only 3D model worth standing in for is a TREE: Standard draws the whole `tree`
+            // source-layer as models from z15, and dropping it left every park a bare green slab.
+            // A building or a wind turbine has no such reduction, so those are still dropped.
+            if (layer.type === 'model' && layer['source-layer'] !== 'tree') {
+                coverage.drop(`layer type "model"`, 'no 3D models, and no 2D stand-in for this one', layer.id);
+                return;
+            }
+            // CartoCSS draws no raster: a hillshade becomes a composite slot the app fills with its DEM
+            // (CompositeVectorTileLayer), configured with the values `massif:sdk-layer` tuned for the SDK.
+            if (layer.type === 'hillshade' && emitHillshadeSlot(layer, index)) {
+                return;
+            }
+            const symbolizer = LAYER_SYMBOLIZER[layer.type];
+            if (!symbolizer) {
+                coverage.drop(`layer type "${layer.type}"`, 'unsupported layer type', layer.id);
+                return;
+            }
+            const sourceLayer = layer['source-layer'];
+            if (!sourceLayer) {
+                coverage.drop(`layer "${layer.id}"`, 'no source-layer', layer.id);
+                return;
+            }
+            // Retargeting at another tile schema is a rename plus a filter clause - what the source
+            // schema said by splitting into layers, the target says with a `class` field. One source
+            // layer can feed SEVERAL target ones (MapBox draws a road and its name off the same one);
+            // each keeps only the part of the filter that can match it.
+            const targets = [];
+            if (options.schema) {
+                const { mappings, why } = mapSourceLayer(sourceLayer, options.schema, sourceSchema);
+                if (mappings.length === 0) {
+                    coverage.drop(`source-layer "${sourceLayer}"`, why ?? 'no equivalent', layer.id);
+                    return;
+                }
+                // The RAW layer, then folded again per target. foldLayer records which FIELD a
+                // recolourable icon is keyed by, as a bare name; retargeting the folded layer renamed
+                // the expression and left that name behind, so every POI fell back to flat sprite
+                // artwork and lost its category-coloured plate. Folding after the rename costs one
+                // extra fold per target and keeps the two in step.
+                const raw = (style.layers ?? [])[index];
+                for (const mapping of mappings) {
+                    const retargetedLayer = retargetLayer(raw, mapping, sourceSchema, {
+                        dropped: (field) => coverage.approximate(`"${field}" test dropped on "${layer.id}": the target schema has no such field, ` +
+                            'and a test on it can only fail, which would draw nothing at all'),
+                        approximate: (what) => coverage.approximate(`on "${layer.id}": ${what}`),
+                    });
+                    if (!retargetedLayer)
+                        continue;
+                    const folded = foldLayer(retargetedLayer, values, scene);
+                    // Same visibility strip the pre-folded pass does: the `buildings` parameter carries
+                    // the 3D switch now, so the layer's own visibility must not.
+                    const { visibility, ...layout } = buildings3D.has(layer.id) ? (folded.layout ?? {}) : {};
+                    targets.push({
+                        target: mapping.layer,
+                        layer: buildings3D.has(layer.id) ? { ...folded, layout } : folded,
+                    });
+                }
+                if (targets.length === 0) {
+                    coverage.drop(`layer "${layer.id}"`, 'its filter can never match the target schema', layer.id);
+                    return;
+                }
+            }
+            else {
+                targets.push({ target: sourceLayer, layer });
+            }
+            for (const { target, layer: schemaLayer } of targets) {
+                (positions.get(target) ?? positions.set(target, []).get(target)).push(index);
+                emitted.push(target);
+                // The contour schemas name the elevation differently; renaming it here means the filter,
+                // the label and every paint expression all see the field the tiles actually carry.
+                const retargeted = options.contour
+                    ? rewriteContourFields(schemaLayer, options.contour)
+                    : schemaLayer;
+                // A field-driven paint value becomes one attachment per branch, and a line-sort-key one
+                // per key value in draw order - see split.ts.
+                const variants = expandSortKey(isContourLayer(layer) ? retargeted : schemaLayer, coverage)
+                    .flatMap(expandSetFilter)
+                    .flatMap((ordered) => splitLayer(ordered, coverage))
+                    .flatMap((ordered) => splitDashByZoom(ordered, coverage))
+                    .map(narrowLayer);
+                variants.forEach((variant, branch) => {
+                    const suffix = variants.length > 1 ? `_b${branch + 1}` : '';
+                    emitLayer(variant, `${attachmentName(layer.id)}${suffix}`, target, symbolizer, index);
+                });
+            }
+        });
+        /**
+         * Mapbox lights its 2D layers; we draw their colours as authored. Folding the layer's own
+         * emissive-strength into the colour is what makes a night preset read as night - see
+         * emissive.ts, which is also where the limits of the approximation are written down.
+         */
+        function light(layer, declarations) {
+            // The emissive branch does NOT need the scene light: it emits what a layer STATES (or what
+            // mapbox defaults it to), for the renderer to light. A style with no `lights` block of its
+            // own - MapTiler Streets states none - is exactly the case that needs it, because mapbox
+            // defaults geometry to 0 where this SDK draws an unstated colour as authored.
+            if (radiance === null && !options.liveLight)
+                return declarations;
+            // Under --live-light the colour stays as the style authored it and the emissive rides along
+            // instead, for the renderer to apply. A value of 1 is never emitted: it is the default on
+            // both sides, and it is what most of Standard's labels resolve to.
+            if (options.liveLight) {
+                const emitted = new Set();
+                const extra = [];
+                for (const declaration of declarations) {
+                    const property = declaration.slice(0, declaration.indexOf(':'));
+                    const target = EMISSIVE_TARGETS.find(([prefix]) => property.startsWith(prefix))?.[1] ?? null;
+                    if (target === null || emitted.has(target))
+                        continue;
+                    const source = emissiveProperty(property);
+                    const stated = source ? layer.paint?.[source] : undefined;
+                    if (stated === undefined && EMISSIVE_NO_DEFAULT.has(target))
+                        continue;
+                    // A CAP, not just a default: Standard states 1 on its shields deliberately, so a
+                    // style that wants them to follow the light has to be able to say so over the top.
+                    const cap = LABEL_EMISSIVE.has(source ?? '') ? options.labelEmissive : undefined;
+                    if (cap !== undefined) {
+                        const stops = capStops(stated, cap, (name) => values.get(name));
+                        if (stops !== null) {
+                            emitted.add(target);
+                            extra.push(`${target}: ${stops};`);
+                        }
+                        const halo = haloTargetOf(target);
+                        if (halo !== null && options.haloEmissive !== undefined) {
+                            extra.push(`${halo}: ${round(Math.max(0, options.haloEmissive))};`);
+                        }
+                        continue;
+                    }
+                    if (stated !== undefined && typeof stated !== 'number') {
+                        // Standard states most of these as a ramp over the scene brightness, which
+                        // --live-light keeps as `[view::brightness]` - so the strength itself follows
+                        // the hour rather than freezing at the preset the conversion was run for.
+                        const translated = tryTranslate(stated, source, layer.id, coverage);
+                        if (translated !== null && translated !== '1') {
+                            emitted.add(target);
+                            extra.push(`${target}: ${translated};`);
+                            continue;
+                        }
+                    }
+                    const emissive = stated === undefined
+                        ? geometryFloor(source, emissiveDefault(source, options.labelEmissive), options.geometryEmissive)
+                        : typeof stated === 'number' ? stated
+                            : representativeEmissive(stated, representativeScale(stated, 1), (name) => values.get(name));
+                    if (emissive === null || emissive >= 1)
+                        continue;
+                    emitted.add(target);
+                    extra.push(`${target}: ${round(Math.max(0, emissive))};`);
+                }
+                return [...declarations, ...extra];
+            }
+            if (radiance === null)
+                return declarations;
+            return declarations.map((declaration) => {
+                const colon = declaration.indexOf(':');
+                const property = declaration.slice(0, colon);
+                // Map settings are not symbolizer properties, so they are not in the table.
+                const known = allowed.get(property);
+                if (known ? known.kind !== 'color' : !property.endsWith('-color'))
+                    return declaration;
+                // A `model` layer's colour is the canopy's, so it reads the model's own strength.
+                // The LAYER TYPE wins where the property name would mislead - a circle's colour and a
+                // fill's outline both translate to names whose mapbox counterpart the layer never states.
+                const source = layer.type === 'model' ? 'model-emissive-strength'
+                    : emissiveForLayerType(layer.type) ?? emissiveProperty(property);
+                const stated = source ? layer.paint?.[source] : undefined;
+                // Unstated takes MAPBOX's default for that property, which is 1 for a label and 0 for
+                // geometry - see EMISSIVE_DEFAULT. A zoom ramp has no single answer, so it takes the
+                // mean of its stops, as every other zoom-driven value baked in here does.
+                const value = declaration.slice(colon + 1, declaration.lastIndexOf(';')).trim();
+                // A ZOOM-ramped emissive keeps its ramp: Standard fades six layers - land, water,
+                // hillshade, recreation-polygon and the two ferries - between a lit and an unlit form
+                // over zoom, and land is the one that shows: 0.1 below z13 and 0 above z14, so a night
+                // map is markedly lighter zoomed out than zoomed in. Collapsed to one number the whole
+                // world got the zoomed-IN value and every low zoom came out too dark.
+                const stops = zoomStops(stated);
+                if (stops && !ZOOM_RAMP.test(value)) {
+                    const lit = stops.map(([zoom, emissive]) => {
+                        const factor = lightingFactor(emissive, radiance);
+                        return [zoom, factor === null ? value : applyLighting(value, factor)];
+                    });
+                    if (lit.some(([, colour]) => colour !== value)) {
+                        const frames = lit.map(([zoom, colour]) => `(${round(zoom - 1)}, ${colour})`).join(', ');
+                        return `${property}: linear(([view::zoom] - 1), ${frames});`;
+                    }
+                    return declaration;
+                }
+                // Unstated takes MAPBOX's default for that property, which is 1 for a label and 0 for
+                // geometry - see EMISSIVE_DEFAULT.
+                // The mean of the positive numbers is the LAST resort, not the first: it is what this
+                // used to do for everything, and it is still better than the property default when the
+                // expression cannot be resolved at all.
+                const emissive = stated === undefined ? emissiveDefault(source)
+                    : typeof stated === 'number' ? stated
+                        : representativeEmissive(stated, representativeScale(stated, 1), (name) => values.get(name));
+                const factor = lightingFactor(emissive, radiance);
+                if (factor === null)
+                    return declaration;
+                const lit = applyLighting(value, factor);
+                return lit === value ? declaration : `${property}: ${lit};`;
+            });
+        }
+        /**
+         * An emissive strength stated as an `interpolate(zoom, ...)` ramp, as its (zoom, value) pairs.
+         * Null for anything else - a constant, a ramp over something other than zoom, or a ramp whose
+         * values are still expressions after the fold.
+         */
+        function zoomStops(value) {
+            if (!Array.isArray(value) || value[0] !== 'interpolate')
+                return null;
+            const input = value[2];
+            if (!Array.isArray(input) || input[0] !== 'zoom')
+                return null;
+            const stops = [];
+            for (let i = 3; i + 1 < value.length; i += 2) {
+                const zoom = value[i];
+                const stop = representativeConstant(value[i + 1]);
+                if (typeof zoom !== 'number' || typeof stop !== 'number')
+                    return null;
+                stops.push([zoom, stop]);
+            }
+            return stops.length >= 2 ? stops : null;
+        }
+        function emitHillshadeSlot(layer, layerIndex) {
+            const sdk = layer.metadata?.['massif:sdk-layer'];
+            if (!sdk || typeof sdk !== 'object' || sdk.type !== 'hillshade')
+                return false;
+            const declarations = [];
+            for (const [key, property] of [['opacity', 'hillshade-opacity'], ['exaggeration', 'hillshade-exaggeration']]) {
+                if (sdk[key] === undefined)
+                    continue;
+                const value = tryTranslate(sdk[key], property, layer.id, coverage);
+                if (value !== null)
+                    declarations.push(`${property}: ${value};`);
+            }
+            const range = Array.isArray(sdk.visibleZoomRange) ? sdk.visibleZoomRange : [];
+            let selector;
+            try {
+                selector = `#${layer.id}${[...zoomPredicates(range[0] || layer.minzoom, range[1] ?? layer.maxzoom),
+                    ...translateFilter(layer.filter ?? null)].join('')}`;
+            }
+            catch (error) {
+                coverage.drop(`filter on "${layer.id}"`, describe(error), layer.id);
+                return true;
+            }
+            blocks.push({ selector, owner: layer.id, declarations });
+            drawOrder.push({ sourceLayer: layer.id, attachment: '', index: layerIndex });
+            return true;
+        }
+        function emitLayer(layer, attachment, sourceLayer, symbolizer, layerIndex) {
+            const paramised = paramiseValues(layer, options, coverage);
+            const extrusion = symbolizer === 'building'
+                ? flattenExtrusionOpacity(paramised.layer) : { layer: paramised.layer, opacity: null };
+            let declarations = layerDeclarations(extrusion.layer, symbolizer, allowed, coverage, options, layerIndex);
+            // The style's own opacity, as a parameter rather than a literal - see flattenExtrusionOpacity.
+            if (extrusion.opacity !== null) {
+                const stated = options.styleParams.get(OPACITY_PARAM);
+                // One parameter for every extrusion, so a style asking for two different alphas gets the
+                // first of them everywhere. No source style does; say so rather than pick silently.
+                if (typeof stated === 'number' && stated !== extrusion.opacity) {
+                    coverage.approximate(`"${layer.id}" asks for fill-extrusion-opacity ${extrusion.opacity} `
+                        + `where another extrusion asks for ${stated}: both draw at ${stated}, the `
+                        + `${OPACITY_PARAM} parameter being one knob for all of them`);
+                }
+                else {
+                    options.styleParams.set(OPACITY_PARAM, extrusion.opacity);
+                }
+                declarations = declarations.map((declaration) => (declaration.startsWith('building-fill-opacity:')
+                    ? `building-fill-opacity: [param::${OPACITY_PARAM}];` : declaration));
+            }
+            if (paramised.subs.size > 0) {
+                declarations = declarations.map((declaration) => {
+                    for (const [sentinel, lookup] of paramised.subs)
+                        declaration = declaration.split(sentinel).join(lookup);
+                    return declaration;
+                });
+            }
+            if (declarations.length === 0)
+                return;
+            let selector;
+            try {
+                // `selector = *predicate` with a skipper, so bracketed tests can abut the layer name -
+                // but `when(...)` is a bare word and would glue onto it (`#aviationwhen(...)`).
+                let filter = layer.filter ?? null;
+                if (options.contour && isContourLayer(layer)) {
+                    filter = rewriteContourFilter(filter, options.contour, () => coverage.approximate(`contour nth_line test rewritten as div >= ${options.contour.majorDiv}: ` +
+                        'only the major/minor split survives, the base interval is not in the style'));
+                }
+                const buildings = buildingPredicate(symbolizer, sourceLayer, buildings3D.get(layer.id) === 'flat');
+                if (buildings)
+                    usesBuildings = true;
+                // `massif:minzoom-param`: the zoom this layer starts at is a parameter an app sets, tested by
+                // every band. The band starting AT its default drops its own start, so an app may go lower;
+                // a layer starting below its default keeps that floor, the lowest an app may go.
+                const minParam = layer.metadata?.['massif:minzoom-param'];
+                const minDefault = typeof minParam === 'string' ? Number(parameters.get(minParam)?.default) : NaN;
+                const hasParam = typeof minParam === 'string' && zoomOffsetLevels() === 0;
+                const paramStart = hasParam && typeof layer.minzoom === 'number' && Math.floor(layer.minzoom) === minDefault;
+                const predicates = [
+                    ...(hasParam ? [`[zoom >= 'param::${minParam}']`] : []),
+                    ...zoomPredicates(paramStart ? undefined : layer.minzoom, layer.maxzoom),
+                    ...(buildings ? [buildings] : []),
+                    ...translateFilter(filter),
+                ].map((p) => (p.startsWith('when(') ? ` ${p}` : p));
+                selector = `#${sourceLayer}${predicates.join('')}::${attachment}`;
+            }
+            catch (error) {
+                const why = error instanceof Untranslatable ? error.what : String(error);
+                coverage.drop(`filter on "${layer.id}"`, `untranslatable filter: ${why}`, layer.id);
+                return;
+            }
+            // An EXTRUSION is lit by the renderer, not baked: mapbox draws it through apply_lighting
+            // and its `fill-extrusion-emissive-strength` is 0, so folding the scene light in here as
+            // well multiplied it twice - once at conversion, once per fragment.
+            //
+            // Under --live-light nothing is folded for ANY layer - light() only appends the emissive
+            // for the renderer to apply - so the bypass would cost the extrusion its own strength and
+            // leave it on the Map block's one global. Standard lights a lit window and a plain facade
+            // differently, and both came out the same.
+            const renderLit = symbolizer === 'building' && options.liveLight !== true;
+            blocks.push({ selector, owner: layer.id, declarations: renderLit ? declarations : light(layer, declarations) });
+            drawOrder.push({ sourceLayer, attachment, index: layerIndex });
+        }
+        if (usesBuildings) {
+            options.styleParams.set(BUILDINGS_PARAM, BUILDINGS_3D);
+            options.styleParams.set(TILT_DROP_PARAM, TILT_DROP_PERCENT);
+            options.styleParams.set(AO_PARAM, 1);
+            // Whatever the layers did not state, so a converted style is not left on the SDK's own
+            // (OSM-tuned) building lighting - see BUILDING_MAP_DEFAULTS.
+            if (lights !== undefined) {
+                mapBlock.push(...buildingLightSettings(lights, buildingSettingsSeen, coverage, (node) => foldConfig(node, values)));
+            }
+            else if (!buildingSettingsSeen.has(HEIGHT_VIEW_SCALE)) {
+                // Not a light: without it `building_tilt_drop` is declared and drives nothing.
+                mapBlock.push(`${HEIGHT_VIEW_SCALE}: ${HEIGHT_TILT_RAMP};`);
+            }
+        }
+        // Lit here or by the renderer at colour evaluation, the 2D colours carry the light either way;
+        // left to the building defaults, a style with no `lights` had its ground lit a second time.
+        if ((options.liveLight || lights !== undefined) && !mapBlock.some((d) => d.startsWith('colors-prelit:'))) {
+            mapBlock.push('colors-prelit: 1;');
+        }
+        // The MEDIAN index, not the first. `road` has 82 layers spanning indices 3 to 130 in Mapbox
+        // Standard, and its FIRST is one early tunnel layer - ordering by that sank all 82 beneath
+        // landuse, so the landuse polygons painted over every road. The median puts a source-layer
+        // where most of its layers actually are, which is the depth that misorders the fewest.
+        const order = new Map([...positions].map(([name, at]) => {
+            const sorted = [...at].sort((a, b) => a - b);
+            return [name, sorted[sorted.length >> 1]];
+        }));
+        reportSplitLayers(drawOrder, coverage);
+        reportSources(style, layers, coverage);
+        return { mapBlock, blocks, order, drawOrder, brightness };
+    }
+    const base = emitAll(configValues, coverage);
+    if (base.brightness !== null) {
+        coverage.approximate(options.liveLight
+            ? '["measure-light", "brightness"] left live as [view::brightness], which the SDK resolves ' +
+                'per frame; a ramp over it whose stops are per-feature expressions still snaps to the nearer end'
+            : `["measure-light", "brightness"] resolved to ${base.brightness.toFixed(2)} from ` +
+                "the style's own ambient light; our renderer cannot measure it back, and a ramp over it " +
+                'whose stops are per-feature expressions snaps to the nearer end');
+    }
+    const { mapBlock, blocks, drawOrder } = base;
+    // The Map block goes through the palette pass with the rules: a variant that recolours the
+    // water and not the background behind it is not a variant anybody wants.
+    const withMap = (result) => [{ owner: 'map', declarations: result.mapBlock }, ...result.blocks];
+    // Every preset is converted, and all of them are hoisted TOGETHER. A variable then stands for
+    // the same sites in each one, so the palettes share `style.mss` and differ only in their
+    // values. Hoisting each preset on its own instead let a colour two layers happen to share by
+    // day - and not by night - name itself differently in the two files.
+    const presetConfigs = new Map();
+    for (const preset of options.presets ?? presetsOf(parameters)) {
+        if (preset === configValues.get(LIGHT_PRESET))
+            continue;
+        presetConfigs.set(preset, new Map(configValues).set(LIGHT_PRESET, preset));
+    }
+    // A parameter TABLE is a per-preset value like a palette entry: poi-label's colours are a
+    // per-class table whose entries ramp with the scene brightness. Written into the shared
+    // project they were simply overwritten by whichever preset was emitted last - which is how
+    // every preset ended up drawing its POIs in the NIGHT colours.
+    const presetParams = new Map();
+    presetParams.set('', new Map(options.styleParams));
+    const alternates = new Map();
+    for (const [preset, values] of presetConfigs) {
+        options.styleParams.clear();
+        const result = emitAll(values, new Coverage());
+        presetParams.set(preset, new Map(options.styleParams));
+        // Only a run that lines up block for block can share the rules; folding is written to
+        // guarantee that, and this is the check that it held.
+        if (aligns(base, result))
+            alternates.set(preset, result);
+        else
+            coverage.drop(`preset "${preset}"`, 'its layers do not line up with the default preset', preset);
+    }
+    // Back to the default preset's table, which is what the shared project carries.
+    options.styleParams.clear();
+    for (const [name, value] of presetParams.get('') ?? [])
+        options.styleParams.set(name, value);
+    let hoisted = withMap(base);
+    let palette = [];
+    const presetPalettes = new Map();
+    let defaultPreset = null;
+    if (options.variables !== false) {
+        const result = hoistVariables(hoisted, allowed, [...alternates.values()].map(withMap), (style.metadata)?.['massif:palette-names']);
+        hoisted = result.blocks;
+        palette = result.palette;
+        for (const [index, preset] of [...alternates.keys()].entries()) {
+            presetPalettes.set(preset, [...paletteHeader(style.name, preset), '', ...result.alternates[index], ''].join('\n'));
+        }
+        // The DEFAULT preset gets a named project too, so all four are picked the same way -
+        // CompiledStyleSet takes a style NAME and finds <name>.json, and "project" is not one.
+        const fallback = configValues.get(LIGHT_PRESET);
+        if (presetPalettes.size > 0 && typeof fallback === 'string')
+            defaultPreset = fallback;
+    }
+    const selectors = ['Map', ...blocks.map((block) => block.selector)];
+    const [mapRule, ...ruleBlocks] = hoisted.map((block, index) => ({ ...block, selector: selectors[index] }));
+    const header = [
+        '/* Generated by massif-style mapbox2css. Do not edit by hand:',
+        '   re-run the converter against the source style instead. */',
+    ];
+    if (palette.length > 0)
+        header.push(`/* Colours, fonts and shared sizes live in ${VARIABLES_FILE}. */`);
+    if (style.name)
+        header.push(`/* Source style: ${style.name} */`);
+    const render = (block) => `${block.selector} {\n${block.declarations.map((d) => `  ${d}`).join('\n')}\n}`;
+    const mss = [
+        ...header,
+        '',
+        ...(mapRule.declarations.length > 0 ? [render(mapRule), ''] : []),
+        ...ruleBlocks.map(render),
+        '',
+    ].join('\n');
+    const variables = palette.length > 0 ? [...paletteHeader(style.name), '', ...palette, ''].join('\n') : null;
+    // loadMapProject REVERSES this array (layerNames.insert(begin)), and MapBox layers run
+    // bottom-to-top, so the project list is the draw order reversed.
+    const projectLayers = projectEntries(drawOrder).reverse();
+    const styles = variables ? [VARIABLES_FILE, 'style.mss'] : ['style.mss'];
+    // `fonts` is for whoever has to CARRY the project - the decoder finds them by scanning the
+    // package for <style>/fonts/ and needs no list, but a project served over HTTP cannot be
+    // listed, so the preview reads this to know what to fetch.
+    const fonts = options.fonts ?? [];
+    const project = JSON.stringify({
+        styles,
+        layers: projectLayers,
+        ...(fonts.length > 0 ? { fonts } : {}),
+        ...(options.styleParams.size > 0
+            ? { styleparameters: Object.fromEntries([...options.styleParams].sort()) }
+            : {}),
+    }, null, 2) + '\n';
+    // Only what DIFFERS from the shared table: a preset project extends project.json, and
+    // `extends` merges styleparameters, so an entry it does not restate is inherited.
+    const shared = presetParams.get('') ?? new Map();
+    const presetOverrides = new Map();
+    for (const [preset, params] of presetParams) {
+        if (preset === '')
+            continue;
+        const differing = [...params].filter(([name, value]) => shared.get(name) !== value);
+        if (differing.length > 0)
+            presetOverrides.set(preset, Object.fromEntries(differing.sort()));
+    }
+    return { mss, project, coverage, variables, presets: presetPalettes, defaultPreset, presetOverrides };
+}
+/**
+ * MapBox states a building's shading per LAYER; the SDK shades every building at once, from the Map
+ * block (`CartoCSSMapLoader`'s float settings). The names line up one for one, so the value is
+ * carried verbatim - a zoom ramp included, since these are FloatFunctionProperty and evaluated per
+ * frame. A boolean becomes 1/0 for the same reason.
+ *
+ * Left out because the SDK has no equivalent: `flood-light-*` (a per-building light source),
+ * `cutoff-fade-range`. `emissive-strength` is approximated into the colour
+ * instead - see emissive.ts.
+ */
+/**
+ * How far the extrusions are flattened as the camera turns onto the map. Tilt 90 is straight DOWN
+ * in this SDK, and at that angle a tall building covers the streets it stands in and reads as a
+ * stain rather than a building; scaling it away is what keeps a top-down 3D map legible.
+ *
+ * Nothing happens before tilt 80 - a 3D camera at 55-75 must be untouched - and the drop is a
+ * PERCENTAGE an app can change at any time: `building_tilt_drop` is a style parameter, so setting
+ * it is a redraw, not a re-decode. 90 leaves a tenth of the height, enough to read the storeys.
+ *
+ * `view::tilt` is a view-state variable, so the ramp costs no re-decode either: the property is
+ * re-read every frame (MapRenderer::collectStyleEnvironment) against that frame's camera.
+ */
+/**
+ * A live switch over the ground AO, so the contact shadows can be turned off on a running map
+ * without a re-decode - a style parameter is a redraw. It multiplies the intensity, so 0 is off and
+ * 1 is whatever the style asked for.
+ */
+const AO_PARAM = 'building_ao';
+const TILT_DROP_PARAM = 'building_tilt_drop';
+const TILT_DROP_PERCENT = 90;
+// `* 0.01`, not `/ 100`: the parameter is declared as a whole number and the two would be an
+// INTEGER division - 90/100 = 0, and the flattening silently did nothing.
+const HEIGHT_TILT_RAMP = `1 - ([param::${TILT_DROP_PARAM}] * 0.01) * linear([view::tilt], (80, 0), (90, 1))`;
+/** Where it goes: the DRAWN height only. The shadow caster keeps the building's real height. */
+const HEIGHT_VIEW_SCALE = 'building-height-view-scale';
+/**
+ * MapBox raises the ground AO between its z17 and z17.8. Those are 512 px tiles, so on this SDK's
+ * own scale that is z18-z18.8: the contact shadows only appear once you are on top of a building,
+ * where they are what makes it stand on the ground rather than float. Shifted one level earlier;
+ * -2 puts them at z16.
+ */
+/** A value that already ramps over zoom; combining two ramps is not expressible here. */
+const ZOOM_RAMP = /\[view::zoom\]/;
+const AO_GROUND_ZOOM_SHIFT = -1;
+/** Move an `interpolate(..., ["zoom"], ...)` ramp's key frames, leaving its values alone. */
+function shiftZoomStops(value, delta) {
+    if (!Array.isArray(value) || value[0] !== 'interpolate')
+        return value;
+    const input = value[2];
+    if (!Array.isArray(input) || input[0] !== 'zoom')
+        return value;
+    return value.map((item, i) => (i >= 3 && i % 2 === 1 && typeof item === 'number' ? item + delta : item));
+}
+/**
+ * What MapBox itself uses when a layer states nothing. The SDK's own defaults are tuned for the
+ * hand-written OSM style - ambient 0.35, ao-intensity 0.2, ao-attenuation 1.7 - and a converted
+ * MapBox style that inherits them comes out markedly darker than the browser draws it. Stating
+ * MapBox's defaults explicitly is what keeps the two comparable.
+ */
+const BUILDING_MAP_DEFAULTS = {
+    // No MapBox equivalent: gl-js has no tilt term. See HEIGHT_TILT_RAMP.
+    [HEIGHT_VIEW_SCALE]: HEIGHT_TILT_RAMP,
+    // gl-js clamps a wall's shading to a FLOOR of about 0.7 (fill_extrusion.vertex.glsl mixes
+    // 0.7..0.98 by light intensity); the SDK's wall factor is `1 - gradient` at the foot, so 0.3
+    // puts the foot in the same place. Its own default of 0.65 takes it to 0.35 - less than half
+    // the brightness gl-js gives it, which is why our side walls read so much darker.
+    'building-vertical-gradient': '0.3',
+    'building-ao-intensity': '0', // gl-js: ambient-occlusion-intensity 0
+    'building-ao-ground-radius': '3', // gl-js: ambient-occlusion-ground-radius 3
+    // NOT gl-js's 0.69: that number lives in a different formula. See groundAttenuation.
+    'building-ao-ground-attenuation': '1.75',
+    'building-edge-radius': '0', // gl-js: edge-radius 0
+    'building-rounded-roof': '1', // gl-js: rounded-roof true
+    // gl-js has no timed fade for an extrusion: a style that wants one ramps
+    // `fill-extrusion-opacity` over zoom, as Standard does between z15 and z15.3. The SDK fades
+    // every geometry in with its tile, which put a second, timed fade on top of that one.
+    'building-fade-on-appear': '0',
+    // The 2D colours carry the light by the time the terrain surface samples them, so it must not
+    // light them a second time. True in BOTH modes: folded in here by default, and applied by the
+    // renderer at colour evaluation - which runs before the drape bake - under --live-light. Says
+    // nothing about the shadows, which a pre-lit style still receives.
+    'colors-prelit': '1',
+};
+const BUILDING_MAP_SETTINGS = {
+    'fill-extrusion-vertical-gradient': 'building-vertical-gradient',
+    'fill-extrusion-ambient-occlusion-intensity': 'building-ao-intensity',
+    'fill-extrusion-ambient-occlusion-ground-radius': 'building-ao-ground-radius',
+    'fill-extrusion-ambient-occlusion-ground-attenuation': 'building-ao-ground-attenuation',
+    'fill-extrusion-edge-radius': 'building-edge-radius',
+    'fill-extrusion-rounded-roof': 'building-rounded-roof',
+    // Standard grows its buildings out of the ground as they appear - 0 at z15, 1 at z15.3 - and
+    // this is how: a ZOOM ramp on the height, not a timed animation, so it is the same at every
+    // visit. Dropped, every extrusion snapped to full height the moment its layer switched on.
+    'fill-extrusion-vertical-scale': 'building-height-scale',
+};
+/**
+ * MapBox's ground-attenuation is not the SDK's, and the two run in opposite directions.
+ *
+ * gl-js takes 0..1 and documents it as "lower values give a more crisp look" (default 0.69). The
+ * SDK's is the EXPONENT k of `(1 - d)^k` over the normalized distance from the wall
+ * (`polygon3dGroundFsh`), so a HIGHER value is the crisp one and its own default is 1.75. Carried
+ * verbatim, MapBox's 0.69 landed as a very low exponent: the band spread to the full radius and
+ * lost its contrast, which is exactly "too large, and less accentuated".
+ *
+ * The map is `k = 1.75 * 0.69 / a`: monotone, the right way round, and it puts each renderer's own
+ * default on the other's. It is a fit between two curves, not a conversion - a value far from 0.69
+ * only keeps the direction, not the profile.
+ */
+function groundAttenuation(value, layerId, coverage) {
+    if (typeof value !== 'number' || !(value > 0)) {
+        coverage.approximate(`"${layerId}" drives ambient-occlusion-ground-attenuation with an ` +
+            'expression; the SDK\'s is an exponent in a different formula and only a constant can ' +
+            'be mapped onto it, so the default is kept');
+        return null;
+    }
+    return String(Math.round((1.75 * 0.69 / value) * 100) / 100);
+}
+/**
+ * The ground AO's INTENSITY, ramped over the same zoom window as its radius.
+ *
+ * MapBox states a constant (0.15) beside a radius that ramps in, so the contact shadow arrives at
+ * full strength the moment the radius leaves zero - which reads as a hard switch, not as buildings
+ * settling onto the ground. Given the radius ramp, the intensity gets the same keyframes from 0.
+ * A constant radius leaves the intensity alone.
+ */
+function rampLikeGroundAO(intensity, layer) {
+    if (typeof intensity !== 'number')
+        return intensity;
+    const radius = layer.paint?.['fill-extrusion-ambient-occlusion-ground-radius'];
+    const shifted = shiftZoomStops(radius, AO_GROUND_ZOOM_SHIFT);
+    if (!Array.isArray(shifted) || shifted[0] !== 'interpolate')
+        return intensity;
+    const stops = shifted.slice(3).filter((_, i) => i % 2 === 0);
+    if (stops.length < 2)
+        return intensity;
+    const first = stops[0];
+    const last = stops[stops.length - 1];
+    return ['interpolate', ['linear'], ['zoom'], first, 0, last, intensity];
+}
+/**
+ * A 3D building's OPACITY, taken as a constant and carried as a STYLE PARAMETER.
+ *
+ * Standard fades an extrusion in by ramping `fill-extrusion-opacity` alongside its height. We draw
+ * the shadow map from the buildings at their FULL cast whatever their alpha, so during the fade the
+ * shadows are already at full strength and visible straight THROUGH the half-transparent walls that
+ * cast them. The height ramp alone is the better fade: a building grows out of the ground opaque,
+ * and its shadow grows with it. So the ramp is flattened to one number.
+ *
+ * That number is the style's, not ours. It used to be forced to 1 - the 3D pass draws with blending
+ * off, and MapTiler's 0.4 turned a city into a wash of half-buildings showing through each other -
+ * but forcing it also threw away what the style meant by it: maplibre draws Liberty's buildings at
+ * 0.8, which blends a fifth of the pale background back through every wall and is a good part of
+ * why ours read darker than the browser's. A parameter states the style's value and lets an app
+ * take it back to 1 as a redraw rather than a re-decode.
+ */
+function flattenExtrusionOpacity(layer) {
+    const opacity = layer.paint?.['fill-extrusion-opacity'];
+    // A fade over the camera angle is the style's own live value, not one to flatten.
+    if (Array.isArray(opacity) && opacity[0] === 'interpolate' && isPitch(opacity[2]))
+        return { layer, opacity: null };
+    let value = opacity;
+    if (Array.isArray(opacity) && opacity[0] === 'interpolate') {
+        const constant = representativeConstant(opacity);
+        if (constant === null)
+            return { layer, opacity: null };
+        value = constant;
+    }
+    if (typeof value !== 'number')
+        return { layer, opacity: null };
+    const clamped = Math.min(1, Math.max(0, value));
+    return {
+        layer: value === opacity ? layer : { ...layer, paint: { ...layer.paint, 'fill-extrusion-opacity': clamped } },
+        opacity: clamped,
+    };
+}
+/** The style parameter a converted extrusion's opacity is carried as. */
+const OPACITY_PARAM = 'building_opacity';
+/**
+ * A layer's `metadata["massif:paint"]` / `["massif:layout"]`, merged over its real paint and layout,
+ * and `["massif:filter"]`, ANDed onto its real filter.
+ *
+ * A hand-written source style has to stay a VALID MapLibre style - the preview draws it with
+ * maplibre beside the SDK, and that comparison is the whole point of the file. But half of what is
+ * worth taking from Mapbox Standard is GL v3 only: `fill-extrusion-edge-radius`,
+ * `-vertical-scale`, `-ambient-occlusion-*`. Written into paint, maplibre rejects the style and the
+ * reference pane goes blank.
+ *
+ * `metadata` is the style spec's own escape hatch - arbitrary, and ignored by every renderer. So a
+ * property maplibre will not accept goes there, and this lifts it back out for the converter, which
+ * then treats it exactly as if Standard had stated it. Converting a real MapBox style is unaffected:
+ * it states these in paint, where they are legal for it.
+ *
+ * `massif:filter` is the same escape hatch for a test maplibre refuses outright - `["config", …]`
+ * is one, legal only inside an imported fragment and rejected in a filter anywhere - so a style
+ * that carries a second layer set behind a runtime switch keeps drawing its DEFAULT set in the
+ * reference pane, which is what a comparison wants.
+ */
+function applyMassifExtras(layer) {
+    const metadata = layer.metadata;
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return layer;
+    const paint = metadata['massif:paint'];
+    const layout = metadata['massif:layout'];
+    const filter = metadata['massif:filter'];
+    const object = (value) => (value && typeof value === 'object' && !Array.isArray(value) ? value : null);
+    const extraPaint = object(paint);
+    const extraLayout = object(layout);
+    const extraFilter = Array.isArray(filter) ? filter : null;
+    if (!extraPaint && !extraLayout && !extraFilter)
+        return layer;
+    return {
+        ...layer,
+        paint: extraPaint ? { ...layer.paint, ...extraPaint } : layer.paint,
+        layout: extraLayout ? { ...layer.layout, ...extraLayout } : layer.layout,
+        filter: extraFilter
+            ? (layer.filter === undefined ? extraFilter : ['all', layer.filter, extraFilter])
+            : layer.filter,
+    };
+}
+function buildingMapSettings(layer, seen, coverage, ramp, aoFollowsHeight, lit) {
+    const out = [];
+    // Under lights gl-js ignores the vertical gradient and darkens a wall's foot with its faux AO
+    // (fill_extrusion.fragment.glsl): (1 - 0.08 I)(1 - 0.9 I) at the foot, nearly gone ~6 m up at its
+    // 3 m wall radius. The SDK's linear ramp over that height is the closest it draws.
+    const wallAO = layer.paint?.['fill-extrusion-ambient-occlusion-intensity'];
+    if (lit && typeof wallAO === 'number' && wallAO > 0 && !seen.has('building-vertical-gradient')) {
+        seen.add('building-vertical-gradient');
+        out.push(`building-vertical-gradient: ${round(1 - (1 - 0.08 * wallAO) * (1 - 0.9 * wallAO))};`, 'building-vertical-gradient-height: 6;');
+        coverage.emit('building-vertical-gradient');
+    }
+    for (const [from, to] of Object.entries(BUILDING_MAP_SETTINGS)) {
+        // `fill-extrusion-edge-radius` is a LAYOUT property, not a paint one - reading only paint
+        // dropped Standard's 0.4 bevel silently.
+        const raw = layer.paint?.[from] ?? layer.layout?.[from];
+        if (raw === undefined || seen.has(to))
+            continue;
+        const value = to === 'building-ao-ground-radius' ? shiftZoomStops(raw, AO_GROUND_ZOOM_SHIFT)
+            : to === 'building-ao-intensity' ? rampLikeGroundAO(raw, layer)
+                : raw;
+        const translated = to === 'building-ao-ground-attenuation'
+            ? groundAttenuation(value, layer.id, coverage)
+            : typeof value === 'boolean'
+                ? (value ? '1' : '0')
+                : tryTranslate(value, from, layer.id, coverage);
+        if (translated === null)
+            continue;
+        seen.add(to);
+        // --ao-follows-height: the contact shadow belongs to the building standing in it, so it
+        // fades on the SAME ramp that lays the walls down - a flattened city otherwise keeps a
+        // full-strength dark ring around every footprint, the stain the drop exists to remove.
+        // Opt-in, and in the STYLE rather than the renderer: whether the shadow outlives the walls
+        // is the style's call. Both are view-state expressions, so neither costs a re-decode.
+        out.push(to === 'building-ao-intensity'
+            ? `${to}: [param::${AO_PARAM}] * (${translated})${aoFollowsHeight ? ` * (${HEIGHT_TILT_RAMP})` : ''};`
+            : `${to}: ${translated};`);
+        coverage.emit(to);
+    }
+    // A style that states no vertical scale pops its buildings in at full height. Standard grows
+    // them over a third of a zoom level, and the ramp is placed at the extrusion layer's own
+    // minzoom - which is where they first exist to grow.
+    if (ramp && !seen.has('building-height-scale')) {
+        const minZoom = typeof layer.minzoom === 'number' ? layer.minzoom : 15;
+        seen.add('building-height-scale');
+        out.push(`building-height-scale: linear(${zoomInput()}, (${round(minZoom)}, 0), (${round(minZoom + 0.3)}, 1));`);
+        coverage.emit('building-height-scale');
+    }
+    return out;
+}
+/**
+ * The building settings a converted MapBox style still needs after its own paint is read: MapBox's
+ * defaults for what it left unstated, and its LIGHTS as the SDK's two building light knobs. The
+ * lights block is MapBox's whole lighting model, and `building-ambient` / `building-light-intensity`
+ * are the same two numbers - the SDK's own 0.35 ambient is what made a white building read grey.
+ */
+function buildingLightSettings(lights, seen, coverage, fold) {
+    const out = [];
+    // The intensity may be a zoom RAMP, and these are FloatFunctionProperty, so it goes through
+    // whole. Requiring a plain number left Standard's directional light unstated - its 0.2 is a
+    // flat `interpolate(zoom, …)` - and the SDK fell back to 1.0, five times as strong, which is
+    // what made every wall so much darker than the browser draws it.
+    const intensityOf = (type) => {
+        const folded = fold(lights);
+        if (!Array.isArray(folded))
+            return null;
+        const light = folded.find((l) => !!l && typeof l === 'object'
+            && l.type === type);
+        const intensity = light?.properties?.intensity;
+        if (intensity === undefined)
+            return null;
+        if (typeof intensity === 'number')
+            return String(round(intensity));
+        try {
+            return translateExpression(intensity);
+        }
+        catch {
+            return null;
+        }
+    };
+    for (const [type, name] of [['ambient', 'building-ambient'], ['directional', 'building-light-intensity']]) {
+        if (seen.has(name))
+            continue;
+        const intensity = intensityOf(type);
+        if (intensity === null)
+            continue;
+        seen.add(name);
+        out.push(`${name}: ${intensity};`);
+        coverage.emit(name);
+    }
+    // WHERE the sun is, not just how strong. MapBox states it per preset - day is `[180, 20]`,
+    // 20 degrees off the zenith - and without it the app's own sun lit the buildings: at the
+    // demo's default the roofs came out at 86% of their colour where the browser draws them at
+    // ~100%, which reads as "the building colour is wrong" and is not.
+    const direction = (() => {
+        const folded = fold(lights);
+        if (!Array.isArray(folded))
+            return null;
+        const light = folded.find((l) => !!l && typeof l === 'object'
+            && l.type === 'directional');
+        const value = light?.properties?.direction;
+        const list = Array.isArray(value) && value[0] === 'literal' ? value[1] : value;
+        return Array.isArray(list) && list.length === 2 && list.every((v) => typeof v === 'number')
+            ? list : null;
+    })();
+    // The light's COLOUR, which is what actually separates the presets. Their intensities barely
+    // move - dawn 0.75 against day's 0.8 - while the ambient goes from white to a warm cream at
+    // dawn and to hsl(228, 27%, 29%) at dusk, with an orange sun against it. Without these, dawn
+    // rendered as day and dusk as a washed-out day, and a roof kept the tone of the wall beside it
+    // because a white ambient at 0.8 drowns the directional term that separates them.
+    const colourOf = (type) => {
+        const folded = fold(lights);
+        if (!Array.isArray(folded))
+            return null;
+        const light = folded.find((l) => !!l && typeof l === 'object'
+            && l.type === type);
+        const colour = light?.properties?.color;
+        return typeof colour === 'string' ? colour : null;
+    };
+    for (const [type, name] of [['ambient', 'ambient-color'], ['directional', 'sun-color']]) {
+        if (seen.has(name))
+            continue;
+        const colour = colourOf(type);
+        if (colour === null)
+            continue;
+        seen.add(name);
+        out.push(`${name}: ${colour};`);
+        coverage.emit(name);
+    }
+    if (direction && !seen.has('sun-azimuth')) {
+        // MapBox's pair is [azimuthal, polar]: the azimuth runs clockwise from north, as the SDK's
+        // does, and the polar angle is measured from straight UP, so the altitude is its complement.
+        seen.add('sun-azimuth');
+        out.push(`sun-azimuth: ${round(direction[0])};`, `sun-altitude: ${round(90 - direction[1])};`);
+        coverage.emit('sun-azimuth');
+        coverage.emit('sun-altitude');
+    }
+    // gl-js clamps a wall's shading to `mix(0.7, 0.98, 1 - lightIntensity)`
+    // (fill_extrusion.vertex.glsl), so the floor RISES as the directional light weakens: at
+    // Standard's 0.2 it is 0.92, not the 0.7 the constant alone suggests. The SDK's wall factor is
+    // `1 - gradient` at the foot, so this is the same floor expressed its way. Measured: with a
+    // flat 0.3 the foot sat at 0.63 of the roof where the browser keeps it near 0.9.
+    const rawDirectional = (() => {
+        const folded = fold(lights);
+        if (!Array.isArray(folded))
+            return undefined;
+        const light = folded.find((l) => !!l && typeof l === 'object'
+            && l.type === 'directional');
+        return light?.properties?.intensity;
+    })();
+    // A flat ramp is still one number - representativeConstant takes the branch most features get.
+    const reduced = rawDirectional === undefined ? null : representativeConstant(rawDirectional);
+    const constant = typeof reduced === 'number' ? reduced : null;
+    if (!seen.has('building-vertical-gradient') && constant !== null && Number.isFinite(constant)) {
+        const floor = 0.7 + (1 - Math.min(Math.max(constant, 0), 1)) * 0.28;
+        seen.add('building-vertical-gradient');
+        out.push(`building-vertical-gradient: ${round(1 - floor)};`);
+    }
+    for (const [name, value] of Object.entries(BUILDING_MAP_DEFAULTS)) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        out.push(`${name}: ${value};`);
+    }
+    return out;
+}
+/**
+ * The style parameter that turns buildings off, flat, or 3D - the same three states, spelled the
+ * same way, as the hand-written styles under `assets/style`: `['param::buildings'>0]` gates the
+ * footprint and `>1` the extrusion. An app then has one knob for every converted style, and can
+ * drop the 3D pass on a device that cannot afford it without editing the CartoCSS.
+ *
+ * It defaults to 3D, so a converted style draws what its source drew until an app says otherwise.
+ */
+const BUILDINGS_PARAM = 'buildings';
+const BUILDINGS_3D = 2;
+/** A source layer of footprints, whatever the schema calls it. */
+const BUILDING_LAYER = /building/i;
+function buildingPredicate(symbolizer, sourceLayer, flat) {
+    // The FLAT variant is the one MapBox draws when 3D is off, so it is the middle state and has
+    // to be shut off above it too - without the upper bound both variants drew at `buildings: 2`.
+    if (flat)
+        return `['param::${BUILDINGS_PARAM}'>0]['param::${BUILDINGS_PARAM}'<2]`;
+    if (symbolizer === 'building')
+        return `['param::${BUILDINGS_PARAM}'>1]`;
+    return BUILDING_LAYER.test(sourceLayer) ? `['param::${BUILDINGS_PARAM}'>0]` : null;
+}
+/**
+ * Which side of MapBox's 3D switch a layer is on, from its `visibility` alone.
+ *
+ * Standard draws footprints and extrusions as two layers over the same source, each gated on
+ * `["case", ["all", ["config", "show3dBuildings"], ["config", "show3dObjects"]], …]`. Folded with
+ * the default config - 3D on - the flat pair resolved to `"none"` and was dropped outright, so
+ * `buildings: 1` left the map with no buildings at all rather than with their footprints.
+ *
+ * Null for anything whose visibility does not turn on that switch: it is then a plain
+ * visibility and folding it is right.
+ */
+function buildings3DGate(layer) {
+    const visibility = layer.layout?.visibility;
+    if (!Array.isArray(visibility) || visibility[0] !== 'case' || visibility.length !== 4)
+        return null;
+    const names = new Set();
+    const walk = (node) => {
+        if (!Array.isArray(node))
+            return;
+        if (node[0] === 'config' && typeof node[1] === 'string')
+            names.add(node[1]);
+        node.forEach((item) => walk(item));
+    };
+    walk(visibility[1]);
+    if (!names.has('show3dBuildings') && !names.has('show3dObjects'))
+        return null;
+    if (visibility[2] === 'visible' && visibility[3] === 'none')
+        return '3d';
+    if (visibility[2] === 'none' && visibility[3] === 'visible')
+        return 'flat';
+    return null;
+}
+function backgroundProperties(layer, coverage) {
+    const out = [];
+    for (const [name, value] of Object.entries(layer.paint ?? {})) {
+        const target = PROPERTY_MAP.background[name];
+        if (!target) {
+            coverage.drop(name, KNOWN_GAPS[name] ?? 'not mapped', layer.id);
+            continue;
+        }
+        const translated = tryTranslate(value, name, layer.id, coverage);
+        if (translated !== null) {
+            out.push(`${target}: ${translated};`);
+            coverage.emit(target);
+        }
+    }
+    return out;
+}
+function layerDeclarations(layer, symbolizer, allowed, coverage, options, layerIndex = 0) {
+    const table = PROPERTY_MAP[layer.type] ?? {};
+    const out = [];
+    // A symbol layer's icon is a SECOND symbolizer in the same rule, so marker-* declarations sit
+    // beside the text-* ones rather than replacing them - unless the icon is a road shield, whose
+    // sprite is picked per feature and is drawn as a plate behind the text instead.
+    const isShield = layer.type === 'symbol' && isShieldLayer(layer);
+    const plates = layer.type === 'symbol' && !isShield ? flatPlateShield(layer, options) : null;
+    const iconDeclarations = layer.type === 'model'
+        ? canopyDeclarations(layer, coverage)
+        : layer.type !== 'symbol'
+            ? []
+            : isShield
+                ? plateDeclarations(layer, coverage)
+                : plates
+                    ? flatPlateDeclarations(layer, plates, options, coverage)
+                    : markerDeclarations(layer, coverage, options);
+    if (symbolizer === 'text') {
+        out.push(`text-placement: '${resolvePlacement(layer, 'text')}';`);
+        coverage.emit('text-placement');
+    }
+    for (const [name, value] of Object.entries({ ...layer.layout, ...layer.paint })) {
+        // A CASING, not a line: `line-gap-width` is the road it runs either side of, and
+        // `line-width` is the casing on ONE side. Both are folded into the width here and the
+        // fill layer above covers the middle, which is how a casing has always been drawn in
+        // CartoCSS. Dropped, the casing drew as a solid band the full width of the road - which
+        // is every road in Mapbox Standard, 28 layers of them, and the reason ours came out as
+        // lavender slabs where the browser draws a white road with a thin edge.
+        if (name === 'visibility') {
+            if (value === 'none')
+                return []; // the whole layer is off
+            continue;
+        }
+        if (HANDLED_ELSEWHERE.has(name))
+            continue;
+        // text-field may be the legacy "{field}" token form rather than an expression.
+        if (name === 'text-field' && typeof value === 'string' && value.includes('{')) {
+            out.push(`text-name: ${expandTokens(value)};`);
+            coverage.emit('text-name');
+            continue;
+        }
+        // A text-field that branches per country (MapBox's shields slice the ref) is worth keeping
+        // as its fallback rather than losing the label: the fallback IS the name for most features.
+        if (name === 'text-field') {
+            const text = tryTranslate(value, name, layer.id, coverage) ?? retryCollapsed(value, layer, coverage);
+            if (text === null)
+                continue;
+            out.push(`text-name: ${text};`);
+            coverage.emit('text-name');
+            continue;
+        }
+        // MapBox names one anchor; CartoCSS splits it into a horizontal and a vertical alignment.
+        // The senses agree - see the default derivation in TextSymbolizer.cpp, where a text pushed
+        // right (dx > 0) defaults to alignment 'left', i.e. the edge nearest the anchor.
+        if (name === 'text-anchor') {
+            const constant = typeof value === 'string' ? value : representativeConstant(value);
+            if (typeof constant !== 'string') {
+                coverage.drop(name, 'anchor branches on something with no constant form', layer.id);
+                continue;
+            }
+            if (constant !== value) {
+                coverage.approximate(`text-anchor on "${layer.id}" branches; took "${constant}"`);
+            }
+            const anchor = TEXT_ANCHOR[constant];
+            if (!anchor) {
+                coverage.drop(name, `unknown anchor "${constant}"`, layer.id);
+                continue;
+            }
+            out.push(`text-horizontal-alignment: '${anchor[0]}';`, `text-vertical-alignment: '${anchor[1]}';`);
+            coverage.emit('text-horizontal-alignment');
+            coverage.emit('text-vertical-alignment');
+            continue;
+        }
+        // Everything MapBox measures in ems of the text size. CartoCSS takes pixels, so each one
+        // is multiplied by text-size - the expression form included, or a zoom-driven size would
+        // silently pin the value to one zoom.
+        if (name === 'text-offset') {
+            const pair = Array.isArray(value) && value.length === 2 && value.every((v) => typeof v === 'number')
+                ? value
+                : representativeConstant(value);
+            if (!Array.isArray(pair) || pair.length !== 2) {
+                coverage.drop(name, 'offset branches on something with no constant form', layer.id);
+                continue;
+            }
+            if (pair !== value) {
+                coverage.approximate(`text-offset on "${layer.id}" branches; took [${pair.join(', ')}]`);
+            }
+            const dx = ems(pair[0], layer, coverage, name);
+            const dy = ems(pair[1], layer, coverage, name);
+            if (dx === null || dy === null)
+                continue;
+            out.push(`text-dx: ${dx};`, `text-dy: ${dy};`);
+            coverage.emit('text-dx');
+            coverage.emit('text-dy');
+            // An offset TRANSLATES the text in MapBox, but with no alignment given the SDK reads a
+            // non-zero dx/dy as the anchor instead (TextSymbolizer::getFormatterOptions), so
+            // MapTiler's text-offset [0, 0.05] hung every road ref off its shield's bottom edge.
+            // Pin the anchor the offset moves - MapBox's default, centre.
+            if (layer.layout?.['text-anchor'] === undefined) {
+                out.push(`text-horizontal-alignment: 'middle';`, `text-vertical-alignment: 'middle';`);
+                coverage.emit('text-horizontal-alignment');
+                coverage.emit('text-vertical-alignment');
+            }
+            continue;
+        }
+        // text-max-width is 10 ems by default; taken as pixels it wrapped every name onto one word
+        // per line. A line-placed label is laid out along the line and MapLibre never wraps it.
+        if (name === 'text-max-width') {
+            if (followsLine(layer)) {
+                out.push('text-wrap-width: 0;');
+                coverage.emit('text-wrap-width');
+                continue;
+            }
+            const width = ems(value, layer, coverage, name);
+            if (width === null)
+                continue;
+            out.push(`text-wrap-width: ${width};`);
+            coverage.emit('text-wrap-width');
+            continue;
+        }
+        // The modern spelling of text-allow-overlap. 'cooperative' has no equivalent and is the
+        // conservative 'never' here. icon-overlap belongs to the marker and is handled with it -
+        // a lone marker-* declaration builds a marker with no file, which draws the default blue
+        // ellipse over every feature of the layer.
+        if (name === 'text-overlap') {
+            out.push(`text-allow-overlap: ${value === 'always'};`);
+            coverage.emit('text-allow-overlap');
+            continue;
+        }
+        // MapBox places the LOWEST sort key first; CartoCSS's culler takes the highest priority.
+        if (name === 'symbol-sort-key')
+            continue; // folded into the layer's priority below
+        if (name === 'line-sort-key')
+            continue; // became this attachment's place in the order - see split.ts
+        // MapBox's text-opacity fades the WHOLE label; CartoCSS's fades only the fill, and the halo
+        // keeps its own. A style that hides a label with `step(zoom, 0, …, 13, 1)` was leaving the
+        // halo at full opacity - a white ghost of the name at every zoom it should not be at.
+        if (name === 'text-opacity') {
+            const translated = tryTranslate(value, name, layer.id, coverage);
+            if (translated === null)
+                continue;
+            out.push(`text-opacity: ${translated};`, `text-halo-opacity: ${translated};`);
+            coverage.emit('text-opacity');
+            coverage.emit('text-halo-opacity');
+            continue;
+        }
+        // MapBox grows a label's collision box by text-padding on every side and tests the grown
+        // boxes against each other, which is what `collision-padding` is. It used to arrive as a
+        // minimum-distance, which is a different thing - that one only separates labels of the same
+        // GROUP (the text hash), so two different road shields were held apart by nothing, and it
+        // doubles as the repeat floor, so a line-placed label could not be given one at all.
+        if ((name === 'text-padding' || name === 'icon-padding')
+            && (symbolizer === 'text' || symbolizer === 'shield')) {
+            const translated = tryTranslate(value, name, layer.id, coverage);
+            if (translated === null)
+                continue;
+            const property = symbolizer === 'shield' ? 'shield-collision-padding' : 'text-collision-padding';
+            if (out.some((declaration) => declaration.startsWith(`${property}:`)))
+                continue; // icon-padding after text-padding
+            out.push(`${property}: (${collisionPad(options)} * ${translated});`);
+            coverage.emit(property);
+            continue;
+        }
+        // A circle's RADIUS is a marker's WIDTH: carried as it was, every circle drew at half its size.
+        if (name === 'circle-radius') {
+            const translated = tryTranslate(value, name, layer.id, coverage);
+            if (translated === null)
+                continue;
+            // and a circle never collides in MapLibre: a marker that did would vanish under a label
+            out.push(`marker-width: (2 * ${translated});`, 'marker-allow-overlap: true;');
+            coverage.emit('marker-width');
+            coverage.emit('marker-allow-overlap');
+            continue;
+        }
+        if (name === 'text-letter-spacing') {
+            const spacing = ems(value, layer, coverage, name);
+            if (spacing === null)
+                continue;
+            out.push(`text-character-spacing: ${spacing};`);
+            coverage.emit('text-character-spacing');
+            continue;
+        }
+        // text-line-height is a TOTAL line height in ems; text-line-spacing is what is added on top
+        // of the font's own, which already is MapBox's 1.2 default.
+        if (name === 'text-line-height' && typeof value === 'number') {
+            const spacing = ems(value - 1.2, layer, coverage, name);
+            if (spacing === null)
+                continue;
+            out.push(`text-line-spacing: ${spacing};`);
+            coverage.emit('text-line-spacing');
+            continue;
+        }
+        // A pattern names a SPRITE, and the raw name reached the decoder as a file name that
+        // never existed (`misc:construction_pattern`): the sheet qualifier only says where to LOOK.
+        if (name === 'fill-pattern' || name === 'line-pattern') {
+            out.push(...patternDeclarations(name, value, table[name], layer, coverage, options));
+            continue;
+        }
+        // MapBox DISABLES fill-color under a fill-pattern and fades the pattern with fill-opacity;
+        // the pattern is its own symbolizer here, with its own fill and opacity, so a polygon-fill
+        // beside it would paint a solid layer under the hatch and polygon-opacity would fade only
+        // that. MapTiler's construction areas are a 0.15 hatch and drew fully saturated.
+        if (layer.paint?.['fill-pattern'] !== undefined && (name === 'fill-color' || name === 'fill-opacity')) {
+            if (name === 'fill-color') {
+                coverage.drop(name, 'MapBox disables fill-color under a fill-pattern', layer.id);
+                continue;
+            }
+            emitTranslated(out, coverage, layer, 'fill-opacity', 'polygon-pattern-opacity', undefined, false);
+            continue;
+        }
+        // MapBox dash lengths are multiples of the line width; CartoCSS's are pixels.
+        if (name === 'line-dasharray') {
+            const dash = dashPattern(value);
+            if (dash === null) {
+                coverage.drop(name, 'no literal dash pattern to take', layer.id);
+                continue;
+            }
+            const { pattern, zoom } = dash;
+            // `[1, 0]` is MapBox's spelling of SOLID. Scaled by a line width it became a 430 px
+            // "dash", which is a 430 px bitmap rasterized to draw an unbroken line.
+            if (!pattern.some((v, i) => i % 2 === 1 && v > 0)) {
+                coverage.drop(name, 'the pattern has no gap, so the line is solid', layer.id);
+                continue;
+            }
+            if (pattern !== value) {
+                // MapTiler ramps its path dashes over zoom and CartoCSS takes ONE pattern. The
+                // base (the widest band, and every stop below the first) is what is on screen at
+                // nearly every zoom; taking nothing left every footway drawn solid.
+                coverage.approximate(`line-dasharray taken at one stop, ${pattern.join(',')}: ` +
+                    'CartoCSS takes one dash pattern, not a ramp');
+            }
+            const width = dashWidth(layer.paint?.['line-width']);
+            // At the zoom the pattern is CHOSEN at, not the mean of the width's stops: Standard's
+            // steps ramp to 80 px by z22, so the mean is 43 and its 0.2 dash came out at 8.6 px
+            // where gl-js draws under 2 - coarse bands instead of fine treads.
+            // A banded attachment reads the width in the middle of its OWN band; see splitDashByZoom.
+            const banded = layer.dashZoom === undefined ? null : rampAt(width, layer.dashZoom);
+            const scale = banded ?? (zoom === null ? null : rampAt(width, zoom))
+                ?? representativeScale(width, 1);
+            if (typeof width !== 'number' && banded === null) {
+                coverage.approximate(`line-dasharray scaled by ${round(scale)}, a zoom-driven ` +
+                    'line-width read at one zoom: CartoCSS takes one dash pattern, not a ramp');
+            }
+            out.push(`line-dasharray: ${pattern.map((v) => round(v * scale)).join(',')};`);
+            coverage.emit('line-dasharray');
+            continue;
+        }
+        // A fill's outline is a second symbolizer on the same rule, not a polygon property.
+        if (name === 'fill-outline-color') {
+            const translated = tryTranslate(value, name, layer.id, coverage);
+            if (translated !== null) {
+                out.push(`line-color: ${translated};`, `line-width: ${FILL_OUTLINE_WIDTH};`);
+                coverage.emit('line-color');
+                coverage.approximate(`fill-outline-color drawn as a line of width ${FILL_OUTLINE_WIDTH}: MapBox's is a ` +
+                    '1-DEVICE-pixel hairline (gl.LINES) and a CartoCSS width scales with the display, ' +
+                    'so no constant is right at every dpi');
+            }
+            continue;
+        }
+        // Placed with the icon instead (variableAnchorDeclarations): each says where the text goes
+        // relative to one, so on a layer with no icon there is nothing for them to describe.
+        if (VARIABLE_ANCHOR_LAYOUT.has(name)) {
+            if (layer.layout?.['icon-image'] === undefined) {
+                coverage.drop(name, 'positions the text against an icon, and this layer has none', layer.id);
+            }
+            continue;
+        }
+        // One occlusion opacity per LABEL: it is a TextSymbolizer property here, so a symbol's
+        // icon and its text share it. MapBox states the pair together where it states both
+        // (Standard's natural-point-label sets 0 twice), so the icon's is taken only where the
+        // text states none - and an icon-only layer is a marker, which is not a label.
+        //
+        // Only a STATED value is carried, which is MapBox's own meaning: absent is "occluded by
+        // the terrain alone", the SDK's default, and 0 is "occluded by 3D content too". That is
+        // what makes Standard's road and water names go behind a building while its POI labels
+        // stay drawn - and what stops every label paying for the occlusion pass.
+        if (name === 'icon-occlusion-opacity') {
+            if (layer.paint?.['text-occlusion-opacity'] !== undefined) {
+                coverage.drop(name, 'the label carries one occlusion opacity, taken from text-occlusion-opacity', layer.id);
+                continue;
+            }
+            if (layer.layout?.['text-field'] === undefined) {
+                coverage.drop(name, 'an icon-only layer draws a marker, which is not a label', layer.id);
+                continue;
+            }
+            const translated = tryTranslate(value, name, layer.id, coverage);
+            if (translated === null)
+                continue;
+            out.push(`text-occlusion-opacity: ${translated};`);
+            coverage.emit('text-occlusion-opacity');
+            continue;
+        }
+        const target = table[name];
+        if (!target) {
+            // An extrusion's LOOK is a Map setting here, and buildingMapSettings has already taken
+            // it (see BUILDING_MAP_SETTINGS). Reporting it dropped as well says a bevel or an
+            // ambient occlusion was thrown away when it is in the Map block.
+            if (!(symbolizer === 'building' && name in BUILDING_MAP_SETTINGS)) {
+                coverage.drop(name, KNOWN_GAPS[name] ?? 'not mapped', layer.id);
+            }
+            continue;
+        }
+        if (!allowed.has(target)) {
+            // The table above claims a property the decoder does not bind - a bug here, not in the
+            // source style. Say so rather than blaming the style.
+            coverage.drop(name, `maps to "${target}", absent from the generated allowlist`, layer.id);
+            continue;
+        }
+        // A per-category palette belongs in project.json, not baked into the rule.
+        const paramTable = fieldParamTable(value, layer, name, target, coverage, options);
+        if (paramTable !== null) {
+            out.push(`${target}: ${paramTable};`);
+            coverage.emit(target);
+            continue;
+        }
+        const translated = tryTranslate(value, name, layer.id, coverage);
+        if (translated === null)
+            continue;
+        out.push(`${target}: ${remapValue(target, translated)};`);
+        coverage.emit(target);
+    }
+    if (symbolizer === 'text') {
+        const priority = placementPriority(layer, layerIndex, coverage);
+        if (priority !== null) {
+            out.push(`text-placement-priority: ${priority};`);
+            coverage.emit('text-placement-priority');
+        }
+    }
+    // text-padding is 2 px on every MapBox layer that states nothing, and the culler's own floor is
+    // one label unit. A line-placed label gets it too now: it pads the collision box, where the old
+    // minimum-distance would have disabled the repeat floor the decoder needs.
+    const padded = symbolizer === 'shield' ? 'shield-collision-padding' : 'text-collision-padding';
+    if ((symbolizer === 'text' || symbolizer === 'shield') && !out.some((d) => d.startsWith(`${padded}:`))) {
+        out.push(`${padded}: ${collisionPad(options) * DEFAULT_TEXT_PADDING};`);
+        coverage.emit(padded);
+    }
+    // MapBox repeats a line label every 250 px whether or not the layer says so; CartoCSS's spacing
+    // defaults to 0, which is ONE label for the whole line - so a long road got its name once and a
+    // contour ring got it once, where MapTiler writes it the length of both.
+    if (symbolizer === 'text' && repeatsAlongLine(layer) && !out.some((d) => d.startsWith('text-spacing:'))) {
+        out.push(`text-spacing: ${DEFAULT_SYMBOL_SPACING};`);
+        coverage.emit('text-spacing');
+    }
+    // MapBox's spacing is a SCREEN distance it keeps over the whole line; the decoder walks it in
+    // tile units and restarts per FEATURE, so a road cut into many short ways got a shield on each
+    // one - six "D 41" where MapTiler draws two. The culler is what measures across tiles and
+    // features, so the same distance is handed to it as the floor between two labels of the group.
+    const spacingDecl = out.find((d) => d.startsWith('text-spacing:'));
+    if (symbolizer === 'text' && spacingDecl && !out.some((d) => d.startsWith('text-min-distance:'))) {
+        out.push(`text-min-distance: ${spacingDecl.slice('text-spacing:'.length).trim().replace(/;$/, '')};`);
+        coverage.emit('text-min-distance');
+    }
+    // MapBox wraps at 10 ems whether or not the layer says so; CartoCSS's wrap-width defaults to 0,
+    // which is no wrapping at all - so an unstated max-width has to be written out.
+    if (symbolizer === 'text' && !followsLine(layer) && !out.some((d) => d.startsWith('text-wrap-width:'))) {
+        const width = ems(DEFAULT_TEXT_MAX_WIDTH, layer, coverage, 'text-max-width');
+        if (width !== null) {
+            out.push(`text-wrap-width: ${width};`);
+            coverage.emit('text-wrap-width');
+        }
+    }
+    // Wrap BEFORE the word that would not fit, which is what MapBox does and what `wrap-width`
+    // means. CartoCSS defaults the other way and breaks AFTER it: `splitLines` measures the word it
+    // has just finished, so a line overshoots by one word and - because the test only runs at a
+    // wrap character - the LAST word never moves at all. "10TH ARRONDISSEMENT" and
+    // "Strasbourg - Saint-Denis" stayed on one line where mapbox-gl puts them on two.
+    const wrapDecl = out.find((d) => d.startsWith('text-wrap-width:'));
+    if (wrapDecl && !/text-wrap-width:\s*0\s*;/.test(wrapDecl)) {
+        out.push('text-wrap-before: true;');
+        coverage.emit('text-wrap-before');
+    }
+    // text-name is what makes a text symbolizer exist at all; without it every other text property
+    // is dropped with the rule - but an icon-only layer still has its marker to draw.
+    if (symbolizer === 'text' && !out.some((d) => d.startsWith('text-name:'))) {
+        // An icon stands on its own; a plate is a background FOR text and would be a floating box.
+        if (isShield) {
+            coverage.drop(`layer "${layer.id}"`, 'shield with no usable text-field, so no plate either', layer.id);
+            return [];
+        }
+        if (out.length > 0 && iconDeclarations.length === 0) {
+            coverage.drop(`layer "${layer.id}"`, 'symbol layer with neither text-field nor a usable icon', layer.id);
+        }
+        return iconDeclarations;
+    }
+    // An icon AND text is ONE symbol in MapBox. Emitted as a marker beside a text label they are
+    // two labels that collide, and the marker wins - a city dot with no name beside it. The shield
+    // is the one-label construct, so the whole rule is renamed into it.
+    // Any shield-* declaration: a sprite (shield-file) or a font icon (shield-icon-name).
+    if (iconDeclarations.some((d) => d.startsWith('shield-'))) {
+        const renamed = out.map(asShieldDeclaration).filter((d) => d !== null);
+        return [...renamed, ...iconDeclarations];
+    }
+    return [...out, ...iconDeclarations];
+}
+/**
+ * The disc under a recolourable icon, as the shield's icon PLATE.
+ *
+ * MapBox draws these as ONE image whose `params` colour a disc, its ring and the glyph, and the
+ * sheet bakes only the icon's own defaults into its flat render. The glyph is the distance field
+ * above - extractIconPlate cropped it to the disc's own box - so the plate needs no padding and its
+ * border falls exactly where the artwork's ring was. All three colours are style properties here,
+ * so they are evaluated per feature, which is what gets a POI its class colour back.
+ */
+function iconPlateDeclarations(layer, icon, sized, coverage, options) {
+    const params = layer.layout?.[ICON_PARAMS];
+    if (!icon.plate || !params)
+        return [];
+    const out = [];
+    // Where the plate covers only some features, its colours are transparent for the others - a
+    // plate with no fill and no border draws nothing (TileLabel::Style::Plate::draws).
+    const scoped = (value) => (icon.plateWhen ? `(${icon.plateWhen} ? ${value} : transparent)` : value);
+    // Radius and ring are the artwork's pixels at icon-size 1, the plate's are the screen's: at
+    // icon-size 0.4 a ring stated 3 drew 3 px where MapLibre draws 1.2, and the disc grew with it.
+    const sizedBy = (value) => (sized === '1' ? value : `((${value}) * (${sized}))`);
+    const colour = (name, target, gate = false, size = false) => {
+        if (params[name] === undefined)
+            return false;
+        // `"massif:params": ["icon-image"]` puts the icon's own palette in project.json too, so the
+        // disc, its ring and the glyph are tuned in the same place as the label's colour.
+        const translated = fieldParamTable(params[name], layer, 'icon-image', target, coverage, options)
+            ?? tryTranslate(params[name], `icon-image params.${name}`, layer.id, coverage);
+        if (translated === null)
+            return false;
+        const value = size ? sizedBy(translated) : translated;
+        out.push(`${target}: ${gate ? scoped(value) : value};`);
+        coverage.emit(target);
+        return true;
+    };
+    // The glyph, unless the layer states an icon-color of its own - that one is already out.
+    if (layer.paint?.['icon-color'] === undefined)
+        colour('icon', 'shield-icon-fill');
+    colour('background', 'shield-icon-background-fill', true);
+    // A shape the STYLE states wins over the one measured off the drawing. Radius alone spells every
+    // plate there is - half the box is a circle, a few pixels a rounded square, 0 a rectangle - so a
+    // transit badge needs no artwork of its own, and one sheet of discs covers the lot. Measured
+    // otherwise, which is what a Standard sheet of real roundels wants.
+    if (!colour('radius', 'shield-icon-background-radius', false, true)) {
+        out.push(`shield-icon-background-radius: ${sizedBy(String(round(icon.plate.radius)))};`);
+        coverage.emit('shield-icon-background-radius');
+    }
+    // Both paddings default to a text plate's, which would grow the disc off its own artwork.
+    out.push('shield-icon-background-padding-x: 0;', 'shield-icon-background-padding-y: 0;');
+    coverage.emit('shield-icon-background-padding-x');
+    coverage.emit('shield-icon-background-padding-y');
+    // Only with a colour to draw it in. `icon-background-border-fill` defaults to BLACK, and
+    // LabelPlateStyle::hasBorder is colour-and-width, so a width on its own drew an opaque black
+    // ring round the artwork - a peak's mountain glyph in a black circle, since Standard's
+    // natural_point_label states no `background-stroke` at all.
+    if (icon.plate.borderWidth > 0 && colour('background-stroke', 'shield-icon-background-border-fill', true)) {
+        // Stated wins over measured, as `radius` does: the ring is measured off the artwork, and one
+        // sheet of identical discs therefore rings a small badge as heavily as a full circle.
+        if (!colour('background-stroke-width', 'shield-icon-background-border-width', false, true)) {
+            out.push(`shield-icon-background-border-width: ${sizedBy(String(round(icon.plate.borderWidth)))};`);
+            coverage.emit('shield-icon-background-border-width');
+        }
+    }
+    // MapBox's `icon-stroke` is the outline it draws UNDER the glyph, which is exactly what the
+    // SDK grows from a distance field - so it is the icon HALO, not the plate's border (that one is
+    // the disc's ring). Standard sets it transparent while its POI background is a circle, so this
+    // is what a style asking for `backgroundPointOfInterestLabels: none` gets: a coloured glyph
+    // with a white outline and no disc at all.
+    if (params['icon-stroke'] !== undefined && icon.plate.strokeWidth > 0) {
+        colour('icon-stroke', 'shield-icon-halo-fill');
+        out.push(`shield-icon-halo-radius: ${round(icon.plate.strokeWidth)};`);
+        coverage.emit('shield-icon-halo-radius');
+    }
+    return out;
+}
+/**
+ * A road shield as the plate CartoCSS draws behind a label: the sprite is tinted by icon-color and
+ * outlined by its halo, and `text-background-*` is exactly that without needing the image. See
+ * shield.ts for what makes a layer one.
+ */
+function plateDeclarations(layer, coverage) {
+    const out = [];
+    for (const [from, to] of PLATE_MAP) {
+        emitTranslated(out, coverage, layer, from, to, undefined, false);
+    }
+    out.push(plateRadius());
+    coverage.emit('text-background-radius');
+    coverage.note(`"${layer.id}": shield sprite drawn as a text background plate, so the ` +
+        'country-specific artwork is lost but the ref stays readable');
+    return out;
+}
+/** MapBox's own default when a layer states no icon-text-fit-padding. */
+const DEFAULT_FIT_PADDING = [0, 0, 0, 0];
+/**
+ * Rebuild an icon-image expression with every image NAME replaced by whatever `of` returns for it.
+ * Null when a name could be built rather than chosen - a `concat` of a field - because then the set
+ * of images the layer can draw is not knowable here.
+ */
+function mapImageNames(image, of) {
+    if (typeof image === 'string')
+        return of(image);
+    if (!Array.isArray(image))
+        return null;
+    const head = image[0];
+    const rebuild = (indices) => {
+        const out = [...image];
+        for (const i of indices) {
+            const mapped = mapImageNames(image[i], of);
+            if (mapped === null)
+                return null;
+            out[i] = mapped;
+        }
+        return out;
+    };
+    if (head === 'image' || head === 'to-string')
+        return mapImageNames(image[1], of);
+    if (head === 'coalesce')
+        return rebuild(image.map((_, i) => i).slice(1));
+    if (head === 'case' && image.length >= 4 && image.length % 2 === 0) {
+        const branches = [];
+        for (let i = 2; i < image.length; i += 2)
+            branches.push(i);
+        return rebuild([...branches, image.length - 1]);
+    }
+    if (head === 'match' && image.length >= 5 && image.length % 2 === 1) {
+        const branches = [];
+        for (let i = 3; i < image.length; i += 2)
+            branches.push(i);
+        return rebuild([...branches, image.length - 1]);
+    }
+    return null;
+}
+/**
+ * The plate's colour per feature, as the ternary that picked its image - with the leaf image name
+ * replaced by the colour read off that artwork.
+ *
+ * A branch whose CONDITION has no CartoCSS form is skipped rather than fatal, the same way the
+ * sprite path treats one: MapTiler picks a shield on `slice(ref, 2, 3)` in places, and dropping the
+ * whole expression for it would cost every road its plate where dropping the branch costs one
+ * country its colour.
+ */
+function plateTernary(image, colourOf, onSkip) {
+    const leaf = (node) => {
+        if (typeof node === 'string')
+            return colourOf(node);
+        if (Array.isArray(node) && node.length === 2
+            && (node[0] === 'image' || node[0] === 'string' || node[0] === 'to-string')) {
+            return leaf(node[1]);
+        }
+        return null;
+    };
+    const build = (node) => {
+        const direct = leaf(node);
+        if (direct !== null)
+            return direct;
+        if (!Array.isArray(node))
+            return null;
+        const pairs = [];
+        if (node[0] === 'case' && node.length >= 4 && node.length % 2 === 0) {
+            for (let i = 1; i < node.length - 1; i += 2)
+                pairs.push([node[i], node[i + 1]]);
+        }
+        else if (node[0] === 'match' && node.length >= 5 && node.length % 2 === 1) {
+            const input = node[1];
+            for (let i = 2; i < node.length - 1; i += 2) {
+                const labels = Array.isArray(node[i]) ? node[i] : [node[i]];
+                const test = labels.length === 1
+                    ? ['==', input, labels[0]]
+                    : ['any', ...labels.map((l) => ['==', input, l])];
+                pairs.push([test, node[i + 1]]);
+            }
+        }
+        else {
+            return null;
+        }
+        let expr = build(node[node.length - 1]);
+        if (expr === null)
+            return null;
+        for (const [condition, value] of [...pairs].reverse()) {
+            const colour = build(value);
+            let test = null;
+            try {
+                test = colour === null ? null : translateExpression(condition);
+            }
+            catch {
+                test = null;
+            }
+            if (test === null) {
+                onSkip();
+                continue;
+            }
+            expr = `((${test}) ? ${colour} : ${expr})`;
+        }
+        return expr;
+    };
+    return build(image);
+}
+/**
+ * A shield whose every image is a flat plate - see describeFlatPlate. The SDK draws that without a
+ * bitmap at all, so the artwork is read for its colours and thrown away; only a shield whose
+ * outline carries meaning (a US interstate) keeps its sprite.
+ */
+function flatPlateShield(layer, options) {
+    const layout = layer.layout ?? {};
+    const fit = layout['icon-text-fit'];
+    if (!options.sprites || layout['text-field'] === undefined)
+        return null;
+    // The image has to BE the text's background, not something beside it.
+    if (fit === undefined || fit === 'none')
+        return null;
+    const plates = [];
+    const image = layout['icon-image'];
+    const mapped = mapImageNames(image, (name) => {
+        const plate = describeFlatPlate(options.sprites.sheets, name);
+        if (!plate)
+            return null;
+        plates.push(plate);
+        return name;
+    });
+    if (mapped === null || plates.length === 0)
+        return null;
+    // A shape this builder cannot write out keeps its sprite rather than losing its colour.
+    return plateTernary(image, () => '#000000', () => { }) === null ? null : plates;
+}
+/**
+ * A flat plate as the label's own background: the colours come from the artwork, per feature,
+ * through the same expression that picked the image.
+ */
+function flatPlateDeclarations(layer, plates, options, coverage) {
+    const sheets = options.sprites.sheets;
+    const image = (layer.layout ?? {})['icon-image'];
+    const colourOf = (pick) => plateTernary(image, (name) => pick(describeFlatPlate(sheets, name)), () => {
+        coverage.approximate(`one plate branch on "${layer.id}" has no CartoCSS form and is ` +
+            'skipped: those features take the next branch that matches');
+    });
+    const out = [`text-background-fill: ${colourOf((p) => p.fill)};`];
+    coverage.emit('text-background-fill');
+    if (plates.some((p) => p.borderWidth > 0)) {
+        out.push(`text-background-border-fill: ${colourOf((p) => p.border)};`);
+        out.push(`text-background-border-width: ${round(Math.max(...plates.map((p) => p.borderWidth)))};`);
+        coverage.emit('text-background-border-fill');
+        coverage.emit('text-background-border-width');
+    }
+    out.push(`text-background-radius: ${round(Math.max(...plates.map((p) => p.radius)))};`);
+    coverage.emit('text-background-radius');
+    // MapBox grows the image to the text and pads by icon-text-fit-padding; the plate is grown by
+    // the decoder, so the same numbers become its padding. [top, right, bottom, left].
+    const fit = ((layer.layout ?? {})['icon-text-fit-padding'] ?? DEFAULT_FIT_PADDING);
+    out.push(`text-background-padding-x: ${round((fit[1] + fit[3]) / 2)};`);
+    out.push(`text-background-padding-y: ${round((fit[0] + fit[2]) / 2)};`);
+    coverage.emit('text-background-padding-x');
+    coverage.emit('text-background-padding-y');
+    coverage.emit('icon-text-fit');
+    coverage.emit('icon-text-fit-padding');
+    coverage.emit('icon-image');
+    coverage.note(`"${layer.id}": every image is a flat plate, so the colours are read off the ` +
+        'artwork and the label draws its own background - no sprite ships');
+    return out;
+}
+/**
+ * The image half of a shield. ShieldSymbolizer draws the bitmap at its own size - there is no
+ * equivalent of marker-width - so icon-size cannot be carried, and unlock-image is what lets the
+ * text move off the icon (a POI name sits below its pin).
+ */
+function shieldImageDeclarations(layer, icon, scale, coverage, options) {
+    // shield-placement comes from the renamed text-placement - one label, one placement.
+    // A per-feature name arrives as a whole expression (see dynamicIconDeclarations); a constant
+    // one is just a path and takes the url() around it here.
+    const fileValue = icon.file.startsWith('@@EXPR@@')
+        ? icon.file.slice('@@EXPR@@'.length) : `url('${icon.file}')`;
+    const out = [`shield-file: ${fileValue};`, 'shield-unlock-image: true;'];
+    coverage.emit('shield-file');
+    coverage.emit('shield-unlock-image');
+    // icon-size is a zoom ramp of its own - mapbox animates an icon independently of its name - and
+    // shield-image-scale takes a function, so the ramp goes through whole rather than collapsed to
+    // a mean. Divided by the sheet's pixelRatio: a 2x sheet is drawn at half scale to come out the
+    // size the style asked for.
+    const sized = translateExpression(layer.layout?.['icon-size'] ?? 1);
+    // The divisor is spelled as a float on purpose: `/` between two INTEGERS truncates
+    // (Expression.cpp's DivOperator), so a default icon-size of 1 over a 2x sheet came out `(1) / 2`
+    // = 0 and every icon of thirteen POI layers drew at zero size.
+    const drawScale = `((${sized}) / ${icon.pixelRatio.toFixed(1)})`;
+    out.push(`shield-image-scale: ${drawScale};`);
+    coverage.emit('shield-image-scale');
+    // A distance field stays crisp at any size and takes its colour from the style, so an SDF
+    // sprite goes in as one rather than being resolved to pixels and tinted here.
+    //
+    // Only a sprite the SHEET calls a field. `shield-sdf` makes the renderer read the red channel
+    // as signed distance (GlyphMode::SDF), so a colour bitmap handed to it comes out as whatever
+    // its red channel happened to cross the edge on: Standard's transit icons are a blue disc with
+    // a white glyph, and they drew as the glyph alone with the disc gone - the colours inverted.
+    if (icon.sdf) {
+        // Per FEATURE where the plate only covers some of them: a distance field for those, the
+        // sheet's own artwork for the rest. `sdf` is a BoolProperty read with an expression
+        // context, so the one rule can say both - which is what keeps Paris's own metro roundel
+        // (white disc, blue ring, blue M) instead of recolouring it as a generic transit square.
+        out.push(`shield-sdf: ${icon.plateWhen ?? 'true'};`);
+        coverage.emit('shield-sdf');
+        emitTranslated(out, coverage, layer, 'icon-color', 'shield-icon-fill', undefined, false);
+        emitTranslated(out, coverage, layer, 'icon-opacity', 'shield-icon-opacity', undefined, false);
+        // The icon's own outline. It is what draws the dark ring round a white city dot and the
+        // white one round a POI glyph, and it is NOT the text halo - the two are separate in
+        // mapbox and now separate here.
+        emitTranslated(out, coverage, layer, 'icon-halo-color', 'shield-icon-halo-fill', undefined, false);
+        emitTranslated(out, coverage, layer, 'icon-halo-width', 'shield-icon-halo-radius', undefined, false);
+        out.push(...iconPlateDeclarations(layer, icon, sized, coverage, options));
+    }
+    else if (layer.layout?.[RECOLOURABLE_ICON] === true) {
+        // A recolourable sprite whose artwork is NOT a disc with a glyph on it (extractIconPlate
+        // took it apart where it is): the sheet ships one flat render with the icon's own default
+        // params and nothing here can tint it per feature.
+        coverage.approximate(`"${layer.id}" recolours its icon per feature; drawn with the ` +
+            "sprite sheet's own colours, so a per-class tint is lost");
+    }
+    out.push(...variableAnchorDeclarations(layer, coverage, options));
+    // Locked to the image, the text is centred ON it. MapBox anchors the TEXT and leaves the icon
+    // on the point, so the image is moved clear by half its height instead - a city name sits above
+    // its dot, a POI name below its pin, and neither is drawn over the other.
+    //
+    // An ANCHORED shield needs none of it: the culler places the text against the icon's own edge
+    // and mirrors dx/dy as the gap, so moving the image too would double the separation.
+    const clearance = out.some((d) => d.startsWith('shield-anchors:'))
+        ? 0 : iconClearance(layer, icon, scale);
+    if (clearance !== 0) {
+        out.push(`shield-dy: ${clearance};`);
+        coverage.emit('shield-dy');
+    }
+    return out;
+}
+/** Every literal dash pattern inside a value, in the order MapBox states them. */
+function dashPatterns(value) {
+    if (Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === 'number')) {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((part) => dashPatterns(part));
+    }
+    if (value && typeof value === 'object') {
+        const stops = value.stops;
+        if (Array.isArray(stops))
+            return stops.flatMap((s) => dashPatterns(s[1]));
+    }
+    return [];
+}
+/**
+ * The one dash pattern to draw, out of whatever MapBox states - CartoCSS takes a pattern, not a
+ * ramp. The LAST one that actually dashes, with the zoom it starts at: MapTiler's disputed border
+ * ramps from `[1, 0]` (a SOLID line, below z5) to `[3, 2, 0.1, 2]`, and taking the base there would
+ * draw it solid at every zoom anyone looks at. Where several stops dash - Standard's steps go
+ * `[0.2, 0.2]` at z17 then `[0.1, 0.1]` at z19 - the last is the one whose line is widest, and a
+ * dash is a multiple of that width, so it is also the one that lands closest across the range.
+ * Null when no literal pattern is reachable at all.
+ */
+function dashPattern(value) {
+    const patterns = dashPatterns(value);
+    if (!patterns.length)
+        return null;
+    const dashes = (p) => p.length > 1 && p.some((v, i) => i % 2 === 1 && v > 0);
+    const dashing = patterns.filter(dashes);
+    const pattern = dashing.length ? dashing[dashing.length - 1] : patterns[0];
+    return { pattern, zoom: stopZoomOf(value, pattern) };
+}
+/**
+ * A dashed line whose WIDTH ramps over zoom, as one attachment per zoom band.
+ *
+ * A MapBox dash length is a multiple of the line width, and CartoCSS takes ONE pattern of PIXELS per
+ * rule - the decoder rasterises it into a bitmap keyed by the literal string, so it cannot be a
+ * function of anything. A single rule is therefore only right at one zoom: Liberty's rail hatching
+ * ramps its width 3 -> 8 between z15 and z20, and the one scale we could pick drew the dash 1.8x too
+ * long at the bottom of that range and 0.7x too short at the top.
+ *
+ * Banded, each attachment scales its dash by the width in the MIDDLE of its own band, and the bands
+ * are cut where the width DOUBLES - so the worst error inside one is a factor of sqrt(2) instead of
+ * the whole ramp. The outer edges keep the layer's own zoom range, so nothing stops being drawn.
+ *
+ * It lives here rather than in split.ts because it needs `dashPattern` and `rampAt`, and moving
+ * those would cost an import cycle for one caller.
+ */
+function splitDashByZoom(layer, coverage) {
+    const dash = layer.paint?.['line-dasharray'];
+    const width = dashWidth(layer.paint?.['line-width']);
+    if (dash === undefined || layer.dashZoom !== undefined || !Array.isArray(width))
+        return [layer];
+    const pattern = dashPattern(dash);
+    // A dash the style RAMPS states the zoom its pattern begins at, and reading the width there is
+    // already the targeted answer - Standard's treads depend on it. Banding is for the plain
+    // literal dash, which has no zoom of its own to be read at.
+    if (pattern === null || pattern.zoom !== null)
+        return [layer];
+    // From the first stop that is actually DRAWN, not the first stop: a ramp starting at width 0 -
+    // Liberty's rail hatchings start (14.5, 0) - has nothing to keep the dash in proportion to
+    // below it. And no further than the last stop, above which the width is flat and a band would
+    // read the same number twice.
+    const stops = rampStops(width);
+    const lo = Math.floor(Math.max(layer.minzoom ?? 0, stops.find(([, w]) => w > 0)?.[0] ?? 0));
+    const hi = Math.ceil(Math.min(layer.maxzoom ?? 24, stops[stops.length - 1]?.[0] ?? 24, 24));
+    const wLo = rampAt(width, lo);
+    const wHi = rampAt(width, hi);
+    if (hi - lo < 2 || !wLo || !wHi || wLo <= 0 || wHi <= 0)
+        return [layer];
+    // Cut where the width DOUBLES, rounding up: a band spanning a 2x range is at worst sqrt(2) out
+    // in the middle, which is the error this is willing to keep.
+    const ratio = Math.max(wHi / wLo, wLo / wHi);
+    const bandCount = Math.min(MAX_DASH_BANDS, hi - lo, Math.ceil(Math.log2(ratio)));
+    if (bandCount < 2)
+        return [layer];
+    const step = Math.max(1, Math.round((hi - lo) / bandCount));
+    const bands = [];
+    for (let from = lo; from < hi; from += step) {
+        const to = Math.min(hi, from + step);
+        bands.push({
+            ...layer,
+            // The ends keep whatever the layer stated, so banding never narrows what it draws.
+            minzoom: from === lo ? layer.minzoom : from,
+            maxzoom: to >= hi ? layer.maxzoom : to,
+            dashZoom: (from + to) / 2,
+        });
+    }
+    if (bands.length < 2)
+        return [layer];
+    coverage.approximate(`line-dasharray on "${layer.id}" split into ${bands.length} zoom bands: a `
+        + 'dash is a multiple of the line width and CartoCSS takes one pattern per rule, so a '
+        + 'ramped width needs a rule per band to stay in proportion');
+    return bands;
+}
+/**
+ * The width a dash is scaled by. A width chosen per config value (`match` on `["config", ...]`) is
+ * read at its fallback: its numbers averaged over every branch drew an e-ink track's 5 px dash 50 px.
+ */
+function dashWidth(width) {
+    if (Array.isArray(width) && width[0] === 'match' && Array.isArray(width[1]) && width[1][0] === 'config') {
+        return dashWidth(width[width.length - 1]);
+    }
+    return width;
+}
+/** A zoom ramp's `(zoom, value)` stops, in order. Empty for anything that is not one. */
+function rampStops(expr) {
+    if (!Array.isArray(expr) || (expr[0] !== 'interpolate' && expr[0] !== 'step'))
+        return [];
+    const stops = [];
+    for (let i = 3; i + 1 < expr.length; i += 2) {
+        const value = stopNumber(expr[i + 1]);
+        if (typeof expr[i] === 'number' && value !== null)
+            stops.push([expr[i], value]);
+    }
+    return stops;
+}
+/** Past this the rule count costs more than the dash proportions are worth. */
+const MAX_DASH_BANDS = 4;
+/** The zoom a `step` ramp switches to this pattern at, so the line width can be read there. */
+function stopZoomOf(value, pattern) {
+    if (!Array.isArray(value) || value[0] !== 'step')
+        return null;
+    const same = (node) => Array.isArray(node) && node.length === pattern.length
+        && node.every((v, i) => v === pattern[i]);
+    for (let i = 3; i + 1 < value.length; i += 2) {
+        const stop = value[i + 1];
+        const list = Array.isArray(stop) && stop[0] === 'literal' ? stop[1] : stop;
+        if (same(list) && typeof value[i] === 'number')
+            return value[i];
+    }
+    return null;
+}
+/**
+ * One stop of a zoom ramp as a number: the value itself, or the FALLBACK branch of a data-driven
+ * one. Standard's cycleway width is `interpolate(zoom, 12, match(type, piste, 0.5, 0), 18, match(…,
+ * 4, 2), 22, match(…, 40, 20))`, and a stop that was not a plain number sank the whole ramp - the
+ * dash then fell back to the mean of every literal in it, 13.3 px against the 1.3 gl-js draws at the
+ * zoom the pattern starts. The fallback is the branch nearly every feature takes; a piste is the
+ * exception, and one pattern cannot serve both.
+ */
+function stopNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    if (!Array.isArray(value))
+        return null;
+    if (value[0] === 'literal')
+        return stopNumber(value[1]);
+    if (value[0] === 'match' || value[0] === 'case')
+        return stopNumber(value[value.length - 1]);
+    return null;
+}
+/**
+ * A zoom ramp read at ONE zoom, or null when the shape is not one this can evaluate.
+ *
+ * The mean of a ramp's stops is no use for a dash: Standard's steps run `12, 0, 18, 6, 22, 80`, so
+ * the mean is 43 px - a width nothing on screen ever has - and MapBox's `0.2` dash came out at
+ * 8.6 px where gl-js draws well under 2.
+ */
+function rampAt(expr, zoom) {
+    if (typeof expr === 'number')
+        return expr;
+    if (!Array.isArray(expr))
+        return null;
+    if (expr[0] === 'step') {
+        let value = expr[2];
+        for (let i = 3; i + 1 < expr.length; i += 2) {
+            if (typeof expr[i] !== 'number' || expr[i] > zoom)
+                break;
+            value = expr[i + 1];
+        }
+        return stopNumber(value);
+    }
+    if (expr[0] !== 'interpolate')
+        return null;
+    const kind = expr[1];
+    const base = Array.isArray(kind) && kind[0] === 'exponential' && typeof kind[1] === 'number'
+        ? kind[1] : 1;
+    const stops = [];
+    for (let i = 3; i + 1 < expr.length; i += 2) {
+        const value = stopNumber(expr[i + 1]);
+        if (typeof expr[i] === 'number' && value !== null) {
+            stops.push([expr[i], value]);
+        }
+    }
+    if (!stops.length)
+        return null;
+    if (zoom <= stops[0][0])
+        return stops[0][1];
+    if (zoom >= stops[stops.length - 1][0])
+        return stops[stops.length - 1][1];
+    for (let i = 1; i < stops.length; i++) {
+        const [z0, v0] = stops[i - 1];
+        const [z1, v1] = stops[i];
+        if (zoom > z1)
+            continue;
+        const span = z1 - z0;
+        const t = base === 1 || span === 0
+            ? (zoom - z0) / span
+            : (Math.pow(base, zoom - z0) - 1) / (Math.pow(base, span) - 1);
+        return v0 + t * (v1 - v0);
+    }
+    return null;
+}
+/** The layout properties variableAnchorDeclarations owns, so the generic loop leaves them alone. */
+const VARIABLE_ANCHOR_LAYOUT = new Set([
+    'text-variable-anchor', 'text-optional', 'text-radial-offset', 'text-justify',
+]);
+/** MapBox's variable anchor -> the SDK's, which spells the corners without the hyphen. */
+const VARIABLE_ANCHORS = new Set([
+    'center', 'left', 'right', 'top', 'bottom',
+    'top-left', 'top-right', 'bottom-left', 'bottom-right',
+]);
+/**
+ * The two spellings are OPPOSITES. MapBox names the part of the TEXT nearest the anchor, so
+ * `bottom` puts the text ABOVE the point; the SDK names the SIDE the text is laid out on
+ * (`vt::LabelAnchor`, "which side of its anchor a label's text is laid out on"), so `bottom` puts it
+ * BELOW. Carried across name-for-name, every anchored label sat on the wrong side of its icon - and
+ * it read as correct in one pane at a time, since the two errors cancel when only one is looked at.
+ */
+function oppositeAnchor(anchor) {
+    const flip = { top: 'bottom', bottom: 'top', left: 'right', right: 'left' };
+    return anchor.split('-').map((part) => flip[part] ?? part).join('');
+}
+/**
+ * MapBox tries each of `text-variable-anchor` in turn and keeps the first side the label fits on,
+ * falling back to the icon alone when `text-optional` allows it. `ShieldSymbolizer` does the same
+ * thing from the same list, so the four properties that describe it map straight across - all of
+ * them shield-only, because a side to place the text on presupposes an icon to place it beside.
+ */
+function variableAnchorDeclarations(layer, coverage, options) {
+    const layout = layer.layout ?? {};
+    const out = [];
+    const variable = layout['text-variable-anchor'];
+    // --shield-anchors, for a style that states none. Standard is one: every POI name sits under its
+    // icon and is dropped WITH it when it does not fit, where mapbox-gl would keep the icon.
+    if (!Array.isArray(variable) && options.shieldAnchors) {
+        out.push(`shield-anchors: '${options.shieldAnchors}';`);
+        coverage.emit('shield-anchors');
+        if (layout['text-optional'] === undefined) {
+            out.push('shield-text-optional: true;');
+            coverage.emit('shield-text-optional');
+        }
+        coverage.note(`"${layer.id}": text anchored to the icon's free side (--shield-anchors), ` +
+            'which the source style does not ask for');
+    }
+    if (Array.isArray(variable)) {
+        const anchors = variable.filter((a) => typeof a === 'string' && VARIABLE_ANCHORS.has(a));
+        if (anchors.length < variable.length) {
+            coverage.drop('text-variable-anchor', 'unknown anchor in the list', layer.id);
+        }
+        if (anchors.length) {
+            out.push(`shield-anchors: '${anchors.map(oppositeAnchor).join(',')}';`);
+            coverage.emit('shield-anchors');
+        }
+    }
+    // Without this a label that fits on no side is dropped WITH its icon.
+    if (layout['text-optional'] === true) {
+        out.push('shield-text-optional: true;');
+        coverage.emit('shield-text-optional');
+    }
+    else if (layout['text-optional'] !== undefined && layout['text-optional'] !== false) {
+        coverage.drop('text-optional', 'only a literal true is carried', layer.id);
+    }
+    // The icon placed whatever it covers. The shield is one label, so its name overlaps too, where
+    // MapBox would drop an optional name that collides.
+    if (layout['icon-allow-overlap'] === true) {
+        out.push('shield-allow-overlap: true;');
+        coverage.emit('shield-allow-overlap');
+    }
+    // Carried as MapBox's own property, not as dx: it is measured from the ANCHOR to the near edge
+    // of the text, on the chosen side's axis and nothing across it (evaluateVariableOffset). Read as
+    // dx the SDK added the icon's half-width to every side gap, and slid a name centred under its
+    // icon one dx to the right. Only read when no text-offset states it, as MapBox does.
+    const radial = layout['text-radial-offset'];
+    if (typeof radial === 'number' && radial !== 0 && layout['text-offset'] === undefined) {
+        const gap = ems(radial, layer, coverage, 'text-radial-offset');
+        if (gap !== null) {
+            out.push(`shield-text-radial-offset: ${gap};`);
+            coverage.emit('shield-text-radial-offset');
+        }
+    }
+    else if (radial !== undefined && typeof radial !== 'number') {
+        coverage.drop('text-radial-offset', 'only a literal offset is carried', layer.id);
+    }
+    // How a WRAPPED label justifies itself once a side is chosen; 'auto' follows that side.
+    const justify = layout['text-justify'];
+    if (typeof justify === 'string') {
+        const align = justify === 'center' ? 'middle' : justify;
+        out.push(`shield-text-horizontal-alignment: '${align}';`);
+        coverage.emit('shield-text-horizontal-alignment');
+    }
+    else if (justify !== undefined) {
+        coverage.drop('text-justify', 'only a literal justification is carried', layer.id);
+    }
+    return out;
+}
+/**
+ * Which way, and how far, the image moves so the text does not land on it.
+ *
+ * MapBox measures `text-offset` from the anchor the ICON also sits on, so an offset smaller than
+ * half the icon leaves the two overlapping - a city dot at 0.15 em landed on its own name's
+ * descender. The SDK centres the text on the IMAGE instead, so what it needs is the offset TOPPED
+ * UP to half the icon, never the two added: a POI states 0.8 em, already clear of its pin, and
+ * adding half an icon on top of that floated the name well below it.
+ */
+/** A value as authored when it is a constant, else the branch representativeConstant picks. */
+function literalOrRepresentative(value) {
+    if (value === undefined || !Array.isArray(value))
+        return value;
+    // A plain [x, y] offset is a literal, not an expression.
+    if (value.every((v) => typeof v === 'number'))
+        return value;
+    return representativeConstant(value) ?? undefined;
+}
+/**
+ * The INK's own size, with the transparent margin padField added round an SDF field taken back off.
+ * The quad is drawn at the padded size and that is what marker-width wants; what the text has to
+ * clear is the artwork.
+ */
+function artworkSize(icon) {
+    return [icon.width - 2 * icon.padding, icon.height - 2 * icon.padding];
+}
+function iconClearance(layer, icon, scale) {
+    // Both may BRANCH - Standard's poi-label states its anchor as a step over zoom and its offset
+    // as a case over the feature - and read literally each one falls back to "no anchor", which
+    // skipped the top-up entirely and left every POI name sitting on its own icon.
+    const anchor = literalOrRepresentative(layer.layout?.['text-anchor']);
+    const offset = literalOrRepresentative(layer.layout?.['text-offset']);
+    const dy = Array.isArray(offset) && typeof offset[1] === 'number' ? offset[1] : 0;
+    if (layer.layout?.['text-radial-offset'] !== undefined)
+        return 0;
+    // The offset is in ems of the text size, the icon in pixels, so they meet at a representative
+    // size - the same approximation representativeScale makes for a zoom-driven icon-size.
+    const emPixels = Math.abs(dy) * representativeScale(layer.layout?.['text-size'], 16);
+    // 'bottom' anchors the text's bottom edge, so the text is ABOVE and the icon goes below.
+    const below = anchor === 'bottom';
+    const above = anchor === 'top';
+    if (!below && !above)
+        return 0;
+    const shortfall = artworkSize(icon)[1] * scale / 2 - emPixels;
+    if (shortfall <= 0)
+        return 0;
+    // HALF the shortfall, and the half is empirical.
+    //
+    // By the model it should be 0: the SDK honours the anchor (TextFormatter::layoutLines puts the
+    // block's top edge on the offset point when alignment.y is +1), which is exactly what MapBox
+    // means by `text-anchor: top`, so the stated offset already clears the icon on both sides.
+    // Measured against Standard at the Louvre, 0 sits a shade tight and the full shortfall pushes
+    // the name visibly further off its icon than mapbox-gl does - our extracted sprite is drawn
+    // larger than MapBox draws the same icon, and the shortfall is computed from ours.
+    return round((below ? 1 : -1) * shortfall * 0.5);
+}
+/**
+ * One number to bake an icon-size into the bitmap with. A zoom ramp has no single answer, so it
+ * takes the mean of its stops - the icon is then right in the middle of the range and a little off
+ * at both ends, which beats drawing every sprite at full size.
+ */
+/**
+ * An emissive strength out of a value that branches.
+ *
+ * NOT `representativeScale`: that one averages the strictly POSITIVE numbers it finds, which is
+ * right for a size (0 means unset) and wrong for an emissive, where 0 is the whole point. Standard
+ * writes the roads' as `0.4 + case(isHighClass, 0.2, 0)`; averaging gave 0.3, so every ordinary
+ * road at dusk came out a sixth too dark, and the water's `interpolate(zoom, ..., 0)` lost its 0
+ * stop entirely and kept 0.1 - which is why the water polygon and the waterway line, drawn with the
+ * same colour by mapbox, disagreed by 5 L points at night.
+ *
+ * This takes the branch most features get (the last one, as `representativeConstant` does) and
+ * folds the arithmetic around it, so the roads resolve to 0.4 and the water to 0.
+ */
+function representativeEmissive(value, fallback, config = () => undefined) {
+    const bound = new Map();
+    const fold = (node) => {
+        if (typeof node === 'number')
+            return node;
+        if (!Array.isArray(node))
+            return null;
+        const head = node[0];
+        if (head === 'literal')
+            return fold((node[1] ?? null));
+        // `let` binds name/value pairs and evaluates its last argument; `var` reads one back.
+        // Standard writes the ROADS' emissive that way, and without this the whole expression was
+        // unresolvable - which fell back to the property default of 0 and drew every road black.
+        if (head === 'let' && node.length >= 2) {
+            for (let i = 1; i + 1 < node.length - 1; i += 2) {
+                if (typeof node[i] === 'string')
+                    bound.set(node[i], node[i + 1]);
+            }
+            return fold(node[node.length - 1]);
+        }
+        if (head === 'var' && typeof node[1] === 'string') {
+            const value = bound.get(node[1]);
+            return value === undefined ? null : fold(value);
+        }
+        if (head === 'to-boolean' || head === 'number')
+            return fold((node[1] ?? null));
+        // A style knob the emissive is built from - Standard's roads are `roadsBrightness + …`.
+        if (head === 'config' && typeof node[1] === 'string') {
+            const value = config(node[1]);
+            return value === undefined ? null : fold(value);
+        }
+        // The detailed end of a ramp, a case's fallback - what a feature in a dense tile gets.
+        if ((head === 'step' || head === 'interpolate' || head === 'case' || head === 'match') && node.length >= 4) {
+            return fold(node[node.length - 1]);
+        }
+        if ((head === '+' || head === '-' || head === '*' || head === '/') && node.length === 3) {
+            const a = fold(node[1]);
+            const b = fold(node[2]);
+            if (a === null || b === null)
+                return null;
+            return head === '+' ? a + b : head === '-' ? a - b : head === '*' ? a * b : (b === 0 ? null : a / b);
+        }
+        if ((head === 'min' || head === 'max') && node.length >= 3) {
+            const parts = node.slice(1).map((n) => fold(n));
+            if (parts.some((n) => n === null))
+                return null;
+            return head === 'min' ? Math.min(...parts) : Math.max(...parts);
+        }
+        return null;
+    };
+    const folded = value === undefined ? null : fold(value);
+    return folded === null ? fallback : folded;
+}
+function representativeScale(size, fallback = 1) {
+    if (size === undefined)
+        return fallback;
+    if (typeof size === 'number')
+        return size;
+    const numbers = [];
+    const walk = (value) => {
+        if (typeof value === 'number')
+            numbers.push(value);
+        else if (Array.isArray(value))
+            value.forEach((item) => walk(item));
+        else if (value && typeof value === 'object')
+            Object.values(value).forEach((item) => walk(item));
+    };
+    // Drop the zoom keys: in `interpolate(…, 6, 0.6, 14, 0.7)` only every second number is a size.
+    // interpolate(…, zoom, z0, v0, z1, v1) puts its values at 4, 6, …; step(zoom, v0, z1, v1) at 2, 4, …
+    if (Array.isArray(size) && (size[0] === 'interpolate' || size[0] === 'step')) {
+        for (let i = size[0] === 'step' ? 2 : 4; i < size.length; i += 2)
+            walk(size[i]);
+    }
+    else {
+        walk(size);
+    }
+    const sizes = numbers.filter((n) => n > 0);
+    return sizes.length === 0 ? fallback : sizes.reduce((a, b) => a + b, 0) / sizes.length;
+}
+/**
+ * The field a data-driven `icon-image` names its sprite from, or null when it names a constant.
+ *
+ * MapTiler writes `coalesce(image(subclass), image(class), image('dot'))`: the first name that IS
+ * in the sprite wins. CartoCSS has no coalesce, so only the FIRST field is used - a POI whose
+ * subclass has no sprite gets its label without an icon, where MapTiler falls back to the dot.
+ */
+function dynamicIconField(image) {
+    // `["image", …]` is unwrapped in fold.ts (the SDK cannot tint a sprite per feature), and the
+    // type assertions around a name carry nothing, so both are seen through here rather than being
+    // matched on. Standard names a POI icon `case(has(maki_beta), coalesce(maki_beta, maki), maki)`.
+    const fieldOf = (node) => {
+        if (!Array.isArray(node))
+            return null;
+        if (node[0] === 'image' || node[0] === 'string' || node[0] === 'to-string') {
+            return fieldOf(node[1]);
+        }
+        return node[0] === 'get' && typeof node[1] === 'string' ? node[1] : null;
+    };
+    const constantOf = (node) => {
+        if (Array.isArray(node) && node[0] === 'image' && typeof node[1] === 'string')
+            return node[1];
+        return typeof node === 'string' ? node : null;
+    };
+    const fields = [];
+    let fallback = null;
+    // Only the VALUE branches name an icon; a condition tests something else entirely.
+    const gather = (node) => {
+        if (Array.isArray(node) && node[0] === 'coalesce') {
+            node.slice(1).forEach((branch) => gather(branch));
+            return;
+        }
+        if (Array.isArray(node) && node[0] === 'case' && node.length >= 4) {
+            for (let i = 2; i + 1 < node.length; i += 2)
+                gather(node[i]);
+            gather(node[node.length - 1]);
+            return;
+        }
+        const field = fieldOf(node);
+        if (field !== null) {
+            if (!fields.includes(field))
+                fields.push(field);
+            return;
+        }
+        fallback = constantOf(node) ?? fallback;
+    };
+    gather(image);
+    return fields.length ? { fields, fallback } : null;
+}
+/**
+ * An `icon-image` that names its sprite from the feature, as a chain of parameter lookups.
+ *
+ * MapTiler writes these three ways, and all three are lookups on ONE field:
+ *   coalesce(image(subclass), image(class), image('dot'))
+ *   match(get(class), ['bed_and_breakfast', …], get(class), 'apartment', 'lodging', 'lodging')
+ *   case(get(cuisine) == 'turkish', 'kebab', …, match(get(class), …))
+ *
+ * A style parameter per label IS that lookup - `[param::t-<label>]` is null when the label has no
+ * entry, so `??` falls through exactly as coalesce and the fallback branch do. The alternative was
+ * one attachment per branch, which cost a rule each and ran into MAX_VARIANTS: MapTiler's
+ * accommodation table has nine branches, so it did not split at all and every hotel lost its icon.
+ */
+/**
+ * The sprite table again under the names the TARGET tiles use. A per-feature icon is looked up by
+ * the field's value at draw time, so a class OpenMapTiles spells `town_hall` cannot be rewritten in
+ * the style - only answered for. See ICON_ALIASES.
+ */
+function aliasSprites(names, file, prefix, options) {
+    if (!options.schema)
+        return;
+    const have = new Set(names);
+    for (const [alias, sprite] of Object.entries(ICON_ALIASES[options.sourceSchema ?? 'maptiler'])) {
+        if (have.has(sprite) && !have.has(alias))
+            options.styleParams.set(`${prefix}${alias}`, file.get(sprite));
+    }
+}
+function iconExpression(image, layer, coverage, options) {
+    const sprites = options.sprites;
+    const slug = safeParamName(layer.id);
+    let sample = null;
+    let tableIndex = 0;
+    // A recolourable icon is cut in two - the glyph as a field, the disc as the shield's plate - so
+    // the style's colours reach it per feature (extractIconPlate). Its own parameter table, because
+    // the two halves live under the same NAME and a rule must not pick up the other one's file.
+    const plateMode = layer.layout?.[ICON_PARAMS] !== undefined;
+    const paramPrefix = plateMode ? GLYPH_PARAM_PREFIX : ICON_PARAM_PREFIX;
+    // The params may cover only some of the layer's features (see IconParamScope). The rest keep
+    // the sheet's own artwork, so the rule has to pick per feature between a field and a raster -
+    // which `shield-sdf` allows, being read with an expression context like every other property.
+    const scope = layer.layout?.[ICON_PARAM_SCOPE];
+    const plateWhen = scope
+        ? `(${scope.labels.map((l) => `[${scope.field}] = '${l}'`).join(' || ')})`
+        : null;
+    // What the layer NAMES outright, and what a whole-sheet lookup could reach. Separate because
+    // one rule states one plate geometry: Standard's transit roundel is a rounded square and its
+    // POI icons are circles, and a median over the sheet gives the transit rule the POI's radius.
+    const namedPlates = [];
+    const sheetPlates = [];
+    // And their SIZES, for the same reason: `sample` is whichever sprite was reached first, and its
+    // height is what iconClearance moves the image by. Standard's POI sheet spans a 20 px glyph and
+    // a 54 px badge, so the first one taken hung every natural_point_label name a badge's height off
+    // its own icon.
+    const namedSizes = [];
+    const sheetSizes = [];
+    // A `match` states its sprite names as LABELS even when the branch resolves per feature, and a
+    // rule carries one plate geometry: Standard's transit roundel is a rounded square while its POI
+    // icons are circles, so a median over the whole sheet gives the transit rule a circle's radius.
+    // Only the geometry is taken here - the name still comes from the whole-sheet table.
+    // --icon-font: the table holds a CHARACTER of the icon face per name instead of a file path, so
+    // every shape below (a match table, a whole-sheet lookup, a `{token}` prefix) resolves the same
+    // way and nothing is cut out of the sheet at all.
+    const glyphs = options.iconFont?.glyphs;
+    const notePlate = (name) => {
+        if (glyphs || !plateMode)
+            return;
+        const icon = extractIconPlate(sprites.sheets, name, sprites.outDir);
+        if (icon?.plate)
+            namedPlates.push(icon.plate);
+        if (icon)
+            namedSizes.push(artworkSize(icon));
+    };
+    const named = (name) => {
+        if (glyphs)
+            return glyphs.get(name) ?? null;
+        // In plate mode the rule declares `shield-sdf`, and that is a statement about EVERY file it
+        // can name: a raster cut handed to it is read as a distance field and comes out inverted.
+        // So a sprite with no field is not named at all - it draws nothing rather than a blob.
+        const icon = plateMode
+            ? extractIconPlate(sprites.sheets, name, sprites.outDir)
+            : extractIcon(sprites.sheets, name, sprites.outDir, options.flattenSdf, undefined, 1);
+        if (!icon)
+            return null;
+        if (icon.plate)
+            namedPlates.push(icon.plate);
+        namedSizes.push(artworkSize(icon));
+        if (!sample || (icon.plate && !sample.plate))
+            sample = icon;
+        return icon.file;
+    };
+    // The labels a condition accepts for one field, or null when it tests something else.
+    const labelsOf = (condition, field) => {
+        if (!Array.isArray(condition))
+            return null;
+        const [op, a, b] = condition;
+        if (op === '==' && Array.isArray(a) && a[0] === 'get' && a[1] === field && typeof b === 'string')
+            return [b];
+        if (op === 'in' && Array.isArray(a) && a[0] === 'get' && a[1] === field
+            && Array.isArray(b) && b[0] === 'literal' && Array.isArray(b[1])) {
+            return b[1].every((l) => typeof l === 'string') ? b[1] : null;
+        }
+        if (op === 'any' || op === 'all') {
+            const parts = condition.slice(1).map((c) => labelsOf(c, field));
+            if (op === 'any' && parts.every((x) => x !== null))
+                return parts.flat();
+        }
+        return null;
+    };
+    // The field a case's first condition tests, so the rest can be checked against it.
+    const fieldOfCase = (condition) => {
+        const walk = (node) => {
+            if (!Array.isArray(node))
+                return null;
+            if (node[0] === 'get' && typeof node[1] === 'string')
+                return node[1];
+            for (const child of node.slice(1)) {
+                const found = walk(child);
+                if (found)
+                    return found;
+            }
+            return null;
+        };
+        return walk(condition);
+    };
+    // A name built from a literal prefix and ONE field: `road_{ref_length}` and its expression
+    // spelling `concat('road_', get(ref_length))`. The parameter name is built the same way, so the
+    // lookup lands on icon-road_3 - which is what gets a junction its real shield artwork.
+    const prefixed = (prefix, field) => {
+        const all = ensureEverySprite();
+        const matching = all.names.filter((n) => n.startsWith(prefix));
+        if (matching.length === 0)
+            return null;
+        for (const name of matching)
+            options.styleParams.set(`${paramPrefix}${name}`, all.file.get(name));
+        return `[param::${paramPrefix}${prefix}[${field}]]`;
+    };
+    /** Every sprite written out, each under the file the rule should name it by. */
+    let everySprite = null;
+    const ensureEverySprite = () => {
+        if (glyphs)
+            return { names: [...glyphs.keys()], file: glyphs };
+        if (!everySprite) {
+            const file = new Map();
+            let best;
+            if (plateMode) {
+                // ONLY the sprites that split. A rule that declares `shield-sdf` says it of every
+                // file it can name, so seeding this from the raster cut and overwriting the ones
+                // that split left a third of the table pointing at colour bitmaps - each read as a
+                // distance field, and each drawn as an inverted blob.
+                const glyphs = extractAllIconPlates(sprites.sheets, sprites.outDir);
+                for (const { name, icon } of glyphs.entries) {
+                    file.set(name, icon.file);
+                    if (icon.plate)
+                        sheetPlates.push(icon.plate);
+                    sheetSizes.push(artworkSize(icon));
+                }
+                if (glyphs.skipped.length > 0) {
+                    coverage.approximate(`"${layer.id}" resolves its icon through the whole sheet, ` +
+                        `and ${glyphs.skipped.length} of its sprites are not a disc with a glyph on ` +
+                        "it - MapBox's generic pin among them. Those are left out, so a feature " +
+                        'naming one draws its label alone');
+                }
+                best = glyphs.sample;
+            }
+            else {
+                const raster = extractAllIcons(sprites.sheets, sprites.outDir, options.flattenSdf);
+                for (const name of raster.names)
+                    file.set(name, `icons/${name}.png`);
+                best = raster.sample;
+            }
+            everySprite = { names: [...file.keys()], file };
+            if (!sample || (best?.plate && !sample.plate))
+                sample = best;
+        }
+        return everySprite;
+    };
+    /**
+     * A case or match no ONE-field table can carry, written out as a ternary instead.
+     *
+     * MapTiler picks a shield's artwork on `class` AND `iso_a2` AND the route network at once, so
+     * the branch conditions read several fields - which a ternary handles and a parameter name
+     * cannot. Only the NAMES need the table treatment, and each branch spells its own.
+     */
+    const asTernary = (node) => {
+        if (!Array.isArray(node))
+            return null;
+        const pairs = [];
+        let tail;
+        if (node[0] === 'case' && node.length >= 4 && node.length % 2 === 0) {
+            for (let i = 1; i + 1 < node.length; i += 2)
+                pairs.push([node[i], node[i + 1]]);
+            tail = node[node.length - 1];
+        }
+        else if (node[0] === 'match' && node.length >= 5 && node.length % 2 === 1) {
+            const input = node[1];
+            for (let i = 2; i + 1 < node.length; i += 2) {
+                const labels = Array.isArray(node[i]) ? node[i] : [node[i]];
+                for (const label of labels)
+                    if (typeof label === 'string')
+                        notePlate(label);
+                const test = labels.length === 1
+                    ? ['==', input, labels[0]]
+                    : ['any', ...labels.map((l) => ['==', input, l])];
+                pairs.push([test, node[i + 1]]);
+            }
+            tail = node[node.length - 1];
+        }
+        else {
+            return null;
+        }
+        let expr = build(tail);
+        if (expr === null)
+            return null;
+        for (const [condition, value] of [...pairs].reverse()) {
+            // A branch that cannot be spelled is SKIPPED, not fatal. One of MapTiler's shield
+            // branches tests `slice(ref, 2, 3)`, which is not a prefix and has no CartoCSS form -
+            // and dropping the whole expression for it cost every shield its artwork, where
+            // dropping the branch costs one country its variant.
+            const name = build(value);
+            let test = null;
+            try {
+                test = name === null ? null : translateExpression(condition);
+            }
+            catch {
+                test = null;
+            }
+            if (test === null) {
+                coverage.approximate(`one icon-image branch on "${layer.id}" has no CartoCSS form ` +
+                    'and is skipped: those features take the next branch that matches');
+                continue;
+            }
+            expr = `((${test}) ? ${name} : ${expr})`;
+        }
+        return expr;
+    };
+    const build = (node) => {
+        // The type assertions and coercions carry nothing but their value, and Standard wraps every
+        // POI icon name in them - `case(has(maki_beta), to-string(coalesce(string(maki_beta),
+        // string(maki))), string(maki))`. Unseen, every branch built to null and the whole
+        // expression with it, which is why a POI drew its label and no icon.
+        if (Array.isArray(node) && node.length === 2
+            && (node[0] === 'string' || node[0] === 'to-string' || node[0] === 'number')) {
+            return build(node[1]);
+        }
+        if (typeof node === 'string') {
+            const token = node.match(/^([^{}]*)\{([A-Za-z0-9_:-]+)\}$/);
+            if (token)
+                return prefixed(token[1], token[2]);
+            const file = named(node);
+            return file ? `'${file}'` : `''`;
+        }
+        if (Array.isArray(node) && node[0] === 'concat') {
+            const parts = node.slice(1);
+            // A leading 'sheet:' only chose a sprite sheet. Every sheet is written out under bare
+            // names now (see extractAllIcons), so the prefix is dropped and the rest resolved.
+            if (typeof parts[0] === 'string' && /:$/.test(parts[0]) && parts.length === 2) {
+                return build(parts[1]);
+            }
+            // Otherwise the pieces spell a file NAME. mapnik interpolates every [field] in a
+            // string, so the path carries them directly - which is what lets a name read two
+            // fields (`AL-highway_2` is iso_a2 and ref_length) where a parameter lookup, holding
+            // one, cannot.
+            const spelled = parts.map((part) => {
+                let piece = part;
+                while (Array.isArray(piece) && piece[0] === 'to-string')
+                    piece = piece[1];
+                if (typeof piece === 'string' || typeof piece === 'number')
+                    return String(piece);
+                if (Array.isArray(piece) && piece[0] === 'get' && typeof piece[1] === 'string')
+                    return `[${piece[1]}]`;
+                return null;
+            });
+            if (spelled.some((piece) => piece === null))
+                return null;
+            // A spelled name is a FILE path mapnik interpolates the fields into; an icon face has no
+            // such thing, so the name has to come out of the table instead.
+            if (glyphs) {
+                coverage.drop('icon-image', `"${layer.id}" names its sprite by spelling a path ` +
+                    '(--icon-font has no per-feature file name to spell)', layer.id);
+                return null;
+            }
+            ensureEverySprite();
+            return `url('icons/${spelled.join('')}.png')`;
+        }
+        if (Array.isArray(node) && node[0] === 'image')
+            return build(node[1]);
+        if (Array.isArray(node) && node[0] === 'get' && typeof node[1] === 'string') {
+            // Named after the value itself - the global one-parameter-per-sprite table covers it,
+            // and the table is what gives `??` a miss to fall through on.
+            const all = ensureEverySprite();
+            for (const name of all.names)
+                options.styleParams.set(`${paramPrefix}${name}`, all.file.get(name));
+            aliasSprites(all.names, all.file, paramPrefix, options);
+            const field = `[param::${paramPrefix}[${node[1]}]]`;
+            if (glyphs || !plateWhen || node[1] !== scope.field)
+                return field;
+            // The features the params do NOT cover: their own artwork, from the raster table, and
+            // `shield-sdf` false for them (see plateWhen in shieldImageDeclarations).
+            const raster = extractAllIcons(sprites.sheets, sprites.outDir, options.flattenSdf);
+            for (const name of raster.names) {
+                options.styleParams.set(`${ICON_PARAM_PREFIX}${name}`, `icons/${name}.png`);
+            }
+            aliasSprites(raster.names, new Map(raster.names.map((n) => [n, `icons/${n}.png`])), ICON_PARAM_PREFIX, options);
+            return `(${plateWhen} ? ${field} : [param::${ICON_PARAM_PREFIX}[${node[1]}]])`;
+        }
+        if (Array.isArray(node) && node[0] === 'coalesce') {
+            const parts = node.slice(1).map((b) => build(b)).filter((x) => x !== null);
+            return parts.length ? parts.join(' ?? ') : null;
+        }
+        // match / case both become one table on one field, plus whatever their fallback is.
+        let field = null;
+        const branches = [];
+        let fallback = null;
+        if (Array.isArray(node) && node[0] === 'match' && node.length >= 5 && node.length % 2 === 1) {
+            const input = node[1];
+            if (!Array.isArray(input) || input[0] !== 'get' || typeof input[1] !== 'string')
+                return asTernary(node);
+            field = input[1];
+            for (let i = 2; i + 1 < node.length; i += 2) {
+                const raw = Array.isArray(node[i]) ? node[i] : [node[i]];
+                if (!raw.every((l) => typeof l === 'string' || typeof l === 'number'))
+                    return asTernary(node);
+                branches.push({ labels: raw.map(String), value: node[i + 1] });
+            }
+            fallback = node[node.length - 1];
+        }
+        else if (Array.isArray(node) && node[0] === 'case' && node.length >= 4 && node.length % 2 === 0) {
+            field = fieldOfCase(node[1]);
+            if (!field)
+                return asTernary(node);
+            for (let i = 1; i + 1 < node.length; i += 2) {
+                const labels = labelsOf(node[i], field);
+                if (!labels)
+                    return asTernary(node);
+                branches.push({ labels, value: node[i + 1] });
+            }
+            fallback = node[node.length - 1];
+        }
+        else {
+            return asTernary(node);
+        }
+        const table = `${slug}-t${tableIndex++}`;
+        let wrote = 0;
+        for (const { labels, value } of branches) {
+            for (const label of labels) {
+                notePlate(label);
+                const selfNamed = Array.isArray(value) && value[0] === 'get' && value[1] === field;
+                const name = selfNamed ? label : (typeof value === 'string' ? value : null);
+                if (name === null)
+                    continue;
+                const file = named(name);
+                if (!file)
+                    continue;
+                options.styleParams.set(`${table}-${label}`, file);
+                wrote++;
+            }
+        }
+        const rest = fallback === null ? null : build(fallback);
+        const tail = rest && rest !== `''` ? ` ?? ${rest}` : '';
+        if (wrote === 0)
+            return rest;
+        return `[param::${table}-[${field}]]${tail}`;
+    };
+    const expr = build(image);
+    // In font mode there is no sprite to measure: the glyph run is sized by the label.
+    if (glyphs)
+        return expr ? `(${expr})` : null;
+    if (!expr || !sample)
+        return null;
+    // One rule, one plate: the geometry is a declaration, not a per-feature lookup. The MEDIAN of
+    // what the layer's icons measure - Standard's POI sheet is one disc size and its transit sheet
+    // another, and each is a rule of its own, so the spread inside one is a rounding.
+    const median = (values) => values.slice().sort((a, b) => a - b)[values.length >> 1];
+    const plates = namedPlates.length > 0 ? namedPlates : sheetPlates;
+    if (plates.length > 0) {
+        sample = {
+            ...sample,
+            plateWhen: plateWhen ?? undefined,
+            plate: {
+                radius: median(plates.map((p) => p.radius)),
+                borderWidth: median(plates.map((p) => p.borderWidth)),
+                strokeWidth: median(plates.map((p) => p.strokeWidth)),
+            },
+        };
+    }
+    // The size the same way, and as the ARTWORK's - what a feature actually draws, and what the
+    // text has to clear.
+    const sizes = namedSizes.length > 0 ? namedSizes : sheetSizes;
+    if (sizes.length > 0) {
+        sample = {
+            ...sample,
+            width: median(sizes.map(([w]) => w)),
+            height: median(sizes.map(([, h]) => h)),
+            padding: 0,
+        };
+    }
+    options.iconSample = sample;
+    coverage.note(`"${layer.id}": icon named per feature, resolved through style parameters`);
+    return `(${expr})`;
+}
+/** A style parameter name is a bare identifier - a layer id is not. */
+/**
+ * A colour as a hex literal, or null when it is not one this understands.
+ *
+ * A style parameter carries a plain VALUE, and the SDK parses it back with parseColor - which does
+ * not take `hsl(...)`. Left as MapTiler writes them, every parameter failed to parse and took its
+ * whole rule down with it (the water in a probe style simply stopped drawing). Hex is the form that
+ * survives the round trip.
+ */
+function colourToHex(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    if (/^#[0-9a-fA-F]{6}$/.test(text))
+        return text.toLowerCase();
+    if (/^#[0-9a-fA-F]{3}$/.test(text)) {
+        return `#${text.slice(1).split('').map((c) => c + c).join('')}`.toLowerCase();
+    }
+    const hex = (r, g, b) => `#${[r, g, b].map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('')}`;
+    const rgb = text.match(/^rgba?\(([^)]+)\)$/i);
+    if (rgb) {
+        const parts = rgb[1].split(',').map((v) => parseFloat(v));
+        if (parts.length < 3 || parts.some((v) => Number.isNaN(v)))
+            return null;
+        if (parts.length > 3 && parts[3] !== 1)
+            return null; // alpha has no hex form parseColor takes
+        return hex(parts[0], parts[1], parts[2]);
+    }
+    const hsl = text.match(/^hsla?\(([^)]+)\)$/i);
+    if (hsl) {
+        const parts = hsl[1].split(',').map((v) => parseFloat(v));
+        if (parts.length < 3 || parts.some((v) => Number.isNaN(v)))
+            return null;
+        if (parts.length > 3 && parts[3] !== 1)
+            return null;
+        const [h, sPct, lPct] = parts;
+        const sat = sPct / 100, light = lPct / 100;
+        const c = (1 - Math.abs(2 * light - 1)) * sat;
+        const hp = (((h % 360) + 360) % 360) / 60;
+        const x = c * (1 - Math.abs((hp % 2) - 1));
+        const m = light - c / 2;
+        const [r, g, b] = hp < 1 ? [c, x, 0] : hp < 2 ? [x, c, 0] : hp < 3 ? [0, c, x]
+            : hp < 4 ? [0, x, c] : hp < 5 ? [x, 0, c] : [c, 0, x];
+        return hex((r + m) * 255, (g + m) * 255, (b + m) * 255);
+    }
+    return null;
+}
+/** Below this a nested ternary is smaller and easier to read than a table of parameters. */
+const MIN_PARAM_CASES = 8;
+/**
+ * A `match` over ONE field whose results are all constants, or null for any other shape.
+ *
+ * MapTiler keys a road shield's colour off `iso_a2` this way - 54 countries on `Highway shields`
+ * alone, and the same again for its halo. As a ternary that is the largest expression in the style
+ * and the decoder walks it per feature; as a style parameter per country it is one lookup.
+ */
+function constantMatchOnField(node) {
+    if (!Array.isArray(node) || node[0] !== 'match')
+        return null;
+    const input = node[1];
+    if (!(Array.isArray(input) && input[0] === 'get' && typeof input[1] === 'string'))
+        return null;
+    const cases = [];
+    for (let i = 2; i + 1 < node.length; i += 2) {
+        const raw = node[i];
+        const labels = Array.isArray(raw) ? raw : [raw];
+        if (!labels.every((l) => typeof l === 'string'))
+            return null;
+        const result = node[i + 1];
+        if (typeof result !== 'string' && typeof result !== 'number')
+            return null;
+        cases.push([labels, result]);
+    }
+    if (cases.length < MIN_PARAM_CASES)
+        return null;
+    return { field: input[1], cases, fallback: node[node.length - 1] };
+}
+/**
+ * Turns the single-field `match` in a property value into a style-parameter lookup, in place.
+ *
+ * The rewritten value carries a SENTINEL string where the match was, so the whole expression can go
+ * through the normal translation - conditions, nesting and all - and the lookup is substituted into
+ * the finished declaration afterwards. That keeps this out of every emitter's signature.
+ */
+function paramiseValues(layer, options, coverage) {
+    const subs = new Map();
+    const paint = { ...(layer.paint ?? {}) };
+    let changed = false;
+    for (const [property, value] of Object.entries(paint)) {
+        // The whole value, or the FALLBACK of a case whose own conditions read several fields -
+        // which is exactly how MapTiler writes it: a handful of network special cases over a long
+        // per-country table.
+        const whole = constantMatchOnField(value);
+        const isCase = Array.isArray(value) && value[0] === 'case' && value.length >= 4;
+        const tail = isCase ? constantMatchOnField(value[value.length - 1]) : null;
+        const found = whole ?? tail;
+        if (!found)
+            continue;
+        // Only when every result survives as hex - a value the SDK cannot parse back takes its
+        // whole rule down, so a table with one bad entry is not worth the trade.
+        const asHex = found.cases.map(([labels, result]) => [labels, typeof result === 'number' ? result : colourToHex(result)]);
+        if (asHex.some(([, result]) => result === null))
+            continue;
+        const prefix = `${safeParamName(layer.id)}-${safeParamName(property)}`;
+        for (const [labels, result] of asHex) {
+            for (const label of labels)
+                options.styleParams.set(`${prefix}-${label}`, result);
+        }
+        const fallback = tryTranslate(found.fallback, property, layer.id, coverage);
+        if (fallback === null)
+            continue;
+        const sentinel = `@@param${subs.size}@@`;
+        subs.set(`'${sentinel}'`, `([param::${prefix}-[${found.field}]] ?? ${fallback})`);
+        if (whole) {
+            paint[property] = sentinel;
+        }
+        else {
+            const rewritten = [...value];
+            rewritten[rewritten.length - 1] = sentinel;
+            paint[property] = rewritten;
+        }
+        changed = true;
+        coverage.approximate(`${property} on "${layer.id}" reads ${found.cases.length} cases of ` +
+            `[${found.field}] from style parameters instead of a nested ternary`);
+    }
+    return { layer: changed ? { ...layer, paint } : layer, subs };
+}
+function safeParamName(id) {
+    return id.replace(/[^A-Za-z0-9]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
+}
+/**
+ * A fill or line pattern: a sprite sliced out to its own file, like a marker's. MapBox may qualify
+ * the name with the sheet it lives in and CartoCSS wants a path, so the qualifier is dropped and
+ * the sprite written under its bare name - which is also where every other sheet's icons land.
+ */
+function patternDeclarations(name, value, target, layer, coverage, options) {
+    if (!target)
+        return [];
+    if (typeof value !== 'string') {
+        coverage.drop(name, 'a data-driven pattern names no one sprite', layer.id);
+        return [];
+    }
+    if (!options.sprites) {
+        coverage.drop(name, 'no sprite loaded (pass --sprite or let the style provide one)', layer.id);
+        return [];
+    }
+    const bare = value.includes(':') ? value.slice(value.indexOf(':') + 1) : value;
+    // Flattened: a pattern is painted as it stands, and there is no pattern-sdf to tint one with.
+    const icon = extractIcon(options.sprites.sheets, value, options.sprites.outDir, true, undefined, 1, bare);
+    if (!icon) {
+        coverage.drop(name, `"${value}" is not in the sprite`, layer.id);
+        return [];
+    }
+    coverage.emit(target);
+    return [`${target}: url('${icon.file}');`];
+}
+/**
+ * A shield's icon as a GLYPH of an icon font (--icon-font), instead of a sprite.
+ *
+ * `shield-icon-name` is the run ShieldSymbolizer shapes from `shield-icon-face-name` and draws
+ * BEFORE the text, on the anchor - the same place the bitmap would have gone, so everything else
+ * about the label is unchanged. The face is resolved as a fallback of the label font, which is what
+ * puts its glyphs in the label's own atlas.
+ *
+ * The face carries one glyph per icon NAME, so a name it has none for draws no icon: an artwork
+ * shield (an RER roundel, a country's motorway plate) has no font equivalent and is lost here. That
+ * is the trade the mode is for - one font against a sheet of several hundred PNGs.
+ */
+function fontShieldDeclarations(layer, image, coverage, options) {
+    const font = options.iconFont;
+    // A constant name is looked up outright; anything data-driven goes through the same parameter
+    // table the sprite lookup builds, holding characters instead of file paths.
+    const constant = typeof image === 'string' && !/\{[A-Za-z0-9_:-]+\}/.test(image);
+    const glyph = constant
+        ? (font.glyphs.has(image) ? `'${font.glyphs.get(image)}'` : null)
+        : iconExpression(image, layer, coverage, options);
+    if (glyph === null) {
+        coverage.drop('icon-image', constant
+            ? `"${image}" has no glyph in the "${font.face}" icon face`
+            : `no glyph name of the "${font.face}" icon face could be resolved from it`, layer.id);
+        return [];
+    }
+    const out = [`shield-icon-name: ${glyph};`, `shield-icon-face-name: '${font.face}';`];
+    coverage.emit('shield-icon-name');
+    coverage.emit('shield-icon-face-name');
+    // MapBox's icon-size SCALES a sprite; a glyph is sized in pixels. Given --icon-font-size, the
+    // glyph's height in sprite pixels, it scales the same way; otherwise as a multiple of the text size.
+    const sized = translateExpression(layer.layout?.['icon-size'] ?? 1);
+    if (font.size !== undefined) {
+        out.push(`shield-icon-size: ((${sized}) * ${font.size});`);
+        coverage.emit('shield-icon-size');
+    }
+    else {
+        const size = representativeScale(layer.layout?.['icon-size']);
+        if (size !== 1) {
+            out.push(`shield-icon-size: ${round(size * representativeScale(layer.layout?.['text-size'], DEFAULT_TEXT_SIZE))};`);
+            coverage.emit('shield-icon-size');
+        }
+    }
+    emitTranslated(out, coverage, layer, 'icon-color', 'shield-icon-fill', undefined, false);
+    emitTranslated(out, coverage, layer, 'icon-opacity', 'shield-icon-opacity', undefined, false);
+    emitTranslated(out, coverage, layer, 'icon-halo-color', 'shield-icon-halo-fill', undefined, false);
+    emitTranslated(out, coverage, layer, 'icon-halo-width', 'shield-icon-halo-radius', undefined, false);
+    // A recolourable badge keeps its disc: the plate measured off the sheet, as the sprite path does.
+    const plate = layer.layout?.[ICON_PARAMS] !== undefined ? fontPlateSample(options) : null;
+    if (plate)
+        out.push(...iconPlateDeclarations(layer, plate, sized, coverage, options));
+    out.push(...variableAnchorDeclarations(layer, coverage, options));
+    return out;
+}
+const fontPlates = new WeakMap();
+/** The first badge of the sheet that splits into a disc and a glyph, measured once per conversion. */
+function fontPlateSample(options) {
+    if (!options.sprites || !options.iconFont)
+        return null;
+    if (!fontPlates.has(options)) {
+        let found = null;
+        for (const name of options.iconFont.glyphs.keys()) {
+            const icon = extractIconPlate(options.sprites.sheets, name, options.sprites.outDir);
+            if (icon?.plate) {
+                found = icon;
+                break;
+            }
+        }
+        fontPlates.set(options, found);
+    }
+    return fontPlates.get(options);
+}
+/** MapBox's icon-* onto marker-*, once the sprite has been sliced into its own file. */
+function markerDeclarations(layer, coverage, options) {
+    const image = layer.layout?.['icon-image'];
+    if (image === undefined)
+        return [];
+    // --icon-font replaces a shield's ARTWORK with a glyph, and needs no sheet at all. Only a
+    // shield: an icon-only layer is a marker (a oneway arrow, a crossing), which has no glyph run.
+    if (options.iconFont && layer.layout?.['text-field'] !== undefined) {
+        return fontShieldDeclarations(layer, image, coverage, options);
+    }
+    if (!options.sprites) {
+        coverage.drop('icon-image', 'no sprite loaded (pass --sprite or let the style provide one)', layer.id);
+        return [];
+    }
+    // MapTiler names a POI's icon from the feature. The SDK resolves shield-file per feature and
+    // mapnik interpolates [field] inside a string, so the whole sheet is written out and the field
+    // goes in the file name - see dynamicIconField.
+    // A legacy token name (`road_{ref_length}`) is data-driven too, even though it is a string.
+    if (typeof image !== 'string' || /\{[A-Za-z0-9_:-]+\}/.test(image)) {
+        const expr = iconExpression(image, layer, coverage, options);
+        if (expr && options.iconSample) {
+            const scale = layer.layout?.['text-field'] !== undefined
+                ? representativeScale(layer.layout?.['icon-size']) : 1;
+            return shieldImageDeclarations(layer, { ...options.iconSample, file: `@@EXPR@@${expr}` }, scale, coverage, options);
+        }
+    }
+    if (typeof image !== 'string') {
+        coverage.drop('icon-image', 'data-driven icon name', layer.id);
+        return [];
+    }
+    // With text beside it the icon becomes a SHIELD - one label, no collision with its own name.
+    // ShieldSymbolizer has no `sdf`, so the field is resolved and the style's icon-color baked in.
+    const asShield = layer.layout?.['text-field'] !== undefined;
+    // A shield is SHIPPED at the sprite's own resolution and shrunk by shield-image-scale. Baking
+    // icon-size into the bitmap instead resampled the distance field into fewer texels than it
+    // needs, so the smaller the icon the blockier and softer it drew.
+    const scale = asShield ? representativeScale(layer.layout?.['icon-size']) : 1;
+    const icon = extractIcon(options.sprites.sheets, image, options.sprites.outDir, options.flattenSdf, undefined, 1);
+    if (!icon) {
+        coverage.drop('icon-image', `"${image}" is not in the sprite`, layer.id);
+        return [];
+    }
+    if (asShield)
+        return shieldImageDeclarations(layer, icon, scale, coverage, options);
+    const out = [
+        `marker-file: url('${icon.file}');`,
+        `marker-placement: '${resolvePlacement(layer, 'icon')}';`,
+    ];
+    coverage.emit('marker-file');
+    coverage.emit('marker-placement');
+    // `symbol-spacing` reaches an icon-only layer nowhere else: the table maps it to text-spacing,
+    // and a layer with no text-field drops every text-* declaration it built. MarkersSymbolizer's
+    // own default is 100 against MapBox's 250, so every oneway arrow was drawn two and a half times
+    // too often. One tile unit is one CSS pixel at the tile's own zoom, so the number carries over
+    // unscaled - the same reason text-spacing takes it raw.
+    if (repeatsAlongLine(layer)) {
+        const spacing = layer.layout?.['symbol-spacing'];
+        if (spacing !== undefined && typeof spacing !== 'number') {
+            coverage.approximate(`symbol-spacing on "${layer.id}" read at one stop: ` +
+                'marker-spacing is a static property, not a ramp');
+        }
+        out.push(`marker-spacing: ${round(representativeScale(spacing, DEFAULT_SYMBOL_SPACING))};`);
+        coverage.emit('marker-spacing');
+    }
+    const sdf = icon.sdf && !options.flattenSdf;
+    if (sdf) {
+        out.push('marker-sdf: true;');
+        coverage.emit('marker-sdf');
+    }
+    // icon-size scales the sprite's own size. `marker-width` is read at DECODE (it sizes the
+    // raster), so a zoom-driven size is evaluated per tile zoom rather than per frame - which is
+    // how a raster marker has to behave anyway, and is why it is carried here for a plain sprite
+    // too. Dropping it left the marker at its native size: Standard draws a crosswalk at
+    // icon-size 0.2 from a 61 px sprite, so every crossing came out five times too big.
+    const size = layer.layout?.['icon-size'];
+    const sizeExpr = size === undefined
+        ? String(round(icon.width))
+        : scaledSize(size, icon.width, name('icon-size', layer, coverage));
+    out.push(`marker-width: ${sizeExpr};`);
+    coverage.emit('marker-width');
+    // An SDF icon carries no colour of its own, so marker-color IS the icon colour and MapBox
+    // defaults it to black. A plain sprite already has its colours and must not be tinted.
+    if (icon.sdf) {
+        emitTranslated(out, coverage, layer, 'icon-color', 'marker-color', '#000000', !sdf);
+    }
+    emitTranslated(out, coverage, layer, 'icon-opacity', 'marker-opacity', undefined, !sdf);
+    // Halos are grown from the field, so they only exist in SDF mode. The halo carries its own
+    // opacity, so icon-opacity has to reach it too or a faded-out icon keeps a solid outline.
+    if (sdf) {
+        emitTranslated(out, coverage, layer, 'icon-halo-color', 'marker-halo-fill', undefined, false);
+        emitTranslated(out, coverage, layer, 'icon-halo-width', 'marker-halo-radius', undefined, false);
+        emitTranslated(out, coverage, layer, 'icon-opacity', 'marker-halo-opacity', undefined, false);
+    }
+    const overlap = layer.layout?.['icon-overlap'];
+    if (layer.layout?.['icon-allow-overlap'] === true || overlap !== undefined) {
+        out.push(`marker-allow-overlap: ${layer.layout?.['icon-allow-overlap'] === true || overlap === 'always'};`);
+        coverage.emit('marker-allow-overlap');
+        // `marker-clip` defaults to allow-overlap in MarkersSymbolizer, and a clipped marker is
+        // tile GEOMETRY, stencil-masked to its tile: a oneway arrow sitting on a tile edge lost the
+        // half that overhangs. A MapBox symbol is a label whatever its collision setting.
+        out.push('marker-clip: false;');
+        coverage.emit('marker-clip');
+    }
+    out.push(...markerRotation(layer, coverage));
+    return out;
+}
+/**
+ * A tree, drawn as its canopy.
+ *
+ * Standard draws the `tree` source-layer as 3D models from z15 and there is nothing to port; a
+ * filled dot in the greenspace colour is what is left, and it is what the parks were missing.
+ *
+ * The size is a GROUND size, a crown about 3 m across, so the dots keep their spacing as the
+ * map zooms: base-2 between two stops five levels apart is exactly the doubling curve. The SDK's
+ * zoom counts 256 unscaled-DPI units per tile, so one unit at mapbox z15 is 17.8 m and the two
+ * stops follow from that. `marker-width` is a width, so these are diameters. A real crown is
+ * wider, but a flat disc reads heavier than the textured canopy MapBox draws and 8 m of it
+ * filled the parks in.
+ *
+ * The outline is the canopy colour darkened by 18 points of lightness, which is what separates one
+ * tree from the next where they touch; a marker's own default line is near-black and drew every
+ * tree as an outlined ring instead.
+ *
+ * `allow-overlap` with `clip` ON is deliberate and the one place the two are not emitted together
+ * (see markerDeclarations): a tile carries hundreds of trees, and pushing those through the label
+ * culler would cost far more than the half-tree an occasional tile edge cuts.
+ */
+function canopyDeclarations(layer, coverage) {
+    const out = [
+        'marker-width: exponential(2, ([view::zoom] - 1), (15, 2), (20, 24));',
+        'marker-allow-overlap: true;',
+        'marker-clip: true;',
+    ];
+    coverage.emit('marker-width');
+    coverage.emit('marker-allow-overlap');
+    coverage.emit('marker-clip');
+    const color = layer.paint?.['model-color'];
+    const translated = color === undefined ? null : tryTranslate(color, 'model-color', layer.id, coverage);
+    if (translated === null) {
+        out.push('marker-line-width: 0;');
+    }
+    else {
+        out.push(`marker-line-color: darken(${translated}, 0.18);`, 'marker-line-width: 1;');
+        coverage.emit('marker-line-color');
+    }
+    coverage.emit('marker-line-width');
+    return out;
+}
+/**
+ * `icon-rotate`, which turns a marker on the MAP.
+ *
+ * A rotation is a `marker-transform`, and its angle is an expression, so it is read per feature -
+ * which is what Standard's crosswalks need: they are points carrying a `direction` in degrees, and
+ * unrotated every one of them drew its stripes across the same axis whatever way its street ran.
+ *
+ * MarkersSymbolizer switches a marker with a rotation to the POINT orientation, so it lies flat and
+ * turns with the map. That is `icon-rotation-alignment: map` and nothing else, so a layer that
+ * rotates against the VIEWPORT is reported rather than silently laid down - the SDK has no
+ * screen-space rotation for a billboard.
+ */
+function markerRotation(layer, coverage) {
+    const rotate = layer.layout?.['icon-rotate'];
+    if (rotate === undefined || rotate === 0)
+        return [];
+    if (layer.layout?.['icon-rotation-alignment'] !== 'map') {
+        coverage.drop('icon-rotate', 'the SDK turns a marker on the map, not against the viewport, ' +
+            'and this layer does not state icon-rotation-alignment: map', layer.id);
+        return [];
+    }
+    const translated = tryTranslate(rotate, 'icon-rotate', layer.id, coverage);
+    if (translated === null)
+        return [];
+    coverage.emit('marker-transform');
+    // No sign flip. MapBox's icon-rotate turns clockwise from north, and `rotate()` is applied in
+    // the tile's own frame, where y grows DOWNWARD - so a positive angle about +z already reads
+    // clockwise on screen. Negated, every crossing sat at twice its own angle off its street.
+    return [`marker-transform: rotate(${translated});`];
+}
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+/**
+ * What decides which of two colliding labels survives.
+ *
+ * MapBox's `symbol-sort-key` orders symbols only WITHIN a layer - between layers the style's own
+ * order decides, later winning. The culler here compares one priority across every layer at once
+ * and only falls back to the layer index, so a village with `rank 1` (priority -1) beat a town with
+ * `rank 12` (-12) whatever layer each came from: Annecy's neighbours were drawn and Rumilly was not.
+ *
+ * Folding the layer's position in as the leading term restores MapBox's meaning - the sort key
+ * still separates labels inside a layer, and it can no longer reach across one. The stride only has
+ * to exceed the range a sort key spans (MapTiler's widest is the capital's -1000).
+ */
+const LAYER_PRIORITY_STRIDE = 100000;
+function placementPriority(layer, layerIndex, coverage) {
+    const base = layerIndex * LAYER_PRIORITY_STRIDE;
+    const sortKey = layer.layout?.['symbol-sort-key'];
+    if (sortKey === undefined)
+        return String(base);
+    const translated = tryTranslate(sortKey, 'symbol-sort-key', layer.id, coverage);
+    // MapBox places the LOWEST key first, and the culler takes the highest priority.
+    return translated === null ? String(base) : `(${base} - ${translated})`;
+}
+/**
+ * What one unit of MapBox's text-padding is worth as a collision padding: one for one, since both
+ * grow the box on every side. --label-spacing scales it for a map that wants thinning beyond what
+ * the style asks for.
+ */
+function collisionPad(options) {
+    return options.labelSpacing ?? 1;
+}
+/** MapBox defaults for a layer that never states them. */
+const DEFAULT_TEXT_SIZE = 16;
+const DEFAULT_TEXT_MAX_WIDTH = 10;
+const DEFAULT_TEXT_PADDING = 2;
+const DEFAULT_SYMBOL_SPACING = 250;
+/**
+ * Width of the line that stands in for `fill-outline-color`. MapBox draws that outline with
+ * `gl.LINES`, so it is one DEVICE pixel whatever the display; a CartoCSS width is multiplied by the
+ * pixel scale, so `1` came out ~3 px on a 2.75x phone and small buildings were solid outline
+ * (measured at La Clusaz z14.5: 7456 outline pixels against 1747 of fill). This reads as a hairline
+ * from 2x up, which is every phone.
+ */
+const FILL_OUTLINE_WIDTH = 0.4;
+/** One style parameter per sprite name, so a per-feature lookup can fall through when it misses. */
+const ICON_PARAM_PREFIX = 'icon-';
+/** The glyph FIELD of a recolourable icon, a different file under the same name. */
+const GLYPH_PARAM_PREFIX = 'glyph-';
+/** A value in ems of the layer's own text-size, as the pixels CartoCSS wants. */
+function ems(value, layer, coverage, from) {
+    const size = layer.layout?.['text-size'] ?? DEFAULT_TEXT_SIZE;
+    if (typeof value === 'number' && typeof size === 'number')
+        return String(round(value * size));
+    const valueExpr = typeof value === 'number' ? String(round(value)) : tryTranslate(value, from, layer.id, coverage);
+    const sizeExpr = typeof size === 'number' ? String(size) : tryTranslate(size, 'text-size', layer.id, coverage);
+    return valueExpr === null || sizeExpr === null ? null : `(${valueExpr} * ${sizeExpr})`;
+}
+/** icon-size is a multiplier on the sprite's own width. */
+function scaledSize(size, width, translated) {
+    if (typeof size === 'number')
+        return String(round(width * size));
+    return translated === null ? String(round(width)) : `(${translated} * ${round(width)})`;
+}
+/** Translates a MapBox paint/layout value onto a CartoCSS property, or reports why it could not. */
+function emitTranslated(out, coverage, layer, from, to, fallback, constantOnly) {
+    const value = layer.paint?.[from] ?? layer.layout?.[from];
+    if (value === undefined) {
+        if (fallback !== undefined) {
+            out.push(`${to}: ${fallback};`);
+            coverage.emit(to);
+        }
+        return;
+    }
+    if (constantOnly && typeof value !== 'string' && typeof value !== 'number') {
+        coverage.drop(from, `a flattened bitmap needs a constant ${from}`, layer.id);
+        return;
+    }
+    const translated = name(from, layer, coverage);
+    if (translated !== null) {
+        out.push(`${to}: ${translated};`);
+        coverage.emit(to);
+    }
+}
+/** The translated form of a layer property, counting the drop itself when it has none. */
+/**
+ * A `match` on ONE field whose branches are all constants, written as a style-parameter LOOKUP keyed
+ * by that field - `[param::poi-fill-bus]`, one parameter per label - instead of the ternary chain
+ * the decoder would otherwise walk per feature.
+ *
+ * Two things come with it. A category palette becomes EDITABLE in project.json without touching the
+ * generated stylesheet, which is where a style's colours want to live; and sixty string comparisons
+ * per POI become one lookup. The fallback stays in the rule, so a class the table does not name
+ * still draws - `??` is what a parameter miss falls through on, as the icon table already relies on.
+ *
+ * OPT-IN, per property, through the style's own metadata:
+ *
+ *     "metadata": { "massif:params": ["text-color"] }
+ *
+ * which keeps the layer a valid MapLibre style (metadata is ignored by every renderer) and leaves
+ * every other converted style byte-identical. A table is worth it for a palette the author means to
+ * tune and not for the two-branch colour ramp on a road, and only the author knows which is which.
+ */
+function fieldParamTable(value, layer, property, target, coverage, options, suffix = '') {
+    if (!options.styleParams || !Array.isArray(value))
+        return null;
+    const asked = layer.metadata?.['massif:params'];
+    if (!Array.isArray(asked) || !asked.includes(property))
+        return null;
+    // A day/night pair of tables: `measure-light` over one table per stop, so a palette that follows
+    // the hour is still a lookup per feature rather than the ternary chain it would otherwise become.
+    const input = value[2];
+    if (value[0] === 'interpolate' && Array.isArray(input) && input[0] === 'measure-light' && input[1] === 'brightness') {
+        const stops = [];
+        for (let i = 3; i + 1 < value.length; i += 2) {
+            const last = i + 2 >= value.length;
+            const table = foldOrConstant(value[i + 1], layer, property, target, coverage, options, last ? suffix : `${suffix}-b${Math.round(Number(value[i]) * 100)}`);
+            if (table === null)
+                return null;
+            stops.push(`(${round(Number(value[i]))}, ${table})`);
+        }
+        return `linear([view::brightness], ${stops.join(', ')})`;
+    }
+    if (value[0] !== 'match')
+        return null;
+    // A palette per VARIANT: a match on a live config whose every branch folds becomes one set of
+    // tables per branch, picked by a parameter test - a per-draw comparison, then one lookup.
+    const on = value[1];
+    if (Array.isArray(on) && on[0] === 'config' && typeof on[1] === 'string' && value.length % 2 === 1) {
+        const branches = [];
+        for (let i = 2; i + 1 < value.length; i += 2) {
+            const labels = (Array.isArray(value[i]) ? value[i] : [value[i]]);
+            if (!labels.every((l) => typeof l === 'string' && /^[A-Za-z0-9_]+$/.test(l)))
+                return null;
+            const table = foldOrConstant(value[i + 1], layer, property, target, coverage, options, `${suffix}-${labels[0]}`);
+            if (table === null)
+                return null;
+            const test = labels.map((l) => `[param::${on[1]}] = '${l}'`).join(' || ');
+            branches.push(`(${test}) ? ${table}`);
+        }
+        const rest = foldOrConstant(value[value.length - 1], layer, property, target, coverage, options, suffix);
+        if (rest === null)
+            return null;
+        return `(${branches.join(' : ')} : ${rest})`;
+    }
+    if (value.length < 5 || value.length % 2 === 0)
+        return null;
+    const key = value[1];
+    if (!Array.isArray(key) || key[0] !== 'get' || typeof key[1] !== 'string')
+        return null;
+    const field = key[1];
+    const entries = [];
+    for (let i = 2; i + 1 < value.length; i += 2) {
+        const labels = Array.isArray(value[i]) ? value[i] : [value[i]];
+        const branch = value[i + 1];
+        if (typeof branch !== 'string' && typeof branch !== 'number')
+            return null;
+        for (const label of labels) {
+            if (typeof label !== 'string' || !/^[A-Za-z0-9_]+$/.test(label))
+                return null;
+            entries.push([label, branch]);
+        }
+    }
+    const rest = value[value.length - 1];
+    if (typeof rest !== 'string' && typeof rest !== 'number')
+        return null;
+    const fallback = tryTranslate(rest, property, layer.id, coverage);
+    if (fallback === null)
+        return null;
+    const slug = `${layer['source-layer'] ?? safeParamName(layer.id)}-${target.replace(/^(text|shield|marker)-/, '')}${suffix}`;
+    for (const [label, branch] of entries)
+        options.styleParams.set(`${slug}-${label}`, paramValue(branch));
+    coverage.note(`"${layer.id}": ${property} is a ${entries.length}-entry table in project.json ` +
+        `(${slug}-*), read per feature by [${field}]`);
+    return `(([param::${slug}-[${field}]]) ?? ${fallback})`;
+}
+/** A branch of a variant or brightness split: a table where it folds, a plain value where it is one. */
+function foldOrConstant(value, layer, property, target, coverage, options, suffix) {
+    if (typeof value === 'string' || typeof value === 'number')
+        return tryTranslate(value, property, layer.id, coverage);
+    return fieldParamTable(value, layer, property, target, coverage, options, suffix);
+}
+/**
+ * A parameter value as the DECODER will read it. A colour goes in as hex: a style parameter is a
+ * plain string that `parseColor` has to read at runtime, and its grammar knows `#rrggbb`, `rgb()`
+ * and the CSS names but NOT `hsl()` - which the CartoCSS compiler does know, so an hsl() literal in
+ * a rule is fine and the same literal in a parameter silently lost every POI its colour.
+ */
+function paramValue(branch) {
+    if (typeof branch !== 'string')
+        return branch;
+    const hsla = toHsla(branch);
+    if (!hsla)
+        return branch;
+    const [h, s, l, a] = hsla;
+    if (a < 1)
+        return branch; // an alpha has no hex spelling here; rgba() parses, so leave it
+    const c = (1 - Math.abs(2 * l / 100 - 1)) * (s / 100);
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = l / 100 - c / 2;
+    const [r, g, b] = h < 60 ? [c, x, 0] : h < 120 ? [x, c, 0] : h < 180 ? [0, c, x]
+        : h < 240 ? [0, x, c] : h < 300 ? [x, 0, c] : [c, 0, x];
+    const hex = (v) => Math.round((v + m) * 255).toString(16).padStart(2, '0');
+    return `#${hex(r)}${hex(g)}${hex(b)}`;
+}
+function name(property, layer, coverage) {
+    const value = layer.paint?.[property] ?? layer.layout?.[property];
+    if (value === undefined)
+        return null;
+    return tryTranslate(value, property, layer.id, coverage);
+}
+/** Second chance for a value one of whose branches has no CartoCSS form: keep the fallback branch. */
+function retryCollapsed(value, layer, coverage) {
+    const collapsed = collapseBranches(value);
+    if (JSON.stringify(collapsed) === JSON.stringify(value))
+        return null;
+    const translated = tryTranslate(collapsed, 'text-field', layer.id, coverage);
+    if (translated !== null) {
+        coverage.approximate(`text-field on "${layer.id}" kept only its fallback branch: another ` +
+            'branch has no CartoCSS form, and no label at all is worse than the common one');
+    }
+    return translated;
+}
+/**
+ * text-font is a LIST of faces in preference order and CartoCSS takes one name. A `match` over the
+ * feature wraps each list in `["literal", [...]]`, and after the split collapses that branch the
+ * value is the literal itself - reading element 0 then emitted the face name `literal`, which
+ * resolves to nothing and drew eight layers in the fallback font.
+ */
+function firstFontName(value) {
+    if (Array.isArray(value) && value[0] === 'literal' && Array.isArray(value[1])) {
+        return firstFontName(value[1]);
+    }
+    return Array.isArray(value) && typeof value[0] === 'string' ? value[0] : undefined;
+}
+function tryTranslate(value, name, layerId, coverage) {
+    const notes = [];
+    try {
+        const fontList = name === 'text-font' ? firstFontName(value) : undefined;
+        const translated = fontList !== undefined
+            ? translateExpression(fontList, notes)
+            : translateExpression(value, notes);
+        notes.forEach((note) => coverage.approximate(note));
+        return translated;
+    }
+    catch (error) {
+        coverage.drop(name, describe(error), layerId);
+        return null;
+    }
+}
+function remapValue(target, translated) {
+    // The two disagree on which side is positive: mapbox offsets a line to the RIGHT of its
+    // direction of travel, mapnik to the LEFT. Left as-is, a cycleway drawn beside its road lands
+    // on the wrong side of it. CartoCSS has no unary minus before a parenthesised value, hence
+    // `0 - x` rather than `-x`.
+    if (target === 'line-offset')
+        return `(0 - (${translated}))`;
+    const map = VALUE_MAP[target];
+    if (!map)
+        return translated;
+    const bare = translated.replace(/^'|'$/g, '');
+    return map[bare] !== undefined ? `'${map[bare]}'` : translated;
+}
+/**
+ * A CartoCSS project is ONE datasource; a MapBox style may draw from several tilesets and says so
+ * per layer. Flattened into one project the difference disappears, and every source-layer that came
+ * from another tileset silently draws nothing - which is what hid MapTiler topo-v4's peaks, since
+ * `peak` and `volcano` live in its `landform` source and not in the planet tiles the rest uses.
+ *
+ * There is nothing to translate here: the app has to point a layer, or a composite slot, at each
+ * tileset. Naming them is what turns "the peaks are missing" into a wiring question.
+ */
+function reportSources(style, layers, coverage) {
+    const bySource = new Map();
+    for (const layer of layers) {
+        const source = layer.source;
+        const sourceLayer = layer['source-layer'];
+        if (!source || !sourceLayer)
+            continue;
+        if (!bySource.has(source))
+            bySource.set(source, new Set());
+        bySource.get(source).add(sourceLayer);
+    }
+    if (bySource.size < 2)
+        return;
+    const urlOf = (name) => {
+        const source = style.sources?.[name];
+        return source?.url ?? source?.tiles?.[0] ?? '';
+    };
+    const biggest = [...bySource.entries()].sort((a, b) => b[1].size - a[1].size)[0][0];
+    const others = [...bySource.entries()]
+        .filter(([name]) => name !== biggest)
+        .map(([name, set]) => `  "${name}" (${[...set].sort().join(', ')})${urlOf(name) ? ` <- ${urlOf(name)}` : ''}`);
+    coverage.note(`the style draws from ${bySource.size} tilesets and a CartoCSS project has one. "${biggest}" ` +
+        'is the biggest and is what the project assumes; every layer below needs its own datasource ' +
+        'or composite slot in the app, or it draws nothing:\n' + others.join('\n'));
+}
+/**
+ * The project's `layers`, in MapBox's own draw order.
+ *
+ * A bare entry pulls EVERY attachment of that source-layer, so a layer MapBox interleaves with
+ * another cannot be placed by one entry: Standard draws its pedestrian areas at index 3, its parks
+ * at 4 and its road casings at 60, all on two source-layers, and any single depth for `road` puts
+ * the pedestrian slab either over the park or under the casings.
+ *
+ * An entry may name ONE attachment (`road::pedestrian_polygon`), so a source-layer that MapBox
+ * splits is emitted once per RUN of consecutive attachments. A layer that forms one run keeps its
+ * bare entry, which is every layer of a style that interleaves nothing.
+ */
+export function projectEntries(drawOrder) {
+    const sorted = drawOrder.map((entry, at) => ({ entry, at }))
+        .sort((a, b) => a.entry.index - b.entry.index || a.at - b.at)
+        .map((item) => item.entry);
+    const runs = [];
+    for (const { sourceLayer, attachment } of sorted) {
+        const last = runs[runs.length - 1];
+        if (last && last.sourceLayer === sourceLayer)
+            last.attachments.push(attachment);
+        else
+            runs.push({ sourceLayer, attachments: [attachment] });
+    }
+    const split = new Set(runs.map((run) => run.sourceLayer)
+        .filter((name, at, all) => all.indexOf(name) !== at));
+    return runs.flatMap((run) => (split.has(run.sourceLayer)
+        ? run.attachments.map((attachment) => `${run.sourceLayer}::${attachment}`)
+        : [run.sourceLayer]));
+}
+/** What the split above cost, so a project that grew entries says why. */
+function reportSplitLayers(drawOrder, coverage) {
+    const entries = projectEntries(drawOrder);
+    const split = new Set(entries.filter((entry) => entry.includes('::')).map((entry) => entry.split('::')[0]));
+    if (split.size > 0) {
+        coverage.note(`${split.size} source-layer(s) are drawn at more than one depth, because MapBox ` +
+            'interleaves them with another: ' + [...split].sort().join(', ') + '. Each is one ' +
+            'project entry per run of attachments, which is what keeps its draw order.');
+    }
+}
+function describe(error) {
+    return error instanceof Untranslatable ? `untranslatable: ${error.what}` : String(error);
+}
+//# sourceMappingURL=index.js.map