@itwin/ecschema-rpcinterface-tests 5.9.0-dev.7 → 5.9.0-dev.9

package/lib/dist/bundled-tests.js

@@ -35656,6 +35656,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   CloudSqliteError: () => (/* binding */ CloudSqliteError),
 /* harmony export */   EditTxnError: () => (/* binding */ EditTxnError),
 /* harmony export */   ITwinSettingsError: () => (/* binding */ ITwinSettingsError),
+/* harmony export */   ServerBasedLocksError: () => (/* binding */ ServerBasedLocksError),
 /* harmony export */   SqliteError: () => (/* binding */ SqliteError),
 /* harmony export */   ViewStoreError: () => (/* binding */ ViewStoreError),
 /* harmony export */   WorkspaceError: () => (/* binding */ WorkspaceError)
@@ -35778,6 +35779,24 @@ var EditTxnError;
     }
     EditTxnError.isError = isError;
 })(EditTxnError || (EditTxnError = {}));
+/** Errors originating from the server-based implementation of the [LockControl]($backend) interface.
+ * @beta
+ */
+var ServerBasedLocksError;
+(function (ServerBasedLocksError) {
+    /** the ITwinError scope for `ServerBasedLocksError`s. */
+    ServerBasedLocksError.scope = "itwin-ServerBasedLocks";
+    /** Instantiate and throw a ServerBasedLocksError */
+    function throwError(key, message) {
+        _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.ITwinError.throwError({ iTwinErrorId: { scope: ServerBasedLocksError.scope, key }, message });
+    }
+    ServerBasedLocksError.throwError = throwError;
+    /** Determine whether an error object is a ServerBasedLocksError */
+    function isError(error, key) {
+        return _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.ITwinError.isError(error, ServerBasedLocksError.scope, key);
+    }
+    ServerBasedLocksError.isError = isError;
+})(ServerBasedLocksError || (ServerBasedLocksError = {}));
 
 
 /***/ }),
@@ -45664,6 +45683,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   Run: () => (/* reexport safe */ _annotation_TextBlock__WEBPACK_IMPORTED_MODULE_3__.Run),
 /* harmony export */   SchemaState: () => (/* reexport safe */ _BriefcaseTypes__WEBPACK_IMPORTED_MODULE_13__.SchemaState),
 /* harmony export */   SectionType: () => (/* reexport safe */ _ElementProps__WEBPACK_IMPORTED_MODULE_32__.SectionType),
+/* harmony export */   ServerBasedLocksError: () => (/* reexport safe */ _ITwinCoreErrors__WEBPACK_IMPORTED_MODULE_73__.ServerBasedLocksError),
 /* harmony export */   ServerError: () => (/* reexport safe */ _IModelError__WEBPACK_IMPORTED_MODULE_71__.ServerError),
 /* harmony export */   ServerTimeoutError: () => (/* reexport safe */ _IModelError__WEBPACK_IMPORTED_MODULE_71__.ServerTimeoutError),
 /* harmony export */   SilhouetteEdgeArgs: () => (/* reexport safe */ _internal_cross_package__WEBPACK_IMPORTED_MODULE_164__.SilhouetteEdgeArgs),
@@ -83000,6 +83020,23 @@ class BriefcaseTxns extends BriefcaseNotificationHandler {
     async reverseSingleTxn() {
         return this.reverseTxns(1);
     }
+    /** Reverse (undo) the most recent operation to this briefcase in the current session. By default, this method also
+     * abandons the locks that were acquired for that operation.
+     * @beta
+     * @note This method will also abandon locks associated with any later, reversed Txns, if they have not
+     * already been abandoned. For example, if a call to [[reverseTxns]] reverses Txn 2 without abandoning
+     * its locks, and then this method is called to reverse Txn 1, it will abandon the locks associated
+     * with _both_ Txn 1 and Txn 2.
+     * @note If there are any outstanding uncommitted changes, they are reversed.
+     * @note The term "operation" is used rather than Txn, since multiple Txns can be grouped together via [TxnManager.beginMultiTxnOperation]($backend). So,
+     * even though this method reverses only one operation, multiple Txns may be reversed if they were grouped together when they were made.
+     * @note If there are no reversible operations, this method does nothing and returns Success.
+     * @param args Optional arguments to control the behavior of the reverse operation, such as whether to retain locks.
+     * @returns A Promise that resolves to success if the transactions were reversed, or rejects with an IModelError otherwise.
+     */
+    async reverseSingleTxnAsync(args) {
+        await this.reverseTxnsAsync(1, args);
+    }
     /** Reverse (undo) the most recent operation(s) to the briefcase in the current session.
      * @param numOperations the number of operations to reverse. If this is greater than 1, the entire set of operations will
      *  be reinstated together when/if [[reinstateTxn]] is called.
@@ -83011,6 +83048,26 @@ class BriefcaseTxns extends BriefcaseNotificationHandler {
     async reverseTxns(numOperations) {
         return _IpcApp__WEBPACK_IMPORTED_MODULE_3__.IpcApp.appFunctionIpc.reverseTxns(this._iModel.key, numOperations);
     }
+    /** Reverse (undo) the most recent operation(s) to the briefcase in the current session. By default, this method also
+     * abandons the locks that were acquired for those operations.
+     * @beta
+     * @note This method will also abandon locks associated with any later, reversed Txns, if they have not
+     * already been abandoned. For example, if a call to [[reverseTxns]] reverses Txn 2 without abandoning
+     * its locks, and then this method is called to reverse Txn 1, it will abandon the locks associated
+     * with _both_ Txn 1 and Txn 2.
+     * @note If you do not want to abandon any locks, set [ReverseTxnArgs.retainLocks]($common) to true.
+     * @note If there are any outstanding uncommitted changes, they are reversed.
+     * @note The term "operation" is used rather than Txn, since multiple Txns can be grouped together via [[beginMultiTxnOperation]]. So,
+     * even if numOperations is 1, multiple Txns may be reversed if they were grouped together when they were made.
+     * @note If numOperations is too large only the operations are reversible are reversed.
+     * @param numOperations the number of operations to reverse. If this is greater than 1, the entire set of operations will
+     *  be reinstated together when/if ReinstateTxn is called.
+     * @param args Optional arguments to control the behavior of the reverse operation, such as whether to retain locks.
+     * @returns A Promise that resolves to success if the transactions were reversed, or rejects with an IModelError otherwise.
+     */
+    async reverseTxnsAsync(numOperations, args) {
+        return _IpcApp__WEBPACK_IMPORTED_MODULE_3__.IpcApp.appFunctionIpc.reverseTxnsAsync(this._iModel.key, numOperations, args);
+    }
     /** Reverse (undo) all changes back to the beginning of the session.
      * @see [[reinstateTxn]] to redo changes.
      * @see [[reverseSingleTxn]] to undo only the most recent operation.
@@ -83019,6 +83076,21 @@ class BriefcaseTxns extends BriefcaseNotificationHandler {
     async reverseAll() {
         return _IpcApp__WEBPACK_IMPORTED_MODULE_3__.IpcApp.appFunctionIpc.reverseAllTxn(this._iModel.key);
     }
+    /** Reverse (undo) all operations back to the beginning of the session. By default, this method also
+     * abandons the locks that were acquired for those operations.
+     * @beta
+     * @note This method will also abandon locks associated with any later, reversed Txns, if they have not
+     * already been abandoned. For example, if a call to [[reverseTxns]] reverses Txn 2 without abandoning
+     * its locks, and then this method is called to reverse Txn 1, it will abandon the locks associated
+     * with _both_ Txn 1 and Txn 2.
+     * @note If there are any outstanding uncommitted changes, they are reversed.
+     * @note If there are no reversible operations, this method does nothing and returns Success.
+     * @param args Optional arguments to control the behavior of the reverse operation, such as whether to retain locks.
+     * @returns A Promise that resolves to success if the transactions were reversed, or rejects with an IModelError otherwise.
+     */
+    async reverseAllTxnsAsync(args) {
+        return _IpcApp__WEBPACK_IMPORTED_MODULE_3__.IpcApp.appFunctionIpc.reverseAllTxnsAsync(this._iModel.key, args);
+    }
     /** Reinstate (redo) the most recently reversed transaction. Since at any time multiple transactions can be reversed, it
      * may take multiple calls to this method to reinstate all reversed operations.
      * @returns Success if a reversed transaction was reinstated, error status otherwise.
@@ -83029,6 +83101,19 @@ class BriefcaseTxns extends BriefcaseNotificationHandler {
     async reinstateTxn() {
         return _IpcApp__WEBPACK_IMPORTED_MODULE_3__.IpcApp.appFunctionIpc.reinstateTxn(this._iModel.key);
     }
+    /** Reinstate (redo) the most recently reversed transaction. Since at any time multiple transactions can be reversed, it
+     * may take multiple calls to this method to reinstate all reversed operations. This method also
+     * re-acquires the locks that were abandoned when those operations were reversed.
+     * @beta
+     * @param args Optional arguments to control the behavior of the reinstate operation.
+     * @returns Success if a reversed transaction was reinstated, error status otherwise.
+     * @note If there are any outstanding uncommitted changes, they are canceled before the Txn is reinstated.
+     * @see [[isRedoPossible]] to determine if any reinstatable operations exist.
+     * @see [[reverseSingleTxn]] or [[reverseAll]] to undo changes.
+     */
+    async reinstateTxnAsync(args) {
+        return _IpcApp__WEBPACK_IMPORTED_MODULE_3__.IpcApp.appFunctionIpc.reinstateTxnAsync(this._iModel.key, args);
+    }
     /** Restart the current TxnManager session. This causes all Txns in the current session to no longer be undoable (as if the file was closed
      * and reopened.)
      * @note This can be quite disconcerting to the user expecting to be able to undo previously made changes. It should only be used
@@ -184054,7 +184139,7 @@ class ToolAdmin {
         const imodel = _IModelApp__WEBPACK_IMPORTED_MODULE_5__.IModelApp.viewManager.selectedView?.view.iModel;
         if (undefined === imodel || imodel.isReadonly || !imodel.isBriefcaseConnection())
             return false;
-        return (_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.Success === await imodel.txns.reverseSingleTxn() ? true : false);
+        return imodel.txns.reverseSingleTxnAsync().then(() => true).catch(() => false);
     }
     /** Called to redo previous data button for primitive tools or undo last write operation. */
     async doRedoOperation() {
@@ -184067,7 +184152,7 @@ class ToolAdmin {
         const imodel = _IModelApp__WEBPACK_IMPORTED_MODULE_5__.IModelApp.viewManager.selectedView?.view.iModel;
         if (undefined === imodel || imodel.isReadonly || !imodel.isBriefcaseConnection())
             return false;
-        return (_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.Success === await imodel.txns.reinstateTxn() ? true : false);
+        return imodel.txns.reinstateTxnAsync().then(() => true).catch(() => false);
     }
     onActiveToolChanged(tool, start) {
         this.clearMotionPromises();
@@ -189026,18 +189111,18 @@ __webpack_require__.r(__webpack_exports__);
  */
 var AxisOrder;
 (function (AxisOrder) {
-    /** Right handed system, X then Y then Z */
+    /** Right-handed system, X then Y then Z. */
     // eslint-disable-next-line @typescript-eslint/no-shadow
     AxisOrder[AxisOrder["XYZ"] = 0] = "XYZ";
-    /** Right handed system, Y then Z then X */
+    /** Right-handed system, Y then Z then X. */
     AxisOrder[AxisOrder["YZX"] = 1] = "YZX";
-    /** Right handed system, Z then X then Y */
+    /** Right-handed system, Z then X then Y. */
     AxisOrder[AxisOrder["ZXY"] = 2] = "ZXY";
-    /** Left handed system, X then Z then Y */
+    /** Left-handed system, X then Z then Y. For a right-handed alternative, swap the first two axes and use `AxisOrder.ZXY`. */
     AxisOrder[AxisOrder["XZY"] = 4] = "XZY";
-    /** Left handed system, Y then X then Z */
+    /** Left-handed system, Y then X then Z. For a right-handed alternative, swap the first two axes and use `AxisOrder.XYZ`.*/
     AxisOrder[AxisOrder["YXZ"] = 5] = "YXZ";
-    /** Left handed system, Z then Y then X */
+    /** Left-handed system, Z then Y then X. For a right-handed alternative, swap the first two axes and use `AxisOrder.YZX`.*/
     AxisOrder[AxisOrder["ZYX"] = 6] = "ZYX";
 })(AxisOrder || (AxisOrder = {}));
 /**
@@ -189137,6 +189222,8 @@ class Geometry {
     static smallAngleSeconds = 2e-7;
     /** Numeric value that may be considered zero for fractions between 0 and 1. */
     static smallFraction = 1.0e-10;
+    /** Relative fraction tolerance for Newton iterations. */
+    static smallNewtonStep = 1.0e-11;
     /** Tight tolerance near machine precision (unitless). Useful for snapping values, e.g., to 0 or 1. */
     static smallFloatingPoint = 1.0e-15;
     /** Radians value for full circle 2PI radians minus [[smallAngleRadians]]. */
@@ -201815,6 +201902,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   TriangularFacetLocationDetail: () => (/* reexport safe */ _polyface_FacetLocationDetail__WEBPACK_IMPORTED_MODULE_115__.TriangularFacetLocationDetail),
 /* harmony export */   UVSelect: () => (/* reexport safe */ _bspline_BSplineSurface__WEBPACK_IMPORTED_MODULE_108__.UVSelect),
 /* harmony export */   UVSurfaceOps: () => (/* reexport safe */ _geometry3d_UVSurfaceOps__WEBPACK_IMPORTED_MODULE_34__.UVSurfaceOps),
+/* harmony export */   UniformStrokeCollector: () => (/* reexport safe */ _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_8__.UniformStrokeCollector),
 /* harmony export */   UnionOfConvexClipPlaneSets: () => (/* reexport safe */ _clipping_UnionOfConvexClipPlaneSets__WEBPACK_IMPORTED_MODULE_42__.UnionOfConvexClipPlaneSets),
 /* harmony export */   UnionRegion: () => (/* reexport safe */ _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_88__.UnionRegion),
 /* harmony export */   UnivariateBezier: () => (/* reexport safe */ _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_52__.UnivariateBezier),
@@ -202908,6 +202996,17 @@ class Arc3d extends _CurvePrimitive__WEBPACK_IMPORTED_MODULE_1__.CurvePrimitive
     startPoint(result) {
         return this.fractionToPoint(0.0, result);
     }
+    /**
+     * Whether the start and end points are defined and within tolerance.
+     * * Does not check for degeneracy.
+     * @param tolerance optional distance tolerance (default is [[Geometry.smallMetricDistance]])
+     * @param xyOnly if true, ignore z coordinate (default is `false`)
+     */
+    isPhysicallyClosedCurve(tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_6__.Geometry.smallMetricDistance, xyOnly = false) {
+        if (this.sweep.isFullCircle)
+            return true;
+        return super.isPhysicallyClosedCurve(tolerance, xyOnly);
+    }
     /**
      * Return the end point of the arc.
      * @param result optional preallocated result.
@@ -205103,32 +205202,42 @@ class CurveChainWithDistanceIndex extends _curve_CurvePrimitive__WEBPACK_IMPORTE
         }
         return undefined;
     }
+    /**
+     * Given a parent chain, convert the corresponding child detail in the specified pair.
+     * * Converted details refer to the chain's global parameterization instead of the child's.
+     * * It is assumed that `pair.detailA.curve` is a child of chainA (similarly for chainB).
+     * @param pair detail pair to convert in place
+     * @param chainA convert pair.detailA to the global parameterization of chainA
+     * @param chainB convert pair.detailB to the global parameterization of chainB
+     * @return the converted pair
+     */
+    static convertChildDetailToChainDetailSingle(pair, chainA, chainB) {
+        if (chainA) {
+            const chainDetail = chainA.computeChainDetail(pair.detailA);
+            if (chainDetail)
+                pair.detailA = chainDetail;
+        }
+        if (chainB) {
+            const chainDetail = chainB.computeChainDetail(pair.detailB);
+            if (chainDetail)
+                pair.detailB = chainDetail;
+        }
+        return pair;
+    }
     /**
      * Given a parent chain, convert the corresponding child details in the specified pairs.
      * * Converted details refer to the chain's global parameterization instead of the child's.
      * * It is assumed that for all i >= index0, `pairs[i].detailA.curve` is a child of chainA (similarly for chainB).
-     * @param pairs array to mutate
+     * @param pairs array of pairs to convert in place
      * @param index0 convert details of pairs in the tail of the array, starting at index0
      * @param chainA convert each specified detailA to the global parameterization of chainA
      * @param chainB convert each specified detailB to the global parameterization of chainB
      * @param compressAdjacent whether to remove adjacent duplicate pairs after conversion
      * @return the converted array
-     * @internal
      */
     static convertChildDetailToChainDetail(pairs, index0, chainA, chainB, compressAdjacent) {
-        for (let i = index0; i < pairs.length; ++i) {
-            const childDetailPair = pairs[i];
-            if (chainA) {
-                const chainDetail = chainA.computeChainDetail(childDetailPair.detailA);
-                if (chainDetail)
-                    childDetailPair.detailA = chainDetail;
-            }
-            if (chainB) {
-                const chainDetail = chainB.computeChainDetail(childDetailPair.detailB);
-                if (chainDetail)
-                    childDetailPair.detailB = chainDetail;
-            }
-        }
+        for (let i = index0; i < pairs.length; ++i)
+            pairs[i] = this.convertChildDetailToChainDetailSingle(pairs[i], chainA, chainB);
         if (compressAdjacent)
             pairs = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetailPair.removeAdjacentDuplicates(pairs, index0);
         return pairs;
@@ -205397,25 +205506,34 @@ class CurveCollection extends _GeometryQuery__WEBPACK_IMPORTED_MODULE_1__.Geomet
         return this.isAnyRegionType;
     }
     /**
-     * Return true for a `Path`, i.e. a chain of curves joined head-to-tail
-     * @see isPath
+     * Return true for a `Path`, i.e. a chain of curves joined head-to-tail.
+     * * This is NOT a test for (lack of) physical closure.
+     * @see [[isPath]], [[CurveChain.isPhysicallyClosedCurve]]
      */
     get isOpenPath() {
         return this.dgnBoundaryType() === 1;
     }
-    /** Type guard for Path */
+    /**
+     * Type guard for Path.
+     * * This is NOT a test for (lack of) physical closure.
+     * @see [[CurveChain.isPhysicallyClosedCurve]]
+     */
     isPath() {
         return this.isOpenPath;
     }
     /**
      * Return true for a single-loop planar region type, i.e. `Loop`.
-     * * This is NOT a test for physical closure of a `Path`.
-     * @see isLoop
+     * * This is NOT a test for physical closure.
+     * @see [[isLoop]], [[CurveChain.isPhysicallyClosedCurve]]
      */
     get isClosedPath() {
         return this.dgnBoundaryType() === 2;
     }
-    /** Type guard for Loop */
+    /**
+     * Type guard for Loop.
+     * * This is NOT a test for physical closure.
+     * @see [[CurveChain.isPhysicallyClosedCurve]]
+     */
     isLoop() {
         return this.isClosedPath;
     }
@@ -205835,7 +205953,7 @@ class CurveCurve {
      * * If more than one approach is returned, one of them is the closest approach.
      * * If an input curve is a `CurveCollection`, then close approaches are computed to each `CurvePrimitive` child.
      * This can lead to many returned pairs, especially when both inputs are `CurveCollection`s. If an input curve is
-     * an `AnyRegion` then close approaches are computed only to the boundary curves, not to the interior.
+     * an `AnyRegion`, then close approaches are computed only to the defining curves, not to the area they enclose.
      * @param curveA first curve
      * @param curveB second curve
      * @param maxDistance maximum xy-distance to consider between the curves.
@@ -205868,6 +205986,7 @@ class CurveCurve {
         let iMin = 0;
         let minDistXY = 2 * maxDistance;
         for (let i = 0; i < closeApproaches.length; ++i) {
+            // TODO: this distance should already be in detail.a. Verify this, then just use it instead of recomputing below.
             const distXY = closeApproaches[i].detailA.point.distanceXY(closeApproaches[i].detailB.point);
             if (distXY < minDistXY) {
                 iMin = i;
@@ -206947,8 +207066,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   CurveLocationDetailPair: () => (/* binding */ CurveLocationDetailPair),
 /* harmony export */   CurveSearchStatus: () => (/* binding */ CurveSearchStatus)
 /* harmony export */ });
-/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
-/* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
+/* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -206958,6 +207078,7 @@ __webpack_require__.r(__webpack_exports__);
  */
 
 
+
 /**
  * An enumeration of special conditions being described by a CurveLocationDetail.
  * @public
@@ -207038,9 +207159,9 @@ class CurveLocationDetail {
     pointQ;
     /** Constructor */
     constructor() {
-        this.pointQ = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.createZero();
+        this.pointQ = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero();
         this.fraction = 0;
-        this.point = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.createZero();
+        this.point = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero();
         this.a = 0.0;
     }
     /** Set the (optional) intervalRole field. */
@@ -207187,7 +207308,7 @@ class CurveLocationDetail {
     static createConditionalMoveSignedDistance(allowExtension, curve, startFraction, endFraction, requestedSignedDistance, result) {
         let a = requestedSignedDistance;
         let status = CurveSearchStatus.success;
-        if (!allowExtension && !_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.isIn01(endFraction)) {
+        if (!allowExtension && !_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isIn01(endFraction)) {
             // cap the movement at the endpoint
             if (endFraction < 0.0) {
                 a = -curve.curveLengthBetweenFractions(startFraction, 0.0);
@@ -207298,7 +207419,7 @@ class CurveLocationDetail {
     inverseInterpolateFraction(f, defaultFraction = 0) {
         if (this.fraction1 === undefined)
             return defaultFraction;
-        const a = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.inverseInterpolate01(this.fraction, this.fraction1, f);
+        const a = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.inverseInterpolate01(this.fraction, this.fraction1, f);
         if (a === undefined)
             return defaultFraction;
         return a;
@@ -207321,7 +207442,7 @@ class CurveLocationDetail {
      * @param fractionTol optional relative tolerance for comparing fractions with [[Geometry.isAlmostEqualNumber]].
     */
     isSameCurveAndFraction(other, fractionTol) {
-        return this.curve === other.curve && _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.isAlmostEqualNumber(this.fraction, other.fraction, fractionTol);
+        return this.curve === other.curve && _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualNumber(this.fraction, other.fraction, fractionTol);
     }
     /**
      * Transform the detail in place.
@@ -207457,6 +207578,64 @@ class CurveLocationDetailPair {
     tryTransformInPlace(transform) {
         return this.detailA.tryTransformInPlace(transform) && this.detailB.tryTransformInPlace(transform);
     }
+    /**
+     * Return a pair comparator useful for sorting an array of detail pairs by their fractions.
+     * * Comparison assumes detailA curves are the same and detailB curves are the same.
+     * * Comparison checks for equality of pair fractions, then of pair points, then sorts by detailA.fraction, then detailB.fraction.
+     * @param fractionTol tolerance for comparing fractions. Default value [[Geometry.smallFraction]].
+     * @param pointTol tolerance for comparing points, used if fractions are distinct. Default value [[Geometry.smallMetricDistance]].
+     * @param xyOnly whether to perform point comparisons in xy only. Default is false (compare 3D points).
+     * @param equateClosedCurveFractions whether to equate fractions 0 and 1 for physically closed curves. Default is false.
+     */
+    static comparePairsByFractions(fractionTol = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallFraction, pointTol = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallMetricDistance, xyOnly = false, equateClosedCurveFractions = false) {
+        return (p0, p1) => {
+            (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(() => p0.detailA.curve === p1.detailA.curve && p0.detailB.curve === p1.detailB.curve, "pairs are compatible");
+            const curveA = p0.detailA.curve;
+            const curveB = p0.detailB.curve;
+            let fraction0A = p0.detailA.fraction;
+            let fraction0B = p0.detailB.fraction;
+            let fraction1A = p1.detailA.fraction;
+            let fraction1B = p1.detailB.fraction;
+            if (equateClosedCurveFractions) {
+                if (curveA?.isPhysicallyClosedCurve(pointTol, xyOnly)) {
+                    if (_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualEitherNumber(p0.detailA.fraction, 0, 1, fractionTol))
+                        fraction0A = 0;
+                    if (_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualEitherNumber(p1.detailA.fraction, 0, 1, fractionTol))
+                        fraction1A = 0;
+                }
+                if (curveB?.isPhysicallyClosedCurve(pointTol, xyOnly)) {
+                    if (_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualEitherNumber(p0.detailB.fraction, 0, 1, fractionTol))
+                        fraction0B = 0;
+                    if (_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualEitherNumber(p1.detailB.fraction, 0, 1, fractionTol))
+                        fraction1B = 0;
+                }
+            }
+            const sameFractionsA = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualNumber(fraction0A, fraction1A, fractionTol);
+            if (sameFractionsA && _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isAlmostEqualNumber(fraction0B, fraction1B, fractionTol))
+                return 0;
+            const samePointsA = xyOnly ? p0.detailA.point.isAlmostEqualXY(p1.detailA.point, pointTol) : p0.detailA.point.isAlmostEqual(p1.detailA.point, pointTol);
+            if (samePointsA && (xyOnly ? p0.detailB.point.isAlmostEqualXY(p1.detailB.point, pointTol) : p0.detailB.point.isAlmostEqual(p1.detailB.point, pointTol)))
+                return 0;
+            return sameFractionsA ? fraction0B - fraction1B : fraction0A - fraction1A;
+        };
+    }
+    /**
+     * Return a pair comparator useful for sorting an array of detail pairs by their points.
+     * * Comparison sorts the points lexicographically, `detailA.point` first, then `detailB.point`.
+     * @param pointTol tolerance for comparing points. Default value [[Geometry.smallMetricDistance]].
+     * @param xyOnly whether to perform point comparisons in xy only. Default is false (compare 3D points).
+     */
+    static comparePairsByPoints(pointTol = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallMetricDistance, xyOnly = false) {
+        return (p0, p1) => {
+            const comparePoints = xyOnly ? _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.compareXY(pointTol) : _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.compareXYZ(pointTol);
+            const compareA = comparePoints(p0.detailA.point, p1.detailA.point);
+            const compareB = comparePoints(p0.detailB.point, p1.detailB.point);
+            const samePointsA = compareA === 0;
+            if (samePointsA && compareB === 0)
+                return 0;
+            return samePointsA ? compareB : compareA;
+        };
+    }
 }
 /**
  * Data bundle for a pair of arrays of CurveLocationDetail structures.
@@ -208410,11 +208589,11 @@ class CurvePrimitive extends _GeometryQuery__WEBPACK_IMPORTED_MODULE_1__.Geometr
     }
     /**
      * Attach StrokeCountMap structure to this primitive (and recursively to any children)
-     * * Base class implementation (here) gets the simple count from computeStrokeCountForOptions and attaches it.
-     * * LineString3d, arc3d, BezierCurve3d, BezierCurve3dH accept that default.
-     * * Subdivided primitives (linestring, bspline curve) implement themselves and attach a StrokeCountMap containing the
+     * * Base class implementation (here) gets the simple count from [[computeStrokeCountForOptions]] and attaches it.
+     * * [[LineString3d]], [[Arc3d]], [[BezierCurve3d]], [[BezierCurve3dH]] accept that default.
+     * * Subdivided primitives ([[LineString3d]], [[BSplineCurve3d]]) implement themselves and attach a StrokeCountMap containing the
      *       total count, and also containing an array of StrokeCountMap per component.
-     * * For CurvePrimitiveWithDistanceIndex, the top level gets (only) a total count, and each child gets
+     * * For [[CurveChainWithDistanceIndex]], the top level gets (only) a total count, and each child gets
      *       its own StrokeCountMap with appropriate structure.
      * @param options StrokeOptions that determine count
      * @param parentStrokeMap optional map from parent.  Its count, curveLength, and a1 values are increased with count
@@ -208428,11 +208607,11 @@ class CurvePrimitive extends _GeometryQuery__WEBPACK_IMPORTED_MODULE_1__.Geometr
     }
     /**
      * Evaluate strokes at fractions indicated in a StrokeCountMap.
-     *   * Base class implementation (here) gets the simple count from computeStrokeCountForOptions and strokes at
+     *   * Base class implementation (here) gets the simple count from [[computeStrokeCountForOptions]] and strokes at
      * uniform fractions.
-     *   * LineString3d, arc3d, BezierCurve3d, BezierCurve3dH accept that default.
-     *   * Subdivided primitives (linestring, bspline curve) implement themselves and evaluate within components.
-     *   * CurvePrimitiveWithDistanceIndex recurses to its children.
+     *   * [[LineString3d]], [[Arc3d]], [[BezierCurve3d]], [[BezierCurve3dH]] accept that default.
+     *   * Subdivided primitives ([[LineString3d]], [[BSplineCurve3d]]) implement themselves and evaluate within components.
+     *   * [[CurveChainWithDistanceIndex]] recurses to its children.
      * * if packedFraction and packedDerivative arrays are present in the LineString3d, fill them.
      * @param map = stroke count data.
      * @param linestring = receiver linestring.
@@ -208463,7 +208642,7 @@ class CurvePrimitive extends _GeometryQuery__WEBPACK_IMPORTED_MODULE_1__.Geometr
      * Return an array containing only the curve primitives.
      * * This DEFAULT implementation simply pushes `this` to the collectorArray.
      * @param collectorArray array to receive primitives (pushed -- the array is not cleared)
-     * @param smallestPossiblePrimitives if true, a [[CurvePrimitiveWithDistanceIndex]] recurses on its (otherwise hidden)
+     * @param smallestPossiblePrimitives if true, a [[CurveChainWithDistanceIndex]] recurses on its (otherwise hidden)
      * children. If false, it returns only itself.
      * @param explodeLinestrings if true, push a [[LineSegment3d]] for each segment of a [[LineString3d]]. If false,
      * push only the [[LineString3d]].
@@ -208476,8 +208655,9 @@ class CurvePrimitive extends _GeometryQuery__WEBPACK_IMPORTED_MODULE_1__.Geometr
      * * This DEFAULT implementation captures the optional collector and calls [[collectCurvePrimitivesGo]].
      * @param collectorArray optional array to receive primitives.   If present, new primitives are ADDED (without
      * clearing the array.)
-     * @param smallestPossiblePrimitives if false, CurvePrimitiveWithDistanceIndex returns only itself.  If true,
-     * it recurses to its (otherwise hidden) children.
+     * @param smallestPossiblePrimitives if false (default), a [[CurveChainWithDistanceIndex]] returns only itself;
+     * otherwise, it recurses to its (otherwise hidden) children.
+     * @param explodeLinestrings whether to return [[LineSegment3d]]s for a [[LineString3d]] (default false).
      */
     collectCurvePrimitives(collectorArray, smallestPossiblePrimitives = false, explodeLinestrings = false) {
         const results = collectorArray === undefined ? [] : collectorArray;
@@ -213612,9 +213792,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../geometry3d/IndexedXYZCollection */ "../../core/geometry/lib/esm/geometry3d/IndexedXYZCollection.js");
 /* harmony import */ var _geometry3d_Point3dArrayCarrier__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ../geometry3d/Point3dArrayCarrier */ "../../core/geometry/lib/esm/geometry3d/Point3dArrayCarrier.js");
 /* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
-/* harmony import */ var _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ../geometry3d/PolygonOps */ "../../core/geometry/lib/esm/geometry3d/PolygonOps.js");
+/* harmony import */ var _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(/*! ../geometry3d/PolygonOps */ "../../core/geometry/lib/esm/geometry3d/PolygonOps.js");
 /* harmony import */ var _geometry3d_PolylineCompressionByEdgeOffset__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ../geometry3d/PolylineCompressionByEdgeOffset */ "../../core/geometry/lib/esm/geometry3d/PolylineCompressionByEdgeOffset.js");
-/* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
+/* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(/*! ../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
 /* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
 /* harmony import */ var _geometry3d_SortablePolygon__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(/*! ../geometry3d/SortablePolygon */ "../../core/geometry/lib/esm/geometry3d/SortablePolygon.js");
 /* harmony import */ var _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ../geometry3d/Transform */ "../../core/geometry/lib/esm/geometry3d/Transform.js");
@@ -213622,18 +213802,19 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _polyface_PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../polyface/PolyfaceBuilder */ "../../core/geometry/lib/esm/polyface/PolyfaceBuilder.js");
 /* harmony import */ var _topology_Graph__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../topology/Graph */ "../../core/geometry/lib/esm/topology/Graph.js");
 /* harmony import */ var _topology_HalfEdgeGraphSearch__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ../topology/HalfEdgeGraphSearch */ "../../core/geometry/lib/esm/topology/HalfEdgeGraphSearch.js");
-/* harmony import */ var _topology_Merging__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(/*! ../topology/Merging */ "../../core/geometry/lib/esm/topology/Merging.js");
+/* harmony import */ var _topology_Merging__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(/*! ../topology/Merging */ "../../core/geometry/lib/esm/topology/Merging.js");
 /* harmony import */ var _topology_Triangulation__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../topology/Triangulation */ "../../core/geometry/lib/esm/topology/Triangulation.js");
 /* harmony import */ var _CurveCollection__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
-/* harmony import */ var _CurveCurve__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./CurveCurve */ "../../core/geometry/lib/esm/curve/CurveCurve.js");
+/* harmony import */ var _CurveCurve__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ./CurveCurve */ "../../core/geometry/lib/esm/curve/CurveCurve.js");
+/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(/*! ./CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
 /* harmony import */ var _CurveOps__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./CurveOps */ "../../core/geometry/lib/esm/curve/CurveOps.js");
 /* harmony import */ var _CurvePrimitive__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./CurvePrimitive */ "../../core/geometry/lib/esm/curve/CurvePrimitive.js");
 /* harmony import */ var _CurveWireMomentsXYZ__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./CurveWireMomentsXYZ */ "../../core/geometry/lib/esm/curve/CurveWireMomentsXYZ.js");
-/* harmony import */ var _GeometryQuery__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(/*! ./GeometryQuery */ "../../core/geometry/lib/esm/curve/GeometryQuery.js");
+/* harmony import */ var _GeometryQuery__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./GeometryQuery */ "../../core/geometry/lib/esm/curve/GeometryQuery.js");
 /* harmony import */ var _internalContexts_ChainCollectorContext__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./internalContexts/ChainCollectorContext */ "../../core/geometry/lib/esm/curve/internalContexts/ChainCollectorContext.js");
 /* harmony import */ var _internalContexts_PolygonOffsetContext__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./internalContexts/PolygonOffsetContext */ "../../core/geometry/lib/esm/curve/internalContexts/PolygonOffsetContext.js");
