@massif-maps/style-tools 6.1.1 → 6.1.3-dev.142

package/dist/mapbox2css/index.js

@@ -6,10 +6,10 @@ 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 { describeFlatPlate, extractAllIconPlates, extractAllIcons, extractIcon, extractIconPlate, hasIcon } 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 { BAND_MAXZOOM, BAND_MINZOOM, 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';
@@ -227,7 +227,9 @@ export function convert(style, table, options = {}) {
             continue;
         }
         configValues.delete(name);
-        options.styleParams.set(name, spec.values ? { default: spec.default, values: spec.values } : spec.default);
+        // a bare object or array would read as a declaration or an enum, so a table keeps its `default`
+        const table = typeof spec.default === 'object' && spec.default !== null;
+        options.styleParams.set(name, spec.values || table ? { default: spec.default, ...(spec.values ? { values: spec.values } : {}) } : spec.default);
         coverage.note(`config "${name}" stays a style parameter, settable on a running map`);
     }
     if (configValues.size > 0) {
@@ -388,18 +390,21 @@ export function convert(style, table, options = {}) {
                     : 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);
+                // An attachment per sort key, lowest first - the only split that has to ORDER its parts.
+                // The rest have exclusive filters, so they are rules of that one attachment: an
+                // attachment walks the whole source layer per tile, and its features keep the tile's
+                // order, as MapBox draws one layer.
+                const ordered = expandSortKey(isContourLayer(layer) ? retargeted : schemaLayer, coverage);
                 // `massif:attachment`: layers drawing into ONE attachment, so a child project's rule on it
                 // merges with whichever of them matches instead of drawing the feature a second time.
                 const sharedAttachment = layer.metadata?.['massif:attachment'];
-                variants.forEach((variant, branch) => {
-                    const suffix = variants.length > 1 ? `_b${branch + 1}` : '';
+                ordered.forEach((sortKeyed, branch) => {
+                    const suffix = ordered.length > 1 ? `_b${branch + 1}` : '';
                     const attachment = typeof sharedAttachment === 'string' ? attachmentName(sharedAttachment) : `${attachmentName(layer.id)}${suffix}`;
-                    emitLayer(variant, attachment, target, symbolizer, index);
+                    expandSetFilter(sortKeyed)
+                        .flatMap((variant) => splitLayer(variant, coverage))
+                        .map((variant) => narrowLayer(bandDashByZoom(variant, coverage)))
+                        .forEach((variant) => emitLayer(variant, attachment, target, symbolizer, index));
                 });
             }
         });
@@ -554,9 +559,13 @@ export function convert(style, table, options = {}) {
                     declarations.push(`${property}: ${value};`);
             }
             const range = Array.isArray(sdk.visibleZoomRange) ? sdk.visibleZoomRange : [];
