@math.gl/geospatial 5.0.0-beta.1 → 5.0.0-beta.2

package/src/discontinuous/map-layout.ts

@@ -54,15 +54,40 @@ export type MapSeam = {
   kind: 'join' | 'cut' | 'boundary';
 };
 export type MapPoint = {regionId: string; position: Position};
-export type MapLine = {regionId: string; coordinates: Position[]; sourceCoordinates: Position[]};
+export type MapLine = {
+  regionId: string;
+  coordinates: Position[];
+  sourceCoordinates: Position[];
+  provenance?: {
+    segments: number[];
+    parameters: number[];
+    vertices: number[];
+    angularDistances: number[];
+    startReason?: string;
+    endReason?: string;
+  };
+};
+export type MapPolygonEdge = {
+  kind: 'source-boundary' | 'coverage-boundary' | 'chart-cut' | 'continuous-chart-join';
+  ring: number;
+  segment: number;
+  t0: number;
+  t1: number;
+};
 export type MapPolygon = {
   regionId: string;
   coordinates: Position[][];
   sourceCoordinates: Position[][];
+  edgeProvenance?: MapPolygonEdge[][];
 };
 export type MapSamplingOptions = {
   /** Maximum angular sampling interval in degrees. Default 2, range (0, 90]. */
   maxAngularStep?: number;
+  /** Opt-in minor-great-circle source lineage, recorded during clipping/sampling. */
+  pathProvenance?: boolean;
+  pathDistances?: boolean;
+  pathBoundaries?: boolean;
+  polygonEdgeProvenance?: boolean;
   /** Midpoint chord-error target in placed output units. Default 1e-4. */
   tolerance?: number;
 };
