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

package/dist/workers/operations.cjs

@@ -13546,8 +13546,49 @@ function cutSphericalPolygon(rings, options) {
 }
 function projectSphericalPolygon(map, rings, options) {
   const result = [];
+  if (options.polygonEdgeProvenance && (!map.regions || !map.seams))
+    throw new Error("Atlas provenance requires map region and seam metadata");
   for (const part of cutSphericalPolygon(rings, options))
-    result.push(...map.projectPolygon(part.rings, options));
+    for (const polygon of map.projectPolygon(part.rings, options)) {
+      if (options.polygonEdgeProvenance) {
+        if (!polygon.edgeProvenance)
+          throw new Error("Map backend does not support polygon edge provenance");
+        const region = map.regions.find((r) => r.id === polygon.regionId);
+        polygon.edgeProvenance = polygon.edgeProvenance.map((edges, ring) => edges.map((edge2, i) => {
+          if (edge2.kind !== "source-boundary")
+            return edge2;
+          const parent = part.edges[edge2.ring][edge2.segment];
+          if (parent.kind === "source")
+            return {
+              ...edge2,
+              ring: parent.ringIndex,
+              segment: parent.edgeIndex,
+              t0: parent.startFraction + edge2.t0 * (parent.endFraction - parent.startFraction),
+              t1: parent.startFraction + edge2.t1 * (parent.endFraction - parent.startFraction)
+            };
+          const a = geographic(polygon.sourceCoordinates[ring][i]), b = geographic(polygon.sourceCoordinates[ring][i + 1]), kinds = [];
+          region.boundary.forEach((p, j) => {
+            const normal = cross(geographic(p), geographic(region.boundary[(j + 1) % region.boundary.length]));
+            const length = Math.hypot(...normal);
+            if (length < 1e-12)
+              return;
+            if ([a, b].every((v) => Math.abs(dot(normal, v)) / length < 1e-10)) {
+              const seam = map.seams.find((s) => s.regions.some((id, k2) => id === region.id && s.edges[k2] === j));
+              if (seam)
+                kinds.push(seam.kind);
+            }
+          });
+          return {
+            kind: kinds.includes("boundary") ? "coverage-boundary" : kinds.includes("cut") ? "chart-cut" : "continuous-chart-join",
+            ring: 4294967295,
+            segment: 4294967295,
+            t0: 0,
+            t1: 0
+          };
+        }));
+      }
+      result.push(polygon);
+    }
   return result;
 }
 
@@ -13584,33 +13625,13 @@ var lerp = (a, b, t) => [
   a[0] + (b[0] - a[0]) * t,
   a[1] + (b[1] - a[1]) * t
 ];
-function clipSegment(a, b, polygons) {
-  const ts = [0, 1], dx = b[0] - a[0], dy = b[1] - a[1];
-  for (const rings of polygons)
-    for (const ring of rings)
-      for (let i = 1; i < ring.length; i++) {
-        const c = ring[i - 1], d = ring[i], ex = d[0] - c[0], ey = d[1] - c[1], det = dx * ey - dy * ex;
-        if (Math.abs(det) < 1e-14)
-          continue;
-        const t = ((c[0] - a[0]) * ey - (c[1] - a[1]) * ex) / det;
-        const u = ((c[0] - a[0]) * dy - (c[1] - a[1]) * dx) / det;
-        if (t > 0 && t < 1 && u >= -1e-10 && u <= 1 + 1e-10)
-          ts.push(t);
-      }
-  ts.sort((a2, b2) => a2 - b2);
-  const result = [];
-  for (let i = 1; i < ts.length; i++)
-    if (ts[i] - ts[i - 1] > 1e-12 && contains(polygons, lerp(a, b, (ts[i] + ts[i - 1]) / 2)))
-      result.push([lerp(a, b, ts[i - 1]), lerp(a, b, ts[i])]);
-  return result;
-}
 function sampling(options) {
   const step = options.maxAngularStep ?? 2, tolerance = options.tolerance ?? 1e-4;
   if (!Number.isFinite(step) || step <= 0 || step > 90 || !Number.isFinite(tolerance) || tolerance <= 0)
     throw new Error("Invalid map sampling options");
   return { step, tolerance };
 }