+            // `massif:maxzoom-param`: the slot ends where an app says, past the standalone layer's visibleZoomRange
+            const maxParam = layer.metadata?.['massif:maxzoom-param'];
+            const hasMaxParam = typeof maxParam === 'string' && zoomOffsetLevels() === 0;
             let selector;
             try {
-                selector = `#${layer.id}${[...zoomPredicates(range[0] || layer.minzoom, range[1] ?? layer.maxzoom),
+                selector = `#${layer.id}${[...(hasMaxParam ? [`[zoom < 'param::${maxParam}']`] : []),
+                    ...zoomPredicates(range[0] || layer.minzoom, hasMaxParam ? undefined : range[1] ?? layer.maxzoom),
                     ...translateFilter(layer.filter ?? null)].join('')}`;
             }
             catch (error) {
@@ -626,15 +635,18 @@ export function convert(style, table, options = {}) {
                 // when the style compiles - a child project overrides it in its `constants`, at no runtime cost.
                 const minConst = layer.metadata?.['massif:minzoom-const'];
                 const maxConst = layer.metadata?.['massif:maxzoom-const'];
-                if (typeof minConst === 'string' && typeof layer.minzoom === 'number')
+                // a zoom band of a split layer (splitIconByZoom) tests its own edge beside the constant
+                const bandMin = layer.metadata?.[BAND_MINZOOM];
+                const bandMax = layer.metadata?.[BAND_MAXZOOM];
+                if (typeof minConst === 'string' && typeof layer.minzoom === 'number' && bandMin === undefined)
                     constants.set(minConst, Math.floor(layer.minzoom) + zoomOffsetLevels());
-                if (typeof maxConst === 'string' && typeof layer.maxzoom === 'number')
+                if (typeof maxConst === 'string' && typeof layer.maxzoom === 'number' && bandMax === undefined)
                     constants.set(maxConst, Math.ceil(layer.maxzoom) + zoomOffsetLevels());
                 const predicates = [
                     ...(hasParam ? [`[zoom >= 'param::${minParam}']`] : []),
                     ...(typeof minConst === 'string' ? [`[zoom >= $${minConst}]`] : []),
                     ...(typeof maxConst === 'string' ? [`[zoom < $${maxConst}]`] : []),
-                    ...zoomPredicates(paramStart || typeof minConst === 'string' ? undefined : layer.minzoom, typeof maxConst === 'string' ? undefined : layer.maxzoom),
+                    ...zoomPredicates(paramStart || (typeof minConst === 'string' && bandMin === undefined) ? undefined : layer.minzoom, typeof maxConst === 'string' && bandMax === undefined ? undefined : layer.maxzoom),
                     ...(buildings ? [buildings] : []),
                     ...translateFilter(filter),
                 ].map((p) => (p.startsWith('when(') ? ` ${p}` : p));
@@ -735,6 +747,16 @@ export function convert(style, table, options = {}) {
     options.styleParams.clear();
     for (const [name, value] of presetParams.get('') ?? [])
         options.styleParams.set(name, value);
+    // `massif:attachment` names an attachment a child project's rules join, so it keeps its name
+    const sharedAttachments = new Set((style.layers ?? [])
+        .map((layer) => layer.metadata?.['massif:attachment'])
+        .filter((name) => typeof name === 'string').map(attachmentName));
+    const merged = mergeIdenticalPaint(blocks, drawOrder, [...alternates.values()].map((result) => result.blocks), sharedAttachments);
+    if (merged > 0) {
+        coverage.note(`${merged} attachment(s) joined the one drawn just before them: same source-layer, ` +
+            'and every rule of both paints the same opaque lines or fills in every preset, so their ' +
+            'order cannot show and one pass over the layer draws both');
+    }
     let hoisted = withMap(base);
     let palette = [];
     const presetPalettes = new Map();
@@ -836,7 +858,7 @@ export function convert(style, table, options = {}) {
     for (const [preset, params] of presetParams) {
         if (preset === '')
             continue;
-        const differing = [...params].filter(([name, value]) => shared.get(name) !== value);
+        const differing = [...params].filter(([name, value]) => JSON.stringify(shared.get(name)) !== JSON.stringify(value));
         if (differing.length > 0)
             presetOverrides.set(preset, Object.fromEntries(differing.sort()));
     }
@@ -1522,29 +1544,40 @@ function layerDeclarations(layer, symbolizer, allowed, coverage, options, layerI
                 continue;
             }
             const zoom = dash.zoom;
-            const pattern = (layer.dashZoom === undefined ? null : dashPatternAt(value, layer.dashZoom)) ?? dash.pattern;
+            const width = dashWidth(layer.paint?.['line-width']);
             // `[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)) {
+            const gaps = (pattern) => pattern.some((v, i) => i % 2 === 1 && v > 0);
+            if (layer.dashBands !== undefined) {
+                // A banded dash reads the width in the middle of its OWN band; see bandDashByZoom.
+                const frames = layer.dashBands.map(({ from, dashZoom }) => {
+                    const pattern = dashPatternAt(value, dashZoom) ?? dash.pattern;
+                    const scale = rampAt(width, dashZoom) ?? (zoom === null ? null : rampAt(width, zoom))
+                        ?? representativeScale(width, 1);
+                    const pixels = gaps(pattern) ? pixelDashes(pattern.map((v) => v * scale)).map(round).join(',') : '';
+                    return `(${Math.floor(from) + zoomOffsetLevels()}, '${pixels}')`;
+                });
+                out.push(`line-dasharray: step([zoom], ${frames.join(', ')});`);
+                coverage.emit('line-dasharray');
+                continue;
+            }
+            const pattern = dash.pattern;
+            if (!gaps(pattern)) {
                 coverage.drop(name, 'the pattern has no gap, so the line is solid', layer.id);
                 continue;
             }
-            if (pattern !== value && layer.dashZoom === undefined) {
+            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) {
+            const scale = (zoom === null ? null : rampAt(width, zoom)) ?? representativeScale(width, 1);
+            if (typeof width !== 'number') {
                 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');
             }
@@ -1708,7 +1741,7 @@ function layerDeclarations(layer, symbolizer, allowed, coverage, options, layerI
  * 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) {
+function iconPlateDeclarations(layer, icon, sized, coverage, options, fixedBox = false) {
     const params = layer.layout?.[ICON_PARAMS];
     if (!icon.plate || !params)
         return [];
@@ -1719,6 +1752,7 @@ function iconPlateDeclarations(layer, icon, sized, coverage, options) {
     // 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 stated = new Map();
     const colour = (name, target, gate = false, size = false) => {
         if (params[name] === undefined)
             return false;
@@ -1731,6 +1765,7 @@ function iconPlateDeclarations(layer, icon, sized, coverage, options) {
         const value = size ? sizedBy(translated) : translated;
         out.push(`${target}: ${gate ? scoped(value) : value};`);
         coverage.emit(target);
+        stated.set(target, translated);
         return true;
     };
     // The glyph, unless the layer states an icon-color of its own - that one is already out.
@@ -1759,6 +1794,17 @@ function iconPlateDeclarations(layer, icon, sized, coverage, options) {
         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');
+            stated.set('shield-icon-background-border-width', String(round(icon.plate.borderWidth)));
+        }
+    }
+    // A glyph's box is its own outline, so a plate fitted to it took each glyph's shape: the disc's box
+    // is stated instead, ring included (LabelPlateStyle::size is the outer size).
+    if (fixedBox) {
+        const ring = stated.get('shield-icon-background-border-width');
+        for (const [axis, side] of [['width', icon.width], ['height', icon.height]]) {
+            const outer = ring !== undefined ? `(${round(side)} + 2 * (${ring}))` : String(round(side));
+            out.push(`shield-icon-background-${axis}: ${sizedBy(outer)};`);
+            coverage.emit(`shield-icon-background-${axis}`);
         }
     }
     // MapBox's `icon-stroke` is the outline it draws UNDER the glyph, which is exactly what the
@@ -2002,7 +2048,7 @@ function shieldImageDeclarations(layer, icon, scale, coverage, options) {
         // 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);
+        emitTranslated(out, coverage, layer, 'icon-halo-width', 'shield-icon-halo-radius', undefined, false, options);
         out.push(...iconPlateDeclarations(layer, icon, sized, coverage, options));
     }
     else if (layer.layout?.[RECOLOURABLE_ICON] === true) {
@@ -2061,26 +2107,26 @@ function dashPattern(value) {
     return { pattern, zoom: stopZoomOf(value, pattern) };
 }
 /**
- * A dashed line whose WIDTH ramps over zoom, as one attachment per zoom band.
+ * A dashed line whose WIDTH ramps over zoom, as one `step([zoom], ...)` dash over zoom bands.
  *
- * 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
+ * A MapBox dash length is a multiple of the line width, and CartoCSS takes a pattern of PIXELS - the
+ * decoder rasterises it into a bitmap per tile, keyed by the string, so it can follow the TILE's zoom
+ * but not the view's. One pattern 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.
+ * Banded, each band 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. One rule carries them all: a band per attachment was a style each, ~200 in Massif.
  *
  * 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) {
+function bandDashByZoom(layer, coverage) {
     const dash = layer.paint?.['line-dasharray'];
     const width = dashWidth(layer.paint?.['line-width']);
-    if (dash === undefined || layer.dashZoom !== undefined || dashPattern(dash) === null)
-        return [layer];
+    if (dash === undefined || layer.dashBands !== undefined || dashPattern(dash) === null)
+        return layer;
     const zmin = layer.minzoom ?? 0;
     const zmax = Math.min(layer.maxzoom ?? 24, 24);
     // A dash the style STEPS over zoom is a rule per step: one pattern for all of them drew Standard's
@@ -2104,7 +2150,7 @@ function splitDashByZoom(layer, coverage) {
             cuts.add(at);
     }
     if (!cuts.size)
-        return [layer];
+        return layer;
     const edges = [zmin, ...[...cuts].sort((a, b) => a - b), zmax];
     const bands = [];
     for (let i = 0; i + 1 < edges.length; i++) {
@@ -2116,28 +2162,20 @@ function splitDashByZoom(layer, coverage) {
         if (stops.length && !((rampAt(width, dashZoom) ?? 0) > 0) && Math.max(from, lo) < b) {
             dashZoom = (Math.max(from, lo) + b) / 2;
         }
-        bands.push({
-            ...layer,
-            // The ends keep whatever the layer stated, so banding never narrows what it draws.
-            minzoom: i === 0 ? layer.minzoom : from,
-            maxzoom: i + 2 === edges.length ? layer.maxzoom : to,
-            dashZoom,
-        });
+        bands.push({ from, dashZoom });
     }
     // Two solid bands in a row are one: a width cut means nothing where no dash is drawn.
     const solid = (band) => !(dashPatternAt(dash, band.dashZoom) ?? [0, 1]).some((v, i) => i % 2 === 1 && v > 0);
     for (let i = bands.length - 1; i > 0; i--) {
-        if (solid(bands[i]) && solid(bands[i - 1])) {
-            bands[i - 1] = { ...bands[i - 1], maxzoom: bands[i].maxzoom };
+        if (solid(bands[i]) && solid(bands[i - 1]))
             bands.splice(i, 1);
-        }
     }
     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 or a stepped dash needs a rule per band');
-    return bands;
+        return layer;
+    coverage.approximate(`line-dasharray on "${layer.id}" stepped over ${bands.length} zoom bands: a `
+        + 'dash is a multiple of the line width and the decoder rasterises one pattern per tile, so a '
+        + 'ramped width or a stepped dash takes a pattern per band');
+    return { ...layer, dashBands: bands };
 }
 /**
  * No dash under a pixel: drawn through a bitmap, a 0.5 px sleeper lights a pixel only where it happens to land,
@@ -2590,8 +2628,8 @@ function dynamicIconField(image) {
  *   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
+ * A parameter table keyed by label IS that lookup - `get([param::t], [class])` 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.
  */
@@ -2600,13 +2638,13 @@ function dynamicIconField(image) {
  * 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) {
+function aliasSprites(names, file, table, 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));
+            setTableEntry(options, table, alias, file.get(sprite));
     }
 }
 function iconExpression(image, layer, coverage, options) {
@@ -2620,7 +2658,7 @@ function iconExpression(image, layer, coverage, options) {
     // 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;
+    const paramTable = plateMode ? GLYPH_TABLE : ICON_TABLE;
     // 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.
@@ -2717,8 +2755,8 @@ function iconExpression(image, layer, coverage, options) {
         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}]]`;
+            setTableEntry(options, paramTable, name, all.file.get(name));
+        return tableRead(paramTable, `concat('${prefix}', [${field}])`);
     };
     /** Every sprite written out, each under the file the rule should name it by. */
     let everySprite = null;
@@ -2875,19 +2913,19 @@ function iconExpression(image, layer, coverage, options) {
             // 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]}]]`;
+                setTableEntry(options, paramTable, name, all.file.get(name));
+            aliasSprites(all.names, all.file, paramTable, options);
+            const field = tableRead(paramTable, `[${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`);
+                setTableEntry(options, ICON_TABLE, 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]}]])`;
+            aliasSprites(raster.names, new Map(raster.names.map((n) => [n, `icons/${n}.png`])), ICON_TABLE, options);
+            return `(${plateWhen} ? ${field} : ${tableRead(ICON_TABLE, `[${node[1]}]`)})`;
         }
         if (Array.isArray(node) && node[0] === 'coalesce') {
             const parts = node.slice(1).map((b) => build(b)).filter((x) => x !== null);
@@ -2937,7 +2975,7 @@ function iconExpression(image, layer, coverage, options) {
                 const file = named(name);
                 if (!file)
                     continue;
-                options.styleParams.set(`${table}-${label}`, file);
+                setTableEntry(options, table, label, file);
                 wrote++;
             }
         }
@@ -2945,7 +2983,7 @@ function iconExpression(image, layer, coverage, options) {
         const tail = rest && rest !== `''` ? ` ?? ${rest}` : '';
         if (wrote === 0)
             return rest;
-        return `[param::${table}-[${field}]]${tail}`;
+        return `${tableRead(table, `[${field}]`)}${tail}`;
     };
     const expr = build(image);
     // In font mode there is no sprite to measure: the glyph run is sized by the label.
@@ -3090,13 +3128,13 @@ function paramiseValues(layer, options, coverage) {
         const prefix = `${safeParamName(layer.id)}-${safeParamName(property)}`;
         for (const [labels, result] of asHex) {
             for (const label of labels)
-                options.styleParams.set(`${prefix}-${label}`, result);
+                setTableEntry(options, 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})`);
+        subs.set(`'${sentinel}'`, `(${tableRead(prefix, `[${found.field}]`)} ?? ${fallback})`);
         if (whole) {
             paint[property] = sentinel;
         }