-/* harmony import */ var _internalContexts_TransferWithSplitArcs__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(/*! ./internalContexts/TransferWithSplitArcs */ "../../core/geometry/lib/esm/curve/internalContexts/TransferWithSplitArcs.js");
-/* harmony import */ var _LineSegment3d__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(/*! ./LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
+/* harmony import */ var _internalContexts_TransferWithSplitArcs__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(/*! ./internalContexts/TransferWithSplitArcs */ "../../core/geometry/lib/esm/curve/internalContexts/TransferWithSplitArcs.js");
+/* harmony import */ var _LineSegment3d__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
 /* harmony import */ var _LineString3d__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
 /* harmony import */ var _Loop__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./Loop */ "../../core/geometry/lib/esm/curve/Loop.js");
 /* harmony import */ var _OffsetOptions__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./OffsetOptions */ "../../core/geometry/lib/esm/curve/OffsetOptions.js");
@@ -213692,6 +213873,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 
 
 /**
@@ -214391,27 +214573,113 @@ class RegionOps {
         }
         return _geometry3d_SortablePolygon__WEBPACK_IMPORTED_MODULE_33__.SortablePolygon.sortAsAnyRegion(loopAndArea);
     }
+    /**
+     * Simplify the graph by removing bridge edges that do not serve to connect inner and outer loops.
+     * * If edgeTags are `CurveLocationDetail`s, e.g., as set by `PlanarSubdivision.assembleHalfEdgeGraph`, attempt to heal edges split by removed bridge edges.
+     * @param graph half edges to process.
+     * @param isBridgeEdge optional function to identify a bridge edge. Default looks for `HalfEdgeMask.BRIDGE_EDGE`.
+     * @param faceToArea optional function to compute face area. Default is `HalfEdgeGraphSearch.signedFaceArea`.
+     * @returns the number of extraneous bridge edges removed from the graph.
+     * @internal
+     */
+    static removeExtraneousBridgeEdges(graph, isBridgeEdge, faceToArea) {
+        const toHeal = [];
+        const interiorBridges = [];
+        if (!faceToArea)
+            faceToArea = (node) => _topology_HalfEdgeGraphSearch__WEBPACK_IMPORTED_MODULE_17__.HalfEdgeGraphSearch.signedFaceArea(node);
+        if (!isBridgeEdge)
+            isBridgeEdge = (node) => node.isMaskSet(_topology_Graph__WEBPACK_IMPORTED_MODULE_15__.HalfEdgeMask.BRIDGE_EDGE);
+        // isolate dangling bridges, bridges separating different faces, and "exterior" bridges in the negative area face
+        graph.announceEdges((_g, node) => {
+            if (isBridgeEdge(node)) {
+                if (node.isDangling || node.edgeMate.isDangling || !node.findAroundFace(node.edgeMate) || faceToArea(node) < 0.0) {
+                    toHeal.push(node.vertexSuccessor);
+                    toHeal.push(node.edgeMate.vertexSuccessor);
+                    node.isolateEdge();
+                }
+                else {
+                    interiorBridges.push(node);
+                }
+            }
+            return true;
+        });
+        // Relies only on face loop orientation. Doesn't use static HalfEdgeMasks!
+        const isBoundaryEdge = (node) => {
+            if (faceToArea(node) < 0.0)
+                return true; // exterior face
+            if (node.findAroundFace(node.edgeMate))
+                return false; // interior washer face
+            return faceToArea(node.edgeMate) < 0.0; // adjacent to exterior face
+        };
+        // All bridges in the negative area face were isolated, but this may have promoted other bridges to the
+        // negative area face. Keep isolating these bridge edges until none remain.
+        let numIsolatedThisPass;
+        do {
+            numIsolatedThisPass = 0;
+            for (const node of interiorBridges) {
+                if (!node.isIsolatedEdge && isBoundaryEdge(node)) {
+                    toHeal.push(node.vertexSuccessor);
+                    toHeal.push(node.edgeMate.vertexSuccessor);
+                    node.isolateEdge();
+                    numIsolatedThisPass++;
+                }
+            }
+        } while (numIsolatedThisPass > 0);
+        // lambda to extend the detail interval on a side of a healed edge
+        const mergeDetails = (he, newFraction, newPoint) => {
+            if (he && he.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_34__.CurveLocationDetail && he.sortData !== undefined && newFraction !== undefined && newPoint) {
+                if (he.sortData > 0)
+                    he.edgeTag.captureFraction1Point1(newFraction, newPoint);
+                else
+                    he.edgeTag.captureFractionPoint(newFraction, newPoint);
+            }
+        };
+        // At this point all removable bridges are isolated. Clean up their original vertex loops, if possible.
+        for (const doomedA of toHeal) {
+            const doomedB = doomedA.vertexSuccessor;
+            if ( // are the geometries mergeable?
+            doomedA !== doomedB &&
+                doomedA.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_34__.CurveLocationDetail && doomedA.sortData !== undefined &&
+                doomedB.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_34__.CurveLocationDetail && doomedB.sortData !== undefined &&
+                doomedA.edgeTag.curve === doomedB.edgeTag.curve &&
+                doomedA.edgeTag.isInterval() && doomedB.edgeTag.isInterval() &&
+                doomedA.sortData * doomedB.sortData < 0 &&
+                ((doomedA.sortData > 0 && _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.isSmallRelative(doomedA.edgeTag.fraction - doomedB.edgeTag.fraction1)) ||
+                    (doomedA.sortData < 0 && _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.isSmallRelative(doomedA.edgeTag.fraction1 - doomedB.edgeTag.fraction)))) {
+                const survivorA = _topology_Graph__WEBPACK_IMPORTED_MODULE_15__.HalfEdge.healEdge(doomedA, false);
+                if (survivorA) {
+                    const endFractionA = (doomedA.sortData > 0) ? doomedA.edgeTag.fraction1 : doomedA.edgeTag.fraction;
+                    const endPointA = (doomedA.sortData > 0) ? doomedA.edgeTag.point1 : doomedA.edgeTag.point;
+                    mergeDetails(survivorA, endFractionA, endPointA);
+                    const endFractionB = (doomedB.sortData > 0) ? doomedB.edgeTag.fraction1 : doomedB.edgeTag.fraction;
+                    const endPointB = (doomedB.sortData > 0) ? doomedB.edgeTag.point1 : doomedB.edgeTag.point;
+                    mergeDetails(survivorA.edgeMate, endFractionB, endPointB);
+                }
+            }
+        }
+        return graph.deleteIsolatedEdges();
+    }
     /**
      * Collect inputs that are nominally closed: regions, and physically closed curves.
      * * Physically closed input curves are each returned wrapped in a Loop to facilitate xy-algorithms,
      * but outside this limited context, these Loops only makes sense if they are planar.
+     * @param curves inputs
+     * @param openCurves optional array to receive open input curves that were not returned as regions.
+     * @param tolerance optional distance tolerance for determining physical closure. Default is [[Geometry.smallMetricDistance]].
     */
