mapshaper 0.7.37 → 0.7.39

package/www/mapshaper.js

@@ -31882,6 +31882,7 @@ ${svg}
         type: 'flag'
       })
       .option('polar', {
+        // special polar handling is activated automatically now, so I'm making this an undocumented option.
         // describe: 'keep lat-long buffers within the valid extent (+/-180, +/-90); for growing polygons sliced at the antimeridian/poles (erode not yet supported)',
         type: 'flag'
       })
@@ -32233,6 +32234,26 @@ ${svg}
         describe: 'one or more assignment expressions (comma-sep.)'
       });
 
+    parser.command('densify')
+      .describe('add vertices along path segments so no segment exceeds an interval')
+      .option('interval', {
+        DEFAULT: true,
+        describe: 'max segment length in distance units or degrees for lat-long data in planar mode'
+      })
+      .option('geodesic', {
+        describe: '[lat-long, default] interpolate along the ellipsoidal shortest path',
+        type: 'flag'
+      })
+      .option('rhumb', {
+        describe: '[lat-long] interpolate along a rhumb line (constant bearing)',
+        type: 'flag'
+      })
+      .option('planar', {
+        describe: '[default for projected data] interpolate along a straight line in coordinate space',
+        type: 'flag'
+      })
+      .option('target', targetOpt);
+
     parser.command('dissolve')
       .describe('merge features within a layer (repairs polygon topology)')
       .option('field', {}) // old arg handled by dissolve function
@@ -33076,15 +33097,18 @@ ${svg}
         type: 'flag'
       })
       .option('corner-bias', {
-        // Sensitivity of corner detection (default 0 = neutral). Positive keeps
-        // more corners, negative fewer; +/- values of equal size are inverses.
-        // Under the hood it scales only the distance-proportional detection
-        // parameters (not angles), detecting corners as if the distance were
-        // divided by k, where k = bias+1 for bias >= 0 and 1/(1-bias) for bias < 0;
-        // the smoothing kernel keeps using the real distance. So corner-bias=-1
-        // finds the corners a 2x distance would, corner-bias=1 those of a 0.5x
-        // distance. Use no-corners to turn corner preservation off entirely.
-        describe: 'corner-detection sensitivity (default 0; + is more sensitive, - is less)',
+        // Sensitivity of corner detection, RELATIVE to an automatic baseline
+        // (default 0 = the automatic setting). Detection is auto-coarsened on
+        // geometry that is sparse relative to the smoothing distance (long segments
+        // read ordinary coarse bends as corners); this option adds to that base.
+        // Positive keeps more corners, negative fewer; it scales only the distance-
+        // proportional detection parameters (not angles), detecting corners as if
+        // the distance were divided by k, where k = bias+1 for bias >= 0 and
+        // 1/(1-bias) for bias < 0, and the smoothing kernel keeps using the real
+        // distance. So on fine data (no auto adjustment) corner-bias=-1 finds the
+        // corners a 2x distance would; on coarse data a positive value counteracts
+        // the automatic coarsening. Use no-corners to turn preservation off entirely.
+        describe: 'corner-detection sensitivity relative to auto (default 0; + more, - fewer)',
         type: 'number'
       })
       .option('prefilter-gate', {
@@ -43238,7 +43262,7 @@ ${svg}
     return x;
   }
 
-  var POLAR_BUFFER_MARGIN_DEGREES = 1e-4;
+  var POLAR_BUFFER_MARGIN_DEGREES$1 = 1e-4;
 
 
   // Returns a function for generating GeoJSON MultiPolygon geometries
@@ -43303,9 +43327,9 @@ ${svg}
           maxAbsLat = Math.max(maxAbsLat, Math.abs(latLngPathIter.y));
         }
       });
-      if (maxAbsLat + angularDist >= 90 - POLAR_BUFFER_MARGIN_DEGREES) {
+      if (maxAbsLat + angularDist >= 90 - POLAR_BUFFER_MARGIN_DEGREES$1) {
         stop$1('Buffering lat-long coordinates near the poles is not supported; ' +
-          'use the polar option for polygons sliced at the antimeridian/poles.');
+          'positive polygon buffers that reach a pole use experimental polar handling.');
       }
     }
 
@@ -47692,6 +47716,32 @@ ${svg}
 
   function makePolygonBuffer(lyr, dataset, opts) {
     var spherical = isLatLngCRS(getDatasetCRS(dataset));
+    if (spherical && sourceHasCollapsingBandEdge(lyr, dataset)) {
+      // A ring edge that jumps a full 360 degrees of longitude (e.g. -180 -> 180)
+      // with no intermediate vertices is ambiguous: the antimeridian unwrap reads
+      // its delta as 0, collapsing the edge's endpoints onto one meridian in
+      // Mercator, so the offset returns a sliver. (Pole-encircling rings and
+      // pole floors are exempt -- see sourceHasCollapsingBandEdge.) Warn rather
+      // than silently collapse; densifying the edge fixes it.
+      warn('A polygon edge spans the full longitude range with no intermediate vertices and will collapse when buffered. Add vertices along the edge (e.g. densify it) before buffering.');
+    }
+    if (spherical && !opts.polar && sourceHasPoleEnclosingRing(lyr, dataset)) {
+      // A lat-long polygon whose ring encircles a pole (e.g. an Antarctica shell)
+      // has no closed planar representation: projected to Mercator and unwrapped
+      // across the antimeridian, its endpoints land a full world-width apart, so
+      // the offset construction reads the ring as an open line and returns a
+      // two-sided ribbon instead of a grown polygon. Insert a floor along the
+      // enclosed pole line so the ring becomes an ordinary closed polygon (the same
+      // representation as a pole-touching shell) and route it through polar
+      // handling, which grows it correctly and clips the result to the world rect.
+      var normalized = buildPoleEnclosingNormalizedSource(lyr, dataset);
+      if (normalized) {
+        message('Buffering a polygon that encircles a pole; using experimental polar handling.');
+        lyr = normalized.layer;
+        dataset = normalized.dataset;
+        opts = Object.assign({}, opts, {polar: true});
+      }
+    }
     // debug-mosaic is implemented only for line buffers; for polygons it has no
     // handling and would leak into the per-shape dissolve and corrupt output, so
     // drop it and warn rather than silently mislead.
@@ -47749,6 +47799,17 @@ ${svg}
       }
       return debugDataset;
     }
