@itwin/rpcinterface-full-stack-tests 4.5.0-dev.21 → 4.5.0-dev.23

package/lib/dist/bundled-tests.js

@@ -27695,6 +27695,7 @@ var IModelStatus;
     IModelStatus[IModelStatus["NotRegistered"] = 65605] = "NotRegistered";
     IModelStatus[IModelStatus["FunctionNotFound"] = 65606] = "FunctionNotFound";
     IModelStatus[IModelStatus["NoActiveCommand"] = 65607] = "NoActiveCommand";
+    IModelStatus[IModelStatus["Aborted"] = 65608] = "Aborted";
 })(IModelStatus || (IModelStatus = {}));
 /** Error statuses produced by various briefcase operations, typically encountered as the `errorNumber` of an [IModelError]($common).
  * @public
@@ -32065,7 +32066,10 @@ class StatusCategory {
                 return category;
             }
         }
-        return lookupCategory(error);
+        const errorNumber = error.errorNumber;
+        if (typeof errorNumber === "number")
+            return lookupHttpStatusCategory(errorNumber);
+        return new UnknownError();
     }
 }
 StatusCategory.handlers = new Set();
@@ -32301,8 +32305,10 @@ class UnknownError extends HTTP.InternalServerError {
 }
 class NotImplemented extends HTTP.NotImplemented {
 }
-function lookupCategory(error) {
-    switch (error.errorNumber) {
+class Aborted extends HTTP.BadRequest {
+}
+function lookupHttpStatusCategory(statusCode) {
+    switch (statusCode) {
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.BentleyStatus.SUCCESS: return new Success();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.BentleyStatus.ERROR: return new UnknownError();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.Success: return new Success();
@@ -32376,6 +32382,7 @@ function lookupCategory(error) {
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.NotRegistered: return new NotImplemented();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.FunctionNotFound: return new NotImplemented();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.NoActiveCommand: return new StateViolation();
+        case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.Aborted: return new Aborted();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.BriefcaseStatus.CannotAcquire: return new OperationFailed();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.BriefcaseStatus.CannotDownload: return new OperationFailed();
         case _BentleyError__WEBPACK_IMPORTED_MODULE_0__.BriefcaseStatus.CannotUpload: return new OperationFailed();
@@ -61693,7 +61700,7 @@ class RpcInvocation {
             status.responseValue = rawResult; // for ipc case
             fulfillment.rawResult = status;
         }
-        if (rawResult instanceof _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.BentleyError) {
+        if (rawResult instanceof Error) {
             fulfillment.status = _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.StatusCategory["for"](rawResult).code;
         }
     }
@@ -95044,6 +95051,10 @@ class ViewManager {
             clearTimeout(this._idleWorkTimer);
             this._idleWorkTimer = undefined;
         }
+        this._viewports.map((viewport) => {
+            if (!viewport.isDisposed)
+                this.dropViewport(viewport, true);
+        });
         this._viewports.length = 0;
         this.decorators.length = 0;
         this.toolTipProviders.length = 0;
@@ -207376,7 +207387,7 @@ class MXCubicAlongArcEvaluator extends _CubicEvaluator__WEBPACK_IMPORTED_MODULE_
         super.scaleInPlace(scaleFactor);
     }
     /** return a deep copy of the evaluator */
-    clone() { return new MXCubicAlongArcEvaluator(this.nominalLength1, this.nominalRadius1, super._axisLength, this.cubicM); }
+    clone() { return new MXCubicAlongArcEvaluator(this.nominalLength1, this.nominalRadius1, this.axisLength, this.cubicM); }
     /** Member by member matchup ... */
     isAlmostEqual(other) {
         if (other instanceof MXCubicAlongArcEvaluator) {
@@ -207666,7 +207677,7 @@ class PolishCubicEvaluator extends _CubicEvaluator__WEBPACK_IMPORTED_MODULE_0__.
         super.scaleInPlace(scaleFactor);
     }
     /** return a deep copy of the evaluator */
-    clone() { return new PolishCubicEvaluator(this.nominalLength1, this.nominalRadius1, super._axisLength, this.cubicM); }
+    clone() { return new PolishCubicEvaluator(this.nominalLength1, this.nominalRadius1, this.axisLength, this.cubicM); }
     /** Member by member matchup ... */
     isAlmostEqual(other) {
         if (other instanceof PolishCubicEvaluator) {
@@ -211679,6 +211690,9 @@ class FrameBuilder {
                     break;
             }
         }
+        else if (data.hasOwnProperty("x") && data.hasOwnProperty("y") && data.hasOwnProperty("z")) {
+            this.announcePoint(_Point3dVector3d__WEBPACK_IMPORTED_MODULE_3__.Point3d.create(data.x, data.y, data.z));
+        }
     }
     /**
      * Create a localToWorld frame for the given data.
@@ -213762,7 +213776,7 @@ class GrowableXYZArray extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_0_
         this._xyzInUse = 0;
     }
     /**
-     * Get a point by index, strongly typed as a Point3d.  This is unchecked.  Use getPoint3dAtCheckedPointIndex to have validity test.
+     * Get a point by index, strongly typed as a Point3d.  This is unchecked.  Use [[getPoint3dAtCheckedPointIndex]] to have validity test.
      * @param pointIndex index to access
      * @param result optional result
      */
@@ -213771,7 +213785,7 @@ class GrowableXYZArray extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_0_
         return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Point3d.create(this._data[index], this._data[index + 1], this._data[index + 2], result);
     }
     /**
-     * Get a point by index, strongly typed as a Point2d.  This is unchecked.  Use getPoint2dAtCheckedPointIndex to have validity test.
+     * Get a point by index, strongly typed as a Point2d.  This is unchecked.  Use [[getPoint2dAtCheckedPointIndex]] to have validity test.
      * @param pointIndex index to access
      * @param result optional result
      */
@@ -213779,6 +213793,15 @@ class GrowableXYZArray extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_0_
         const index = 3 * pointIndex;
         return _Point2dVector2d__WEBPACK_IMPORTED_MODULE_3__.Point2d.create(this._data[index], this._data[index + 1], result);
     }