@@ -243,6 +268,10 @@ export class DiscontinuousMap {
     const points = line.map(geographic);
     for (let i = 1; i < points.length; i++) validateArc(points[i - 1], points[i]);
     const results: MapLine[] = [];
+    const cumulative = options.pathDistances ? [0] : undefined;
+    if (cumulative)
+      for (let i = 1; i < points.length; i++)
+        cumulative.push(cumulative[i - 1] + angle(points[i - 1], points[i]));
     for (const r of this.compiled) {
       let current: MapLine | null = null;
       for (let i = 1; i < points.length; i++) {
@@ -251,6 +280,25 @@ export class DiscontinuousMap {
           current = null;
           continue;
         }
+        const reason = (p: Vector, endpoint: Vector, isEndpoint: boolean) => {
+          if (isEndpoint && angle(p, endpoint) < 1e-12) return 'source-endpoint';
+          const kinds = r.normals
+            .map((normal, edge) =>
+              Math.abs(dot(normal, p)) < 1e-9
+                ? this.seams.find(s =>
+                    s.regions.some((id, i) => id === r.definition.id && s.edges[i] === edge)
+                  )?.kind
+                : undefined
+            )
+            .filter(Boolean);
+          return kinds.includes('boundary')
+            ? 'coverage-boundary'
+            : kinds.includes('cut')
+              ? 'chart-cut'
+              : kinds.includes('join')
+                ? 'continuous-chart-join'
+                : 'coverage-boundary';
+        };
         const sampled = this.sample(r, clipped[0], clipped[1], settings);
         if (sampled.length < 2) continue;
         if (
@@ -265,12 +313,33 @@ export class DiscontinuousMap {
           )
         ) {
           current = {regionId: r.definition.id, coordinates: [], sourceCoordinates: []};
+          if (options.pathProvenance)
+            current.provenance = {segments: [], parameters: [], vertices: [], angularDistances: []};
+          if (current.provenance && options.pathBoundaries)
+            current.provenance.startReason = reason(clipped[0], points[0], i === 1);
           results.push(current);
         } else sampled.shift();
         for (const p of sampled) {
           current.coordinates.push(this.project(r, p));
           current.sourceCoordinates.push(coordinates(p));
+          if (current.provenance) {
+            const length = angle(points[i - 1], points[i]);
+            const t = length ? Math.min(1, Math.max(0, angle(points[i - 1], p) / length)) : 0;
+            current.provenance.segments.push(i - 1);
+            current.provenance.parameters.push(t);
+            current.provenance.vertices.push(
+              angle(points[i - 1], p) < 1e-12 ? i - 1 : angle(points[i], p) < 1e-12 ? i : 0xffffffff
+            );
+            if (cumulative)
+              current.provenance.angularDistances.push(cumulative[i - 1] + t * length);
+          }
         }
+        if (current.provenance && options.pathBoundaries)
+          current.provenance.endReason = reason(
+            clipped[1],
+            points[points.length - 1],
+            i === points.length - 1
+          );
         // Even an excursion returning to the same seam point starts a new part.
         if (!this.contains(r, points[i])) current = null;
       }
@@ -392,24 +461,118 @@ export class DiscontinuousMap {
           coordinates: [],
           sourceCoordinates: []
         };
+        if (options.polygonEdgeProvenance) output.edgeProvenance = [];
         polygon.forEach((ring, index) => {
           const sphere = ring.map(p => unit(add(center, add(scale(x, p[0]), scale(y, p[1])))));
           const points: Vector[] = [];
+          const edges: MapPolygonEdge[] = [];
+          const classify = (a: Vector, b: Vector): MapPolygonEdge => {
+            // Directional pole copies can differ in floating-point coordinates
+            // while describing the same source direction. Their zero-length
+            // connector is computational, never an original boundary.
+            if (angle(a, b) < 64 * Number.EPSILON)
+              return {
+                kind: 'continuous-chart-join',
+                ring: 0xffffffff,
+                segment: 0xffffffff,
+                t0: 0,
+                t1: 0
+              };
+            // Attribute the boolean boundary in the source clipping chart, before
+            // projection/resampling. Original constraints win on coincident cuts.
+            const candidates: {ring: number; segment: number}[] = [];
+            vectors.forEach((source, ring) =>
+              source.forEach((u, segment) => {
+                const v = source[(segment + 1) % source.length],
+                  length = angle(u, v);
+                if (
+                  length > 1e-12 &&
+                  [a, b].every(
+                    p =>
+                      Math.abs(dot(unit(cross(u, v)), p)) < 1e-12 &&
+                      Math.abs(angle(u, p) + angle(p, v) - length) < 1e-10
+                  )
+                )
+                  candidates.push({ring, segment});
+              })
+            );
+            if (candidates.length > 1) throw new Error('Ambiguous polygon boundary provenance');
+            if (candidates.length) {
+              const {ring, segment} = candidates[0],
+                source = vectors[ring],
+                u = source[segment],
+                length = angle(u, source[(segment + 1) % source.length]);
+              return {
+                kind: 'source-boundary',
+                ring,
+                segment,
+                t0: Math.min(1, angle(u, a) / length),
+                t1: Math.min(1, angle(u, b) / length)
+              };
+            }
+            const kinds = r.normals
+              .map((n, edge) =>
+                [a, b].every(p => Math.abs(dot(n, p)) < 1e-9)
+                  ? this.seams.find(s =>
+                      s.regions.some((id, i) => id === r.definition.id && s.edges[i] === edge)
+                    )?.kind
+                  : undefined
+              )
+              .filter(Boolean);
+            if (!kinds.length) throw new Error('Unknown polygon clipping constraint');
+            return {
+              kind: kinds.includes('boundary')
+                ? 'coverage-boundary'
+                : kinds.includes('cut')
+                  ? 'chart-cut'
+                  : 'continuous-chart-join',
+              ring: 0xffffffff,
+              segment: 0xffffffff,
+              t0: 0,
+              t1: 0
+            };
+          };
           for (let i = 1; i < sphere.length; i++) {
+            const origin =
+              options.polygonEdgeProvenance &&
+              !sphere[i - 1].every((value, k) => value === sphere[i][k])
+                ? classify(sphere[i - 1], sphere[i])
+                : undefined;
             const sampled = this.sample(r, sphere[i - 1], sphere[i], settings);
             for (const point of sampled) {
               const previous = points[points.length - 1];
-              if (!previous || !point.every((value, k) => value === previous[k]))
+              if (!previous || !point.every((value, k) => value === previous[k])) {
+                if (previous && origin) {
+                  const edge = {...origin};
+                  if (edge.kind === 'source-boundary') {
+                    const source = vectors[edge.ring],
+                      u = source[edge.segment],
+                      length = angle(u, source[(edge.segment + 1) % source.length]);
+                    edge.t0 = Math.min(1, angle(u, previous) / length);
+                    edge.t1 = Math.min(1, angle(u, point) / length);
+                  }
+                  edges.push(edge);
+                }
                 points.push(point);
+              }
             }
           }
           if (points.length < 3) return;
           if (points[points.length - 1].every((value, k) => value === points[0][k])) points.pop();
+          if (options.polygonEdgeProvenance && edges.length < points.length)
+            edges.push(classify(points[points.length - 1], points[0]));
           points.push(points[0]);
           const xy = points.map(p => this.project(r, p));
           if (ringOrientation(xy) > 0 !== (index === 0)) {
             xy.reverse();
             points.reverse();
+            edges.reverse();
+            for (const e of edges) [e.t0, e.t1] = [e.t1, e.t0];
+          }
+          if (output.edgeProvenance) {
+            if (edges.length !== points.length - 1)
+              throw new Error('Mismatched polygon edge provenance');
+            output.edgeProvenance.push(edges);
           }
           output.coordinates.push(xy);
           output.sourceCoordinates.push(points.map(coordinates));

package/src/discontinuous/map-transition.ts

@@ -7,6 +7,71 @@ import type {GeographicPosition, MapSamplingOptions, MapRegion} from './map-layo
 import {geographic, type Position} from './math';
 import {rectangle} from './elastic/geometry';
 
+// Qualified default world formulas with finite coverage and no interior cuts.
+// Keep this explicit: a newly registered kernel is not automatically qualified.
+// Bertin and Sinu-Mollweide need rotated-chart coverage fixes; Gringorten has
+// interior cuts. Singular or folded formulas and parameter overrides remain
+// conservative until their endpoint coverage and correspondence are qualified.
+const directWorldProjections = new Set([
+  'gilbert',
+  'aitoff',
+  'august',
+  'baker',
+  'boggs',
+  'bromley',
+  'collignon',
+  'craster',
+  'eckert1',
+  'eckert2',
+  'eckert3',
+  'eckert4',
+  'eckert5',
+  'eckert6',
+  'fahey',
+  'foucaut',
+  'ginzburg4',
+  'ginzburg5',
+  'ginzburg6',
+  'ginzburg8',
+  'ginzburg9',
+  'homolosine',
+  'kavrayskiy7',
+  'larrivee',
+  'laskowski',
+  'miller',
+  'mollweide',
+  'mt-flat-polar-parabolic',
+  'mt-flat-polar-quartic',
+  'mt-flat-polar-sinusoidal',
+  'natural-earth2',
+  'nell-hammer',
+  'patterson',
+  'robinson',
+  'sinusoidal',
+  'times',
+  'van-der-grinten',
+  'van-der-grinten2',
+  'van-der-grinten3',
+  'van-der-grinten4',
+  'wagner4',
+  'wagner6',
+  'winkel3',
+  'bonne',
+  'bottomley',
+  'cylindrical-equal-area',
+  'cylindrical-stereographic',
+  'foucaut-sinusoidal',
+  'hammer',
+  'hill',
+  'hufnagel',
+  'hyperelliptical',
+  'lagrange',
+  'loximuthal',
+  'wagner7',
+  'quartic-authalic',
+  'wagner'
+]);
+
 export type MapTransitionOptions = {strategy?: 'auto' | 'direct' | 'via-globe'};
 export type MapTransitionPart = Readonly<{
   kind: 'line' | 'polygon';
@@ -316,9 +381,8 @@ function fullCoverage(map: MapEngine): boolean {
     covered =
       completeSections && !overlaps && polygonClipping.difference(world, ...domains).length === 0;
   } else if (d.type === 'world') {
-    // Deliberately bounded to global formulas with finite poles. Other kernels,
-    // custom charts and regional maps retain the conservative globe route.
-    covered = ['sinusoidal', 'mollweide', 'robinson'].includes(d.projection);
+    covered =
+      directWorldProjections.has(d.projection) && Object.keys(d.parameters ?? {}).length === 0;
   }
   coverageCache.set(map, covered);
   return covered;

package/src/discontinuous/mercator-map.ts

@@ -3,6 +3,8 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 import polygonClipping from 'polygon-clipping';
+import {tracePolygonConstraints, composePolygonEdge} from './polygon-constraints';
+import {sourceArc} from './source-arc';
 import {
   DiscontinuousMap,
   type GeographicPosition,
@@ -10,7 +12,7 @@ import {
   type MapRegion,
   type MapSamplingOptions
 } from './map-layout';
-import {geographic, RAD, type Vector} from './math';
+import {angle, coordinates, geographic, RAD, unit, type Vector} from './math';
 
 /** Spherical Mercator, clipped to a finite latitude band after seam splitting. */
 export class MercatorMap extends DiscontinuousMap {
@@ -117,18 +119,83 @@ export class MercatorMap extends DiscontinuousMap {
           continue;
         }
         const at = (t: number): [number, number] => [a[0] + (b[0] - a[0]) * t, a[1] + dy * t];
-        const start = at(t0),
-          end = at(t1);
+        // Locate the latitude cut on the sampled source great-circle arc, not
+        // on its projected chord. Retain the parent segment throughout this stage.
+        const endpoint = (t: number) => {
+          if (t === 0 || t === 1) return {xy: at(t), source: part.sourceCoordinates[i - 1 + t], t};
+          const va = geographic(part.sourceCoordinates[i - 1]),
+            vb = geographic(part.sourceCoordinates[i]),
+            arc = angle(va, vb);
+          const sourceAt = (t: number) => {
+            if (!arc) return part.sourceCoordinates[i - 1];
+            const a = Math.sin((1 - t) * arc) / Math.sin(arc),
+              b = Math.sin(t * arc) / Math.sin(arc);
+            return coordinates(unit(va.map((v, k) => a * v + b * vb[k]) as Vector));
+          };
+          const latitude = Math.sign(at(t)[1]) * this.limit;
+          let lo = 0,
+            hi = 1;
+          for (let j = 0; j < 52; j++) {
+            const mid = (lo + hi) / 2;
+            if (sourceAt(mid)[1] < latitude === part.sourceCoordinates[i - 1][1] < latitude)
+              lo = mid;
+            else hi = mid;
+          }
+          const f = (lo + hi) / 2,
+            source = sourceAt(f);
+          const xy = super.projectPoint(source, part.regionId)!.position;
+          return {xy, source, t: f};
+        };
+        const start = endpoint(t0),
+          end = endpoint(t1);
+        const append = (point: typeof start, index: number) => {
+          current!.coordinates.push(point.xy);
+          current!.sourceCoordinates.push(point.source);
+          const source = part.provenance,
+            target = current!.provenance;
+          if (!source || !target) return;
+          const segment = source.segments[i];
+          const from = source.segments[i - 1] === segment ? source.parameters[i - 1] : 0;
+          target.segments.push(point.t === 0 || point.t === 1 ? source.segments[index] : segment);
+          target.parameters.push(
+            point.t === 0 || point.t === 1
+              ? source.parameters[index]
+              : from + point.t * (source.parameters[i] - from)
+          );
+          target.vertices.push(
+            point.t === 0 || point.t === 1 ? source.vertices[index] : 0xffffffff
+          );
+          if (options?.pathDistances)
+            target.angularDistances.push(
+              source.angularDistances[i - 1] +
+                point.t * (source.angularDistances[i] - source.angularDistances[i - 1])
+            );
+        };
         if (!current || t0 > 0) {
           current = {
             regionId: part.regionId,
-            coordinates: [start],
-            sourceCoordinates: [this.source(start)]
+            coordinates: [],
+            sourceCoordinates: [],
+            ...(part.provenance
+              ? {
+                  provenance: {
+                    segments: [],
+                    parameters: [],
+                    vertices: [],
+                    angularDistances: [],
+                    ...(options?.pathBoundaries
+                      ? {startReason: t0 > 0 ? 'coverage-boundary' : part.provenance.startReason}
+                      : {})
+                  }
+                }
+              : {})
           };
           result.push(current);
+          append(start, i - 1);
         }
-        current.coordinates.push(end);
-        current.sourceCoordinates.push(this.source(end));
+        append(end, i);
+        if (current.provenance && options?.pathBoundaries)
+          current.provenance.endReason = t1 < 1 ? 'coverage-boundary' : part.provenance!.endReason;
         if (t1 < 1) current = undefined;
       }
     }
@@ -150,11 +217,83 @@ export class MercatorMap extends DiscontinuousMap {
       ]
     ];
     return super.projectPolygon(rings, options).flatMap(part =>
-      polygonClipping.intersection(part.coordinates, box).map(coordinates => ({
-        regionId: part.regionId,
-        coordinates,
-        sourceCoordinates: coordinates.map(ring => ring.map(p => this.source(p)))
-      }))
+      polygonClipping.intersection(part.coordinates, box).map(polygon => {
+        const traced = tracePolygonConstraints(
+          part.coordinates,
+          polygon,
+          1e-10,
+          part.edgeProvenance
+        );
+        const sources = traced.rings.map(r => r.map(p => this.source(p)));
+        traced.owners.forEach((owners, r) =>
+          owners.forEach((owner, i) => {
+            if (!owner) return;
+            const [parentRing, parentEdge] = owner,
+              a = part.sourceCoordinates[parentRing][parentEdge],
+              b = part.sourceCoordinates[parentRing][parentEdge + 1],
+              at = sourceArc(a, b);
+            for (const j of [i, i + 1]) {
+              const q = traced.rings[r][j],
+                first = part.coordinates[parentRing][parentEdge],
+                last = part.coordinates[parentRing][parentEdge + 1];
+              if (Math.hypot(q[0] - first[0], q[1] - first[1]) < 1e-10 * this.radius)
+                sources[r][j] = [...a];
+              else if (Math.hypot(q[0] - last[0], q[1] - last[1]) < 1e-10 * this.radius)
+                sources[r][j] = [...b];
+              else {
+                const latitude = Math.sign(q[1]) * this.limit;
+                let lo = 0,
+                  hi = 1;
+                if (a[1] < latitude === b[1] < latitude)
+                  throw new Error('Unresolved Mercator source constraint intersection');
+                for (let k = 0; k < 52; k++) {
+                  const mid = (lo + hi) / 2;
+                  if (at(mid)[1] < latitude === a[1] < latitude) lo = mid;
+                  else hi = mid;
+                }
+                sources[r][j] = at((lo + hi) / 2);
+              }
+            }
+          })
+        );
+        for (const r of sources) r[r.length - 1] = [...r[0]];
+        return {
+          regionId: part.regionId,
+          sourceCoordinates: sources,
+          coordinates: sources.map(r => r.map(p => super.projectPoint(p, part.regionId)!.position)),
+          ...(options?.polygonEdgeProvenance
+            ? {
+                edgeProvenance: traced.owners.map((owners, r) =>
+                  owners.map((owner, i) => {
+                    if (owner) {
+                      const [pr, pe] = owner;
+                      return composePolygonEdge(
+                        part.edgeProvenance![pr][pe],
+                        part.sourceCoordinates[pr][pe],
+                        part.sourceCoordinates[pr][pe + 1],
+                        sources[r][i],
+                        sources[r][i + 1]
+                      );
+                    }
+                    if (
+                      !sources[r]
+                        .slice(i, i + 2)
+                        .every(p => Math.abs(Math.abs(p[1]) - this.limit) < 1e-7)
+                    )
+                      throw new Error('Unknown Mercator clipping constraint');
+                    return {
+                      kind: 'coverage-boundary' as const,
+                      ring: 0xffffffff,
+                      segment: 0xffffffff,
+                      t0: 0,
+                      t1: 0
+                    };
+                  })
+                )
+              }
+            : {})
+        };
+      })
     );
   }
 }

package/src/discontinuous/polygon-constraints.ts

@@ -0,0 +1,184 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import {angle, geographic, type Position} from './math';
+import type {MapPolygonEdge} from './map-layout';
+export type ConstraintOwner = readonly [ring: number, edge: number] | null;
+/** Attribute boolean output to indexed input constraints before final map
+ * projection/resampling. Restore vertices erased by collinear-edge merging.
+ * Ambiguous ancestry rejects; target rendering coordinates never identify an
+ * original source segment. The caller owns this computational clipping chart.
+ */
+export function tracePolygonConstraints(
+  input: Position[][],
+  output: Position[][],
+  tolerance = 1e-10,
+  priorities?: MapPolygonEdge[][],
+  accept?: (point: Position) => boolean,
+  degenerate?: (a: Position, b: Position) => boolean
+) {
+  const constraints = input.flatMap((ring, r) =>
+    ring.slice(0, -1).map((a, i) => ({a, b: ring[i + 1], r, i}))
+  );
+  let work = 0;
+  const tick = () => {
+    if (++work > 20000000) throw new Error('Polygon constraint work limit exceeded');
+  };
+  const fraction = (p: Position, a: Position, b: Position) => {
+    const dx = b[0] - a[0],
+      dy = b[1] - a[1],
+      l = dx * dx + dy * dy;
+    return l ? ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l : NaN;
+  };
+  const on = (p: Position, a: Position, b: Position) => {
+    tick();
+    const t = fraction(p, a, b),
+      length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    return (
+      length > 0 &&
+      t >= -tolerance &&
+      t <= 1 + tolerance &&
+      Math.hypot(p[0] - a[0] - t * (b[0] - a[0]), p[1] - a[1] - t * (b[1] - a[1])) <=
+        tolerance * Math.max(1, length)
+    );
+  };
+  type Box = readonly [number, number, number, number];
+  type Node = {box: Box; ids?: number[]; left?: Node; right?: Node};
+  const boxes: Box[] = constraints.map(c => [
+    Math.min(c.a[0], c.b[0]),
+    Math.min(c.a[1], c.b[1]),
+    Math.max(c.a[0], c.b[0]),
+    Math.max(c.a[1], c.b[1])
+  ]);
+  const build = (ids: number[]): Node => {
+    const box: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const id of ids) {
+      tick();
+      const b = boxes[id];
+      box[0] = Math.min(box[0], b[0]);
+      box[1] = Math.min(box[1], b[1]);
+      box[2] = Math.max(box[2], b[2]);
+      box[3] = Math.max(box[3], b[3]);
+    }
+    if (ids.length <= 16) return {box, ids};
+    const axis = box[2] - box[0] >= box[3] - box[1] ? 0 : 1;
+    ids.sort((a, b) => {
+      tick();
+      return boxes[a][axis] + boxes[a][axis + 2] - boxes[b][axis] - boxes[b][axis + 2];
+    });
+    const middle = Math.floor(ids.length / 2);
+    return {box, left: build(ids.slice(0, middle)), right: build(ids.slice(middle))};
+  };
+  const root = build(constraints.map((_, i) => i));
+  const padding = tolerance * Math.max(1, root.box[2] - root.box[0], root.box[3] - root.box[1]);
+  const query = (a: Position, b: Position) => {
+    const box: Box = [
+        Math.min(a[0], b[0]) - padding,
+        Math.min(a[1], b[1]) - padding,
+        Math.max(a[0], b[0]) + padding,
+        Math.max(a[1], b[1]) + padding
+      ],
+      ids: number[] = [];
+    const overlaps = (b: Box) =>
+      b[0] <= box[2] && b[2] >= box[0] && b[1] <= box[3] && b[3] >= box[1];
+    const visit = (node: Node) => {
+      tick();
+      if (!overlaps(node.box)) return;
+      if (node.ids) {
+        for (const id of node.ids) {
+          tick();
+          if (overlaps(boxes[id])) ids.push(id);
+        }
+      } else {
+        visit(node.left!);
+        visit(node.right!);
+      }
+    };
+    visit(root);
+    return ids.map(id => constraints[id]);
+  };
+  const rings: Position[][] = [],
+    owners: ConstraintOwner[][] = [];
+  for (const ring of output) {
+    const points: Position[] = [];
+    for (let i = 1; i < ring.length; i++) {
+      const a = ring[i - 1],
+        b = ring[i];
+      if (a.every((v, k) => v === b[k])) continue;
+      const breaks: {t: number; p: Position}[] = [{t: 0, p: a}];
+      for (const c of query(a, b))
+        if (on(c.a, a, b) && (!accept || accept(c.a))) {
+          const t = fraction(c.a, a, b);
+          if (t > 1e-12 && t < 1 - 1e-12) breaks.push({t, p: c.a});
+        }
+      breaks.sort((a, b) => a.t - b.t);
+      for (const item of breaks)
+        if (
+          !points.length ||
+          Math.hypot(...points[points.length - 1].map((v, k) => v - item.p[k])) > 1e-14
+        )
+          points.push([...item.p]);
+    }
+    if (points.length < 3) continue;
+    points.push([...points[0]]);
+    const tags: ConstraintOwner[] = [];
+    for (let i = 1; i < points.length; i++) {
+      const a = points[i - 1],
+        b = points[i];
+      if (degenerate?.(a, b)) {
+        tags.push(null);
+        continue;
+      }
+      let candidates = query(a, b).filter(c => on(a, c.a, c.b) && on(b, c.a, c.b));
+      const same = (p: Position, q: Position) =>
+        Math.hypot(...p.map((v, k) => v - q[k])) <=
+        64 * Number.EPSILON * Math.max(1, ...p.map(Math.abs), ...q.map(Math.abs));
+      const exact = candidates.filter(
+        c => (same(a, c.a) && same(b, c.b)) || (same(a, c.b) && same(b, c.a))
+      );
+      if (exact.length) candidates = exact;
+      if (candidates.some(c => priorities?.[c.r]?.[c.i]?.kind === 'source-boundary'))
+        candidates = candidates.filter(c => priorities?.[c.r]?.[c.i]?.kind === 'source-boundary');
+      if (candidates.length > 1) {
+        const score = (c: (typeof candidates)[number]) =>
+          Math.max(
+            ...[a, b].map(p => {
+              const t = Math.min(1, Math.max(0, fraction(p, c.a, c.b)));
+              return Math.hypot(
+                p[0] - c.a[0] - t * (c.b[0] - c.a[0]),
+                p[1] - c.a[1] - t * (c.b[1] - c.a[1])
+              );
+            })
+          );
+        candidates.sort((a, b) => score(a) - score(b));
+        const epsilon = 64 * Number.EPSILON * Math.max(1, ...a.map(Math.abs), ...b.map(Math.abs));
+        if (score(candidates[1]) - score(candidates[0]) > epsilon) candidates = [candidates[0]];
+        else if (Math.hypot(a[0] - b[0], a[1] - b[1]) <= 2 * epsilon) candidates = [];
+        else throw new Error('Ambiguous polygon clipping constraint ancestry');
+      }
+      tags.push(candidates.length ? [candidates[0].r, candidates[0].i] : null);
+    }
+    rings.push(points);
+    owners.push(tags);
+  }
+  return {rings, owners};
+}
+/** Compose directed fractions through a known parent edge; never search raw
+ * input geometry for an original segment after resampling or projection. */
+export function composePolygonEdge(
+  parent: MapPolygonEdge,
+  a: Position,
+  b: Position,
+  start: Position,
+  end: Position
+): MapPolygonEdge {
+  if (parent.kind !== 'source-boundary') return {...parent};
+  const v = geographic(a),
+    length = angle(v, geographic(b));
+  const parameter = (p: Position) => (length ? Math.min(1, angle(v, geographic(p)) / length) : 0);
+  return {
+    ...parent,
+    t0: parent.t0 + parameter(start) * (parent.t1 - parent.t0),
+    t1: parent.t0 + parameter(end) * (parent.t1 - parent.t0)
+  };
+}