-    static collectRegionsAndClosedPrimitives(curves, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.smallMetricDistance) {
+    static collectRegionsAndClosedPrimitives(curves, openCurves, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.smallMetricDistance) {
         const regions = [];
         if (!Array.isArray(curves))
             curves = [curves];
         for (const curve of curves) {
-            if (curve instanceof _Loop__WEBPACK_IMPORTED_MODULE_8__.Loop || curve instanceof _ParityRegion__WEBPACK_IMPORTED_MODULE_9__.ParityRegion || curve instanceof _UnionRegion__WEBPACK_IMPORTED_MODULE_14__.UnionRegion) {
+            if (curve instanceof _Loop__WEBPACK_IMPORTED_MODULE_8__.Loop || curve instanceof _ParityRegion__WEBPACK_IMPORTED_MODULE_9__.ParityRegion || curve instanceof _UnionRegion__WEBPACK_IMPORTED_MODULE_14__.UnionRegion)
                 regions.push(curve);
-            }
-            else if (curve instanceof _Path__WEBPACK_IMPORTED_MODULE_24__.Path) {
-                if (curve.isPhysicallyClosedCurve(tolerance))
-                    regions.push(_Loop__WEBPACK_IMPORTED_MODULE_8__.Loop.create(...curve.children));
-            }
-            else if (curve instanceof _CurvePrimitive__WEBPACK_IMPORTED_MODULE_27__.CurvePrimitive) {
-                if (curve.isPhysicallyClosedCurve(tolerance))
-                    regions.push(_Loop__WEBPACK_IMPORTED_MODULE_8__.Loop.create(curve));
-            }
+            else if (curve instanceof _Path__WEBPACK_IMPORTED_MODULE_24__.Path && curve.isPhysicallyClosedCurve(tolerance))
+                regions.push(_Loop__WEBPACK_IMPORTED_MODULE_8__.Loop.create(...curve.children));
+            else if (curve instanceof _CurvePrimitive__WEBPACK_IMPORTED_MODULE_27__.CurvePrimitive && curve.isPhysicallyClosedCurve(tolerance))
+                regions.push(_Loop__WEBPACK_IMPORTED_MODULE_8__.Loop.create(curve));
+            else if (openCurves)
+                openCurves.push(curve);
         }
         return regions;
     }
@@ -214421,9 +214689,9 @@ class RegionOps {
      * * "Holes" implied/bounded by inputs are _not_ preserved/discovered in output; in particular [[ParityRegion]]
      * hole loops are treated like any other positive area loops.
      * * A common use case of this method is to assemble the bounding negative-area "exterior" loop for each connected
-     * component of input curves. Passing `addBridges = true` decreases the number of connected components for nested
-     * input [[Loop]]s, and thus increases the likelihood of returning exactly one exterior loop. (This is why the
-     * default value for `addBridges` is `true`.)
+     * component of input curves. Passing addBridges = true adds "bridge" segments to connect unconnected input [[Loops]]s
+     * and thereby increases the likelihood that a single connected component is returned. (This is why the default value
+     * for addBridges is true.)
      * @param curvesAndRegions Any collection of curves. Each [[AnyRegion]] contributes its children _stripped of
      * parity context_.
      * @param tolerance optional distance tolerance for coincidence. Default is [[Geometry.smallMetricDistance]].
@@ -214439,24 +214707,33 @@ class RegionOps {
      */
     static constructAllXYRegionLoops(curvesAndRegions, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.smallMetricDistance, addBridges = true) {
         let primitives = RegionOps.collectCurvePrimitives(curvesAndRegions, undefined, true, true);
-        primitives = _internalContexts_TransferWithSplitArcs__WEBPACK_IMPORTED_MODULE_34__.TransferWithSplitArcs.clone(_CurveCollection__WEBPACK_IMPORTED_MODULE_25__.BagOfCurves.create(...primitives)).children;
+        primitives = _internalContexts_TransferWithSplitArcs__WEBPACK_IMPORTED_MODULE_35__.TransferWithSplitArcs.clone(_CurveCollection__WEBPACK_IMPORTED_MODULE_25__.BagOfCurves.create(...primitives)).children;
         const range = this.curveArrayRange(primitives);
         const areaTol = this.computeXYAreaTolerance(range, tolerance);
-        if (addBridges) { // generate a temp graph to extract its bridge edges
+        let hasOpenCurve = false;
+        if (addBridges) { // generate a temp graph from ONLY the closed inputs to extract its bridge edges
             const context = _RegionOpsClassificationSweeps__WEBPACK_IMPORTED_MODULE_13__.RegionBooleanContext.create(_RegionOpsClassificationSweeps__WEBPACK_IMPORTED_MODULE_13__.RegionGroupOpType.Union, _RegionOpsClassificationSweeps__WEBPACK_IMPORTED_MODULE_13__.RegionGroupOpType.Union);
-            const regions = this.collectRegionsAndClosedPrimitives(curvesAndRegions, tolerance);
+            const openCurves = [];
+            const regions = this.collectRegionsAndClosedPrimitives(curvesAndRegions, openCurves, tolerance);
+            hasOpenCurve = openCurves.length > 0;
             if (regions.length > 0) {
                 context.addMembers(regions, undefined);
                 context.annotateAndMergeCurvesInGraph(tolerance);
                 context.graph.announceEdges((_graph, edge) => {
-                    if (edge.isMaskSet(_topology_Graph__WEBPACK_IMPORTED_MODULE_15__.HalfEdgeMask.BRIDGE_EDGE))
-                        primitives.push(_LineSegment3d__WEBPACK_IMPORTED_MODULE_35__.LineSegment3d.create(edge.getPoint3d(), edge.faceSuccessor.getPoint3d()));
+                    if (edge.isMaskSet(_topology_Graph__WEBPACK_IMPORTED_MODULE_15__.HalfEdgeMask.BRIDGE_EDGE)) {
+                        // ensure the bridge edge roundtrips thru assembleHalfEdgeGraph so that we can filter it later if necessary
+                        const bridgeSegment = _LineSegment3d__WEBPACK_IMPORTED_MODULE_36__.LineSegment3d.create(edge.getPoint3d(), edge.faceSuccessor.getPoint3d());
+                        bridgeSegment.parent = new _RegionOpsClassificationSweeps__WEBPACK_IMPORTED_MODULE_13__.RegionGroupMember(bridgeSegment, context.extraGeometry);
+                        primitives.push(bridgeSegment);
+                    }
                     return true;
                 });
             }
         }
-        const intersections = _CurveCurve__WEBPACK_IMPORTED_MODULE_36__.CurveCurve.allIntersectionsAmongPrimitivesXY(primitives, tolerance);
+        const intersections = _CurveCurve__WEBPACK_IMPORTED_MODULE_37__.CurveCurve.allIntersectionsAmongPrimitivesXY(primitives, tolerance);
         const graph = _Query_PlanarSubdivision__WEBPACK_IMPORTED_MODULE_16__.PlanarSubdivision.assembleHalfEdgeGraph(primitives, intersections, tolerance);
+        if (addBridges && hasOpenCurve)
+            RegionOps.removeExtraneousBridgeEdges(graph);
         return _Query_PlanarSubdivision__WEBPACK_IMPORTED_MODULE_16__.PlanarSubdivision.collectSignedLoopSetsInHalfEdgeGraph(graph, areaTol);
     }
     /**
@@ -214513,12 +214790,12 @@ class RegionOps {
      * @param worldToLocal transform to apply to data before computing its range
      */
     static curveArrayRange(data, worldToLocal) {
-        const range = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_37__.Range3d.create();
-        if (data instanceof _GeometryQuery__WEBPACK_IMPORTED_MODULE_38__.GeometryQuery)
+        const range = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_38__.Range3d.create();
+        if (data instanceof _GeometryQuery__WEBPACK_IMPORTED_MODULE_39__.GeometryQuery)
             data.extendRange(range, worldToLocal);
         else if (Array.isArray(data)) {
             for (const c of data) {
-                if (c instanceof _GeometryQuery__WEBPACK_IMPORTED_MODULE_38__.GeometryQuery)
+                if (c instanceof _GeometryQuery__WEBPACK_IMPORTED_MODULE_39__.GeometryQuery)
                     c.extendRange(range, worldToLocal);
                 else if (c instanceof _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d)
                     range.extendPoint(c, worldToLocal);
@@ -214554,7 +214831,7 @@ class RegionOps {
                     for (const polygon of polygons)
                         writablePolygons.push(_geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_18__.GrowableXYZArray.create(polygon));
                 }
-                const sortedPolygons = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_39__.PolygonOps.sortOuterAndHoleLoopsXY(writablePolygons);
+                const sortedPolygons = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_40__.PolygonOps.sortOuterAndHoleLoopsXY(writablePolygons);
                 if (sortedPolygons.length === 1) { // below requires exactly one outer loop!
                     if (graph = _topology_Triangulation__WEBPACK_IMPORTED_MODULE_11__.Triangulator.createTriangulatedGraphFromLoops(sortedPolygons[0]))
                         _topology_Triangulation__WEBPACK_IMPORTED_MODULE_11__.Triangulator.flipTriangles(graph);
@@ -214637,7 +214914,7 @@ class RegionOps {
         if (!graph)
             return undefined;
         if (options?.maximizeConvexFacets)
-            _topology_Merging__WEBPACK_IMPORTED_MODULE_40__.HalfEdgeGraphOps.expandConvexFaces(graph);
+            _topology_Merging__WEBPACK_IMPORTED_MODULE_41__.HalfEdgeGraphOps.expandConvexFaces(graph);
         return _polyface_PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_12__.PolyfaceBuilder.graphToPolyface(graph, options);
     }
     /**
@@ -214651,7 +214928,7 @@ class RegionOps {
         if (!graph)
             return undefined;
         if (maximize)
-            _topology_Merging__WEBPACK_IMPORTED_MODULE_40__.HalfEdgeGraphOps.expandConvexFaces(graph);
+            _topology_Merging__WEBPACK_IMPORTED_MODULE_41__.HalfEdgeGraphOps.expandConvexFaces(graph);
         const convexPolygons = [];
         graph.announceFaceLoops((_graph, seed) => {
             if (!seed.isMaskSet(_topology_Graph__WEBPACK_IMPORTED_MODULE_15__.HalfEdgeMask.EXTERIOR))
@@ -214700,15 +214977,15 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _topology_Merging__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../topology/Merging */ "../../core/geometry/lib/esm/topology/Merging.js");
 /* harmony import */ var _topology_RegularizeFace__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../topology/RegularizeFace */ "../../core/geometry/lib/esm/topology/RegularizeFace.js");
 /* harmony import */ var _Arc3d__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./Arc3d */ "../../core/geometry/lib/esm/curve/Arc3d.js");
-/* harmony import */ var _CurveCurve__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./CurveCurve */ "../../core/geometry/lib/esm/curve/CurveCurve.js");
-/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
+/* harmony import */ var _CurveCurve__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./CurveCurve */ "../../core/geometry/lib/esm/curve/CurveCurve.js");
+/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
 /* harmony import */ var _GeometryQuery__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./GeometryQuery */ "../../core/geometry/lib/esm/curve/GeometryQuery.js");
 /* harmony import */ var _internalContexts_PlaneAltitudeRangeContext__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./internalContexts/PlaneAltitudeRangeContext */ "../../core/geometry/lib/esm/curve/internalContexts/PlaneAltitudeRangeContext.js");
 /* harmony import */ var _internalContexts_TransferWithSplitArcs__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./internalContexts/TransferWithSplitArcs */ "../../core/geometry/lib/esm/curve/internalContexts/TransferWithSplitArcs.js");
 /* harmony import */ var _LineSegment3d__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
 /* harmony import */ var _Loop__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./Loop */ "../../core/geometry/lib/esm/curve/Loop.js");
 /* harmony import */ var _ParityRegion__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./ParityRegion */ "../../core/geometry/lib/esm/curve/ParityRegion.js");
-/* harmony import */ var _Query_PlanarSubdivision__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./Query/PlanarSubdivision */ "../../core/geometry/lib/esm/curve/Query/PlanarSubdivision.js");
+/* harmony import */ var _Query_PlanarSubdivision__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./Query/PlanarSubdivision */ "../../core/geometry/lib/esm/curve/Query/PlanarSubdivision.js");
 /* harmony import */ var _RegionOps__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./RegionOps */ "../../core/geometry/lib/esm/curve/RegionOps.js");
 /* harmony import */ var _UnionRegion__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./UnionRegion */ "../../core/geometry/lib/esm/curve/UnionRegion.js");
 /*---------------------------------------------------------------------------------------------
@@ -215213,94 +215490,6 @@ class RegionBooleanContext {
             this.extraGeometry.addMember(bridgeLine, true);
         }
     }
-    /**
-     * Simplify the graph by removing bridge edges that do not serve to connect inner and outer loops, i.e.:
-     * * the bridge edge is dangling
-     * * the bridge edge is adjacent to multiple faces
-     * * the bridge edge is adjacent to a negative area face
-     * @returns the number of extraneous bridge edges removed from the graph.
-     */
-    removeExtraneousBridgeEdges() {
-        const toHeal = [];
-        const interiorBridges = [];
-        // lambda test for boundary edge. Relies only on face loop orientation. Doesn't use HalfEdgeMasks!
-        const isExteriorEdge = (node) => {
-            if (this.faceAreaFunction(node) < 0.0)
-                return true;
-            if (!node.findAroundFace(node.edgeMate))
-                return this.faceAreaFunction(node.edgeMate) < 0.0;
-            return false;
-        };
-        // isolate dangling bridges, bridges separating different faces, and "exterior" bridges in the negative area face
-        this.graph.announceEdges((_graph, node) => {
-            if (node.edgeTag !== undefined) {
-                if (node.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__.CurveLocationDetail) {
-                    if (node.edgeTag.curve) {
-                        if (node.edgeTag.curve.parent instanceof RegionGroupMember) {
-                            if (node.edgeTag.curve.parent.parentGroup === this.extraGeometry) {
-                                if (node.isDangling || node.edgeMate.isDangling || !node.findAroundFace(node.edgeMate) || this.faceAreaFunction(node) < 0.0) {
-                                    toHeal.push(node.vertexSuccessor);
-                                    toHeal.push(node.edgeMate.vertexSuccessor);
-                                    node.isolateEdge();
-                                }
-                                else {
-                                    interiorBridges.push(node);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return true;
-        });
-        // At this point, all bridges that were exterior are isolated, but this may have caused formerly
-        // interior bridges to become exterior. Now we successively isolate exterior bridges until none remain.
-        let numIsolatedThisPass;
-        do {
-            numIsolatedThisPass = 0;
-            for (const node of interiorBridges) {
-                if (!node.isIsolatedEdge && isExteriorEdge(node)) {
-                    toHeal.push(node.vertexSuccessor);
-                    toHeal.push(node.edgeMate.vertexSuccessor);
-                    node.isolateEdge();
-                    numIsolatedThisPass++;
-                }
-            }
-        } while (numIsolatedThisPass > 0);
-        // lambda to extend the detail interval on a side of a healed edge
-        const mergeDetails = (he, newFraction, newPoint) => {
-            if (he && he.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__.CurveLocationDetail && he.sortData !== undefined && newFraction !== undefined && newPoint) {
-                if (he.sortData > 0)
-                    he.edgeTag.captureFraction1Point1(newFraction, newPoint);
-                else
-                    he.edgeTag.captureFractionPoint(newFraction, newPoint);
-            }
-        };
-        // At this point all removable bridges are isolated. Clean up their original vertex loops, if possible.
-        for (const doomedA of toHeal) {
-            const doomedB = doomedA.vertexSuccessor;
-            if ( // are the geometries mergeable?
-            doomedA !== doomedB &&
-                doomedA.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__.CurveLocationDetail && doomedA.sortData !== undefined &&
-                doomedB.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__.CurveLocationDetail && doomedB.sortData !== undefined &&
-                doomedA.edgeTag.curve === doomedB.edgeTag.curve &&
-                doomedA.edgeTag.isInterval() && doomedB.edgeTag.isInterval() &&
-                doomedA.sortData * doomedB.sortData < 0 &&
-                ((doomedA.sortData > 0 && _Geometry__WEBPACK_IMPORTED_MODULE_7__.Geometry.isSmallRelative(doomedA.edgeTag.fraction - doomedB.edgeTag.fraction1)) ||
-                    (doomedA.sortData < 0 && _Geometry__WEBPACK_IMPORTED_MODULE_7__.Geometry.isSmallRelative(doomedA.edgeTag.fraction1 - doomedB.edgeTag.fraction)))) {
-                const survivorA = _topology_Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdge.healEdge(doomedA, false);
-                if (survivorA) {
-                    const endFractionA = (doomedA.sortData > 0) ? doomedA.edgeTag.fraction1 : doomedA.edgeTag.fraction;
-                    const endPointA = (doomedA.sortData > 0) ? doomedA.edgeTag.point1 : doomedA.edgeTag.point;
-                    mergeDetails(survivorA, endFractionA, endPointA);
-                    const endFractionB = (doomedB.sortData > 0) ? doomedB.edgeTag.fraction1 : doomedB.edgeTag.fraction;
-                    const endPointB = (doomedB.sortData > 0) ? doomedB.edgeTag.point1 : doomedB.edgeTag.point;
-                    mergeDetails(survivorA.edgeMate, endFractionB, endPointB);
-                }
-            }
-        }
-        return this.graph.deleteIsolatedEdges();
-    }
     /**
      * Markup and assembly steps for geometry in the RegionGroups.
      * * Annotate connection from group to curves.
@@ -215322,11 +215511,9 @@ class RegionBooleanContext {
                 }
             }
         }
-        const intersections = _CurveCurve__WEBPACK_IMPORTED_MODULE_17__.CurveCurve.allIntersectionsAmongPrimitivesXY(allPrimitives, mergeTolerance);
-        const graph = _Query_PlanarSubdivision__WEBPACK_IMPORTED_MODULE_18__.PlanarSubdivision.assembleHalfEdgeGraph(allPrimitives, intersections, mergeTolerance);
-        this.graph = graph;
-        this.faceAreaFunction = faceAreaFromCurvedEdgeData;
-        this.removeExtraneousBridgeEdges();
+        const intersections = _CurveCurve__WEBPACK_IMPORTED_MODULE_16__.CurveCurve.allIntersectionsAmongPrimitivesXY(allPrimitives, mergeTolerance);
+        const graph = _Query_PlanarSubdivision__WEBPACK_IMPORTED_MODULE_17__.PlanarSubdivision.assembleHalfEdgeGraph(allPrimitives, intersections, mergeTolerance);
+        _RegionOps__WEBPACK_IMPORTED_MODULE_1__.RegionOps.removeExtraneousBridgeEdges(this.graph = graph, undefined, this.faceAreaFunction = faceAreaFromCurvedEdgeData);
     }
     _announceFaceFunction;
     /**
@@ -215412,7 +215599,7 @@ class RegionBooleanContext {
         const data = node.edgeTag;
         if (data instanceof RegionGroupMember)
             return updateRegionGroupMemberState(data);
-        if (data instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__.CurveLocationDetail && data.curve) {
+        if (data instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_18__.CurveLocationDetail && data.curve) {
             // We trust that the caller has linked from the graph node to a curve which has a RegionGroupMember as its parent.
             const member = data.curve.parent;
             if (member instanceof RegionGroupMember)
@@ -215523,7 +215710,7 @@ class GraphComponent {
             f.sumAroundFace(vertexFunction);
         }
         this.faceAreas.length = 0;
-        if (faceAreaFunction === faceAreaFromCurvedEdgeData && !this.faces.every((he) => he.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_16__.CurveLocationDetail))
+        if (faceAreaFunction === faceAreaFromCurvedEdgeData && !this.faces.every((he) => he.edgeTag instanceof _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_18__.CurveLocationDetail))
             faceAreaFunction = undefined; // prerequisite CurveLocationDetails are absent, fall through to default
         if (!faceAreaFunction)
             faceAreaFunction = (node) => _topology_HalfEdgeGraphSearch__WEBPACK_IMPORTED_MODULE_4__.HalfEdgeGraphSearch.signedFaceArea(node); // polygon area
@@ -215591,14 +215778,21 @@ __webpack_require__.r(__webpack_exports__);
  * * Nearly all stroke and facet use cases will apply an angle tolerance.
  *   * For curves, 15 degrees is typical
  *   * For facets, 22.5 degrees is typical.
- *   * Halving the angle tolerance will (roughly) make curves get twice as many strokes, and surfaces get 4 times as many facets.
- *   * The angle tolerance has the useful property that its effect is independent of scale of that data.  If data is suddenly scaled into millimeters rather than meters, the facet counts remain the same.
+ *   * Halving the angle tolerance will (roughly) make curves get twice as many strokes, and surfaces get 4 times as
+ * many facets.
+ *   * The angle tolerance has the useful property that its effect is independent of scale of that data.  If data is
+ * suddenly scaled into millimeters rather than meters, the facet counts remain the same.
  * * When creating output for devices such as 3D printing will want a chord tolerance.
- * * For graphics display, use an angle tolerance of around 15 degrees and an chord tolerance which is the size of several pixels.
+ * * For graphics display, use an angle tolerance of around 15 degrees and an chord tolerance which is the size of
+ * several pixels.
  * * Analysis meshes (e.g. Finite Elements) commonly need to apply maxEdgeLength.
- *   * Using maxEdgeLength for graphics probably produces too many facets.   For example, it causes long cylinders to get many nearly-square facets instead of the small number of long quads usually used for graphics.
- * * Facet tolerances are, as the Pirates' Code, guidelines, not absolute rules.   Facet and stroke code may ignore tolerances in awkward situations.
- * * If multiple tolerances are in effect, the actual count will usually be based on the one that demands the most strokes or facets, unless it is so high that it violates some upper limit on the number of facets on an arc or a section of a curve.
+ *   * Using maxEdgeLength for graphics probably produces too many facets. For example, it causes long cylinders to
+ * get many nearly-square facets instead of the small number of long quads usually used for graphics.
+ * * Facet tolerances are, as the Pirates' Code, guidelines, not absolute rules. Facet and stroke code may ignore
+ * tolerances in awkward situations.
+ * * If multiple tolerances are in effect, the actual count will usually be based on the one that demands the most
+ * strokes or facets, unless it is so high that it violates some upper limit on the number of facets on an arc or a
+ * section of a curve.
  * @public
  */
 class StrokeOptions {
@@ -215919,9 +216113,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
 /* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
 /* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
-/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
-/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
-/* harmony import */ var _NewtonRtoRStrokeHandler__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./NewtonRtoRStrokeHandler */ "../../core/geometry/lib/esm/curve/internalContexts/NewtonRtoRStrokeHandler.js");
+/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
+/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -215935,12 +216128,11 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
 /**
  * Context for searching for the tangent(s) to a CurvePrimitive.
  * @internal
  */
-class AnnounceTangentStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORTED_MODULE_1__.NewtonRtoRStrokeHandler {
+class AnnounceTangentStrokeHandler extends _numerics_Newton__WEBPACK_IMPORTED_MODULE_1__.NewtonRtoRStrokeHandler {
     _curve;
     _announceTangent;
     _spacePoint;
@@ -215970,7 +216162,7 @@ class AnnounceTangentStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMP
         this._distanceTolSquared = this._distanceTol * this._distanceTol;
         this._workRay = _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_4__.Ray3d.createZero();
         this.startCurvePrimitive(undefined);
-        this._newtonSolver = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_5__.Newton1dUnboundedApproximateDerivative(this);
+        this._newtonSolver = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_1__.Newton1dUnboundedApproximateDerivative(this);
     }
     /** Specified by IStrokeHandler. */
     needPrimaryGeometryForStrokes() {
@@ -216003,7 +216195,7 @@ class AnnounceTangentStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMP
             cp = this._parentCurvePrimitive;
         if (this._curveMRU === cp && _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.isAlmostEqualOptional(this._fractionMRU, fraction, _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallFloatingPoint))
             return; // avoid announcing duplicate tangents in succession (e.g., at interior stroke point)
-        this._workDetail = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_6__.CurveLocationDetail.createCurveFractionPoint(cp, fraction, point, this._workDetail);
+        this._workDetail = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPoint(cp, fraction, point, this._workDetail);
         this._announceTangent(this._workDetail);
         this._fractionMRU = fraction;
         this._curveMRU = cp;
@@ -216116,12 +216308,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   AppendPlaneIntersectionStrokeHandler: () => (/* binding */ AppendPlaneIntersectionStrokeHandler)
 /* harmony export */ });
-/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
 /* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
-/* harmony import */ var _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../numerics/BezierPolynomials */ "../../core/geometry/lib/esm/numerics/BezierPolynomials.js");
-/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
-/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
-/* harmony import */ var _NewtonRtoRStrokeHandler__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./NewtonRtoRStrokeHandler */ "../../core/geometry/lib/esm/curve/internalContexts/NewtonRtoRStrokeHandler.js");
+/* harmony import */ var _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../numerics/BezierPolynomials */ "../../core/geometry/lib/esm/numerics/BezierPolynomials.js");
+/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
+/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -216134,12 +216325,11 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
 /**
  * Context for computing intersections of a CurvePrimitive with a plane.
  * @internal
  */
-class AppendPlaneIntersectionStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORTED_MODULE_0__.NewtonRtoRStrokeHandler {
+class AppendPlaneIntersectionStrokeHandler extends _numerics_Newton__WEBPACK_IMPORTED_MODULE_0__.NewtonRtoRStrokeHandler {
     _curve;
     _plane;
     _intersections;
@@ -216168,7 +216358,7 @@ class AppendPlaneIntersectionStrokeHandler extends _NewtonRtoRStrokeHandler__WEB
         this._intersections = intersections;
         this.startCurvePrimitive(undefined);
         this._ray = _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_1__.Ray3d.createZero();
-        this._newtonSolver = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_2__.Newton1dUnboundedApproximateDerivative(this);
+        this._newtonSolver = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_0__.Newton1dUnboundedApproximateDerivative(this);
     }
     startCurvePrimitive(curve) {
         this._curve = curve;
@@ -216185,7 +216375,7 @@ class AppendPlaneIntersectionStrokeHandler extends _NewtonRtoRStrokeHandler__WEB
             numStrokes = 1;
         const df = 1.0 / numStrokes;
         for (let i = 0; i <= numStrokes; i++) {
-            const fraction = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fraction0, i * df, fraction1);
+            const fraction = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.interpolate(fraction0, i * df, fraction1);
             cp.fractionToPointAndDerivative(fraction, this._ray);
             this.announcePointTangent(this._ray.origin, fraction, this._ray.direction);
         }
@@ -216195,11 +216385,11 @@ class AppendPlaneIntersectionStrokeHandler extends _NewtonRtoRStrokeHandler__WEB
         const h1 = this._plane.altitude(point1);
         if (h0 * h1 > 0.0)
             return;
-        const fraction01 = _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_4__.Order2Bezier.solveCoffs(h0, h1);
+        const fraction01 = _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_3__.Order2Bezier.solveCoffs(h0, h1);
         // let numIntersection = 0;
         if (fraction01 !== undefined) {
             // numIntersection++;
-            const fraction = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fraction0, fraction01, fraction1);
+            const fraction = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.interpolate(fraction0, fraction01, fraction1);
             this._newtonSolver.setX(fraction);
             if (this._newtonSolver.runIterations()) {
                 this.announceSolutionFraction(this._newtonSolver.getX());
@@ -216211,7 +216401,7 @@ class AppendPlaneIntersectionStrokeHandler extends _NewtonRtoRStrokeHandler__WEB
         const curve = this.effectiveCurve();
         if (curve) {
             this._ray = curve.fractionToPointAndDerivative(fraction, this._ray);
-            this._intersections.push(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPoint(curve, fraction, this._ray.origin));
+            this._intersections.push(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPoint(curve, fraction, this._ray.origin));
         }
     }
     evaluate(fraction) {
@@ -216234,7 +216424,7 @@ class AppendPlaneIntersectionStrokeHandler extends _NewtonRtoRStrokeHandler__WEB
         if (this._functionB === 0)
             this.announceSolutionFraction(this._fractionB);
         if (this._functionA * this._functionB < 0) {
-            const fraction = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.inverseInterpolate(this._fractionA, this._functionA, this._fractionB, this._functionB);
+            const fraction = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.inverseInterpolate(this._fractionA, this._functionA, this._fractionB, this._functionB);
             if (fraction) {
                 this._newtonSolver.setX(fraction);
                 if (this._newtonSolver.runIterations())
@@ -216617,11 +216807,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
 /* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
 /* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
-/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
-/* harmony import */ var _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../../numerics/SmallSystem */ "../../core/geometry/lib/esm/numerics/SmallSystem.js");
-/* harmony import */ var _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../CurveExtendMode */ "../../core/geometry/lib/esm/curve/CurveExtendMode.js");
-/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
-/* harmony import */ var _NewtonRtoRStrokeHandler__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./NewtonRtoRStrokeHandler */ "../../core/geometry/lib/esm/curve/internalContexts/NewtonRtoRStrokeHandler.js");
+/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
+/* harmony import */ var _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../../numerics/SmallSystem */ "../../core/geometry/lib/esm/numerics/SmallSystem.js");
+/* harmony import */ var _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../CurveExtendMode */ "../../core/geometry/lib/esm/curve/CurveExtendMode.js");
+/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -216637,12 +216826,11 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
 /**
  * Context for searching for the closest point to a CurvePrimitive.
  * @internal
  */
-class ClosestPointStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORTED_MODULE_1__.NewtonRtoRStrokeHandler {
+class ClosestPointStrokeHandler extends _numerics_Newton__WEBPACK_IMPORTED_MODULE_1__.NewtonRtoRStrokeHandler {
     _curve;
     _closestPoint;
     _spacePoint;
@@ -216671,7 +216859,7 @@ class ClosestPointStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORT
         this._extend = extend ?? false;
         this._xyOnly = xyOnly ?? false;
         this.startCurvePrimitive(undefined);
-        this._newtonSolver = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_5__.Newton1dUnboundedApproximateDerivative(this);
+        this._newtonSolver = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_1__.Newton1dUnboundedApproximateDerivative(this);
     }
     claimResult() {
         if (this._closestPoint) {
@@ -216679,7 +216867,7 @@ class ClosestPointStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORT
             this._curve = this._closestPoint.curve;
             if (this._newtonSolver.runIterations()) {
                 let fraction = this._newtonSolver.getX();
-                fraction = _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__.CurveExtendOptions.correctFraction(this._extend, fraction);
+                fraction = _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__.CurveExtendOptions.correctFraction(this._extend, fraction);
                 this.announceSolutionFraction(fraction);
             }
         }
@@ -216713,7 +216901,7 @@ class ClosestPointStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORT
         const distance = this._xyOnly ? this._spacePoint.distanceXY(point) : this._spacePoint.distance(point);
         if (this._closestPoint && distance > this._closestPoint.a)
             return;
-        this._closestPoint = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetail.createCurveFractionPoint(cp, fraction, point, this._closestPoint);
+        this._closestPoint = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_6__.CurveLocationDetail.createCurveFractionPoint(cp, fraction, point, this._closestPoint);
         this._closestPoint.a = distance;
         if (this._parentCurvePrimitive !== undefined)
             this._closestPoint.curve = this._parentCurvePrimitive;
@@ -216721,13 +216909,13 @@ class ClosestPointStrokeHandler extends _NewtonRtoRStrokeHandler__WEBPACK_IMPORT
     announceSegmentInterval(cp, point0, point1, _numStrokes, fraction0, fraction1) {
         let localFraction = 0;
         if (this._xyOnly)
-            localFraction = _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_8__.SmallSystem.lineSegment3dXYClosestPointUnbounded(point0, point1, this._spacePoint) ?? 0;
+            localFraction = _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_7__.SmallSystem.lineSegment3dXYClosestPointUnbounded(point0, point1, this._spacePoint) ?? 0;
         else
             localFraction = this._spacePoint.fractionOfProjectionToLine(point0, point1, 0.0);
         // only consider segment extension at a parent curve endpoint, i.e. when fraction0 is 0 or fraction1 is 1
-        const extend0 = (fraction0 === 0) ? _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__.CurveExtendOptions.resolveVariantCurveExtendParameterToCurveExtendMode(this._extend, 0) : _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__.CurveExtendMode.None;
-        const extend1 = (fraction1 === 1) ? _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__.CurveExtendOptions.resolveVariantCurveExtendParameterToCurveExtendMode(this._extend, 1) : _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__.CurveExtendMode.None;
-        localFraction = _CurveExtendMode__WEBPACK_IMPORTED_MODULE_6__.CurveExtendOptions.correctFraction([extend0, extend1], localFraction);
+        const extend0 = (fraction0 === 0) ? _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__.CurveExtendOptions.resolveVariantCurveExtendParameterToCurveExtendMode(this._extend, 0) : _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__.CurveExtendMode.None;
+        const extend1 = (fraction1 === 1) ? _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__.CurveExtendOptions.resolveVariantCurveExtendParameterToCurveExtendMode(this._extend, 1) : _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__.CurveExtendMode.None;
+        localFraction = _CurveExtendMode__WEBPACK_IMPORTED_MODULE_5__.CurveExtendOptions.correctFraction([extend0, extend1], localFraction);
         this._workPoint = point0.interpolate(localFraction, point1);
         const globalFraction = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fraction0, localFraction, fraction1);
         this.announceCandidate(cp, globalFraction, this._workPoint);
@@ -216874,21 +217062,25 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   CurveCurveCloseApproachXY: () => (/* binding */ CurveCurveCloseApproachXY)
 /* harmony export */ });
 /* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
-/* harmony import */ var _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../../bspline/BSplineCurve */ "../../core/geometry/lib/esm/bspline/BSplineCurve.js");
+/* harmony import */ var _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ../../bspline/BSplineCurve */ "../../core/geometry/lib/esm/bspline/BSplineCurve.js");
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
 /* harmony import */ var _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../geometry3d/GeometryHandler */ "../../core/geometry/lib/esm/geometry3d/GeometryHandler.js");
