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

package/dist/workers/index.cjs

@@ -809,8 +809,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;
 }
 var import_polygon_clipping, TOL, arcCross, angle2;
@@ -841,33 +882,13 @@ function inRing(p, ring, includeBoundary = true) {
   }
   return inside;
 }
-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)
@@ -878,23 +899,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 };
 }
@@ -1001,7 +1022,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;
@@ -1016,12 +1037,71 @@ function geographicRings(rings, center3) {
     });
   });
 }
-var import_polygon_clipping2, MapTransitionGeometry, MapTransition, coverageCache;
+var import_polygon_clipping2, directWorldProjections, MapTransitionGeometry, MapTransition, coverageCache;
 var init_map_transition = __esm({
   "dist/discontinuous/map-transition.js"() {
     import_polygon_clipping2 = __toESM(require("polygon-clipping"), 1);
     init_math2();
     init_geometry();
+    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"
+    ]);
     MapTransitionGeometry = class {
       constructor(parts, strategy, radius2) {
         this.strategy = strategy;
@@ -1234,6 +1314,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 = [];
@@ -1254,7 +1344,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),
@@ -1266,12 +1376,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);
       }
@@ -1335,12 +1474,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)
+        }
+      } : {}
     }
   };
 }
@@ -1355,6 +1520,181 @@ var init_prepare_features = __esm({
   }
 });
 
+// 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)
+  };
+}
+var init_polygon_constraints = __esm({
+  "dist/discontinuous/polygon-constraints.js"() {
+    init_math2();
+  }
+});
+
+// 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;
+  };
+}
+var init_source_arc = __esm({
+  "dist/discontinuous/source-arc.js"() {
+    init_math2();
+  }
+});
+
 // dist/discontinuous/map-layout.js
 function sampling2(options) {
   const step = options.maxAngularStep ?? 2, tolerance = options.tolerance ?? 1e-4;
@@ -1546,6 +1886,10 @@ var init_map_layout = __esm({
         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++) {
@@ -1554,18 +1898,42 @@ var init_map_layout = __esm({
               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;
           }
@@ -1662,26 +2030,91 @@ var init_map_layout = __esm({
               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));
@@ -1794,6 +2227,8 @@ var CapMap;
 var init_cap_map = __esm({
   "dist/discontinuous/cap-map.js"() {
     init_clip_circle();
+    init_polygon_constraints();
+    init_source_arc();
     init_circle();
     init_map_layout();
     init_math2();
@@ -1850,10 +2285,11 @@ var init_cap_map = __esm({
       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");
@@ -1908,14 +2344,49 @@ var init_cap_map = __esm({
           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: () => {
           },
@@ -1932,7 +2403,9 @@ var init_cap_map = __esm({
           }
           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) {
@@ -1949,11 +2422,14 @@ var init_cap_map = __esm({
           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();
@@ -1965,7 +2441,41 @@ var init_cap_map = __esm({
       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)
@@ -2038,15 +2548,95 @@ var init_cap_map = __esm({
           };
           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
+                  };
+                }))
+              } : {}
             });
           }
         }
@@ -4322,6 +4912,101 @@ var init_grid = __esm({
   }
 });
 
+// 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;
+}
+var init_source_arc2 = __esm({
+  "dist/discontinuous/elastic/source-arc.js"() {
+    init_math2();
+    init_geometry();
+    init_source_arc();
+  }
+});
+
 // dist/discontinuous/elastic/map.js
 function createElasticMap(data, options = {}) {
   return new ElasticMap(data, options.radius ?? 1);
@@ -4331,7 +5016,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)));
 }
 var import_polygon_clipping4, kernel, splitter, ElasticMap;
 var init_map = __esm({
@@ -4341,6 +5026,9 @@ var init_map = __esm({
     init_math2();
     init_grid();
     init_geometry();
+    init_source_arc2();
+    init_source_arc();
+    init_polygon_constraints();
     kernel = Object.assign((x, y) => [x, y], {
       invert: (x, y) => [x, y]
     });
@@ -4468,7 +5156,7 @@ var init_map = __esm({
       }
       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)));
@@ -4477,23 +5165,70 @@ var init_map = __esm({
         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;
               }
-            flush();
+              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;
+              }
+            }
           }
         return out;
       }
@@ -4501,13 +5236,175 @@ var init_map = __esm({
         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 } : {}
               });
             }
           }
@@ -7242,7 +8139,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) => {
@@ -7285,11 +8182,11 @@ function countOverlaps(faces) {
     }
   return count;
 }
-var import_core2, import_geometry3;
+var import_core2, import_geometry4;
 var init_unfold = __esm({
   "dist/discontinuous/myriahedral/unfold.js"() {
     import_core2 = require("@math.gl/core");
-    import_geometry3 = require("@math.gl/geometry");
+    import_geometry4 = require("@math.gl/geometry");
     init_mesh();
   }
 });
@@ -7488,6 +8385,8 @@ var import_polygon_clipping5, MercatorMap;
 var init_mercator_map = __esm({
   "dist/discontinuous/mercator-map.js"() {
     import_polygon_clipping5 = __toESM(require("polygon-clipping"), 1);
+    init_polygon_constraints();
+    init_source_arc();
     init_map_layout();
     init_math2();
     MercatorMap = class extends DiscontinuousMap {
@@ -7567,17 +8466,65 @@ var init_mercator_map = __esm({
               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;
           }
@@ -7595,11 +8542,60 @@ var init_mercator_map = __esm({
             [-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
+                };
+              }))
+            } : {}
+          };
+        }));
       }
     };
   }