mapshaper 0.7.34 → 0.7.36

package/mapshaper.js

@@ -31959,12 +31959,12 @@ ${svg}
         type: 'flag'
       })
       .option('coarse-bridge', {
-        // Undocumented: in the clean-outline-winding construction, bridge concave
-        // bends with the low-resolution makeCoarseConcaveJoin (as few as one
-        // reversed arc vertex) instead of the full-resolution makeConcaveJoin.
-        // The reversed bridge only bounds a self-overlap loop the direction remover
-        // collapses, so this leaves the final boundary unchanged while producing a
-        // smaller ring for the winding dissolve -- a construction-speed tradeoff.
+        // Undocumented: force the low-resolution concave bridge at EVERY deep
+        // concave bend, bypassing the default's exposure gate and the loop
+        // remover's clip budget. The guarded form is the default (2026-07-02);
+        // this unguarded form is faster still but NOT area-safe: an exposed
+        // bridge can dent the buffer or create spurious holes (see the caution
+        // at makeCoarseConcaveJoin and "coarse-bridge" in buffer-line-notes.md).
         type: 'flag'
       })
       .option('no-gap-patch', {
@@ -32519,6 +32519,14 @@ ${svg}
         type: 'number',
         describe: 'Visvalingam angle-weight coefficient (default 0.7); higher removes spiky detail more eagerly'
       })
+      .option('roundness', {
+        type: 'number',
+        describe: 'protect rounded loops: min enclosed-area / loop-perimeter as a fraction of the distance (default 0.2); higher removes more, 0 disables'
+      })
+      .option('min-area', {
+        type: 'number',
+        describe: 'drop a closed ring (island/hole) when the filter leaves less than this fraction of its original area (default 0.6); 0 disables'
+      })
       .option('planar', {
         describe: 'treat decimal degree coords as planar x,y (default is spherical)',
         type: 'flag'
@@ -33052,6 +33060,13 @@ ${svg}
         describe: 'shrinkage-correction (default 1; 0 = none, >1 exaggerates bends)',
         type: 'number'
       })
+      .option('strength', {
+        // undocumented: multiplier on the smoothing kernel scale relative to the
+        // distance (default 1; >1 smooths more strongly with larger divergence from
+        // the original, <1 more gently). Scales only the low-pass kernel -- corner
+        // detection, prefiltering and island dropping stay keyed to the raw distance.
+        type: 'number'
+      })
       .option('max-bend-angle', {
         describe: 'max bend between output segments in degrees (default is 8)',
         type: 'number'
@@ -33061,10 +33076,15 @@ ${svg}
         type: 'flag'
       })
       .option('corner-bias', {
-        // undocumented: corner-preservation sensitivity (default 1). Its inverse
-        // scales the min structural-run length, so corner-bias=0.5 doubles it (fewer
-        // corners kept) and corner-bias=2 halves it (more corners kept).
-        // corner-bias=0 turns corner preservation off entirely.
+        // 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)',
         type: 'number'
       })
       .option('prefilter-gate', {
@@ -33072,6 +33092,19 @@ ${svg}
         // intricate detail (default 4; higher removes less)
         type: 'number'
       })
+      .option('prefilter-roundness', {
+        // undocumented: prefilter roundness protection -- min enclosed-area /
+        // loop-perimeter (as a fraction of the smoothing distance) for a loop
+        // (e.g. an island) to be protected from the prefilter (default 0.2;
+        // higher removes more, 0 disables and lets rounded islands collapse)
+        type: 'number'
+      })
+      .option('prefilter-min-area', {
+        // undocumented: drop a closed ring (island/hole) when the prefilter would
+        // leave less than this fraction of its original area (default 0.6), rather
+        // than smoothing a distorted remnant; 0 disables the drop
+        type: 'number'
+      })
       .option('planar', {
         // describe: 'smooth decimal degree coords in 2D space (default is spherical)',
         type: 'flag'
@@ -42059,17 +42092,15 @@ ${svg}
     return turnPrefix[posHi] - turnPrefix[posLo];
   }
 
-  // Multi-pass collapse gated by the offset ring's own cumulative absolute turn over the collapsed span, a
-  // provenance-free proxy for the source-path turn gate (each offset join's turn
-  // angle equals the source bend angle it derives from, and straight offset
-  // segments contribute zero turn, so summing |turn| over a ring span with no cap
-  // reconstructs the source stretch's cumulative turn). Iterating lets the
-  // collapse of tight inner overshoot loops shorten the spans of the loops that
-  // wrap them, so a wrapper that was too-large-turn on one pass can become a
-  // single-bend covered overshoot on the next -- the multi-pass "peel simple
-  // interior loops first" idea. maxTurn is the same gate constant as the source
-  // turn gate; caps (180-degree arcs) exceed it and so are never collapsed.
-  // @fillFloor (dip+coverage path): max winding-0 area a collapse may swallow; a
+  // Multi-pass collapse. Iterating lets the collapse of tight inner overshoot
+  // loops shorten the spans of the loops that wrap them, so a wrapper whose span
+  // was too long (or too-large-turn, on the gated paths) on one pass can become
+  // collapsible on the next -- the multi-pass "peel simple interior loops first"
+  // idea. With dipTags supplied (clean-outline rings; the tags act as a flag,
+  // see below) each candidate is decided by the exact coverage check plus the
+  // opposite-wound hole guard; otherwise the source-turn or geometric turn gate
+  // applies (maxTurn; caps' 180-degree arcs exceed it and are never collapsed).
+  // @fillFloor (coverage path): max winding-0 area a collapse may swallow; a
   // collapse filling a larger hole/notch is refused (see BUFFER_LOOP_FILL_AREA_FRAC).
   // Callers pass dist^2 * BUFFER_LOOP_FILL_AREA_FRAC; defaults to the uncovered
   // floor when omitted (unit tests without a buffer distance).
@@ -42078,11 +42109,32 @@ ${svg}
     if (maxTurn === undefined) maxTurn = BUFFER_LOOP_MAX_TURN;
     if (!(maxPasses >= 1)) maxPasses = 12;
     if (!(fillFloor >= 0)) fillFloor = BUFFER_LOOP_CHECK_MIN_AREA;
-    var work = ring, workPos = null, workTags = dipTags || null;
+    // dipTags acts purely as a flag here: a ring built by the clean-outline
+    // construction opts into the coverage-checked path. The per-vertex tag
+    // values are not consulted (the tag-excluded turn gate was removed in favor
+    // of the exact coverage check), so the tags are not threaded through passes.
+    var coverage = !!dipTags;
+    // Neighborhood clip budget, shared by all passes over this ring: each
+    // accepted collapse's uncovered (clipped) area accumulates in a coarse
+    // grid, and an accept that would push any touched cell past the per-collapse
+    // floor is refused instead. Individually sub-floor clips are the design's
+    // tolerance, but several of them can land in the SAME neighborhood (dense
+    // fold clusters -- routine with coarse bridge geometry, theoretically
+    // possible with overlapping same-pass collapses) and compound into a
+    // floor-scale dent; the budget bounds the damage per neighborhood to the
+    // same floor that bounds it per collapse.
+    // Cell size scales with the buffer radius (recovered from the disk-relative
+    // fillFloor) so a neighborhood is radius-scale at any latitude/units; clip
+    // attribution is O(1) per accept (center cell), so a dent straddling a cell
+    // edge is bounded by 2x the floor rather than 1x.
+    var budgetCell = Math.max(1000, Math.sqrt(fillFloor / BUFFER_LOOP_FILL_AREA_FRAC));
+    var clipBudget = coverage ? {map: new Map(), cell: budgetCell} : null;
+    var work = ring, workPos = null;
     for (var pass = 0; pass < maxPasses; pass++) {
-      var res = collapseRingLoopsPass(work, maxGap, workPos, turnPrefix, maxTurn, workTags, fillFloor);
+      var res = collapseRingLoopsPass(work, maxGap, workPos, turnPrefix, maxTurn,
+        coverage, fillFloor, clipBudget);
       if (res.ring.length === work.length) return res.ring; // stable
-      work = res.ring; workPos = res.srcPos; workTags = res.dipTags;
+      work = res.ring; workPos = res.srcPos;
     }
     return work;
   }
@@ -42090,38 +42142,25 @@ ${svg}
   // One greedy forward-collapse pass (mirrors removeBufferRingLoops' compaction).
   // The span gate is, in order of preference:
   //   - the reliable source-path turn (getSpanTurn) when srcPos+turnPrefix given;