-/* harmony import */ var _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../../geometry3d/GrowableFloat64Array */ "../../core/geometry/lib/esm/geometry3d/GrowableFloat64Array.js");
+/* harmony import */ var _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../../geometry3d/GrowableFloat64Array */ "../../core/geometry/lib/esm/geometry3d/GrowableFloat64Array.js");
 /* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
-/* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
-/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
-/* harmony import */ var _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../../numerics/Polynomials */ "../../core/geometry/lib/esm/numerics/Polynomials.js");
-/* harmony import */ var _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../../numerics/SmallSystem */ "../../core/geometry/lib/esm/numerics/SmallSystem.js");
-/* harmony import */ var _Arc3d__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../Arc3d */ "../../core/geometry/lib/esm/curve/Arc3d.js");
-/* harmony import */ var _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../CurveChainWithDistanceIndex */ "../../core/geometry/lib/esm/curve/CurveChainWithDistanceIndex.js");
-/* harmony import */ var _CurveCollection__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
-/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
-/* harmony import */ var _LineSegment3d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
-/* harmony import */ var _LineString3d__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
+/* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
+/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
+/* harmony import */ var _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../../numerics/Polynomials */ "../../core/geometry/lib/esm/numerics/Polynomials.js");
+/* harmony import */ var _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../../numerics/SmallSystem */ "../../core/geometry/lib/esm/numerics/SmallSystem.js");
+/* harmony import */ var _Arc3d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../Arc3d */ "../../core/geometry/lib/esm/curve/Arc3d.js");
+/* harmony import */ var _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../CurveChainWithDistanceIndex */ "../../core/geometry/lib/esm/curve/CurveChainWithDistanceIndex.js");
+/* harmony import */ var _CurveCollection__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
+/* harmony import */ var _CurveCurve__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../CurveCurve */ "../../core/geometry/lib/esm/curve/CurveCurve.js");
+/* harmony import */ var _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../CurveLocationDetail */ "../../core/geometry/lib/esm/curve/CurveLocationDetail.js");
+/* harmony import */ var _CurvePrimitive__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ../CurvePrimitive */ "../../core/geometry/lib/esm/curve/CurvePrimitive.js");
+/* harmony import */ var _LineSegment3d__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ../LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
+/* harmony import */ var _LineString3d__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
+/* harmony import */ var _ProxyCurve__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../ProxyCurve */ "../../core/geometry/lib/esm/curve/ProxyCurve.js");
+/* harmony import */ var _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ../spiral/TransitionSpiral3d */ "../../core/geometry/lib/esm/curve/spiral/TransitionSpiral3d.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -216912,6 +217104,10 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
+
+
 // cspell:word XYRR currentdFdX
 /**
  * Handler class for XY close approach between _geometryB and another geometry.
@@ -216929,9 +217125,6 @@ __webpack_require__.r(__webpack_exports__);
  */
 class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_1__.RecurseToCurvesGeometryHandler {
     _geometryB;
-    setGeometryB(geometryB) {
-        this._geometryB = geometryB;
-    }
     /**
      * Maximum XY distance (z is ignored). Approach larger than this is not interesting.
      * This is caller defined and can be undefined.
@@ -216939,6 +217132,8 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
     _maxDistanceToAccept;
     /** Squared max distance. Default is [[Geometry.smallMetricDistanceSquared]]. */
     _maxDistanceSquared;
+    _xyTolerance;
+    _newtonTolerance;
     /**
      * Start and end points of line segments that meet closest approach criteria, i.e., they are perpendicular to
      * both curves and their length is smaller than _maxDistanceToAccept.
@@ -216952,18 +217147,28 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
     /**
      * Constructor.
      * @param geometryB second curve for intersection. Saved for reference by specific handler methods.
+     * @param xyTolerance optional tolerance for comparing xy points (default [[Geometry.smallMetricDistance]]).
+     * @param newtonTolerance optional relative fraction tolerance for Newton iteration (default [[Geometry.smallNewtonStep]]).
      */
-    constructor(geometryB) {
+    constructor(geometryB, xyTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistance, newtonTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallNewtonStep) {
         super();
-        this.setGeometryB(geometryB);
+        this._geometryB = geometryB instanceof _ProxyCurve__WEBPACK_IMPORTED_MODULE_4__.ProxyCurve ? geometryB.proxyCurve : geometryB;
         this._maxDistanceSquared = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistanceSquared;
-        this._results = [];
+        this._xyTolerance = xyTolerance;
+        this._newtonTolerance = newtonTolerance;
+        const compare = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetailPair.comparePairsByPoints(xyTolerance, true);
+        this._results = new _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.SortedArray(compare, _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.DuplicatePolicy.Retain);
     }
     /** Set the (possibly undefined) max XY distance (z is ignored) to accept. */
     set maxDistanceToAccept(value) {
-        this._maxDistanceToAccept = value;
-        if (this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0)
-            this._maxDistanceSquared = this._maxDistanceToAccept * this._maxDistanceToAccept;
+        if (value === undefined) {
+            this._maxDistanceToAccept = undefined;
+            this._maxDistanceSquared = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistanceSquared;
+        }
+        else {
+            this._maxDistanceToAccept = Math.abs(value);
+            this._maxDistanceSquared = value * value;
+        }
     }
     /** Access the (possibly undefined) max XY distance (z is ignored) to accept. */
     get maxDistanceToAccept() {
@@ -216973,9 +217178,14 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
     get isMaxDistanceSet() {
         return this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0;
     }
-    /** Reset the geometry and flags, leaving all other parts unchanged (and preserving accumulated intersections) */
+    /**
+     * Reset the geometry.
+     * * Undefined inputs are ignored.
+     * * All other instance data is unchanged, including accumulated intersections.
+     */
     resetGeometry(geometryB) {
-        this.setGeometryB(geometryB);
+        if (geometryB)
+            this._geometryB = geometryB;
     }
     /** returns true if `fraction` is in [0,1] within tolerance */
     acceptFraction(fraction, fractionTol = 1.0e-12) {
@@ -216985,131 +217195,103 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
             return false;
         return true;
     }
-    /**
-     * Return the results structure for the intersection calculation, structured as an array of CurveLocationDetailPair.
-     * @param reinitialize if true, a new results structure is created for use by later calls.
-     */
-    grabPairedResults(reinitialize = false) {
-        const result = this._results;
-        if (reinitialize)
-            this._results = [];
-        return result;
-    }
-    /**
-     * If distance between pointA and pointB is less than maxDistance, record CurveLocationDetailPair which is
-     * the approach from pointA to pointB.
-     */
-    testAndRecordPointPairApproach(cpA, fA, pointA, cpB, fB, pointB, reversed) {
+    /** Extract (and clear) the results, structured as an array of CurveLocationDetailPair. */
+    grabPairedResults() {
+        return this._results.extractArray();
+    }
+    /**
+     * Create and record a close-approach pair from raw curve/fraction/point data.
+     * * If points are undefined, they are computed from the fractions via `fractionToPoint`.
+     * * Fractions are global (i.e., relative to the full curve, not a sub-segment).
+     * * The pair is recorded only if the XY distance is within `_maxDistanceSquared`.
+     * @param cpA first curve
+     * @param fA global fraction on cpA
+     * @param pointA point on cpA at fA, or undefined to compute from fA
+     * @param cpB second curve
+     * @param fB global fraction on cpB
+     * @param pointB point on cpB at fB, or undefined to compute from fB
+     * @param reversed if true, swap detailA and detailB before recording
+     */
+    testAndRecordPointPair(cpA, fA, pointA, cpB, fB, pointB, reversed) {
+        if (!pointA)
+            pointA = cpA.fractionToPoint(fA);
+        if (!pointB)
+            pointB = cpB.fractionToPoint(fB);
         const d2 = pointA.distanceSquaredXY(pointB);
-        if (d2 < this._maxDistanceSquared) {
+        if (d2 <= this._maxDistanceSquared) {
             const d = Math.sqrt(d2);
-            const detailA = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPointDistance(cpA, fA, pointA, d);
-            const detailB = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPointDistance(cpB, fB, pointB, d);
-            const pair = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetailPair.createCapture(detailA, detailB);
+            const detailA = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPointDistance(cpA, fA, pointA, d);
+            const detailB = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPointDistance(cpB, fB, pointB, d);
+            detailA.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveIntervalRole.isolated);
+            detailB.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveIntervalRole.isolated);
+            const pair = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetailPair.createCapture(detailA, detailB);
             if (reversed)
                 pair.swapDetails();
-            this._results.push(pair);
+            this._results.insert(pair);
         }
     }
     /**
-     * Create a close approach pair if XY distance is within maxDistance.
-     * @param localFractionA a fraction on first curve
-     * @param cpA the first curve
-     * @param fractionA0 start of the first curve
-     * @param fractionA1 end of the first curve
-     * @param localFractionB a fraction on second curve
-     * @param cpB the second curve
-     * @param fractionB0 start of the second curve
-     * @param fractionB1 end of the second curve
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
+     * Record a pre-built close-approach pair with global fractions already set.
+     * * Computes and stores the XY distance on both details.
+     * * The pair is recorded only if the XY distance is within `_maxDistanceSquared`.
+     * @param pair details with global fractions and points already set; modified in place
+     * @param reversed if true, swap detailA and detailB before recording
      */
-    recordPointWithLocalFractions(localFractionA, cpA, fractionA0, fractionA1, localFractionB, cpB, fractionB0, fractionB1, reversed) {
-        const globalFractionA = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionA0, localFractionA, fractionA1);
-        const globalFractionB = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionB0, localFractionB, fractionB1);
-        // ignore duplicate of most recent approach
-        const numPrevious = this._results.length;
-        if (numPrevious > 0) {
-            const oldDetailA = this._results[numPrevious - 1].detailA;
-            const oldDetailB = this._results[numPrevious - 1].detailB;
-            if (reversed) {
-                if (oldDetailB.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailA.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-            else {
-                if (oldDetailA.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailB.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-        }
-        const pointA = cpA.fractionToPoint(globalFractionA);
-        const pointB = cpB.fractionToPoint(globalFractionB);
-        const d2 = pointA.distanceSquaredXY(pointB);
+    testAndRecordPair(pair, reversed) {
+        const d2 = pair.detailA.point.distanceSquaredXY(pair.detailB.point);
         if (d2 > this._maxDistanceSquared)
             return;
         const d = Math.sqrt(d2);
-        const detailA = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPointDistance(cpA, globalFractionA, pointA, d);
-        const detailB = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPointDistance(cpB, globalFractionB, pointB, d);
-        detailA.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveIntervalRole.isolated);
-        detailB.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveIntervalRole.isolated);
+        pair.detailA.a = pair.detailB.a = d;
+        pair.detailA.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveIntervalRole.isolated);
+        pair.detailB.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveIntervalRole.isolated);
         if (reversed)
-            this._results.push(new _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetailPair(detailB, detailA));
-        else
-            this._results.push(new _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetailPair(detailA, detailB));
-    }
-    /**
-     * Capture a close approach pair that has point and local fraction but not curve.
-     * * Record the pair, each detail modified with global fraction and input curve.
-     * * Pair is neither modified nor recorded if it would be a duplicate of the last recorded pair.
-     * @param pair details computed with local fractions
-     * @param cpA curveA
-     * @param fractionA0 global start fraction on curveA
-     * @param fractionA1 global end fraction on curveA
-     * @param cpB curveB
-     * @param fractionB0 global start fraction on curveB
-     * @param fractionB1 global end fraction on curveB
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
-     */
-    capturePairWithLocalFractions(pair, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed) {
+            pair.swapDetails();
+        this._results.insert(pair);
+    }
+    /**
+     * Convert a close-approach pair from local (sub-segment) fractions to global fractions, then record it.
+     * * Local fractions in the pair are interpolated into the global fraction ranges.
+     * * Points are recomputed from the parent curves at the global fractions.
+     * * The pair is recorded only if the XY distance is within `_maxDistanceSquared`.
+     * @param pair local details (curve unspecified); modified in place with global fractions, curves, and points
+     * @param cpA parent curve A
+     * @param fractionA0 global fraction corresponding to local fraction 0 on curve A
+     * @param fractionA1 global fraction corresponding to local fraction 1 on curve A
+     * @param cpB parent curve B
+     * @param fractionB0 global fraction corresponding to local fraction 0 on curve B
+     * @param fractionB1 global fraction corresponding to local fraction 1 on curve B
+     * @param reversed if true, swap detailA and detailB before recording
+     */
+    testAndRecordLocalPair(pair, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed) {
         const globalFractionA = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionA0, pair.detailA.fraction, fractionA1);
         const globalFractionB = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionB0, pair.detailB.fraction, fractionB1);
-        // ignore duplicate of most recent pair
-        const numPrevious = this._results.length;
-        if (numPrevious > 0) {
-            const oldDetailA = this._results[numPrevious - 1].detailA;
-            const oldDetailB = this._results[numPrevious - 1].detailB;
-            if (reversed) {
-                if (oldDetailB.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailA.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-            else {
-                if (oldDetailA.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailB.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-        }
-        // recompute the points just in case
-        _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveEvaluatedFraction(cpA, globalFractionA, pair.detailA);
-        _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveEvaluatedFraction(cpB, globalFractionB, pair.detailB);
-        pair.detailA.a = pair.detailB.a = pair.detailA.point.distanceXY(pair.detailB.point);
-        pair.detailA.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveIntervalRole.isolated);
-        pair.detailB.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveIntervalRole.isolated);
+        const pointA = cpA.fractionToPoint(globalFractionA);
+        const pointB = cpB.fractionToPoint(globalFractionB);
+        const d2 = pointA.distanceSquaredXY(pointB);
+        if (d2 > this._maxDistanceSquared)
+            return;
+        const d = Math.sqrt(d2);
+        _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPointDistance(cpA, globalFractionA, pointA, d, pair.detailA);
+        _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPointDistance(cpB, globalFractionB, pointB, d, pair.detailB);
+        pair.detailA.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveIntervalRole.isolated);
+        pair.detailB.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveIntervalRole.isolated);
         if (reversed)
             pair.swapDetails();
-        this._results.push(pair);
+        this._results.insert(pair);
     }