+    if (spherical && !opts.polar && polygonBufferNeedsPolarMode(lyr, dataset, opts)) {
+      message('Using experimental polar buffer mode because the buffer reaches a pole.');
+      opts = Object.assign({}, opts, {polar: true});
+    } else if (spherical && !opts.polar && polygonBufferWrapsAntimeridian(lyr, dataset, opts)) {
+      // A ring that wraps the full longitude range (e.g. a band around the globe)
+      // becomes a world-wide rectangle in Mercator whose long straight edges the
+      // default offset construction collapses to thin seam caps. Route it through
+      // polar handling, which pins the seam edges and clips to the world rect.
+      message('Using experimental polar buffer mode because the geometry wraps around the antimeridian.');
+      opts = Object.assign({}, opts, {polar: true});
+    }
     if (spherical && opts.polar) {
       // Pole/antimeridian-sliced polygons (grow only): keep the seam edges at the
       // extent and clip to the world rectangle instead of wrapping at the
@@ -48260,11 +48321,276 @@ ${svg}
 
   // World rectangle (lng/lat) the polar buffer is clipped to.
   var POLAR_WORLD_BBOX = [-180, -90, 180, 90];
+  var POLAR_BUFFER_MARGIN_DEGREES = 1e-4;
+
+  function polygonBufferNeedsPolarMode(lyr, dataset, opts) {
+    if (!dataset.arcs) return false;
+    var bounds = dataset.arcs.getBounds();
+    var maxAbsLat = Math.max(Math.abs(bounds.ymin), Math.abs(bounds.ymax));
+    var maxPositiveDistance = getMaxPositiveBufferDistance(lyr, dataset, opts);
+    if (!(maxPositiveDistance > 0)) return false;
+    return maxAbsLat + maxPositiveDistance / R$3 * R2D$1 >= 90 - POLAR_BUFFER_MARGIN_DEGREES;
+  }
+
+  function getMaxPositiveBufferDistance(lyr, dataset, opts) {
+    var distanceFn = getBufferDistanceFunction(lyr, dataset, opts);
+    var max = 0, hasNegative = false;
+    (lyr.shapes || []).forEach(function(shape, i) {
+      if (!shape) return;
+      var distance = distanceFn(i);
+      if (distance < 0) hasNegative = true;
+      if (distance > max) max = distance;
+    });
+    // Don't auto-enable polar mode for mixed or negative erode buffers: the polar
+    // construction keeps pole seams pinned and currently supports grow buffers only.
+    return hasNegative ? 0 : max;
+  }
+
+  // True for a positive (grow) buffer whose source has a ring that wraps the full
+  // longitude range (e.g. a band circling the globe). Such a ring is closed in
+  // unwrapped Mercator (net winding 0, unlike a pole-encircling ring) but its
+  // world-wide straight edges collapse in the default construction, so it needs
+  // the seam-pinning polar path.
+  function polygonBufferWrapsAntimeridian(lyr, dataset, opts) {
+    if (!(getMaxPositiveBufferDistance(lyr, dataset, opts) > 0)) return false;
+    return sourceHasFullLongitudeRing(lyr, dataset);
+  }
+
+  // Minimum unwrapped longitude span (of 360) for a ring to count as wrapping the
+  // full globe.
+  var FULL_LONGITUDE_MIN_SPAN = 350;
+
+  // Raw (not unwrapped) longitude delta, in degrees, above which an edge is treated
+  // as a full-turn "sweep" edge (endpoints on opposite antimeridian reps, e.g.
+  // -180 -> 180). A genuine antimeridian crossing has a much smaller raw delta.
+  var SWEEP_EDGE_MIN_RAW_DELTA = 359;
+  // A vertex within this many degrees of +/-90 counts as sitting on a pole.
+  var POLE_LATITUDE_EPS = 1e-3;
+  // A ring is pole-encircling (handled by normalization, not a collapsing band)
+  // when |net longitude winding| is near 360; treat anything below this as a band.
+  var NON_ENCIRCLING_WINDING_MAX = 180;
+
+  // True if a ring has a full-longitude "sweep" edge that will collapse when
+  // buffered: an edge whose raw longitude delta is ~360 and that does NOT sit on a
+  // pole (a sweep edge along a pole line is a single point, so it is harmless).
+  function ringHasCollapsingSweepEdge(ring) {
+    if (!ring) return false;
+    for (var i = 1; i < ring.length; i++) {
+      var a = ring[i - 1], b = ring[i];
+      if (Math.abs(b[0] - a[0]) < SWEEP_EDGE_MIN_RAW_DELTA) continue;
+      if (Math.abs(a[1]) < 90 - POLE_LATITUDE_EPS ||
+          Math.abs(b[1]) < 90 - POLE_LATITUDE_EPS) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // True if the source has a ring that will collapse when buffered because a
+  // full-longitude edge has no intermediate vertices. Excludes pole-encircling
+  // rings (|net winding| ~ 360), which are normalized and buffer correctly, and
+  // sweep edges that lie on a pole line (harmless). Cheap O(1) gates first: the
+  // dataset must reach both antimeridian extremes; only full-width shapes are
+  // exported and scanned.
+  function sourceHasCollapsingBandEdge(lyr, dataset) {
+    if (!dataset.arcs) return false;
+    var b = dataset.arcs.getBounds();
+    if (b.xmin > -180 + 1e-6 || b.xmax < 180 - 1e-6) return false;
+    return (lyr.shapes || []).some(function(shape) {
+      if (!shape) return false;
+      var sb = dataset.arcs.getMultiShapeBounds(shape);
+      if (!sb || (sb.xmax - sb.xmin) < FULL_LONGITUDE_MIN_SPAN) return false;
+      return getPolygonMultiPolygonCoords(shape, dataset.arcs).some(function(rings) {
+        return rings.some(function(ring) {
+          return Math.abs(ringLngWinding(ring)) < NON_ENCIRCLING_WINDING_MAX &&
+            ringHasCollapsingSweepEdge(ring);
+        });
+      });
+    });
+  }
+
+  // True if any source ring spans (nearly) the full longitude range once its
+  // longitudes are unwrapped across the antimeridian. Uses the same cheap gates as
+  // sourceHasPoleEnclosingRing (dataset reaches the antimeridian; only wide shapes
+  // are exported and scanned). A small polygon that merely crosses the antimeridian
+  // unwraps to a narrow span and is correctly excluded.
+  function sourceHasFullLongitudeRing(lyr, dataset) {
+    if (!dataset.arcs) return false;
+    var b = dataset.arcs.getBounds();
+    if (b.xmin > -180 + 1e-6 && b.xmax < 180 - 1e-6) return false;
+    return (lyr.shapes || []).some(function(shape) {
+      if (!shape) return false;
+      var sb = dataset.arcs.getMultiShapeBounds(shape);
+      if (!sb || (sb.xmax - sb.xmin) < FULL_LONGITUDE_MIN_SPAN) return false;
+      return getPolygonMultiPolygonCoords(shape, dataset.arcs).some(function(rings) {
+        return rings.some(function(ring) {
+          return ringUnwrappedLngSpan(ring) >= FULL_LONGITUDE_MIN_SPAN;
+        });
+      });
+    });
+  }
+
+  // Longitude extent of a ring after unwrapping across the antimeridian (each edge's
+  // longitude delta reduced to (-180, 180], accumulated). A globe-wrapping ring
+  // spans ~360; a small antimeridian-crossing polygon spans only its true width.
+  function ringUnwrappedLngSpan(ring) {
+    if (!ring || ring.length < 2) return 0;
+    var x = 0, min = 0, max = 0;
+    for (var i = 1; i < ring.length; i++) {
+      var d = ring[i][0] - ring[i - 1][0];
+      if (d > 180) d -= 360;
+      else if (d < -180) d += 360;
+      x += d;
+      if (x < min) min = x;
+      if (x > max) max = x;
+    }
+    return max - min;
+  }
+
+  // A ring is at least this many degrees wide (full longitude range is 360) to be
+  // considered a possible pole-encircling ring; skips the coordinate export and
+  // winding scan for ordinary shapes.
+  var POLE_ENCLOSING_MIN_WIDTH = 350;
+  // A ring encircles a pole when its longitudes wind a full turn; accept a wide
+  // band around 360 so a jagged coastline that overshoots/undershoots still counts.
+  var POLE_WINDING_TOLERANCE = 90;
+
+  // True if any source ring encircles a pole (spans the full longitude range and
+  // its longitudes wind a full turn). Cheap O(1) guards first: the dataset must
+  // reach the antimeridian, and only shapes spanning nearly the whole longitude
+  // range are exported to coordinates and winding-tested.
+  function sourceHasPoleEnclosingRing(lyr, dataset) {
+    if (!dataset.arcs) return false;
+    var b = dataset.arcs.getBounds();
+    if (b.xmin > -180 + 1e-6 && b.xmax < 180 - 1e-6) return false;
+    return (lyr.shapes || []).some(function(shape) {
+      if (!shape) return false;
+      var sb = dataset.arcs.getMultiShapeBounds(shape);
+      if (!sb || (sb.xmax - sb.xmin) < POLE_ENCLOSING_MIN_WIDTH) return false;
+      return getPolygonMultiPolygonCoords(shape, dataset.arcs).some(function(rings) {
+        return rings.some(function(ring) { return ringEnclosedPole(ring) !== 0; });
+      });
+    });
+  }
+
+  // Net signed longitude winding of a lng/lat ring (sum of per-edge longitude
+  // deltas, each unwrapped to (-180, 180]). A ring that encircles a pole winds
+  // +/-360; an ordinary ring (including one that merely straddles the antimeridian)
+  // winds 0.
+  function ringLngWinding(ring) {
+    var net = 0;
+    for (var i = 1; i < ring.length; i++) {
+      var d = ring[i][0] - ring[i - 1][0];
+      if (d > 180) d -= 360;
+      else if (d < -180) d += 360;
+      net += d;
+    }
+    return net;
+  }
+
+  // Returns the pole latitude (+90 or -90) a ring encircles, or 0 if it does not.
+  // The enclosed pole is the one in the ring's hemisphere: a pole-hugging coastline
+  // lies entirely to one side of the equator, so the mean vertex latitude picks the
+  // correct pole (and is robust to the ambiguous which-pole guess in
+  // removePolygonCrosses).
+  function ringEnclosedPole(ring) {
+    if (!ring || ring.length < 4) return 0;
+    if (Math.abs(Math.abs(ringLngWinding(ring)) - 360) > POLE_WINDING_TOLERANCE) return 0;
+    var sum = 0;
+    for (var i = 0; i < ring.length; i++) sum += ring[i][1];
+    return sum / ring.length < 0 ? -90 : 90;
+  }
+
+  // Close a pole-encircling ring by walking a floor along the enclosed pole line
+  // from the ring's antimeridian exit meridian back to its entry meridian, turning
+  // it into an ordinary closed polygon (the pole-touching-shell representation).
+  // Handles the common single-antimeridian-crossing case; returns null otherwise so
+  // the caller leaves the ring unchanged.
+  function closeRingThroughPole(ring, poleLat) {
+    if (countCrosses(ring) === 0) return null;
+    var parts = splitPathAtAntimeridian(ring);
+    if (parts.length !== 1) return null; // only the single-crossing case
+    var part = parts[0];
+    var startX = part[0][0];
+    var endX = part[part.length - 1][0];
+    if (Math.abs(startX) !== 180 || Math.abs(endX) !== 180 || startX === endX) {
+      return null;
+    }
+    var out = part.map(function(p) { return p.concat(); });
+    poleLineVertices(endX, startX, poleLat).forEach(function(p) { out.push(p); });
+    out.push(part[0].concat()); // close the ring
+    return out;
+  }
+
+  // Vertices tracing the pole line from fromX to toX (both +/-180) at poleLat, with
+  // an intermediate point at least every 45 degrees so no segment spans more than a
+  // quarter turn (long near-pole segments confuse the Mercator offset joins).
+  function poleLineVertices(fromX, toX, poleLat) {
+    var step = fromX > toX ? -45 : 45;
+    var pts = [[fromX, poleLat]];
+    var x = fromX;
+    while (Math.abs(x - toX) > 45 + 1e-9) {
+      x += step;
+      pts.push([x, poleLat]);
+    }
+    pts.push([toX, poleLat]);
+    return pts;
+  }
+
+  // Rebuild the target layer with pole floors inserted into pole-encircling rings,
+  // so the buffer's polar path can grow them. Preserves shape order/count (so the
+  // per-shape distance function and data table stay aligned) and the source CRS.
+  // Returns {layer, dataset} or null if no ring was actually normalized.
+  function buildPoleEnclosingNormalizedSource(lyr, dataset) {
+    var changed = false;
+    var features = (lyr.shapes || []).map(function(shape) {
+      var geom = null;
+      if (shape) {
+        var polys = getPolygonMultiPolygonCoords(shape, dataset.arcs).map(function(rings) {
+          return rings.map(function(ring) {
+            var poleLat = ringEnclosedPole(ring);
+            if (!poleLat) return ring;
+            var closed = closeRingThroughPole(ring, poleLat);
+            if (closed) { changed = true; return closed; }
+            return ring;
+          });
+        });
+        if (polys.length > 0) geom = {type: 'MultiPolygon', coordinates: polys};
+      }
+      return {type: 'Feature', properties: null, geometry: geom};
+    });
+    if (!changed) return null;
+    var normDataset = importGeoJSON({type: 'FeatureCollection', features: features},
+      {type: 'polygon'});
+    if (!normDataset.arcs) return null;
+    normDataset.info = Object.assign({}, dataset.info);
+    var normLyr = normDataset.layers[0];
+    normLyr.name = lyr.name;
+    if (lyr.data) normLyr.data = lyr.data.clone();
+    return {layer: normLyr, dataset: normDataset};
+  }
 
   // Buffer a polygon sliced at the antimeridian (lng +/-180) and/or a pole
   // (lat +/-90): build the offset (the pole-touching source rings are added back,
-  // see makePolygonBufferGeoJSON), dissolve, and clip to the world rectangle
-  // instead of wrapping at the antimeridian.
+  // see makePolygonBufferGeoJSON), dissolve, and constrain the result to the world
+  // rectangle. The overshoot past the antimeridian is handled one of two ways,
+  // depending on the source:
+  //
+  //  - A pole-abutting shape that does NOT span the antimeridian (e.g. a cap slice
+  //    reaching the pole from a limited range of longitudes) genuinely wraps when
+  //    grown: a fixed ground distance spans an unbounded longitude range as
+  //    latitude approaches +/-90, so the offset ring's near-pole corners swing all
+  //    the way across the antimeridian. That wrapped part is real coverage, so it
+  //    is folded back into [-180,180] by an antimeridian split; a plain world-rect
+  //    clip would discard it and drop the whole shape.
+  //
+  //  - A shape whose source already sits on the antimeridian seam (an
+  //    Antarctica-style shell spanning +/-180) only spills a thin band past the
+  //    seam, and that band is redundant -- the shell already covers those
+  //    longitudes -- so it is clipped off to keep the seam pinned to the extent.
+  //    Wrapping such a full-width ring instead mangles it (the near-global ring
+  //    reads as an antimeridian crossing and gets cut apart), so the split is
+  //    skipped for these.
   //
   // Only positive (grow) distances are supported. A negative (erode) buffer would
   // have to keep the artificial seam edges pinned to the extent while only the
@@ -48282,11 +48608,23 @@ ${svg}
       if (output.dissolveAfterSplit) {
         dissolveBufferDataset2(dataset2, opts);
       }
+      if (!sourceReachesAntimeridian(dataset)) {
+        splitAntimeridianBufferDataset(dataset2);
+      }
       clipDatasetToWorldRect(dataset2);
     }
     return dataset2;
   }
 
+  // True if the source geometry reaches the antimeridian (lng +/-180), i.e. it is
+  // an antimeridian-sliced shell whose seam edges the polar buffer should pin to
+  // the extent rather than wrap (see makePolarPolygonBuffer).
+  function sourceReachesAntimeridian(dataset) {
+    if (!dataset.arcs) return false;
+    var b = dataset.arcs.getBounds();
+    return b.xmin <= -180 + 1e-3 || b.xmax >= 180 - 1e-3;
+  }
+
   function polarBufferHasNegativeDistance(lyr, dataset, opts) {
     var distanceFn = getBufferDistanceFunction(lyr, dataset, opts);
     return (lyr.shapes || []).some(function(shape, i) {
@@ -48375,8 +48713,17 @@ ${svg}
   // Combine a buffer geometry with the source polygon's rings into one
   // MultiPolygon (overlapping); a later union dissolve merges them. Used by the
   // polar option to keep the polar interior that the pole-pinched ribbon drops.
+  //
+  // Only the source parts that actually reach a pole are appended. A multipolygon
+  // feature can mix a pole-touching part with mid-latitude parts (e.g. a lake-
+  // holed rectangle far from the pole in the same feature); those mid-latitude
+  // parts buffer correctly on their own, and re-injecting their source rings would
+  // override the eroded holes the offset construction already produced (the source
+  // holes come in at full, un-eroded size and win the union), leaving the holes
+  // unbuffered.
   function appendSourceRings(geom, shape, arcs) {
-    var sourceCoords = getPolygonMultiPolygonCoords(shape, arcs);
+    var sourceCoords = getPolygonMultiPolygonCoords(shape, arcs)
+      .filter(polyReachesPole);
     var coords = [];
     if (geom && geom.type == 'MultiPolygon') coords = coords.concat(geom.coordinates);
     else if (geom && geom.type == 'Polygon') coords.push(geom.coordinates);
@@ -48385,6 +48732,16 @@ ${svg}
     return {type: 'MultiPolygon', coordinates: coords};
   }
 
+  // True if any vertex of a MultiPolygon part (an array of [x,y] rings) sits at a
+  // pole (lat +/-90).
+  function polyReachesPole(poly) {
+    return poly.some(function(ring) {
+      return ring.some(function(p) {
+        return p[1] >= 90 - 1e-3 || p[1] <= -90 + 1e-3;
+      });
+    });
+  }
+
   function getPolygonRingBufferMaker(dataset, opts, side, winding) {
     // The band-method escape hatch forces the older non-winding construction even
     // for callers that request winding-fill (see the 'band-method' option).
@@ -55728,6 +56085,185 @@ ${svg}
     compiled(null, defs);
   };
 
+  cmd.densify = densifyCommandDataset;
+
+  // Add vertices along path segments so no segment is longer than an interval,
+  // interpolating along one of three paths:
+  //   geodesic (default for lat-long) - ellipsoidal shortest path
+  //   rhumb                           - constant bearing (loxodrome)
+  //   planar (default for projected)  - straight line in coordinate space
+  //
+  // interval= is a ground distance (with units, e.g. 100km) for geodesic/rhumb; for
+  // planar it is decimal degrees for lat-long data and coordinate units for
+  // projected data.
+  function densifyCommandDataset(dataset, opts, targetLayers) {
+    var crs = getDatasetCRS(dataset);
+    var spherical = isLatLngCRS(crs);
+    var mode = getDensifyMode(opts, spherical);
+    var interval = getDensifyInterval(opts, crs, mode, spherical);
+    var interpolate = getDensifyInterpolator(mode, crs);
+    var segmentLength = getSegmentLengthFunction(mode);
+    var targetSet = getTargetLayerSet(dataset, targetLayers);
+    // full-longitude edge detection only applies to lat-long data (projected
+    // coordinates routinely differ by more than 180 units)
+    var stats = spherical ? {undividedWideSegments: 0} : null;
+    var editor = new DatasetEditor(dataset);
+    dataset.layers.forEach(function(lyr) {
+      var densify = targetSet.indexOf(lyr) > -1 &&
+        (lyr.geometry_type == 'polygon' || lyr.geometry_type == 'polyline');
+      editor.editLayer(lyr, function(coords) {
+        if (lyr.geometry_type == 'point') return coords; // pass points through
+        return [densify ?
+          densifyPath(coords, interval, interpolate, segmentLength, stats) : coords];
+      });
+    });
+    editor.done();
+    if (stats && stats.undividedWideSegments > 0) {
+      message('Left ' + stats.undividedWideSegments + ' full-longitude edge(s) undivided; ' +
+        (mode == 'geodesic' ?
+          'geodesic interpolation can\'t subdivide an edge whose endpoints coincide on the globe -- use the rhumb or planar option.' :
+          'the endpoints coincide, so there is no path to interpolate along.'));
+    }
+  }
+
+  function getTargetLayerSet(dataset, targetLayers) {
+    return targetLayers && targetLayers.length ? targetLayers : dataset.layers;
+  }
+
+  function getDensifyMode(opts, spherical) {
+    var modes = ['geodesic', 'rhumb', 'planar'].filter(function(m) { return opts[m]; });
+    if (modes.length > 1) {
+      stop$1('Use only one of geodesic, rhumb or planar');
+    }
+    var mode = modes[0] || (spherical ? 'geodesic' : 'planar');
+    if (!spherical && mode != 'planar') {
+      stop$1('The ' + mode + ' option requires a lat-long dataset; use planar for projected data');
+    }
+    return mode;
+  }
+
+  function getDensifyInterval(opts, crs, mode, spherical) {
+    if (opts.interval === undefined) {
+      stop$1('Expected an interval= parameter');
+    }
+    var interval;
+    if (mode == 'planar' && spherical) {
+      // planar densification of lat-long data works in coordinate space, so the
+      // interval is in decimal degrees
+      interval = parseDegreeInterval(opts.interval);
+    } else if (mode == 'planar') {
+      // planar densification of projected data uses coordinate units
+      interval = convertIntervalParam(opts.interval, crs);
+    } else {
+      // geodesic/rhumb measure the interval as a ground distance in meters
+      interval = convertDistanceParam(opts.interval, crs);
+    }
+    if (interval > 0 === false) {
+      stop$1('Expected a positive interval, received:', opts.interval);
+    }
+    return interval;
+  }
+
+  // Parse a decimal-degrees interval: a bare number, or a number with an explicit
+  // degree unit (e.g. 5deg or 5°). Distance units (km, mi, ...) are rejected
+  // because planar interpolation of lat-long data measures the interval in
+  // coordinate (degree) space.
+  function parseDegreeInterval(opt) {
+    var str = String(opt).trim();
+    var match = /^(-?\d*\.?\d+)\s*(?:d|deg|degs|degree|degrees|°)?$/i.exec(str);
+    if (match) {
+      return Number(match[1]);
+    }
+    if (parseMeasure2(str).units) {
+      stop$1('Planar densification of a lat-long dataset uses decimal degrees; "' + opt +
+        '" has distance units -- use the geodesic or rhumb option for a ground distance.');
+    }
+    stop$1('Invalid interval:', opt);
+  }
+
+  function getDensifyInterpolator(mode, crs) {
+    if (mode == 'planar') {
+      return function(a, b, k) { return interpolatePoint2D(a[0], a[1], b[0], b[1], k); };
+    }
+    if (mode == 'rhumb') {
+      return interpolateRhumbPoint;
+    }
+    var geodesic = getInterpolationFunction(crs);
+    return function(a, b, k) { return geodesic(a[0], a[1], b[0], b[1], k); };
+  }
+
+  function getSegmentLengthFunction(mode) {
+    if (mode == 'planar') {
+      return function(a, b) {
+        return Math.sqrt((b[0] - a[0]) * (b[0] - a[0]) + (b[1] - a[1]) * (b[1] - a[1]));
+      };
+    }
+    if (mode == 'rhumb') {
+      return rhumbDistance;
+    }
+    return function(a, b) { return greatCircleDistance(a[0], a[1], b[0], b[1]); };
+  }
+
+  // Insert vertices so no segment exceeds the interval; endpoints are computed
+  // independently at even fractions so they land exactly on the interpolated path
+  // and no rounding drift accumulates.
+  function densifyPath(coords, interval, interpolate, segmentLength, stats) {
+    if (!coords || coords.length < 2) return coords;
+    var out = [coords[0]];
+    for (var i = 1; i < coords.length; i++) {
+      var a = coords[i - 1], b = coords[i];
+      var n = Math.ceil(segmentLength(a, b) / interval);
+      // A segment that spans a large longitude range but has ~zero length can't be
+      // subdivided by this mode (e.g. a -180 -> 180 edge has zero great-circle
+      // distance -- the endpoints are the same point on the globe).
+      if (n < 2 && stats && Math.abs(b[0] - a[0]) > 180) {
+        stats.undividedWideSegments++;
+      }
+      for (var j = 1; j < n; j++) {
+        var p = interpolate(a, b, j / n);
+        if (isFinite(p[0]) && isFinite(p[1])) out.push(p); // guard against degenerate math
+      }
+      out.push(b);
+    }
+    return out;
+  }
+
+  // Isometric ("Mercator-stretched") latitude in degrees-in; returns +/-Infinity at
+  // the poles.
+  function isometricLatitude(latDeg) {
+    return Math.log(Math.tan(Math.PI / 4 + latDeg * D2R$1 / 2));
+  }
+
+  // Rhumb-line (loxodrome) interpolation, fraction k of the way from A to B.
+  // Uses the RAW longitude delta so a -180 -> 180 edge fills the whole parallel
+  // (the constant-latitude case), rather than collapsing across the antimeridian.
+  function interpolateRhumbPoint(a, b, k) {
+    var lat1 = a[1], lat2 = b[1];
+    var dLng = b[0] - a[0]; // raw: preserves a full-longitude sweep
+    var lat = lat1 + (lat2 - lat1) * k; // rhumb distance is linear in latitude
+    var psi1 = isometricLatitude(lat1);
+    var psi2 = isometricLatitude(lat2);
+    // Longitude advances linearly with isometric latitude, except along a meridian
+    // (dLng == 0), a parallel (lat1 == lat2), or when an endpoint is at a pole
+    // (isometric latitude is infinite) -- in those cases longitude is linear in k
+    // (and the 0 * Infinity / Infinity would otherwise be NaN).
+    var lng = dLng !== 0 && isFinite(psi1) && isFinite(psi2) && psi2 !== psi1 ?
+      a[0] + dLng * (isometricLatitude(lat) - psi1) / (psi2 - psi1) :
+      a[0] + dLng * k;
+    return [lng, lat];
+  }
+
+  // Rhumb-line distance in meters, using the raw longitude delta (so a full-parallel
+  // sweep returns the parallel's length rather than 0).
+  function rhumbDistance(a, b) {
+    var phi1 = a[1] * D2R$1, phi2 = b[1] * D2R$1;
+    var dPhi = phi2 - phi1;
+    var dLambda = (b[0] - a[0]) * D2R$1; // raw
+    var dPsi = Math.log(Math.tan(Math.PI / 4 + phi2 / 2) / Math.tan(Math.PI / 4 + phi1 / 2));
+    var q = Math.abs(dPsi) > 1e-12 ? dPhi / dPsi : Math.cos(phi1);
+    return Math.sqrt(dPhi * dPhi + q * q * dLambda * dLambda) * R$3;
+  }
+
   // Variable name pattern. Matches simple identifiers: must start with a letter
   // or underscore, followed by letters, digits or underscores.
   var VAR_NAME_RXP = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -63609,6 +64145,14 @@ ${svg}
   //      -- whether a tight coastline or a gentle, hundreds-of-km graticule arc --
   //      never qualifies; only a localized kink, where the inner turn approaches
   //      the full turn, is a corner.
+  //   1b. (open paths) Also flag the end of a long straight run that turns sharply
+  //      over a single segment but only gently over the window -- a small jog where
+  //      a surveyed border meets a curve, which step 1's window would dilute below
+  //      the corner angle. Keyed off the raw segment turn, but the pinned vertex is
+  //      snapped to the nearby end of the straight run (stable under tiny vertex
+  //      moves) and only where that run's line is actually left (so an incidental
+  //      notch after which the run resumes on the same line is not flagged). See
+  //      straightRunEndNear.
   //   2. Between flagged corners, classify each span as "structural" if it is long
   //      relative to the tolerance and its curvature stays low (so a straight or
   //      slowly-curving graticule line counts, but sub-tolerance wiggle does not).
@@ -63651,14 +64195,18 @@ ${svg}
   // to count, which matches intuition (a 28 km stretch bending at radius 4 km is
   // obviously not straight). Genuinely curving coastline bows far from its chord
   // and is still rejected, so spurious corners inside wiggly stretches keep getting
-  // culled.
-  var STRAIGHT_DEV_FACTOR = 0.03;
+  // culled. Tightened from 0.03 to 0.02 (a run may curve ~9 deg over its length, not
+  // ~14) after a coastline island pinned corners at both ends of a ~10 deg-curving
+  // stretch that read as "straight" only under the looser corridor: an acute corner
+  // takes the full corridor regardless of the angle coupling below, so only the base
+  // factor governs whether such a run can anchor a sharp corner.
+  var STRAIGHT_DEV_FACTOR = 0.02;
 
   // Angle coupling for corner retention: how much sharper the corner must turn than
   // the run it borders already curves. A run that passes the chord test may still
   // bend gently within the STRAIGHT_DEV_FACTOR corridor -- for a circular arc the
-  // chord-deviation ratio is ~ (the run's total turn)/8, so the base 0.03 admits a
-  // run that curves ~14 deg over its length. Pinning a *gentle* bend at the end of
+  // chord-deviation ratio is ~ (the run's total turn)/8, so the base 0.02 admits a
+  // run that curves ~9 deg over its length. Pinning a *gentle* bend at the end of
   // such a run is unsafe: the "corner" is barely sharper than the run's own
   // curving, so it is really a point on a smooth bend, not a junction. (This is the
   // failure mode on coarsely sampled / already-simplified coastlines, where a
@@ -63669,7 +64217,7 @@ ${svg}
   //   turn >= PIN_TURN_RATIO * (8 * dev)  <=>  dev <= turn / (8 * PIN_TURN_RATIO).
   // retentionDevLimit() returns the smaller of STRAIGHT_DEV_FACTOR and
   // turn/(8*PIN_TURN_RATIO), so the coupling only bites for gentle corners (below
-  // ~2*STRAIGHT_DEV_FACTOR*PIN_TURN_RATIO ~ 69 deg); sharp corners (surveyed-border
+  // ~2*STRAIGHT_DEV_FACTOR*PIN_TURN_RATIO ~ 46 deg); sharp corners (surveyed-border
   // right angles, spits, hairpins) keep the full base tolerance, unchanged.
   var PIN_TURN_RATIO = 5;
 
@@ -63693,6 +64241,15 @@ ${svg}
   // old 1*tol behaviour for users who want shorter runs pinned.
   var MIN_PIN_RUN_LEN_FACTOR = 2.0;
 
+  // When a long straight run's end turns sharply into a curve with a small jog, the
+  // sharpest single-segment turn can land a few vertices past the run's actual end.
+  // straightRunEndNear searches back this many source vertices (in addition to the
+  // distance-scaled tangent window) to snap to the stable run end, so detection
+  // does not depend on the smoothing distance being large enough for the window to
+  // span the jog. A jog is a handful of vertices; this is deliberately generous
+  // because the search returns the nearest genuine run end (or nothing).
+  var MAX_JOG_VERTICES = 6;
+
   // Convert the user-facing corner-bias (0 = neutral) into the positive multiplier
   // k applied to corner-detection resolution (ctol = tol / k). The mapping is
   // symmetric about zero -- k(+b) * k(-b) = 1 -- and smooth there (both branches
@@ -63707,6 +64264,39 @@ ${svg}
     return b >= 0 ? b + 1 : 1 / (1 - b);
   }
 
+  // Ratio of (typical segment length / smoothing distance) at or below which corner
+  // detection sees several segments per tangent window and behaves normally, so no
+  // automatic coarsening is applied. Above it the window shrinks toward a single
+  // segment and ordinary coarse-data bends start reading as corners.
+  var AUTO_BIAS_RATIO = 0.15;
+  // Most-negative automatic bias. Caps how far detection is coarsened on very sparse
+  // geometry (e.g. lo-res contours), where the ratio can be many times AUTO_BIAS_RATIO
+  // but a handful of doublings already merges the whole neighbourhood.
+  var AUTO_BIAS_FLOOR = -4;
+
+  // Automatic corner-bias from the geometry's coarseness relative to the smoothing
+  // distance. @medianSeg is a robust (median) segment length; @dist is the raw
+  // smoothing distance, both in the same ground units. Corner detection keys off a
+  // tangent window ~0.3*dist wide; when the typical segment is an appreciable
+  // fraction of the distance (ratio r = medianSeg/dist above AUTO_BIAS_RATIO) that
+  // window spans too few segments and gentle-but-coarse bends read as corners. We
+  // return a negative bias that coarsens detection (as if the distance were larger)
+  // enough to push the effective ratio back down: each halving of the effective
+  // resolution costs one bias step, so bias = -log2(r / AUTO_BIAS_RATIO), floored.
+  // Returns 0 (no adjustment) when the geometry is fine relative to the distance,
+  // which is the normal case for detailed datasets smoothed at a real distance.
+  // Note it only ever coarsens: a straight run that genuinely anchors a sharp corner
+  // survives this (the corner is retained by bordering a long straight run, which
+  // coarsening does not remove until it exceeds the run's length), while weakly
+  // supported bends on coarse coastlines/contours fall below the corner threshold.
+  function autoCornerBias(medianSeg, dist) {
+    if (!(medianSeg > 0) || !(dist > 0)) return 0;
+    var r = medianSeg / dist;
+    if (r <= AUTO_BIAS_RATIO) return 0;
+    var b = -Math.log2(r / AUTO_BIAS_RATIO);
+    return b < AUTO_BIAS_FLOOR ? AUTO_BIAS_FLOOR : b;
+  }
+
   // @cornerBias (optional, default 0 = neutral) scales only the distance-
   // proportional corner parameters, by dividing the tolerance they key off
   // (ctol = tol / k, k = cornerBiasScale(bias)). The dimensionless thresholds are
@@ -63763,9 +64353,107 @@ ${svg}
       if (inner[j] < params.concentration * turns[j]) continue;
       if (isLocalMaxTurn(t, turns, j, W, L, m, lo, hi, cyclic)) corners.push(j);
     }
+    // Open paths: also flag the terminal vertex of a long straight run that bends
+    // sharply over a single segment but only gently over the tangent window -- e.g.
+    // where a surveyed border meets a coastline with a small jog. The windowed test
+    // above misses these because the wide window dilutes the sharp segment turn into
+    // a sub-threshold bend, so the straight run's end gets rounded into the adjacent
+    // curve. Here we key off the raw segment turn instead, but confine this rescue
+    // to a genuine straight-run end with two gates (plus straightRunEndNear):
+    //   1. the turn is fully concentrated in the inner window: inner-window turn >=
+    //      full-window turn. This is a stricter form of the windowed path's
+    //      concentration test (>= concentration * full) and is the crux of the
+    //      distinction. At a straight-run end the approaches carry ~no turning, so
+    //      the whole window's turn sits in the inner window (ratio >= 1); on a
+    //      steadily-curving coastline the turning is spread across the window (inner
+    //      < full), so a lone sharp segment there is rejected. The wide window
+    //      dilutes the end's departure below the corner threshold (which is why the
+    //      windowed path misses it), but the concentration ratio stays high.
+    //   2. (via straightRunEndNear) a bordering straight run's line is actually left,
+    //      so an incidental notch on an otherwise-continuing run is not pinned.
+    // Rings keep the windowed-only detection for now.
+    if (!cyclic) {
+      var raw = new Float64Array(m);
+      for (i = lo; i < hi; i++) raw[i] = vertexTurn(channels, K, i);
+      for (j = lo; j < hi; j++) {
+        if (raw[j] < params.cornerAngle) continue;
+        if (inner[j] < turns[j]) continue;
+        if (!isLocalMaxTurn(t, raw, j, W, L, m, lo, hi, cyclic)) continue;
+        var e = straightRunEndNear(t, channels, n, j, W, params);
+        if (e >= 0 && corners.indexOf(e) === -1) corners.push(e);
+      }
+      corners.sort(function (a, b) { return a - b; });
+    }
     return corners;
   }
 
+  // Given a sharp single-segment turn at open-path vertex @j, find the end of a
+  // long straight run that the path leaves, within arc length @W of @j, and return
+  // that run-end vertex to pin (or -1). We search a neighbourhood rather than
+  // requiring the run's last vertex to be exactly where the segment turn peaks: a
+  // jog into a curve can place its sharpest vertex a step or two past the run's
+  // end, and exactly which vertex is sharpest is sensitive to tiny differences in
+  // vertex placement -- but the straight run's end itself is stable. Snapping to it
+  // keeps detection from flickering on and off with sub-tolerance vertex moves. The
+  // straightRunLeaves test only succeeds at a genuine run end whose continuation
+  // departs, so an incidental jog after which the run resumes is still not pinned.
+  function straightRunEndNear(t, channels, n, j, W, params) {
+    var e, k;
+    // The jog between the sharp turn and the run's end is a fixed handful of source
+    // vertices, independent of the smoothing distance -- so the search extends by a
+    // vertex count as well as the distance-scaled window W. Without the vertex floor
+    // the window shrinks with the distance and, at small distances, can no longer
+    // reach back across the jog to the run end (fewer, not more, corners pinned as
+    // the distance drops -- the opposite of what a long run warrants). We return the
+    // first (nearest) run end found, so a generous reach only costs a few extra
+    // straightRunLeaves checks when there is nothing to pin.
+    for (e = j, k = 0; e >= 1; e--, k++) {
+      if (t[j] - t[e] > W && k > MAX_JOG_VERTICES) break;
+      if (straightRunLeaves(t, channels, n, e, -1, params) ||
+          straightRunLeaves(t, channels, n, e, 1, params)) return e;
+    }
+    for (e = j + 1, k = 1; e < n - 1; e++, k++) {
+      if (t[e] - t[j] > W && k > MAX_JOG_VERTICES) break;
+      if (straightRunLeaves(t, channels, n, e, -1, params) ||
+          straightRunLeaves(t, channels, n, e, 1, params)) return e;
+    }
+    return -1;
+  }
+
+  // Is the near side of @e (walking direction @dir: -1 = run precedes e, +1 = run
+  // follows e) a long straight run, AND does the far side leave that run's line --
+  // i.e. a point a full run-length along the far side sits outside the run's
+  // straightness corridor? A jog that rejoins the run returns to ~0 perpendicular
+  // offset and fails this, so it is not flagged. (This also implies @e is the run's
+  // end: if the run continued straight past @e, the far point would stay on its
+  // line.)
+  function straightRunLeaves(t, channels, n, e, dir, params) {
+    var K = channels.length, L = t[n - 1];
+    var nearEnd = reach(t, n, n, L, e, dir, params.minPinRunLen, false);
+    if (nearEnd === e) return false;
+    var a = dir < 0 ? nearEnd : e;
+    var b = dir < 0 ? e : nearEnd;
+    // Require the near run to be straight to the SAME angle-coupled tolerance
+    // retention will demand of a pin at @e (retentionDevLimit of the turn at @e),
+    // not the looser default corridor. This makes straightRunEndNear's backward
+    // scan stop at the run's true end -- the last vertex actually on the run's line
+    // -- rather than a vertex a little past it that squeaks inside the loose 3%
+    // corridor but would then be culled by retention (leaving nothing pinned).
+    var devLim = retentionDevLimit(cornerTurn(t, channels, n, e, false, params));
+    if (!isStraightRun(t, channels, a, b, params, devLim)) return false;
+    var farEnd = reach(t, n, n, L, e, -dir, params.minPinRunLen, false);
+    if (farEnd === e) return false;
+    var pe = getPt(channels, K, e);
+    var u = subv(getPt(channels, K, nearEnd), pe, K); // direction along the near run
+    var uu = dot(u, u, K);
+    if (!(uu > 0)) return false;
+    var af = subv(getPt(channels, K, farEnd), pe, K);
+    var along = Math.abs(dot(af, u, K)) / Math.sqrt(uu);
+    var perp = Math.sqrt(perpDistSq(channels, K, farEnd, pe, u, uu));
+    // outside the straight corridor extended from the run -> the path has left it
+    return perp > STRAIGHT_DEV_FACTOR * along;
+  }
+
   // Is span [a, b] (inclusive vertex indices, a < b, open frame) a structural run:
   // long relative to the tolerance and low-curvature throughout?
   function isStructuralRun(t, channels, a, b, params) {
@@ -64139,6 +64827,20 @@ ${svg}
                                       // segments); user-overridable via max-bend-angle
   var DEVIATION_FACTOR = 0.1;         // sagitta guard: also cut a gentle bend that bows
                                       // more than tolerance * this from its chord
+  // Preserved structural runs (long straight / low-curvature spans between pinned
+  // corners) are not smoothed, but their ORIGINAL vertices are resampled with the
+  // same bend-angle decimation so the whole output has adaptive vertex spacing
+  // (no abrupt density seam at a run boundary). The decimation runs in the
+  // smoothing channels, so for unprojected data a long line -- which curves in the
+  // geocentric x,y,z space even when it is "straight" in lng/lat -- keeps enough
+  // interior vertices to approximate that curve on reprojection, scaling with the
+  // line's length automatically. Because it only ever keeps a SUBSET of the
+  // original vertices (never interpolates new ones), it can't distort a rhumb or
+  // geodesic edge -- every output vertex still lies exactly where the source drew
+  // it. Structural runs use a fraction of the bend angle (sampled finer than
+  // smoothed spans) as a conservative bias toward preservation / reprojection
+  // headroom.
+  var STRUCTURAL_BEND_FACTOR = 0.5;   // structural-run bend angle = max-bend-angle * this
 
   // Smooth a single arc's coordinates.
   // @xx, @yy: coordinate arrays (may be typed-array subarrays) for one arc.
@@ -64147,8 +64849,9 @@ ${svg}
   // arcs are preserved exactly (so shared topology nodes stay put); closed arcs
   // are smoothed cyclically and returned closed (first point repeated at the end).
   // With keepCorners, structural corners (where long straight/low-curvature runs
-  // meet) are detected and pinned, and the runs themselves are kept verbatim;
-  // only the spans between corners are smoothed.
+  // meet) are detected and pinned; the runs themselves are not smoothed but are
+  // resampled (a subset of their original vertices, at adaptive spacing), and only
+  // the spans between corners are smoothed.
   // Resolve the curvature-correction gain (default 1 = fully corrected). gain=0
   // leaves the plain weighted moving average; negative values are clamped to 0.
   function resolveGain(opts) {
@@ -64198,7 +64901,7 @@ ${svg}
     var origY = toArray(yy);
     var tol = opts.tolerance * KERNEL_FROM_DISTANCE;
     if (n < 3 || !(opts.tolerance > 0)) {
-      return {xx: origX, yy: origY};
+      return {xx: origX, yy: origY, corners: 0};
     }
     var method = opts.method == 'gaussian' ? 'gaussian' : 'paek';
     var closed = !!opts.closed;
@@ -64210,7 +64913,7 @@ ${svg}
     // kernel scale stays in true distance regardless of coordinate representation.
     var t = arcLengths(origX, origY, n, spherical);
     if (!(t[n - 1] > 0)) {
-      return {xx: origX, yy: origY}; // degenerate (coincident points)
+      return {xx: origX, yy: origY, corners: 0}; // degenerate (coincident points)
     }
     // The low-pass kernel scale is the raw distance scale (tol) times the baked-in
     // KERNEL_STRENGTH calibration and the user's `strength` multiplier (default 1).
@@ -64260,7 +64963,9 @@ ${svg}
         corners = filterRingCornersByStructure(t, channels, n, corners, ringParams);
       }
       if (corners.length === 0) {
-        return smoothClosedCyclic(t, channels, n, ctx);
+        var cyc = smoothClosedCyclic(t, channels, n, ctx);
+        cyc.corners = 0;
+        return cyc;
       }
       // A ring with corners is processed as an open path: rotate it to start (and
       // end) at one corner, with the remaining corners as interior breakpoints.
@@ -64271,7 +64976,11 @@ ${svg}
       t = arcLengths(origX, origY, n, spherical);
       channels = spherical ? lngLatToXYZChannels(origX, origY, n) : [origX, origY];
       var breaks = mapRotatedCorners(corners, rot.shift, rot.m);
-      return smoothOpenSpans(origX, origY, t, channels, n, breaks, ctx);
+      var ring = smoothOpenSpans(origX, origY, t, channels, n, breaks, ctx);
+      // The ring seam (corners[0], pinned as the rotated start/end) is itself a
+      // preserved corner, on top of the interior breakpoints smoothOpenSpans kept.
+      ring.corners += 1;
+      return ring;
     }
 
     var openBreaks = keepCorners ?
@@ -64304,11 +65013,12 @@ ${svg}
       var lo = bounds[s], hi = bounds[s + 1];
       var preserve = !!params && isStructuralRun(t, channels, lo, hi, params);
       var span = preserve ?
-        copySpan(origX, origY, lo, hi) :
+        resampleStructuralRun(origX, origY, channels, lo, hi, ctx) :
         smoothSpanOpen(origX, origY, t, channels, lo, hi, ctx);
       appendSpan(xx, yy, span, s === 0);
     }
