@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/AP214E3_2010/ap214_geometry_extraction.js

@@ -4,10 +4,110 @@ import { ObjectPool } from "../core/native_pool.js";
 import { MemoizationCapture, RegressionCaptureState } from "../core/regression_capture_state.js";
 import { ExtractResult } from "../core/shared_constants.js";
 import Logger from "../logging/logger.js";
-import { advanced_brep_shape_representation, advanced_face, annotation_occurrence, axis2_placement_2d, axis2_placement_3d, b_spline_curve, b_spline_curve_with_knots, b_spline_surface, b_spline_surface_with_knots, boolean_result, cartesian_point, cartesian_transformation_operator_3d, circle, colour_rgb, composite_curve, composite_curve_segment, conical_surface, context_dependent_shape_representation, conversion_based_unit, cylindrical_surface, draughting_model, edge_curve, edge_loop, ellipse, extruded_area_solid, face, face_based_surface_model, faceted_brep, fill_area_style_colour, geometric_curve_set, geometrically_bounded_2d_wireframe_representation, geometrically_bounded_wireframe_shape_representation, global_unit_assigned_context, half_space_solid, item_defined_transformation, length_unit, line, manifold_solid_brep, mapped_item, next_assembly_usage_occurrence, over_riding_styled_item, parameter_value, pcurve, placement, plane, poly_loop, polyline, presentation_layer_assignment, product, product_definition, product_definition_shape, property_definition, rational_b_spline_curve, rational_b_spline_surface, representation_item, representation_relationship_with_transformation, seam_curve, shape_definition_representation, shape_representation, shape_representation_relationship, shell_based_surface_model, si_prefix, si_unit, spherical_surface, styled_item, surface_curve, surface_of_linear_extrusion, surface_of_revolution, surface_side, surface_style_fill_area, surface_style_rendering, surface_style_usage, toroidal_surface, trimmed_curve, trimming_preference, vertex_loop, vertex_point, view_volume, } from "./AP214E3_2010_gen/index.js";
+import { arrayToWasmHeap, wasmHeapView } from "../core/wasm_heap.js";
+import { advanced_brep_shape_representation, advanced_face, annotation_occurrence, axis2_placement_2d, axis2_placement_3d, b_spline_curve, b_spline_curve_with_knots, b_spline_surface, b_spline_surface_with_knots, boolean_result, cartesian_point, cartesian_transformation_operator_3d, circle, colour_rgb, composite_curve, composite_curve_segment, conical_surface, context_dependent_shape_representation, conversion_based_unit, curve, cylindrical_surface, draughting_model, edge_curve, edge_loop, ellipse, extruded_area_solid, face, face_based_surface_model, faceted_brep, fill_area_style_colour, geometric_curve_set, geometrically_bounded_2d_wireframe_representation, geometrically_bounded_wireframe_shape_representation, global_unit_assigned_context, half_space_solid, item_defined_transformation, length_unit, line, manifold_solid_brep, mapped_item, next_assembly_usage_occurrence, over_riding_styled_item, parameter_value, pcurve, placement, plane, poly_loop, polyline, pre_defined_colour, presentation_layer_assignment, product, product_definition, product_definition_shape, property_definition, rational_b_spline_curve, rational_b_spline_surface, representation_item, representation_relationship_with_transformation, shape_definition_representation, shape_representation, shape_representation_relationship, shell_based_surface_model, si_prefix, si_unit, spherical_surface, styled_item, surface_curve, surface_of_linear_extrusion, surface_of_revolution, surface_side, surface_style_fill_area, surface_style_rendering, surface_style_usage, toroidal_surface, trimmed_curve, trimming_preference, vertex_loop, vertex_point, view_volume, } from "./AP214E3_2010_gen/index.js";
 import EntityTypesAP214 from "./AP214E3_2010_gen/entity_types_ap214.gen.js";
 import { AP214ProductShapeMap } from "./ap214_product_shape_map.js";
 import { AP214SceneBuilder } from "./ap214_scene_builder.js";