-  //   - else the ring's cumulative turn with tagged fold cusps excluded, when
-  //     dipTags (construction-tagged reversed concave-join arcs) are supplied;
-  //   - else the same but with a geometric cusp threshold (no provenance).
-  // Returns {ring, srcPos, dipTags} so the caller can iterate.
-  function collapseRingLoopsPass(ring, maxGap, srcPos, turnPrefix, maxTurn, dipTags, fillFloor) {
+  //   - else the exact coverage check when `coverage` is set (clean-outline rings);
+  //   - else the ring's cumulative turn with a geometric cusp threshold.
+  // Returns {ring, srcPos} so the caller can iterate.
+  function collapseRingLoopsPass(ring, maxGap, srcPos, turnPrefix, maxTurn, coverage, fillFloor, clipBudget) {
     var gated = !!(srcPos && turnPrefix);
     var n = ring.length - 1;
-    // The dip path defers entirely to the exact coverage check, so it needs neither
-    // the tag-excluded turn gate nor its cumulative-turn prefix; the other two paths
+    // The coverage path defers entirely to the exact coverage check, so it needs
+    // neither a turn gate nor a cumulative-turn prefix; the other two paths
     // (source-turn, geometric) have no coverage check and keep the turn gate.
-    var coveragePath = !gated && !!dipTags;
-    var ringTurn = (!gated && !dipTags) ? ringAbsTurnPrefix(ring, dipTags) : null;
-    // Build the ring's y-band edge index once per pass so the coverage check's
-    // per-loop edge lookup is local rather than O(ring length).
-    var covIndex = coveragePath ? buildEdgeYIndex(ring, n) : null;
-    // Opposite-wound hole protection. The coverage check only guards against
-    // UNCOVERING area, so it cannot catch a collapse that FILLS a real winding-0
-    // hole (filling adds coverage), and its area pre-filter treats any sub-floor
-    // loop as safe to drop. A dropped sub-loop wound OPPOSITE to the parent ring
-    // bounds such a hole, so refuse the collapse outright -- this keeps real holes
-    // (annulus interiors, self-crossing-line pockets) the coverage check alone
-    // misses, at the cost of only an O(span) signed-area test on the crossings the
-    // collapse actually evaluates (far cheaper than the old O(n*maxGap) per-pass
-    // pre-scan). A same-wound overshoot fold that happens to WRAP a hole is caught
-    // instead by the fill guard in the coverage check (it measures filled area).
-    var parentCCW = coveragePath ? (ringSignedArea(ring) >= 0) : false;
+    var ringTurn = (!gated && !coverage) ? ringAbsTurnPrefix(ring) : null;
+    // The y-band edge index and the parent orientation are built lazily, on the
+    // first candidate that survives to the coverage check: most rings (and most
+    // passes) never get that far, and both are O(ring length) to compute.
+    var covIndex = null;
+    var parentCCW = false, parentKnown = false;
     var out = [ring[0]];
     var outPos = gated ? [srcPos[0]] : null;
-    var outTags = dipTags ? [dipTags[0]] : null;
     var segmentEnd = ring[1];
     var segmentEndPos = gated ? srcPos[1] : 0;
-    var segmentEndTag = dipTags ? dipTags[1] : 0;
     var nextRingIndex = 2;
     while (true) {
       var anchor = out[out.length - 1];
@@ -42133,22 +42172,34 @@ ${svg}
         var c = ring[s], d = ring[s + 1];
         var hit = segHit(ax, ay, bx, by, c[0], c[1], d[0], d[1]);
         if (!hit) continue;
-        if (coveragePath) {
-          // Never collapse a sub-loop wound opposite to the parent: it bounds a
-          // real winding-0 hole the coverage check cannot see being filled (see the
-          // hole-protection note above).
+        if (coverage) {
+          // Opposite-wound hole protection. The coverage check only guards against
+          // UNCOVERING area, so it cannot catch a collapse that FILLS a real
+          // winding-0 hole (filling adds coverage), and its area pre-filter treats
+          // any sub-floor loop as safe to drop. A dropped sub-loop wound OPPOSITE
+          // to the parent ring bounds such a hole, so refuse the collapse outright
+          // -- this keeps real holes (annulus interiors, self-crossing-line
+          // pockets) the coverage check alone misses, at the cost of only an
+          // O(span) signed-area test on the crossings the collapse actually
+          // evaluates. A same-wound overshoot fold that happens to WRAP a hole is
+          // caught instead by the fill guard in the coverage check.
+          if (!parentKnown) {
+            parentCCW = ringSignedArea(ring) >= 0;
+            parentKnown = true;
+          }
           if ((loopAreaSign(hit[0], hit[1], bx, by, ring, nextRingIndex, s) >= 0) !== parentCCW) {
             continue;
           }
-          // No turn gate on the dip path: the exact coverage check is the arbiter.
-          // It measures how much of the dropped region would become uncovered and
-          // refuses collapses that would clip a significant lobe (see
-          // docs/development/buffer-line-notes.md), catching real lobes and end caps
-          // that a cheap turn/area/winding signal cannot separate from safe folds.
-          // The turn gate was both leaving valid interior loops uncollapsed (tight
-          // hairpins whose source turn exceeds the cap) and slowing the pipeline by
-          // deferring their removal to the dissolve.
-          if (!collapseKeepsAreaCovered(ring, n, hit, segmentEnd, nextRingIndex, s, covIndex, fillFloor)) {
+          // No turn gate on the coverage path: the exact coverage check is the
+          // arbiter. It measures how much of the dropped region would become
+          // uncovered and refuses collapses that would clip a significant lobe
+          // (see docs/development/buffer-line-notes.md), catching real lobes and
+          // end caps that a cheap turn/area/winding signal cannot separate from
+          // safe folds. The turn gate was both leaving valid interior loops
+          // uncollapsed (tight hairpins whose source turn exceeds the cap) and
+          // slowing the pipeline by deferring their removal to the dissolve.
+          if (!covIndex) covIndex = buildEdgeYIndex(ring, n);
+          if (!collapseKeepsAreaCovered(ring, n, hit, segmentEnd, nextRingIndex, s, covIndex, fillFloor, clipBudget)) {
             continue; // dropping this loop would uncover or fill real area -- leave it
           }
         } else {
@@ -42166,24 +42217,20 @@ ${svg}
       if (crossing) {
         segmentEnd = crossing;
         if (gated) segmentEndPos = anchorPos;
-        segmentEndTag = 0; // an offset crossing is not a dip vertex
         nextRingIndex = crossingEndIndex;
         continue;
       }
       out.push(segmentEnd);
       if (gated) outPos.push(segmentEndPos);
-      if (dipTags) outTags.push(segmentEndTag);
       if (nextRingIndex > n - 1) break;
       segmentEnd = ring[nextRingIndex];
       if (gated) segmentEndPos = srcPos[nextRingIndex];
-      if (dipTags) segmentEndTag = dipTags[nextRingIndex];
       nextRingIndex++;
     }
-    if (out.length < 4) return {ring: ring, srcPos: srcPos, dipTags: dipTags};
+    if (out.length < 4) return {ring: ring, srcPos: srcPos}; // collapsed away; keep original
     out.push(out[0].concat());
     if (gated) outPos.push(outPos[0]);
-    if (dipTags) outTags.push(outTags[0]);
-    return {ring: out, srcPos: gated ? outPos : null, dipTags: dipTags ? outTags : null};
+    return {ring: out, srcPos: gated ? outPos : null};
   }
 
   // Cumulative absolute turn (degrees) indexed by ring vertex, EXCLUDING fold
@@ -42191,17 +42238,13 @@ ${svg}
   // near-180-degree cusps where the offset doubles back on itself (an artifact of
   // the self-crossing offset, with no corresponding source bend). A normal offset
   // join's turn equals its source bend angle, so the remaining sum reconstructs
-  // the source stretch's cumulative turn -- the reliable loop-removal signal --
-  // without source provenance.
-  //
-  // A cusp is identified by construction tag when dipTags are supplied (a vertex
-  // on a reversed concave-join arc AND turning sharply); otherwise by a purely
-  // geometric turn threshold. Tag-gating is the point: a real sharp bend (e.g. a
-  // fjord mouth, emitted as a miter, never tagged) keeps its turn and so is never
-  // mistaken for a fold, which is what makes the geometric-only threshold
-  // over-collapse sharp coastlines.
+  // the source stretch's cumulative turn -- the loop-removal signal -- without
+  // source provenance. Only the provenance-free geometric path uses this (the
+  // clean-outline rings use the exact coverage check instead); the purely
+  // geometric cusp threshold can over-collapse real sharp bends (e.g. a fjord
+  // mouth), which is one reason the coverage check replaced it as the default.
   var CUSP_TURN = 135;
-  function ringAbsTurnPrefix(ring, dipTags) {
+  function ringAbsTurnPrefix(ring) {
     var n = ring.length - 1;
     var prefix = new Float64Array(n + 1);
     var RAD = 180 / Math.PI;
@@ -42212,8 +42255,7 @@ ${svg}
       var cross = e1x * e2y - e1y * e2x;
       var dot = e1x * e2x + e1y * e2y;
       var ang = Math.abs(Math.atan2(cross, dot)) * RAD;
-      var isCusp = ang > CUSP_TURN && (dipTags ? dipTags[k] : true);
-      prefix[k] = prefix[k - 1] + (isCusp ? 0 : ang);
+      prefix[k] = prefix[k - 1] + (ang > CUSP_TURN ? 0 : ang);
     }
     prefix[n] = prefix[n - 1];
     return prefix;
@@ -42261,12 +42303,14 @@ ${svg}
   // The threshold is in ring units; under web Mercator the scale factor is >= 1
   // everywhere, so it is an upper bound on the real m^2 area and no genuinely large
   // clip is skipped regardless of latitude.
-  function collapseKeepsAreaCovered(ring, n, X, b, nextRingIndex, s, index, fillFloor) {
+  function collapseKeepsAreaCovered(ring, n, X, b, nextRingIndex, s, index, fillFloor, clipBudget) {
     // Area pre-filter keeps the scanline off the hot path: a loop can neither clip
-    // nor fill more than its own area, so it is safe to skip whenever the loop is
-    // below BOTH thresholds. (Filling a winding-0 region never reaches the uncovered
-    // floor, so the fill floor must join the skip test -- otherwise small folds that
-    // could fill a small hole would be skipped, or every collapse would be scanned.)
+    // nor fill more than its own (absolute winding) area, so it is safe to skip
+    // whenever the loop is below BOTH thresholds; collapseUncoveredArea guards the
+    // self-crossing case where the net shoelace under-reports that area. (Filling
+    // a winding-0 region never reaches the uncovered floor, so the fill floor must
+    // join the skip test -- otherwise small folds that could fill a small hole
+    // would be skipped, or every collapse would be scanned.)
     var floor = fillFloor < BUFFER_LOOP_CHECK_MIN_AREA ? fillFloor : BUFFER_LOOP_CHECK_MIN_AREA;
     var u = collapseUncoveredArea(ring, n, X, b, nextRingIndex, s, index, floor);
     if (u < 0) return true; // loop below both floors -- too small to clip or fill
@@ -42275,33 +42319,68 @@ ${svg}
     // fill floor scales with the buffer disk (dist^2) because a real hole's area is
     // a fixed fraction of the disk while a fold sliver is orders of magnitude
     // smaller relative to the radius (see BUFFER_LOOP_FILL_AREA_FRAC).
-    return u < BUFFER_LOOP_CHECK_MIN_AREA && _lastFillArea < fillFloor;
+    if (!(u < BUFFER_LOOP_CHECK_MIN_AREA && _lastFillArea < fillFloor)) return false;
+    // Neighborhood budget (see removeBufferRingLoopsIterative): a sub-floor clip
+    // is only accepted while its neighborhood's accumulated clips stay under the
+    // floor. Zero-clip collapses (the common case) skip this entirely.
+    if (u > 0 && clipBudget) {
+      // Key on the clipped region's own centroid (accumulated by the sweep):
+      // overlapping clips from different collapses then share a cell even when
+      // their loops' bboxes differ by kilometers. Two dents straddling a cell
+      // edge can still each spend a budget, so the worst-case neighborhood dent
+      // is 2x the per-collapse floor.
+      var cell = clipBudget.cell;
+      var key = Math.floor(_lastClipX / cell) + ':' + Math.floor(_lastClipY / cell);
+      var spent = clipBudget.map.get(key) || 0;
+      if (spent + u >= BUFFER_LOOP_CHECK_MIN_AREA) return false;
+      clipBudget.map.set(key, spent + u);
+    }
+    return true;
   }
 
   // Returns the area of the dropped region a collapse would leave uncovered, or -1
-  // when the loop's own area is below `floor` (too small to matter -- scanline
-  // skipped). See collapseKeepsAreaCovered for the winding rationale.
+  // when the loop is provably too small to matter (scanline skipped). See
+  // collapseKeepsAreaCovered for the winding rationale.
+  //
+  // The skip must not trust the net shoelace area alone: a SELF-CROSSING span
+  // (figure-eight) has lobes of opposite winding whose signed areas cancel, so a
+  // near-zero net can hide winding regions far above the floor. |net| bounds the
+  // regions only for a simple loop; the bbox bounds them always. So the scanline
+  // is skipped when the bbox is under the floor, or when the net is under the
+  // floor AND the loop has no self-crossing (O(span^2) pairwise test, span <=
+  // maxGap+2 edges -- run only in the suspicious small-net/large-bbox band).
   function collapseUncoveredArea(ring, n, X, b, nextRingIndex, s, index, floor) {
     var i, loopLen = s - nextRingIndex + 3; // X, b, ring[next..s]
     // Loop area (shoelace over X, b, ring[next..s]) and bounding box.
     var area2 = 0, px = X[0], py = X[1];
     var minx = X[0], maxx = X[0], miny = X[1], maxy = X[1];
-    function bbox(qx, qy) {
+    var qx = b[0], qy = b[1];
+    if (qx < minx) minx = qx; else if (qx > maxx) maxx = qx;
+    if (qy < miny) miny = qy; else if (qy > maxy) maxy = qy;
+    area2 += px * qy - qx * py; px = qx; py = qy;
+    for (i = nextRingIndex; i <= s; i++) {
+      qx = ring[i][0]; qy = ring[i][1];
+      area2 += px * qy - qx * py; px = qx; py = qy;
       if (qx < minx) minx = qx; else if (qx > maxx) maxx = qx;
       if (qy < miny) miny = qy; else if (qy > maxy) maxy = qy;
     }
-    bbox(b[0], b[1]);
-    area2 += px * b[1] - b[0] * py; px = b[0]; py = b[1];
-    for (i = nextRingIndex; i <= s; i++) {
-      area2 += px * ring[i][1] - ring[i][0] * py; px = ring[i][0]; py = ring[i][1];
-      bbox(ring[i][0], ring[i][1]);
-    }
     area2 += px * X[1] - X[0] * py;
-    if (Math.abs(area2) / 2 < floor) return -1; // too small to matter
-    // Collect the ring edges whose y-range meets the loop's band (the only ones
-    // that can cross any scanline); reuse module scratch to avoid per-call garbage.
+    var smallNet = Math.abs(area2) / 2 < floor;
+    if (smallNet && (maxx - minx) * (maxy - miny) < floor) return -1;
     var scr = coverageScratch(n + loopLen);
     var lx0 = scr.lx0, ly0 = scr.ly0, lx1 = scr.lx1, ly1 = scr.ly1;
+    // Loop edges (X->b, b->ring[next..s], ring[s]->X), built before the band
+    // collection so the self-cross test can run first.
+    var lc = 0;
+    lx0[lc] = X[0]; ly0[lc] = X[1]; lx1[lc] = b[0]; ly1[lc] = b[1]; lc++;
+    lx0[lc] = b[0]; ly0[lc] = b[1]; lx1[lc] = ring[nextRingIndex][0]; ly1[lc] = ring[nextRingIndex][1]; lc++;
+    for (i = nextRingIndex; i < s; i++) {
+      lx0[lc] = ring[i][0]; ly0[lc] = ring[i][1]; lx1[lc] = ring[i + 1][0]; ly1[lc] = ring[i + 1][1]; lc++;
+    }
+    lx0[lc] = ring[s][0]; ly0[lc] = ring[s][1]; lx1[lc] = X[0]; ly1[lc] = X[1]; lc++;
+    if (smallNet && !loopEdgesCross(lx0, ly0, lx1, ly1, lc)) return -1; // simple: |net| == area
+    // Collect the ring edges whose y-range meets the loop's band (the only ones
+    // that can cross any scanline); reuse module scratch to avoid per-call garbage.
     var band = scr.band, le = 0;
     var gen = ++index.gen, stamp = index.stamp, start = index.start, edges = index.edges;
     var kb, klo = index.binOf(miny), khi = index.binOf(maxy);
@@ -42316,17 +42395,23 @@ ${svg}
         band[le++] = ei;
       }
     }
-    // Loop edges (X->b, b->ring[next..s], ring[s]->X).
-    var lc = 0;
-    lx0[lc] = X[0]; ly0[lc] = X[1]; lx1[lc] = b[0]; ly1[lc] = b[1]; lc++;
-    lx0[lc] = b[0]; ly0[lc] = b[1]; lx1[lc] = ring[nextRingIndex][0]; ly1[lc] = ring[nextRingIndex][1]; lc++;
-    for (i = nextRingIndex; i < s; i++) {
-      lx0[lc] = ring[i][0]; ly0[lc] = ring[i][1]; lx1[lc] = ring[i + 1][0]; ly1[lc] = ring[i + 1][1]; lc++;
-    }
-    lx0[lc] = ring[s][0]; ly0[lc] = ring[s][1]; lx1[lc] = X[0]; ly1[lc] = X[1]; lc++;
     return loopUncoveredArea(ring, band, le, lx0, ly0, lx1, ly1, lc, minx, maxx, miny, maxy, scr);
   }
 
+  // True if any two non-adjacent loop edges cross (strict interior). Adjacent
+  // edges share an endpoint and cannot strictly cross, so they are skipped.
+  function loopEdgesCross(lx0, ly0, lx1, ly1, lc) {
+    for (var i = 0; i < lc - 1; i++) {
+      for (var j = i + 2; j < lc; j++) {
+        if (i === 0 && j === lc - 1) continue; // adjacent via closure at X
+        if (segHit(lx0[i], ly0[i], lx1[i], ly1[i], lx0[j], ly0[j], lx1[j], ly1[j])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   // y-band index of ring edges: bins the ring's y-range so a scanline query at
   // [miny, maxy] returns only edges reaching that band instead of scanning all n.
   // start[k]..start[k+1] are indices into `edges` for bin k; `stamp`/`gen` dedup an
@@ -42383,16 +42468,24 @@ ${svg}
   // Returns the uncovered area and writes the filled area to _lastFillArea.
   // `band` lists the indices of ring edges that can reach the loop's y-band.
   var _lastFillArea = 0;
+  var _lastClipX = 0, _lastClipY = 0;
   function loopUncoveredArea(ring, band, be, lx0, ly0, lx1, ly1, le, minx, maxx, miny, maxy, scr) {
     var h = maxy - miny;
     _lastFillArea = 0;
     if (h <= 0 || maxx <= minx) return 0;
+    // Known limitation: rows are uniform with a hard cap, so dy scales with the
+    // loop's bbox height and a region thinner than dy in y can fall between row
+    // midpoints unmeasured (only reachable via a loop whose bbox is much taller
+    // than the region -- not observed outside synthetic data). A designed fix
+    // (vertex-guided rows) was implemented, measured at 4-8% of buffer build
+    // time, and reverted; see "Scanline row starvation" in
+    // docs/development/buffer-line-notes.md to re-add it if it is ever needed.
     var target = Math.sqrt(BUFFER_LOOP_CHECK_MIN_AREA) / 4;
     var rows = Math.round(h / (target > 0 ? target : h));
     if (rows < 8) rows = 8; else if (rows > 40) rows = 40;
     var dy = h / rows;
     var xs = scr.xs, df = scr.df, dl = scr.dl, order = scr.order;
-    var total = 0, fill = 0, r, k, i;
+    var total = 0, fill = 0, momX = 0, momY = 0, r, k, i;
     for (r = 0; r < rows; r++) {
       var y = miny + (r + 0.5) * dy;
       // Winding just left of the loop's x-range (base), plus the crossings that
@@ -42421,17 +42514,24 @@ ${svg}
       for (i = 0; i < m; i++) {
         var o = order[i], xk = xs[o];
         if (wl !== 0 && xk > prevx) {
-          if (wf - wl === 0) total += xk - prevx;
+          if (wf - wl === 0) {
+            total += xk - prevx;
+            momX += (xk + prevx) / 2 * (xk - prevx); momY += y * (xk - prevx);
+          }
           else if (wf === 0) fill += xk - prevx;
         }
         wf += df[o]; wl += dl[o]; prevx = xk;
       }
       if (wl !== 0 && maxx > prevx) {
-        if (wf - wl === 0) total += maxx - prevx;
+        if (wf - wl === 0) {
+          total += maxx - prevx;
+          momX += (maxx + prevx) / 2 * (maxx - prevx); momY += y * (maxx - prevx);
+        }
         else if (wf === 0) fill += maxx - prevx;
       }
     }
     _lastFillArea = fill * dy;
+    if (total > 0) { _lastClipX = momX / total; _lastClipY = momY / total; }
     return total * dy;
   }
 
@@ -43151,9 +43251,9 @@ ${svg}
     var roundJoinSegAngle = 90 / roundJoinSegsPerQuadrant;
     // Max arc step (degrees) for the coarse concave bridge (makeCoarseConcaveJoin),
     // the optional low-resolution alternative to makeConcaveJoin in
-    // traceCleanOffsetSide. Larger = fewer points = faster dissolve. The reversed
-    // bridge only bounds a self-overlap loop that the direction remover collapses,
-    // so its resolution does not affect the final boundary.
+    // traceCleanOffsetSide. Larger = fewer points = faster dissolve. NOTE: a
+    // surviving (uncollapsed) bridge CAN become output boundary, where this step
+    // sets the dent depth -- see the caution at makeCoarseConcaveJoin.
     var CLEAN_OUTLINE_BRIDGE_STEP = 90;
     var capStyle = opts.cap_style || 'round'; // expect 'round' or 'flat'
     var pathIter = useMercator ?
@@ -44159,11 +44259,38 @@ ${svg}
           } else {
             add(p2Prev, segId, 1);
             joinPoints = concaveJoin(x1, y1, bearing - 90, -joinAngle, dist);
+            var exposedWedge = false;
+            if (!opts.coarse_bridge) {
+              // Exposure-gated coarse bridge (default): a dip may be emitted
+              // coarsely only when it cannot affect the output.
+              // 1. Exposure gate: probe the full-resolution arc + tips against
+              //    the source path (wedgeIsExposed; each probe uses its own
+              //    radius with a 0.98 margin, erring toward "exposed" = the
+              //    full arc). An uncovered arc point is potential true output
+              //    boundary -- an exposed dip that the loop remover refuses to
+              //    collapse IS the boundary there, so it must stay at full
+              //    resolution (see the caution at makeCoarseConcaveJoin).
+              //    Collapsed coarse dips legally clip up to the remover's
+              //    per-collapse floor (the chord-to-arc lens is single-covered
+              //    where only the fold's own winding spans it); the remover's
+              //    neighborhood clip budget keeps clustered dips from
+              //    compounding several such clips into one visible dent (a
+              //    102k m^2 dent on the innerlines 2km Sabine River fold
+              //    cluster before the budget existed).
+              if (!vertsSegIndex) vertsSegIndex = buildVertsSegmentIndex(verts);
+              exposedWedge = wedgeIsExposed(vertsSegIndex, segId - 1, segId,
+                x1, y1, joinPoints, p2Prev, p1);
+              if (!exposedWedge) {
+                joinPoints = makeCoarseConcaveJoin(x1, y1, bearing - 90, -joinAngle, dist);
+              }
+            }
             if (useGapPatch(opts, useMercator) &&
                 offsetEdgesFanApart(p1Prev, p2Prev, p1, p2)) {
               if (!vertsSegIndex) vertsSegIndex = buildVertsSegmentIndex(verts);
-              if (wedgeIsExposed(vertsSegIndex, segId - 1, segId, x1, y1,
-                  joinPoints, p2Prev, p1)) {
+              if (opts.coarse_bridge ?
+                  wedgeIsExposed(vertsSegIndex, segId - 1, segId, x1, y1,
+                    joinPoints, p2Prev, p1) :
+                  exposedWedge) {
                 fanApartBends.push(segId);
               }
             }
@@ -44367,13 +44494,21 @@ ${svg}
       return makeRoundJoin(cx, cy, startBearing, arcAngle, dist).reverse();
     }
 
-    // Coarse alternative to makeConcaveJoin (selected by opts.coarse_bridge in
-    // traceCleanOffsetSide): bridges a concave bend with as few as one reversed
-    // arc vertex (CLEAN_OUTLINE_BRIDGE_STEP), producing a smaller ring for the
-    // winding dissolve to chew through. The reversed bridge only bounds a self-
-    // overlap loop the direction remover collapses, so the coarser resolution
-    // does not change the final boundary -- it just trades a little construction
-    // fidelity for dissolve speed.
+    // Coarse alternative to makeConcaveJoin: bridges a concave bend with as few
+    // as one reversed arc vertex (CLEAN_OUTLINE_BRIDGE_STEP), producing a
+    // smaller ring for the winding dissolve to chew through. Used by default
+    // only behind the exposure gate above (plus the loop remover's neighborhood
+    // clip budget); opts.coarse_bridge forces it everywhere, unguarded.
+    // CAUTION -- unsound WITHOUT those guards (2026-07-02 eval, see
+    // "coarse-bridge" in docs/development/buffer-line-notes.md): a dip that the
+    // loop remover refuses to collapse can be real output boundary (near-U-turn
+    // bends whose wedge nothing else covers; single-sided polygon grows; hole
+    // boundaries), and there the coarse chords replace the true arc. Chord
+    // vertices stay on the radius-dist circle, so coarse geometry never falls
+    // OUTSIDE the true buffer -- the failures are inward dents (sagitta up to
+    // (1-cos45)*dist ~ 0.29*dist at the 90-degree step) and spurious holes
+    // (chord-triangle slivers whose at-radius vertices defeat the artifact-hole
+    // filter's distance classification).
     function makeCoarseConcaveJoin(cx, cy, startBearing, arcAngle, dist) {
       var segs = Math.min(roundJoinSegsPerQuadrant,
         Math.max(1, Math.ceil(arcAngle / CLEAN_OUTLINE_BRIDGE_STEP)));
@@ -44385,6 +44520,7 @@ ${svg}
       return points.reverse();
     }
 
+
     // get interior vertices of an interpolated CW arc
     function makeRoundJoin(cx, cy, startBearing, arcAngle, dist) {
       var points = [];
@@ -58231,18 +58367,55 @@ ${svg}
   //     threshold) -- a jetty, fjord or crinkle. Otherwise restore the run's
   //     original vertices, so gentle stretches keep full detail for -smooth.
   //
+  // A ROUNDNESS gate protects substantial, rounded loops from both the merge pass
+  // and the commit. Tortuosity (path length / chord) alone cannot tell a thin
+  // needle from a round bulge -- both can be highly tortuous, and a closing chord
+  // of length ~0 makes tortuosity infinite for either. Worst case: a closed ring
+  // stores its start and end vertex at the same coordinate, so the seam chord
+  // (vertex 0 -> vertex n-1) has length 0 and infinite tortuosity, which used to
+  // make the merge pass splice out the entire ring -- destroying every island
+  // whose perimeter fit inside the merge window, regardless of size or roundness.
+  // The gate distinguishes them by the enclosed area: for a candidate section
+  // closed by its chord, protect it when area / loop-perimeter >= roundness * D
+  // (the isoperimetric area-to-perimeter ratio, biased by the detail distance). A
+  // thin needle encloses ~0 area (never protected -> still cut); a round island
+  // encloses a large area (protected). Because area/perimeter equals radius/2 for
+  // a circle, the default gate protects circular features at or above the detail
+  // resolution and preferentially removes smaller or less-round ones.
+  //
   // @xx, @yy  coordinate arrays for one arc (may be typed-array subarrays).
-  // @opts: {distance, tortuosity, spherical, weighting}
+  // @opts: {distance, tortuosity, spherical, weighting, roundness}
   //   distance   detail size threshold in ground units (meters when spherical): the
   //              longest chord the filter is allowed to create.
   //   tortuosity min original-length / chord ratio for a run to be cut (default 2).
   //   spherical  measure area/length on the sphere (lng/lat -> geocentric x,y,z).
   //   weighting  Visvalingam angle-weight coefficient (default 0.7), matching
   //              -simplify's weighted_visvalingam.
+  //   roundness  min enclosed-area / loop-perimeter (as a fraction of the detail
+  //              distance) for a loop to be protected from removal (default 0.2);
+  //              higher removes more, 0 disables the protection.
   // Returns {xx: [], yy: []}. Arc endpoints are always preserved, so shared
   // topology nodes stay put and the operation is topology-safe like -simplify.
   var DEFAULT_WEIGHTING = 0.7;
   var DEFAULT_TORTUOSITY = 4;
+  // Protect a candidate loop from collapse when its enclosed-area / loop-perimeter
+  // exceeds this fraction of the detail distance D. For a circle area/perimeter =
+  // radius/2, so 0.2 protects circular features of diameter >= ~D and drops finer
+  // or less-round detail; a thin needle (area ~ 0) is never protected.
+  var DEFAULT_ROUNDNESS = 0.2;
+  // A closed ring (island, lake or hole) is dropped entirely when the filter would
+  // leave less than this fraction of its original enclosed area. The roundness gate
+  // stops a substantial ring from being merged away wholesale, but it is evaluated
+  // per candidate span, so cutRun can still slice off convoluted sub-spans of the
+  // perimeter and shrink a near-scale island to a small, distorted remnant. Once
+  // most of the area is gone the remnant no longer faithfully represents the island
+  // and a clean drop is better than a mangled sliver -- so if the survivors enclose
+  // less than this share of the original area, collapse the ring to its degenerate
+  // seam (like a fully sub-scale ring) and let the pipeline discard it. Only closed
+  // rings are affected; open arcs and shared boundaries are never dropped, so the
+  // operation stays topology-safe. Set to 0 to disable. The default 0.6 keeps a
+  // ring only while the filter removes at most ~40% of its area.
+  var DEFAULT_MIN_RING_AREA = 0.6;
   // How far (in detail-distances of arc length) the survivor-merge pass looks ahead
   // for a chord that closes a convoluted excursion. Bounds the pass to O(n) and
   // caps how long a thin spike it can slice in one merge.
@@ -58256,7 +58429,7 @@ ${svg}
 
   function collapseArcDetail(xx, yy, opts) {
     var n = xx.length;
-    var outX = [], outY = [];
+    var outX = [], outY = [], outIdx = [];
     var D = opts.distance;
     if (n < 3 || !(D > 0)) {
       for (var p = 0; p < n; p++) { outX.push(xx[p]); outY.push(yy[p]); }
@@ -58265,6 +58438,12 @@ ${svg}
     var spherical = !!opts.spherical;
     var k = opts.weighting >= 0 ? opts.weighting : DEFAULT_WEIGHTING;
     var T = opts.tortuosity > 0 ? opts.tortuosity : DEFAULT_TORTUOSITY;
+    // roundness >= 0; 0 disables the roundness protection (legacy behavior).
+    var R = opts.roundness >= 0 ? opts.roundness : DEFAULT_ROUNDNESS;
+    // minRingArea >= 0; 0 disables the drop-shredded-ring gate.
+    var minRingArea = opts.minRingArea >= 0 ? opts.minRingArea : DEFAULT_MIN_RING_AREA;
+    // A closed ring stores its start and end vertex at the same coordinate.
+    var isRing = n >= 4 && xx[0] === xx[n - 1] && yy[0] === yy[n - 1];
     var Dsq = D * D;
 
     // Metric coordinates: geocentric x,y,z on a sphere for lng/lat input, plain
@@ -58342,6 +58521,52 @@ ${svg}
     var cumLen = new Float64Array(n);
     for (var q = 1; q < n; q++) cumLen[q] = cumLen[q - 1] + dist(q - 1, q);
 
+    // Cumulative cross products of successive position vectors (in a frame
+    // translated to vertex 0, to keep magnitudes small and the subtraction
+    // precise) give the enclosed area of any section i..j closed by its chord in
+    // O(1). The vector-area form (0.5 * |sum of edge cross products + closing
+    // term|) is origin-independent for a closed loop, so it works unchanged for
+    // the geocentric 3D coords used in spherical mode and the plain 2D coords
+    // otherwise. Only used by the roundness gate below.
+    var ox = mx[0], oy = my[0], oz = spherical ? mz[0] : 0;
+    var cumCz = new Float64Array(n), cumCx, cumCy;
+    if (spherical) { cumCx = new Float64Array(n); cumCy = new Float64Array(n); }
+    for (var t = 1; t < n; t++) {
+      var ax = mx[t - 1] - ox, ay = my[t - 1] - oy, bx = mx[t] - ox, by = my[t] - oy;
+      if (spherical) {
+        var az = mz[t - 1] - oz, bz = mz[t] - oz;
+        cumCx[t] = cumCx[t - 1] + (ay * bz - az * by);
+        cumCy[t] = cumCy[t - 1] + (az * bx - ax * bz);
+        cumCz[t] = cumCz[t - 1] + (ax * by - ay * bx);
+      } else {
+        cumCz[t] = cumCz[t - 1] + (ax * by - ay * bx);
+      }
+    }
+
+    // Area enclosed by the section vertices i..j closed by the chord j->i.
+    function sectionArea(i, j) {
+      var aix = mx[i] - ox, aiy = my[i] - oy, ajx = mx[j] - ox, ajy = my[j] - oy;
+      if (spherical) {
+        var aiz = mz[i] - oz, ajz = mz[j] - oz;
+        var vx = (cumCx[j] - cumCx[i]) + (ajy * aiz - ajz * aiy);
+        var vy = (cumCy[j] - cumCy[i]) + (ajz * aix - ajx * aiz);
+        var vz = (cumCz[j] - cumCz[i]) + (ajx * aiy - ajy * aix);
+        return 0.5 * Math.sqrt(vx * vx + vy * vy + vz * vz);
+      }
+      return 0.5 * Math.abs((cumCz[j] - cumCz[i]) + (ajx * aiy - ajy * aix));
+    }
+
+    // A candidate section (i..j) is protected from collapse when the loop it forms
+    // with its closing chord is a substantial, rounded feature: enclosed area per
+    // unit loop-perimeter reaches the roundness fraction of the detail distance.
+    // A thin needle encloses ~0 area (area/perimeter ~ 0) and is never protected;
+    // a round bulge or island encloses enough area to clear the gate.
+    function isProtected(i, j) {
+      if (!(R > 0)) return false;
+      var perim = (cumLen[j] - cumLen[i]) + dist(i, j);
+      return perim > 0 && sectionArea(i, j) / perim >= R * D;
+    }
+
     function cutRun(a, e) {
       // Emit the kept vertices in (a, e]; a has already been emitted. Walk from a
       // and, at each step, find the span [i, j] (chord <= D) with the highest
@@ -58358,7 +58583,8 @@ ${svg}
           var c = dist(i, j);
           if (c > D) continue; // never create a chord longer than the detail scale
           var tort = c > 0 ? (cumLen[j] - cumLen[i]) / c : Infinity;
-          if (tort > bestTort) {
+          // roundness gate: keep substantial, rounded bulges at full detail
+          if (tort > bestTort && !isProtected(i, j)) {
             bestTort = tort;
             bestJ = j;
           }
@@ -58366,10 +58592,12 @@ ${svg}
         if (bestJ >= 0) {
           outX.push(xx[bestJ]);
           outY.push(yy[bestJ]);
+          outIdx.push(bestJ);
           i = bestJ;
         } else {
           outX.push(xx[i + 1]);
           outY.push(yy[i + 1]);
+          outIdx.push(i + 1);
           i++;
         }
       }
@@ -58399,7 +58627,9 @@ ${svg}
         if (chordSq(s, u) <= mergeChordSq) {
           var ud = dist(s, u);
           var utort = ud > 0 ? (cumLen[u] - cumLen[s]) / ud : Infinity;
-          if (utort > mergeTort) {
+          // roundness gate: a rounded loop (e.g. a closed ring closing on its own
+          // zero-length seam) is a real feature, not a needle -- never merge it.
+          if (utort > mergeTort && !isProtected(s, u)) {
             mergeTort = utort;
             mergeJ = u;
           }
@@ -58418,13 +58648,49 @@ ${svg}
 
     outX.push(xx[0]);
     outY.push(yy[0]);
+    outIdx.push(0);
     var a = 0;
     while (a !== n - 1) {
       var e = next[a];
       cutRun(a, e);
       a = e;
     }
+
+    // Drop a closed ring that the filter has shredded to a small remnant: if the
+    // survivors enclose less than minRingArea of the original ring's area, collapse
+    // it to its degenerate seam so the pipeline discards it (a clean drop rather
+    // than a distorted sliver). Uses the survivors' metric coordinates for the
+    // filtered area and the whole-ring section area for the original.
+    if (isRing && minRingArea > 0) {
+      var origArea = sectionArea(0, n - 1);
+      if (origArea > 0 && ringAreaByIdx(outIdx) < minRingArea * origArea) {
+        return {xx: [xx[0], xx[n - 1]], yy: [yy[0], yy[n - 1]]};
+      }
+    }
     return {xx: outX, yy: outY};
+
+    // Enclosed area of the closed ring formed by the survivor vertices (given as
+    // indices into the original arc), measured in the same metric space as
+    // sectionArea via the origin-independent vector-area form.
+    function ringAreaByIdx(idx) {
+      var m = idx.length;
+      if (m < 4) return 0;
+      var o0x = mx[idx[0]], o0y = my[idx[0]], o0z = spherical ? mz[idx[0]] : 0;
+      var vx = 0, vy = 0, vz = 0;
+      for (var t = 1; t < m; t++) {
+        var p = idx[t - 1], q = idx[t];
+        var ax = mx[p] - o0x, ay = my[p] - o0y, bx = mx[q] - o0x, by = my[q] - o0y;
+        if (spherical) {
+          var az = mz[p] - o0z, bz = mz[q] - o0z;
+          vx += ay * bz - az * by;
+          vy += az * bx - ax * bz;
+          vz += ax * by - ay * bx;
+        } else {
+          vz += ax * by - ay * bx;
+        }
+      }
+      return spherical ? 0.5 * Math.sqrt(vx * vx + vy * vy + vz * vz) : 0.5 * Math.abs(vz);
+    }
   }
 
   // Optional preprocessing step before -smooth: collapse intricate sub-scale
@@ -58455,6 +58721,8 @@ ${svg}
       distance: distance,
       tortuosity: opts.tortuosity,
       weighting: opts.weighting,
+      roundness: opts.roundness,
+      minRingArea: opts.min_area,
       spherical: spherical
     });
     var removed = before - arcs.getPointCount();
@@ -58478,6 +58746,8 @@ ${svg}
         distance: opts.distance,
         tortuosity: opts.tortuosity,
         weighting: opts.weighting,
+        roundness: opts.roundness,
+        minRingArea: opts.minRingArea,
         spherical: opts.spherical
       });
       nn.push(res.xx.length);
@@ -63320,7 +63590,7 @@ ${svg}
   });
 
   // Structural-corner detection for -smooth's corner preservation (on by default;
-  // disabled with no-corners or corner-bias=0).
+  // disabled with no-corners).
   //
   // Many boundaries alternate between natural, freely-curving stretches (coast,
   // river centerline) and artificial straight-line segments (state/county
@@ -63354,21 +63624,112 @@ ${svg}
   var INNER_WINDOW_FACTOR = 0.4;         // concentration probe window = tangentWindow * this
   var CORNER_CONCENTRATION = 0.6;        // min ratio of inner-window turn to full-window turn
   var MIN_RUN_LEN_FACTOR = 1.0;          // a structural run must be at least tol * this long
-  var MIN_RUN_RADIUS_FACTOR = 1.0;       // and bend no tighter than radius tol * this
-
-  // @cornerBias (optional, default 1) divides the min structural-run length, so a
-  // value < 1 lengthens the run a corner must border to be preserved (fewer, only
-  // well-supported corners), and a value > 1 shortens it (more corners kept).
+  // ...and bend no tighter than radius tol * this. This is the curvature gate for
+  // "structural" (straight or slowly-curving, e.g. a surveyed border or graticule
+  // arc). It must be well above 1: at factor 1 a minimal run may turn a full
+  // radian (~57 deg) over its own length, so ordinary coastal arcs qualify and
+  // their end bends get pinned as spurious corners (radius ~1-1.6*tol). At 3 a
+  // minimal run turns <= ~19 deg, excluding natural coastal curvature while still
+  // admitting genuinely straight borders (radius ~infinite) and graticule arcs
+  // (radius >> tol).
+  var MIN_RUN_RADIUS_FACTOR = 3.0;
+
+  // Straightness gate used to decide corner *retention* (whether a detected corner
+  // borders a run worth pinning), as distinct from isStructuralRun's per-vertex
+  // gate that decides whether a span is copied verbatim. A run is "straight at the
+  // smoothing scale" if every vertex stays within a thin corridor around the
+  // straight chord joining the run's endpoints: max perpendicular deviation <=
+  // STRAIGHT_DEV_FACTOR * chord length. Because this measures deviation from the
+  // chord rather than summing raw per-segment turning, it is robust to
+  // sub-tolerance digitizing wiggle: a finely ragged but geometrically straight
+  // border (huge total per-vertex turning, tiny deviation) qualifies, so its
+  // bounding corners are kept -- while isStructuralRun would (correctly, for its
+  // own purpose) reject it as too wiggly to copy verbatim. The ratio behaves like
+  // a minimum-radius-over-length gate: a run bending with radius R over length L
+  // deviates from its chord by ~L/(8R), so the threshold corresponds to
+  // R >~ L/(8*STRAIGHT_DEV_FACTOR) -- longer runs must be proportionally straighter
+  // 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;
+
+  // 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
+  // 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
+  // gently curving stretch is sampled as a few long segments that read as a
+  // borderline-straight run with soft bends at each end.) So the straightness limit
+  // for retention is tightened for gentle corners: a corner is pinnable only if its
+  // turn is at least PIN_TURN_RATIO times the run's own bend, i.e.
+  //   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
+  // right angles, spits, hairpins) keep the full base tolerance, unchanged.
+  var PIN_TURN_RATIO = 5;
+
+  // Minimum length (in tol units) a straight run must have to justify *pinning* a
+  // bordering corner. This is deliberately larger than MIN_RUN_LEN_FACTOR (the
+  // floor for calling a span "structural" at all): pinning a corner is a stronger
+  // commitment than copying a clean span, so it demands stronger evidence that the
+  // run is a deliberate straight feature rather than incidental collinearity.
+  //
+  // The failure mode this guards against appears on sparse / already-simplified
+  // data, where a gently curving coastline is sampled as a few long segments. A
+  // short near-collinear stretch only ~1*tol long (often just 1-2 segments) then
+  // passes the chord-deviation test -- with so few interior points there is almost
+  // nothing to deviate -- and gets pinned, kinking an otherwise smooth curve. At
+  // the smoothing scale such a stretch is indistinguishable from a coarsely
+  // sampled bend, so it should not anchor a corner. Requiring the run to be
+  // clearly longer than the smoothing distance (factor 2) drops these stubs while
+  // keeping genuine straight borders (which run many times the distance) and even
+  // coarsely sampled but truly long straight segments (e.g. a 2-3*tol contour
+  // edge). Scales with corner-bias (via ctol), so a positive bias restores the
+  // old 1*tol behaviour for users who want shorter runs pinned.
+  var MIN_PIN_RUN_LEN_FACTOR = 2.0;
+
+  // 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
+  // have slope 1 at b = 0), so opposite biases of equal magnitude are exact
+  // inverses. A positive bias makes detection finer (k > 1, ctol < tol: more, more
+  // finely supported corners); a negative bias makes it coarser (k < 1, ctol > tol:
+  // fewer corners), each as if the smoothing distance were tol/k. Examples: +1
+  // doubles the resolution (k=2, "as if distance were halved"), -1 halves it
+  // (k=1/2, "as if doubled"); +2 -> k=3, -2 -> k=1/3.
+  function cornerBiasScale(cornerBias) {
+    var b = cornerBias || 0;
+    return b >= 0 ? b + 1 : 1 / (1 - 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
+  // left untouched: the corner angle, the concentration ratio, and -- downstream,
+  // inside isStraightRun / retentionDevLimit -- STRAIGHT_DEV_FACTOR and
+  // PIN_TURN_RATIO. So corner-bias detects (and retains) corners exactly as if the
+  // smoothing distance were tol/k, while the smoothing kernel keeps using the real
+  // distance. In particular `-smooth corner-bias=-1 1km` gives the same corner
+  // results as `-smooth 2km` (a negative bias finds fewer, only well-supported
+  // corners; a positive bias finds more), but smooths at 1km. All lengths below are
+  // derived from ctol; only cornerAngle and concentration (both dimensionless) stay
+  // fixed.
   function getCornerParams(tol, cornerBias) {
-    var bias = cornerBias > 0 ? cornerBias : 1;
+    var ctol = tol / cornerBiasScale(cornerBias);
     return {
       tol: tol,
       cornerAngle: CORNER_ANGLE,
-      tangentWindow: TANGENT_WINDOW_FACTOR * tol,
-      innerWindow: INNER_WINDOW_FACTOR * TANGENT_WINDOW_FACTOR * tol,
+      tangentWindow: TANGENT_WINDOW_FACTOR * ctol,
+      innerWindow: INNER_WINDOW_FACTOR * TANGENT_WINDOW_FACTOR * ctol,
       concentration: CORNER_CONCENTRATION,
-      minRunLen: MIN_RUN_LEN_FACTOR * tol / bias,
-      maxTurnRate: 1 / (MIN_RUN_RADIUS_FACTOR * tol) // radians of turning per ground unit
+      minRunLen: MIN_RUN_LEN_FACTOR * ctol,
+      minPinRunLen: MIN_PIN_RUN_LEN_FACTOR * ctol,
+      maxTurnRate: 1 / (MIN_RUN_RADIUS_FACTOR * ctol) // radians of turning per ground unit
     };
   }
 
@@ -63420,6 +63781,122 @@ ${svg}
     return totalTurn / len <= params.maxTurnRate;
   }
 
+  // Cyclic form of isStructuralRun for a closed ring: the span runs forward from
+  // ring vertex @a to ring vertex @b over the m = n-1 unique vertices, wrapping
+  // when b <= a (a == b means the whole ring). Length and turning are measured
+  // cyclically. Used to decide whether a detected ring corner borders a genuine
+  // straight/low-curvature run before it is pinned (see smoothArcCoords).
+  function isStructuralRingSpan(t, channels, n, a, b, params) {
+    var m = n - 1;
+    if (m < 2) return false;
+    var L = t[n - 1];
+    var len = b > a ? t[b] - t[a] : (L - t[a]) + t[b];
+    if (!(len >= params.minRunLen)) return false;
+    var K = channels.length;
+    var totalTurn = 0;
+    var i = a;
+    while (true) {
+      i = (i + 1) % m;
+      if (i === b) break;
+      totalTurn += ringVertexTurn(channels, K, m, i);
+      if (totalTurn / len > params.maxTurnRate) return false;
+    }
+    return totalTurn / len <= params.maxTurnRate;
+  }
+
+  // Is span [a, b] (inclusive vertex indices, a < b, open frame) "straight at the
+  // smoothing scale": clearly longer than the smoothing distance (>= minPinRunLen,
+  // see MIN_PIN_RUN_LEN_FACTOR) AND confined to a thin corridor around its endpoint
+  // chord (see STRAIGHT_DEV_FACTOR)? Used to decide whether a detected corner
+  // borders a straight run worth pinning. Unlike isStructuralRun -- which sums raw
+  // per-segment turning and is therefore defeated by sub-tolerance digitizing
+  // noise -- this measures perpendicular deviation from the chord, so a finely
+  // ragged but geometrically straight border still qualifies. The length floor is
+  // the pinning-specific minPinRunLen (not minRunLen): a run only ~1*tol long has
+  // too few interior points for the chord test to distinguish a true straight
+  // border from a coarsely sampled bend, so it must not anchor a corner. @devLimit
+  // overrides the corridor half-width (default STRAIGHT_DEV_FACTOR); retention
+  // passes a per-corner value tightened for gentle bends (see retentionDevLimit).
+  function isStraightRun(t, channels, a, b, params, devLimit) {
+    var lim = devLimit === undefined ? STRAIGHT_DEV_FACTOR : devLimit;
+    var len = t[b] - t[a];
+    if (!(len >= params.minPinRunLen)) return false;
+    var K = channels.length;
+    var A = getPt(channels, K, a);
+    var AB = subv(getPt(channels, K, b), A, K);
+    var abDot = dot(AB, AB, K);
+    if (!(abDot > 0)) return false;
+    var limit2 = lim * lim * abDot;
+    for (var i = a + 1; i < b; i++) {
+      if (perpDistSq(channels, K, i, A, AB, abDot) > limit2) return false;
+    }
+    return true;
+  }
+
+  // Cyclic form of isStraightRun for a closed ring: the span runs forward from ring
+  // vertex @a to ring vertex @b over the m = n-1 unique vertices, wrapping when
+  // b <= a. A whole-ring span (a == b, the single-corner case) has no meaningful
+  // chord, so it falls back to the turning-rate test (a large low-curvature ring
+  // keeps its one corner). Used by the closed-ring corner cull (see
+  // filterRingCornersByStructure in mapshaper-smooth-algos).
+  function isStraightRingSpan(t, channels, n, a, b, params, devLimit) {
+    var lim = devLimit === undefined ? STRAIGHT_DEV_FACTOR : devLimit;
+    var m = n - 1;
+    if (m < 2) return false;
+    if (a === b) return isStructuralRingSpan(t, channels, n, a, b, params);
+    var L = t[n - 1];
+    var len = b > a ? t[b] - t[a] : (L - t[a]) + t[b];
+    if (!(len >= params.minPinRunLen)) return false;
+    var K = channels.length;
+    var A = getPt(channels, K, a);
+    var AB = subv(getPt(channels, K, b), A, K);
+    var abDot = dot(AB, AB, K);
+    if (!(abDot > 0)) return false;
+    var limit2 = lim * lim * abDot;
+    var i = a;
+    while (true) {
+      i = (i + 1) % m;
+      if (i === b) break;
+      if (perpDistSq(channels, K, i, A, AB, abDot) > limit2) return false;
+    }
+    return true;
+  }
+
+  // Straightness limit for pinning a corner whose windowed turn is @turnRad (see
+  // PIN_TURN_RATIO): min(STRAIGHT_DEV_FACTOR, turnRad / (8 * PIN_TURN_RATIO)).
+  function retentionDevLimit(turnRad) {
+    var lim = turnRad / (8 * PIN_TURN_RATIO);
+    return lim < STRAIGHT_DEV_FACTOR ? lim : STRAIGHT_DEV_FACTOR;
+  }
+
+  // Windowed turn (radians) at vertex @i, over params.tangentWindow each side --
+  // the same measure findInteriorCorners uses to flag the corner. @cyclic selects
+  // the open or ring frame.
+  function cornerTurn(t, channels, n, i, cyclic, params) {
+    var K = channels.length;
+    var L = t[n - 1];
+    var m = cyclic ? n - 1 : n;
+    var segLen = cyclic ? ringSegLengths(t, m) : null;
+    return windowedTurn(t, channels, K, n, L, m, segLen, i, params.tangentWindow, cyclic);
+  }
+
+  // Does the open span [a, b] justify pinning the corner at vertex @corner: is it a
+  // straight run (isStraightRun) whose straightness is enough for the corner's turn
+  // angle (retentionDevLimit)? A gentle bend needs a straighter run than a sharp
+  // one. Used by refineBounds.
+  function bordersStraightRun(t, channels, n, corner, a, b, params) {
+    var lim = retentionDevLimit(cornerTurn(t, channels, n, corner, false, params));
+    return isStraightRun(t, channels, a, b, params, lim);
+  }
+
+  // Ring analogue of bordersStraightRun, for the closed-ring corner cull
+  // (filterRingCornersByStructure). @corner is a ring vertex; the span runs from
+  // ring vertex @a to @b (cyclic when b <= a).
+  function bordersStraightRingSpan(t, channels, n, corner, a, b, params) {
+    var lim = retentionDevLimit(cornerTurn(t, channels, n, corner, true, params));
+    return isStraightRingSpan(t, channels, n, a, b, params, lim);
+  }
+
   // --- internals ---
 
   function ringSegLengths(t, m) {
@@ -63448,6 +63925,14 @@ ${svg}
     return angleBetween(subv(pi, pp, K), subv(pn, pi, K), K);
   }
 
+  // Local turn at ring vertex i using cyclic neighbours over m unique vertices.
+  function ringVertexTurn(channels, K, m, i) {
+    var pi = getPt(channels, K, i);
+    var pp = getPt(channels, K, (i - 1 + m) % m);
+    var pn = getPt(channels, K, (i + 1) % m);
+    return angleBetween(subv(pi, pp, K), subv(pn, pi, K), K);
+  }
+
   // Walk from vertex i in direction dir (+1/-1) until accumulated arc length
   // reaches W (or a boundary, for open arcs), returning the reached vertex index.
   function reach(t, segLen, n, m, L, i, dir, W, cyclic) {
@@ -63492,6 +63977,25 @@ ${svg}
     return o;
   }
 
+  function dot(a, b, K) {
+    var d = 0;
+    for (var c = 0; c < K; c++) d += a[c] * b[c];
+    return d;
+  }
+
+  // Squared perpendicular distance of vertex @i from the line through point @A
+  // with direction @AB (abDot = AB.AB). = |AP|^2 - (AP.AB)^2 / |AB|^2.
+  function perpDistSq(channels, K, i, A, AB, abDot) {
+    var apAp = 0, apAb = 0, d;
+    for (var c = 0; c < K; c++) {
+      d = channels[c][i] - A[c];
+      apAp += d * d;
+      apAb += d * AB[c];
+    }
+    var perp = apAp - apAb * apAb / abDot;
+    return perp > 0 ? perp : 0;
+  }
+
   function angleBetween(u, v, K) {
     var d = 0, nu = 0, nv = 0;
     for (var c = 0; c < K; c++) {
@@ -63510,13 +64014,15 @@ ${svg}
   // Scale-aware line smoothing primitives, shared by the -smooth command.
   //
   // The smoother treats a path as coordinate signals parameterized by arc length s
-  // and applies a length-scaled low-pass filter. The user-facing distance is a
-  // resolution: detail with a wavelength around the distance is reduced to roughly
-  // half amplitude (the -6 dB cutoff), finer detail is removed, and features much
-  // larger than the distance pass through nearly unchanged. The distance is not a
-  // deviation bound -- a tall, narrow sub-resolution spike can still be displaced
-  // by an amount comparable to its own amplitude (inherent to convolution
-  // smoothers).
+  // and applies a length-scaled low-pass filter. The user-facing distance is
+  // calibrated so that it approximates the maximum displacement of the smoothed
+  // line from the original at high-displacement features (e.g. acute bends): finer
+  // detail is removed and larger features pass through progressively less changed.
+  // In frequency terms the kernel's half-amplitude (-6 dB) wavelength sits at
+  // roughly KERNEL_STRENGTH * distance, so detail a few times finer than the
+  // distance is strongly attenuated. The distance is not a strict deviation
+  // bound -- a tall, narrow sub-resolution spike can still be displaced by an
+  // amount comparable to its own amplitude (inherent to convolution smoothers).
   //
   // The filter is a local second-degree polynomial fit whose quadratic term
   // corrects the inward shrinkage that plain weighted averaging causes on curved
@@ -63536,21 +64042,44 @@ ${svg}
   // -simplify treats spherical coordinates. The kernel scale stays in true ground
   // distance because arc length is measured with great-circle distance.
   //
-  // The user-facing distance is a *resolution*: detail finer than it is removed, a
-  // feature about its size is reduced to roughly half amplitude, and larger
-  // features are largely preserved. KERNEL_FROM_DISTANCE maps that resolution onto
-  // the internal kernel scale, calibrated empirically so the half-amplitude
-  // (-6 dB) wavelength ~= the distance. The remaining calibration constants are
-  // expressed relative to that internal scale and map it onto kernel widths and
-  // output sampling; they are collected here so the mapping can be retuned in one
-  // place. See docs/reference.md.
+  // KERNEL_FROM_DISTANCE maps the user distance onto the internal reference scale
+  // (tol) that keys corner detection, output sampling and densification. The kernel
+  // itself is then widened by KERNEL_STRENGTH (below), so the distance approximates
+  // the maximum displacement at sharp features and the -6 dB wavelength sits near
+  // KERNEL_STRENGTH * distance. The remaining calibration constants are expressed
+  // relative to the internal scale and map it onto kernel widths and output
+  // sampling; they are collected here so the mapping can be retuned in one place.
+  // See docs/reference.md.
   var KERNEL_FROM_DISTANCE = 1.2;   // internal kernel scale = distance * this
+  // Base smoothing strength baked into the default: the low-pass kernel scale is
+  // this * tol (before the user's `strength` multiplier and the ring cap). It is
+  // calibrated so the distance parameter approximates the maximum displacement of
+  // the smoothed line from the original at high-displacement features (e.g. acute
+  // bends) -- a markedly stronger, more intuitive effect than the raw -6 dB
+  // mapping (which displaced the line far less than the distance). ONLY the kernel
+  // scale is affected; tol -- and therefore corner detection, output sampling, the
+  // prefilter and island dropping -- stays keyed to the raw distance.
+  var KERNEL_STRENGTH = 5;
   var GAUSSIAN_SIGMA_FACTOR = 0.4;  // gaussian sigma = internal scale * this
   var PAEK_SCALE_FACTOR = 0.4;      // exponential kernel scale d = internal scale * this
   var WINDOW_RADIUS_FACTOR = 1.2;   // window half-length = internal scale * this
   var SOURCE_SPACING_FACTOR = 0.25; // densify source to <= tolerance * this before smoothing
   var MAX_OUTPUT_FACTOR = 8;        // cap output (and source) vertices at inputCount * this
   var MIN_CLOSED_SEGMENTS = 16;     // floor on segments for closed rings (so they resolve)
+  // A closed ring cannot be smoothed at a resolution coarser than the ring itself:
+  // once the kernel window (radius = internal scale * WINDOW_RADIUS_FACTOR)
+  // reaches half the ring's perimeter, every output point averages over the whole
+  // loop and the ring degenerates toward a point (a circle once re-inflated). So
+  // for a closed ring the internal scale is capped just below that threshold,
+  // which is factor 1/(2*WINDOW_RADIUS_FACTOR) ~ 0.42. Up to the threshold the
+  // ring keeps its shape (elongated stays elongated, and detail is rounded as much
+  // as the ring's own size allows); the enclosed area it loses to curve-shortening
+  // on the way is restored afterward by restoreRingArea() (a similarity rescale
+  // about the centroid), so a small island is rounded at close to the full
+  // requested scale without shrinking. The cap only binds when the requested
+  // distance nears the ring's own size; large rings (perimeter >> distance) smooth
+  // gently, lose negligible area and are effectively unaffected by either step.
+  var MAX_RING_SCALE_FACTOR = 0.42;
 
   // Output resampling. The smoothed curve is a continuous function of arc length;
   // we sample it densely at a uniform step and then thin that dense polyline with a
@@ -63613,12 +64142,29 @@ ${svg}
     return deg * Math.PI / 180;
   }
 
-  // Resolve the keep-corners run-length bias (default 1). Its inverse scales the
-  // min structural-run length, so a value < 1 protects only longer straight runs
-  // (fewer corners kept) and a value > 1 protects shorter runs (more corners kept).
+  // Resolve the corner-detection bias (default 0 = neutral). This is the raw
+  // user-facing value; getCornerParams / cornerBiasScale convert it into the
+  // multiplier on detection resolution. A positive bias keeps more corners, a
+  // negative bias fewer. Missing/null falls back to neutral.
   function resolveCornerBias(opts) {
     var b = opts.cornerBias;
-    return b > 0 ? b : 1;
+    return (b === undefined || b === null) ? 0 : b;
+  }
+
+  // Resolve the smoothing-strength multiplier (default 1). It scales only the
+  // low-pass kernel (window radius and sigma) relative to the distance, so a value
+  // > 1 smooths more strongly (wider kernel, larger divergence from the original)
+  // and < 1 more gently. Everything else keyed to the distance -- corner detection,
+  // output sampling, the prefilter and island dropping -- is left unchanged.
+  // Non-positive or missing values fall back to 1.
+  //
+  // By design, curve exaggeration (gain > 1) scales WITH strength: gain multiplies
+  // the quadratic curvature correction (a0 - mean) in smoothPoint, and that term is
+  // measured over the strength-scaled kernel window, so a wider kernel amplifies a
+  // given gain. This coupling is intentional -- do not normalize it out.
+  function resolveStrength(opts) {
+    var s = opts.strength;
+    return s > 0 ? s : 1;
   }
 
   function smoothArcCoords(xx, yy, opts) {
@@ -63634,6 +64180,29 @@ ${svg}
     var spherical = !!opts.spherical;
     var keepCorners = !!opts.keepCorners;
     var bendAngle = resolveBendAngle(opts);
+
+    // Cumulative arc length in ground units (meters for spherical data), so the
+    // 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)
+    }
+    // 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).
+    // Only the kernel (radius, sigma) uses this scale; tol -- which drives corner
+    // detection, output sampling and densification -- stays keyed to the raw
+    // distance, so those effects are unaffected by either strength factor.
+    var kernelScale = tol * KERNEL_STRENGTH * resolveStrength(opts);
+    // A closed ring smaller than the smoothing resolution would collapse toward its
+    // centroid, so cap both scales at a fraction of the ring's perimeter (see
+    // MAX_RING_SCALE_FACTOR). This only binds when the requested distance (or the
+    // boosted kernel) approaches the ring's own size; otherwise it is a no-op. The
+    // cap on kernelScale also stops a large `strength` from collapsing a ring.
+    if (closed) {
+      var ringCap = MAX_RING_SCALE_FACTOR * t[n - 1];
+      tol = Math.min(tol, ringCap);
+      kernelScale = Math.min(kernelScale, ringCap);
+    }
     var ctx = {
       tol: tol,
       method: method,
@@ -63646,21 +64215,25 @@ ${svg}
       // segment still turns well under the threshold; never coarsen it beyond the
       // default (the angle filter alone thins the output for larger angles).
       denseStep: tol * DENSE_STEP_FACTOR * Math.min(1, bendAngle / DEFAULT_BEND_ANGLE),
-      radius: tol * WINDOW_RADIUS_FACTOR,
-      scale: (method == 'gaussian' ? GAUSSIAN_SIGMA_FACTOR : PAEK_SCALE_FACTOR) * tol
+      radius: kernelScale * WINDOW_RADIUS_FACTOR,
+      scale: (method == 'gaussian' ? GAUSSIAN_SIGMA_FACTOR : PAEK_SCALE_FACTOR) * kernelScale
     };
-
-    // Cumulative arc length in ground units (meters for spherical data), so the
-    // 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)
-    }
     var channels = spherical ? lngLatToXYZChannels(origX, origY, n) : [origX, origY];
 
     if (closed) {
+      var ringParams = getCornerParams(tol, ctx.cornerBias);
       var corners = keepCorners ?
-        findInteriorCorners(t, channels, n, true, getCornerParams(tol, ctx.cornerBias)) : [];
+        findInteriorCorners(t, channels, n, true, ringParams) : [];
+      // findInteriorCorners flags localized bends by angle alone; it does not check
+      // whether a candidate borders a structural (long, low-curvature) run. Keep
+      // only the corners that do -- a natural ring with no straight segments has
+      // none and must smooth cyclically. Otherwise the ring would be rotated to
+      // corners[0] and smoothed as an open path with that vertex pinned as a
+      // spurious cusp (whose location shifts with the tolerance-scaled detection
+      // window), even though refineBounds later drops every interior breakpoint.
+      if (corners.length > 0) {
+        corners = filterRingCornersByStructure(t, channels, n, corners, ringParams);
+      }
       if (corners.length === 0) {
         return smoothClosedCyclic(t, channels, n, ctx);
       }
@@ -63682,9 +64255,18 @@ ${svg}
   }
 
   // Smooth an open path partitioned at @interiorBreaks (sorted interior vertex
-  // indices). Structural runs are copied verbatim; other spans are smoothed with
-  // their endpoints pinned, so every breakpoint (and the two arc endpoints) keeps
-  // its exact original position. Shared breakpoint vertices are emitted once.
+  // indices). Corner retention and verbatim-copy are two separate decisions:
+  //   - A breakpoint is kept only if it borders a straight run that is straight
+  //     enough for its turn angle (bordersStraightRun -- deviation from the endpoint
+  //     chord, robust to sub-tolerance wiggle, and tightened for gentle bends so a
+  //     soft bend on a borderline-straight run is not pinned); otherwise
+  //     refineBounds drops it.
+  //   - A kept span is copied verbatim only if it is clean per-vertex
+  //     (isStructuralRun); otherwise it is smoothed with its endpoints pinned. So a
+  //     straight-but-noisy border is smoothed into a clean straight line between
+  //     its pinned corners, rather than curving into its neighbours.
+  // Every breakpoint (and the two arc endpoints) keeps its exact original position;
+  // shared breakpoint vertices are emitted once.
   function smoothOpenSpans(origX, origY, t, channels, n, interiorBreaks, ctx) {
     var bounds = [0].concat(interiorBreaks);
     bounds.push(n - 1);
@@ -63704,17 +64286,28 @@ ${svg}
     return {xx: xx, yy: yy};
   }
 
-  // Drop interior breakpoints that don't border any structural run (e.g. spikes
-  // inside a wiggly stretch), merging their spans, until the partition is stable.
-  // Merging can turn two short straight pieces back into one structural run, so
-  // structurality is re-tested each pass.
+  // Drop interior breakpoints that don't border any pinnable straight run (e.g.
+  // spikes inside a wiggly stretch, or -- crucially on sparse/simplified data --
+  // points sampled along a gentle curve), merging their spans, until the partition
+  // is stable. Merging can turn two short pieces back into one straight run, so the
+  // test is repeated each pass. A breakpoint is kept only if an adjacent span is
+  // straight at the smoothing scale AND straight enough for the breakpoint's own
+  // turn angle (bordersStraightRun): deviation from the endpoint chord, tightened
+  // for gentle corners so a soft bend on a borderline-straight run is not pinned.
+  // The older per-vertex turning gate (isStructuralRun) is deliberately NOT used
+  // for retention -- it admits any run bending no tighter than radius
+  // MIN_RUN_RADIUS_FACTOR*tol, i.e. gentle curves, which on coarsely-sampled data
+  // produces spurious corners along smooth bends. (isStructuralRun still governs
+  // verbatim-copy of a kept span; see smoothOpenSpans.) The corner for both
+  // adjacent spans is the breakpoint itself, so its turn angle gates each side.
   function refineBounds(t, channels, bounds, params) {
+    var n = channels[0].length;
     var changed = true;
     while (changed && bounds.length > 2) {
       changed = false;
       for (var i = 1; i < bounds.length - 1; i++) {
-        var leftStruct = isStructuralRun(t, channels, bounds[i - 1], bounds[i], params);
-        var rightStruct = isStructuralRun(t, channels, bounds[i], bounds[i + 1], params);
+        var leftStruct = bordersStraightRun(t, channels, n, bounds[i], bounds[i - 1], bounds[i], params);
+        var rightStruct = bordersStraightRun(t, channels, n, bounds[i], bounds[i], bounds[i + 1], params);
         if (!leftStruct && !rightStruct) {
           bounds.splice(i, 1);
           changed = true;
@@ -63725,6 +64318,39 @@ ${svg}
     return bounds;
   }
 
+  // Drop closed-ring corners that don't border a run worth pinning on either side,
+  // merging their (cyclic) spans, until the set is stable -- the cyclic analogue
+  // of refineBounds, applied before the ring is rotated/pinned. A single corner
+  // is tested against the whole-ring span. Uses the same angle-coupled
+  // chord-straightness criterion as refineBounds (see bordersStraightRingSpan).
+  // Returns the surviving corners (a subset of @corners, order preserved); an empty
+  // result means the ring has no qualifying corner and should smooth cyclically.
+  function filterRingCornersByStructure(t, channels, n, corners, params) {
+    var list = corners.slice();
+    var changed = true;
+    while (changed && list.length > 0) {
+      changed = false;
+      for (var i = 0; i < list.length; i++) {
+        var cur = list[i];
+        var leftStruct, rightStruct;
+        if (list.length === 1) {
+          leftStruct = rightStruct = bordersStraightRingSpan(t, channels, n, cur, cur, cur, params);
+        } else {
+          var prev = list[(i - 1 + list.length) % list.length];
+          var next = list[(i + 1) % list.length];
+          leftStruct = bordersStraightRingSpan(t, channels, n, cur, prev, cur, params);
+          rightStruct = bordersStraightRingSpan(t, channels, n, cur, cur, next, params);
+        }
+        if (!leftStruct && !rightStruct) {
+          list.splice(i, 1);
+          changed = true;
+          break;
+        }
+      }
+    }
+    return list;
+  }
+
   // Smooth a single open span [lo, hi] (inclusive) and pin both ends to their
   // original coordinates. Reuses the whole-arc smoothing pipeline on the sub-arc.
   function smoothSpanOpen(origX, origY, t, channels, lo, hi, ctx) {
@@ -63756,6 +64382,10 @@ ${svg}
     var dense = densifyChannels(t, channels, maxSpacing);
     var src = buildSource(dense.t, dense.channels, true, ctx.radius, L);
     var sm = sampleSmoothedCurve(src, 0, L, true, ctx, n);
+    // Smoothing shrinks a closed loop (curve-shortening); restore its original
+    // enclosed area so small rings can be rounded at the full scale without
+    // shrinking. A no-op for large rings (they lose negligible area).
+    restoreRingArea(sm, channels, n, ctx.spherical);
     var out = ctx.spherical ? xyzChannelsToLngLat(sm) : {xx: sm[0], yy: sm[1]};
     // force an exactly closed ring (the periodic endpoints are equal up to fp)
     out.xx[out.xx.length - 1] = out.xx[0];
@@ -63763,6 +64393,98 @@ ${svg}
     return out;
   }
 
+  // Rescale a smoothed closed ring about its centroid so it re-encloses the
+  // original ring's area. Because it is a uniform similarity transform, the
+  // smoothed *shape* is unchanged -- only its size -- so the rounding introduced by
+  // smoothing is preserved while the curve-shortening shrinkage is undone.
+  // @sm are the smoothed smoothing channels (plain arrays; [x,y] planar or unit-
+  // sphere [X,Y,Z] spherical, last point == first). @orig are the original channels
+  // (length @n, closed). Silent no-op if either area is non-positive.
+  function restoreRingArea(sm, orig, n, spherical) {
+    var origArea = ringChannelArea(orig, n, spherical);
+    var m = sm[0].length;
+    var smArea = ringChannelArea(sm, m, spherical);
+    if (!(origArea > 0) || !(smArea > 0)) return;
+    var f = Math.sqrt(origArea / smArea);
+    if (spherical) {
+      scaleRingSpherical(sm, m, f);
+    } else {
+      scaleRingPlanar(sm, m, f);
+    }
+  }
+
+  // Enclosed-area proxy of a closed ring (@count points, last == first). Planar:
+  // the shoelace area on (x,y). Spherical: the shoelace area of the ring projected
+  // into the tangent plane at its centroid direction. Only ratios of two such
+  // areas are used, so the (unit-sphere) scale is irrelevant, and the tangent-plane
+  // error is second order in the ring's size -- negligible for the small rings
+  // where this is needed.
+  function ringChannelArea(ch, count, spherical) {
+    if (!spherical) {
+      var x = ch[0], y = ch[1], a = 0;
+      for (var i = 0; i < count - 1; i++) a += x[i] * y[i + 1] - x[i + 1] * y[i];
+      return Math.abs(a / 2);
+    }
+    var basis = tangentBasis(ringCentroidDir(ch, count - 1));
+    var ex = basis.ex, ey = basis.ey;
+    var X = ch[0], Y = ch[1], Z = ch[2], area = 0, px, py, qx, qy;
+    for (var j = 0; j < count - 1; j++) {
+      px = X[j] * ex[0] + Y[j] * ex[1] + Z[j] * ex[2];
+      py = X[j] * ey[0] + Y[j] * ey[1] + Z[j] * ey[2];
+      qx = X[j + 1] * ex[0] + Y[j + 1] * ex[1] + Z[j + 1] * ex[2];
+      qy = X[j + 1] * ey[0] + Y[j + 1] * ey[1] + Z[j + 1] * ey[2];
+      area += px * qy - qx * py;
+    }
+    return Math.abs(area / 2);
+  }
+
+  function scaleRingPlanar(sm, count, f) {
+    var x = sm[0], y = sm[1], cx = 0, cy = 0, i;
+    for (i = 0; i < count - 1; i++) { cx += x[i]; cy += y[i]; }
+    cx /= (count - 1); cy /= (count - 1);
+    for (i = 0; i < count; i++) {
+      x[i] = cx + (x[i] - cx) * f;
+      y[i] = cy + (y[i] - cy) * f;
+    }
+  }
+
+  // Scale each unit-sphere point's angular offset from the centroid direction by
+  // ~f (keeping the radial component, then renormalizing), which scales the
+  // enclosed area by ~f^2 for the small caps where this runs.
+  function scaleRingSpherical(sm, count, f) {
+    var X = sm[0], Y = sm[1], Z = sm[2];
+    var c = ringCentroidDir(sm, count - 1);
+    for (var i = 0; i < count; i++) {
+      var dot = X[i] * c[0] + Y[i] * c[1] + Z[i] * c[2];
+      var tx = X[i] - dot * c[0], ty = Y[i] - dot * c[1], tz = Z[i] - dot * c[2];
+      var vx = dot * c[0] + f * tx, vy = dot * c[1] + f * ty, vz = dot * c[2] + f * tz;
+      var nrm = Math.sqrt(vx * vx + vy * vy + vz * vz) || 1;
+      X[i] = vx / nrm; Y[i] = vy / nrm; Z[i] = vz / nrm;
+    }
+  }
+
+  function ringCentroidDir(ch, m) {
+    var X = ch[0], Y = ch[1], Z = ch[2], cx = 0, cy = 0, cz = 0;
+    for (var i = 0; i < m; i++) { cx += X[i]; cy += Y[i]; cz += Z[i]; }
+    var nrm = Math.sqrt(cx * cx + cy * cy + cz * cz) || 1;
+    return [cx / nrm, cy / nrm, cz / nrm];
+  }
+
+  // Orthonormal tangent basis (ex, ey) at unit direction c on the sphere.
+  function tangentBasis(c) {
+    // pick the world axis least aligned with c to avoid a degenerate cross product
+    var ax = Math.abs(c[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+    var ex = cross(c, ax);
+    var en = Math.sqrt(ex[0] * ex[0] + ex[1] * ex[1] + ex[2] * ex[2]) || 1;
+    ex = [ex[0] / en, ex[1] / en, ex[2] / en];
+    var ey = cross(c, ex);
+    return {c: c, ex: ex, ey: ey};
+  }
+
+  function cross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  }
+
   function copySpan(origX, origY, lo, hi) {
     var xx = [], yy = [];
     for (var i = lo; i <= hi; i++) {
@@ -64202,11 +64924,12 @@ ${svg}
       stop$1('Expected prefilter-gate to be a number > 0');
     }
     if (opts.corner_bias !== undefined && opts.corner_bias !== null &&
-        !(opts.corner_bias >= 0)) {
-      stop$1('Expected corner-bias to be a number >= 0');
+        typeof opts.corner_bias != 'number') {
+      stop$1('Expected corner-bias to be a number');
     }
-    // Corner preservation is on by default; no-corners or corner-bias=0 turns it off.
-    var keepCorners = !opts.no_corners && opts.corner_bias !== 0;
+    // Corner preservation is on by default; no-corners turns it off. (corner-bias
+    // only tunes sensitivity: 0 is neutral, not off.)
+    var keepCorners = !opts.no_corners;
     var implicitlySmoothedNames = getImplicitlyTargetedLayerNames(dataset, targetLayers, layerHasPaths);
 
     // Smoothing rewrites coordinates, so lock in any pending (non-destructive)
@@ -64225,6 +64948,8 @@ ${svg}
       filterDetailPaths(arcs, {
         distance: tolerance,
         tortuosity: opts.prefilter_gate,
+        roundness: opts.prefilter_roundness,
+        minRingArea: opts.prefilter_min_area,
         spherical: spherical
       });
       var removed = before - arcs.getPointCount();
@@ -64240,6 +64965,7 @@ ${svg}
       keepCorners: keepCorners,
       cornerBias: opts.corner_bias,
       gain: opts.gain,
+      strength: opts.strength,
       maxBendAngle: opts.max_bend_angle
     });
 
@@ -64268,6 +64994,7 @@ ${svg}
         keepCorners: opts.keepCorners,
         cornerBias: opts.cornerBias,
         gain: opts.gain,
+        strength: opts.strength,
         maxBendAngle: opts.maxBendAngle,
         closed: arcs.arcIsClosed(arcId)
       });
@@ -66085,7 +66812,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.34";
+  var version = "0.7.36";
 
   // 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.