-    return {xx: xx, yy: yy};
+    // Interior breakpoints that survived refinement are the pinned corners.
+    return {xx: xx, yy: yy, corners: bounds.length - 2};
   }
 
   // Drop interior breakpoints that don't border any pinnable straight run (e.g.
@@ -64534,6 +65244,34 @@ ${svg}
     return {xx: xx, yy: yy};
   }
 
+  // Resample a preserved structural run [lo, hi] (a long straight / low-curvature
+  // span between pinned corners). The run is NOT smoothed: its shape is kept by
+  // emitting a SUBSET of its original vertices, decimated with the shared
+  // bend-angle filter in the smoothing channels (so a long line that curves in the
+  // geocentric space keeps interior vertices scaling with its length -- see
+  // STRUCTURAL_BEND_FACTOR). Both endpoints are always kept, at their exact
+  // original coordinates, so pinned corners and shared topology nodes are
+  // unchanged. A run too short to decimate is copied verbatim.
+  function resampleStructuralRun(origX, origY, channels, lo, hi, ctx) {
+    var nSub = hi - lo + 1;
+    if (nSub < 3) return copySpan(origX, origY, lo, hi);
+    var K = channels.length;
+    var P = new Array(nSub);
+    for (var i = 0; i < nSub; i++) {
+      var p = new Array(K);
+      for (var c = 0; c < K; c++) p[c] = channels[c][lo + i];
+      P[i] = p;
+    }
+    var keep = decimateByBend(P, K, ctx.bendAngle * STRUCTURAL_BEND_FACTOR, ctx.tol * DEVIATION_FACTOR);
+    var xx = [], yy = [];
+    for (var ki = 0; ki < keep.length; ki++) {
+      var idx = lo + keep[ki];
+      xx.push(origX[idx]); // exact original coordinate, never interpolated
+      yy.push(origY[idx]);
+    }
+    return {xx: xx, yy: yy};
+  }
+
   function appendSpan(xx, yy, span, isFirst) {
     for (var i = isFirst ? 0 : 1; i < span.xx.length; i++) {
       xx.push(span.xx[i]);
@@ -64658,26 +65396,38 @@ ${svg}
     }
 
     // 2. one-pass bend-angle filter
-    var theta = ctx.bendAngle;
-    var epsDev = ctx.tol * DEVIATION_FACTOR;
+    var keep = decimateByBend(P, K, ctx.bendAngle, ctx.tol * DEVIATION_FACTOR);
     var out = [];
     for (var c = 0; c < K; c++) out.push([]);
-    appendPoint(out, P[0], K);
+    for (var ki = 0; ki < keep.length; ki++) appendPoint(out, P[keep[ki]], K);
+    return out;
+  }
+
+  // One-pass forward decimation of a K-channel point list @P: keep the two
+  // endpoints plus every interior point where the turn accumulated since the last
+  // kept point reaches @theta, or where the estimated sagitta of the skipped
+  // stretch (chord * accumulated turn / 8, the bow of a circular arc) reaches
+  // @epsDev. Bounds the angle between consecutive kept segments by construction, so
+  // joins stay smooth. Returns the kept indices into @P (always including 0 and the
+  // last index). Shared by the smoothed-curve resampler and the structural-run
+  // resampler (see resampleStructuralRun).
+  function decimateByBend(P, K, theta, epsDev) {
+    var n = P.length;
+    var keep = [0];
+    if (n < 2) return keep;
     var anchor = 0;     // last kept vertex
     var accTurn = 0;    // absolute turning accumulated since the anchor
-    for (var j = 1; j < nDense - 1; j++) {
+    for (var j = 1; j < n - 1; j++) {
       accTurn += vecAngle(P[j - 1], P[j], P[j], P[j + 1], K);
-      // sagitta of a circular arc of chord c and total turn a is ~ c*a/8; cut a
-      // long gentle bend before it bows more than epsDev from its chord
       var sagitta = chordLen(P[anchor], P[j + 1], K) * accTurn * 0.125;
       if (accTurn >= theta || sagitta >= epsDev) {
-        appendPoint(out, P[j], K);
+        keep.push(j);
         anchor = j;
         accTurn = 0;
       }
     }
-    appendPoint(out, P[nDense - 1], K);
-    return out;
+    keep.push(n - 1);
+    return keep;
   }
 
   // Angle (radians) between vectors (b - a) and (d - c) over K channels.
@@ -64998,16 +65748,32 @@ ${svg}
       }
     }
 