@@ -3148,9 +3186,7 @@ function patternDeclarations(name, value, target, layer, coverage, options) {
  * 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.
+ * A name the face has no glyph for keeps its sprite (markerDeclarations), or draws no icon without one.
  */
 function fontShieldDeclarations(layer, image, coverage, options) {
     const font = options.iconFont;
@@ -3186,11 +3222,11 @@ function fontShieldDeclarations(layer, image, coverage, options) {
     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);
+    emitTranslated(out, coverage, layer, 'icon-halo-width', 'shield-icon-halo-radius', undefined, false, options);
     // 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(...iconPlateDeclarations(layer, plate, sized, coverage, options, true));
     out.push(...variableAnchorDeclarations(layer, coverage, options));
     return out;
 }
@@ -3212,6 +3248,26 @@ function fontPlateSample(options) {
     }
     return fontPlates.get(options);
 }
+/** Every name an icon-image can resolve to, when it states them outright through `match`/`case`. */
+function statedIconNames(image) {
+    if (typeof image === 'string')
+        return /\{[A-Za-z0-9_:-]+\}/.test(image) ? null : [image];
+    if (!Array.isArray(image))
+        return null;
+    const outputs = image[0] === 'match' ? image.filter((_, i) => i >= 3 && (i % 2 === 1 || i === image.length - 1))
+        : image[0] === 'case' ? image.filter((_, i) => i >= 2 && (i % 2 === 0 || i === image.length - 1))
+            : null;
+    if (!outputs)
+        return null;
+    const names = outputs.map((o) => statedIconNames(o));
+    return names.every((n) => n !== null) ? names.flat() : null;
+}
+function spriteOnlyIcon(image, options) {
+    const names = statedIconNames(image);
+    if (!names || !options.sprites)
+        return false;
+    return names.every((n) => !options.iconFont.glyphs.has(n)) && names.some((n) => hasIcon(options.sprites.sheets, n));
+}
 /** 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'];
@@ -3220,6 +3276,9 @@ function markerDeclarations(layer, coverage, options) {
     // --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) {
+        // A map symbol the face has no glyph for (a peak, a town's dot) keeps its sprite.
+        if (spriteOnlyIcon(image, options))
+            return markerDeclarations(layer, coverage, { ...options, iconFont: undefined });
         return fontShieldDeclarations(layer, image, coverage, options);
     }
     if (!options.sprites) {
@@ -3411,6 +3470,11 @@ function placementPriority(layer, layerIndex, coverage) {
     const sortKey = layer.layout?.['symbol-sort-key'];
     if (sortKey === undefined)
         return String(base);
+    // a negated key is a boost: `base + boost` rather than `base - (0 - boost)`
+    if (Array.isArray(sortKey) && sortKey[0] === '-' && sortKey.length === 2) {
+        const boost = tryTranslate(sortKey[1], 'symbol-sort-key', layer.id, coverage);
+        return boost === null ? String(base) : `(${base} + ${boost})`;
+    }
     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})`;
@@ -3436,10 +3500,23 @@ const DEFAULT_SYMBOL_SPACING = 250;
  * 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-';
+/** One table entry per sprite name, so a per-feature lookup can fall through when it misses. */
+const ICON_TABLE = 'icon';
 /** The glyph FIELD of a recolourable icon, a different file under the same name. */
