@chrtco/sdk 0.10.49 → 0.10.50

package/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to `@chrtco/sdk` will be documented in this file.
 ## [Unreleased]
 
 ### Added
+- **`generateStyle({ dangerDepthPlacers: true })`** — the danger depths (the depth beside a rock,
+  wreck or obstruction) as a pair: an invisible placer `s52-{UWTROC,OBSTRN,WRECKS}-placer-label`
+  in 0.10.3's collision form (`text-opacity: 0`) beneath each callout, which is then always drawn
+  and inserts no collision box, so no sounding is hidden and a tile draws the callouts once.
+  Default off: the style is unchanged unless asked. `addDangerDepthPlacers`,
+  `isDangerDepthPlacer` (skip the placers when hit-testing), `dangerDepthPlacerId`,
+  `DANGER_DEPTH_LABEL_ID`, `DANGER_DEPTH_PLACER_ID`, `DANGER_DEPTH_PLACER_LAYOUT`,
+  `DANGER_DEPTH_VISIBLE_LAYOUT`. The style routes take it as `?placers=1`.
 - **`EINK_NIGHT`** — the e-ink night palette (`theme=eink_night`, offline `palette=EINK_NIGHT`,
   `EINK_COLOR_TABLES.night`): `EINK_MONO`'s four greys on a black page, for any e-ink screen at
   night with the front light on, in place of red night. Water black; lines and labels `#aaaaaa`;

package/dist/index.cjs