-    smoothPaths(arcs, {
+    // Corner detection is automatically coarsened on geometry that is sparse
+    // relative to the smoothing distance (long segments -> few segments per
+    // detection window -> ordinary coarse bends misread as corners; see
+    // autoCornerBias). The user's corner-bias is relative to this automatic base:
+    // it is added on top, so corner-bias=0 (the default) is "whatever the geometry
+    // warrants", a positive value finds more corners than the auto baseline, a
+    // negative value fewer.
+    var autoBias = 0;
+    if (keepCorners) {
+      autoBias = autoCornerBias(medianSegmentLength(arcs, spherical), tolerance);
+    }
+    var effectiveCornerBias = autoBias + (opts.corner_bias || 0);
+
+    var corners = smoothPaths(arcs, {
       tolerance: tolerance,
       method: method,
       spherical: spherical,
       keepCorners: keepCorners,
-      cornerBias: opts.corner_bias,
+      cornerBias: effectiveCornerBias,
       gain: opts.gain,
       strength: opts.strength,
       maxBendAngle: opts.max_bend_angle
     });
+    if (keepCorners && corners > 0) {
+      message('Pinned ' + corners + ' corner' + utils.pluralSuffix(corners));
+    }
 
     if (implicitlySmoothedNames.length > 0) {
       message(
@@ -65021,10 +65787,12 @@ ${svg}
   // untouched, shared polygon boundaries stay coincident and topology is
   // preserved; updateVertexData() also handles undo capture and resets stale
   // simplification thresholds.
+  // Returns the total number of structural corners preserved across all arcs.
   function smoothPaths(arcs, opts) {
     var nn = [];
     var xx = [];
     var yy = [];
+    var corners = 0;
     var i, k, res;
     arcs.forEach3(function(axx, ayy, azz, arcId) {
       res = smoothArcCoords(axx, ayy, {
@@ -65038,6 +65806,7 @@ ${svg}
         maxBendAngle: opts.maxBendAngle,
         closed: arcs.arcIsClosed(arcId)
       });
+      corners += res.corners || 0;
       nn.push(res.xx.length);
       for (i = 0, k = res.xx.length; i < k; i++) {
         xx.push(res.xx[i]);
@@ -65045,6 +65814,31 @@ ${svg}
       }
     });
     arcs.updateVertexData(nn, xx, yy);
+    return corners;
+  }
+
+  // Median segment length across all arcs, in ground units (meters for spherical
+  // data), used to gauge how coarse the geometry is relative to the smoothing
+  // distance (see autoCornerBias). The median is robust to a few very long straight
+  // segments (which are not a spurious-corner risk) and to dense sub-scale detail.
+  // Very large datasets are sampled with a stride so the cost stays bounded.
+  function medianSegmentLength(arcs, spherical) {
+    var totalSegs = arcs.getPointCount() - arcs.size();
+    if (totalSegs < 1) return 0;
+    var MAX_SAMPLES = 100000;
+    var stride = Math.ceil(totalSegs / MAX_SAMPLES);
+    var distFn = spherical ? greatCircleDistance : distance2D;
+    var lens = [];
+    var counter = 0;
+    arcs.forEach3(function(xx, yy) {
+      for (var i = 1, n = xx.length; i < n; i++) {
+        if (counter++ % stride === 0) {
+          lens.push(distFn(xx[i - 1], yy[i - 1], xx[i], yy[i]));
+        }
+      }
+    });
+    if (lens.length === 0) return 0;
+    return utils.findMedian(lens);
   }
 
   function getSmoothMethod(opts) {
@@ -66512,6 +67306,9 @@ ${svg}
       } else if (name == 'define') {
         cmd.define(job.catalog, opts);
 
+      } else if (name == 'densify') {
+        cmd.densify(targetDataset, opts, targetLayers);
+
       } else if (name == 'vars') {
         cmd.vars(job, opts);
 
@@ -66852,7 +67649,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.37";
+  var version = "0.7.39";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.