-function sample(line, project, options, cellStep) {
+function sample(line, project, options, cellStep, interpolate) {
   const { step, tolerance } = sampling(options), source = [], xy = [];
   const emit = (p, q) => {
     if (source.length >= 1e5)
@@ -13621,23 +13642,23 @@ function sample(line, project, options, cellStep) {
   const at = (p) => {
     const q = project(p);
     if (!q)
-      throw new Error("Elastic grid is undefined inside its coverage");
+      throw new Error(`Elastic grid is undefined inside its coverage at ${p}`);
     return q;
   };
-  const visit = (a, b, qa, qb, depth) => {
-    const mid = lerp(a, b, 0.5), qm = at(mid), chord2 = lerp(qa, qb, 0.5);
+  const visit = (a, b, qa, qb, depth, segment, t0, t1) => {
+    const tm = (t0 + t1) / 2, mid = interpolate ? interpolate(segment, tm) : lerp(a, b, 0.5), qm = at(mid), chord2 = lerp(qa, qb, 0.5);
     if (Math.hypot(b[0] - a[0], b[1] - a[1]) > Math.min(step, cellStep / 2) || Math.hypot(qm[0] - chord2[0], qm[1] - chord2[1]) > tolerance) {
       if (depth >= 24)
         throw new Error("Elastic sampling limit exceeded");
-      visit(a, mid, qa, qm, depth + 1);
-      visit(mid, b, qm, qb, depth + 1);
+      visit(a, mid, qa, qm, depth + 1, segment, t0, tm);
+      visit(mid, b, qm, qb, depth + 1, segment, tm, t1);
     } else
       emit(b, qb);
   };
   if (line.length) {
     emit(line[0], at(line[0]));
     for (let i = 1; i < line.length; i++)
-      visit(line[i - 1], line[i], at(line[i - 1]), at(line[i]), 0);
+      visit(line[i - 1], line[i], at(line[i - 1]), at(line[i]), 0, i - 1, 0, 1);
   }
   return { source, xy };
 }
@@ -13674,6 +13695,65 @@ function indexDomain(polygons) {
 }
 
 // dist/discontinuous/map-transition.js
+var directWorldProjections = /* @__PURE__ */ 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"
+]);
 var MapTransitionGeometry = class {
   constructor(parts, strategy, radius2) {
     this.strategy = strategy;
@@ -13905,7 +13985,7 @@ function fullCoverage(map) {
     const overlaps = domains.some((domain, i) => domains.slice(i + 1).some((other) => import_polygon_clipping2.default.intersection(domain, other).length > 0));
     covered = completeSections && !overlaps && import_polygon_clipping2.default.difference(world, ...domains).length === 0;
   } else if (d.type === "world") {
-    covered = ["sinusoidal", "mollweide", "robinson"].includes(d.projection);
+    covered = directWorldProjections.has(d.projection) && Object.keys(d.parameters ?? {}).length === 0;
   }
   coverageCache.set(map, covered);
   return covered;
@@ -13955,6 +14035,16 @@ function prepareMapFeatures(map, features, options = {}) {
     throw new Error("Expected a feature array");
   if (options.polygonOutlines !== void 0 && typeof options.polygonOutlines !== "boolean")
     throw new Error("polygonOutlines must be boolean");
+  const provenance = options.provenance;
+  if (provenance !== void 0 && (!provenance || typeof provenance !== "object" || Array.isArray(provenance)))
+    throw new Error("Unsupported provenance policy");
+  if ((provenance == null ? void 0 : provenance.distances) !== void 0 && (!provenance.distances || typeof provenance.distances !== "object"))
+    throw new Error("Unsupported provenance distance policy");
+  if (provenance && (typeof provenance !== "object" || Object.keys(provenance).some((k2) => !["sourceSegments", "boundaries", "distances", "polygonEdges"].includes(k2)) || [provenance.sourceSegments, provenance.boundaries, provenance.polygonEdges].some((v) => v !== void 0 && typeof v !== "boolean") || provenance.distances && (provenance.distances.metric !== "spherical" || !Number.isFinite(provenance.distances.radius) || provenance.distances.radius <= 0)))
+    throw new Error("Unsupported provenance policy");
+  const edgeKinds = [], edgeRings = [], edgeSegments = [], edgeParameters = [];
+  const lineage = Boolean((provenance == null ? void 0 : provenance.sourceSegments) || (provenance == null ? void 0 : provenance.boundaries) || (provenance == null ? void 0 : provenance.distances));
+  const segments = [], parameters = [], originalVertices = [], distances = [], startReasons = [], endReasons = [];
   const regionIds = map.regions.map((r) => r.id), regionIndices = new Map(regionIds.map((id, i) => [id, i]));
   const points = vertices(), paths = vertices(), polygons = vertices();
   const pointParts = [], pathParts = [], polygonParts = [];
@@ -13975,7 +14065,27 @@ function prepareMapFeatures(map, features, options = {}) {
     const isRing = ringIndex !== void 0;
     if (isRing && !closed(line))
       line.push([...line[0]]);
-    for (const p of map.projectLine(line, options.sampling)) {
+    for (const p of map.projectLine(line, {
+      ...options.sampling,
+      pathProvenance: lineage,
+      pathDistances: Boolean(provenance == null ? void 0 : provenance.distances),
+      pathBoundaries: Boolean(provenance == null ? void 0 : provenance.boundaries)
+    })) {
+      if (lineage) {
+        if (!p.provenance)
+          throw new Error("Map backend does not support path provenance");
+        if (provenance == null ? void 0 : provenance.sourceSegments) {
+          segments.push(...p.provenance.segments);
+          parameters.push(...p.provenance.parameters);
+          originalVertices.push(...p.provenance.vertices);
+        }
+        if (provenance == null ? void 0 : provenance.distances)
+          distances.push(...p.provenance.angularDistances.map((d) => d * provenance.distances.radius));
+        if (provenance == null ? void 0 : provenance.boundaries) {
+          startReasons.push(p.provenance.startReason);
+          endReasons.push(p.provenance.endReason);
+        }
+      }
       append(paths, p.coordinates, p.sourceCoordinates);
       pathParts.push({
         ...part(featureIndex, geometryPath, p.regionId),
@@ -13987,12 +14097,41 @@ function prepareMapFeatures(map, features, options = {}) {
     }
   };
   const addPolygon = (input, featureIndex, geometryPath) => {
+    var _a2;
     if (!input.length)
       return;
     const rings = input.map((r) => r.map(position));
-    const parts = options.sphericalCuts ? map.projectGlobalPolygon(rings, { ...options.sampling, ...options.sphericalCuts }) : map.projectPolygon(rings, options.sampling);
+    const parts = options.sphericalCuts ? map.projectGlobalPolygon(rings, {
+      ...options.sampling,
+      ...options.sphericalCuts,
+      polygonEdgeProvenance: provenance == null ? void 0 : provenance.polygonEdges
+    }) : map.projectPolygon(rings, {
+      ...options.sampling,
+      polygonEdgeProvenance: provenance == null ? void 0 : provenance.polygonEdges
+    });
     for (const p of parts) {
       for (let i = 0; i < p.coordinates.length; i++) {
+        if (provenance == null ? void 0 : provenance.polygonEdges) {
+          const edges = (_a2 = p.edgeProvenance) == null ? void 0 : _a2[i];
+          if (!edges)
+            throw new Error("Map backend does not support polygon edge provenance");
+          const kinds = [
+            "source-boundary",
+            "coverage-boundary",
+            "chart-cut",
+            "continuous-chart-join"
+          ];
+          for (const edge2 of edges) {
+            edgeKinds.push(kinds.indexOf(edge2.kind) + 1);
+            edgeRings.push(edge2.ring);
+            edgeSegments.push(edge2.segment);
+            edgeParameters.push(edge2.t0, edge2.t1);
+          }
+          edgeKinds.push(0);
+          edgeRings.push(4294967295);
+          edgeSegments.push(4294967295);
+          edgeParameters.push(0, 0);
+        }
         append(polygons, p.coordinates[i], p.sourceCoordinates[i]);
         ringStarts.push(polygons.positions.length / 2);
       }
@@ -14056,12 +14195,38 @@ function prepareMapFeatures(map, features, options = {}) {
     featureIds,
     regionIds,
     points: { ...pack(points), parts: pointParts },
-    paths: { ...pack(paths), parts: pathParts, pathStarts: new Uint32Array(pathStarts) },
+    paths: {
+      ...pack(paths),
+      parts: pathParts,
+      pathStarts: new Uint32Array(pathStarts),
+      ...lineage ? {
+        provenance: {
+          ...(provenance == null ? void 0 : provenance.sourceSegments) ? {
+            sourceSegmentIndices: new Uint32Array(segments),
+            sourceSegmentParameters: new Float64Array(parameters),
+            sourceVertexIndices: new Uint32Array(originalVertices)
+          } : {},
+          ...(provenance == null ? void 0 : provenance.distances) ? {
+            sourceDistances: new Float64Array(distances),
+            distanceRadius: provenance.distances.radius
+          } : {},
+          ...(provenance == null ? void 0 : provenance.boundaries) ? { startReasons, endReasons } : {}
+        }
+      } : {}
+    },
     polygons: {
       ...pack(polygons),
       parts: polygonParts,
       ringStarts: new Uint32Array(ringStarts),
-      polygonStarts: new Uint32Array(polygonStarts)
+      polygonStarts: new Uint32Array(polygonStarts),
+      ...(provenance == null ? void 0 : provenance.polygonEdges) ? {
+        edgeProvenance: {
+          kinds: new Uint8Array(edgeKinds),
+          sourceRingIndices: new Uint32Array(edgeRings),
+          sourceSegmentIndices: new Uint32Array(edgeSegments),
+          sourceParameterRanges: new Float64Array(edgeParameters)
+        }
+      } : {}
     }
   };
 }
@@ -14069,6 +14234,171 @@ function prepareMapFeatures(map, features, options = {}) {
 // dist/discontinuous/elastic/map.js
 var import_polygon_clipping4 = __toESM(require("polygon-clipping"), 1);
 
+// dist/discontinuous/polygon-constraints.js
+function tracePolygonConstraints(input, output, tolerance = 1e-10, priorities, accept, degenerate) {
+  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 > 2e7)
+      throw new Error("Polygon constraint work limit exceeded");
+  };
+  const fraction = (p, a, b) => {
+    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, a, b) => {
+    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);
+  };
+  const boxes = 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) => {
+    const box = [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, b) => {
+    const 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 = [];
+    const overlaps = (b2) => b2[0] <= box[2] && b2[2] >= box[0] && b2[1] <= box[3] && b2[3] >= box[1];
+    const visit = (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 = [], owners = [];
+  for (const ring of output) {
+    const points = [];
+    for (let i = 1; i < ring.length; i++) {
+      const a = ring[i - 1], b = ring[i];
+      if (a.every((v, k2) => v === b[k2]))
+        continue;
+      const breaks = [{ 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((a2, b2) => a2.t - b2.t);
+      for (const item of breaks)
+        if (!points.length || Math.hypot(...points[points.length - 1].map((v, k2) => v - item.p[k2])) > 1e-14)
+          points.push([...item.p]);
+    }
+    if (points.length < 3)
+      continue;
+    points.push([...points[0]]);
+    const tags = [];
+    for (let i = 1; i < points.length; i++) {
+      const a = points[i - 1], b = points[i];
+      if (degenerate == null ? void 0 : 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, q) => Math.hypot(...p.map((v, k2) => v - q[k2])) <= 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) => {
+        var _a2, _b;
+        return ((_b = (_a2 = priorities == null ? void 0 : priorities[c.r]) == null ? void 0 : _a2[c.i]) == null ? void 0 : _b.kind) === "source-boundary";
+      }))
+        candidates = candidates.filter((c) => {
+          var _a2, _b;
+          return ((_b = (_a2 = priorities == null ? void 0 : priorities[c.r]) == null ? void 0 : _a2[c.i]) == null ? void 0 : _b.kind) === "source-boundary";
+        });
+      if (candidates.length > 1) {
+        const score = (c) => 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((a2, b2) => score(a2) - score(b2));
+        const epsilon7 = 64 * Number.EPSILON * Math.max(1, ...a.map(Math.abs), ...b.map(Math.abs));
+        if (score(candidates[1]) - score(candidates[0]) > epsilon7)
+          candidates = [candidates[0]];
+        else if (Math.hypot(a[0] - b[0], a[1] - b[1]) <= 2 * epsilon7)
+          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 };
+}
+function composePolygonEdge(parent, a, b, start, end) {
+  if (parent.kind !== "source-boundary")
+    return { ...parent };
+  const v = geographic(a), length = angle(v, geographic(b));
+  const parameter = (p) => 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)
+  };
+}
+
+// dist/discontinuous/source-arc.js
+function sourceArc(a, b) {
+  const va = geographic(a), vb = geographic(b), length = angle(va, vb);
+  const poleA = Math.abs(a[1]) === 90, poleB = Math.abs(b[1]) === 90;
+  const start = poleA && !poleB ? [b[0], a[1]] : [...a], end = poleB && !poleA ? [a[0], b[1]] : [...b];
+  return (t) => {
+    if (t === 0)
+      return [...start];
+    if (t === 1)
+      return [...end];
+    if (length < 1e-14)
+      return [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])];
+    const p = coordinates(unit(va.map((v, k2) => (Math.sin((1 - t) * length) * v + Math.sin(t * length) * vb[k2]) / Math.sin(length))));
+    const reference = start[0] + t * (end[0] - start[0]);
+    p[0] += 360 * Math.round((reference - p[0]) / 360);
+    return p;
+  };
+}
+
 // dist/discontinuous/map-layout.js
 var import_polygon_clipping3 = __toESM(require("polygon-clipping"), 1);
 var EPS = 1e-10;
@@ -14218,6 +14548,10 @@ var DiscontinuousMap = class {
     for (let i = 1; i < points.length; i++)
       validateArc(points[i - 1], points[i]);
     const results = [];
+    const cumulative = options.pathDistances ? [0] : void 0;
+    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 = null;
       for (let i = 1; i < points.length; i++) {
@@ -14226,18 +14560,42 @@ var DiscontinuousMap = class {
           current = null;
           continue;
         }
+        const reason = (p, endpoint, isEndpoint) => {
+          if (isEndpoint && angle(p, endpoint) < 1e-12)
+            return "source-endpoint";
+          const kinds = r.normals.map((normal, edge2) => {
+            var _a2;
+            return Math.abs(dot(normal, p)) < 1e-9 ? (_a2 = this.seams.find((s) => s.regions.some((id, i2) => id === r.definition.id && s.edges[i2] === edge2))) == null ? void 0 : _a2.kind : void 0;
+          }).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 (!current || angle(geographic(current.sourceCoordinates[current.sourceCoordinates.length - 1]), clipped[0]) > EPS || !this.sameProjectedPoint(current.coordinates[current.coordinates.length - 1], this.project(r, sampled[0]))) {
           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 : 4294967295);
+            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);
         if (!this.contains(r, points[i]))
           current = null;
       }
@@ -14334,26 +14692,91 @@ var DiscontinuousMap = class {
           coordinates: [],
           sourceCoordinates: []
         };
+        if (options.polygonEdgeProvenance)
+          output.edgeProvenance = [];
         polygon.forEach((ring, index) => {
           const sphere = ring.map((p) => unit(add(center3, add(scale(x, p[0]), scale(y, p[1])))));
           const points = [];
+          const edges = [];
+          const classify = (a, b) => {
+            if (angle(a, b) < 64 * Number.EPSILON)
+              return {
+                kind: "continuous-chart-join",
+                ring: 4294967295,
+                segment: 4294967295,
+                t0: 0,
+                t1: 0
+              };
+            const candidates = [];
+            vectors.forEach((source, ring2) => 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: ring2, segment });
+            }));
+            if (candidates.length > 1)
+              throw new Error("Ambiguous polygon boundary provenance");
+            if (candidates.length) {
+              const { ring: ring2, segment } = candidates[0], source = vectors[ring2], u = source[segment], length = angle(u, source[(segment + 1) % source.length]);
+              return {
+                kind: "source-boundary",
+                ring: ring2,
+                segment,
+                t0: Math.min(1, angle(u, a) / length),
+                t1: Math.min(1, angle(u, b) / length)
+              };
+            }
+            const kinds = r.normals.map((n, edge2) => {
+              var _a2;
+              return [a, b].every((p) => Math.abs(dot(n, p)) < 1e-9) ? (_a2 = this.seams.find((s) => s.regions.some((id, i) => id === r.definition.id && s.edges[i] === edge2))) == null ? void 0 : _a2.kind : void 0;
+            }).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: 4294967295,
+              segment: 4294967295,
+              t0: 0,
+              t1: 0
+            };
+          };
           for (let i = 1; i < sphere.length; i++) {
+            const origin2 = options.polygonEdgeProvenance && !sphere[i - 1].every((value2, k2) => value2 === sphere[i][k2]) ? classify(sphere[i - 1], sphere[i]) : void 0;
             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((value2, k2) => value2 === previous[k2]))
+              if (!previous || !point.every((value2, k2) => value2 === previous[k2])) {
+                if (previous && origin2) {
+                  const edge2 = { ...origin2 };
+                  if (edge2.kind === "source-boundary") {
+                    const source = vectors[edge2.ring], u = source[edge2.segment], length = angle(u, source[(edge2.segment + 1) % source.length]);
+                    edge2.t0 = Math.min(1, angle(u, previous) / length);
+                    edge2.t1 = Math.min(1, angle(u, point) / length);
+                  }
+                  edges.push(edge2);
+                }
                 points.push(point);
+              }
             }
           }
           if (points.length < 3)
             return;
           if (points[points.length - 1].every((value2, k2) => value2 === points[0][k2]))
             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));
@@ -14551,10 +14974,11 @@ var CapMap = class extends DiscontinuousMap {
   unprojectPoint(p, id) {
     return super.unprojectPoint(p, id).filter((q) => this.visible(q.position));
   }
-  clip(rings, polygon, options, regionId) {
+  clip(rings, polygon, options, regionId, segmentIndices) {
     const output = [];
     const originals = /* @__PURE__ */ new Map();
-    let ring = [];
+    let ring = [], indices = [], activeSegment = 0;
+    let previousInput, currentInput;
     const precision = Math.min((options == null ? void 0 : options.maxAngularStep) ?? 2, Math.sqrt(((options == null ? void 0 : options.tolerance) ?? 1e-4) / this.radius) / RAD / 4) * RAD;
     if (!Number.isFinite(precision) || 2 * Math.PI / precision > 1e6)
       throw new Error("Projection sampling limit exceeded; relax tolerance");
@@ -14609,14 +15033,49 @@ var CapMap = class extends DiscontinuousMap {
       point: (x, y) => {
         if (++emitted > 1e6)
           throw new Error("Projection sampling limit exceeded; relax tolerance");
-        ring.push(originals.get(`${x},${y}`) ?? this.source([x / RAD, y / RAD]));
+        let source = originals.get(`${x},${y}`);
+        if (!source && !polygon && this.nonlinear && previousInput && currentInput) {
+          const a = geographic(previousInput), b = geographic(currentInput), length = angle(a, b);
+          const at = (t) => length < 1e-14 ? [...currentInput] : coordinates(unit(a.map((v, k2) => (Math.sin((1 - t) * length) * v + Math.sin(t * length) * b[k2]) / Math.sin(length))));
+          const value2 = (t) => geographic(local(at(t)))[0] - Math.cos(this.cap);
+          const approximate = this.source([x / RAD, y / RAD]);
+          const reference = length ? Math.min(1, angle(a, geographic(approximate)) / length) : 0;
+          const roots = [];
+          for (let j = 0; j < 32; j++) {
+            let lo = j / 32, hi = (j + 1) / 32, f = value2(lo), g = value2(hi);
+            if (Math.abs(f) < 1e-14)
+              roots.push(lo);
+            if (f * g >= 0)
+              continue;
+            for (let k2 = 0; k2 < 52; k2++) {
+              const mid = (lo + hi) / 2;
+              if (value2(mid) >= 0 === f >= 0)
+                lo = mid;
+              else
+                hi = mid;
+            }
+            roots.push((lo + hi) / 2);
+          }
+          if (Math.abs(value2(1)) < 1e-14)
+            roots.push(1);
+          if (!roots.length)
+            throw new Error("Unresolved nonlinear cap source intersection");
+          roots.sort((a2, b2) => Math.abs(a2 - reference) - Math.abs(b2 - reference));
+          source = at(roots[0]);
+        }
+        ring.push(source ?? this.source([x / RAD, y / RAD]));
+        if (segmentIndices)
+          indices.push(activeSegment);
       },
       lineStart: () => {
         ring = [];
+        indices = [];
       },
       lineEnd: () => {
-        if (ring.length > 1)
+        if (ring.length > 1) {
           output.push(ring);
+          segmentIndices == null ? void 0 : segmentIndices.push(indices);
+        }
       },
       polygonStart: () => {
       },
@@ -14633,7 +15092,9 @@ var CapMap = class extends DiscontinuousMap {
       }
       const x = q[0] * RAD, y = q[1] * RAD;
       originals.set(`${x},${y}`, [...p]);
+      currentInput = p;
       stream.point(x, y);
+      previousInput = p;
     };
     const subdivide = (a, b, depth = 0) => {
       if (this.nonlinear && depth < 20) {
@@ -14650,11 +15111,14 @@ var CapMap = class extends DiscontinuousMap {
       emit(b);
     };
     for (const points of rings) {
+      previousInput = void 0;
       stream.lineStart();
       if (points.length)
         emit(points[0]);
-      for (let i = 1; i < points.length; i++)
+      for (let i = 1; i < points.length; i++) {
+        activeSegment = i - 1;
         subdivide(points[i - 1], points[i]);
+      }
       if (polygon && points.length)
         subdivide(points[points.length - 1], points[0]);
       stream.lineEnd();
@@ -14666,7 +15130,41 @@ var CapMap = class extends DiscontinuousMap {
   projectLine(line, options) {
     if (this.cap === Math.PI / 2 && !this.nonlinear)
       return super.projectLine(line, options);
-    return super.projectLine(line, options).flatMap((part) => this.clip([part.sourceCoordinates], false, options, part.regionId).flatMap((line2) => super.projectLine(line2, options).filter((q) => q.regionId === part.regionId)));
+    return super.projectLine(line, options).flatMap((part) => {
+      const indices = part.provenance ? [] : void 0;
+      const clipped = this.clip([part.sourceCoordinates], false, options, part.regionId, indices);
+      return clipped.flatMap((points, piece) => super.projectLine(points, options).filter((q) => q.regionId === part.regionId).map((q) => {
+        const parent = part.provenance, child2 = q.provenance;
+        if (!parent || !child2)
+          return q;
+        const provenance = {
+          segments: [],
+          parameters: [],
+          vertices: [],
+          angularDistances: []
+        };
+        for (let j = 0; j < q.sourceCoordinates.length; j++) {
+          const k2 = child2.segments[j];
+          const edge2 = indices[piece][k2 + 1];
+          const a = geographic(part.sourceCoordinates[edge2]), b = geographic(part.sourceCoordinates[edge2 + 1]), p = geographic(q.sourceCoordinates[j]);
+          const length = angle(a, b), t = length ? Math.min(1, angle(a, p) / length) : 0;
+          const endpoint = t < 1e-12 ? edge2 : t > 1 - 1e-12 ? edge2 + 1 : -1;
+          const segment = parent.segments[edge2 + 1];
+          const from = parent.segments[edge2] === segment ? parent.parameters[edge2] : 0;
+          provenance.segments.push(endpoint >= 0 ? parent.segments[endpoint] : segment);
+          provenance.parameters.push(endpoint >= 0 ? parent.parameters[endpoint] : from + t * (parent.parameters[edge2 + 1] - from));
+          provenance.vertices.push(endpoint >= 0 ? parent.vertices[endpoint] : 4294967295);
+          if (options == null ? void 0 : options.pathDistances)
+            provenance.angularDistances.push(parent.angularDistances[edge2] + t * (parent.angularDistances[edge2 + 1] - parent.angularDistances[edge2]));
+        }
+        if (options == null ? void 0 : options.pathBoundaries) {
+          const same = (a, b) => angle(geographic(a), geographic(b)) < 1e-12;
+          provenance.startReason = same(q.sourceCoordinates[0], part.sourceCoordinates[0]) ? parent.startReason : "coverage-boundary";
+          provenance.endReason = same(q.sourceCoordinates[q.sourceCoordinates.length - 1], part.sourceCoordinates[part.sourceCoordinates.length - 1]) ? parent.endReason : "coverage-boundary";
+        }
+        return { ...q, provenance };
+      }));
+    });
   }
   projectPolygon(rings, options) {
     if (this.cap === Math.PI / 2 && !this.nonlinear)
@@ -14739,15 +15237,95 @@ var CapMap = class extends DiscontinuousMap {
       };
       for (const ring of outer) {
         const plane = ring.map(planar), sources = [ring, ...holes.filter((h2) => contains2(plane, planar(h2[0])))];
+        const parentPlane = part.sourceCoordinates.map((r) => r.map(planar));
+        const fromPlane = (p) => coordinates(unit(center3.map((v, k2) => v + x[k2] * p[0] + y[k2] * p[1])));
+        const traced = tracePolygonConstraints(parentPlane, sources.map((r) => r.map(planar)), this.nonlinear ? 2e-6 : 1e-10, part.edgeProvenance, (p) => this.visible(fromPlane(p)));
+        const resolved2 = traced.rings.map((r) => r.map(fromPlane));
+        traced.owners.forEach((owners, r) => owners.forEach((owner, i) => {
+          if (!owner)
+            return;
+          const [pr, pe] = owner, a = part.sourceCoordinates[pr][pe], b = part.sourceCoordinates[pr][pe + 1], at = sourceArc(a, b);
+          for (const j of [i, i + 1]) {
+            const point = resolved2[r][j], distance3 = angle(geographic(a), geographic(b)), fraction = distance3 ? angle(geographic(a), geographic(point)) / distance3 : 0;
+            if (fraction < 1e-10)
+              resolved2[r][j] = [...a];
+            else if (fraction > 1 - 1e-10)
+              resolved2[r][j] = [...b];
+            else if (Math.hypot(...cross(geographic(a), geographic(b))) > 1e-14 && Math.abs(dot(unit(cross(geographic(a), geographic(b))), geographic(point))) < 1e-12) {
+              resolved2[r][j] = at(Math.min(1, Math.max(0, fraction)));
+            } else {
+              const value2 = (t) => geographic(this.local(at(t)))[0] - Math.cos(this.cap), roots = [];
+              for (let k2 = 0; k2 < 32; k2++) {
+                let lo = k2 / 32, hi = (k2 + 1) / 32, f = value2(lo), g = value2(hi);
+                if (Math.abs(f) < 1e-13)
+                  roots.push(lo);
+                if (f * g >= 0)
+                  continue;
+                for (let n = 0; n < 52; n++) {
+                  const mid = (lo + hi) / 2;
+                  if (value2(mid) >= 0 === f >= 0)
+                    lo = mid;
+                  else
+                    hi = mid;
+                }
+                roots.push((lo + hi) / 2);
+              }
+              if (Math.abs(value2(1)) < 1e-13)
+                roots.push(1);
+              if (!roots.length)
+                throw new Error("Unresolved cap polygon source intersection");
+              roots.sort((a2, b2) => Math.abs(a2 - fraction) - Math.abs(b2 - fraction));
+              resolved2[r][j] = at(roots[0]);
+            }
+          }
+        }));
+        for (const ring2 of resolved2)
+          ring2[ring2.length - 1] = [...ring2[0]];
         result.push({
           regionId: part.regionId,
-          sourceCoordinates: sources,
-          coordinates: sources.map((r) => r.map((p) => {
+          sourceCoordinates: resolved2,
+          coordinates: resolved2.map((r) => r.map((p) => {
             const q = super.projectPoint(p, part.regionId);
             if (!q)
-              throw new Error(`Cap point outside chart ${part.regionId}: ${p}, owner ${super.findRegions(p)}`);
+              throw new Error("Cap polygon source constraint left its owning chart");
             return q.position;
-          }))
+          })),
+          ...(options == null ? void 0 : options.polygonEdgeProvenance) ? {
+            edgeProvenance: traced.owners.map((owners, r) => owners.map((owner, i) => {
+              const a = resolved2[r][i], b = resolved2[r][i + 1];
+              if (owner) {
+                const [pr, pe] = owner;
+                return composePolygonEdge(part.edgeProvenance[pr][pe], part.sourceCoordinates[pr][pe], part.sourceCoordinates[pr][pe + 1], a, b);
+              }
+              if (angle(geographic(a), geographic(b)) < 64 * Number.EPSILON)
+                return {
+                  kind: "continuous-chart-join",
+                  ring: 4294967295,
+                  segment: 4294967295,
+                  t0: 0,
+                  t1: 0
+                };
+              const kinds = [];
+              region.boundary.forEach((p, j) => {
+                const n = cross(geographic(p), geographic(region.boundary[(j + 1) % region.boundary.length])), length = Math.hypot(...n);
+                if (length && [a, b].every((p2) => Math.abs(dot(n, geographic(p2))) / length < 1e-9)) {
+                  const seam = this.seams.find((s) => s.regions.some((id, k2) => id === region.id && s.edges[k2] === j));
+                  if (seam)
+                    kinds.push(seam.kind);
+                }
+              });
+              const horizon = [a, b].every((p) => Math.abs(geographic(this.local(p))[0] - Math.cos(this.cap)) < 1e-7);
+              if (!horizon && !kinds.length)
+                throw new Error("Unknown cap polygon clipping constraint");
+              return {
+                kind: horizon ? "coverage-boundary" : kinds.includes("boundary") ? "coverage-boundary" : kinds.includes("cut") ? "chart-cut" : "continuous-chart-join",
+                ring: 4294967295,
+                segment: 4294967295,
+                t0: 0,
+                t1: 0
+              };
+            }))
+          } : {}
         });
       }
     }
@@ -16572,6 +17150,94 @@ function invertCell(p, target) {
   return output;
 }
 
+// dist/discontinuous/elastic/source-arc.js
+function clipSourceArc(a, b, polygons) {
+  const at = sourceArc(a, b), va = geographic(a), vb = geographic(b), omega = angle(va, vb), ts = [0, 1];
+  let work = 0;
+  const tick = () => {
+    if (++work > 1e6)
+      throw new Error("Elastic source clipping limit exceeded");
+  };
+  const linear = omega < 1e-14 || Math.abs(a[1]) < 1e-12 && Math.abs(b[1]) < 1e-12 || Math.abs(at(0)[0] - at(1)[0]) < 1e-12;
+  const tangent = omega > 1e-14 ? va.map((v, k2) => (vb[k2] - v * Math.cos(omega)) / Math.sin(omega)) : [0, 0, 0];
+  const momentum = Math.abs(omega * (va[0] * tangent[1] - va[1] * tangent[0])) + 64 * Number.EPSILON * omega;
+  const vector = (t) => va.map((v, k2) => v * Math.cos(omega * t) + tangent[k2] * Math.sin(omega * t));
+  const derivative = (t) => va.map((v, k2) => omega * (-v * Math.sin(omega * t) + tangent[k2] * Math.cos(omega * t)));
+  for (const rings of polygons)
+    for (const ring of rings)
+      for (let edge2 = 1; edge2 < ring.length; edge2++) {
+        const c = ring[edge2 - 1], d = ring[edge2], dx = d[0] - c[0], dy = d[1] - c[1], length = Math.hypot(dx, dy);
+        if (!length)
+          continue;
+        const angular = omega / RAD, latitude = Math.min(90, Math.max(Math.abs(a[1]), Math.abs(b[1])) + angular), cosine2 = Math.cos(latitude * RAD), longitude3 = cosine2 > 1e-10 ? angular / cosine2 : 360;
+        if (Math.max(c[1], d[1]) < Math.min(a[1], b[1]) - angular - 1e-10 || Math.min(c[1], d[1]) > Math.max(a[1], b[1]) + angular + 1e-10 || Math.max(c[0], d[0]) < Math.min(a[0], b[0]) - longitude3 - 1e-10 || Math.min(c[0], d[0]) > Math.max(a[0], b[0]) + longitude3 + 1e-10)
+          continue;
+        const value2 = (t) => {
+          tick();
+          const p = at(t);
+          return ((p[0] - c[0]) * dy - (p[1] - c[1]) * dx) / length;
+        };
+        const put = (t) => {
+          const p = at(t), u = ((p[0] - c[0]) * dx + (p[1] - c[1]) * dy) / (length * length);
+          if (u >= -1e-10 && u <= 1 + 1e-10)
+            ts.push(t);
+        };
+        const bisect = (lo, hi, f) => {
+          for (let k2 = 0; k2 < 52; k2++) {
+            const mid = (lo + hi) / 2;
+            if (value2(mid) >= 0 === f >= 0)
+              lo = mid;
+            else
+              hi = mid;
+          }
+          put((lo + hi) / 2);
+        };
+        const visit = (lo, hi, depth) => {
+          tick();
+          const f = value2(lo), g = value2(hi), mid = (lo + hi) / 2, h2 = (hi - lo) / 2;
+          if (Math.abs(f) < 1e-12)
+            put(lo);
+          if (Math.abs(g) < 1e-12)
+            put(hi);
+          if (linear) {
+            if (f * g < 0)
+              bisect(lo, hi, f);
+            return;
+          }
+          const v = vector(mid), dv = derivative(mid), r2 = v[0] * v[0] + v[1] * v[1];
+          const df = ((v[0] * dv[1] - v[1] * dv[0]) / r2 * dy - dv[2] / Math.sqrt(r2) * dx) / (RAD * length);
+          let z = Math.max(Math.abs(vector(lo)[2]), Math.abs(vector(hi)[2]));
+          const phase = Math.atan2(tangent[2], va[2]);
+          for (let k2 = -2; k2 <= 2; k2++) {
+            const theta = phase + k2 * Math.PI;
+            if (theta >= omega * lo && theta <= omega * hi)
+              z = Math.max(z, Math.hypot(va[2], tangent[2]));
+          }
+          const r = Math.sqrt(Math.max(0, 1 - Math.min(1, z) ** 2));
+          const second = r ? (2 * momentum * omega * Math.abs(dy) / r ** 4 + omega ** 2 * Math.abs(dx) * (1 / r + 1 / r ** 3)) / (RAD * length) : Infinity;
+          if (Number.isFinite(df) && Math.abs(df) > second * h2 + 1e-12) {
+            if (f * g < 0)
+              bisect(lo, hi, f);
+            return;
+          }
+          const speed = r ? (momentum * Math.abs(dy) / r ** 2 + omega * Math.abs(dx)) / (RAD * length) : Infinity;
+          if (Math.abs(value2(mid)) > speed * h2 + 1e-12)
+            return;
+          if (depth >= 24)
+            throw new Error("Unresolved Elastic source clipping tangent or pole");
+          visit(lo, mid, depth + 1);
+          visit(mid, hi, depth + 1);
+        };
+        visit(0, 1, 0);
+      }
+  ts.sort((a2, b2) => a2 - b2);
+  const result = [];
+  for (let i = 1; i < ts.length; i++)
+    if (ts[i] - ts[i - 1] > 1e-12 && contains(polygons, at((ts[i] + ts[i - 1]) / 2)))
+      result.push({ a: at(ts[i - 1]), b: at(ts[i]) });
+  return result;
+}
+
 // dist/discontinuous/elastic/map.js
 var kernel = Object.assign((x, y) => [x, y], {
   invert: (x, y) => [x, y]
@@ -16703,7 +17369,7 @@ var ElasticMap = class {
   }
   sourceOptions(options) {
     const { step } = sampling(options);
-    return { maxAngularStep: Math.min(step, 1), tolerance: 1e-5 };
+    return { ...options, maxAngularStep: Math.min(step, 1), tolerance: 1e-5 };
   }
   sampled(c, line, options) {
     return sample(line, (p) => c.grid.project(p), options, Math.min(180 / (c.grid.section.rows - 1), 360 / (c.grid.section.columns - 1)));
@@ -16712,23 +17378,70 @@ var ElasticMap = class {
     const out = [];
     for (const part of splitter.projectLine(line, this.sourceOptions(options)))
       for (const c of this.charts.filter((c2) => c2.baseId === part.regionId)) {
-        let current = [];
-        const flush = () => {
-          if (current.length > 1) {
-            const { source, xy } = this.sampled(c, current, options);
-            out.push({ regionId: c.region.id, coordinates: xy, sourceCoordinates: source });
-          }
-          current = [];
+        let current;
+        const boundary = (point, vertex) => {
+          if (vertex === 0 || vertex === line.length - 1)
+            return "source-endpoint";
+          let edge2 = 0;
+          const kinds = [];
+          for (const polygon of c.domain)
+            for (const ring of polygon)
+              for (let i = 1; i < ring.length; i++, edge2++)
+                if (onSegment(point, ring[i - 1], ring[i])) {
+                  const seam = this.seams.find((s) => s.regions.some((id, j) => id === c.region.id && s.edges[j] === edge2));
+                  kinds.push((seam == null ? void 0 : seam.kind) ?? "boundary");
+                }
+          return kinds.includes("boundary") ? "coverage-boundary" : kinds.includes("cut") ? "chart-cut" : kinds.includes("join") ? "continuous-chart-join" : "coverage-boundary";
         };
-        for (let i = 1; i < part.coordinates.length; i++)
-          for (const [a, b] of clipSegment(part.coordinates[i - 1], part.coordinates[i], c.domain)) {
-            if (current.length && Math.hypot(current[current.length - 1][0] - a[0], current[current.length - 1][1] - a[1]) > 1e-8)
-              flush();
-            if (!current.length)
-              current.push(a);
-            current.push(b);
+        for (let i = 1; i < part.sourceCoordinates.length; i++) {
+          const a = part.coordinates[i - 1], b = part.coordinates[i];
+          const intervals = clipSourceArc(a, b, c.domain);
+          if (!intervals.length) {
+            current = void 0;
+            continue;
+          }
+          if (Math.hypot(intervals[0].a[0] - a[0], intervals[0].a[1] - a[1]) > 1e-8)
+            current = void 0;
+          for (const clipped of intervals) {
+            const arc = sourceArc(clipped.a, clipped.b);
+            const samples = sample([clipped.a, clipped.b], (p) => c.grid.project(p), options, Math.min(180 / (c.grid.section.rows - 1), 360 / (c.grid.section.columns - 1)), (_, t) => arc(t));
+            const first = samples.source[0], last = samples.source[samples.source.length - 1];
+            const joined = current && Math.hypot(...current.sourceCoordinates[current.sourceCoordinates.length - 1].map((v, k2) => v - first[k2])) < 1e-8;
+            if (!joined) {
+              current = { regionId: c.region.id, coordinates: [], sourceCoordinates: [] };
+              if (part.provenance)
+                current.provenance = {
+                  segments: [],
+                  parameters: [],
+                  vertices: [],
+                  angularDistances: []
+                };
+              out.push(current);
+            }
+            for (let j = joined ? 1 : 0; j < samples.source.length; j++) {
+              const p = samples.source[j];
+              current.sourceCoordinates.push(p);
+              current.coordinates.push(samples.xy[j]);
+              const parent = part.provenance, target = current.provenance;
+              if (parent && target) {
+                const length = angle(geographic(a), geographic(b)), t = length ? Math.min(1, angle(geographic(a), geographic(p)) / length) : 0;
+                const endpoint = t < 1e-12 ? i - 1 : t > 1 - 1e-12 ? i : -1, segment = parent.segments[i], from = parent.segments[i - 1] === segment ? parent.parameters[i - 1] : 0;
+                target.segments.push(endpoint >= 0 ? parent.segments[endpoint] : segment);
+                target.parameters.push(endpoint >= 0 ? parent.parameters[endpoint] : from + t * (parent.parameters[i] - from));
+                target.vertices.push(endpoint >= 0 ? parent.vertices[endpoint] : 4294967295);
+                if (options.pathDistances)
+                  target.angularDistances.push(parent.angularDistances[i - 1] + t * (parent.angularDistances[i] - parent.angularDistances[i - 1]));
+                if (options.pathBoundaries) {
+                  if (target.vertices.length === 1)
+                    target.startReason = boundary(p, target.vertices[0]);
+                  target.endReason = boundary(p, target.vertices[target.vertices.length - 1]);
+                }
+              }
+            }
+            if (Math.hypot(last[0] - b[0], last[1] - b[1]) > 1e-8)
+              current = void 0;
           }
-        flush();
+        }
       }
     return out;
   }
@@ -16736,13 +17449,175 @@ var ElasticMap = class {
     const out = [];
     for (const part of splitter.projectPolygon(rings, this.sourceOptions(options)))
       for (const c of this.charts.filter((c2) => c2.baseId === part.regionId)) {
-        const clipped = import_polygon_clipping4.default.intersection(snapPolygon(part.coordinates), c.domain.map(snapPolygon));
+        const prepared = [], preparedEdges = [];
+        part.coordinates.forEach((ring, r) => {
+          const points = [], edges = [];
+          for (let i = 1; i < ring.length; i++) {
+            const a = ring[i - 1], b = ring[i], arc = sourceArc(a, b), length = angle(geographic(a), geographic(b)), fractions = [0, 1];
+            for (const interval of clipSourceArc(a, b, c.domain))
+              for (const p of [interval.a, interval.b]) {
+                const t = length > 1e-14 ? angle(geographic(a), geographic(p)) / length : Math.abs(b[0] - a[0]) > 1e-14 ? (p[0] - a[0]) / (b[0] - a[0]) : 0;
+                if (t > 1e-12 && t < 1 - 1e-12)
+                  fractions.push(t);
+              }
+            fractions.sort((a2, b2) => a2 - b2);
+            const split = fractions.filter((t, i2) => !i2 || t - fractions[i2 - 1] > 1e-12);
+            const append2 = (point) => {
+              if (points.length >= 1e5)
+                throw new Error("Elastic polygon constraint vertex limit exceeded");
+              if (points.length) {
+                const previous = points[points.length - 1];
+                if (options.polygonEdgeProvenance)
+                  edges.push(composePolygonEdge(part.edgeProvenance[r][i - 1], a, b, previous, point));
+              }
+              points.push(point);
+            };
+            const first = arc(0);
+            if (!points.length)
+              points.push(first);
+            else if (points[points.length - 1].some((v, k2) => v !== first[k2])) {
+              if (angle(geographic(points[points.length - 1]), geographic(first)) > 1e-10)
+                throw new Error("Discontinuous Elastic input source constraint");
+              if (options.polygonEdgeProvenance)
+                edges.push({
+                  kind: "continuous-chart-join",
+                  ring: 4294967295,
+                  segment: 4294967295,
+                  t0: 0,
+                  t1: 0
+                });
+              points.push(first);
+            }
+            for (let j = 1; j < split.length; j++) {
+              append2(arc((split[j - 1] + split[j]) / 2));
+              append2(arc(split[j]));
+            }
+          }
+          if (points[points.length - 1].some((v, k2) => v !== points[0][k2])) {
+            if (angle(geographic(points[points.length - 1]), geographic(points[0])) > 1e-10)
+              throw new Error("Unclosed Elastic input source constraint");
+            if (options.polygonEdgeProvenance)
+              edges.push({
+                kind: "continuous-chart-join",
+                ring: 4294967295,
+                segment: 4294967295,
+                t0: 0,
+                t1: 0
+              });
+            points.push([...points[0]]);
+          }
+          prepared.push(points);
+          preparedEdges.push(edges);
+        });
+        const clipped = import_polygon_clipping4.default.intersection(snapPolygon(prepared), c.domain.map(snapPolygon));
         for (const polygon of clipped) {
-          const samples = polygon.map((r) => this.sampled(c, r, options));
+          const input = snapPolygon(prepared), traced = tracePolygonConstraints(input, polygon, 1e-9, options.polygonEdgeProvenance ? preparedEdges : void 0, void 0, (a, b) => angle(geographic(a), geographic(b)) < 64 * Number.EPSILON), resolved2 = traced.rings.map((r) => r.map((p) => [...p]));
+          traced.owners.forEach((owners, r) => owners.forEach((owner, i) => {
+            if (!owner)
+              return;
+            const [pr, pe] = owner, a = prepared[pr][pe], b = prepared[pr][pe + 1], length = angle(geographic(a), geographic(b)), arc = sourceArc(a, b);
+            for (const j of [i, i + 1]) {
+              const q = traced.rings[r][j], start = input[pr][pe], end = input[pr][pe + 1];
+              if (Math.hypot(q[0] - start[0], q[1] - start[1]) < 1e-8)
+                resolved2[r][j] = [...a];
+              else if (Math.hypot(q[0] - end[0], q[1] - end[1]) < 1e-8)
+                resolved2[r][j] = [...b];
+              else {
+                const candidates = clipSourceArc(a, b, c.domain).flatMap((interval) => [
+                  interval.a,
+                  interval.b
+                ]);
+                if (!candidates.length)
+                  throw new Error("Unresolved Elastic polygon source intersection");
+                const reference = length ? angle(geographic(a), geographic(q)) / length : 0;
+                candidates.sort((x, y) => Math.abs((length ? angle(geographic(a), geographic(x)) / length : 0) - reference) - Math.abs((length ? angle(geographic(a), geographic(y)) / length : 0) - reference));
+                const fraction = length ? angle(geographic(a), geographic(candidates[0])) / length : 0;
+                resolved2[r][j] = arc(Math.min(1, Math.max(0, fraction)));
+              }
+            }
+          }));
+          for (const ring of resolved2)
+            ring[ring.length - 1] = [...ring[0]];
+          const generated = (a, b) => {
+            if (angle(geographic(a), geographic(b)) < 64 * Number.EPSILON)
+              return "continuous-chart-join";
+            let edge2 = 0;
+            const kinds = [];
+            for (const polygon2 of c.domain)
+              for (const ring of polygon2)
+                for (let j = 1; j < ring.length; j++, edge2++)
+                  if (onSegment(a, ring[j - 1], ring[j]) && onSegment(b, ring[j - 1], ring[j])) {
+                    const seam = this.seams.find((s) => s.regions.some((id, k2) => id === c.region.id && s.edges[k2] === edge2));
+                    kinds.push((seam == null ? void 0 : seam.kind) ?? "boundary");
+                  }
+            if (!kinds.length)
+              throw new Error("Unknown Elastic polygon clipping constraint");
+            return kinds.includes("boundary") ? "coverage-boundary" : kinds.includes("cut") ? "chart-cut" : "continuous-chart-join";
+          };
+          const coordinates2 = [], sourceCoordinates = [], edgeProvenance = [];
+          resolved2.forEach((ring, r) => {
+            const source = [], xy = [], edges = [];
+            for (let i = 1; i < ring.length; i++) {
+              const owner = traced.owners[r][i - 1], arc = owner ? sourceArc(ring[i - 1], ring[i]) : void 0;
+              const samples = sample(arc ? [arc(0), arc(1)] : [ring[i - 1], ring[i]], (p) => c.grid.project(p), options, Math.min(180 / (c.grid.section.rows - 1), 360 / (c.grid.section.columns - 1)), arc ? (_, t) => arc(t) : void 0);
+              if (!source.length) {
+                source.push(samples.source[0]);
+                xy.push(samples.xy[0]);
+              } else if (source[source.length - 1].some((v, k2) => Math.abs(v - samples.source[0][k2]) > 1e-10)) {
+                if (angle(geographic(source[source.length - 1]), geographic(samples.source[0])) > 1e-10)
+                  throw new Error("Discontinuous Elastic polygon source constraint");
+                if (options.polygonEdgeProvenance)
+                  edges.push({
+                    kind: "continuous-chart-join",
+                    ring: 4294967295,
+                    segment: 4294967295,
+                    t0: 0,
+                    t1: 0
+                  });
+                source.push(samples.source[0]);
+                xy.push(samples.xy[0]);
+              }
+              for (let j = 1; j < samples.source.length; j++) {
+                if (options.polygonEdgeProvenance) {
+                  if (owner) {
+                    const [pr, pe] = owner;
+                    edges.push(composePolygonEdge(preparedEdges[pr][pe], prepared[pr][pe], prepared[pr][pe + 1], source[source.length - 1], samples.source[j]));
+                  } else
+                    edges.push({
+                      kind: generated(ring[i - 1], ring[i]),
+                      ring: 4294967295,
+                      segment: 4294967295,
+                      t0: 0,
+                      t1: 0
+                    });
+                }
+                source.push(samples.source[j]);
+                xy.push(samples.xy[j]);
+              }
+            }
+            if (source.length && source[source.length - 1].some((v, k2) => v !== source[0][k2])) {
+              if (angle(geographic(source[source.length - 1]), geographic(source[0])) > 1e-10)
+                throw new Error("Unclosed Elastic polygon source constraint");
+              if (options.polygonEdgeProvenance)
+                edges.push({
+                  kind: "continuous-chart-join",
+                  ring: 4294967295,
+                  segment: 4294967295,
+                  t0: 0,
+                  t1: 0
+                });
+              source.push([...source[0]]);
+              xy.push([...xy[0]]);
+            }
+            coordinates2.push(xy);
+            sourceCoordinates.push(source);
+            edgeProvenance.push(edges);
+          });
           out.push({
             regionId: c.region.id,
-            coordinates: samples.map((s) => s.xy),
-            sourceCoordinates: samples.map((s) => s.source)
+            coordinates: coordinates2,
+            sourceCoordinates,
+            ...options.polygonEdgeProvenance ? { edgeProvenance } : {}
           });
         }
       }
@@ -16796,7 +17671,7 @@ function wrap2(lon) {
   return x > 180 ? x - 360 : x < -180 ? x + 360 : x;
 }
 function snapPolygon(rings) {
-  return rings.map((ring) => ring.map((p) => p.map((v) => Math.round(v * 1e10) / 1e10)));
+  return rings.map((r) => r.map((p) => p.map((v) => Math.round(v * 1e10) / 1e10)));
 }
 
 // dist/discontinuous/layout.js
@@ -19055,7 +19930,7 @@ function createGraticule(columns) {
 
 // dist/discontinuous/myriahedral/unfold.js
 var import_core2 = require("@math.gl/core");
-var import_geometry3 = require("@math.gl/geometry");
+var import_geometry4 = require("@math.gl/geometry");
 
 // dist/discontinuous/myriahedral/mesh.js
 var subtract3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
@@ -19298,7 +20173,7 @@ function restoreLayout(data) {
   const { mesh, panels, targetAngles } = data;
   if (panels.length !== mesh.faces.length || targetAngles.length !== panels.length || !targetAngles.every(Number.isFinite) || data.rootTransform.length !== 16 || !data.rootTransform.every(Number.isFinite))
     throw new Error("Invalid prepared hinge layout");
-  const tree = new import_geometry3.HingeTree(panels);
+  const tree = new import_geometry4.HingeTree(panels);
   const rootTransform = new import_core2.Matrix4(data.rootTransform);
   const poses = new Float64Array(panels.length * 16), angles = new Float64Array(panels.length);
   const evaluate2 = (amount) => {
@@ -19600,17 +20475,65 @@ var MercatorMap = class extends DiscontinuousMap {
           continue;
         }
         const at = (t) => [a[0] + (b[0] - a[0]) * t, a[1] + dy * t];
-        const start = at(t0), end = at(t1);
+        const endpoint = (t) => {
+          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 = (t2) => {
+            if (!arc)
+              return part.sourceCoordinates[i - 1];
+            const a2 = Math.sin((1 - t2) * arc) / Math.sin(arc), b2 = Math.sin(t2 * arc) / Math.sin(arc);
+            return coordinates(unit(va.map((v, k2) => a2 * v + b2 * vb[k2])));
+          };
+          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 append2 = (point, index) => {
+          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] : 4294967295);
+          if (options == null ? void 0 : 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 == null ? void 0 : options.pathBoundaries) ? { startReason: t0 > 0 ? "coverage-boundary" : part.provenance.startReason } : {}
+              }
+            } : {}
           };
           result.push(current);
+          append2(start, i - 1);
         }
-        current.coordinates.push(end);
-        current.sourceCoordinates.push(this.source(end));
+        append2(end, i);
+        if (current.provenance && (options == null ? void 0 : options.pathBoundaries))
+          current.provenance.endReason = t1 < 1 ? "coverage-boundary" : part.provenance.endReason;
         if (t1 < 1)
           current = void 0;
       }
@@ -19628,11 +20551,60 @@ var MercatorMap = class extends DiscontinuousMap {
         [-x, -y]
       ]
     ];
-    return super.projectPolygon(rings, options).flatMap((part) => import_polygon_clipping5.default.intersection(part.coordinates, box).map((coordinates2) => ({
-      regionId: part.regionId,
-      coordinates: coordinates2,
-      sourceCoordinates: coordinates2.map((ring) => ring.map((p) => this.source(p)))
-    })));
+    return super.projectPolygon(rings, options).flatMap((part) => import_polygon_clipping5.default.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 k2 = 0; k2 < 52; k2++) {
+              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 == null ? void 0 : 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",
+              ring: 4294967295,
+              segment: 4294967295,
+              t0: 0,
+              t1: 0
+            };
+          }))
+        } : {}
+      };
+    }));
   }
 };