@trackunit/react-map 0.2.86 → 0.2.88

package/index.cjs.js

@@ -7757,9 +7757,16 @@ const shapesUnderCursor = (position, features, options) => {
 /**
  * Connected components of features that share fill area. Bbox prefilter then
  * exact polygon intersection, mirroring `countOverlappingShapes`.
+ *
+ * `getGeoJsonPolygonIntersection` delegates to `polygon-clipping`, which can throw
+ * `"Unable to complete output ring"` for degenerate but schema-valid geometry
+ * (SAGA-743). A throw here is treated as "no overlap" — the safe degradation for
+ * grouping — and recorded in `intersectionFailures` so the hook can report it
+ * (mirrors how `droppedInvalidFeatures` surfaces the sibling failure mode).
  */
 const buildOverlapGroups = (records) => {
     const parent = records.map((_, index) => index);
+    const intersectionFailures = [];
     const find = (index) => {
         let root = index;
         while (parent[root] !== root)
@@ -7783,7 +7790,17 @@ const buildOverlapGroups = (records) => {
                 continue;
             if (!bboxesIntersect$1(a.bbox, b.bbox))
                 continue;
-            if (geoJsonUtils.getGeoJsonPolygonIntersection(a.geometry, b.geometry) !== null) {
+            let overlaps;
+            try {
+                overlaps = geoJsonUtils.getGeoJsonPolygonIntersection(a.geometry, b.geometry) !== null;
+            }
+            catch (error) {
+                // polygon-clipping failed on this pair. Treat as no overlap (do not union)
+                // so tiling degrades to full fills rather than crashing the map.
+                intersectionFailures.push({ featureIdA: a.id, featureIdB: b.id, error });
+                continue;
+            }
+            if (overlaps) {
                 union(i, j);
             }
         }
@@ -7799,7 +7816,7 @@ const buildOverlapGroups = (records) => {
             group.push(record);
         }
     });
-    return [...groups.values()].filter(group => group.length >= 2);
+    return { groups: [...groups.values()].filter(group => group.length >= 2), intersectionFailures };
 };
 const buildContendedShapes = (group) => group.map(record => {
     const containedIn = [];
@@ -7943,7 +7960,12 @@ const computeFillTiling = (input) => {
     const fillGeometries = new Map();
     const featureToGroupKey = new Map();
     const featureZIndex = new Map();
-    const overlapGroups = buildOverlapGroups(records);
+    const { groups: overlapGroups, intersectionFailures } = buildOverlapGroups(records);
+    if (intersectionFailures.length > 0) {
+        const pairList = intersectionFailures.map(failure => `${failure.featureIdA}↔${failure.featureIdB}`).join(", ");
+        // eslint-disable-next-line no-console -- Intentional: warn devs when polygon-clipping fails on schema-valid geometry (SAGA-743); the pair is treated as non-overlapping and full fills still render
+        console.warn(`[computeFillTiling] polygon-clipping failed on ${intersectionFailures.length} feature pair(s); treated as non-overlapping (full fill still renders): ${pairList}`);
+    }
     for (const group of overlapGroups) {
         const contended = buildContendedShapes(group);
         const recordById = new Map(group.map(record => [record.id, record]));
@@ -8018,6 +8040,7 @@ const computeFillTiling = (input) => {
         featureToGroupKey,
         featureZIndex,
         droppedInvalidFeatures,
+        intersectionFailures,
     };
 };
 
@@ -8323,6 +8346,31 @@ const buildShapeLabelResolutionContext = (feature, args) => {
     };
 };
 
+/** Stable, order-independent key so the pair (a,b) dedupes to the same entry as (b,a). */
+const resolveIntersectionFailureDedupeKey = (layerHandleId, failure) => {
+    const [first, second] = [failure.featureIdA, failure.featureIdB].sort();
+    return `${layerHandleId}:${first}|${second}`;
+};
+/**
+ * Report to Sentry each feature pair whose overlap test threw inside `polygon-clipping`
+ * (SAGA-743), at most once per handle/pair per session.
+ * Note: `computeFillTiling` emits `console.warn` separately.
+ */
+const captureFillTilingIntersectionFailures = (intersectionFailures, layerHandleId, sessionReportedDedupeKeys, report) => {
+    for (const failure of intersectionFailures) {
+        const key = resolveIntersectionFailureDedupeKey(layerHandleId, failure);
+        if (sessionReportedDedupeKeys.has(key))
+            continue;
+        sessionReportedDedupeKeys.add(key);
+        report({
+            layerHandleId,
+            featureIdA: failure.featureIdA,
+            featureIdB: failure.featureIdB,
+            message: failure.error instanceof Error ? failure.error.message : String(failure.error),
+        });
+    }
+};
+
 /**
  * Extract ALL vertex coordinates from a geometry, walking every part of
  * multi-geometries. Returns a flat array of [lng, lat] positions.
@@ -9577,6 +9625,7 @@ const bboxesIntersect = (a, b) => a[2] >= b[0] && a[0] <= b[2] && a[3] >= b[1] &
  */
 const buildOverlappingShapesCountMap = (features, featureBboxes, viewportBounds) => {
     const counts = new Map();
+    const intersectionFailures = [];
     for (const feature of features) {
         counts.set(feature, 0);
     }
@@ -9605,7 +9654,21 @@ const buildOverlappingShapesCountMap = (features, featureBboxes, viewportBounds)
             const geomB = featureB.geometry;
             const isPolygonalB = geomB !== null && (geomB.type === "Polygon" || geomB.type === "MultiPolygon");
             if (isPolygonalA && isPolygonalB) {
-                if (geoJsonUtils.getGeoJsonPolygonIntersection(geomA, geomB) !== null) {
+                let overlaps;
+                try {
+                    overlaps = geoJsonUtils.getGeoJsonPolygonIntersection(geomA, geomB) !== null;
+                }
+                catch (error) {
+                    // polygon-clipping failed on this pair (SAGA-743). Treat as no overlap so
+                    // decoration counts degrade gracefully instead of crashing the map.
+                    intersectionFailures.push({
+                        featureIdA: featureA.id !== undefined ? String(featureA.id) : `index:${i}`,
+                        featureIdB: featureB.id !== undefined ? String(featureB.id) : `index:${j}`,
+                        error,
+                    });
+                    continue;
+                }
+                if (overlaps) {
                     if (geoJsonUtils.isFullyContainedInGeoJsonGeometry(geomA, geomB) !== true) {
                         counts.set(featureA, (counts.get(featureA) ?? 0) + 1);
                     }
@@ -9620,7 +9683,7 @@ const buildOverlappingShapesCountMap = (features, featureBboxes, viewportBounds)
             }
         }
     }
-    return counts;
+    return { counts, intersectionFailures };
 };
 /**
  * Value-based equality for the nested style overrides maps. Used to skip
@@ -9706,6 +9769,25 @@ const useShapeDecorations = ({ onDecorationsChange, onStyleOverridesChange, api,
     const previousLayoutSides = react.useRef(new Map());
     const prevStyleOverridesRef = react.useRef(new Map());
     const prevDecorationLayersRef = react.useRef([]);
+    const errorHandler = reactCoreHooks.useErrorHandlerOrNull();
+    // Session-level dedupe so a recurring polygon-clipping failure (SAGA-743) reports
+    // to Sentry at most once per handle/pair per session, not on every pan frame.
+    const sessionReportedIntersectionKeysRef = react.useRef(new Set());
+    const reportOverlapIntersectionFailures = react.useCallback((intersectionFailures, layerHandleId) => {
+        if (intersectionFailures.length === 0)
+            return;
+        const pairList = intersectionFailures.map(failure => `${failure.featureIdA}↔${failure.featureIdB}`).join(", ");
+        // eslint-disable-next-line no-console -- Intentional: warn devs when polygon-clipping fails on schema-valid geometry (SAGA-743); the pair is treated as non-overlapping and decorations still render
+        console.warn(`[useShapeDecorations] polygon-clipping failed on ${intersectionFailures.length} feature pair(s); treated as non-overlapping: ${pairList}`);
+        if (errorHandler === null)
+            return;
+        captureFillTilingIntersectionFailures(intersectionFailures, layerHandleId, sessionReportedIntersectionKeysRef.current, payload => {
+            errorHandler.captureException(new Error(`polygon-clipping failed during decoration overlap counting: ${JSON.stringify(payload)}`), {
+                level: "warning",
+                fingerprint: ["react-map", "fill-tiling", "intersection-failure"],
+            });
+        });
+    }, [errorHandler]);
     /**
      * Labels that just transitioned from absent (hidden) to placed. While in
      * this set, edge identity is NOT stored — the algorithm gets one extra
@@ -9765,7 +9847,9 @@ const useShapeDecorations = ({ onDecorationsChange, onStyleOverridesChange, api,
             let overlappingCountsCache = null;
             const getOverlappingCount = (feature) => {
                 if (overlappingCountsCache === null) {
-                    overlappingCountsCache = buildOverlappingShapesCountMap(handle.features.features, featureBboxes, bounds);
+                    const { counts, intersectionFailures } = buildOverlappingShapesCountMap(handle.features.features, featureBboxes, bounds);
+                    overlappingCountsCache = counts;
+                    reportOverlapIntersectionFailures(intersectionFailures, handle.id);
                 }
                 return overlappingCountsCache.get(feature) ?? 0;
             };
@@ -10026,6 +10110,7 @@ const useShapeDecorations = ({ onDecorationsChange, onStyleOverridesChange, api,
         hasSourceReadiness,
         renderedSourceIds,
         isReady,
+        reportOverlapIntersectionFailures,
     ]);
     const updateDecorationsRef = react.useRef(updateDecorations);
     react.useEffect(() => {
@@ -10558,7 +10643,7 @@ const useShapeFillTiling = ({ api, handles, onFillGeometriesChange, onZIndexOver
         const nextRestingFills = new Map();
         const nextRestingZIndices = new Map();
         for (const handle of currentHandles) {
-            const { fillGeometries, featureToGroupKey, featureZIndex, droppedInvalidFeatures } = computeFillTiling({
+            const { fillGeometries, featureToGroupKey, featureZIndex, droppedInvalidFeatures, intersectionFailures } = computeFillTiling({
                 features: handle.features.features,
                 viewportBounds: GLOBAL_BOUNDS,
                 resolveStackOrder: handle.overlap?.resolveStackOrder ?? defaultShapeStackOrder,
@@ -10574,6 +10659,14 @@ const useShapeFillTiling = ({ api, handles, onFillGeometriesChange, onZIndexOver
                     });
                 });
             }
+            if (errorHandler !== null && intersectionFailures.length > 0) {
+                captureFillTilingIntersectionFailures(intersectionFailures, handle.id, sessionReportedDedupeKeysRef.current, payload => {
+                    errorHandler.captureException(new Error(`polygon-clipping failed during fill-tiling overlap grouping: ${JSON.stringify(payload)}`), {
+                        level: "warning",
+                        fingerprint: ["react-map", "fill-tiling", "intersection-failure"],
+                    });
+                });
+            }
             featureToGroupKeyByHandleRef.current.set(handle.id, new Map(featureToGroupKey));
             if (fillGeometries.size > 0) {
                 nextRestingFills.set(handle.id, fillGeometries);

package/index.esm.js

@@ -7756,9 +7756,16 @@ const shapesUnderCursor = (position, features, options) => {
 /**
  * Connected components of features that share fill area. Bbox prefilter then
  * exact polygon intersection, mirroring `countOverlappingShapes`.
+ *
+ * `getGeoJsonPolygonIntersection` delegates to `polygon-clipping`, which can throw
+ * `"Unable to complete output ring"` for degenerate but schema-valid geometry
+ * (SAGA-743). A throw here is treated as "no overlap" — the safe degradation for
+ * grouping — and recorded in `intersectionFailures` so the hook can report it
+ * (mirrors how `droppedInvalidFeatures` surfaces the sibling failure mode).
  */
 const buildOverlapGroups = (records) => {
     const parent = records.map((_, index) => index);
+    const intersectionFailures = [];
     const find = (index) => {
         let root = index;
         while (parent[root] !== root)
@@ -7782,7 +7789,17 @@ const buildOverlapGroups = (records) => {
                 continue;
             if (!bboxesIntersect$1(a.bbox, b.bbox))
                 continue;
-            if (getGeoJsonPolygonIntersection(a.geometry, b.geometry) !== null) {
+            let overlaps;
+            try {
+                overlaps = getGeoJsonPolygonIntersection(a.geometry, b.geometry) !== null;
+            }
+            catch (error) {
+                // polygon-clipping failed on this pair. Treat as no overlap (do not union)
+                // so tiling degrades to full fills rather than crashing the map.
+                intersectionFailures.push({ featureIdA: a.id, featureIdB: b.id, error });
+                continue;
+            }
+            if (overlaps) {
                 union(i, j);
             }
         }
@@ -7798,7 +7815,7 @@ const buildOverlapGroups = (records) => {
             group.push(record);
         }
     });
-    return [...groups.values()].filter(group => group.length >= 2);
+    return { groups: [...groups.values()].filter(group => group.length >= 2), intersectionFailures };
 };
 const buildContendedShapes = (group) => group.map(record => {
     const containedIn = [];
@@ -7942,7 +7959,12 @@ const computeFillTiling = (input) => {
     const fillGeometries = new Map();
     const featureToGroupKey = new Map();
     const featureZIndex = new Map();
-    const overlapGroups = buildOverlapGroups(records);
+    const { groups: overlapGroups, intersectionFailures } = buildOverlapGroups(records);
+    if (intersectionFailures.length > 0) {
+        const pairList = intersectionFailures.map(failure => `${failure.featureIdA}↔${failure.featureIdB}`).join(", ");
+        // eslint-disable-next-line no-console -- Intentional: warn devs when polygon-clipping fails on schema-valid geometry (SAGA-743); the pair is treated as non-overlapping and full fills still render
+        console.warn(`[computeFillTiling] polygon-clipping failed on ${intersectionFailures.length} feature pair(s); treated as non-overlapping (full fill still renders): ${pairList}`);
+    }
     for (const group of overlapGroups) {
         const contended = buildContendedShapes(group);
         const recordById = new Map(group.map(record => [record.id, record]));
@@ -8017,6 +8039,7 @@ const computeFillTiling = (input) => {
         featureToGroupKey,
         featureZIndex,
         droppedInvalidFeatures,
+        intersectionFailures,
     };
 };
 
@@ -8322,6 +8345,31 @@ const buildShapeLabelResolutionContext = (feature, args) => {
     };
 };
 
+/** Stable, order-independent key so the pair (a,b) dedupes to the same entry as (b,a). */
+const resolveIntersectionFailureDedupeKey = (layerHandleId, failure) => {
+    const [first, second] = [failure.featureIdA, failure.featureIdB].sort();
+    return `${layerHandleId}:${first}|${second}`;
+};
+/**
+ * Report to Sentry each feature pair whose overlap test threw inside `polygon-clipping`
+ * (SAGA-743), at most once per handle/pair per session.
+ * Note: `computeFillTiling` emits `console.warn` separately.
+ */
+const captureFillTilingIntersectionFailures = (intersectionFailures, layerHandleId, sessionReportedDedupeKeys, report) => {
+    for (const failure of intersectionFailures) {
+        const key = resolveIntersectionFailureDedupeKey(layerHandleId, failure);
+        if (sessionReportedDedupeKeys.has(key))
+            continue;
+        sessionReportedDedupeKeys.add(key);
+        report({
+            layerHandleId,
+            featureIdA: failure.featureIdA,
+            featureIdB: failure.featureIdB,
+            message: failure.error instanceof Error ? failure.error.message : String(failure.error),
+        });
+    }
+};
+
 /**
  * Extract ALL vertex coordinates from a geometry, walking every part of
  * multi-geometries. Returns a flat array of [lng, lat] positions.
@@ -9576,6 +9624,7 @@ const bboxesIntersect = (a, b) => a[2] >= b[0] && a[0] <= b[2] && a[3] >= b[1] &
  */
 const buildOverlappingShapesCountMap = (features, featureBboxes, viewportBounds) => {
     const counts = new Map();
+    const intersectionFailures = [];
     for (const feature of features) {
         counts.set(feature, 0);
     }
@@ -9604,7 +9653,21 @@ const buildOverlappingShapesCountMap = (features, featureBboxes, viewportBounds)
             const geomB = featureB.geometry;
             const isPolygonalB = geomB !== null && (geomB.type === "Polygon" || geomB.type === "MultiPolygon");
             if (isPolygonalA && isPolygonalB) {
-                if (getGeoJsonPolygonIntersection(geomA, geomB) !== null) {
+                let overlaps;
+                try {
+                    overlaps = getGeoJsonPolygonIntersection(geomA, geomB) !== null;
+                }
+                catch (error) {
+                    // polygon-clipping failed on this pair (SAGA-743). Treat as no overlap so
+                    // decoration counts degrade gracefully instead of crashing the map.
+                    intersectionFailures.push({
+                        featureIdA: featureA.id !== undefined ? String(featureA.id) : `index:${i}`,
+                        featureIdB: featureB.id !== undefined ? String(featureB.id) : `index:${j}`,
+                        error,
+                    });
+                    continue;
+                }
+                if (overlaps) {
                     if (isFullyContainedInGeoJsonGeometry(geomA, geomB) !== true) {
                         counts.set(featureA, (counts.get(featureA) ?? 0) + 1);
                     }
@@ -9619,7 +9682,7 @@ const buildOverlappingShapesCountMap = (features, featureBboxes, viewportBounds)
             }
         }
     }
-    return counts;
+    return { counts, intersectionFailures };
 };
 /**
  * Value-based equality for the nested style overrides maps. Used to skip
@@ -9705,6 +9768,25 @@ const useShapeDecorations = ({ onDecorationsChange, onStyleOverridesChange, api,
     const previousLayoutSides = useRef(new Map());
     const prevStyleOverridesRef = useRef(new Map());
     const prevDecorationLayersRef = useRef([]);
+    const errorHandler = useErrorHandlerOrNull();
+    // Session-level dedupe so a recurring polygon-clipping failure (SAGA-743) reports
+    // to Sentry at most once per handle/pair per session, not on every pan frame.
+    const sessionReportedIntersectionKeysRef = useRef(new Set());
+    const reportOverlapIntersectionFailures = useCallback((intersectionFailures, layerHandleId) => {
+        if (intersectionFailures.length === 0)
+            return;
+        const pairList = intersectionFailures.map(failure => `${failure.featureIdA}↔${failure.featureIdB}`).join(", ");
+        // eslint-disable-next-line no-console -- Intentional: warn devs when polygon-clipping fails on schema-valid geometry (SAGA-743); the pair is treated as non-overlapping and decorations still render
+        console.warn(`[useShapeDecorations] polygon-clipping failed on ${intersectionFailures.length} feature pair(s); treated as non-overlapping: ${pairList}`);
+        if (errorHandler === null)
+            return;
+        captureFillTilingIntersectionFailures(intersectionFailures, layerHandleId, sessionReportedIntersectionKeysRef.current, payload => {
+            errorHandler.captureException(new Error(`polygon-clipping failed during decoration overlap counting: ${JSON.stringify(payload)}`), {
+                level: "warning",
+                fingerprint: ["react-map", "fill-tiling", "intersection-failure"],
+            });
+        });
+    }, [errorHandler]);
     /**
      * Labels that just transitioned from absent (hidden) to placed. While in
      * this set, edge identity is NOT stored — the algorithm gets one extra
@@ -9764,7 +9846,9 @@ const useShapeDecorations = ({ onDecorationsChange, onStyleOverridesChange, api,
             let overlappingCountsCache = null;
             const getOverlappingCount = (feature) => {
                 if (overlappingCountsCache === null) {
-                    overlappingCountsCache = buildOverlappingShapesCountMap(handle.features.features, featureBboxes, bounds);
+                    const { counts, intersectionFailures } = buildOverlappingShapesCountMap(handle.features.features, featureBboxes, bounds);
+                    overlappingCountsCache = counts;
+                    reportOverlapIntersectionFailures(intersectionFailures, handle.id);
                 }
                 return overlappingCountsCache.get(feature) ?? 0;
             };
@@ -10025,6 +10109,7 @@ const useShapeDecorations = ({ onDecorationsChange, onStyleOverridesChange, api,
         hasSourceReadiness,
         renderedSourceIds,
         isReady,
+        reportOverlapIntersectionFailures,
     ]);
     const updateDecorationsRef = useRef(updateDecorations);
     useEffect(() => {
@@ -10557,7 +10642,7 @@ const useShapeFillTiling = ({ api, handles, onFillGeometriesChange, onZIndexOver
         const nextRestingFills = new Map();
         const nextRestingZIndices = new Map();
         for (const handle of currentHandles) {
-            const { fillGeometries, featureToGroupKey, featureZIndex, droppedInvalidFeatures } = computeFillTiling({
+            const { fillGeometries, featureToGroupKey, featureZIndex, droppedInvalidFeatures, intersectionFailures } = computeFillTiling({
                 features: handle.features.features,
                 viewportBounds: GLOBAL_BOUNDS,
                 resolveStackOrder: handle.overlap?.resolveStackOrder ?? defaultShapeStackOrder,
@@ -10573,6 +10658,14 @@ const useShapeFillTiling = ({ api, handles, onFillGeometriesChange, onZIndexOver
                     });
                 });
             }
+            if (errorHandler !== null && intersectionFailures.length > 0) {
+                captureFillTilingIntersectionFailures(intersectionFailures, handle.id, sessionReportedDedupeKeysRef.current, payload => {
+                    errorHandler.captureException(new Error(`polygon-clipping failed during fill-tiling overlap grouping: ${JSON.stringify(payload)}`), {
+                        level: "warning",
+                        fingerprint: ["react-map", "fill-tiling", "intersection-failure"],
+                    });
+                });
+            }
             featureToGroupKeyByHandleRef.current.set(handle.id, new Map(featureToGroupKey));
             if (fillGeometries.size > 0) {
                 nextRestingFills.set(handle.id, fillGeometries);

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@trackunit/react-map",
-  "version": "0.2.86",
+  "version": "0.2.88",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {
     "node": ">=24.x"
   },
   "dependencies": {
-    "@trackunit/react-components": "2.10.7",
+    "@trackunit/react-components": "2.10.9",
     "@trackunit/css-class-variance-utilities": "1.14.17",
-    "@trackunit/react-form-components": "2.6.12",
-    "@trackunit/react-core-hooks": "1.21.14",
-    "@trackunit/geo-json-utils": "1.15.18",
-    "@trackunit/i18n-library-translation": "2.4.14",
+    "@trackunit/react-form-components": "2.6.14",
+    "@trackunit/react-core-hooks": "1.21.16",
+    "@trackunit/geo-json-utils": "1.15.19",
+    "@trackunit/i18n-library-translation": "2.4.16",
     "react-minimal-pie-chart": "^8.4.0",
-    "@trackunit/react-map-adapter-shared": "0.0.98",
+    "@trackunit/react-map-adapter-shared": "0.0.99",
     "@trackunit/react-map-color-utils": "0.0.80",
     "@trackunit/ui-design-tokens": "1.15.7",
     "@floating-ui/react": "^0.26.25",

package/src/layers/useShapes/captureFillTilingIntersectionFailures.d.ts

@@ -0,0 +1,9 @@
+import type { FillTilingIntersectionFailure } from "./shapeFillTiling";
+type ReportFillTilingIntersectionFailureEvent = (payload: Record<string, unknown>) => void;
+/**
+ * Report to Sentry each feature pair whose overlap test threw inside `polygon-clipping`
+ * (SAGA-743), at most once per handle/pair per session.
+ * Note: `computeFillTiling` emits `console.warn` separately.
+ */
+export declare const captureFillTilingIntersectionFailures: (intersectionFailures: ReadonlyArray<FillTilingIntersectionFailure>, layerHandleId: string, sessionReportedDedupeKeys: Set<string>, report: ReportFillTilingIntersectionFailureEvent) => void;
+export {};

package/src/layers/useShapes/shapeFillTiling.d.ts

@@ -70,12 +70,25 @@ export type FillTilingResult = Readonly<{
     featureZIndex: ReadonlyMap<string, number>;
     /** Features excluded from fill tiling when boundary schema validation fails. */
     droppedInvalidFeatures: ReadonlyArray<DroppedInvalidFillTilingFeature>;
+    /**
+     * Feature pairs whose overlap test threw inside `polygon-clipping` (SAGA-743).
+     * The pair was treated as non-overlapping; surfaced here so the hook can report
+     * it to Sentry, since the geometry is schema-valid and never hits
+     * `droppedInvalidFeatures`.
+     */
+    intersectionFailures: ReadonlyArray<FillTilingIntersectionFailure>;
 }>;
 export type DroppedInvalidFillTilingFeature = Readonly<{
     feature: GeoJsonFeature;
     /** `safeParse` failure details (`parsed.error.format()`). */
     validationError: unknown;
 }>;
+export type FillTilingIntersectionFailure = Readonly<{
+    featureIdA: string;
+    featureIdB: string;
+    /** The error thrown by `polygon-clipping` (typically "Unable to complete output ring"). */
+    error: unknown;
+}>;
 /**
  * Planar area of any GeoJSON geometry (outer rings minus holes). Returns 0 for
  * non-polygonal types (Point, LineString, …). Relative magnitude only — not