-    static updatePointToSegmentDistance(fractionA, pointA, pointB0, pointB1, fractionB, maxDistanceSquared, closestApproach) {
+    /** Modify the current closest approach if the inputs are closer. */
+    static updatePointToSegmentDistance(closestApproach, fractionA, pointA, fractionB, pointB0, pointB1, maxDistanceSquared) {
         let updated = false;
         if (fractionB < 0)
             fractionB = 0;
         else if (fractionB > 1)
             fractionB = 1;
-        this._workPointB = pointB0.interpolate(fractionB, pointB1, this._workPointB);
-        const distanceSquared = this._workPointB.distanceSquaredXY(pointA);
+        const pointB = pointB0.interpolate(fractionB, pointB1, this._workPointB);
+        const distanceSquared = pointB.distanceSquaredXY(pointA);
         if (distanceSquared <= Math.min(maxDistanceSquared, closestApproach.detailA.a)) {
             closestApproach.detailA.setFP(fractionA, pointA, undefined, distanceSquared);
-            closestApproach.detailB.setFP(fractionB, this._workPointB, undefined, distanceSquared);
+            closestApproach.detailB.setFP(fractionB, pointB, undefined, distanceSquared);
             updated = true;
         }
         return updated;
@@ -217122,8 +217304,9 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
      * @param b0 start point of line b
      * @param b1 end point of line b
      * @param maxDistanceSquared maximum distance squared (assumed to be positive)
-     * @returns the fractional (not xy) coordinates in result.x and result.y. result.x is fraction on line a.
-     * result.y is fraction on line b.
+     * @returns a pair of details for the closest approach, or `undefined` if no approach is within `maxDistanceSquared`.
+      * `detailA.fraction` is the fraction on segment a; `detailB.fraction` is the fraction on segment b. Returned
+      * details store the *squared* distance in the `a` property.
      */
     static segmentSegmentBoundedApproach(a0, a1, b0, b1, maxDistanceSquared) {
         const ux = a1.x - a0.x;
@@ -217143,32 +217326,32 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
         if (hab0 * hab1 < 0.0 && hba0 * hba1 < 0.0) { // true intersection, strictly within both segments
             const fractionA = -hba0 / (hba1 - hba0);
             const fractionB = -hab0 / (hab1 - hab0);
-            return _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetailPair.createCapture(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPoint(undefined, fractionA, a0.interpolate(fractionA, a1)), _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPoint(undefined, fractionB, b0.interpolate(fractionB, b1)));
+            return _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetailPair.createCapture(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPoint(undefined, fractionA, a0.interpolate(fractionA, a1)), _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetail.createCurveFractionPoint(undefined, fractionB, b0.interpolate(fractionB, b1)));
         }
         // there's no intersection, so find the closest approach within maxDistance from an endpoint
-        const closestApproach = new _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetailPair();
+        const closestApproach = new _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetailPair();
         closestApproach.detailA.a = 2 * maxDistanceSquared; // init to an approach that's too far away
         let reversed = false;
         const uu = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.hypotenuseSquaredXY(ux, uy);
         if (hab0 * hab0 <= maxDistanceSquared * uu) { // test distance of b0 to u
             const fractionA = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(_Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.dotProductXYXY(ux, uy, e00x, e00y), uu, 0.0);
-            if (this.updatePointToSegmentDistance(0, b0, a0, a1, fractionA, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 0, b0, fractionA, a0, a1, maxDistanceSquared))
                 reversed = true;
         }
         if (hab1 * hab1 <= maxDistanceSquared * uu) { // test distance of b1 to u
             const fractionA = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(_Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.dotProductXYXY(ux, uy, e01x, e01y), uu, 0.0);
-            if (this.updatePointToSegmentDistance(1, b1, a0, a1, fractionA, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 1, b1, fractionA, a0, a1, maxDistanceSquared))
                 reversed = true;
         }
         const vv = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.hypotenuseSquaredXY(vx, vy);
         if (hba0 * hba0 <= maxDistanceSquared * vv) { // test distance of a0 to v
             const fractionB = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(-_Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.dotProductXYXY(vx, vy, e00x, e00y), vv, 0.0);
-            if (this.updatePointToSegmentDistance(0, a0, b0, b1, fractionB, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 0, a0, fractionB, b0, b1, maxDistanceSquared))
                 reversed = false;
         }
         if (hba1 * hba1 <= maxDistanceSquared * vv) { // test distance of a1 to v
             const fractionB = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(-_Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.dotProductXYXY(vx, vy, e10x, e10y), vv, 0.0);
-            if (this.updatePointToSegmentDistance(1, a1, b0, b1, fractionB, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 1, a1, fractionB, b0, b1, maxDistanceSquared))
                 reversed = false;
         }
         if (closestApproach.detailA.a > maxDistanceSquared)
@@ -217178,160 +217361,81 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
         return closestApproach;
     }
     /**
-     * Check different combination of fractions on curveA and curveB. If distance between points at 2 fractions
-     * is less than maxDistance, record CurveLocationDetailPair which is the approach between the 2 points.
-     * Optionally, record close approaches of one curve's points if they fall between the other curve's points.
-     * * If an input curve is a LineString3d, then the corresponding fractions must define a segment of the line string.
+     * Compute closest approaches from the endpoints of each curve (if open) to the other curve.
+     * Record a [[CurveLocationDetailPair]] if such a distance is less than [[maxDistance]].
      * @param cpA curveA
-     * @param fA0 fraction0 on curveA
-     * @param fA1 fraction1 on curveA
-     * @param testProjectionOnA whether to record projections of the given curveB points onto curveA
      * @param cpB curveB
-     * @param fB0 fraction0 on curveB
-     * @param fB1 fraction0 on curveB
-     * @param testProjectionOnB whether to record projections of the given curveA points onto curveB
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
-     */
-    testAndRecordFractionalPairApproach(cpA, fA0, fA1, testProjectionOnA, cpB, fB0, fB1, testProjectionOnB, reversed) {
-        const pointA0 = cpA.fractionToPoint(fA0);
-        const pointA1 = cpA.fractionToPoint(fA1);
-        const pointB0 = cpB.fractionToPoint(fB0);
-        const pointB1 = cpB.fractionToPoint(fB1);
-        this.testAndRecordPointPairApproach(cpA, fA0, pointA0, cpB, fB0, pointB0, reversed);
-        this.testAndRecordPointPairApproach(cpA, fA1, pointA1, cpB, fB0, pointB0, reversed);
-        this.testAndRecordPointPairApproach(cpA, fA0, pointA0, cpB, fB1, pointB1, reversed);
-        this.testAndRecordPointPairApproach(cpA, fA1, pointA1, cpB, fB1, pointB1, reversed);
-        if (testProjectionOnB) {
-            this.testAndRecordProjection(cpA, fA0, pointA0, cpB, fB0, fB1, reversed);
-            this.testAndRecordProjection(cpA, fA1, pointA1, cpB, fB0, fB1, reversed);
-        }
-        if (testProjectionOnA) {
-            this.testAndRecordProjection(cpB, fB0, pointB0, cpA, fA0, fA1, !reversed);
-            this.testAndRecordProjection(cpB, fB1, pointB1, cpA, fA0, fA1, !reversed);
-        }
-    }
-    /**
-     * Return XY closest approach between a curve primitive and a point.
-     * Currently, this function only supports Arc3d and LineSegment.
-     * Note that this function doesn't handle endpoints.
-     */
-    getPointCurveClosestApproachXYNewton(curveP, pointQ) {
-        if (!(curveP instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_5__.Arc3d) && !(curveP instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_6__.LineSegment3d)) {
-            (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(false, "getPointCurveClosestApproachXYNewton only supports Arc3d and LineSegment");
-        }
-        const seeds = [0.2, 0.4, 0.6, 0.8]; // HEURISTIC: arcs have up to 4 perpendiculars; lines have only 1
-        const newtonEvaluator = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_7__.CurvePointCloseApproachXYRtoRD(curveP, pointQ);
-        const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_7__.Newton1dUnbounded(newtonEvaluator, 100); // observed convergence to 1.0e-11 in 66 iters
-        let minCloseApproachLength = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.largeCoordinateResult;
-        let minCurvePFraction;
-        let minPointP;
-        for (const seed of seeds) {
-            newtonSearcher.setX(seed);
-            if (newtonSearcher.runIterations()) {
-                const curvePFraction = newtonSearcher.getX();
-                if (this.acceptFraction(curvePFraction)) {
-                    const pointP = curveP.fractionToPoint(curvePFraction);
-                    const closeApproachLength = pointP.distanceSquaredXY(pointQ);
-                    if (closeApproachLength < minCloseApproachLength) {
-                        minCloseApproachLength = closeApproachLength;
-                        minCurvePFraction = curvePFraction;
-                        minPointP = pointP;
-                    }
-                }
-            }
-        }
-        if (minCurvePFraction && minPointP)
-            return _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_4__.CurveLocationDetail.createCurveFractionPoint(curveP, minCurvePFraction, minPointP);
-        return undefined;
-    }
-    /**
-     * Find the closest xy approach between `pointA` and `cpB`. Add the approach if it's within `fB0` and `fB1`.
-     * * Does not test the endpoints of `cpB`.
-     * * The only types supported for `cpB` are Arc3d, LineSegment3d, and LineString3d.
-     * * If `cpB` is a LineString3d, then the interval `[fB0, fB1]` must correspond to a segment of the line string.
-    */
-    testAndRecordProjection(cpA, fA, pointA, cpB, fB0, fB1, reversed) {
-        let detail;
-        if (cpB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d) {
-            const segParamsB = cpB.globalFractionToSegmentIndexAndLocalFraction(fB0 <= fB1 ? fB0 : fB1);
-            const segIndexB = (segParamsB.fraction < 0.999999) ? segParamsB.index : segParamsB.index + 1;
-            const segmentB = cpB.getIndexedSegment(segIndexB);
-            if (segmentB && (detail = this.getPointCurveClosestApproachXYNewton(segmentB, pointA)))
-                _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d.convertLocalToGlobalDetail(detail, segIndexB, cpB.numEdges(), cpB);
+     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to curveA).
+     */
+    testAndRecordEndPointApproaches(cpA, cpB, reversed) {
+        const pt = CurveCurveCloseApproachXY._workPointB;
+        // in closest approach context, endpoints of full sweep arcs are artificial locations, and thus ignored
+        const isClosedArc = (curve) => curve instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_6__.Arc3d && curve.sweep.isFullCircle;
+        if (!isClosedArc(cpA)) {
+            this.testAndRecordProjection(cpA, 0, cpA.startPoint(pt), cpB, reversed);
+            this.testAndRecordProjection(cpA, 1, cpA.endPoint(pt), cpB, reversed);
         }
-        else {
-            detail = this.getPointCurveClosestApproachXYNewton(cpB, pointA);
-        }
-        if (detail) {
-            const fB = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.restrictToInterval(detail.fraction, fB0, fB1);
-            if (fB === detail.fraction) { // if fraction is within fB0 and fB1
-                this.testAndRecordPointPairApproach(cpA, fA, pointA, cpB, detail.fraction, detail.point, reversed);
-            }
+        if (!isClosedArc(cpB)) {
+            this.testAndRecordProjection(cpB, 0, cpB.startPoint(pt), cpA, !reversed);
+            this.testAndRecordProjection(cpB, 1, cpB.endPoint(pt), cpA, !reversed);
         }
     }
+    /** Find the closest xy approach between `pointA` and `cpB`. */
+    testAndRecordProjection(cpA, fA, pointA, cpB, reversed) {
+        const detail = cpB.closestPointXY(pointA);
+        if (detail)
+            this.testAndRecordPointPair(cpA, fA, pointA, cpB, detail.fraction, detail.point, reversed);
+    }
     /**
      * Compute closest xy approach of two line segments.
      * Filter by extension rules.
      * Record with fraction mapping.
      * * The fraction mappings allow portions of a linestring to be passed here.
      */
-    computeSegmentSegment3D(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed) {
+    computeSegmentSegment(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed) {
         // compute a pair with fractions local to segments
         const approach = CurveCurveCloseApproachXY.segmentSegmentBoundedApproach(pointA0, pointA1, pointB0, pointB1, this._maxDistanceSquared);
         // adjust the pair to refer to input curves and global fractions, then record it if new
         if (approach) {
             approach.detailA.setCurve(cpA);
             approach.detailB.setCurve(cpB);
-            this.capturePairWithLocalFractions(approach, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed);
+            this.testAndRecordLocalPair(approach, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed);
         }
     }
-    /** Low level dispatch of segment with segment. */
-    dispatchSegmentSegment(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed) {
-        this.computeSegmentSegment3D(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed);
-    }
     /**
      * Compute the perpendiculars between a line segment and an arc, without extending either curve.
      * * One or two perpendiculars will be found.
      * * Each perpendicular segment starts or ends on the arc where the arc tangent is parallel to the line tangent.
-     * * Perpendiculars from an endpoint are not explicitly computed.
-     * @param cpA line segment or line string; if it is a line string, then the fractions must specify a segment
-     * @param pointA0 start point of the segment
-     * @param fractionA0 fraction of the start of the segment
-     * @param pointA1 end point of the segment
-     * @param fractionA1 fraction of the end of the segment
-     * @param arc the arc
-     * @param reversed swap the details in the recorded pair (default: false)
-     */
-    allPerpendicularsSegmentArcBounded(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed = false) {
-        const dotUT = arc.vector0.crossProductStartEndXY(pointA0, pointA1);
-        const dotVT = arc.vector90.crossProductStartEndXY(pointA0, pointA1);
+     * @param startA line segment start point
+     * @param endA line segment end point
+     * @param arcB the arc
+     * @param announce callback to receive line and arc fractions and optional points of each perpendicular segment computed.
+     */
+    announceAllPerpendicularsSegmentArcBounded(startA, endA, arcB, announce) {
+        const dotUT = arcB.vector0.crossProductStartEndXY(startA, endA);
+        const dotVT = arcB.vector90.crossProductStartEndXY(startA, endA);
         const parallelRadians = Math.atan2(dotVT, dotUT);
         for (const radians1 of [parallelRadians, parallelRadians + Math.PI]) {
-            const arcPoint = arc.radiansToPoint(radians1);
-            const fArc = arc.sweep.radiansToSignedPeriodicFraction(radians1);
-            if (this.acceptFraction(fArc)) { // reject solution outside arc sweep
-                const fLine = _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_9__.SmallSystem.lineSegment3dXYClosestPointUnbounded(pointA0, pointA1, arcPoint);
-                if (fLine !== undefined && this.acceptFraction(fLine))
-                    this.recordPointWithLocalFractions(fLine, cpA, fractionA0, fractionA1, fArc, arc, 0, 1, reversed);
+            const arcPoint = arcB.radiansToPoint(radians1);
+            const arcFraction = arcB.sweep.radiansToSignedPeriodicFraction(radians1);
+            if (this.acceptFraction(arcFraction)) { // reject solution outside arc sweep
+                const lineFraction = _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_7__.SmallSystem.lineSegment3dXYClosestPointUnbounded(startA, endA, arcPoint);
+                if (lineFraction !== undefined && this.acceptFraction(lineFraction))
+                    announce(lineFraction, undefined, arcFraction, arcPoint);
             }
         }
     }
     /**
-     * Low level dispatch of line segment with arc.
-     * Find close approaches within maxDistance between a line segments (pointA0, pointA1) and an arc.
+     * Find close approaches within maxDistance between a line segment and an arc.
      * To consider:
      * 1) intersection between arc and segment.
-     * 2) endpoints to endpoints or endpoints projection to the other curve.
-     * 3) arc tangent parallel to line segment (or line string).
-     * @param cpA curve A (line segment or line string; if it is a line string, then the fractions must specify a segment)
-     * @param pointA0 start point of the segment
-     * @param fractionA0 fraction of the start of the segment
-     * @param pointA1 end point of the segment
-     * @param fractionA1 fraction of the end of the segment
-     * @param arc the arc
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
-     */
-    dispatchSegmentArc(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed) {
+     * 2) endpoints to endpoints, or endpoints projection to the other curve.
+     * 3) arc tangent parallel to line segment
+     * @param lineA the line segment
+     * @param arcB the arc
+     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to arcA).
+     */
+    computeSegmentArc(lineA, arcB, reversed) {
         // 1) intersection between arc and line segment (or string).
         // Suppose:
         // Arc: X = C + cU + sV where c = cos(theta) and s = sin(theta)
@@ -217342,56 +217446,56 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
         // evaluate points.
         // project back to line.
         let intersectionFound = false;
-        const data = arc.toTransformedVectors();
-        const pointA0Local = pointA0;
-        const pointA1Local = pointA1;
-        const alpha = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.center, 1); //  det(A0, A1, C)
-        const beta = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector0, 0); // det(A0, A1, U)
-        const gamma = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector90, 0); // det(A0, A1, V)
-        const cosines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_10__.GrowableFloat64Array(2);
-        const sines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_10__.GrowableFloat64Array(2);
-        const radians = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_10__.GrowableFloat64Array(2);
-        const numRoots = _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_11__.AnalyticRoots.appendImplicitLineUnitCircleIntersections(// solve the equation
-        alpha, beta, gamma, cosines, sines, radians);
+        const data = arcB.toTransformedVectors();
+        const alpha = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(lineA.point0Ref, 1, lineA.point1Ref, 1, data.center, 1); //  det(A0, A1, C)
+        const beta = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(lineA.point0Ref, 1, lineA.point1Ref, 1, data.vector0, 0); // det(A0, A1, U)
+        const gamma = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(lineA.point0Ref, 1, lineA.point1Ref, 1, data.vector90, 0); // det(A0, A1, V)
+        const cosines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_8__.GrowableFloat64Array(2);
+        const sines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_8__.GrowableFloat64Array(2);
+        const radians = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_8__.GrowableFloat64Array(2);
+        const numRoots = _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_9__.AnalyticRoots.appendImplicitLineUnitCircleIntersections(alpha, beta, gamma, cosines, sines, radians);
         for (let i = 0; i < numRoots; i++) {
             const arcPoint = data.center.plus2Scaled(data.vector0, cosines.atUncheckedIndex(i), data.vector90, sines.atUncheckedIndex(i));
             const arcFraction = data.sweep.radiansToSignedPeriodicFraction(radians.atUncheckedIndex(i));
-            const lineFraction = _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_9__.SmallSystem.lineSegment3dXYClosestPointUnbounded(pointA0Local, pointA1Local, arcPoint);
-            // only add if the point is within the start and end fractions of both line segment and arc
-            if (lineFraction !== undefined && this.acceptFraction(lineFraction) && this.acceptFraction(arcFraction)) {
-                this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
-                intersectionFound = true;
+            if (this.acceptFraction(arcFraction)) { // reject solution outside arc sweep
+                const lineFraction = _numerics_SmallSystem__WEBPACK_IMPORTED_MODULE_7__.SmallSystem.lineSegment3dXYClosestPointUnbounded(lineA.point0Ref, lineA.point1Ref, arcPoint);
+                if (lineFraction !== undefined && this.acceptFraction(lineFraction)) {
+                    this.testAndRecordPointPair(lineA, lineFraction, undefined, arcB, arcFraction, arcPoint, reversed);
+                    intersectionFound = true;
+                }
             }
         }
         if (intersectionFound)
             return;
-        // 2) endpoints to endpoints or endpoints projection to the other curve.
-        this.testAndRecordFractionalPairApproach(cpA, fractionA0, fractionA1, true, arc, 0, 1, true, reversed);
-        // 3) arc tangent parallel to line segment (or string).
+        // 2) endpoints to endpoints, or endpoints projection to the other curve.
+        this.testAndRecordEndPointApproaches(lineA, arcB, reversed);
+        // 3) arc tangent parallel to line segment.
         // If line does not intersect the arc, then the closest (and/or the furthest) point on arc to the line is a
         // point where the tangent line on arc at that point is parallel to the line.
-        this.allPerpendicularsSegmentArcBounded(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed);
+        this.announceAllPerpendicularsSegmentArcBounded(lineA.point0Ref, lineA.point1Ref, arcB, (lineFraction, linePoint, arcFraction, arcPoint) => this.testAndRecordPointPair(lineA, lineFraction, linePoint, arcB, arcFraction, arcPoint, reversed));
     }
     /**
      * Compute segments perpendicular to two elliptical arcs, without extending either curve.
      * * Perpendiculars from an endpoint are not explicitly computed.
      * * Intersections are also found by this search: they are reported as zero-length segments.
+     * @param arcA first arc
+     * @param arcB second arc
      * @param reversed swap the details in the recorded pair (default: false)
      */
-    allPerpendicularsArcArcBounded(arc0, arc1, reversed = false) {
-        const newtonEvaluator = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_7__.CurveCurveCloseApproachXYRRtoRRD(arc0, arc1);
-        // HEURISTIC: 2 ellipses have up to 8 perpendiculars and up to 4 intersections
+    allPerpendicularsArcArcBounded(arcA, arcB, reversed = false) {
+        const newtonEvaluator = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.CurveCurveCloseApproachXYRRtoRRD(arcA, arcB);
+        // HEURISTIC: 2 ellipses have up to 8 perpendiculars
         const seedDelta = 1 / 10; // denominator 9 fails the unit test
         const seedStart = seedDelta / 2;
-        const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_7__.Newton2dUnboundedWithDerivative(newtonEvaluator, 100); // observed convergence to 1.0e-11 in 49 iters
+        const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.Newton2dUnboundedWithDerivative(newtonEvaluator, 100); // observed convergence to 1.0e-11 in 49 iters
         for (let seedU = seedStart; seedU < 1; seedU += seedDelta) {
             for (let seedV = seedStart; seedV < 1; seedV += seedDelta) {
                 newtonSearcher.setUV(seedU, seedV);
                 if (newtonSearcher.runIterations()) {
-                    const frac0 = newtonSearcher.getU();
-                    const frac1 = newtonSearcher.getV();
-                    if (this.acceptFraction(frac0) && this.acceptFraction(frac1)) {
-                        this.recordPointWithLocalFractions(frac0, arc0, 0, 1, frac1, arc1, 0, 1, reversed);
+                    const fractionA = newtonSearcher.getU();
+                    const fractionB = newtonSearcher.getV();
+                    if (this.acceptFraction(fractionA) && this.acceptFraction(fractionB)) {
+                        this.testAndRecordPointPair(arcA, fractionA, undefined, arcB, fractionB, undefined, reversed);
                     }
                 }
             }
@@ -217406,33 +217510,33 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
         if (!rangeB.intersectsRangeXY(rangeA))
             return;
         // 1) endpoints to endpoints or endpoints projection to the other curve
-        this.testAndRecordFractionalPairApproach(cpA, 0, 1, true, cpB, 0, 1, true, reversed);
+        this.testAndRecordEndPointApproaches(cpA, cpB, reversed);
         // 2) perpendicular line between 2 arcs (includes intersections)
         this.allPerpendicularsArcArcBounded(cpA, cpB, reversed);
     }
     /** Low level dispatch of arc with (beziers of) a bspline curve */
     dispatchArcBsplineCurve3d(cpA, cpB, reversed) {
-        const ls = _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d.create();
+        const ls = _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d.create();
         cpB.emitStrokes(ls);
         this.computeArcLineString(cpA, ls, reversed);
     }
     /** Low level dispatch of (beziers of) a bspline curve with (beziers of) a bspline curve */
     dispatchBSplineCurve3dBSplineCurve3d(bcurveA, bcurveB, reversed) {
-        const lsA = _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d.create();
+        const lsA = _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d.create();
         bcurveA.emitStrokes(lsA);
-        const lsB = _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d.create();
+        const lsB = _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d.create();
         bcurveB.emitStrokes(lsB);
         this.computeLineStringLineString(lsA, lsB, reversed);
     }
     /** Low level dispatch of linestring with (beziers of) a bspline curve */
     dispatchLineStringBSplineCurve(lsA, curveB, reversed) {
-        const lsB = _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d.create();
+        const lsB = _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d.create();
         curveB.emitStrokes(lsB);
         this.computeLineStringLineString(lsA, lsB, reversed);
     }
     /** Low level dispatch of segment with (beziers of) a bspline curve */
     dispatchSegmentBsplineCurve(segA, curveB, reversed) {
-        const lsB = _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d.create();
+        const lsB = _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d.create();
         curveB.emitStrokes(lsB);
         this.computeSegmentLineString(segA, lsB, reversed);
     }
@@ -217449,7 +217553,7 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
             const fB1 = (i + 1 === numB - 1) ? 1.0 : (i + 1) * deltaFracB; // make sure we nail the end fraction
             lsB.packedPoints.getPoint3dAtUncheckedPointIndex(i, pointB0);
             lsB.packedPoints.getPoint3dAtUncheckedPointIndex(i + 1, pointB1);
-            this.dispatchSegmentSegment(segA, pointA0, 0.0, pointA1, 1.0, lsB, pointB0, fB0, pointB1, fB1, reversed);
+            this.computeSegmentSegment(segA, pointA0, 0.0, pointA1, 1.0, lsB, pointB0, fB0, pointB1, fB1, reversed);
         }
     }
     /** Detail computation for arc approaching linestring. */
@@ -217460,71 +217564,27 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
             rangeA.expandInPlace(this._maxDistanceToAccept);
         if (!rangeB.intersectsRangeXY(rangeA))
             return;
-        const pointB0 = CurveCurveCloseApproachXY._workPointBB0;
-        const pointB1 = CurveCurveCloseApproachXY._workPointBB1;
-        const numB = lsB.numPoints();
-        if (numB > 1) {
-            const dfB = 1.0 / (numB - 1);
-            let fB0;
-            let fB1;
-            fB0 = 0.0;
-            lsB.pointAt(0, pointB0);
-            for (let ib = 1; ib < numB; ib++, pointB0.setFrom(pointB1), fB0 = fB1) {
-                lsB.pointAt(ib, pointB1);
-                fB1 = ib * dfB;
-                this.dispatchSegmentArc(lsB, pointB0, fB0, pointB1, fB1, arcA, !reversed);
-            }
-        }
-    }
-    /** Low level dispatch of curve collection. */
-    dispatchCurveCollection(geomA, geomAHandler) {
-        const geomB = this._geometryB; // save
-        if (!geomB || !geomB.children || !(geomB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_12__.CurveCollection))
-            return;
-        for (const child of geomB.children) {
-            this.resetGeometry(child);
-            geomAHandler(geomA);
-        }
-        this._geometryB = geomB; // restore
-    }
-    /** Low level dispatch to geomA given a CurveChainWithDistanceIndex in geometryB. */
-    dispatchCurveChainWithDistanceIndex(geomA, geomAHandler) {
-        if (!this._geometryB || !(this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex))
-            return;
-        if (geomA instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex) {
-            (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(false, "call handleCurveChainWithDistanceIndex(geomA) instead");
-        }
-        const index0 = this._results.length;
-        const geomB = this._geometryB; // save
-        for (const child of geomB.path.children) {
-            this.resetGeometry(child);
-            geomAHandler(geomA);
-        }
-        this.resetGeometry(geomB); // restore
-        this._results = _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex.convertChildDetailToChainDetail(this._results, index0, undefined, geomB, true);
-    }
-    /** Double dispatch handler for strongly typed segment. */
-    handleLineSegment3d(segmentA) {
-        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_6__.LineSegment3d) {
-            const segmentB = this._geometryB;
-            this.dispatchSegmentSegment(segmentA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, segmentB, segmentB.point0Ref, 0.0, segmentB.point1Ref, 1.0, false);
-        }
-        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d) {
-            this.computeSegmentLineString(segmentA, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_5__.Arc3d) {
-            this.dispatchSegmentArc(segmentA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_14__.BSplineCurve3d) {
-            this.dispatchSegmentBsplineCurve(segmentA, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_12__.CurveCollection) {
-            this.dispatchCurveCollection(segmentA, this.handleLineSegment3d.bind(this));
-        }
-        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(segmentA, this.handleLineSegment3d.bind(this));
+        const v0 = CurveCurveCloseApproachXY._workPointBB0;
+        const v1 = CurveCurveCloseApproachXY._workPointBB1;
+        // 1. record intersections
+        const intersections = _CurveCurve__WEBPACK_IMPORTED_MODULE_12__.CurveCurve.intersectionXYPairs(arcA, false, lsB, false, this._xyTolerance);
+        for (const intersection of intersections)
+            this.testAndRecordPair(intersection, reversed);
+        // 2. record linestring interior vertex projections onto arc
+        const fStep = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(1.0, lsB.numEdges(), 0);
+        for (let i = 1; i < lsB.numEdges(); ++i)
+            this.testAndRecordProjection(lsB, i * fStep, lsB.pointAtUnchecked(i, v0), arcA, !reversed);
+        // 3. record arc/linestring endpoint projections onto linestring/arc
+        this.testAndRecordEndPointApproaches(arcA, lsB, reversed);
+        // 4. record perpendiculars from within a segment to the arc
+        lsB.startPoint(v0);
+        for (let iSeg = 0; iSeg < lsB.numEdges(); ++iSeg, v0.setFrom(v1)) {
+            lsB.pointAtUnchecked(iSeg + 1, v1);
+            this.announceAllPerpendicularsSegmentArcBounded(v0, v1, arcA, (lineFraction, linePoint, arcFraction, arcPoint) => {
+                const fLineString = lsB.segmentIndexAndLocalFractionToGlobalFraction(iSeg, lineFraction);
+                this.testAndRecordPointPair(arcA, arcFraction, arcPoint, lsB, fLineString, linePoint, reversed);
+            });
         }
-        return undefined;
     }
     /**
      * Set bits for comparison to range xy
@@ -217565,7 +217625,7 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
             return;
         let bitB0;
         let bitB1;
-        const rangeA1 = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_15__.Range3d.createNull();
+        const rangeA1 = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_13__.Range3d.createNull();
         const pointA0 = CurveCurveCloseApproachXY._workPointAA0;
         const pointA1 = CurveCurveCloseApproachXY._workPointAA1;
         const pointB0 = CurveCurveCloseApproachXY._workPointBB0;
@@ -217598,76 +217658,235 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
                         // DO NOT study the segment in detail if both bitB bits are on for any of the 4 planes
                         // (i.e., no intersection between rangeA1 and the range around line segment [B0,B1])
                         if ((bitB0 & bitB1) === 0)
-                            this.dispatchSegmentSegment(lsA, pointA0, fA0, pointA1, fA1, lsB, pointB0, fB0, pointB1, fB1, reversed);
+                            this.computeSegmentSegment(lsA, pointA0, fA0, pointA1, fA1, lsB, pointB0, fB0, pointB1, fB1, reversed);
                     }
                 }
             }
         }
     }
+    /** Low level dispatch of curve collection. */
+    dispatchCurveCollection(geomA, geomAHandler) {
+        const geomB = this._geometryB; // save
+        if (!geomB || !geomB.children || !(geomB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_14__.CurveCollection))
+            return;
+        for (const child of geomB.children) {
+            this.resetGeometry(child);
+            geomAHandler(geomA);
+        }
+        this._geometryB = geomB; // restore
+    }
+    /** Low level dispatch to geomA given a CurveChainWithDistanceIndex in geometryB. */
+    dispatchCurveChainWithDistanceIndex(geomA, geomAHandler) {
+        if (!this._geometryB || !(this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex))
+            return;
+        if (geomA instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex)
+            (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(false, "call handleCurveChainWithDistanceIndex(geomA) instead");
+        const saveResults = this.grabPairedResults();
+        const geomB = this._geometryB;
+        for (const child of geomB.path.children) {
+            this.resetGeometry(child);
+            geomAHandler(geomA);
+        }
+        this.resetGeometry(geomB);
+        const childResults = this._results.extractArray();
+        childResults.forEach((pair) => {
+            _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex.convertChildDetailToChainDetailSingle(pair, undefined, geomB);
+            this._results.insert(pair);
+        });
+        saveResults.forEach((pair) => this._results.insert(pair));
+    }
+    /** Double dispatch handler for strongly typed segment. */
+    handleLineSegment3d(segmentA) {
+        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_16__.LineSegment3d) {
+            const segmentB = this._geometryB;
+            this.computeSegmentSegment(segmentA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, segmentB, segmentB.point0Ref, 0.0, segmentB.point1Ref, 1.0, false);
+        }
+        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d) {
+            this.computeSegmentLineString(segmentA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_6__.Arc3d) {
+            this.computeSegmentArc(segmentA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_17__.BSplineCurve3d) {
+            this.dispatchSegmentBsplineCurve(segmentA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_18__.TransitionSpiral3d) {
+            this.dispatchCurveSpiral(segmentA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_14__.CurveCollection) {
+            this.dispatchCurveCollection(segmentA, this.handleLineSegment3d.bind(this));
+        }
+        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(segmentA, this.handleLineSegment3d.bind(this));
+        }
+        return undefined;
+    }
     /** Double dispatch handler for strongly typed linestring. */
     handleLineString3d(lsA) {
-        if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d) {
-            const lsB = this._geometryB;
-            this.computeLineStringLineString(lsA, lsB, false);
-        }
-        else if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_6__.LineSegment3d) {
+        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_16__.LineSegment3d) {
             this.computeSegmentLineString(this._geometryB, lsA, true);
         }
-        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_5__.Arc3d) {
+        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d) {
+            this.computeLineStringLineString(lsA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_6__.Arc3d) {
             this.computeArcLineString(this._geometryB, lsA, true);
         }
-        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_14__.BSplineCurve3d) {
+        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_17__.BSplineCurve3d) {
             this.dispatchLineStringBSplineCurve(lsA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_12__.CurveCollection) {
+        else if (this._geometryB instanceof _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_18__.TransitionSpiral3d) {
+            this.dispatchCurveSpiral(lsA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_14__.CurveCollection) {
             this.dispatchCurveCollection(lsA, this.handleLineString3d.bind(this));
         }
-        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex) {
+        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex) {
             this.dispatchCurveChainWithDistanceIndex(lsA, this.handleLineString3d.bind(this));
         }
         return undefined;
     }
     /** Double dispatch handler for strongly typed arc. */
-    handleArc3d(arc0) {
-        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_6__.LineSegment3d) {
-            this.dispatchSegmentArc(this._geometryB, this._geometryB.point0Ref, 0.0, this._geometryB.point1Ref, 1.0, arc0, true);
+    handleArc3d(arcA) {
+        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_16__.LineSegment3d) {
+            this.computeSegmentArc(this._geometryB, arcA, true);
         }
-        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d) {
-            this.computeArcLineString(arc0, this._geometryB, false);
+        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d) {
+            this.computeArcLineString(arcA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_5__.Arc3d) {
-            this.dispatchArcArc(arc0, this._geometryB, false);
+        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_6__.Arc3d) {
+            this.dispatchArcArc(arcA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_14__.BSplineCurve3d) {
-            this.dispatchArcBsplineCurve3d(arc0, this._geometryB, false);
+        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_17__.BSplineCurve3d) {
+            this.dispatchArcBsplineCurve3d(arcA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_12__.CurveCollection) {
-            this.dispatchCurveCollection(arc0, this.handleArc3d.bind(this));
+        else if (this._geometryB instanceof _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_18__.TransitionSpiral3d) {
+            this.dispatchCurveSpiral(arcA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(arc0, this.handleArc3d.bind(this));
+        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_14__.CurveCollection) {
+            this.dispatchCurveCollection(arcA, this.handleArc3d.bind(this));
+        }
+        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(arcA, this.handleArc3d.bind(this));
         }
         return undefined;
     }
     /** Double dispatch handler for strongly typed bspline curve. */
-    handleBSplineCurve3d(curve) {
-        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_6__.LineSegment3d) {
-            this.dispatchSegmentBsplineCurve(this._geometryB, curve, true);
+    handleBSplineCurve3d(curveA) {
+        if (this._geometryB instanceof _LineSegment3d__WEBPACK_IMPORTED_MODULE_16__.LineSegment3d) {
+            this.dispatchSegmentBsplineCurve(this._geometryB, curveA, true);
         }
-        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_8__.LineString3d) {
-            this.dispatchLineStringBSplineCurve(this._geometryB, curve, true);
+        else if (this._geometryB instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d) {
+            this.dispatchLineStringBSplineCurve(this._geometryB, curveA, true);
         }
-        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_5__.Arc3d) {
-            this.dispatchArcBsplineCurve3d(this._geometryB, curve, true);
+        else if (this._geometryB instanceof _Arc3d__WEBPACK_IMPORTED_MODULE_6__.Arc3d) {
+            this.dispatchArcBsplineCurve3d(this._geometryB, curveA, true);
         }
-        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_14__.BSplineCurve3dBase) {
-            this.dispatchBSplineCurve3dBSplineCurve3d(curve, this._geometryB, false);
+        else if (this._geometryB instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_17__.BSplineCurve3dBase) {
+            this.dispatchBSplineCurve3dBSplineCurve3d(curveA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_12__.CurveCollection) {
-            this.dispatchCurveCollection(curve, this.handleBSplineCurve3d.bind(this));
+        else if (this._geometryB instanceof _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_18__.TransitionSpiral3d) {
+            this.dispatchCurveSpiral(curveA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(curve, this.handleBSplineCurve3d.bind(this));
+        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_14__.CurveCollection) {
+            this.dispatchCurveCollection(curveA, this.handleBSplineCurve3d.bind(this));
+        }
+        else if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(curveA, this.handleBSplineCurve3d.bind(this));
+        }
+        return undefined;
+    }
+    /**
+     * Process seeds for xy close approach between the curve and spiral.
+     * * Refine each result via Newton iteration. If it doesn't converge, remove it.
+     * @param seeds The initial seed results to refine.
+     * @param curveA The other curve primitive. May also be a transition spiral.
+     * @param spiralB The transition spiral.
+     * @param reversed whether `spiralB` data is in `detailA` of each recorded pair, and `curveA` data in `detailB`.
+     */
+    refineSpiralResultsByNewton(seeds, curveA, spiralB, reversed = false) {
+        const xyMatchingFunction = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.CurveCurveCloseApproachXYRRtoRRD(curveA, spiralB);
+        const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.Newton2dUnboundedWithDerivative(xyMatchingFunction, 50, this._newtonTolerance); // seen: 47
+        for (const seed of seeds) {
+            const detailA = reversed ? seed.detailB : seed.detailA;
+            const detailB = reversed ? seed.detailA : seed.detailB;
+            (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(detailB.curve instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d, "Caller has discretized the spiral");
+            newtonSearcher.setUV(detailA.fraction, detailB.fraction); // use linestring fraction as spiral param; it generally yields a closer point than fractional length!
+            if (newtonSearcher.runIterations()) {
+                const fractionA = newtonSearcher.getU();
+                const fractionB = newtonSearcher.getV();
+                if (this.acceptFraction(fractionA) && this.acceptFraction(fractionB))
+                    this.testAndRecordPointPair(curveA, fractionA, undefined, spiralB, fractionB, undefined, reversed);
+            } // ignore failure to converge
+        }
+    }
+    /**
+     * Append stroke points and return the line string.
+     * * This is a convenient wrapper for [[CurvePrimitive.emitStrokes]] but the analogous instance method cannot be added
+     * to that class due to the ensuing recursion with subclass [[LineString3d]].
+     * @param options options for stroking the instance curve.
+     * @param result object to receive appended stroke points; if omitted, a new object is created, populated, and returned.
+     */
+    strokeCurve(curve, options, result) {
+        const ls = result ? result : _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d.create();
+        curve.emitStrokes(ls, options);
+        return ls;
+    }
+    /** Find and return the close approaches between curveA and the discretization of curveB. */
+    computeDiscreteCloseApproachResults(curveA, lsB, reversed) {
+        const maxDist = this.maxDistanceToAccept;
+        const saveResults = this.grabPairedResults(); // save current results
+        const geomB = this._geometryB;
+        this.maxDistanceToAccept = maxDist ? maxDist * 1.2 : undefined; // HEURISTIC: allow slack for Newton seeds
+        this.resetGeometry(curveA);
+        this.handleLineString3d(lsB); // populate empty results with discrete solutions
+        if (!reversed) {
+            // handleLineString3d put lsB data into detailA, so if we aren't reversing, we need to swap
+            for (const result of this._results)
+                result.swapDetails();
+        }
+        this.resetGeometry(geomB);
+        this.maxDistanceToAccept = maxDist;
+        const discreteResults = this._results.extractArray();
+        saveResults.forEach((pair) => this._results.insert(pair)); // restore current results
+        return discreteResults;
+    }
+    /**
+     * Compute the XY close approach of a curve and a spiral.
+     * @param curveA curve to find its close approach with spiralB. May also be a transition spiral.
+     * @param spiralB transition spiral to find its close approach with curveA.
+     * @param reversed whether `spiralB` data will be recorded in `detailA` of each result, and `curveA` data in `detailB`.
+     */
+    dispatchCurveSpiral(curveA, spiralB, reversed) {
+        // explicit search for intersections (Newton converges too slowly on DirectSpiral3d tangent intersections)
+        const intersections = _CurveCurve__WEBPACK_IMPORTED_MODULE_12__.CurveCurve.intersectionXYPairs(curveA, false, spiralB, false, this._xyTolerance);
+        for (const intersection of intersections)
+            this.testAndRecordPair(intersection, reversed);
+        // append seeds computed by solving the discretized spiral close approach problem, then refine the seeds via Newton
+        let cpA = curveA;
+        if (curveA instanceof _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_18__.TransitionSpiral3d)
+            cpA = this.strokeCurve(curveA);
+        const cpB = this.strokeCurve(spiralB);
+        const seeds = this.computeDiscreteCloseApproachResults(cpA, cpB, reversed);
+        this.refineSpiralResultsByNewton(seeds, curveA, spiralB, reversed);
+        if (curveA instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_11__.LineString3d) { // explicitly test corners (where Newton converges too slowly)
+            const fStep = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(1.0, curveA.numEdges(), 0);
+            const v0 = CurveCurveCloseApproachXY._workPointBB0;
+            for (let i = 1; i < curveA.numEdges(); ++i)
+                this.testAndRecordProjection(curveA, i * fStep, curveA.pointAtUnchecked(i, v0), spiralB, reversed);
+        }
+        this.testAndRecordEndPointApproaches(curveA, spiralB, reversed);
+    }
+    /** Double dispatch handler for strongly typed spiral curve. */
+    handleTransitionSpiral(spiral) {
+        if (this._geometryB instanceof _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(spiral, this.handleTransitionSpiral.bind(this));
+        }
+        else if (this._geometryB instanceof _CurvePrimitive__WEBPACK_IMPORTED_MODULE_19__.CurvePrimitive) {
+            this.dispatchCurveSpiral(this._geometryB, spiral, true);
+        }
+        else if (this._geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_14__.CurveCollection) {
+            this.dispatchCurveCollection(spiral, this.handleTransitionSpiral.bind(this));
         }
         return undefined;
     }
@@ -217675,7 +217894,11 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
     handleCurveChainWithDistanceIndex(chain) {
         super.handleCurveChainWithDistanceIndex(chain);
         // if _geometryB is also a CurveChainWithDistanceIndex, it will already have been converted by dispatchCurveChainWithDistanceIndex
-        this._results = _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_13__.CurveChainWithDistanceIndex.convertChildDetailToChainDetail(this._results, 0, chain, undefined, true);
+        const childResults = this._results.extractArray();
+        childResults.forEach((pair) => {
+            _CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_15__.CurveChainWithDistanceIndex.convertChildDetailToChainDetailSingle(pair, chain, undefined);
+            this._results.insert(pair);
+        });
     }
     /** Double dispatch handler for strongly typed homogeneous bspline curve .. */
     handleBSplineCurve3dH(_curve) {
@@ -218700,12 +218923,11 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
     }
     /**
      * Process tail of `this._results` for xy-intersections between the curve and spiral.
-     * * If a result is not already an intersection, refine it via Newton iteration unless it doesn't converge, in which
-     * case remove it.
+     * * Refine each result via Newton iteration. If it doesn't converge, remove it.
      * @param curveA The other curve primitive. May also be a transition spiral.
      * @param spiralB The transition spiral.
      * @param index0 index of first entry in tail of `this._results` to refine.
-     * @param reversed Whether `spiralB` data is in `detailA` of each recorded pair, and `curveA` data in `detailB`.
+     * @param reversed whether `spiralB` data is in `detailA` of each recorded pair, and `curveA` data in `detailB`.
      */
     refineSpiralResultsByNewton(curveA, spiralB, index0, reversed = false) {
         if (index0 >= this._results.length)
@@ -218715,25 +218937,16 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
         const maxIterations = 100; // observed 73 iterations to convergence in tangent case
         const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_13__.Newton2dUnboundedWithDerivative(xyMatchingFunction, maxIterations);
         const fractionTol = 2 * newtonSearcher.stepSizeTolerance; // relative cluster diameter for Newton convergence
-        const comparePairs = (a, b) => {
-            (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(() => a.detailA.curve === b.detailA.curve && a.detailB.curve === b.detailB.curve, "pairs are compatible");
-            // sort on either fraction, then on the point, using appropriate tolerances for each
-            if (_Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.isAlmostEqualNumber(a.detailA.fraction, b.detailA.fraction, fractionTol))
-                return 0;
-            if (a.detailA.point.isAlmostEqualXY(b.detailA.point, this._coincidentGeometryContext.tolerance))
-                return 0;
-            return a.detailA.fraction - b.detailA.fraction;
-        };
-        const myResults = new _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.SortedArray(comparePairs, _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.DuplicatePolicy.Retain);
-        const pushToMyResults = (cpA, fA, cpB, fB) => {
-            const detailA = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetail.createCurveFractionPoint(cpA, fA, cpA.fractionToPoint(fA));
-            const detailB = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetail.createCurveFractionPoint(cpB, fB, cpB.fractionToPoint(fB));
+        const compare = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetailPair.comparePairsByFractions(fractionTol, this._coincidentGeometryContext.tolerance, true);
+        const myResults = new _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.SortedArray(compare, _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.DuplicatePolicy.Retain);
+        const pushToMyResults = (cpA, fA, pA, cpB, fB, pB) => {
+            const detailA = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetail.createCurveFractionPoint(cpA, fA, pA);
+            const detailB = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetail.createCurveFractionPoint(cpB, fB, pB);
             detailA.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveIntervalRole.isolated);
             detailB.setIntervalRole(_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveIntervalRole.isolated);
-            let pushed = false;
-            myResults.insert(new _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetailPair(reversed ? detailB : detailA, reversed ? detailA : detailB), () => pushed = true);
-            return pushed;
+            myResults.insert(new _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_7__.CurveLocationDetailPair(reversed ? detailB : detailA, reversed ? detailA : detailB));
         };
+        const strictTolerance = this._coincidentGeometryContext.tolerance * 0.0001;
         for (let i = index0; i < this._results.length; i++) {
             const pair = this._results[i];
             const detailA = reversed ? pair.detailB : pair.detailA;
@@ -218742,18 +218955,16 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
             const extendA0 = reversed ? this._extendB0 : this._extendA0;
             const extendA1 = reversed ? this._extendB1 : this._extendA1;
             newtonSearcher.setUV(detailA.fraction, detailB.fraction); // use linestring fraction as spiral param; it generally yields a closer point than fractional length!
-            if (newtonSearcher.runIterations()) {
-                const fractionA = newtonSearcher.getU();
-                const fractionB = newtonSearcher.getV();
-                if (this.acceptFraction(extendA0, fractionA, extendA1) && this.acceptFraction(false, fractionB, false))
-                    pushToMyResults(curveA, fractionA, spiralB, fractionB);
-            }
-            else if (newtonSearcher.numIterations < 10) {
-                // if Newton failed early due to vanishing (partial) derivative, check for a root there
-                const fractionA = newtonSearcher.getU();
-                const fractionB = newtonSearcher.getV();
-                if (curveA.fractionToPoint(fractionA).isAlmostEqualXY(spiralB.fractionToPoint(fractionB), this._coincidentGeometryContext.tolerance))
-                    pushToMyResults(curveA, fractionA, spiralB, fractionB);
+            let converged = newtonSearcher.runIterations();
+            const fractionA = newtonSearcher.getU();
+            const fractionB = newtonSearcher.getV();
+            if (this.acceptFraction(extendA0, fractionA, extendA1) && this.acceptFraction(false, fractionB, false)) {
+                const pointA = curveA.fractionToPoint(fractionA, CurveCurveIntersectXY._workPointA0);
+                const pointB = spiralB.fractionToPoint(fractionB, CurveCurveIntersectXY._workPointB0);
+                if (!converged) // Newton may have found close points even if it didn't converge parametrically
+                    converged = pointA.isAlmostEqualXY(pointB, strictTolerance); // we can afford to be choosy
+                if (converged)
+                    pushToMyResults(curveA, fractionA, pointA, spiralB, fractionB, pointB);
             }
         }
         this._results.splice(index0, this._results.length - index0, ...myResults.extractArray());
@@ -218798,7 +219009,7 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
      */
     appendDiscreteIntersectionResults(curveA, extendA0, extendA1, lsB, reversed) {
         const i0 = this._results.length;
-        // handleLineString3d requires us to swap geometries:
+        // handleLineString3d requires us to swap geometries
         const geomB = this._geometryB;
         const extendB0 = this._extendB0;
         const extendB1 = this._extendB1;
@@ -221436,54 +221647,6 @@ class MultiChainCollector {
 }
 
 
-/***/ }),
-
-/***/ "../../core/geometry/lib/esm/curve/internalContexts/NewtonRtoRStrokeHandler.js":
-/*!*************************************************************************************!*\
-  !*** ../../core/geometry/lib/esm/curve/internalContexts/NewtonRtoRStrokeHandler.js ***!
-  \*************************************************************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   NewtonRtoRStrokeHandler: () => (/* binding */ NewtonRtoRStrokeHandler)
-/* harmony export */ });
-/* harmony import */ var _numerics_Newton__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../numerics/Newton */ "../../core/geometry/lib/esm/numerics/Newton.js");
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Curve
- */
-
-/**
- * Intermediate class for managing the parentCurve announcements from an IStrokeHandler.
- * @internal
- */
-class NewtonRtoRStrokeHandler extends _numerics_Newton__WEBPACK_IMPORTED_MODULE_0__.NewtonEvaluatorRtoR {
-    _parentCurvePrimitive;
-    constructor() {
-        super();
-        this._parentCurvePrimitive = undefined;
-    }
-    /**
-     * Retain the parentCurvePrimitive.
-     * * Calling this method tells the handler that the parent curve is to be used for detail searches.
-     * * Example: Transition spiral search is based on linestring first, then the exact spiral.
-     * * Example: CurveChainWithDistanceIndex does NOT do this announcement; the constituents act independently.
-     */
-    startParentCurvePrimitive(curve) {
-        this._parentCurvePrimitive = curve;
-    }
-    /** Forget the parentCurvePrimitive */
-    endParentCurvePrimitive(_curve) {
-        this._parentCurvePrimitive = undefined;
-    }
-}
-
-
 /***/ }),
 
 /***/ "../../core/geometry/lib/esm/curve/internalContexts/PlaneAltitudeRangeContext.js":
@@ -225493,8 +225656,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../../geometry3d/GeometryHandler */ "../../core/geometry/lib/esm/geometry3d/GeometryHandler.js");
 /* harmony import */ var _geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../geometry3d/Segment1d */ "../../core/geometry/lib/esm/geometry3d/Segment1d.js");
-/* harmony import */ var _internalContexts_CurveLengthContext__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../internalContexts/CurveLengthContext */ "../../core/geometry/lib/esm/curve/internalContexts/CurveLengthContext.js");
+/* harmony import */ var _internalContexts_CurveLengthContext__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../internalContexts/CurveLengthContext */ "../../core/geometry/lib/esm/curve/internalContexts/CurveLengthContext.js");
 /* harmony import */ var _LineString3d__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
 /* harmony import */ var _StrokeOptions__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../StrokeOptions */ "../../core/geometry/lib/esm/curve/StrokeOptions.js");
 /* harmony import */ var _AustralianRailCorpXYEvaluator__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./AustralianRailCorpXYEvaluator */ "../../core/geometry/lib/esm/curve/spiral/AustralianRailCorpXYEvaluator.js");
@@ -225524,6 +225688,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 /**
 * DirectSpiral3d acts like a TransitionSpiral3d for serialization purposes, but implements spiral types that have
 * "direct" xy calculations without the integrations required for IntegratedSpiral3d.
@@ -225901,11 +226066,16 @@ class DirectSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1__.Tr
     }
     /**
      * Add strokes from this spiral to `dest`.
-     * * Line strings will usually stroke as just their points.
-     * * If maxEdgeLength is given, this will sub-stroke within the linestring -- not what we want.
+     * @param options optional stroking options. Pass `undefined` to return cached strokes.
      */
     emitStrokes(dest, options) {
-        this.activeStrokes.emitStrokes(dest, options);
+        if (!options)
+            this.activeStrokes.emitStrokes(dest, options);
+        else {
+            const stroker = new _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_12__.UniformStrokeCollector(this);
+            this.emitStrokableParts(stroker, options);
+            stroker.claimLineString(dest);
+        }
     }
     /** Emit stroke fragments to `dest` handler. */
     emitStrokableParts(dest, options) {
@@ -225915,7 +226085,7 @@ class DirectSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1__.Tr
         // hack: specify the extended range so we can compute length of an extended spiral
         let globalFraction0 = 0.0;
         let globalFraction1 = 1.0;
-        if (dest instanceof _internalContexts_CurveLengthContext__WEBPACK_IMPORTED_MODULE_12__.CurveLengthContext) {
+        if (dest instanceof _internalContexts_CurveLengthContext__WEBPACK_IMPORTED_MODULE_13__.CurveLengthContext) {
             if (dest.getFraction0 < 0.0)
                 globalFraction0 = dest.getFraction0;
             if (dest.getFraction1 > 1.0)
@@ -226021,15 +226191,16 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
 /* harmony import */ var _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../../geometry3d/AngleSweep */ "../../core/geometry/lib/esm/geometry3d/AngleSweep.js");
+/* harmony import */ var _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../../geometry3d/GeometryHandler */ "../../core/geometry/lib/esm/geometry3d/GeometryHandler.js");
 /* harmony import */ var _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../geometry3d/Matrix3d */ "../../core/geometry/lib/esm/geometry3d/Matrix3d.js");
-/* harmony import */ var _geometry3d_Plane3dByOriginAndVectors__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../../geometry3d/Plane3dByOriginAndVectors */ "../../core/geometry/lib/esm/geometry3d/Plane3dByOriginAndVectors.js");
+/* harmony import */ var _geometry3d_Plane3dByOriginAndVectors__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../../geometry3d/Plane3dByOriginAndVectors */ "../../core/geometry/lib/esm/geometry3d/Plane3dByOriginAndVectors.js");
 /* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
-/* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
+/* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
 /* harmony import */ var _geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../geometry3d/Segment1d */ "../../core/geometry/lib/esm/geometry3d/Segment1d.js");
-/* harmony import */ var _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../../geometry3d/Transform */ "../../core/geometry/lib/esm/geometry3d/Transform.js");
+/* harmony import */ var _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../../geometry3d/Transform */ "../../core/geometry/lib/esm/geometry3d/Transform.js");
 /* harmony import */ var _numerics_Quadrature__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../numerics/Quadrature */ "../../core/geometry/lib/esm/numerics/Quadrature.js");
 /* harmony import */ var _LineString3d__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