@@ -61,6 +61,10 @@ __export(index_exports, {
   CHRT_STYLE_MODES: () => CHRT_STYLE_MODES,
   Chrt: () => Chrt,
   ChrtError: () => ChrtError,
+  DANGER_DEPTH_LABEL_ID: () => DANGER_DEPTH_LABEL_ID,
+  DANGER_DEPTH_PLACER_ID: () => DANGER_DEPTH_PLACER_ID,
+  DANGER_DEPTH_PLACER_LAYOUT: () => DANGER_DEPTH_PLACER_LAYOUT,
+  DANGER_DEPTH_VISIBLE_LAYOUT: () => DANGER_DEPTH_VISIBLE_LAYOUT,
   DEFAULT_CLICK_TOLERANCE: () => DEFAULT_CLICK_TOLERANCE,
   DEFAULT_CUSTOM_STYLE_CONFIG: () => DEFAULT_CUSTOM_STYLE_CONFIG,
   DEFAULT_INSPECT_CLASS_RANK: () => DEFAULT_INSPECT_CLASS_RANK,
@@ -159,6 +163,7 @@ __export(index_exports, {
   WATER_BODY_LAYER_GROUPS: () => WATER_BODY_LAYER_GROUPS,
   WATER_TEXT_CLASSES: () => WATER_TEXT_CLASSES,
   WeatherEndpoint: () => WeatherEndpoint,
+  addDangerDepthPlacers: () => addDangerDepthPlacers,
   applyBaseBundle: () => applyBaseBundle,
   applyChartSymbolScales: () => applyChartSymbolScales,
   applyChartSymbolScalesToLayer: () => applyChartSymbolScalesToLayer,
@@ -201,6 +206,7 @@ __export(index_exports, {
   combineWithBandFilter: () => combineWithBandFilter,
   contourValueFactor: () => contourValueFactor,
   contrastRatio: () => contrastRatio,
+  dangerDepthPlacerId: () => dangerDepthPlacerId,
   daymarkColor: () => daymarkColor,
   decimateFeatures: () => decimateFeatures,
   decodeAreaFeatureProps: () => decodeAreaFeatureProps,
@@ -251,6 +257,7 @@ __export(index_exports, {
   hazardFillExpression: () => hazardFillExpression,
   iconExpressionForFamily: () => iconExpressionForFamily,
   iconSliderFor: () => iconSliderFor,
+  isDangerDepthPlacer: () => isDangerDepthPlacer,
   isDepthAreaClassLayerId: () => isDepthAreaClassLayerId,
   isDrapeable: () => isDrapeable,
   isEinkColorTable: () => isEinkColorTable,
@@ -24903,6 +24910,11 @@ function labelSortKey(rank, within) {
     ["min", 999, ["max", 0, within]]
   ];
 }
+var DANGER_DEPTH_PLACEMENT_KEY = labelSortKey(100, [
+  "*",
+  10,
+  ["to-number", ["coalesce", ["get", "VALSOU"], ["get", "valsou"], 0], 0]
+]);
 var NAV_DESIGNATION_STOPWORDS = [
   "Buoy",
   "Can",
@@ -25710,43 +25722,23 @@ function getLabelConfig(layerName, opts = {}) {
           "text-variable-anchor": ["top-left", "bottom-left", "top-right", "bottom-right"],
           "text-radial-offset": 0.9,
           "text-justify": "auto",
-          // ⚠ A DANGER DEPTH IS NEVER DROPPED (owner, 2026-10-06). Before,
-          // a callout with no free corner was culled and the rock, wreck or
-          // obstruction drew with no depth beside it: 15 of 136 at Boston
-          // z12.3. ALLOW-OVERLAP ONLY, and that is the whole point:
-          //   - the variable anchors still fan out first — MapLibre 5.24
-          //     tries every corner without overlap and overlaps, at the
-          //     first corner, only when none is free (`placement.ts`,
-          //     `placementPasses`), so only the callouts that used to vanish
-          //     draw over something;
-          //   - `text-ignore-placement` stays false, so a callout keeps its
-          //     collision space and blocks what it blocked before. Ignoring
-          //     placement as well freed that space for buoy and place names,
-          //     which then pushed shallow soundings off: 11 shoals uncovered
-          //     at z12.3 on the bench. This form: 0.
-          // The census and its numbers: `scripts/chart-bench/
-          // danger-depth-census.ts` and `.chrt/standards/s-52.md` §8a.
+          // ⚠ A DANGER DEPTH IS NEVER DROPPED (owner, 2026-10-06). This is
+          // 0.10.4's form, which the SERVED style keeps: always drawn
+          // (`text-allow-overlap`), still in collision, fanned out by its four
+          // variable anchors, placed shallowest first. Its cost, measured: a
+          // newly drawn callout takes space a sounding held (7 soundings under
+          // 3.048 m hidden at the 100 % default), and the depth key on an
+          // overlapping layer draws one segment per depth (+14 % draw calls).
+          // With `generateStyle({ dangerDepthPlacers: true })` — CHRTweb and
+          // CHRTdesktop — `danger-depth-placer.ts` turns it into a PAIR: an
+          // invisible placer in 0.10.3's form holds the space, and this label
+          // is drawn over it, displacing nothing, with one key. The census:
+          // `scripts/chart-bench/danger-depth-census.ts`; `.chrt/standards/
+          // s-52.md` §8a.
           "text-allow-overlap": true,
           "text-optional": true,
           "text-padding": 2,
-          // ⚠ THE DEPTH SORT KEY IS LOAD-BEARING — do not "optimise" it to a
-          // constant. It costs draw calls: MapLibre 5.24 draws an overlapping
-          // layer with a data-driven key one segment per distinct key, twice
-          // with a halo over 1 px (`drawLayerSymbols`, `hasSortKey &&
-          // bucket.canOverlap`), so at 100 % the chart issues +14 % draw calls
-          // at z12.3 against 0.10.3 (R6's 0.10.4 gate). But the key is also
-          // the PLACEMENT order, and a callout keeps its collision box, so the
-          // order decides which corner each callout takes and therefore which
-          // soundings and buoy names survive beneath it. Measured with each
-          // form booted fresh (2026-10-06, Boston and Salem Sound, z11.5–16,
-          // at 1280×800 and the Pi's 1920×1185): a constant key, 3/4/5 depth
-          // bands and whole metres ALL uncover shoals that 0.10.3 drew (a
-          // constant key: 5 at z12.3 on the Pi's canvas, a 0.6 m one at
-          // 1280×800) and change buoy names; only this key matches 0.10.4's
-          // census. `danger-depth-census.ts --form <json>` re-runs that gate
-          // for any candidate. A 1 px halo (one pass, not two) halves the
-          // cost with placement byte-identical — a portrayal call, not taken.
-          "symbol-sort-key": labelSortKey(100, ["*", 10, valsou])
+          "symbol-sort-key": DANGER_DEPTH_PLACEMENT_KEY
         }
       };
     }
@@ -26507,6 +26499,62 @@ function buildBridgeNoteLayers(sourceId, palette = "DAY", depthUnits = "meters")
   ];
 }
 
+// src/atlas/danger-depth-placer.ts
+var DANGER_DEPTH_LABEL_ID = /^s52-(UWTROC|OBSTRN|WRECKS)-label(?=$|-)/;
+var DANGER_DEPTH_PLACER_ID = /^s52-(UWTROC|OBSTRN|WRECKS)-placer-label(?=$|-)/;
+function dangerDepthPlacerId(labelId) {
+  return labelId.replace(/^s52-(UWTROC|OBSTRN|WRECKS)-label/, "s52-$1-placer-label");
+}
+function isDangerDepthPlacer(layerId) {
+  return DANGER_DEPTH_PLACER_ID.test(layerId);
+}
+var DANGER_DEPTH_VISIBLE_LAYOUT = {
+  "text-allow-overlap": true,
+  "text-ignore-placement": true,
+  "symbol-sort-key": labelSortKey(100),
+  "symbol-z-order": "source"
+};
+var DANGER_DEPTH_PLACER_LAYOUT = {
+  "text-allow-overlap": false,
+  "text-ignore-placement": false,
+  "symbol-sort-key": DANGER_DEPTH_PLACEMENT_KEY
+};
+function addDangerDepthPlacers(layers) {
+  if (!layers.some((l) => isVisibleDangerDepthLabel(l))) return layers;
+  const out = [];
+  for (let i = 0; i < layers.length; ) {
+    const cls = classOf(layers[i]);
+    if (cls === null) {
+      out.push(layers[i]);
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < layers.length && classOf(layers[j]) === cls) j++;
+    const run = layers.slice(i, j);
+    for (const l of run) out.push(placerFor(l));
+    for (const l of run) out.push({ ...l, layout: { ...l.layout ?? {}, ...DANGER_DEPTH_VISIBLE_LAYOUT } });
+    i = j;
+  }
+  return out;
+}
+function placerFor(l) {
+  const { "symbol-z-order": _zOrder, ...layout } = l.layout ?? {};
+  return {
+    ...l,
+    id: dangerDepthPlacerId(l.id),
+    layout: { ...layout, ...DANGER_DEPTH_PLACER_LAYOUT },
+    paint: { ...l.paint ?? {}, "text-opacity": 0 },
+    metadata: { ...l.metadata ?? {}, "chrt:placerFor": l.id }
+  };
+}
+function isVisibleDangerDepthLabel(l) {
+  return l.type === "symbol" && DANGER_DEPTH_LABEL_ID.test(l.id) && l.layout?.["text-field"] !== void 0;
+}
+function classOf(l) {
+  return isVisibleDangerDepthLabel(l) ? DANGER_DEPTH_LABEL_ID.exec(l.id)?.[1] ?? null : null;
+}
+
 // src/atlas/feature-decimation.ts
 function getGridSizeForZoom(zoom) {
   if (zoom < 7) return 50;
@@ -29663,7 +29711,6 @@ function buildLayersForClass(objectClass2, ct, sourceId = DEFAULT_REGION, opts =
       };
       if (HAZARD_GROUPS.has(entry?.viewingGroup ?? 0)) {
         const watlev = ["to-number", ["coalesce", ["get", "WATLEV"], ["get", "watlev"], 0], 0];
-        const valsou = ["to-number", ["coalesce", ["get", "VALSOU"], ["get", "valsou"], 99], 99];
         const hazardIconSize = [
           "interpolate",
           ["linear"],
@@ -29707,9 +29754,9 @@ function buildLayersForClass(objectClass2, ct, sourceId = DEFAULT_REGION, opts =
           //
           // Deconflicting hazards against each other stays; it just no longer
           // runs through suppression:
-          //   - `symbol-sort-key` (below) still ranks by danger, and with
-          //     overlap allowed it now sets DRAW ORDER, so the worst hazard is
-          //     the one painted on top rather than the one that survives.
+          //   - `symbol-sort-key` (below) sets PAINT ORDER, so the worst
+          //     hazard is the one painted on top rather than the one that
+          //     survives.
           //   - the icon-size curve above is what keeps a dense ledge legible
           //     at the zoomed-out end of Harbor. That is now the only thing
           //     doing it, which is why its low end was lowered in the same
@@ -29726,18 +29773,59 @@ function buildLayersForClass(objectClass2, ct, sourceId = DEFAULT_REGION, opts =
           // hazards present to OTHER classes' placement, keeping labels off
           // them.
           "icon-padding": 2,
+          // ── PAINT ORDER: THE WORST HAZARD ON TOP, IN FOUR KEYS ─────────────
+          //
+          // With overlap allowed MapLibre paints a layer in ascending key,
+          // so a HIGHER key is painted OVER a lower one:
+          //   3  covers and uncovers (WATLEV 4)
+          //   2  awash (WATLEV 5)
+          //   1  everything else: submerged, unknown, subject to inundation,
+          //      floating
+          //   0  stands above the water (WATLEV 1 partly submerged at high
+          //      water, 2 always dry). Seen by eye, and it usually carries no
+          //      sounding, so the old key already ranked it last (a missing
+          //      VALSOU counted as 99 m).
+          //
+          // Until 2026-10-09 this was `case 4 → 1, 5 → 2, else 10 + VALSOU`,
+          // meant as "worst first". With overlap that is "worst UNDERNEATH":
+          // the deepest rock was painted over everything. Measured on the
+          // chart bench, Boston z12.3 at 1280×800: of 758 overlapping pairs
+          // with different icons, all 758 had the lesser hazard on top.
+          //
+          // Why four keys and not a depth ladder:
+          //   - An icon is picked by WATLEV alone (the `icon-image` match
+          //     above, every symbol family), never by depth. Each key holds
+          //     ONE icon per class (UWTROC 01 | 03 | 04 | 04, OBSTRN
+          //     03 | 03 | 03 | 01, WRECKS 04 | 04 | 04 | 01), so two hazards
+          //     that share a key look the same, and which is on top cannot be
+          //     seen. With three keys the dry obstructions and wrecks shared
+          //     the lowest one and were painted over submerged ones up to 4
+          //     times a view; with four, never.
+          //   - MapLibre 5.24 draws a layer that can overlap and has a
+          //     feature-reading key ONE SEGMENT PER DISTINCT KEY PER TILE
+          //     (`SymbolBucket.addSymbols` → `prepareSegment`;
+          //     `drawLayerSymbols`, `hasSortKey && bucket.canOverlap`). The
+          //     old key had one value per sounded depth, so it cost a draw
+          //     call for every distinct VALSOU in every tile (up to 50 in one
+          //     bucket). Four keys cost at most four, and no bucket measured
+          //     held more than three.
+          //
+          // It should change paint order only. A hazard icon has one fixed
+          // anchor and is always drawn, and every one of them puts its box in
+          // the collision index whatever the order. The census measures that
+          // rather than assuming it: every icon, label and sounding in view,
+          // each form booted twice (`scripts/chart-bench/hazard-icon-census.ts`).
+          // Its numbers are in `danger-depth-callouts.test.ts`, which pins
+          // this order.
           "symbol-sort-key": [
             "case",
             ["==", watlev, 4],
-            1,
+            3,
             ["==", watlev, 5],
             2,
-            // Submerged rocks: sounded depth determines priority. Shallower
-            // = smaller sort-key = wins collisions. Offset by 10 so any
-            // submerged rock still loses to a covers-and-uncovers / awash
-            // hazard at the same point, but ranks dangerously-shallow
-            // submerged rocks above deeper ones.
-            ["+", 10, valsou]
+            ["any", ["==", watlev, 1], ["==", watlev, 2]],
+            0,
+            1
           ]
         };
       }
@@ -32309,7 +32397,14 @@ function generateStyle(palette = "DAY", opts = {}) {
     layers: finalLayers
   };
   const familyStyle = symbolSet === "s101" ? applyS101SymbolSet(style) : symbolSet === "chrt" ? applyChrtSymbolSet(style, palette) : symbolSet === "raster" ? applyRasterSymbolSet(style) : style;
-  const portrayed = applyEinkPortrayal(familyStyle, palette, { safetyContour: opts.safetyContour });
+  const einked = applyEinkPortrayal(familyStyle, palette, { safetyContour: opts.safetyContour });
+  const placed = opts.dangerDepthPlacers === true ? addDangerDepthPlacers(einked.layers) : einked.layers;
+  const portrayed = placed === einked.layers ? einked : {
+    ...einked,
+    layers: placed,
+    // The placers are emitted layers: the count is of what the style carries.
+    metadata: { ...einked.metadata, "chrt:layer-count": placed.length }
+  };
   const sized = applyChartSymbolScales(portrayed.layers, opts.symbolScales, opts.soundingsRule);
   return sized === portrayed.layers ? portrayed : { ...portrayed, layers: sized };
 }
@@ -33235,6 +33330,10 @@ var Chrt = class {
   CHRT_STYLE_MODES,
   Chrt,
   ChrtError,
+  DANGER_DEPTH_LABEL_ID,
+  DANGER_DEPTH_PLACER_ID,
+  DANGER_DEPTH_PLACER_LAYOUT,
+  DANGER_DEPTH_VISIBLE_LAYOUT,
   DEFAULT_CLICK_TOLERANCE,
   DEFAULT_CUSTOM_STYLE_CONFIG,
   DEFAULT_INSPECT_CLASS_RANK,
@@ -33333,6 +33432,7 @@ var Chrt = class {
   WATER_BODY_LAYER_GROUPS,
   WATER_TEXT_CLASSES,
   WeatherEndpoint,
+  addDangerDepthPlacers,
   applyBaseBundle,
   applyChartSymbolScales,
   applyChartSymbolScalesToLayer,
@@ -33375,6 +33475,7 @@ var Chrt = class {
   combineWithBandFilter,
   contourValueFactor,
   contrastRatio,
+  dangerDepthPlacerId,
   daymarkColor,
   decimateFeatures,
   decodeAreaFeatureProps,
@@ -33425,6 +33526,7 @@ var Chrt = class {
   hazardFillExpression,
   iconExpressionForFamily,
   iconSliderFor,
+  isDangerDepthPlacer,
   isDepthAreaClassLayerId,
   isDrapeable,
   isEinkColorTable,