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

package/dist/mapbox2css/index.js

@@ -9,7 +9,7 @@ import { PLATE_MAP, asShieldDeclaration, isShieldLayer, plateRadius } from './sh
 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');
             }
@@ -2015,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) {
@@ -2074,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
@@ -2117,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++) {
@@ -2129,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,
@@ -2603,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.
  */
@@ -2613,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) {
@@ -2633,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.
@@ -2730,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;
@@ -2888,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);
@@ -2950,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++;
             }
         }
@@ -2958,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.
@@ -3103,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;
         }
@@ -3197,7 +3222,7 @@ 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)
@@ -3475,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;
@@ -3495,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) {
@@ -3508,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);
@@ -3517,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
@@ -3593,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) {
@@ -3757,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] });
     }
@@ -3768,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);