-/* harmony import */ var _StrokeOptions__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../StrokeOptions */ "../../core/geometry/lib/esm/curve/StrokeOptions.js");
+/* harmony import */ var _StrokeOptions__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../StrokeOptions */ "../../core/geometry/lib/esm/curve/StrokeOptions.js");
 /* harmony import */ var _NormalizedTransition__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./NormalizedTransition */ "../../core/geometry/lib/esm/curve/spiral/NormalizedTransition.js");
 /* harmony import */ var _TransitionConditionalProperties__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./TransitionConditionalProperties */ "../../core/geometry/lib/esm/curve/spiral/TransitionConditionalProperties.js");
 /* harmony import */ var _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TransitionSpiral3d */ "../../core/geometry/lib/esm/curve/spiral/TransitionSpiral3d.js");
@@ -226055,6 +226226,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 /**
  * An IntegratedSpiral3d is a curve defined by integrating its curvature.
  * * The first integral of curvature (with respect to distance along the curve) is the bearing angle (in radians).
@@ -226310,11 +226482,16 @@ class IntegratedSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1_
     }
     /**
      * Add strokes from this spiral to `dest`.
-     * * Linestrings will usually stroke as just their points.
-     * * If maxEdgeLength is given, this will sub-stroke within the linestring -- not what we want.
+     * @param options optional stroking options. Pass `undefined` to return cached strokes.
      */
     emitStrokes(dest, options) {
-        this.activeStrokes.emitStrokes(dest, options);
+        if (!options)
+            this.activeStrokes.emitStrokes(dest, options);
+        else {
+            const stroker = new _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_11__.UniformStrokeCollector(this);
+            this.emitStrokableParts(stroker, options);
+            stroker.claimLineString(dest);
+        }
     }
     /** Emit stroke fragments to `dest` handler. */
     emitStrokableParts(dest, options) {
@@ -226343,7 +226520,7 @@ class IntegratedSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1_
             numStroke = options.applyMinStrokesPerPrimitive(numStroke);
         }
         else {
-            numStroke = _StrokeOptions__WEBPACK_IMPORTED_MODULE_11__.StrokeOptions.applyAngleTol(undefined, 4, this.bearing01.sweepRadians);
+            numStroke = _StrokeOptions__WEBPACK_IMPORTED_MODULE_12__.StrokeOptions.applyAngleTol(undefined, 4, this.bearing01.sweepRadians);
         }
         return numStroke;
     }