+    /**
+     * Get a vector by index, strongly typed as a Vector3d.  This is unchecked.  Use [[getVector3dAtCheckedVectorIndex]] to have validity test.
+     * @param vectorIndex index to access
+     * @param result optional result
+     */
+    getVector3dAtUncheckedVectorIndex(vectorIndex, result) {
+        const index = 3 * vectorIndex;
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this._data[index], this._data[index + 1], this._data[index + 2], result);
+    }
     /** copy xyz into strongly typed Point3d */
     getPoint3dAtCheckedPointIndex(pointIndex, result) {
         if (this.isIndexValid(pointIndex)) {
@@ -238849,7 +238872,7 @@ class IndexedPolyfaceVisitor extends _PolyfaceData__WEBPACK_IMPORTED_MODULE_0__.
         this._currentFacetIndex = facetIndex;
         this._nextFacetIndex = facetIndex + 1;
         this._numEdges = this._polyface.numEdgeInFacet(facetIndex);
-        this.resizeAllDataArrays(this._numEdges + this._numWrap);
+        this.resizeAllArrays(this._numEdges + this._numWrap);
         this.gatherIndexedData(this._polyface.data, this._polyface.facetIndex0(this._currentFacetIndex), this._polyface.facetIndex1(this._currentFacetIndex), this._numWrap);
         return true;
     }
@@ -239069,6 +239092,7 @@ __webpack_require__.r(__webpack_exports__);
  * @module Polyface
  */
 /* eslint-disable @typescript-eslint/naming-convention, no-empty */
+// cspell:word internaldocs
 
 
 
@@ -239358,10 +239382,10 @@ class IndexedPolyface extends Polyface {
     }
     /**
      * Create an empty facet set with coordinate and index data to be supplied later.
-     * @param needNormals true if normals will be constructed.
-     * @param needParams true if uv parameters will be constructed.
-     * @param needColors true if colors will be constructed.
-     * @param twoSided true if the facets are to be considered viewable from the back.
+     * @param needNormals `true` to allocate empty normal data and index arrays; `false` (default) to leave undefined.
+     * @param needParams `true` to allocate empty uv parameter data and index arrays; `false` (default) to leave undefined.
+     * @param needColors `true` to allocate empty color data and index arrays; `false` (default) to leave undefined.
+     * @param twoSided `true` if the facets are to be considered viewable from the back; `false` (default) if not.
      */
     static create(needNormals = false, needParams = false, needColors = false, twoSided = false) {
         return new IndexedPolyface(new _PolyfaceData__WEBPACK_IMPORTED_MODULE_3__.PolyfaceData(needNormals, needParams, needColors, twoSided));
@@ -239430,19 +239454,19 @@ class IndexedPolyface extends Polyface {
      */
     addNormal(normal, priorIndexA, priorIndexB) {
         // check if `normal` is duplicate of `dataNormal` at index `i`
-        const normalIsDuplicate = (dataNormal, i) => {
-            const distance = dataNormal.distanceIndexToPoint(i, normal);
+        const normalIsDuplicate = (i) => {
+            const distance = this.data.normal.distanceIndexToPoint(i, normal);
             return distance !== undefined && _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.isSmallMetricDistance(distance);
         };
         if (this.data.normal !== undefined) {
-            if (priorIndexA !== undefined && normalIsDuplicate(this.data.normal, priorIndexA))
+            if (priorIndexA !== undefined && normalIsDuplicate(priorIndexA))
                 return priorIndexA;
-            if (priorIndexB !== undefined && normalIsDuplicate(this.data.normal, priorIndexB))
+            if (priorIndexB !== undefined && normalIsDuplicate(priorIndexB))
                 return priorIndexB;
             // check the tail index for possible duplicate
             if (priorIndexA !== undefined || priorIndexB !== undefined) {
                 const tailIndex = this.data.normal.length - 1;
-                if (normalIsDuplicate(this.data.normal, tailIndex))
+                if (normalIsDuplicate(tailIndex))
                     return tailIndex;
             }
         }
@@ -239529,10 +239553,16 @@ class IndexedPolyface extends Polyface {
                 messages.push("colorIndex count must equal pointIndex count");
             if (this.data.edgeVisible.length !== lengthB)
                 messages.push("visibleIndex count must equal pointIndex count");
+            if (!Polyface.areIndicesValid(this.data.pointIndex, lengthA, lengthB, this.data.point, this.data.point ? this.data.point.length : 0))
+                messages.push("invalid point indices in the last facet");
             if (!Polyface.areIndicesValid(this.data.normalIndex, lengthA, lengthB, this.data.normal, this.data.normal ? this.data.normal.length : 0))
                 messages.push("invalid normal indices in the last facet");
+            if (!Polyface.areIndicesValid(this.data.paramIndex, lengthA, lengthB, this.data.param, this.data.param ? this.data.param.length : 0))
+                messages.push("invalid param indices in the last facet");
+            if (!Polyface.areIndicesValid(this.data.colorIndex, lengthA, lengthB, this.data.color, this.data.color ? this.data.color.length : 0))
+                messages.push("invalid color indices in the last facet");
             if (messages.length > 0) {
-                this.data.trimAllIndexArrays(lengthB);
+                this.data.trimAllIndexArrays(lengthA);
                 return messages;
             }
         }
@@ -239776,8 +239806,8 @@ class FacetSector {
      */
     loadIndexedPointAndDerivativeCoordinatesFromPackedArrays(i, packedXYZ, packedDerivatives, fractions, v) {
         packedXYZ.getPoint3dAtCheckedPointIndex(i, this.xyz);
-        if (fractions && v !== undefined)
-            this.uv = _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_1__.Point2d.create(fractions.atUncheckedIndex(i), v);
+        if (this.uv && fractions && v !== undefined)
+            this.uv.set(fractions.atUncheckedIndex(i), v);
         this.xyzIndex = -1;
         this.normalIndex = -1;
         this.uvIndex = -1;
@@ -240462,8 +240492,7 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
                 this.addIndexedTriangleNormalIndexes(sectorA0.normalIndex, sectorA1.normalIndex, sectorA2.normalIndex);
             if (this._options.needParams)
                 this.addIndexedTriangleParamIndexes(sectorA0.uvIndex, sectorA1.uvIndex, sectorA2.uvIndex);
-            this.addIndexedTrianglePointIndexes(sectorA0.xyzIndex, sectorA1.xyzIndex, sectorA2.xyzIndex);
-            this._polyface.terminateFacet();
+            this.addIndexedTrianglePointIndexes(sectorA0.xyzIndex, sectorA1.xyzIndex, sectorA2.xyzIndex, true);
         }
     }
     addSectorQuadA01B01(sectorA0, sectorA1, sectorB0, sectorB1) {
@@ -240479,8 +240508,7 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
                 this.addIndexedQuadNormalIndexes(sectorA0.normalIndex, sectorA1.normalIndex, sectorB0.normalIndex, sectorB1.normalIndex);
             if (this._options.needParams)
                 this.addIndexedQuadParamIndexes(sectorA0.uvIndex, sectorA1.uvIndex, sectorB0.uvIndex, sectorB1.uvIndex);
-            this.addIndexedQuadPointIndexes(sectorA0.xyzIndex, sectorA1.xyzIndex, sectorB0.xyzIndex, sectorB1.xyzIndex);
-            this._polyface.terminateFacet();
+            this.addIndexedQuadPointIndexes(sectorA0.xyzIndex, sectorA1.xyzIndex, sectorB0.xyzIndex, sectorB1.xyzIndex, true);
         }
     }
     /** Add facets between lineStrings with matched point counts.
@@ -240552,14 +240580,14 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
         for (let i = 1; i < numPoints; i++) {
             if (this.options.shouldTriangulate) {
                 if (distinctIndices(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i))) {
-                    this.addIndexedTrianglePointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i));
+                    this.addIndexedTrianglePointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i), false);
                     if (normalA && normalB)
                         this.addIndexedTriangleNormalIndexes(normalA.atUncheckedIndex(i - 1), normalA.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1));
                     if (paramA && paramB)
                         this.addIndexedTriangleParamIndexes(paramA.atUncheckedIndex(i - 1), paramA.atUncheckedIndex(i), paramB.atUncheckedIndex(i - 1));
                 }
                 if (distinctIndices(pointB.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i - 1))) {
-                    this.addIndexedTrianglePointIndexes(pointA.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1));
+                    this.addIndexedTrianglePointIndexes(pointA.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), false);
                     if (normalA && normalB)
                         this.addIndexedTriangleNormalIndexes(normalA.atUncheckedIndex(i - 1), normalB.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1));
                     if (paramA && paramB)
@@ -240568,14 +240596,14 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
             }
             else {
                 if (pointA.atUncheckedIndex(i - 1) !== pointA.atUncheckedIndex(i) || pointB.atUncheckedIndex(i - 1) !== pointB.atUncheckedIndex(i)) {
-                    this.addIndexedQuadPointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i));
+                    this.addIndexedQuadPointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i), false);
                     if (normalA && normalB)
                         this.addIndexedQuadNormalIndexes(normalA.atUncheckedIndex(i - 1), normalA.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1), normalB.atUncheckedIndex(i));
                     if (paramA && paramB)
                         this.addIndexedQuadParamIndexes(paramA.atUncheckedIndex(i - 1), paramA.atUncheckedIndex(i), paramB.atUncheckedIndex(i - 1), paramB.atUncheckedIndex(i));
                 }
-                this._polyface.terminateFacet();
             }
+            this._polyface.terminateFacet();
         }
     }
     /** Add facets between lineStrings with matched point counts.
@@ -241219,11 +241247,14 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
     /** add facets for a GeometryQuery object.   This is double dispatch through `dispatchToGeometryHandler(this)` */
     addGeometryQuery(g) { g.dispatchToGeometryHandler(this); }
     /**
-     *
-     * * Visit all faces
-     * * Test each face with f(node) for any node on the face.
-     * * For each face that passes, pass its coordinates to the builder.
-     * * Rely on the builder's compress step to find common vertex coordinates
+     * Add a graph to the builder.
+     * * Visit one node per face
+     * * If `acceptFaceFunction(node)` returns true, pass face coordinates to the builder
+     * * Accepted face edge visibility is determined by `isEdgeVisibleFunction`.
+     * * Rely on the builder's compress step to find common vertex coordinates.
+     * @param graph faces to add as facets
+     * @param acceptFaceFunction optional test for whether to add a given face. Default: ignore exterior faces
+     * @param isEdgeVisibleFunction optional test for whether to hide an edge. Default: hide interior edges
      * @internal
      */
     addGraph(graph, acceptFaceFunction = (node) => _topology_Graph__WEBPACK_IMPORTED_MODULE_23__.HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => _topology_Graph__WEBPACK_IMPORTED_MODULE_23__.HalfEdge.testMateMaskExterior(node)) {
@@ -241262,7 +241293,7 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
      *  * terminate the facet
      * @internal
      */
-    addGraphFaces(_graph, faces) {
+    addGraphFaces(faces) {
         let index = 0;
         for (const seed of faces) {
             let node = seed;
@@ -241274,21 +241305,26 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
             this._polyface.terminateFacet();
         }
     }
-    /** Create a polyface containing the faces of a HalfEdgeGraph, with test function to filter faces.
+    /**
+     * Create a polyface containing the faces of a HalfEdgeGraph, with test functions to filter faces and hide edges.
+     * * This is a static wrapper of [[addGraph]].
+     * @param graph faces to add as facets
+     * @param acceptFaceFunction optional test for whether to add a given face. Default: ignore exterior faces
+     * @param isEdgeVisibleFunction optional test for whether to hide an edge. Default: hide interior edges
      * @internal
      */
-    static graphToPolyface(graph, options, acceptFaceFunction = (node) => _topology_Graph__WEBPACK_IMPORTED_MODULE_23__.HalfEdge.testNodeMaskNotExterior(node)) {
+    static graphToPolyface(graph, options, acceptFaceFunction = (node) => _topology_Graph__WEBPACK_IMPORTED_MODULE_23__.HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => _topology_Graph__WEBPACK_IMPORTED_MODULE_23__.HalfEdge.testMateMaskExterior(node)) {
         const builder = PolyfaceBuilder.create(options);
-        builder.addGraph(graph, acceptFaceFunction);
+        builder.addGraph(graph, acceptFaceFunction, isEdgeVisibleFunction);
         builder.endFace();
         return builder.claimPolyface();
     }
     /** Create a polyface containing the faces of a HalfEdgeGraph that are specified by the HalfEdge array.
      * @internal
      */
-    static graphFacesToPolyface(graph, faces) {
+    static graphFacesToPolyface(faces) {
         const builder = PolyfaceBuilder.create();
-        builder.addGraphFaces(graph, faces);
+        builder.addGraphFaces(faces);
         builder.endFace();
         return builder.claimPolyface();
     }
@@ -242301,39 +242337,28 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+// cspell:word internaldocs
 /**
- * PolyfaceData carries data arrays for point, normal, param, color and their indices.
- *
- * * IndexedPolyface carries a PolyfaceData as a member. (NOT as a base class -- it already has GeometryQuery as base)
- * * IndexedPolyfaceVisitor uses PolyfaceData as a base class.  In this use there is only a single facet in the polyfaceData.
- * * PolyfaceData does not know (!!!) what indices range constitute a facet.  That is managed by derived class or carrier class.
+ * `PolyfaceData` carries data arrays for point, normal, uv-parameters, and color, and index arrays for each.
+ * * Normal, uv-parameter, and color data are optional.
+ * * A given data array is defined if and only if its corresponding index array is defined.
+ * * All defined index arrays have parallel face loop order and structure, and thus the same length.
+ * * `IndexedPolyface` carries a PolyfaceData as a member (NOT as a base class; it already has `GeometryQuery` as base).
+ * * `IndexedPolyfaceVisitor` uses PolyfaceData as a base class. In this use, there is only a single facet in `PolyfaceData`.
+ * * `PolyfaceData` does not know what index range constitutes a given facet. This is managed by a derived/carrier class.
  * @public
  */
 class PolyfaceData {
-    /** boolean tag indicating if the facets are to be considered viewable from the back */
-    get twoSided() { return this._twoSided; }
-    set twoSided(value) { this._twoSided = value; }
-    /** set the `taggedNumericData` member */
-    setTaggedNumericData(data) {
-        this.taggedNumericData = data;
-    }
     /**
-     * Flag indicating if the mesh closure is unknown (0), open sheet (1), closed solid (2).
-     * * A boundary edge of a mesh is defined as an edge with only one connected facet.
-     * * Closed solid is a mesh with no boundary edge. Open sheet is a mesh that has boundary edge(s).
-     */
-    get expectedClosure() { return this._expectedClosure; }
-    set expectedClosure(value) { this._expectedClosure = value; }
-    /** Constructor for facets.
-     *   * The various params control whether respective arrays are to be allocated.
-     *   * If arrayData is provided, all other params are IGNORED.
-     *   *
+     * Constructor for facets.
+     * @param needNormals `true` to allocate empty normal data and index arrays; `false` (default) to leave undefined.
+     * @param needParams `true` to allocate empty uv parameter data and index arrays; `false` (default) to leave undefined.
+     * @param needColors `true` to allocate empty color data and index arrays; `false` (default) to leave undefined.
+     * @param twoSided `true` if the facets are to be considered viewable from the back; `false` (default) if not.
      */
     constructor(needNormals = false, needParams = false, needColors = false, twoSided = false) {
-        this.face = [];
         this.point = new _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_0__.GrowableXYZArray();
         this.pointIndex = [];
-        this.edgeVisible = [];
         if (needNormals) {
             this.normal = new _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_0__.GrowableXYZArray();
             this.normalIndex = [];
@@ -242346,6 +242371,8 @@ class PolyfaceData {
             this.color = [];
             this.colorIndex = [];
         }
+        this.face = [];
+        this.edgeVisible = [];
         this._twoSided = twoSided;
         this._expectedClosure = 0;
     }
@@ -242354,30 +242381,29 @@ class PolyfaceData {
         const result = new PolyfaceData();
         result.point = this.point.clone();
         result.pointIndex = this.pointIndex.slice();
-        result.edgeVisible = this.edgeVisible.slice();
-        result.face = this.face.slice();
-        result.twoSided = this.twoSided;
-        result.expectedClosure = this.expectedClosure;
         if (this.normal)
             result.normal = this.normal.clone();
-        if (this.param)
-            result.param = this.param.clone();
-        if (this.color)
-            result.color = this.color.slice();
         if (this.normalIndex)
             result.normalIndex = this.normalIndex.slice();
+        if (this.param)
+            result.param = this.param.clone();
         if (this.paramIndex)
             result.paramIndex = this.paramIndex.slice();
+        if (this.color)
+            result.color = this.color.slice();
         if (this.colorIndex)
             result.colorIndex = this.colorIndex.slice();
+        result.face = this.face.slice();
         if (this.auxData)
             result.auxData = this.auxData.clone();
-        if (this.taggedNumericData) {
+        if (this.taggedNumericData)
             result.taggedNumericData = this.taggedNumericData.clone();
-        }
+        result.edgeVisible = this.edgeVisible.slice();
+        result.twoSided = this.twoSided;
+        result.expectedClosure = this.expectedClosure;
         return result;
     }
-    /** Test for equal indices and nearly equal coordinates */
+    /** Test for equal indices and nearly equal coordinates. */
     isAlmostEqual(other) {
         if (!_geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_0__.GrowableXYZArray.isAlmostEqual(this.point, other.point))
             return false;
@@ -242395,77 +242421,133 @@ class PolyfaceData {
             return false;
         if (!_geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_2__.NumberArray.isExactEqual(this.colorIndex, other.colorIndex))
             return false;
-        if (!_geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_2__.NumberArray.isExactEqual(this.edgeVisible, other.edgeVisible))
-            return false;
         if (!_AuxData__WEBPACK_IMPORTED_MODULE_3__.PolyfaceAuxData.isAlmostEqual(this.auxData, other.auxData))
             return false;
+        if (!_TaggedNumericData__WEBPACK_IMPORTED_MODULE_4__.TaggedNumericData.areAlmostEqual(this.taggedNumericData, other.taggedNumericData))
+            return false;
+        if (!_geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_2__.NumberArray.isExactEqual(this.edgeVisible, other.edgeVisible))
+            return false;
         if (this.twoSided !== other.twoSided)
             return false;
         if (this.expectedClosure !== other.expectedClosure)
             return false;
-        if (!_TaggedNumericData__WEBPACK_IMPORTED_MODULE_4__.TaggedNumericData.areAlmostEqual(this.taggedNumericData, other.taggedNumericData))
-            return false;
         return true;
     }
     /** Ask if normals are required in this mesh. */
-    get requireNormals() { return undefined !== this.normal; }
+    get requireNormals() {
+        return undefined !== this.normal;
+    }
+    /** Ask if params are required in this mesh. */
+    get requireParams() {
+        return undefined !== this.param;
+    }
+    /** Ask if colors are required in this mesh. */
+    get requireColors() {
+        return undefined !== this.color;
+    }
     /** Get the point count */
-    get pointCount() { return this.point.length; }
+    get pointCount() {
+        return this.point.length;
+    }
     /** Get the normal count */
-    get normalCount() { return this.normal ? this.normal.length : 0; }
+    get normalCount() {
+        return this.normal ? this.normal.length : 0;
+    }
     /** Get the param count */
-    get paramCount() { return this.param ? this.param.length : 0; }
+    get paramCount() {
+        return this.param ? this.param.length : 0;
+    }
     /** Get the color count */
-    get colorCount() { return this.color ? this.color.length : 0; }
-    /** Get the index count.  Note that there is one count, and all index arrays (point, normal, param, color) must match */
-    get indexCount() { return this.pointIndex.length; } // ALWAYS INDEXED ... all index vectors must have same length.
-    /** Get the number of faces.
+    get colorCount() {
+        return this.color ? this.color.length : 0;
+    }
+    /** Get the index count. Note that the point array is always indexed, and index arrays all have the same length. */
+    get indexCount() {
+        return this.pointIndex.length;
+    }
+    /**
+     * Get the number of faces.
      * * Note that a "face" is not a facet.
-     * * A "face" is a subset of facets grouped for application purposes.
-     */
-    get faceCount() { return this.face.length; }
-    /** return indexed point. This is a copy of the coordinates, not a reference. */
-    getPoint(i, out) {
-        return this.point.getPoint3dAtCheckedPointIndex(i, out);
-    }
-    /** return indexed normal. This is the COPY to the normal, not a reference. */
-    getNormal(i) { return this.normal ? this.normal.getVector3dAtCheckedVectorIndex(i) : undefined; }
-    /** return indexed param. This is the COPY of the coordinates, not a reference. */
-    getParam(i) { return this.param ? this.param.getPoint2dAtCheckedPointIndex(i) : undefined; }
-    /** return indexed color */
-    getColor(i) { return this.color ? this.color[i] : 0; }
-    /** return indexed visibility */
-    getEdgeVisible(i) { return this.edgeVisible[i]; }
-    /** Copy the contents (not pointer) of point[i] into dest. */
-    copyPointTo(i, dest) { this.point.getPoint3dAtUncheckedPointIndex(i, dest); }
-    /** Copy the contents (not pointer) of normal[i] into dest. */
-    copyNormalTo(i, dest) { if (this.normal)
-        this.normal.getVector3dAtCheckedVectorIndex(i, dest); }
-    /** Copy the contents (not pointer) of param[i] into dest. */
-    copyParamTo(i, dest) { if (this.param)
-        this.param.getPoint2dAtCheckedPointIndex(i, dest); }
-    /** test if normal at a specified index matches uv */
-    isAlmostEqualParamIndexUV(index, u, v) {
-        if (this.param !== undefined && index >= 0 && index < this.param.length)
-            return _Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.isSameCoordinate(u, this.param.getXAtUncheckedPointIndex(index))
-                && _Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.isSameCoordinate(v, this.param.getYAtUncheckedPointIndex(index));
+     * * A face is a subset of the Polyface's facets grouped for application purposes.
+     */
+    get faceCount() {
+        return this.face.length;
+    }
+    /** Return indexed point at index `i`. This is a COPY of the coordinates, not a reference. */
+    getPoint(i, result) {
+        return this.point.getPoint3dAtCheckedPointIndex(i, result);
+    }
+    /** Return indexed normal at index `i`. This is a COPY of the normal, not a reference. */
+    getNormal(i, result) {
+        return this.normal ? this.normal.getVector3dAtCheckedVectorIndex(i, result) : undefined;
+    }
+    /** Return indexed param at index `i`. This is a COPY of the coordinates, not a reference. */
+    getParam(i, result) {
+        return this.param ? this.param.getPoint2dAtCheckedPointIndex(i, result) : undefined;
+    }
+    /** Return indexed color at index `i`. Index `i` is not checked for validity. */
+    getColor(i) {
+        return this.color ? this.color[i] : 0;
+    }
+    /** Return indexed visibility. at index `i`. Index `i` is not checked for validity. */
+    getEdgeVisible(i) {
+        return this.edgeVisible[i];
+    }
+    /** Get boolean tag indicating if the facets are to be considered viewable from the back. */
+    get twoSided() {
+        return this._twoSided;
+    }
+    set twoSided(value) {
+        this._twoSided = value;
+    }
+    /** Get flag indicating if the mesh closure is unknown (0), open sheet (1), closed solid (2). */
+    get expectedClosure() {
+        return this._expectedClosure;
+    }
+    set expectedClosure(value) {
+        this._expectedClosure = value;
+    }
+    /** Set the tagged geometry data. */
+    setTaggedNumericData(data) {
+        this.taggedNumericData = data;
+    }
+    /** Copy the contents (not pointer) of `point[i]` into `dest`. Index `i` is not checked for validity. */
+    copyPointTo(i, dest) {
+        this.point.getPoint3dAtUncheckedPointIndex(i, dest);
+    }
+    /** Copy the contents (not pointer) of `normal[i]` into `dest`. Index `i` is not checked for validity. */
+    copyNormalTo(i, dest) {
+        if (this.normal)
+            this.normal.getVector3dAtUncheckedVectorIndex(i, dest);
+    }
+    /** Copy the contents (not pointer) of `param[i]` into `dest`. Index `i` is not checked for validity. */
+    copyParamTo(i, dest) {
+        if (this.param)
+            this.param.getPoint2dAtUncheckedPointIndex(i, dest);
+    }
+    /** Test if param at a index `i` matches the given uv */
+    isAlmostEqualParamIndexUV(i, u, v) {
+        if (this.param !== undefined && i >= 0 && i < this.param.length)
+            return _Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.isSameCoordinate(u, this.param.getXAtUncheckedPointIndex(i))
+                && _Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.isSameCoordinate(v, this.param.getYAtUncheckedPointIndex(i));
         return false;
     }
     /**
-     * * Copy data from other to this.
+     * Copy data from `other` to `this`.
      * * This is the essence of transferring coordinates spread throughout a large polyface into a visitor's single facet.
-     * * "other" is the large polyface
-     * * "this" is the visitor
-     * * does NOT copy face data - visitors reference the FacetFaceData array for the whole polyface!!
+     * * Common usage: "other" is a Polyface, "this" is a PolyfaceVisitor to receive data from a single facet of the Polyface.
+     * * Does NOT copy face data - visitors reference the FacetFaceData array for the whole polyface.
      * @param other polyface data being mined.
-     * @param index0 start index in other's index arrays
-     * @param index1 end index (one beyond last data accessed0 in other's index arrays
+     * @param index0 start index in other's index arrays.
+     * @param index1 end index (one beyond last data accessed) in other's index arrays.
      * @param numWrap number of points to replicate as wraparound.
      */
     gatherIndexedData(other, index0, index1, numWrap) {
         const numEdge = index1 - index0;
+        if (numWrap > numEdge)
+            numWrap = numEdge;
         const numTotal = numEdge + numWrap;
-        this.resizeAllDataArrays(numTotal);
+        this.resizeAllArrays(numTotal);
         // copy wrapped points
         for (let i = 0; i < numEdge; i++)
             this.point.transferFromGrowableXYZArray(i, other.point, other.pointIndex[index0 + i]);
@@ -242476,41 +242558,48 @@ class PolyfaceData {
             this.pointIndex[i] = other.pointIndex[index0 + i];
         for (let i = 0; i < numWrap; i++)
             this.pointIndex[numEdge + i] = this.pointIndex[i];
-        // copy wrapped edge visibility
-        for (let i = 0; i < numEdge; i++)
-            this.edgeVisible[i] = other.edgeVisible[index0 + i];
-        for (let i = 0; i < numWrap; i++)
-            this.edgeVisible[numEdge + i] = this.edgeVisible[i];
+        // copy wrapped normals
         if (this.normal && this.normalIndex && other.normal && other.normalIndex) {
             for (let i = 0; i < numEdge; i++)
                 this.normal.transferFromGrowableXYZArray(i, other.normal, other.normalIndex[index0 + i]);
             for (let i = 0; i < numWrap; i++)
                 this.normal.transferFromGrowableXYZArray(numEdge + i, this.normal, i);
+            // copy wrapped normalIndex
             for (let i = 0; i < numEdge; i++)
                 this.normalIndex[i] = other.normalIndex[index0 + i];
             for (let i = 0; i < numWrap; i++)
                 this.normalIndex[numEdge + i] = this.normalIndex[i];
         }
+        // copy wrapped params
         if (this.param && this.paramIndex && other.param && other.paramIndex) {
             for (let i = 0; i < numEdge; i++)
                 this.param.transferFromGrowableXYArray(i, other.param, other.paramIndex[index0 + i]);
             for (let i = 0; i < numWrap; i++)
                 this.param.transferFromGrowableXYArray(numEdge + i, this.param, i);
+            // copy wrapped paramIndex
             for (let i = 0; i < numEdge; i++)
                 this.paramIndex[i] = other.paramIndex[index0 + i];
             for (let i = 0; i < numWrap; i++)
                 this.paramIndex[numEdge + i] = this.paramIndex[i];
         }
+        // copy wrapped colors
         if (this.color && this.colorIndex && other.color && other.colorIndex) {
             for (let i = 0; i < numEdge; i++)
                 this.color[i] = other.color[other.colorIndex[index0 + i]];
             for (let i = 0; i < numWrap; i++)
                 this.color[numEdge + i] = this.color[i];
+            // copy wrapped colorIndex
             for (let i = 0; i < numEdge; i++)
                 this.colorIndex[i] = other.colorIndex[index0 + i];
             for (let i = 0; i < numWrap; i++)
                 this.colorIndex[numEdge + i] = this.colorIndex[i];
         }
+        // copy wrapped edge visibility
+        for (let i = 0; i < numEdge; i++)
+            this.edgeVisible[i] = other.edgeVisible[index0 + i];
+        for (let i = 0; i < numWrap; i++)
+            this.edgeVisible[numEdge + i] = this.edgeVisible[i];
+        // copy wrapped auxData
         if (this.auxData && other.auxData && this.auxData.channels.length === other.auxData.channels.length) {
             for (let iChannel = 0; iChannel < this.auxData.channels.length; iChannel++) {
                 const thisChannel = this.auxData.channels[iChannel];
@@ -242527,19 +242616,21 @@ class PolyfaceData {
                     }
                 }
             }
+            // copy wrapped auxData index
             for (let i = 0; i < numEdge; i++)
                 this.auxData.indices[i] = other.auxData.indices[index0 + i];
             for (let i = 0; i < numWrap; i++)
                 this.auxData.indices[numEdge + i] = this.auxData.indices[i];
         }
     }
+    /** Trim the `data` arrays to the stated `length`. */
     static trimArray(data, length) {
         if (data && length < data.length)
             data.length = length;
     }
     /**
-     * Trim all index arrays to the stated length.
-     * This is called by PolyfaceBuilder to clean up after an aborted construction sequence.
+     * Trim all index arrays to the stated `length`.
+     * * This is called by PolyfaceBuilder to clean up after an aborted construction sequence.
      */
     trimAllIndexArrays(length) {
         PolyfaceData.trimArray(this.pointIndex, length);
@@ -242555,7 +242646,78 @@ class PolyfaceData {
             }
         }
     }
-    /** Resize all data arrays to specified length */
+    /**
+     * Resize all data and index arrays to the specified `length`.
+     * * This is used by visitors, whose data and index arrays are all parallel.
+     */
+    resizeAllArrays(length) {
+        if (length > this.point.length) {
+            while (this.point.length < length)
+                this.point.push(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create());
+            while (this.pointIndex.length < length)
+                this.pointIndex.push(-1);
+            if (this.normal)
+                while (this.normal.length < length)
+                    this.normal.push(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create());
+            if (this.normalIndex)
+                while (this.normalIndex.length < length)
+                    this.normalIndex.push(-1);
+            if (this.param)
+                while (this.param.length < length)
+                    this.param.push(_geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_7__.Point2d.create());
+            if (this.paramIndex)
+                while (this.paramIndex.length < length)
+                    this.paramIndex.push(-1);
+            if (this.color)
+                while (this.color.length < length)
+                    this.color.push(0);
+            if (this.colorIndex)
+                while (this.colorIndex.length < length)
+                    this.colorIndex.push(-1);
+            while (this.edgeVisible.length < length)
+                this.edgeVisible.push(false);
+            if (this.auxData) {
+                for (const channel of this.auxData.channels) {
+                    for (const channelData of channel.data) {
+                        while (channelData.values.length < length * channel.entriesPerValue)
+                            channelData.values.push(0);
+                    }
+                }
+                if (this.auxData.indices)
+                    this.auxData.indices.push(-1);
+            }
+        }
+        else if (length < this.point.length) {
+            this.point.resize(length);
+            this.pointIndex.length = length;
+            if (this.normal)
+                this.normal.resize(length);
+            if (this.normalIndex)
+                this.normalIndex.length = length;
+            if (this.param)
+                this.param.resize(length);
+            if (this.paramIndex)
+                this.paramIndex.length = length;
+            if (this.color)
+                this.color.length = length;
+            if (this.colorIndex)
+                this.colorIndex.length = length;
+            this.edgeVisible.length = length;
+            if (this.auxData) {
+                for (const channel of this.auxData.channels) {
+                    for (const channelData of channel.data) {
+                        channelData.values.length = length * channel.entriesPerValue;
+                    }
+                }
+                if (this.auxData.indices)
+                    this.auxData.indices.length = length;
+            }
+        }
+    }
+    /**
+     * Resize all data arrays to the specified `length`.
+     * @deprecated in 4.x because name is misleading. Call [[PolyfaceData.resizeAllArrays]] instead.
+     */
     resizeAllDataArrays(length) {
         if (length > this.point.length) {
             while (this.point.length < length)
@@ -242601,19 +242763,21 @@ class PolyfaceData {
             }
         }
     }
-    /** Return the range of the point array (optionally transformed) */
+    /** Return the range of the point array (optionally transformed). */
     range(result, transform) {
         result = result ? result : _geometry3d_Range__WEBPACK_IMPORTED_MODULE_8__.Range3d.createNull();
         result.extendArray(this.point, transform);
         return result;
     }
-    /** reverse indices facet-by-facet, with the given facetStartIndex array delimiting faces.
-     *
-     * * facetStartIndex[0] == 0 always -- start of facet zero.
-     * * facet k has indices from facetStartIndex[k] <= i < facetStartIndex[k+1]
-     * * hence for "internal" k, facetStartIndex[k] is both the upper limit of facet k-1 and the start of facet k.
-     * *
-     */
+    /**
+     * Reverse the indices for the specified facets in the index arrays (pointIndex, normalIndex, paramIndex, colorIndex,
+     * and edgeVisible).
+     * @param facetStartIndex start indices of *consecutive* facets to be reversed.
+     * * Consecutive indices in this array define where a given facet is represented in each of the parallel index arrays.
+     * * The indices for facet k are `facetStartIndex[k]` up to (but not including) `facetStartIndex[k + 1]`.
+     * * This implies `facetStartIndex[k + 1]` is both the upper limit of facet k's indices, and the start index of facet k+1.
+     * * For example, passing an IndexedPolyface's _facetStart array into this method reverses every facet.
+    */
     reverseIndices(facetStartIndex) {
         if (facetStartIndex && PolyfaceData.isValidFacetStartIndexArray(facetStartIndex)) {
             PolyfaceData.reverseIndices(facetStartIndex, this.pointIndex, true);
@@ -242626,31 +242790,33 @@ class PolyfaceData {
             PolyfaceData.reverseIndices(facetStartIndex, this.edgeVisible, false);
         }
     }
-    /** reverse indices facet-by-facet, with the given facetStartIndex array delimiting faces.
-     *
-     * * facetStartIndex[0] == 0 always -- start of facet zero.
-     * * facet k has indices from facetStartIndex[k] <= i < facetStartIndex[k+1]
-     * * hence for "internal" k, facetStartIndex[k] is both the upper limit of facet k-1 and the start of facet k.
-     * *
+    /**
+     * Reverse the indices for the specified facet in the index arrays (pointIndex, normalIndex, paramIndex, colorIndex,
+     * and edgeVisible).
+     * @param facetIndex index of the facet to reverse. The entries of each index array to be reversed are found at
+     * `facetStartIndex[facetIndex] <= i < facetStartIndex[facetIndex + 1]`.
+     * @param facetStartIndex start indices of *consecutive* facets, e.g., an IndexedPolyface's _facetStart array.
+     * See [[reverseIndices]].
      */
-    reverseIndicesSingleFacet(facetId, facetStartIndex) {
-        PolyfaceData.reverseIndicesSingleFacet(facetId, facetStartIndex, this.pointIndex, true);
+    reverseIndicesSingleFacet(facetIndex, facetStartIndex) {
+        PolyfaceData.reverseIndicesSingleFacet(facetIndex, facetStartIndex, this.pointIndex, true);
         if (this.normalIndex !== this.pointIndex)
-            PolyfaceData.reverseIndicesSingleFacet(facetId, facetStartIndex, this.normalIndex, true);
+            PolyfaceData.reverseIndicesSingleFacet(facetIndex, facetStartIndex, this.normalIndex, true);
         if (this.paramIndex !== this.pointIndex)
-            PolyfaceData.reverseIndicesSingleFacet(facetId, facetStartIndex, this.paramIndex, true);
+            PolyfaceData.reverseIndicesSingleFacet(facetIndex, facetStartIndex, this.paramIndex, true);
         if (this.colorIndex !== this.pointIndex)
-            PolyfaceData.reverseIndicesSingleFacet(facetId, facetStartIndex, this.colorIndex, true);
-        PolyfaceData.reverseIndicesSingleFacet(facetId, facetStartIndex, this.edgeVisible, false);
+            PolyfaceData.reverseIndicesSingleFacet(facetIndex, facetStartIndex, this.colorIndex, true);
+        PolyfaceData.reverseIndicesSingleFacet(facetIndex, facetStartIndex, this.edgeVisible, false);
     }
-    /** Scale all the normals by -1 */
+    /** Scale all the normals by -1. */
     reverseNormals() {
         if (this.normal)
             this.normal.scaleInPlace(-1.0);
     }
-    /** Apply `transform` to point and normal arrays and to auxData.
-     * * IMPORTANT This base class is just a data carrier.  It does not know if the index order and normal directions have special meaning.
-     * * i.e. caller must separately reverse index order and normal direction if needed.
+    /**
+     * Apply `transform` to point and normal arrays and to auxData.
+     * * IMPORTANT This base class is just a data carrier. It does not know if the index order and normal directions
+     * have special meaning, i.e., caller must separately reverse index order and normal direction if needed.
      */
     tryTransformInPlace(transform) {
         this.point.multiplyTransformInPlace(transform);
@@ -242663,13 +242829,14 @@ class PolyfaceData {
      * * Search for duplicates within points, normals, params, and colors.
      * * Compress each data array.
      * * Revise all indexing for the relocated data.
-     * @param tolerance optional tolerance for clustering mesh vertices. Default is [[Geometry.smallMetricDistance]].
+     * @param tolerance (optional) tolerance for clustering mesh vertices. Default is [[Geometry.smallMetricDistance]].
      */
     compress(tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.smallMetricDistance) {
+        // more info can be found at geometry/internaldocs/Polyface.md
         const packedPoints = _numerics_ClusterableArray__WEBPACK_IMPORTED_MODULE_9__.ClusterableArray.clusterGrowablePoint3dArray(this.point, tolerance);
         this.point = packedPoints.growablePackedPoints;
         packedPoints.updateIndices(this.pointIndex);
-        // for now, normals, params, and colors use the default tolerance for clustering...
+        // for now, normals, params, and colors use the default tolerance for clustering
         if (this.normalIndex && this.normal) {
             const packedNormals = _numerics_ClusterableArray__WEBPACK_IMPORTED_MODULE_9__.ClusterableArray.clusterGrowablePoint3dArray(this.normal);
             this.normal = packedNormals.growablePackedPoints;
@@ -242687,10 +242854,11 @@ class PolyfaceData {
         }
     }
     /**
-     * Test if facetStartIndex is (minimally!) valid:
-     * * length must be nonzero (recall that for "no facets" the facetStartIndexArray still must contain a 0)
+     * Test if `facetStartIndex` is (minimally) valid.
+     * * Length must be nonzero (recall that for "no facets", the `facetStartIndex` array still must contain a 0).
      * * Each entry must be strictly smaller than the one that follows.
-     * @param facetStartIndex array of facetStart data.  facet `i` has indices at `facetsStartIndex[i]` to (one before) `facetStartIndex[i+1]`
+     * @param facetStartIndex start indices of all facets. Facet k starts at facetStartIndex[k] up to (but not including)
+     * `facetStartIndex[k + 1]`
      */
     static isValidFacetStartIndexArray(facetStartIndex) {
         // facetStartIndex for empty facets has a single entry "0" -- empty array is not allowed
@@ -242701,8 +242869,14 @@ class PolyfaceData {
                 return false;
         return true;
     }
-    /** Reverse data in entire facet indexing arrays.
-     * * parameterized over type T so non-number data -- e.g. boolean visibility flags -- can be reversed.
+    /**
+     * Reverse the indices for the specified facets in the given index array.
+     * * Parameterized over type T so non-number data (e.g., boolean visibility flags) can be reversed.
+     * @param facetStartIndex start indices of *consecutive* facets to be reversed, e.g., an IndexedPolyface's _facetStart
+     * array. See the non-static [[reverseIndices]].
+     * @param indices the index array, e.g., pointIndex, normalIndex, etc.
+     * @param preserveStart `true` to preserve the start index of each facet (e.g., facet [1,2,3,4] becomes [1,4,3,2]);
+     * `false` to reverse all indices (e.g., facet [1,2,3,4] becomes [4,3,2,1]).
      */
     static reverseIndices(facetStartIndex, indices, preserveStart) {
         if (!indices || indices.length === 0)
@@ -242712,8 +242886,7 @@ class PolyfaceData {
                 for (let i = 0; i + 1 < facetStartIndex.length; i++) {
                     let index0 = facetStartIndex[i];
                     let index1 = facetStartIndex[i + 1];
-                    if (preserveStart) {
-                        // leave [index0] as is so reversed facet starts at same vertex
+                    if (preserveStart) { // leave "index0" as is so reversed facet starts at same vertex
                         while (index1 > index0 + 2) {
                             index1--;
                             index0++;
@@ -242722,8 +242895,7 @@ class PolyfaceData {
                             indices[index1] = a;
                         }
                     }
-                    else {
-                        // reverse all
+                    else { // reverse all
                         while (index1 > index0 + 1) {
                             index1--;
                             const a = indices[index0];
@@ -242738,19 +242910,26 @@ class PolyfaceData {
         }
         return false;
     }
-    /** Reverse data in entire facet indexing arrays.
-     * * parameterized over type T so non-number data -- e.g. boolean visibility flags -- can be reversed.
+    /**
+     * Reverse the indices for the specified facet in the specified index array.
+     * * Parameterized over type T so non-number data (e.g., boolean visibility flags) can be reversed.
+     * @param facetIndex index of the facet to reverse. The entries of `indices` to be reversed are found at
+     * `facetStartIndex[facetIndex] <= i < facetStartIndex[facetIndex + 1]`.
+     * @param facetStartIndex start indices of *consecutive* facets, e.g., an IndexedPolyface's _facetStart array.
+     * See [[reverseIndices]].
+     * @param indices the index array, e.g., pointIndex, normalIndex, etc.
+     * @param preserveStart `true` to preserve the start index of each facet (e.g., facet [1,2,3,4] becomes [1,4,3,2]);
+     * `false` to reverse all indices (e.g., facet [1,2,3,4] becomes [4,3,2,1]).
      */
-    static reverseIndicesSingleFacet(facetId, facetStartIndex, indices, preserveStart) {
+    static reverseIndicesSingleFacet(facetIndex, facetStartIndex, indices, preserveStart) {
         if (!indices || indices.length === 0)
             return true; // empty case
         if (indices.length > 0) {
             if (facetStartIndex[facetStartIndex.length - 1] === indices.length
-                && facetId >= 0 && facetId + 1 < facetStartIndex.length) {
-                let index0 = facetStartIndex[facetId];
-                let index1 = facetStartIndex[facetId + 1];
-                if (preserveStart) {
-                    // leave [index0] as is so reversed facet starts at same vertex
+                && facetIndex >= 0 && facetIndex + 1 < facetStartIndex.length) {
+                let index0 = facetStartIndex[facetIndex];
+                let index1 = facetStartIndex[facetIndex + 1];
+                if (preserveStart) { // leave "index0" as is so reversed facet starts at same vertex
                     while (index1 > index0 + 2) {
                         index1--;
                         index0++;
@@ -242759,8 +242938,7 @@ class PolyfaceData {
                         indices[index1] = a;
                     }
                 }
-                else {
-                    // reverse all
+                else { // reverse all
                     while (index1 > index0 + 1) {
                         index1--;
                         const a = indices[index0];
@@ -242775,18 +242953,10 @@ class PolyfaceData {
         return false;
     }
 }
-// <ul
-// <li>optional arrays (normal, uv, color) must be indicated at constructor time.
-// <li>all arrays are (independently) indexed.
-// <li>with regret, the point, param, normal, and color arrays are exposed publicly.
-// <li>getX methods are "trusting" -- no bounds check
-// <li>getX methods return references to X.
-// <li> EXCEPT -- for optional arrays, the return 000.
-// <li>copyX methods move data to caller-supplied result..
-// </ul>
-/** Relative tolerance used in tests for planar facets
+/**
+ * Relative tolerance used in tests for planar facets.
  * @internal
- */
+*/
 PolyfaceData.planarityLocalRelTol = 1.0e-13;
 
 
@@ -263761,7 +263931,6 @@ class HalfEdgeGraph {
     }
     /** Returns the number of vertex loops in a graph structure. */
     countVertexLoops() {
-        this.clearMask(HalfEdgeMask.VISITED);
         let count = 0;
         this.announceVertexLoops((_graph, _seed) => {
             count++;
@@ -263771,7 +263940,6 @@ class HalfEdgeGraph {
     }
     /** Returns the number of face loops in a graph structure. */
     countFaceLoops() {
-        this.clearMask(HalfEdgeMask.VISITED);
         let count = 0;
         this.announceFaceLoops((_graph, _seed) => {
             count++;
@@ -263781,7 +263949,6 @@ class HalfEdgeGraph {
     }
     /** Returns the number of face loops satisfying a filter function with mask argument. */
     countFaceLoopsWithMaskFilter(filter, mask) {
-        this.clearMask(HalfEdgeMask.VISITED);
         let count = 0;
         this.announceFaceLoops((_graph, seed) => {
             if (filter(seed, mask))
@@ -267120,14 +267287,15 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "Triangulator": () => (/* binding */ Triangulator)
 /* harmony export */ });
-/* harmony import */ var _clipping_ClipUtils__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../clipping/ClipUtils */ "../../core/geometry/lib/esm/clipping/ClipUtils.js");
+/* harmony import */ var _clipping_ClipUtils__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../clipping/ClipUtils */ "../../core/geometry/lib/esm/clipping/ClipUtils.js");
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
-/* harmony import */ var _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../geometry3d/IndexedXYZCollection */ "../../core/geometry/lib/esm/geometry3d/IndexedXYZCollection.js");
-/* harmony import */ var _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../geometry3d/Plane3dByOriginAndUnitNormal */ "../../core/geometry/lib/esm/geometry3d/Plane3dByOriginAndUnitNormal.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_FrameBuilder__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../geometry3d/FrameBuilder */ "../../core/geometry/lib/esm/geometry3d/FrameBuilder.js");
+/* harmony import */ var _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../geometry3d/IndexedXYZCollection */ "../../core/geometry/lib/esm/geometry3d/IndexedXYZCollection.js");
+/* harmony import */ var _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../geometry3d/Plane3dByOriginAndUnitNormal */ "../../core/geometry/lib/esm/geometry3d/Plane3dByOriginAndUnitNormal.js");
+/* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
 /* harmony import */ var _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../geometry3d/PointHelpers */ "../../core/geometry/lib/esm/geometry3d/PointHelpers.js");
-/* harmony import */ var _geometry3d_PointStreaming__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../geometry3d/PointStreaming */ "../../core/geometry/lib/esm/geometry3d/PointStreaming.js");
-/* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
+/* harmony import */ var _geometry3d_PointStreaming__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../geometry3d/PointStreaming */ "../../core/geometry/lib/esm/geometry3d/PointStreaming.js");
+/* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
 /* harmony import */ var _Graph__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Graph */ "../../core/geometry/lib/esm/topology/Graph.js");
 /* harmony import */ var _HalfEdgeMarkSet__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./HalfEdgeMarkSet */ "../../core/geometry/lib/esm/topology/HalfEdgeMarkSet.js");
 /* harmony import */ var _InsertAndRetriangulateContext__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./InsertAndRetriangulateContext */ "../../core/geometry/lib/esm/topology/InsertAndRetriangulateContext.js");
@@ -267149,6 +267317,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 /**
  * (static) methods for triangulating polygons
  * * @internal
@@ -267361,7 +267530,10 @@ class Triangulator {
         return undefined;
     }
     /**
-     * Triangulate all positive area faces of a graph.
+     * Triangulate all positive area faces of a (planar) graph.
+     * * Area is computed using `HalfEdge.signedFaceArea`, which ignores z-coordinates.
+     * @returns whether all indicated faces were triangulated successfully
+     * @see [[triangulateAllInteriorFaces]]
      */
     static triangulateAllPositiveAreaFaces(graph) {
         const seeds = graph.collectFaceLoops();
@@ -267376,6 +267548,44 @@ class Triangulator {
         }
         return numFail === 0;
     }
+    /**
+     * Triangulate all interior faces of a graph.
+     * * A random node is checked for each face; if it has the `HalfEdgeMask.EXTERIOR` mask, the face is ignored.
+     * @param useLocalCoords whether to transform each face into local coords before triangulating.
+     * This is useful if the graph has z-coordinates.
+     * @returns whether all indicated faces were triangulated successfully
+     * @see [[triangulateAllPositiveAreaFaces]]
+     */
+    static triangulateAllInteriorFaces(graph, useLocalCoords) {
+        const seeds = graph.collectFaceLoops();
+        const visited = useLocalCoords ? graph.grabMask() : _Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdgeMask.NULL_MASK;
+        let localToWorld;
+        let nodes;
+        let nodeCount = 0;
+        let numFail = 0;
+        for (const face of seeds) {
+            if (face.countEdgesAroundFace() > 3) {
+                if (face.getMask(_Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdgeMask.EXTERIOR))
+                    continue;
+                if (useLocalCoords) {
+                    nodeCount = graph.countNodes();
+                    nodes = face.collectAroundFace();
+                    localToWorld = this._workTransform = _geometry3d_FrameBuilder__WEBPACK_IMPORTED_MODULE_5__.FrameBuilder.createRightHandedLocalToWorld(nodes, this._workTransform);
+                    localToWorld?.multiplyInversePoint3dArrayInPlace(nodes);
+                }
+                // don't flip triangles if using local coords; an edge of this face can be flipped out of plane if the neighboring triangle is non-coplanar.
+                if (!Triangulator.triangulateSingleFace(graph, face, useLocalCoords))
+                    numFail++;
+                if (localToWorld && nodes) {
+                    for (let iNewNode = nodeCount; iNewNode < graph.countNodes(); ++iNewNode)
+                        nodes.push(graph.allHalfEdges[iNewNode]);
+                    localToWorld.multiplyPoint3dArrayInPlace(nodes);
+                }
+            }
+        }
+        graph.dropMask(visited);
+        return numFail === 0;
+    }
     /**
      * Triangulate the polygon made up of by a series of points.
      * * The loop may be either CCW or CW -- CCW order will be used for triangles.
@@ -267424,7 +267634,7 @@ class Triangulator {
         let n = data.length;
         let x0, y0, x1, y1;
         while (n > 1) {
-            if (data instanceof _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_5__.IndexedXYZCollection) {
+            if (data instanceof _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_6__.IndexedXYZCollection) {
                 x0 = data.getXAtUncheckedPointIndex(0);
                 y0 = data.getYAtUncheckedPointIndex(0);
                 x1 = data.getXAtUncheckedPointIndex(n - 1);
@@ -267456,8 +267666,8 @@ class Triangulator {
     static directCreateFaceLoopFromCoordinates(graph, data) {
         const n = this.getUnwrappedLength(data); // open it up to allow starting at a bridge edge
         let baseNode;
-        if (data instanceof _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_5__.IndexedXYZCollection) {
-            const xyz = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
+        if (data instanceof _geometry3d_IndexedXYZCollection__WEBPACK_IMPORTED_MODULE_6__.IndexedXYZCollection) {
+            const xyz = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
             for (let i = 0; i < n; i++) {
                 data.getPoint3dAtCheckedPointIndex(i, xyz);
                 baseNode = Triangulator.interiorEdgeSplit(graph, baseNode, xyz);
@@ -267478,7 +267688,7 @@ class Triangulator {
      */
     static directCreateChainsFromCoordinates(graph, data, id = 0) {
         const assembler = new AssembleXYZXYZChains(graph, id);
-        _geometry3d_PointStreaming__WEBPACK_IMPORTED_MODULE_7__.VariantPointDataStream.streamXYZ(data, assembler);
+        _geometry3d_PointStreaming__WEBPACK_IMPORTED_MODULE_8__.VariantPointDataStream.streamXYZ(data, assembler);
         return assembler.claimSeeds();
     }
     /**
@@ -267604,14 +267814,12 @@ class Triangulator {
         return b0;
     }
     /**
-     * main ear slicing loop which triangulates a polygon (given as a linked list)
-     * While there still exists ear nodes that have not yet been triangulated...
-     *
-     * *  Check if the ear is hashed, and can easily be split off. If so, "join" that ear.
-     * *  If not hashed, move on to a separate ear.
-     * *  If no ears are currently hashed, attempt to cure self intersections or split the polygon into two before continuing
+     * Main ear slicing loop which triangulates the face starting at `ear`.
+     * @param graph containing graph to receive new edges
+     * @param ear sector at which to start triangulation of the containing face.
+     * @param noFlips if false (default) perform edge-flipping after each ear cut for better aspect ratio. Pass true if your graph isn't planar.
      */
-    static triangulateSingleFace(graph, ear) {
+    static triangulateSingleFace(graph, ear, noFlips = false) {
         if (!ear) {
             Triangulator.setDebugGraph(graph);
             return false;
@@ -267662,7 +267870,8 @@ class Triangulator {
                 // If we already have a separated triangle, do not join
                 if (ear.faceSuccessor.faceSuccessor !== ear.facePredecessor) {
                     Triangulator.joinNeighborsOfEar(graph, ear);
-                    ear = Triangulator.doPostCutFlips(ear);
+                    if (!noFlips)
+                        ear = Triangulator.doPostCutFlips(ear);
                     ear = ear.faceSuccessor.edgeMate.faceSuccessor;
                     // another step?   Nate's 2017 code went one more.
                 }
@@ -267726,15 +267935,15 @@ class Triangulator {
         if (area <= 0)
             return false; // reflex, can't be an ear
         const planes = this._planes;
-        if (!_geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__.Plane3dByOriginAndUnitNormal.createOriginAndTargetXY(a, b, planes[0])
-            || !_geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__.Plane3dByOriginAndUnitNormal.createOriginAndTargetXY(b, c, planes[1])
-            || !_geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__.Plane3dByOriginAndUnitNormal.createOriginAndTargetXY(c, a, planes[2]))
+        if (!_geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__.Plane3dByOriginAndUnitNormal.createOriginAndTargetXY(a, b, planes[0])
+            || !_geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__.Plane3dByOriginAndUnitNormal.createOriginAndTargetXY(b, c, planes[1])
+            || !_geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__.Plane3dByOriginAndUnitNormal.createOriginAndTargetXY(c, a, planes[2]))
             return false;
         // now make sure we don't have other points inside the potential ear, or edges crossing.
         const earRange = this._earRange;
         const edgeRange = this._edgeRange;
         const edgeInterval = this._edgeInterval;
-        _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__.Range2d.createXYXYXY(a.x, a.y, b.x, b.y, c.x, c.y, earRange);
+        _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__.Range2d.createXYXYXY(a.x, a.y, b.x, b.y, c.x, c.y, earRange);
         earRange.expandInPlace(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.smallMetricDistance);
         let p = c;
         const zeroPlus = 1.0e-8;
@@ -267744,11 +267953,11 @@ class Triangulator {
         const clipTolerance = 1.0e-10 * area;
         while (p !== a) {
             const q = p.faceSuccessor;
-            _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__.Range2d.createXYXY(p.x, p.y, q.x, q.y, edgeRange);
+            _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__.Range2d.createXYXY(p.x, p.y, q.x, q.y, edgeRange);
             if (earRange.intersectsRange(edgeRange)) {
                 // Does pq impinge on the triangle abc?
-                _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__.Range1d.createXX(zeroMinus, onePlus, edgeInterval);
-                _clipping_ClipUtils__WEBPACK_IMPORTED_MODULE_10__.ClipUtilities.clipSegmentBelowPlanesXY(planes, p, q, edgeInterval, clipTolerance);
+                _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__.Range1d.createXX(zeroMinus, onePlus, edgeInterval);
+                _clipping_ClipUtils__WEBPACK_IMPORTED_MODULE_11__.ClipUtilities.clipSegmentBelowPlanesXY(planes, p, q, edgeInterval, clipTolerance);
                 if (!edgeInterval.isNull) {
                     if (edgeInterval.low > oneMinus) {
                         // only q touches triangle abc, so b might still be an ear if q lies at a vertex
@@ -268076,20 +268285,20 @@ class Triangulator {
 /** @internal */
 Triangulator.sEnableDebugGraphCapture = false;
 // for reuse over all calls to isEar ....
-Triangulator._edgeInterval = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__.Range1d.createNull();
-Triangulator._earRange = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__.Range2d.createNull();
-Triangulator._edgeRange = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_9__.Range2d.createNull();
+Triangulator._edgeInterval = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__.Range1d.createNull();
+Triangulator._earRange = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__.Range2d.createNull();
+Triangulator._edgeRange = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_10__.Range2d.createNull();
 Triangulator._planes = [
-    _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__.Plane3dByOriginAndUnitNormal.createXYPlane(),
-    _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__.Plane3dByOriginAndUnitNormal.createXYPlane(),
-    _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_8__.Plane3dByOriginAndUnitNormal.createXYPlane(),
+    _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__.Plane3dByOriginAndUnitNormal.createXYPlane(),
+    _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__.Plane3dByOriginAndUnitNormal.createXYPlane(),
+    _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_9__.Plane3dByOriginAndUnitNormal.createXYPlane(),
 ];
 
 /**
  * Internal class for assembling chains
  * @internal
  */
-class AssembleXYZXYZChains extends _geometry3d_PointStreaming__WEBPACK_IMPORTED_MODULE_7__.PointStreamXYZXYZHandlerBase {
+class AssembleXYZXYZChains extends _geometry3d_PointStreaming__WEBPACK_IMPORTED_MODULE_8__.PointStreamXYZXYZHandlerBase {
     constructor(graph, id) {
         super();
         this._graph = graph;
@@ -288859,7 +289068,7 @@ class TestContext {
         this.initializeRpcInterfaces({ title: this.settings.Backend.name, version: this.settings.Backend.version });
         const iModelClient = new imodels_client_management_1.IModelsClient({ api: { baseUrl: `https://${process.env.IMJS_URL_PREFIX ?? ""}api.bentley.com/imodels` } });
         await core_frontend_1.NoRenderApp.startup({
-            applicationVersion: "4.5.0-dev.21",
+            applicationVersion: "4.5.0-dev.23",
             applicationId: this.settings.gprid,
             authorizationClient: new frontend_1.TestFrontendAuthorizationClient(this.adminUserAccessToken),
             hubAccess: new imodels_access_frontend_1.FrontendIModelsAccess(iModelClient),
@@ -308182,7 +308391,7 @@ module.exports = JSON.parse('{"name":"axios","version":"0.21.4","description":"P
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"4.5.0-dev.21","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","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 ES2020 --outDir lib/esm","clean":"rimraf 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","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","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:^4.5.0-dev.21","@itwin/core-bentley":"workspace:^4.5.0-dev.21","@itwin/core-common":"workspace:^4.5.0-dev.21","@itwin/core-geometry":"workspace:^4.5.0-dev.21","@itwin/core-orbitgt":"workspace:^4.5.0-dev.21","@itwin/core-quantity":"workspace:^4.5.0-dev.21"},"//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":{"@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/certa":"workspace:*","@itwin/eslint-plugin":"4.0.0-dev.44","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/mocha":"^10.0.6","@types/sinon":"^17.0.2","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.3.10","chai-as-promised":"^7.1.1","cpx2":"^3.0.0","eslint":"^8.44.0","glob":"^7.1.2","mocha":"^10.2.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^17.0.1","source-map-loader":"^4.0.0","typescript":"~5.0.2","typemoq":"^2.1.0","webpack":"^5.76.0"},"//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/cloud-agnostic-core":"^2.1.0","@itwin/object-storage-core":"^2.2.2","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"}}');
+module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"4.5.0-dev.23","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","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 ES2020 --outDir lib/esm","clean":"rimraf 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","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","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:^4.5.0-dev.23","@itwin/core-bentley":"workspace:^4.5.0-dev.23","@itwin/core-common":"workspace:^4.5.0-dev.23","@itwin/core-geometry":"workspace:^4.5.0-dev.23","@itwin/core-orbitgt":"workspace:^4.5.0-dev.23","@itwin/core-quantity":"workspace:^4.5.0-dev.23"},"//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":{"@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/certa":"workspace:*","@itwin/eslint-plugin":"4.0.0-dev.44","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/mocha":"^10.0.6","@types/sinon":"^17.0.2","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.3.10","chai-as-promised":"^7.1.1","cpx2":"^3.0.0","eslint":"^8.44.0","glob":"^7.1.2","mocha":"^10.2.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^17.0.1","source-map-loader":"^4.0.0","typescript":"~5.0.2","typemoq":"^2.1.0","webpack":"^5.76.0"},"//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/cloud-agnostic-core":"^2.1.0","@itwin/object-storage-core":"^2.2.2","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"}}');
 
 /***/ }),