+// Fewest points a bound can have and still span a plane, which is what
+// GetBasisFromCoplanarPoints needs downstream.
+const MINIMUM_BOUND_POINTS = 3;
+// Ceiling on how finely one span of a pcurve's parameter curve is sampled
+// when it is pushed through an angular surface parameterization. Nothing in
+// STEP bounds how far a parameter curve may run in u or v - a helix wound a
+// thousand times is a legal (if unusual) parameter-space line - and without a
+// cap the sample count is a function of file content rather than of the
+// extractor. At circleSegments density this is over twenty full turns of a
+// single span - well past the point where the polyline is the limiting
+// factor on any face it bounds.
+const MAXIMUM_PCURVE_SPAN_SAMPLES = 256;
+/**
+ * Whether an edge's vertices are the basis curve's own endpoints, making its
+ * trim a no-op that spans the whole curve.
+ *
+ * Only B-splines are considered. A LINE or CIRCLE has no endpoint entities to
+ * compare against — a circle is unbounded parametrically, and a line's trim is
+ * what gives it extent at all — so "whole curve" does not apply to them and
+ * their trims must be resolved.
+ *
+ * Compared by entity localID, not by coordinates: the file references the
+ * same CARTESIAN_POINT from both the control point list and the VERTEX_POINT,
+ * so this is exact and needs no tolerance.
+ *
+ * localID rather than object identity, deliberately. `===` looks equivalent
+ * and is not: getTypedElementByLocalID caches instances only while
+ * model.elementMemoization holds, and extraction turns it off for
+ * lowMemoryMode or a buffer over MEMOIZATION_THRESHOLD. StepModelBase says so
+ * outright — "it's not guaranteed element objects returned from this have
+ * referential equality even if they have ID equality". With `===` this guard
+ * would quietly stop firing on exactly the large models where a dropped face
+ * costs most.
+ *
+ * @param basisCurve The edge's underlying geometry.
+ * @param edgeStart The edge's start vertex.
+ * @param edgeEnd The edge's end vertex.
+ * @return {boolean} True when the edge covers the entire basis curve.
+ */
+function isWholeCurveEdge(basisCurve, edgeStart, edgeEnd) {
+    if (!(edgeStart instanceof vertex_point) ||
+        !(edgeEnd instanceof vertex_point)) {
+        return false;
+    }
+    // An edge from a vertex back to ITSELF spans the whole of its basis curve:
+    // that is how STEP writes a closed edge, and trimming a circle by one point
+    // taken twice is how a torus's equator circles were resolving to a single
+    // point - which starved the revolution face of every angular sample it had
+    // and collapsed the swept surface flat (conway#461). The caller's gates make
+    // this safe for an open basis curve too: recovery only replaces the trimmed
+    // result when it was already degenerate AND the untrimmed extraction yields
+    // more points, and an identical-vertex edge over an open curve is degenerate
+    // whichever way it is read.
+    if (edgeStart.vertex_geometry.localID === edgeEnd.vertex_geometry.localID) {
+        return true;
+    }
+    if (!(basisCurve instanceof b_spline_curve)) {
+        return false;
+    }
+    const controlPoints = basisCurve.control_points_list;
+    if (controlPoints.length < 2) {
+        return false;
+    }
+    const first = controlPoints[0].localID;
+    const last = controlPoints[controlPoints.length - 1].localID;
+    const from = edgeStart.vertex_geometry.localID;
+    const to = edgeEnd.vertex_geometry.localID;
+    // Either orientation: same_sense is normalised separately, and an edge
+    // running end -> start still spans the whole curve. A closed curve whose
+    // first and last control points coincide also lands here, which is correct
+    // — that edge is the whole curve too.
+    return (from === first && to === last) || (from === last && to === first);
+}
+/**
+ * Render something thrown that is not an Error, for a log message.
+ *
+ * Interpolating a thrown value straight into a template string is how the
+ * public baseline ended up with 8 rows reading `[object Object]` — a message
+ * that names the face type and then says nothing about the failure. JSON
+ * first so a plain thrown object shows its fields; String() as the fallback
+ * for what JSON cannot take (cycles, BigInt, symbols).
+ *
+ * @param thrown The caught value, known not to be an Error.
+ * @return {string} A description with at least as much information as String().
+ */
+function describeThrown(thrown) {
+    try {
+        const asJson = JSON.stringify(thrown);
+        // undefined for a symbol or a bare undefined; "{}" for an object whose
+        // own properties are all non-enumerable, which is no better than String().
+        if (asJson !== void 0 && asJson !== "{}") {
+            return asJson;
+        }
+    }
+    catch {
+        // Cyclic, BigInt, or a throwing toJSON - fall through.
+    }
+    return String(thrown);
+}
 /**
  * Extract an AP214 Colour into our RGBA color, using premultiplied alpha.
  *
@@ -21,6 +121,19 @@ import { AP214SceneBuilder } from "./ap214_scene_builder.js";
 export function extractColorRGBPremultiplied(from, alpha = 1) {
     return [from.red * alpha, from.green * alpha, from.blue * alpha, alpha];
 }
+// RGB values for the ISO 10303-46 pre-defined draughting colour names
+// (draughting_pre_defined_colour / pre_defined_colour), which carry a name
+// instead of components.
+const PRE_DEFINED_COLOUR_RGB = {
+    "red": [1, 0, 0],
+    "green": [0, 1, 0],
+    "blue": [0, 0, 1],
+    "yellow": [1, 1, 0],
+    "magenta": [1, 0, 1],
+    "cyan": [0, 1, 1],
+    "black": [0, 0, 0],
+    "white": [1, 1, 1],
+};
 /**
  * Extract an AP214 Colour into our RGBA color.
  *
@@ -59,16 +172,6 @@ export function extractColorOrFactor(from, surfaceColor, alpha = 1) {
  * Can export to OBJ, GLTF (Draco), GLB (Draco)
  */
 export class AP214GeometryExtraction {
-    /**
-     * Construct a geometry extraction from an AP214 step model and conway model
-     *
-     * @param conwayModel
-     * @param model
-     * @param limitCSGDepth Whether to limit the depth of CSG operations.
-     * @param csgDepthLimit The maximum depth for CSG operations when limit CSG depth is used,
-     * or the maximum level for CSG memoization if it is not.
-     * @param lowMemoryMode Whether to enable low memory mode for geometry extraction.
-     */
     constructor(conwayModel, model, limitCSGDepth = true, csgDepthLimit = 20, lowMemoryMode = false) {
         this.conwayModel = conwayModel;
         this.model = model;
@@ -88,7 +191,9 @@ export class AP214GeometryExtraction {
          * Statistics by the loader/proxies after extraction.
          */
         this.geometryTypeCounts = new Map();
+        this.demandCursor_ = 0;
         this.csgMemoization = !this.lowMemoryMode;
+        this.quietRecoverableLogging = false;
         this.materials = model.materials;
         this.scene = new AP214SceneBuilder(model, conwayModel, this.materials);
         this.productShapeMap = new AP214ProductShapeMap();
@@ -508,14 +613,7 @@ export class AP214GeometryExtraction {
      * @return {number} Pointer/memory address
      */
     arrayToWasmHeap(array) {
-        // Allocate memory for the array within the Wasm module
-        const bytesPerElement = array.BYTES_PER_ELEMENT;
-        const numBytes = array.length * bytesPerElement;
-        const arrayPtr = this.wasmModule._malloc(numBytes);
-        // Create a new Uint8Array view on the Wasm memory buffer, then set the array to it
-        const arrayWasm = new Uint8Array(this.wasmModule.HEAPU8.buffer, arrayPtr, numBytes);
-        arrayWasm.set(new Uint8Array(array.buffer));
-        return arrayPtr;
+        return arrayToWasmHeap(this.wasmModule, array);
     }
     /**
      * @param array
@@ -791,18 +889,39 @@ export class AP214GeometryExtraction {
                         const fillAreaColor = fillAreaStyles.find((value => value instanceof fill_area_style_colour));
                         if (fillAreaColor !== void 0) {
                             try {
-                                const fillColor = fillAreaColor.fill_colour;
-                                if (!(fillColor instanceof colour_rgb)) {
+                                // `fill_colour` is the schema's colour select, but AP214
+                                // gives pre_defined_colour TWO supertypes (colour AND
+                                // pre_defined_item) and the single-inheritance generator
+                                // kept only pre_defined_item — so the typed getter throws
+                                // "incorrectly typed" for e.g.
+                                // DRAUGHTING_PRE_DEFINED_COLOUR('white') (Onshape exports).
+                                // Re-extract the same field (offset 1) under the type the
+                                // generator did keep, and map the name to RGB.
+                                let surfaceColor;
+                                let fillColor;
+                                try {
+                                    fillColor = fillAreaColor.fill_colour;
+                                }
+                                catch {
+                                    const preDefined = fillAreaColor.extractElement(1, 0, 0, true, pre_defined_colour);
+                                    const rgb = PRE_DEFINED_COLOUR_RGB[preDefined?.name?.toLowerCase() ?? ""];
+                                    if (rgb !== void 0) {
+                                        surfaceColor = [rgb[0], rgb[1], rgb[2], 1];
+                                    }
+                                }
+                                if (fillColor instanceof colour_rgb) {
+                                    surfaceColor = extractColorRGBPremultiplied(fillColor, 1);
+                                }
+                                if (surfaceColor === void 0) {
                                     continue;
                                 }
-                                const surfaceColor = extractColorRGBPremultiplied(fillColor, 1);
                                 newMaterial.baseColor = surfaceColor;
                                 newMaterial.legacyColor = surfaceColor;
                                 newMaterial.roughness = 1;
                             }
                             catch (error) {
-                                Logger.warning(`Error extracting fill area style color for expressID: 
-                  #${from.expressID} - type: 
+                                Logger.warning(`Error extracting fill area style color for expressID:
+                  #${from.expressID} - type:
                   ${EntityTypesAP214[style.type]} - error: ${error}`);
                             }
                         }
@@ -994,9 +1113,18 @@ export class AP214GeometryExtraction {
      */
     extractCurve(from, parentSense = true, isEdge = false, trimmingArguments = void 0) {
         let stepCurve;
-        stepCurve = this.curves.get(from.localID);
-        if (stepCurve !== void 0) {
-            return stepCurve;
+        // Edge-supplied trims are specific to one EDGE_CURVE, but `from` is the
+        // shared basis curve — memoising a trimmed extraction under the basis
+        // curve's localID would hand the first edge's arc to every other edge
+        // sharing that curve. Trimmed extractions are memoised by the caller
+        // under the EDGE_CURVE's localID instead (see extractAdvancedFace);
+        // untrimmed extractions stay memoised here.
+        const hasEdgeTrims = trimmingArguments?.exist === true;
+        if (!hasEdgeTrims) {
+            stepCurve = this.curves.get(from.localID);
+            if (stepCurve !== void 0) {
+                return stepCurve;
+            }
         }
         // console.log("[extractCurve]: curve express ID: "
         // + from.expressID + " type: " + EntityTypesAP214[from.type])
@@ -1090,9 +1218,16 @@ export class AP214GeometryExtraction {
             stepCurve = this.extractCurve(parentCurve, sameSense, isEdge);
         }
         else if (from instanceof pcurve) {
-            const seamCurve = from.findVariant(seam_curve);
-            if (seamCurve !== void 0) {
-                stepCurve = this.extractCurve(seamCurve.curve_3d, parentSense, isEdge, trimmingArguments);
+            // An explicit 3D representation beats the parameter-space mapping where
+            // one is carried, as it already does for surface_curve and seam_curve
+            // reached in their own right. surface_curve rather than seam_curve:
+            // seam_curve and intersection_curve are both its subtypes and all three
+            // carry curve_3d, so this is the same preference over the whole family
+            // (bldrs-ai/conway#505).
+            const surfaceCurve = from.findVariant(surface_curve);
+            if (surfaceCurve !== void 0) {
+                stepCurve =
+                    this.extractCurve(surfaceCurve.curve_3d, parentSense, isEdge, trimmingArguments);
             }
             else {
                 stepCurve = this.extractPScurve1(from);
@@ -1102,7 +1237,9 @@ export class AP214GeometryExtraction {
             Logger.warning(`Unsupported Curve! Type: ${EntityTypesAP214[from.type]}`);
             return;
         }
-        this.curves.add(from.localID, stepCurve);
+        if (!hasEdgeTrims) {
+            this.curves.add(from.localID, stepCurve);
+        }
         return stepCurve;
     }
     /**
@@ -1150,36 +1287,232 @@ export class AP214GeometryExtraction {
         return compositeCurve;
     }
     /**
+     * The ISO 10303-42 parameterization of an elementary basis surface,
+     * expressed in that surface's placement-local frame. Writing C for the
+     * placement's origin, x/y/z for its axes, R (and r) for the radii and a for
+     * conical_surface.semi_angle, the standard's forms are
+     *
+     *   plane        s(u,v) = C + u x + v y
+     *   cylindrical  s(u,v) = C + R((cos u) x + (sin u) y) + v z
+     *   conical      s(u,v) = C + (R + v tan a)((cos u) x + (sin u) y) + v z
+     *   spherical    s(u,v) = C + R cos v ((cos u) x + (sin u) y) + R sin v z
+     *   toroidal     s(u,v) = C + (R + r cos v)((cos u) x + (sin u) y)
+     *                           + r sin v z
+     *
+     * Note v on a sphere is a LATITUDE in [-90, 90] degrees, not a polar angle,
+     * and v on a torus runs around the tube. Those four are quoted here from the
+     * entities IFC adopted verbatim from this part - IfcPlane,
+     * IfcCylindricalSurface, IfcSphericalSurface and IfcToroidalSurface, each
+     * carrying its equation under "Definition according to ISO/CD 10303-42" plus
+     * "Entity adapted from <name> defined in ISO 10303-42".
+     *
+     * The cone is the one worth stating explicitly, because it is the arm a
+     * review of this code read the other way (bldrs-ai/conway#520): its v is
+     * distance along the AXIS, so the radius grows by tan a per unit v - not
+     * distance along the generator, which would grow it by sin a. Two STEP readers
+     * settle it the same way. Open CASCADE parameterizes its own
+     * Geom_ConicalSurface along the generator, P(u,v) = O + (R + v sin a)(...)
+     * + v cos a z, and therefore rescales v by 1/cos(a) coming in from STEP and
+     * by cos(a) going back out - GeomConvert_Units::DegreeToRadian and
+     * ::RadianToDegree, which is exactly the path its STEP reader pushes pcurves
+     * through (StepToTopoDS_TranslateEdge::MakePCurve). truck's STEP reader
+     * builds the cone by revolving the line (R,0,0) + t (tan a, 0, 1), which is
+     * the form above with t = v.
+     *
+     * conway-geom tessellates the same surfaces by inverting these formulae:
+     * TriangulateCylindricalSurface, TriangulateSphericalSurface,
+     * TriangulateConicalSurface and TriangulateToroidalSurface (conway-geom
+     * `conway_geometry/operations/mesh_utils.h`) recover (theta, height) or
+     * (theta, latitude) from world points, so a pcurve mapped here lands on the
+     * same surface the face it bounds is triangulated on. It differs in one
+     * deliberate way, on the cone's sign - see that arm.
+     *
+     * Angular parameters are radians taken straight from the file. Conway
+     * applies no plane-angle unit conversion anywhere on the STEP path -
+     * conical_surface.semi_angle reaches conway-geom raw in
+     * extractConicalSurface - so a degree-unit export is wrong here in exactly
+     * the same way, and consistently so.
+     *
+     * @param from The basis surface.
+     * @return {SurfaceParameterization | undefined} The parameterization, or
+     * undefined for a surface that has none here (b-spline and swept surfaces).
+     */
+    surfaceParameterization(from) {
+        if (from instanceof plane) {
+            // The one non-angular case: (u, v) are distances along the placement's
+            // x and y axes.
+            return {
+                position: from.position,
+                evaluate: (u, v) => ({ x: u, y: v, z: 0 }),
+                angularU: false,
+                angularV: false,
+            };
+        }
+        if (from instanceof cylindrical_surface) {
+            const radius = from.radius;
+            return {
+                position: from.position,
+                evaluate: (u, v) => ({ x: radius * Math.cos(u), y: radius * Math.sin(u), z: v }),
+                angularU: true,
+                angularV: false,
+            };
+        }
+        if (from instanceof conical_surface) {
+            const radius = from.radius;
+            // tan, not sin, because v is axial distance rather than distance along
+            // the generator - see the equations in this method's doc comment.
+            //
+            // Signed, unlike the native tesselator's tan(fabs(semi_angle)): that
+            // one fits its generator line from boundary samples and only needs the
+            // taper's magnitude, whereas the 2D curve here was authored against the
+            // spec's parameterization, where the radius grows with v by the SIGNED
+            // taper and a narrowing cone runs the other way.
+            const taper = Math.tan(from.semi_angle);
+            return {
+                position: from.position,
+                evaluate: (u, v) => {
+                    const ring = radius + (v * taper);
+                    return { x: ring * Math.cos(u), y: ring * Math.sin(u), z: v };
+                },
+                angularU: true,
+                angularV: false,
+            };
+        }
+        if (from instanceof spherical_surface) {
+            const radius = from.radius;
+            return {
+                position: from.position,
+                evaluate: (u, v) => {
+                    const ring = radius * Math.cos(v);
+                    return {
+                        x: ring * Math.cos(u),
+                        y: ring * Math.sin(u),
+                        z: radius * Math.sin(v),
+                    };
+                },
+                angularU: true,
+                angularV: true,
+            };
+        }
+        // Covers degenerate_toroidal_surface, which is a subtype and shares the
+        // parameterization (it only restricts the range v is meaningful over).
+        if (from instanceof toroidal_surface) {
+            const majorRadius = from.major_radius;
+            const minorRadius = from.minor_radius;
+            return {
+                position: from.position,
+                evaluate: (u, v) => {
+                    const ring = majorRadius + (minorRadius * Math.cos(v));
+                    return {
+                        x: ring * Math.cos(u),
+                        y: ring * Math.sin(u),
+                        z: minorRadius * Math.sin(v),
+                    };
+                },
+                angularU: true,
+                angularV: true,
+            };
+        }
+        return void 0;
+    }
+    /**
+     * Extract a pcurve: a curve given in the parameter space of a basis surface
+     * (ISO 10303-42). The parameter curve is extracted through the ordinary
+     * curve path and its (u, v) samples are pushed through the basis surface's
+     * parameterization, giving the 3D polyline every other arm of extractCurve
+     * hands back.
      *
-     * @param from
-     * @return {CurveObject | undefined}
+     * Extent comes from the parameter curve itself: a bounded one (polyline,
+     * b-spline, trimmed or composite curve) carries its own, and an unbounded
+     * 2D LINE or CIRCLE gets whatever the ordinary line/circle extraction gives
+     * it. An EDGE_CURVE's vertex trims are 3D and are deliberately NOT inverted
+     * back into parameter space here, so an edge whose parameter curve is an
+     * unbounded LINE comes out at that line's own extent rather than the edge's
+     * - see https://github.com/bldrs-ai/conway/issues/505.
+     *
+     * @param from The pcurve to extract.
+     * @return {CurveObject | undefined} The mapped 3D curve, or undefined where
+     * the basis surface has no parameterization here or the parameter curve
+     * yields no points. Both are warned about naming the type responsible, so
+     * the residue is measurable per surface family rather than as one row.
      */
     extractPScurve1(from) {
-        const surface = from.basis_surface;
-        if (!(surface instanceof plane)) {
-            Logger.error("PSCurve not a plane, other curves unsupported");
+        const basisSurface = from.basis_surface;
+        const parameterization = this.surfaceParameterization(basisSurface);
+        if (parameterization === void 0) {
+            Logger.warning("Unsupported PCURVE basis surface, type: " +
+                `${EntityTypesAP214[basisSurface.type]}`, from.expressID);
             return;
         }
-        const point = surface.position.location.coordinates;
-        const dim = point.length;
-        const pointsFlattened = new Float32Array(dim * 1);
-        pointsFlattened[0] = point[0];
-        pointsFlattened[1] = point[1];
-        if (dim > 2) {
-            pointsFlattened[2] = point[2];
-            // pointsFlattened[ 3 ] = point[ 0 ] + ( dir[ 0 ] * mag )
-            // pointsFlattened[ 4 ] = point[ 1 ] + ( dir[ 1 ] * mag )
-            // pointsFlattened[ 5 ] = point[ 2 ] + ( dir[ 2 ] * mag )
+        // ISO 10303-42 constrains reference_to_curve to a single curve item in a
+        // 2D parametric context, but the field is a general representation, so
+        // the curve is searched for rather than indexed blindly.
+        const parameterCurveItem = from.reference_to_curve.items.find((item) => item instanceof curve);
+        if (parameterCurveItem === void 0) {
+            Logger.warning("PCURVE reference_to_curve carries no curve item", from.expressID);
+            return;
         }
-        else {
-            // pointsFlattened[ 2 ] = point[ 0 ] + ( dir[ 0 ] * mag )
-            // pointsFlattened[ 3 ] = point[ 1 ] + ( dir[ 1 ] * mag )
+        const parameterCurve = this.extractCurve(parameterCurveItem);
+        const parameterCount = parameterCurve?.getPointsSize() ?? 0;
+        if (parameterCurve === void 0 || parameterCount === 0) {
+            // extractCurve has already warned under the parameter curve's own type.
+            return;
         }
+        // The frame is built by the same native call the surface side uses
+        // (extractCylindricalSurface and friends), so the pcurve is orthonormalised
+        // identically to the surface it lies on rather than by a second, subtly
+        // different implementation here.
+        const placement = this.conwayModel.getAxis2Placement3D(this.extractAxis2Placement3D(parameterization.position, basisSurface.localID, true));
+        const transform = placement.getValues();
+        // Sample density for angular parameters: the same knob the ellipse path
+        // uses, so a mapped arc is tessellated like every other arc conway emits.
+        const angularStep = (2 * Math.PI) / this.circleSegments;
+        const localPoints = [];
+        let previous = parameterCurve.get2d(0);
+        localPoints.push(parameterization.evaluate(previous.x, previous.y));
+        for (let index = 1; index < parameterCount; ++index) {
+            const current = parameterCurve.get2d(index);
+            const deltaU = current.x - previous.x;
+            const deltaV = current.y - previous.y;
+            // A straight run in an angular parameter is an arc in space, so a span
+            // that covers real angle is subdivided rather than chorded across.
+            let samples = 1;
+            if (parameterization.angularU) {
+                samples = Math.max(samples, Math.ceil(Math.abs(deltaU) / angularStep));
+            }
+            if (parameterization.angularV) {
+                samples = Math.max(samples, Math.ceil(Math.abs(deltaV) / angularStep));
+            }
+            samples = Math.min(samples, MAXIMUM_PCURVE_SPAN_SAMPLES);
+            for (let sample = 1; sample <= samples; ++sample) {
+                const ratio = sample / samples;
+                localPoints.push(parameterization.evaluate(previous.x + (deltaU * ratio), previous.y + (deltaV * ratio)));
+            }
+            previous = current;
+        }
+        // Column-major Glmdmat4: basis columns at 0, 4, 8, translation at 12.
+        const pointsFlattened = new Float64Array(localPoints.length * this.THREE_DIMENSIONS);
+        let offset = 0;
+        for (const localPoint of localPoints) {
+            pointsFlattened[offset] =
+                (transform[0] * localPoint.x) + (transform[4] * localPoint.y) +
+                    (transform[8] * localPoint.z) + transform[12];
+            pointsFlattened[offset + 1] =
+                (transform[1] * localPoint.x) + (transform[5] * localPoint.y) +
+                    (transform[9] * localPoint.z) + transform[13];
+            pointsFlattened[offset + 2] =
+                (transform[2] * localPoint.x) + (transform[6] * localPoint.y) +
+                    (transform[10] * localPoint.z) + transform[14];
+            offset += this.THREE_DIMENSIONS;
+        }
+        placement.delete();
         const pointsPtr = this.arrayToWasmHeap(pointsFlattened);
         const parameters = this.paramsGetPolyCurvePool.acquire();
         parameters.points = pointsPtr;
-        parameters.pointsLength = 1;
-        parameters.dimensions = dim;
+        parameters.pointsLength = localPoints.length;
+        parameters.dimensions = this.THREE_DIMENSIONS;
+        parameters.senseAgreement = true;
+        parameters.isEdge = false;
         const curve_ = this.conwayModel.getPolyCurve(parameters);
         this.paramsGetPolyCurvePool.release(parameters);
         this.wasmModule._free(pointsPtr);
@@ -1576,15 +1909,20 @@ export class AP214GeometryExtraction {
         return void 0;
     }
     /**
-     * Efficiently flatten the points into a Float32Array
+     * Efficiently flatten the points into a Float64Array.
+     *
+     * Float64 because getPolyCurve, the only consumer, reinterprets the buffer
+     * as `const double *`: Float32 elements decode there as unrelated numbers
+     * (and read twice as many bytes as were written). Matches the IFC side's
+     * helper of the same name.
      *
      * @param points - Array of AP214CartesianPoint
      * @param dimensions - dimensions of points
-     * @return {Float32Array}
+     * @return {Float64Array}
      */
-    flattenPointsToFloat32Array(points, dimensions) {
+    flattenPointsToFloat64Array(points, dimensions) {
         const totalCoordinates = points.length * dimensions;
-        const flatCoordinates = new Float32Array(totalCoordinates);
+        const flatCoordinates = new Float64Array(totalCoordinates);
         let offset = 0;
         points.forEach((point) => {
             flatCoordinates.set(point.coordinates, offset);
@@ -1604,7 +1942,7 @@ export class AP214GeometryExtraction {
         const pointsLength = points.length;
         const dim = pointsLength > 0 ? points[0].coordinates.length : this.THREE_DIMENSIONS;
         if (pointsLength > 0) {
-            const pointsFlattened = this.flattenPointsToFloat32Array(points, dim);
+            const pointsFlattened = this.flattenPointsToFloat64Array(points, dim);
             const pointsPtr = this.arrayToWasmHeap(pointsFlattened);
             const parameters = this.paramsGetPolyCurvePool.acquire();
             parameters.points = pointsPtr;
@@ -1925,7 +2263,12 @@ export class AP214GeometryExtraction {
                     Logger.error(`Error extracting face ${EntityTypesAP214[face_.type]} - ${error.message}\t\n${error.stack} - expressID: #${face_.expressID}`);
                 }
                 else {
-                    Logger.error(`Error extracting face ${EntityTypesAP214[face_.type]} - ${error} - expressID: #${face_.expressID}`);
+                    // A non-Error throw interpolates as "[object Object]" in a template
+                    // string, which is what 8 occurrences in the public baseline
+                    // actually say - the message names the face type and nothing else.
+                    // JSON first so a plain thrown object shows its fields; String() as
+                    // the fallback for what JSON cannot take (cycles, BigInt, symbols).
+                    Logger.error(`Error extracting face ${EntityTypesAP214[face_.type]} - ${describeThrown(error)} - expressID: #${face_.expressID}`);
                 }
             }
         }
@@ -2085,6 +2428,11 @@ export class AP214GeometryExtraction {
         }
         const conwayModel = this.conwayModel;
         const bound3DVector = this.nativeBound3DVector();
+        // Loop curves are collected before bound creation so the outer-bound
+        // heuristic below can compare their extents across the whole face.
+        const loopCurves = [];
+        const loopIsOuter = [];
+        const loopOrientations = [];
         for (const bound of bounds) {
             let vec3Array;
             const innerBound = bound.bound;
@@ -2160,14 +2508,97 @@ export class AP214GeometryExtraction {
                                 };
                             }
                         }
+                        // EDGE_CURVE.same_sense: does the edge's start→end direction agree
+                        // with the basis curve's parametrisation? For same_sense=false the
+                        // edge sweeps from edge_start to edge_end AGAINST the curve
+                        // parameter. The native circle/ellipse trim (getAP214Circle) always
+                        // sweeps the positive parametric arc from trim1 to trim2 (its
+                        // senseAgreement=false path mis-negates the sweep), so ignoring
+                        // same_sense selects the COMPLEMENT arc — e.g. Onshape AP242
+                        // exports write near-straight edges as shallow arcs of large
+                        // circles, and the complement is a ~340° loop that explodes the
+                        // face boundary (Right_Hand.step spikes; the CDT "Intersecting
+                        // constraint edges" cascade). Normalise instead of forwarding the
+                        // flag: swap the trim ends so the positive sweep is the correct
+                        // arc, leaving the extracted (memoised) curve running edge_end →
+                        // edge_start; the orientation check below compensates.
+                        const sameSense = edgeElement.same_sense;
                         const trimmingArguments = {
                             exist: !!((trimmingStart !== void 0 && trimmingEnd !== void 0)),
-                            start: trimmingStart,
-                            end: trimmingEnd,
+                            start: sameSense ? trimmingStart : trimmingEnd,
+                            end: sameSense ? trimmingEnd : trimmingStart,
                         };
-                        const curve = this.extractCurve(edgeCurve, true, true, trimmingArguments);
+                        // Trimmed extractions are memoised under THIS edge's localID —
+                        // not the basis curve's — so edges sharing one basis curve with
+                        // different trims each get their own arc, while the second
+                        // ORIENTED_EDGE user of this edge (the adjacent face) still
+                        // reuses the extraction. extractCurve skips its basis-curve
+                        // memo whenever edge trims exist (see hasEdgeTrims there); the
+                        // shared this.curves container keeps ownership either way.
+                        let curve = this.curves.get(edgeElement.localID);
+                        if (curve === void 0) {
+                            curve = this.extractCurve(edgeCurve, true, true, trimmingArguments);
+                            // An edge whose vertices ARE the basis curve's own endpoints
+                            // spans the whole curve, so its trim carries no information —
+                            // and on some B-splines resolving it anyway comes back as just
+                            // the two endpoints. When such edges form a face's outer loop
+                            // the loop is collinear by construction, GetBasisFromCoplanarPoints
+                            // finds no basis, and TriangulateBounds discards the ENTIRE face,
+                            // eleven good 47-point inner bounds along with it (two edges on
+                            // nist_ctc_02_asme1_rc.stp, bldrs-ai/conway#492).
+                            //
+                            // Deliberately gated on the result being degenerate rather than
+                            // on the trim being a no-op. Most whole-curve trims resolve
+                            // correctly — 33 of 35 on that model — and bypassing those too
+                            // would re-route working edges onto a different extraction and
+                            // memoisation path for no reason, which is churn masquerading as
+                            // a fix. This only fires where the current path has already
+                            // failed, so an edge that works keeps its exact output.
+                            if (curve !== void 0 &&
+                                curve.getPointsSize() < MINIMUM_BOUND_POINTS &&
+                                isWholeCurveEdge(edgeCurve, edgeStart, edgeEnd)) {
+                                // extractCurve memoises an untrimmed extraction under the
+                                // BASIS curve's localID and owns it there.
+                                const untrimmed = this.extractCurve(edgeCurve, true, true, { exist: false, start: void 0, end: void 0 });
+                                const recovered = untrimmed !== void 0 &&
+                                    untrimmed.getPointsSize() > curve.getPointsSize();
+                                if (recovered) {
+                                    // Only now is the trimmed result known to be a defect rather
+                                    // than the curve's honest shape - a degree-1 B-spline over
+                                    // two control points really is two points, trimmed or not,
+                                    // and warning about those would be the false-row noise the
+                                    // comment further down argues against.
+                                    Logger.warning(`Whole-curve trim on edge #${edgeElement.expressID} ` +
+                                        `(${EntityTypesAP214[edgeCurve.type]}) resolved to ` +
+                                        `${curve.getPointsSize()} point(s); recovered ` +
+                                        `${untrimmed.getPointsSize()} untrimmed.`);
+                                    // The trimmed CurveObject is being dropped, and nothing else
+                                    // holds it: it was never added to this.curves, so without
+                                    // this its native allocation is unreachable.
+                                    curve.delete();
+                                    curve = untrimmed;
+                                }
+                                // Memoise under the edge either way. The adjacent face's
+                                // ORIENTED_EDGE shares this edge, and without the entry it
+                                // re-runs the whole native trim extraction, re-warns, and
+                                // leaks a second trimmed curve.
+                                if (curve !== void 0 && trimmingArguments.exist) {
+                                    this.curves.add(edgeElement.localID, curve);
+                                }
+                            }
+                            else if (curve !== void 0 && trimmingArguments.exist) {
+                                this.curves.add(edgeElement.localID, curve);
+                            }
+                        }
                         if (curve !== void 0) {
-                            if (!edge.orientation) {
+                            // The memoised curve runs edge_start→edge_end when same_sense
+                            // held, edge_end→edge_start when the trims were swapped above
+                            // (and, for untrimmed basis curves like full B-splines, native
+                            // point order is parametric order — reversed relative to the
+                            // edge exactly when same_sense is false). Traversal for this
+                            // ORIENTED_EDGE must run with `orientation`, so invert on the
+                            // XOR of the two flags rather than orientation alone.
+                            if (edge.orientation !== sameSense) {
                                 // reverse curve
                                 // Logger.info("edge orientation == true, inverting curve")
                                 const invertedCurve = curve.clone();
@@ -2224,9 +2655,13 @@ export class AP214GeometryExtraction {
             }
             else {
                 Logger.warning(`Unsupported bound ${bound.bound}`);
-                // Free this iteration's edge-curve vector and the face's partial
-                // bound vector before bailing out, or they leak per bad face.
+                // Free this iteration's edge-curve vector, previously collected
+                // loop curves and the face's partial bound vector before bailing
+                // out, or they leak per bad face.
                 nativeEdgeCurves.delete();
+                for (const loopCurve of loopCurves) {
+                    loopCurve.delete();
+                }
                 bound3DVector.delete();
                 return;
             }
@@ -2236,11 +2671,67 @@ export class AP214GeometryExtraction {
             };
             // Logger.info("isEdgeLoop: " + (isEdgeLoop) ? "TRUE" : "FALSE")
             const curve = this.conwayModel.getLoop(parameters);
-            // create bound vector
+            // No general "bound has fewer than 3 points" check here, deliberately.
+            // It looks like the obvious backstop for the #479 family and it is not:
+            // a VERTEX_LOOP is one point and zero edges BY DESIGN - the degenerate
+            // loop at a sphere pole or cone apex - and it is legitimate input that
+            // conway is expected to handle (bldrs-ai/conway#461). Measured on the
+            // smoke subset, such a check fires 50 times across Right_Hand.step and
+            // nist_ctc_01_asme1_rd.stp, and every one of those is a valid
+            // VERTEX_LOOP or single-edge closed loop. Reporting them would put 50
+            // false "the face will be dropped" rows into the blessed baseline, which
+            // is the noise problem in #478 rather than a fix for it.
+            //
+            // The known real cause is handled above, where it IS distinguishable
+            // from legitimate input.
+            loopCurves.push(curve);
+            loopIsOuter.push(bound.type === EntityTypesAP214.FACE_OUTER_BOUND);
+            loopOrientations.push(bound.orientation);
+            vec3Array.delete();
+            nativeEdgeCurves.delete();
+        }
+        // STEP allows a face's loops to all be plain FACE_BOUNDs; without a
+        // FACE_OUTER_BOUND the native triangulators would warn ("Expected outer
+        // bound, using fallback tesselation") and treat loops[0] as outer, which
+        // is only right by luck (Onshape AP242 exports order hole loops first on
+        // some faces). A face's outer loop strictly contains its holes, so tag
+        // the loop with the largest bounding-box diagonal as the outer one.
+        if (loopCurves.length > 1 && !loopIsOuter.includes(true)) {
+            let largestIndex = 0;
+            let largestDiagonal2 = -1;
+            for (let loopIndex = 0; loopIndex < loopCurves.length; ++loopIndex) {
+                const loopCurve = loopCurves[loopIndex];
+                const pointCount = loopCurve.getPointsSize();
+                let minX = Infinity;
+                let minY = Infinity;
+                let minZ = Infinity;
+                let maxX = -Infinity;
+                let maxY = -Infinity;
+                let maxZ = -Infinity;
+                for (let where = 0; where < pointCount; ++where) {
+                    const point = loopCurve.get3d(where);
+                    minX = Math.min(minX, point.x);
+                    minY = Math.min(minY, point.y);
+                    minZ = Math.min(minZ, point.z);
+                    maxX = Math.max(maxX, point.x);
+                    maxY = Math.max(maxY, point.y);
+                    maxZ = Math.max(maxZ, point.z);
+                }
+                const diagonal2 = ((maxX - minX) * (maxX - minX)) +
+                    ((maxY - minY) * (maxY - minY)) +
+                    ((maxZ - minZ) * (maxZ - minZ));
+                if (pointCount > 0 && diagonal2 > largestDiagonal2) {
+                    largestDiagonal2 = diagonal2;
+                    largestIndex = loopIndex;
+                }
+            }
+            loopIsOuter[largestIndex] = true;
+        }
+        for (let loopIndex = 0; loopIndex < loopCurves.length; ++loopIndex) {
             const parametersCreateBounds3D = {
-                curve: curve,
-                orientation: bound.orientation,
-                type: (bound.type === EntityTypesAP214.FACE_OUTER_BOUND) ? 0 : 1,
+                curve: loopCurves[loopIndex],
+                orientation: loopOrientations[loopIndex],
+                type: loopIsOuter[loopIndex] ? 0 : 1,
             };
             const bound3D = this.conwayModel.createBound3D(parametersCreateBounds3D);
             bound3DVector.push_back(bound3D);
@@ -2248,15 +2739,19 @@ export class AP214GeometryExtraction {
             // bound wrapper are temporaries that must be freed to avoid leaking
             // native memory on every face bound.
             bound3D.delete();
-            curve.delete();
-            vec3Array.delete();
-            nativeEdgeCurves.delete();
+            loopCurves[loopIndex].delete();
         }
         const surface = from.face_geometry;
         // add face to geometry
         const nativeSurface = (new (this.wasmModule.IfcSurface));
         this.extractSurface(surface, nativeSurface);
         nativeSurface.sameSense = from.same_sense;
+        // Declares the flag above as real, so the tessellator may orient the
+        // face against the surface normal. Extractors that leave this false
+        // (the IFC path today) keep the older projection-based orientation
+        // rather than having a default-constructed sense read as an answer.
+        // See https://github.com/bldrs-ai/conway/issues/459.
+        nativeSurface.sameSenseKnown = true;
         const parameters = {
             boundsArray: bound3DVector,
             advancedBrep: true,
@@ -2346,11 +2841,24 @@ export class AP214GeometryExtraction {
      * @param nativeSurface
      */
     extractSurfaceOfLinearExtrusion(from, nativeSurface) {
-        const profile = this.extractProfile(from.swept_curve);
-        if (profile?.nativeProfile === void 0) {
+        // AP214's swept_curve is a bare curve, not a profile_def, so it goes
+        // through extractCurve + createNativeIfcProfile like the revolution
+        // path does. extractProfile() never fills nativeProfile for bare
+        // curves, which silently dropped every linear-extrusion face (1,370
+        // faces on the Jetenginestep compressor shaft alone).
+        const nativeCurve = this.extractCurve(from.swept_curve);
+        if (nativeCurve === void 0) {
             Logger.warning("Couldn't get curve profile for linear extrusion surface");
             return;
         }
+        const parameters = {
+            curve: nativeCurve,
+            holes: this.nativeVectorCurve(),
+            isConvex: false,
+            isComposite: false,
+            profiles: this.nativeVectorProfile(),
+        };
+        const nativeProfile = this.conwayModel.createNativeIfcProfile(parameters);
         const extrusionAxis = from.extrusion_axis;
         const depth = extrusionAxis.magnitude;
         const directionCoords = extrusionAxis.orientation.direction_ratios;
@@ -2362,7 +2870,7 @@ export class AP214GeometryExtraction {
                 y: directionCoords[1],
                 z: directionCoords[2],
             },
-            profile: profile?.nativeProfile,
+            profile: nativeProfile,
         };
     }
     /**
@@ -2473,9 +2981,13 @@ export class AP214GeometryExtraction {
             pointer = this.wasmModule._malloc(numBytes);
             capacity = maxPossibleFloats;
         }
-        // 2) Create a Float64Array view into WASM memory
-        // We only need to create a subarray up to the capacity
-        const wasmFloat64View = this.wasmModule.HEAPF64.subarray(pointer / bytesPerElement, pointer / bytesPerElement + capacity);
+        // 2) Create a Float64Array view into WASM memory, over the heap as it is
+        // after the _malloc above rather than over whatever view the module had
+        // cached before it - see wasm_heap.ts for why those can differ. Built
+        // rather than subarray'd off HEAPF64 for the same reason: subarray clamps
+        // an out-of-range window into a short one, and the set() loop below would
+        // then quietly write somewhere other than the allocation (#485).
+        const wasmFloat64View = wasmHeapView(this.wasmModule, Float64Array, pointer, capacity);
         // 3) Single pass to skip consecutive duplicates, fill up the wasm array
         let offset = 0;
         let prevLocalID = -1;
@@ -2792,6 +3304,38 @@ export class AP214GeometryExtraction {
         result.setValues(v);
         return result;
     }
+    /**
+     * The root transform taking a shape representation's own length unit
+     * into conway's world space.
+     *
+     * World space is METRES. That convention is set by the IFC path, which
+     * folds `linearScalingFactor` — metres per file unit — into its
+     * coordination matrix (`compat/web-ifc/coordination_f64.ts`). STEP
+     * geometry is emitted in raw file coordinates instead, so the
+     * whole-model unit conversion has to ride on this root transform.
+     *
+     * The factor is therefore metres-per-file-unit itself: a millimetre
+     * file scales by 1e-3. It is NOT the reciprocal — using `1 / unitInM`
+     * put every millimetre STEP model into world space 1e6x too large,
+     * and 1e6x out of step with any IFC model federated beside it. That
+     * went unseen because Share frames the camera from the model's own
+     * bounds, which absorbs a uniform scale error, and because the
+     * regression digests hash geometry in file coordinates, which this
+     * transform never touches.
+     * See https://github.com/bldrs-ai/conway/issues/458.
+     *
+     * @param shapeRepresentation The representation whose unit context to read.
+     * @return The scale transform, or undefined if no length unit is declared.
+     */
+    rootUnitScaleTransform(shapeRepresentation) {
+        const sourceShapeContext = shapeRepresentation.context_of_items.findVariant(global_unit_assigned_context)?.units?.
+            find((unit) => unit.findVariant(length_unit))?.findVariant(length_unit);
+        if (sourceShapeContext === void 0) {
+            return void 0;
+        }
+        const sourceUnitInM = this.convertToMetres(sourceShapeContext) ?? 1;
+        return this.uniformScaleAffine(this.identity3DNativeMatrix, sourceUnitInM);
+    }
     /**
      *
      */
@@ -2809,7 +3353,14 @@ export class AP214GeometryExtraction {
                 }
             }
             catch (error) {
-                Logger.error(`Error populating styled item map for item ${styledItem.localID}: ${error}`);
+                if (!this.quietRecoverableLogging) {
+                    // toString(), not localID: localID is the dense internal index and
+                    // means nothing against the source file, and these land in the
+                    // regression run's `expressids` column where the whole point is to
+                    // be able to go look at the record. It also spells the inline case
+                    // honestly rather than passing off an index as a reference.
+                    Logger.error(`Error populating styled item map: ${error}`, styledItem.toString());
+                }
             }
         }
         for (const overridingStyledItem of overridingStyledItems) {
@@ -2819,7 +3370,9 @@ export class AP214GeometryExtraction {
                 }
             }
             catch (error) {
-                Logger.error(`Error populating styled item map for item ${overridingStyledItem.localID}: ${error}`);
+                if (!this.quietRecoverableLogging) {
+                    Logger.error(`Error populating overriding styled item map: ${error}`, overridingStyledItem.toString());
+                }
             }
         }
     }
@@ -2902,16 +3455,27 @@ export class AP214GeometryExtraction {
      * @return {[ExtractResult, AP214SceneBuilder]} - Enum indicating extraction result
      * + Geometry array
      */
-    extractAP214GeometryData(logTime = false) {
-        let result = ExtractResult.INCOMPLETE;
-        const startTime = Date.now();
-        //  this.extractLinearScalingFactor()
-        const previousMemoizationState = this.model.elementMemoization;
-        // populate relMaterialsMap
-        // const relAssociatesMaterials = this.model.types(AP214RelAssociatesMaterial)
+    /**
+     * Prepare per-unit demand extraction (STEP demand parity phase 2)
+     * without executing any geometry work: builds the assembly tree and
+     * thunks exactly like the whole-model walk, but the root executions
+     * are captured as an ordered list of UNITS — a childless root is one
+     * unit; a root with children is flattened one level (one unit per
+     * immediate child, in order, then one for the root's own items), so
+     * single-root assemblies still pump progressively per part. Executing
+     * every unit in order then calling {@link finishDemandExtraction}
+     * reproduces the whole-model walk exactly — the classic
+     * {@link extractAP214GeometryData} runs through this same path.
+     * Idempotent.
+     */
+    // eslint-disable-next-line max-lines-per-function
+    prepareDemandExtraction() {
+        if (this.demandUnits_ !== void 0) {
+            return;
+        }
         const model = this.model;
         const treeMap = new Map();
-        const makeThunk = (representation, owningElementLocalID, mappedTreeNode) => {
+        const makeThunk = (representation, owningElementLocalID, mappedTreeNode, slice) => {
             return (owningLocalID, parentTransform) => {
                 owningLocalID ??= owningElementLocalID;
                 const mappedItem = mappedTreeNode !== void 0 || parentTransform !== void 0;
@@ -2920,8 +3484,12 @@ export class AP214GeometryExtraction {
                 if (parentTransform !== void 0) {
                     this.scene.addTransform(representation.localID, parentTransform.getValues(), parentTransform, true);
                 }
-                if (mappedTreeNode?.children !== void 0) {
-                    for (const [childLocalID, childOwningLocalID, childTransform] of mappedTreeNode.children) {
+                if (mappedTreeNode?.children !== void 0 &&
+                    (slice === void 0 || slice.childStart !== slice.childEnd)) {
+                    const sliceChildren = slice !== void 0 ?
+                        mappedTreeNode.children.slice(slice.childStart, slice.childEnd) :
+                        mappedTreeNode.children;
+                    for (const [childLocalID, childOwningLocalID, childTransform] of sliceChildren) {
                         const mappedChild = treeMap.get(childLocalID);
                         const enterChildStackDepth = this.scene.stackLength;
                         const enterChildParent = this.scene.currentParent;
@@ -2955,7 +3523,10 @@ export class AP214GeometryExtraction {
                             mappedChild.thunk(childOwningLocalID, childTransform);
                         }
                         catch (ex) {
-                            if (ex instanceof Error) {
+                            if (this.quietRecoverableLogging) {
+                                // Preview prefix: dangling children are expected — skip quietly.
+                            }
+                            else if (ex instanceof Error) {
                                 Logger.error(`Error processing child shape_representation: \n\t${ex.name}\n\t${ex.message}\n\texpressID: #${this.model.getExpressIDByLocalID(childLocalID)}`);
                             }
                             else {
@@ -2966,12 +3537,14 @@ export class AP214GeometryExtraction {
                         while (this.scene.stackLength > enterChildStackDepth) {
                             this.scene.popTransform();
                         }
-                        if (this.scene.stackLength !== enterChildStackDepth || this.scene.currentParent !== enterChildParent) {
+                        if ((this.scene.stackLength !== enterChildStackDepth ||
+                            this.scene.currentParent !== enterChildParent) && !this.quietRecoverableLogging) {
                             Logger.error(`Stack length mismatch after processing child shape_representation ${this.scene.currentParent} ${enterChildParent} expressID: #${representation.expressID}`);
                         }
                     }
                 }
-                for (const item of representation.items) {
+                const includeItems = slice?.includeItems ?? true;
+                for (const item of includeItems ? representation.items : []) {
                     try {
                         if (item instanceof placement) {
                             this.extractPlacement(item, mappedItem);
@@ -2995,7 +3568,12 @@ export class AP214GeometryExtraction {
                     }
                     catch (ex) {
                         if (ex instanceof Error) {
-                            Logger.error(`Error processing representation item: \n\t${ex.name}\n\t${ex.message}\n\texpressID: #${item.expressID}`);
+                            // Stack included for the same reason extractFaces includes it:
+                            // this family's message is the same string for every occurrence
+                            // ("Value in select must be populated" accounts for all 274 in
+                            // the NIST AP242 set), so without a stack there is nothing to
+                            // tell one occurrence from another or say WHICH select failed.
+                            Logger.error(`Error processing representation item: \n\t${ex.name}\n\t${ex.message}\n\t${ex.stack}\n\texpressID: #${item.expressID}`);
                         }
                         else {
                             Logger.error(`Unknown exception processing representation item (${ex}) expressID: #${item.expressID}`);
@@ -3005,16 +3583,25 @@ export class AP214GeometryExtraction {
                 while (this.scene.stackLength > entryTransformDepth) {
                     this.scene.popTransform();
                 }
-                if (this.scene.stackLength !== entryTransformDepth || this.scene.currentParent !== currentParent) {
+                if ((this.scene.stackLength !== entryTransformDepth ||
+                    this.scene.currentParent !== currentParent) && !this.quietRecoverableLogging) {
                     Logger.error(`Stack length mismatch after processing shape_representation  ${this.scene.currentParent} ${currentParent} expressID: #${representation.expressID}`);
                 }
             };
         };
-        try {
+        // Roots the whole-model walk would execute, in execution order —
+        // expanded into units at the end of preparation (children arrays
+        // are final only once every edge loop has run).
+        const pendingRoots = [];
+        {
             this.scene.clearParentStack();
             // 256 meg limit for memoization - smaller models get a big
             // win from memoization, but much larger models it uses far too much heap.
             const MEMOIZATION_THRESHOLD = 256 * 1024 * 1024;
+            // Remembered for finishDemandExtraction / the classic wrapper's
+            // finally — the pump spans many calls, so restoration cannot live
+            // in a single method's finally anymore.
+            this.demandMemoizationRestore_ = this.model.elementMemoization;
             if (this.lowMemoryMode || model.bufferBytesize > MEMOIZATION_THRESHOLD) {
                 this.model.elementMemoization = false;
             }
@@ -3040,9 +3627,21 @@ export class AP214GeometryExtraction {
                 }
             }
             for (const contextDependentShapeRepresentation of contextDependentShapeRepresentations) {
-                const assembly = contextDependentShapeRepresentation.represented_product_relation;
+                // Per-record containment: reference getters throw on
+                // malformed/dangling records (a mid-parse PREFIX model — the
+                // preview channel's snapshots — always has a truncated tail).
+                // One bad edge record skips, it must not abort the whole
+                // preparation.
+                let assembly;
+                let shapeRelationship;
+                try {
+                    assembly = contextDependentShapeRepresentation.represented_product_relation;
+                    shapeRelationship = contextDependentShapeRepresentation.representation_relation;
+                }
+                catch {
+                    continue;
+                }
                 const owningLocalID = assembly.localID;
-                const shapeRelationship = contextDependentShapeRepresentation.representation_relation;
                 shapeRepresentationRelationshipsSeen.add(shapeRelationship.localID);
                 /* Exporters disagree on the rep_1/rep_2 order of an assembly
                  * placement relationship: as1-style files write (child, parent),
@@ -3056,8 +3655,15 @@ export class AP214GeometryExtraction {
                  * SDR-bound product definition against them, and keep the legacy
                  * (child, parent) reading when the match is ambiguous/unresolvable.
                  */
-                let sourceShape = shapeRelationship.rep_1;
-                let targetShape = shapeRelationship.rep_2;
+                let sourceShape;
+                let targetShape;
+                try {
+                    sourceShape = shapeRelationship.rep_1;
+                    targetShape = shapeRelationship.rep_2;
+                }
+                catch {
+                    continue;
+                }
                 let orientationFlipped = false;
                 try {
                     const nauo = assembly.definition;
@@ -3078,7 +3684,15 @@ export class AP214GeometryExtraction {
                 catch {
                     // Malformed NAUO/PDS reference — keep the legacy orientation.
                 }
-                const [transform, isContinue] = this.doTransforms(shapeRelationship, sourceShape, targetShape, owningLocalID, orientationFlipped);
+                let transform;
+                let isContinue;
+                try {
+                    [transform, isContinue] = this.doTransforms(shapeRelationship, sourceShape, targetShape, owningLocalID, orientationFlipped);
+                }
+                catch {
+                    // Malformed transform record (prefix truncation) — skip the edge.
+                    continue;
+                }
                 if (isContinue) {
                     continue;
                 }
@@ -3089,6 +3703,8 @@ export class AP214GeometryExtraction {
                     sourceNode = { parents: 1 };
                     treeMap.set(sourceID, sourceNode);
                     sourceNode.thunk = makeThunk(sourceShape, owningLocalID, sourceNode);
+                    sourceNode.rep = sourceShape;
+                    sourceNode.owningLocalID = owningLocalID;
                 }
                 else {
                     sourceNode.parents ??= 0;
@@ -3117,9 +3733,21 @@ export class AP214GeometryExtraction {
                  * source and rep_2 is the target, whereas in
                  * context_dependent_shape_representation, the relationship is inverted.
                  */
-                const sourceShape = shapeRelationship.rep_2;
-                const targetShape = shapeRelationship.rep_1;
-                const [transform, isContinue] = this.doTransforms(shapeRelationship, sourceShape, targetShape, owningLocalID);
+                let sourceShape;
+                let targetShape;
+                let transform;
+                let isContinue;
+                try {
+                    sourceShape = shapeRelationship.rep_2;
+                    targetShape = shapeRelationship.rep_1;
+                    [transform, isContinue] =
+                        this.doTransforms(shapeRelationship, sourceShape, targetShape, owningLocalID);
+                }
+                catch {
+                    // Malformed relationship/transform record (prefix truncation)
+                    // — skip the edge.
+                    continue;
+                }
                 if (isContinue) {
                     continue;
                 }
@@ -3135,6 +3763,8 @@ export class AP214GeometryExtraction {
                     ++sourceNode.parents;
                 }
                 sourceNode.thunk = makeThunk(sourceShape, owningLocalID, sourceNode);
+                sourceNode.rep = sourceShape;
+                sourceNode.owningLocalID = owningLocalID;
                 let targetNode = treeMap.get(targetID);
                 if (targetNode === void 0) {
                     targetNode = { parents: 0, children: [[sourceID, owningLocalID, transform]] };
@@ -3147,12 +3777,20 @@ export class AP214GeometryExtraction {
             }
             const shapeDefinitions = model.types(shape_definition_representation);
             for (const shapeDefinitionRepresentation of shapeDefinitions) {
-                const shapeRepresentation = shapeDefinitionRepresentation.used_representation;
-                if (!(shapeRepresentation instanceof shape_representation)) {
+                let shapeRepresentation;
+                let definition;
+                try {
+                    shapeRepresentation = shapeDefinitionRepresentation.used_representation;
+                    if (!(shapeRepresentation instanceof shape_representation)) {
+                        continue;
+                    }
+                    definition = shapeDefinitionRepresentation.definition;
+                }
+                catch {
+                    // Malformed SDR record (prefix truncation) — skip it.
                     continue;
                 }
                 //this.scene.clearParentStack()
-                const definition = shapeDefinitionRepresentation.definition;
                 const owningElementLocalID = definition.localID;
                 let treeNode = treeMap.get(shapeRepresentation.localID);
                 const hasMappedNode = treeNode !== void 0;
@@ -3166,18 +3804,26 @@ export class AP214GeometryExtraction {
                 const mappedTreeNode = treeNode;
                 const thunk = makeThunk(shapeRepresentation, owningElementLocalID, mappedTreeNode);
                 mappedTreeNode.thunk = thunk;
+                mappedTreeNode.rep = shapeRepresentation;
+                mappedTreeNode.owningLocalID = owningElementLocalID;
                 if (!hasMappedNode) {
                     mappedTreeNode.processed = true;
-                    const sourceShapeContext = shapeRepresentation.context_of_items.findVariant(global_unit_assigned_context)?.units?.
-                        find(unit => unit.findVariant(length_unit))?.findVariant(length_unit);
                     let scaleTransform = void 0;
-                    if (sourceShapeContext !== void 0) {
-                        const sourceUnitInM = (this.convertToMetres(sourceShapeContext) ?? 1);
-                        scaleTransform =
-                            this.uniformScaleAffine(this.identity3DNativeMatrix, 1 / sourceUnitInM);
+                    try {
+                        scaleTransform = this.rootUnitScaleTransform(shapeRepresentation);
+                    }
+                    catch {
+                        // Malformed unit context (prefix truncation) — no unit scale.
+                        scaleTransform = void 0;
                     }
-                    // not an assembly mapped item, just extract the representation
-                    thunk(void 0, scaleTransform);
+                    // not an assembly mapped item — capture as a pending root
+                    // instead of executing inline (these nodes are childless by
+                    // construction: they were absent from the tree before this
+                    // loop, and all edges were added by the earlier loops).
+                    pendingRoots.push({
+                        node: mappedTreeNode,
+                        scaleTransform,
+                    });
                     continue;
                 }
             }
@@ -3195,45 +3841,168 @@ export class AP214GeometryExtraction {
                 const mappedTreeNode = treeNode;
                 const owningElementLocalID = shapeRepresentation.localID;
                 mappedTreeNode.thunk = makeThunk(shapeRepresentation, owningElementLocalID, mappedTreeNode);
+                mappedTreeNode.rep = shapeRepresentation;
+                mappedTreeNode.owningLocalID = owningElementLocalID;
             }
-            // All thunks are set, now we can execute the full
-            // assembly tree.
+            // All thunks are set — capture remaining assembly-tree roots as
+            // pending roots in the exact order the whole-model walk executed
+            // them.
             for (const [sourceID, mappedNode] of treeMap.entries()) {
                 if ((mappedNode.parents ?? 0) === 0 && mappedNode.thunk !== void 0 && mappedNode.processed !== true) {
-                    //this.scene.clearParentStack()
-                    const shapeRepresentation = this.model.getTypedElementByLocalID(sourceID, shape_representation);
-                    const sourceShapeContext = shapeRepresentation.context_of_items.findVariant(global_unit_assigned_context)?.units?.
-                        find(unit => unit.findVariant(length_unit))?.findVariant(length_unit);
                     let scaleTransform = void 0;
-                    if (sourceShapeContext !== void 0) {
-                        const sourceUnitInM = (this.convertToMetres(sourceShapeContext) ?? 1);
-                        scaleTransform =
-                            this.uniformScaleAffine(this.identity3DNativeMatrix, 1 / sourceUnitInM);
+                    try {
+                        const shapeRepresentation = this.model.getTypedElementByLocalID(sourceID, shape_representation);
+                        scaleTransform = this.rootUnitScaleTransform(shapeRepresentation);
+                    }
+                    catch {
+                        // Malformed unit context (prefix truncation) — no unit scale.
+                        scaleTransform = void 0;
                     }
-                    // not an assembly mapped item, just extract the representation
-                    mappedNode.thunk(void 0, scaleTransform);
+                    pendingRoots.push({ node: mappedNode, scaleTransform });
                 }
             }
-            // Run any deferred face tessellation across the native thread pool
-            // before geometry can be read or temporaries freed.
-            this.finalizeStagedFaces();
-            if (RegressionCaptureState.memoization !== MemoizationCapture.FULL) {
-                this.model.geometry.deleteTemporaries();
+            // Expand pending roots into ordered execution units: childless
+            // roots run their original thunk whole; roots with children are
+            // flattened one level — one unit per immediate child (in order),
+            // then one for the root's own representation items, matching the
+            // thunk body's children-then-items order exactly.
+            const units = [];
+            for (const root of pendingRoots) {
+                const node = root.node;
+                const scaleTransform = root.scaleTransform;
+                const childCount = node.children?.length ?? 0;
+                if (childCount === 0 || node.rep === void 0) {
+                    units.push(() => node.thunk(void 0, scaleTransform));
+                    continue;
+                }
+                for (let child = 0; child < childCount; ++child) {
+                    const sliced = makeThunk(node.rep, node.owningLocalID, node, { childStart: child, childEnd: child + 1, includeItems: false });
+                    units.push(() => sliced(void 0, scaleTransform));
+                }
+                const itemsOnly = makeThunk(node.rep, node.owningLocalID, node, { childStart: 0, childEnd: 0, includeItems: true });
+                units.push(() => itemsOnly(void 0, scaleTransform));
+            }
+            this.demandUnits_ = units;
+        }
+    }
+    /**
+     * Total demand units (see prepareDemandExtraction).
+     *
+     * @return {number} The unit count (0 before preparation).
+     */
+    get demandUnitCount() {
+        return this.demandUnits_?.length ?? 0;
+    }
+    /**
+     * Units already executed by extractDemandUnitBatch.
+     *
+     * @return {number} The cursor.
+     */
+    get demandUnitCursor() {
+        return this.demandCursor_;
+    }
+    /**
+     * Advance the unit cursor WITHOUT executing (parse-time preview
+     * generations resume a global ordinal on a fresh prefix extraction —
+     * earlier units were already emitted from earlier generations).
+     *
+     * @param count Units to skip.
+     */
+    skipDemandUnits(count) {
+        const units = this.demandUnits_;
+        if (units === void 0) {
+            return;
+        }
+        this.demandCursor_ = Math.min(this.demandCursor_ + Math.max(count, 0), units.length);
+    }
+    /**
+     * Execute the next `count` demand units (STEP demand parity phase 2)
+     * — the per-unit pump behind the shim's ExtractGeometryBatch for
+     * AP214 models. Staged face tessellation is finalized after every
+     * batch so captured geometry is complete and readable.
+     *
+     * @param count Max units to execute this call (min 1).
+     * @return {number} Units actually executed.
+     */
+    extractDemandUnitBatch(count) {
+        const units = this.demandUnits_;
+        if (units === void 0) {
+            return 0;
+        }
+        const end = Math.min(this.demandCursor_ + Math.max(count, 1), units.length);
+        let executed = 0;
+        for (; this.demandCursor_ < end; ++this.demandCursor_) {
+            try {
+                units[this.demandCursor_]();
+                ++executed;
             }
-            result = ExtractResult.COMPLETE;
-            // free buffer at the end if you don't need it anymore
-            if (this.pointBuffer?.pointer) {
-                this.wasmModule._free(this.pointBuffer.pointer);
-                this.pointBuffer = null;
+            catch (ex) {
+                if (this.quietRecoverableLogging) {
+                    // Preview prefix: failing units are expected — retried on a
+                    // richer generation, and the durable extraction re-runs all.
+                }
+                else if (ex instanceof Error) {
+                    Logger.error(`Error processing demand unit: \n\t${ex.name}\n\t${ex.message}`);
+                }
+                else {
+                    Logger.error(`Unknown exception processing demand unit (${ex})`);
+                }
             }
-            return [result, this.scene, this.productShapeMap];
+        }
+        // Deferred face tessellation must land before geometry is read.
+        this.finalizeStagedFaces();
+        return executed;
+    }
+    /**
+     * Complete a demand extraction after every unit has run: final staged
+     * tessellation, temporaries cleanup, point-buffer release and
+     * memoization restore — the tail the whole-model walk runs.
+     *
+     * @return {[ExtractResult, AP214SceneBuilder, AP214ProductShapeMap]}
+     * The completed extraction result.
+     */
+    finishDemandExtraction() {
+        this.finalizeStagedFaces();
+        if (RegressionCaptureState.memoization !== MemoizationCapture.FULL) {
+            this.model.geometry.deleteTemporaries();
+        }
+        if (this.pointBuffer?.pointer) {
+            this.wasmModule._free(this.pointBuffer.pointer);
+            this.pointBuffer = null;
+        }
+        if (this.demandMemoizationRestore_ !== void 0) {
+            this.model.elementMemoization = this.demandMemoizationRestore_;
+            this.demandMemoizationRestore_ = void 0;
+        }
+        return [ExtractResult.COMPLETE, this.scene, this.productShapeMap];
+    }
+    /**
+     * Whole-model extraction: prepare + run every demand unit + finish —
+     * a single code path with the per-unit pump, so pumped and classic
+     * extractions are identical by construction.
+     *
+     * @param logTime Unused (kept for call compatibility).
+     * @return {[ExtractResult, AP214SceneBuilder, AP214ProductShapeMap]}
+     * The completed extraction result.
+     */
+    // eslint-disable-next-line no-unused-vars
+    extractAP214GeometryData(logTime = false) {
+        try {
+            this.prepareDemandExtraction();
+            while (this.demandCursor_ < this.demandUnitCount) {
+                this.extractDemandUnitBatch(this.demandUnitCount);
+            }
+            return this.finishDemandExtraction();
         }
         finally {
             // Ensure no staged face jobs outlive extraction (their target
             // geometry may be freed once the model is invalidated), even if
             // extraction exits through an exception.
             this.finalizeStagedFaces();
-            this.model.elementMemoization = previousMemoizationState;
+            if (this.demandMemoizationRestore_ !== void 0) {
+                this.model.elementMemoization = this.demandMemoizationRestore_;
+                this.demandMemoizationRestore_ = void 0;
+            }
         }
     }
     /**