@@ -226401,7 +226578,7 @@ class IntegratedSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1_
     /** Evaluate curve point and derivative with respect to fraction. */
     fractionToPointAndDerivative(activeFraction, result) {
         const globalFraction = this.activeFractionInterval.fractionToPoint(activeFraction);
-        result = result ? result : _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_12__.Ray3d.createZero();
+        result = result ? result : _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_13__.Ray3d.createZero();
         this.fractionToPoint(activeFraction, result.origin);
         const radians = this.globalFractionToBearingRadians(globalFraction);
         const a = this._arcLength01 * this.activeFractionInterval.signedDelta();
@@ -226411,7 +226588,7 @@ class IntegratedSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1_
     /** Return the frenet frame at fractional position. */
     fractionToFrenetFrame(activeFraction, result) {
         const globalFraction = this.activeFractionInterval.fractionToPoint(activeFraction);
-        result = result ? result : _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_13__.Transform.createIdentity();
+        result = result ? result : _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_14__.Transform.createIdentity();
         result.origin.setFrom(this.fractionToPoint(activeFraction));
         _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_5__.Matrix3d.createRigidFromMatrix3d(this.localToWorld.matrix, _Geometry__WEBPACK_IMPORTED_MODULE_10__.AxisOrder.XYZ, result.matrix);
         const radians = this.globalFractionToBearingRadians(globalFraction);
@@ -226433,13 +226610,13 @@ class IntegratedSpiral3d extends _TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_1_
         const radians = this.globalFractionToBearingRadians(globalFraction);
         const c = Math.cos(radians);
         const s = Math.sin(radians);
-        const delta = this.activeFractionInterval.signedDelta();
+        const delta = this._arcLength01 * this.activeFractionInterval.signedDelta();
         const a = delta;
         const b = a * delta;
         const vectorX = this.localToWorld.matrix.multiplyXY(a * c, a * s);
         const vectorY = this.localToWorld.matrix.multiplyXY(-b * s, b * c);
         vectorY.scaleInPlace(this.globalFractionToCurvature(globalFraction));
-        return _geometry3d_Plane3dByOriginAndVectors__WEBPACK_IMPORTED_MODULE_14__.Plane3dByOriginAndVectors.createCapture(origin, vectorX, vectorY, result);
+        return _geometry3d_Plane3dByOriginAndVectors__WEBPACK_IMPORTED_MODULE_15__.Plane3dByOriginAndVectors.createCapture(origin, vectorX, vectorY, result);
     }
     /** Second step of double dispatch:  call `handler.handleTransitionSpiral(this)`. */
     dispatchToGeometryHandler(handler) {
@@ -228150,9 +228327,13 @@ class AngleSweep {
         result.setStartEndRadians(startRadians, endRadians);
         return result;
     }
-    /** Return the AngleSweep obtained by subtracting radians from the start and end angles of this sweep. */
+    /** Return the AngleSweep obtained by adding `radians` to the start and end angles of this sweep. */
+    clonePlusRadians(radians) {
+        return new AngleSweep(this._radians0 + radians, this._radians1 + radians);
+    }
+    /** Return the AngleSweep obtained by subtracting `radians` from the start and end angles of this sweep. */
     cloneMinusRadians(radians) {
-        return new AngleSweep(this._radians0 - radians, this._radians1 - radians);
+        return this.clonePlusRadians(-radians);
     }
     /** Create an AngleSweep from start and end angles given in degrees. */
     static createStartEndDegrees(startDegrees = 0, endDegrees = 360, result) {
@@ -231517,12 +231698,24 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   GeometryHandler: () => (/* binding */ GeometryHandler),
 /* harmony export */   NullGeometryHandler: () => (/* binding */ NullGeometryHandler),
-/* harmony export */   RecurseToCurvesGeometryHandler: () => (/* binding */ RecurseToCurvesGeometryHandler)
+/* harmony export */   RecurseToCurvesGeometryHandler: () => (/* binding */ RecurseToCurvesGeometryHandler),
+/* harmony export */   UniformStrokeCollector: () => (/* binding */ UniformStrokeCollector)
 /* harmony export */ });
+/* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
+/* harmony import */ var _curve_LineString3d__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../curve/LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _Point3dVector3d__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module ArraysAndInterfaces
+ */
+
+
+
+
 /**
  * `GeometryHandler` defines the base abstract methods for double-dispatch geometry computation.
  * * User code that wants to handle one or all of the commonly known geometry types implements a handler class.
@@ -231795,6 +231988,76 @@ class RecurseToCurvesGeometryHandler extends GeometryHandler {
         return undefined;
     }
 }
+/**
+ * A handler that generates uniformly distributed fractions for stroking a CurvePrimitive.
+ * * [[claimFractions]] returns the fractions
+ * * [[claimLineString]] returns the strokes
+ * @public
+ */
+class UniformStrokeCollector {
+    _curve;
+    _fractions;
+    /** Constructor. Curve is optional and not needed for [[claimFractions]]. */
+    constructor(cp, fractionTol = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.smallFraction) {
+        this._curve = undefined;
+        if (cp)
+            this.startCurvePrimitive(cp);
+        this._fractions = new _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.OrderedSet((a, b) => (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.compareWithTolerance)(a, b, fractionTol));
+    }
+    /** Announce a parent curve primitive (ignored). */
+    startParentCurvePrimitive(_c) { }
+    /** Announce the curve primitive that will be described in subsequent calls. */
+    startCurvePrimitive(cp) {
+        this._curve = cp;
+    }
+    /** Announce a single fraction. */
+    announcePointTangent(_p, f, _v) {
+        this._fractions.add(f);
+    }
+    /** Announce uniformly distributed fractions in the fractional interval. */
+    announceIntervalForUniformStepStrokes(_c, numStrokes, f0, f1) {
+        if (numStrokes < 1)
+            numStrokes = 1;
+        this._fractions.add(f0);
+        const df = 1.0 / numStrokes;
+        for (let i = 1; i < numStrokes; i++)
+            this._fractions.add(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(f0, i * df, f1));
+        this._fractions.add(f1);
+    }
+    /** Request primary geometry to avoid cached strokes. */
+    needPrimaryGeometryForStrokes() {
+        return true;
+    }
+    /** Announce the fractional span of the segment. */
+    announceSegmentInterval(_c, _p0, _p1, _numStrokes, f0, f1) {
+        this._fractions.add(f0);
+        this._fractions.add(f1);
+    }
+    /** Announce that all data about the curve has been announced (ignored). */
+    endCurvePrimitive(_c) { }
+    /** Announce that all data about the parent curve has been announced (ignored). */
+    endParentCurvePrimitive(_c) { }
+    /** Retrieve the collected fractions, optionally removing 0 and 1 first. */
+    claimFractions(remove01 = false) {
+        if (remove01) {
+            this._fractions.delete(0);
+            this._fractions.delete(1);
+        }
+        return [...this._fractions];
+    }
+    /** Create a [[LineString3d]] by evaluating the curve at the collected fractions. */
+    claimLineString(result) {
+        if (!this._curve)
+            return undefined;
+        result ??= _curve_LineString3d__WEBPACK_IMPORTED_MODULE_2__.LineString3d.create();
+        const pt = _Point3dVector3d__WEBPACK_IMPORTED_MODULE_3__.Point3d.create();
+        for (const f of this._fractions) {
+            result.addPoint(this._curve.fractionToPoint(f, pt));
+            result.addFraction(f);
+        }
+        return result;
+    }
+}
 
 
 /***/ }),
@@ -232367,21 +232630,31 @@ class GrowableXYArray extends _IndexedXYCollection__WEBPACK_IMPORTED_MODULE_0__.
     _data;
     /** Number of xy tuples (not floats) in the array. */
     _xyInUse;