-const GLYPH_PARAM_PREFIX = 'glyph-';
+const GLYPH_TABLE = 'glyph';
+/**
+ * One entry of a parameter TABLE: an object parameter read with `get([param::table], key)`, unset
+ * for a key it does not name so `??` falls through. An app changes one entry as `table.key`.
+ */
+function setTableEntry(options, table, key, value) {
+    let spec = options.styleParams.get(table);
+    if (!spec)
+        options.styleParams.set(table, spec = { default: {} });
+    spec.default[key] = value;
+}
+function tableRead(table, key) {
+    return `get([param::${table}], ${key})`;
+}
 /** 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;
@@ -3456,7 +3533,7 @@ function scaledSize(size, width, translated) {
     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) {
+function emitTranslated(out, coverage, layer, from, to, fallback, constantOnly, options) {
     const value = layer.paint?.[from] ?? layer.layout?.[from];
     if (value === undefined) {
         if (fallback !== undefined) {
@@ -3469,7 +3546,8 @@ function emitTranslated(out, coverage, layer, from, to, fallback, constantOnly)
         coverage.drop(from, `a flattened bitmap needs a constant ${from}`, layer.id);
         return;
     }
-    const translated = name(from, layer, coverage);
+    // `options`: the property may be one the style asks to keep as a project.json table (massif:params)
+    const translated = (options && fieldParamTable(value, layer, from, to, coverage, options)) ?? name(from, layer, coverage);
     if (translated !== null) {
         out.push(`${to}: ${translated};`);
         coverage.emit(to);
@@ -3478,7 +3556,7 @@ function emitTranslated(out, coverage, layer, from, to, fallback, constantOnly)
 /** 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
+ * by that field - `get([param::poi-fill], [class])`, one table per palette - 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
@@ -3554,18 +3632,23 @@ function fieldParamTable(value, layer, property, target, coverage, options, suff
             entries.push([label, branch]);
         }
     }
+    // The fallback may be a table on ANOTHER field (subclass, then class): a chain of lookups, the
+    // last table keeping the plain name. Same field twice is not a chain, and keeps the ternary.
     const rest = value[value.length - 1];
-    if (typeof rest !== 'string' && typeof rest !== 'number')
-        return null;
-    const fallback = tryTranslate(rest, property, layer.id, coverage);
+    const chained = Array.isArray(rest) && rest[0] === 'match' && Array.isArray(rest[1]) && rest[1][0] === 'get'
+        && rest[1][1] !== field;
+    const fallback = chained
+        ? fieldParamTable(rest, layer, property, target, coverage, options, suffix)
+        : typeof rest === 'string' || typeof rest === 'number' ? tryTranslate(rest, property, layer.id, coverage) : null;
     if (fallback === null)
         return null;
-    const slug = `${layer['source-layer'] ?? safeParamName(layer.id)}-${target.replace(/^(text|shield|marker)-/, '')}${suffix}`;
+    const base = `${layer['source-layer'] ?? safeParamName(layer.id)}-${target.replace(/^(text|shield|marker)-/, '')}${suffix}`;
+    const slug = chained ? `${base}-${field}` : base;
     for (const [label, branch] of entries)
-        options.styleParams.set(`${slug}-${label}`, paramValue(branch));
+        setTableEntry(options, 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})`;
+        `(${slug}), read per feature by [${field}]`);
+    return `((${tableRead(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) {
@@ -3718,8 +3801,10 @@ export function projectEntries(drawOrder) {
     const runs = [];
     for (const { sourceLayer, attachment } of sorted) {
         const last = runs[runs.length - 1];
-        if (last && last.sourceLayer === sourceLayer)
-            last.attachments.push(attachment);
+        if (last && last.sourceLayer === sourceLayer) {
+            if (!last.attachments.includes(attachment))
+                last.attachments.push(attachment);
+        }
         else
             runs.push({ sourceLayer, attachments: [attachment] });
     }
@@ -3729,6 +3814,61 @@ export function projectEntries(drawOrder) {
         ? run.attachments.map((attachment) => `${run.sourceLayer}::${attachment}`)
         : [run.sourceLayer]));
 }
+/** A declaration whose stacking order could show: anything translucent, blended or textured. */
+const ORDER_VISIBLE = /opacity|comp-op|draw-once|elevation-mode|pattern|rgba\(|hsla\(|transparent|#[0-9a-fA-F]{8}\b/;
+/**
+ * Adjacent attachments of one source-layer whose every rule paints the same opaque lines or fills, in
+ * every preset, renamed into the first of them. Drawn one after the other or in the tile's order, the
+ * pixels are the same - and a feature both match is drawn once instead of twice, the same opaque
+ * pixels again. An attachment is a pass over its source layer per tile, so this is decode time saved.
+ * Returns how many attachments were folded into another.
+ */
+export function mergeIdenticalPaint(blocks, drawOrder, presets, keep) {
+    // blocks[i] and drawOrder[i] are pushed together, so they share an index
+    const sequence = drawOrder.map((entry, at) => ({ entry, at }))
+        .sort((a, b) => a.entry.index - b.entry.index || a.at - b.at).map((item) => item.at);
+    const groups = [];
+    for (const at of sequence) {
+        const { sourceLayer, attachment } = drawOrder[at];
+        const last = groups[groups.length - 1];
+        if (last && last.sourceLayer === sourceLayer && last.attachment === attachment)
+            last.at.push(at);
+        else
+            groups.push({ sourceLayer, attachment, at: [at] });
+    }
+    const flat = (declaration) => /^(line|polygon)-/.test(declaration) && !ORDER_VISIBLE.test(declaration);
+    const signature = (group) => {
+        if (group.attachment === '' || keep.has(group.attachment))
+            return null;
+        const runs = [blocks, ...presets];
+        const paints = [];
+        for (const run of runs) {
+            const first = run[group.at[0]].declarations;
+            if (!first.every(flat))
+                return null;
+            const paint = JSON.stringify(first);
+            if (group.at.some((at) => JSON.stringify(run[at].declarations) !== paint))
+                return null;
+            paints.push(paint);
+        }
+        return paints.join('\n');
+    };
+    let merged = 0;
+    let current = null;
+    for (const group of groups) {
+        const paint = signature(group);
+        if (current && paint !== null && current.paint === paint && current.sourceLayer === group.sourceLayer) {
+            for (const at of group.at) {
+                blocks[at].selector = blocks[at].selector.slice(0, -group.attachment.length) + current.attachment;
+                drawOrder[at] = { ...drawOrder[at], attachment: current.attachment };
+            }
+            merged++;
+            continue;
+        }
+        current = { sourceLayer: group.sourceLayer, attachment: group.attachment, paint };
+    }
+    return merged;
+}
 /** What the split above cost, so a project that grew entries says why. */
 function reportSplitLayers(drawOrder, coverage) {
     const entries = projectEntries(drawOrder);