-    /** Capacity in xy tuples. (not floats). */
+    /** Capacity in xy tuples (not floats). */
     _xyCapacity;
-    /** Multiplier used by ensureCapacity to expand requested reallocation size. */
+    /** Multiplier used by [[ensureCapacity]] to expand requested reallocation size. */
     _growthFactor;
     /**
-     * Construct a new GrowablePoint2d array.
-     * @param numPoints initial capacity in xy tuples (default 8).
-     * @param growthFactor used by ensureCapacity to expand requested reallocation size (default 1.5).
-     * @param data optional pre-existing Float64Array to use as the backing memory. If supplied, numPoints is ignored.
+     * Construct a new growable array.
+     * @param numPoints initial capacity in xy tuples. Default value is 8.
+     * @param growthFactor used by [[ensureCapacity]] to expand requested reallocation size. Default value is 1.5.
+     * For no expansion, use 1.
+     * @param data optional array to serve as the point source. If `data` is supplied, `numPoints` is reinterpreted as
+     * the initial point count, defaulting to and bounded above by the array's point capacity. If a subsequent [[push]]
+     * would exceed the array's capacity, a new Float64Array of the same buffer type is allocated and filled.
      */
-    constructor(numPoints = 8, growthFactor, data) {
+    constructor(numPoints, growthFactor, data) {
         super();
-        this._data = data || new Float64Array(numPoints * 2); // 2 values per point
-        this._xyInUse = 0;
-        this._xyCapacity = data ? data.length / 2 : numPoints;
+        if (data) {
+            this._xyCapacity = data.length / 2;
+            this._xyInUse = Math.min(numPoints ?? Infinity, this._xyCapacity);
+            this._data = data;
+        }
+        else {
+            this._xyCapacity = numPoints ?? 8;
+            this._xyInUse = 0;
+            this._data = new Float64Array(2 * this._xyCapacity); // 2 values per point
+        }
         this._growthFactor = (undefined !== growthFactor && growthFactor >= 1.0) ? growthFactor : 1.5;
     }
     /**
@@ -233105,19 +233378,29 @@ class GrowableXYZArray extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_0_
     _xyzInUse;
     /** Capacity in xyz triples (not floats). */
     _xyzCapacity;
-    /** Multiplier used by ensureCapacity to expand requested reallocation size. */
+    /** Multiplier used by [[ensureCapacity]] to expand requested reallocation size. */
     _growthFactor;
     /**
-     * Construct a new GrowablePoint3d array.
-     * @param numPoints initial capacity in xyz triples (default 8).
-     * @param growthFactor used by ensureCapacity to expand requested reallocation size (default 1.5).
-     * @param data optional pre-existing Float64Array to use as the backing memory. If supplied, numPoints is ignored.
+     * Construct a new growable array.
+     * @param numPoints initial capacity in xyz tuples. Default value is 8.
+     * @param growthFactor used by [[ensureCapacity]] to expand requested reallocation size. Default value is 1.5.
+     * For no expansion, use 1.
+     * @param data optional array to serve as the point source. If `data` is supplied, `numPoints` is reinterpreted as
+     * the initial point count, defaulting to and bounded above by the array's point capacity. If a subsequent [[push]]
+     * would exceed the array's capacity, a new Float64Array of the same buffer type is allocated and filled.
      */
-    constructor(numPoints = 8, growthFactor, data) {
+    constructor(numPoints, growthFactor, data) {
         super();
-        this._data = data || new Float64Array(numPoints * 3); // 3 values per point
-        this._xyzInUse = 0;
-        this._xyzCapacity = data ? data.length / 3 : numPoints;
+        if (data) {
+            this._xyzCapacity = data.length / 3;
+            this._xyzInUse = Math.min(numPoints ?? Infinity, this._xyzCapacity);
+            this._data = data;
+        }
+        else {
+            this._xyzCapacity = numPoints ?? 8;
+            this._xyzInUse = 0;
+            this._data = new Float64Array(3 * this._xyzCapacity); // 3 values per point
+        }
         this._growthFactor = (undefined !== growthFactor && growthFactor >= 1.0) ? growthFactor : 1.5;
     }
     /**
@@ -233172,7 +233455,7 @@ class GrowableXYZArray extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_0_
         return this._data;
     }
     /**
-     * If necessary, increase the capacity to the new number of points.  Current coordinates and point count (length) are
+     * If necessary, increase the capacity to the new number of points. Current coordinates and point count (length) are
      * unchanged.
      */
     ensureCapacity(pointCapacity, applyGrowthFactor = true) {
@@ -235606,17 +235889,18 @@ class Matrix3d {
         target.setColumn(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.axisOrderToAxis(axisOrder, 0), vectorU);
         target.setColumn(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.axisOrderToAxis(axisOrder, 1), vectorV);
         target.setColumn(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.axisOrderToAxis(axisOrder, 2), vectorW);
+        target.inverseState = InverseMatrixState.unknown;
         return target;
     }
     /**
      * Create a new orthogonal matrix (perpendicular columns, unit length, transpose is inverse).
-     * * `vectorA1 = Normalized vectorA` is placed in the column specified by **first** letter in
+     * * `vectorA1 = Normalized vectorA` is placed in the column specified by the **first** letter in
      * the AxisOrder name.
-     * * Normalized `vectorC1 = vectorA1 cross vectorB` is placed in the column specified by **third**
+     * * Normalized `vectorC1 = vectorA1 cross vectorB` is placed in the column specified by the **third**
      * letter in the AxisOrder name.
-     * * Normalized  `vectorC1 cross vectorA` is placed in the column specified by **second**
+     * * Normalized  `vectorC1 cross vectorA` is placed in the column specified by the **second**
      * letter in the AxisOrder name.
-     * * This function internally uses createShuffledColumns.
+     * * This function internally uses [[createShuffledColumns]].
      */
     static createRigidFromColumns(vectorA, vectorB, axisOrder, result) {
         const vectorA1 = vectorA.normalize();
@@ -252865,7 +253149,7 @@ class UnivariateBezier extends BezierCoffs {
      * that the final iteration will clean it up to nearly machine precision.
      * @returns final fraction of iteration if converged.  undefined if iteration failed to converge.
      */
-    runNewton(startFraction, tolerance = 1.0e-11) {
+    runNewton(startFraction, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallNewtonStep) {
         const derivativeFactor = this.order - 1;
         let numConverged = 0;
         let u = startFraction;
@@ -254434,6 +254718,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   NewtonEvaluatorRRtoRRD: () => (/* binding */ NewtonEvaluatorRRtoRRD),
 /* harmony export */   NewtonEvaluatorRtoR: () => (/* binding */ NewtonEvaluatorRtoR),
 /* harmony export */   NewtonEvaluatorRtoRD: () => (/* binding */ NewtonEvaluatorRtoRD),
+/* harmony export */   NewtonRtoRStrokeHandler: () => (/* binding */ NewtonRtoRStrokeHandler),
 /* harmony export */   SimpleNewton: () => (/* binding */ SimpleNewton)
 /* harmony export */ });
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
@@ -254451,6 +254736,12 @@ __webpack_require__.r(__webpack_exports__);
 
 
 // cspell:word currentdFdX XYRR
+// A note on differences between using derivatives vs. approximate derivatives for Newton:
+// * Converged values are the same under both schemes.
+// * With derivatives, Newton convergence is quadratic rather than power 1.62 with approximate derivatives.
+// * With approximate derivatives:
+//   - the extra iterative cost is incidental for low iteration counts, and may even be offset by simpler computation.
+//   - the step choice is not based on serious analysis, so could be problematic.
 /**
  * Base class for Newton iterations in various dimensions.
  * Dimension-specific classes carry all dimension-related data and answer generalized queries from this base class.
@@ -254464,12 +254755,12 @@ class AbstractNewtonIterator {
      * it is expected that a first "accept" for (say) 10 to 14 digit step will be followed by another
      * iteration. A well behaved newton would then hypothetically double the number of digits to
      * 20 to 28. Since the IEEE double only carries 16 digits, this second-convergence step will
-     * typically achieve full precision.
-     * @param successiveConvergenceTarget number of successive convergences required for acceptance.
+     * typically achieve full precision. Default [[Geometry.smallNewtonStep]].
+     * @param successiveConvergenceTarget number of successive convergences required for acceptance. Default 2.
      * @param maxIterations max number of iterations. A typical newton step converges in 3 to 6 iterations.
-     * Allow 15 to 20 to catch difficult cases.
+     * Allow 15 to 20 to catch difficult cases. Default 15.
      */
-    constructor(stepSizeTolerance = 1.0e-11, successiveConvergenceTarget = 2, maxIterations = 15) {
+    constructor(stepSizeTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallNewtonStep, successiveConvergenceTarget = 2, maxIterations = 15) {
         this._stepSizeTolerance = stepSizeTolerance;
         this._successiveConvergenceTarget = successiveConvergenceTarget;
         this._maxIterations = maxIterations;
@@ -254484,6 +254775,12 @@ class AbstractNewtonIterator {
     _maxIterations;
     /** Number of iterations (incremented at each step). */
     numIterations = 0;
+    /** Get the relative tolerance for comparing iterations in [[testConvergence]]. */
+    get stepSizeTolerance() {
+        return this._stepSizeTolerance;
+    }
+    /** Smallest iterate size difference in later iterations. */
+    _leastDelta = Number.MAX_VALUE;
     /**
      * Test if a step is converged.
      * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance)
@@ -254491,6 +254788,10 @@ class AbstractNewtonIterator {
      * @param delta step size as reported by currentStepSize.
      */
     testConvergence(delta) {
+        if (this.cacheCandidate && delta < this._leastDelta && this.numIterations > 0.5 * this._maxIterations) {
+            this._leastDelta = delta;
+            this.cacheCandidate();
+        }
         if (Math.abs(delta) < this._stepSizeTolerance) {
             this._numAccepted++;
             return this._numAccepted >= this._successiveConvergenceTarget;
@@ -254508,13 +254809,16 @@ class AbstractNewtonIterator {
     runIterations() {
         this._numAccepted = 0;
         this.numIterations = 0;
+        this._leastDelta = Number.MAX_VALUE;
         while (this.numIterations++ < this._maxIterations && this.computeStep()) {
-            if (this.testConvergence(this.currentStepSize()) && this.applyCurrentStep(true)) {
-                // console.log("iter: " + this.numIterations); // print number of Newton iterations for debug
+            if (this.testConvergence(this.currentStepSize())) {
+                this.applyCurrentStep(true);
                 return true;
             }
             this.applyCurrentStep(false);
         }
+        if (this.restoreCandidate && this.numIterations >= this._maxIterations && Math.abs(this.currentStepSize()) > this._leastDelta)
+            this.restoreCandidate(); // we may have ended up in a late cycle; return our best guess
         return false;
     }
 }
@@ -254556,7 +254860,6 @@ class Newton1dUnbounded extends AbstractNewtonIterator {
     /** Set the independent variable, i.e., x_n. */
     setX(x) {
         this._currentX = x;
-        return true;
     }
     /** Get the independent variable, i.e., x_n. */
     getX() {
@@ -254568,8 +254871,7 @@ class Newton1dUnbounded extends AbstractNewtonIterator {
     }
     /** Move the current X by the just-computed step, i.e., `x_n - dx`. */
     applyCurrentStep() {
-        // console.log(this._currentX - this._currentStep); // print approximations for debug
-        return this.setX(this._currentX - this._currentStep);
+        this.setX(this._currentX - this._currentStep);
     }
     /** Compute the univariate newton step dx. */
     computeStep() {
@@ -254595,6 +254897,30 @@ class NewtonEvaluatorRtoR {
     /** Most recent function evaluation, i.e., f(x_n). */
     currentF;
 }
+/**
+ * Intermediate class for managing the parentCurve announcements from an IStrokeHandler.
+ * @internal
+ */
+class NewtonRtoRStrokeHandler extends NewtonEvaluatorRtoR {
+    _parentCurvePrimitive;
+    constructor() {
+        super();
+        this._parentCurvePrimitive = undefined;
+    }
+    /**
+     * Retain the parentCurvePrimitive.
+     * * Calling this method tells the handler that the parent curve is to be used for detail searches.
+     * * Example: Transition spiral search is based on linestring first, then the exact spiral.
+     * * Example: CurveChainWithDistanceIndex does NOT do this announcement; the constituents act independently.
+     */
+    startParentCurvePrimitive(curve) {
+        this._parentCurvePrimitive = curve;
+    }
+    /** Forget the parentCurvePrimitive */
+    endParentCurvePrimitive(_curve) {
+        this._parentCurvePrimitive = undefined;
+    }
+}
 /**
  * Newton iteration for a univariate function, using approximate derivatives.
  * To approximate the derivatives we use a small step `h`, i.e., `f'(x_n) = (f(x_n + h) - f(x_n)) / h`.
@@ -254626,7 +254952,6 @@ class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {
     /** Set the independent variable, i.e., x_n. */
     setX(x) {
         this._currentX = x;
-        return true;
     }
     /** Get the independent variable, i.e., x_n. */
     getX() {
@@ -254634,8 +254959,7 @@ class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {
     }
     /** Move the current X by the just-computed step, i.e., `x_n - dx`. */
     applyCurrentStep() {
-        // console.log(this._currentX - this._currentStep); // print approximations for debug
-        return this.setX(this._currentX - this._currentStep);
+        this.setX(this._currentX - this._currentStep);
     }
     /** Univariate newton step dx, computed with approximate derivative. */
     computeStep() {
@@ -254700,9 +255024,11 @@ class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     /**
      * Constructor for 2D newton iteration with derivatives.
      * @param func function that returns both function value and derivative.
+     * @param maxIterations max number of iterations. Default 15.
+     * @param stepSizeTolerance tolerance to consider a single step converged. Default [[Geometry.smallNewtonStep]].
      */
-    constructor(func, maxIterations) {
-        super(undefined, undefined, maxIterations);
+    constructor(func, maxIterations, stepSizeTolerance) {
+        super(stepSizeTolerance, undefined, maxIterations);
         this._func = func;
         this._currentStep = _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Vector2d.createZero();
         this._currentUV = _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.createZero();
@@ -254710,7 +255036,6 @@ class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     /** Set the current uv parameters, i.e., `X_n = (u_n, v_n)`. */
     setUV(u, v) {
         this._currentUV.set(u, v);
-        return true;
     }
     /** Get the current u parameter of X_n, i.e., u_n. */
     getU() {
@@ -254720,14 +255045,9 @@ class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     getV() {
         return this._currentUV.y;
     }
-    /** Get the relative tolerance for comparing iterations in [[testConvergence]]. */
-    get stepSizeTolerance() {
-        return this._stepSizeTolerance;
-    }
     /** Update the current uv parameter by currentStep, i.e., compute `X_{n+1} := X_n - dX = (u_n - du, v_n - dv)`. */
     applyCurrentStep() {
-        // console.log("(" + (this._currentUV.x - this._currentStep.x) + "," + (this._currentUV.y - this._currentStep.y) + ")");
-        return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y);
+        this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y);
     }
     /**
      * Evaluate the functions and derivatives at `X_n = (u_n, v_n)`, and solve the Jacobian matrix equation to
@@ -254751,6 +255071,20 @@ class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     currentStepSize() {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.maxAbsXY(this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)), this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)));
     }
+    /** Candidate solution cache. */
+    _cachedUV;
+    /** The current late iterate has the least delta encountered. Remember it. */
+    cacheCandidate() {
+        if (this._cachedUV)
+            this._cachedUV.setFrom(this._currentUV);
+        else
+            this._cachedUV = this._currentUV.clone();
+    }
+    /** Set Newton result to the cached candidate. */
+    restoreCandidate() {
+        if (this._cachedUV)
+            this.setUV(this._cachedUV.x, this._cachedUV.y);
+    }
 }
 /**
  * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments
@@ -254770,7 +255104,7 @@ class SimpleNewton {
     static runNewton1D(x, func, derivative, absoluteTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallFloatingPoint) {
         let numConverged = 0;
         let tolerance;
-        const relTol = 1.0e-11;
+        const relTol = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallNewtonStep;
         for (let iteration = 0; iteration < 20; iteration++) {
             const f = func(x);
             const df = derivative(x);
@@ -265344,20 +265678,20 @@ class PolyfaceQuery {
         return -2;
     }
     /**
-   * Test for convex volume by dihedral angle tests on all edges.
-   * * This tests if all dihedral angles of the mesh are positive.
-   * * In a closed solid, this is a strong test for overall mesh convexity with outward facing normals.
-   * * See [[dihedralAngleSummary]] for the definition of "dihedral angle".
-   * * With `ignoreBoundaries` true, this may be a useful test when all the facets are in a single edge-connected
-   * component, such as a pyramid with no underside.
-   * * It is not a correct test if there are multiple, disjoint components.
-   * * Take the above-mentioned pyramid with no underside.
-   * * Within the same mesh, have a second pyramid placed to the side, still facing upward.
-   * * The angles will pass the dihedral convexity test, but the composite thing surely is not convex.
-   * @param source mesh.
-   * @param ignoreBoundaries if `true` ignore simple boundary edges, i.e., allow unclosed meshes. Default is `false`.
-   * @returns true if all dihedral angles of the mesh are positive.
-   */
+     * Test for convex volume by dihedral angle tests on all edges.
+     * * This tests if all dihedral angles of the mesh are positive.
+     * * In a closed solid, this is a strong test for overall mesh convexity with outward facing normals.
+     * * See [[dihedralAngleSummary]] for the definition of "dihedral angle".
+     * * With `ignoreBoundaries` true, this may be a useful test when all the facets are in a single edge-connected
+     * component, such as a pyramid with no underside.
+     * * It is not a correct test if there are multiple, disjoint components.
+     * * Take the above-mentioned pyramid with no underside.
+     * * Within the same mesh, have a second pyramid placed to the side, still facing upward.
+     * * The angles will pass the dihedral convexity test, but the composite thing surely is not convex.
+     * @param source mesh.
+     * @param ignoreBoundaries if `true` ignore simple boundary edges, i.e., allow unclosed meshes. Default is `false`.
+     * @returns true if all dihedral angles of the mesh are positive.
+     */
     static isConvexByDihedralAngleCount(source, ignoreBoundaries = false) {
         return this.dihedralAngleSummary(source, ignoreBoundaries) > 0;
     }
@@ -277047,8 +277381,8 @@ class DgnSpiralTypeQueries {
         [12, "biquadratic"],
         [13, "cosine"],
         [14, "sine"],
-        [15, "Viennese"],
-        [16, "weightedViennese"],
+        [15, "Viennese"], // not supported
+        [16, "weightedViennese"], // not supported
         [50, "WesternAustralian"],
         [51, "Czech"],
         [52, "AustralianRailCorp"],
@@ -284123,7 +284457,7 @@ class HalfEdge {
      * @param bridgeMask mask preset on bridge edges (default is [[HalfEdgeMask.BRIDGE_EDGE]]).
      */
     isSplitWasherFace(bridgeMask = HalfEdgeMask.BRIDGE_EDGE) {
-        if (!this.countMaskAroundFace(HalfEdgeMask.BRIDGE_EDGE))
+        if (!this.countMaskAroundFace(bridgeMask))
             return false;
         const bridges = new _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.OrderedSet((a, b) => a.id - b.id);
         let node = this;
@@ -325418,7 +325752,7 @@ var loadLanguages = instance.loadLanguages;
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.9.0-dev.7","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers && npm run -s copy:draco","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2022 --outDir lib/esm","clean":"rimraf -g lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","copy:draco":"cpx \\"./node_modules/@loaders.gl/draco/dist/libs/*\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts && npm run -s extract","extract":"betools extract --fileExt=ts --extractFrom=./src/test/example-code --recursive --out=../../generated-docs/extract","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","lint-deprecation":"eslint --fix -f visualstudio --no-inline-config -c ../../common/config/eslint/eslint.config.deprecation-policy.js \\"./src/**/*.ts\\"","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@bentley/aec-units-schema":"^1.0.3","@bentley/formats-schema":"^1.0.0","@bentley/units-schema":"^1.0.9","@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*","@itwin/object-storage-core":"^3.0.4","@itwin/eslint-plugin":"^6.0.0","@types/chai-as-promised":"^7","@types/draco3d":"^1.4.10","@types/sinon":"^17.0.2","@vitest/browser":"^3.0.6","@vitest/coverage-v8":"^3.0.6","cpx2":"^8.0.0","eslint":"^9.31.0","glob":"^10.5.0","playwright":"~1.56.1","rimraf":"^6.0.1","sinon":"^17.0.2","source-map-loader":"^5.0.0","typescript":"~5.6.2","vitest":"^3.0.6","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"2.2.0","webpack":"^5.97.1"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"~4.3.4","@loaders.gl/draco":"~4.3.4","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.9.0-dev.9","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers && npm run -s copy:draco","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2022 --outDir lib/esm","clean":"rimraf -g lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","copy:draco":"cpx \\"./node_modules/@loaders.gl/draco/dist/libs/*\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts && npm run -s extract","extract":"betools extract --fileExt=ts --extractFrom=./src/test/example-code --recursive --out=../../generated-docs/extract","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","lint-deprecation":"eslint --fix -f visualstudio --no-inline-config -c ../../common/config/eslint/eslint.config.deprecation-policy.js \\"./src/**/*.ts\\"","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@bentley/aec-units-schema":"^1.0.3","@bentley/formats-schema":"^1.0.0","@bentley/units-schema":"^1.0.9","@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*","@itwin/object-storage-core":"^3.0.4","@itwin/eslint-plugin":"^6.0.0","@types/chai-as-promised":"^7","@types/draco3d":"^1.4.10","@types/sinon":"^17.0.2","@vitest/browser":"^3.0.6","@vitest/coverage-v8":"^3.0.6","cpx2":"^8.0.0","eslint":"^9.31.0","glob":"^10.5.0","playwright":"~1.56.1","rimraf":"^6.0.1","sinon":"^17.0.2","source-map-loader":"^5.0.0","typescript":"~5.6.2","vitest":"^3.0.6","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"2.2.0","webpack":"^5.97.1"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"~4.3.4","@loaders.gl/draco":"~4.3.4","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
 
 /***/ })