@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/AP214E3_2010/ap214_geometry_extraction.test.js

@@ -105,11 +105,19 @@ describe("AP214 Geometry Extraction", () => {
         expect(extractGearGeometry()).toBe(ExtractResult.COMPLETE);
     });
     test("tubeGeometryArrayLength()", () => {
-        const testParameter = 9108;
+        // Dropped from 9108 with conway-geom#153: cylindrical faces CDT their
+        // trim loops in a (theta, z) unwrap instead of refining earcut chords
+        // until the triangle budget ran out.
+        const testParameter = 828;
         expect(getTubeMeshSize()).toBe(testParameter);
     });
     test("gearGeometryArrayLength()", () => {
-        const testParameter = 48108;
+        // Raised from 48108 with the extent-relative deflection thresholds
+        // (conway-geom relativeCurveDeflectionSquared): the gear's involute
+        // flank splines are a few mm across, so the old absolute 1mm chord
+        // tolerance sampled them with ~3 chords per flank; 0.1%-of-extent
+        // tolerance resolves the involute curvature the profile actually has.
+        const testParameter = 154644;
         expect(getGearMeshSize()).toBe(testParameter);
     });
     test("uniformScaleAffine scales basis AND translation, preserves bottom row", () => {

package/compiled/src/AP214E3_2010/ap214_logical_attribute.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ap214_logical_attribute.test.d.ts.map

package/compiled/src/AP214E3_2010/ap214_logical_attribute.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ap214_logical_attribute.test.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_logical_attribute.test.ts"],"names":[],"mappings":""}

package/compiled/src/AP214E3_2010/ap214_logical_attribute.test.js

@@ -0,0 +1,114 @@
+// ISO 10303-42 declares `b_spline_surface.u_closed`, `v_closed` and
+// `self_intersect` (and the matching attributes on `b_spline_curve`,
+// `composite_curve`, `offset_curve_2d/3d`, `offset_surface` and
+// `shape_aspect`) as LOGICAL, which is three-valued - `.T.`, `.F.`, `.U.`.
+// The generator used to emit `extractBoolean` for them, so a `.U.` threw
+// 'Value in STEP was incorrectly typed' out of the getter and took the whole
+// face - and in the NIST AP242 exports, whole solids - with it.
+//
+// The generator now carries a distinct `logical` token, so a bare EXPRESS
+// LOGICAL selects `extractLogical` and reads `.U.` as null. This test pins
+// that against the regenerated tree: it fails on the pre-regen output, where
+// the `.U.` reads throw. BOOLEAN attributes are asserted alongside, because
+// the failure mode of an over-broad fix is every BOOLEAN quietly becoming a
+// LOGICAL. See bldrs-ai/conway#480 and IFC-gen-internal#2.
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import AP214StepParser from "./ap214_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { b_spline_surface_with_knots, edge_curve } from "./AP214E3_2010_gen/index.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+const conwayGeom = new ConwayGeometry();
+/**
+ * Initialize the wasm.
+ */
+async function initializeWasm() {
+    await conwayGeom.initialize();
+}
+const parser = AP214StepParser.Instance;
+// A bilinear patch, so the fixture stays readable, carrying the same
+// attribute shape as the bicubic patches in `nist_ftc_07_asme1_ap242-e2.stp`
+// that this defect dropped: `.UNSPECIFIED.` surface form followed by
+// u_closed / v_closed / self_intersect all written `.U.`. That file has 20
+// such surfaces, and each one lost an ADVANCED_FACE.
+const UNKNOWN_SURFACE = `
+#1 = CARTESIAN_POINT('',(0.,0.,0.));
+#2 = CARTESIAN_POINT('',(1.,0.,0.));
+#3 = CARTESIAN_POINT('',(0.,1.,0.));
+#4 = CARTESIAN_POINT('',(1.,1.,0.));
+#10 = B_SPLINE_SURFACE_WITH_KNOTS('',1,1,((#1,#2),(#3,#4)),.UNSPECIFIED.,
+  .U.,.U.,.U.,(2,2),(2,2),(0.,1.),(0.,1.),.UNSPECIFIED.);
+`;
+// The same surface with the three LOGICALs written as the two determinate
+// values. A fix that read every LOGICAL as null would pass the `.U.` case
+// and fail here.
+const DETERMINATE_SURFACE = `
+#1 = CARTESIAN_POINT('',(0.,0.,0.));
+#2 = CARTESIAN_POINT('',(1.,0.,0.));
+#3 = CARTESIAN_POINT('',(0.,1.,0.));
+#4 = CARTESIAN_POINT('',(1.,1.,0.));
+#10 = B_SPLINE_SURFACE_WITH_KNOTS('',1,1,((#1,#2),(#3,#4)),.UNSPECIFIED.,
+  .T.,.F.,.F.,(2,2),(2,2),(0.,1.),(0.,1.),.UNSPECIFIED.);
+`;
+const SURFACE_EXPRESS_ID = 10;
+// `edge_curve.same_sense` is a genuine BOOLEAN and must keep reading as one.
+// The edge's vertex and curve references are left dangling: only the trailing
+// BOOLEAN is read here, and resolving the rest would need a curve definition
+// that has nothing to do with what is being pinned.
+const BOOLEAN_EDGES = `
+#20 = EDGE_CURVE('',#21,#22,#23,.T.);
+#30 = EDGE_CURVE('',#21,#22,#23,.F.);
+`;
+const TRUE_EDGE_EXPRESS_ID = 20;
+const FALSE_EDGE_EXPRESS_ID = 30;
+/**
+ * Parse a STEP fragment and return the model it produced.
+ *
+ * @param source The STEP text to parse.
+ * @return {ReturnType< typeof parser.parseDataToModel >[ 1 ]} The model.
+ */
+function modelOf(source) {
+    const [result, model] = parser.parseDataToModel(new ParsingBuffer(new TextEncoder().encode(source)));
+    // INCOMPLETE is expected for the edge fixture, whose references dangle.
+    if (model === void 0 ||
+        (result !== ParseResult.COMPLETE && result !== ParseResult.INCOMPLETE)) {
+        throw new Error(`parse failed with result ${result}`);
+    }
+    return model;
+}
+/**
+ * Parse a surface fixture and read back its three LOGICAL attributes.
+ *
+ * @param source The STEP text to parse.
+ * @return {Array< boolean | null >} u_closed, v_closed, self_intersect.
+ */
+function surfaceLogicalsOf(source) {
+    const surface = modelOf(source).getElementByExpressID(SURFACE_EXPRESS_ID);
+    if (!(surface instanceof b_spline_surface_with_knots)) {
+        throw new Error("expected a b_spline_surface_with_knots");
+    }
+    return [surface.u_closed, surface.v_closed, surface.self_intersect];
+}
+beforeAll(async () => {
+    await initializeWasm();
+});
+describe("a LOGICAL attribute", () => {
+    test(".U. reads as null instead of throwing", () => {
+        expect(surfaceLogicalsOf(UNKNOWN_SURFACE)).toEqual([null, null, null]);
+    });
+    test(".T. and .F. still read as true and false", () => {
+        expect(surfaceLogicalsOf(DETERMINATE_SURFACE)).toEqual([true, false, false]);
+    });
+});
+describe("a BOOLEAN attribute", () => {
+    test(".T. and .F. are unaffected", () => {
+        const model = modelOf(BOOLEAN_EDGES);
+        const trueEdge = model.getElementByExpressID(TRUE_EDGE_EXPRESS_ID);
+        const falseEdge = model.getElementByExpressID(FALSE_EDGE_EXPRESS_ID);
+        if (!(trueEdge instanceof edge_curve) || !(falseEdge instanceof edge_curve)) {
+            throw new Error("expected two edge_curves");
+        }
+        expect(trueEdge.same_sense).toBe(true);
+        expect(falseEdge.same_sense).toBe(false);
+    });
+});

package/compiled/src/AP214E3_2010/ap214_model_geometry.d.ts

@@ -13,6 +13,12 @@ export declare class AP214ModelGeometry implements ModelGeometry {
     /**
      * Add a mesh to this geometry collection.
      *
+     * Freezes the native float vertex mirror at add time, exactly like
+     * IfcModelGeometry.add (see its note): consumers read float vertices
+     * whose frame must match the scene transforms, which are authored
+     * against the geometry AS CREATED — later count-preserving native
+     * mutations (normalize's centering) must not shift the served frame.
+     *
      * @param mesh
      * @param parentLocalID
      */

package/compiled/src/AP214E3_2010/ap214_model_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ap214_model_geometry.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_model_geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAG7C;;GAEG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IAEtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAE1D;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;OAKG;IACI,GAAG,CAAE,IAAI,EAAE,aAAa,EAAE,aAAa,CAAC,EAAG,MAAM,GAAI,IAAI;IAkBhE;;;;OAIG;IACI,MAAM,CAAE,OAAO,EAAE,MAAM;IAe9B;;OAEG;IACI,iBAAiB,IAAI,IAAI;IAgBhC;;;;;OAKG;IACI,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAIlE;;;;OAIG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D;;;OAGG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI3D;;;OAGG;IACI,qBAAqB,IAAI,MAAM;CAoBvC"}
+{"version":3,"file":"ap214_model_geometry.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_model_geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAG7C;;GAEG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IAEtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAE1D;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;OAWG;IACI,GAAG,CAAE,IAAI,EAAE,aAAa,EAAE,aAAa,CAAC,EAAG,MAAM,GAAI,IAAI;IAsBhE;;;;OAIG;IACI,MAAM,CAAE,OAAO,EAAE,MAAM;IAe9B;;OAEG;IACI,iBAAiB,IAAI,IAAI;IAgBhC;;;;;OAKG;IACI,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAIlE;;;;OAIG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D;;;OAGG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI3D;;;OAGG;IACI,qBAAqB,IAAI,MAAM;CAoBvC"}

package/compiled/src/AP214E3_2010/ap214_model_geometry.js

@@ -16,10 +16,19 @@ export class AP214ModelGeometry {
     /**
      * Add a mesh to this geometry collection.
      *
+     * Freezes the native float vertex mirror at add time, exactly like
+     * IfcModelGeometry.add (see its note): consumers read float vertices
+     * whose frame must match the scene transforms, which are authored
+     * against the geometry AS CREATED — later count-preserving native
+     * mutations (normalize's centering) must not shift the served frame.
+     *
      * @param mesh
      * @param parentLocalID
      */
     add(mesh, parentLocalID) {
+        if (mesh.type === CanonicalMeshType.BUFFER_GEOMETRY) {
+            mesh.geometry.GetVertexData();
+        }
         this.meshes_.set(mesh.localID, mesh);
         if (parentLocalID !== void 0) {
             let children = this.children_.get(parentLocalID);

package/compiled/src/AP214E3_2010/ap214_pcurve_basis_surfaces.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ap214_pcurve_basis_surfaces.test.d.ts.map

package/compiled/src/AP214E3_2010/ap214_pcurve_basis_surfaces.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ap214_pcurve_basis_surfaces.test.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_pcurve_basis_surfaces.test.ts"],"names":[],"mappings":""}

package/compiled/src/AP214E3_2010/ap214_pcurve_basis_surfaces.test.js

@@ -0,0 +1,233 @@
+import fs from "fs";
+import { describe, expect, test, beforeAll } from "@jest/globals";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import Logger, { LogLevel } from "../logging/logger.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { AP214GeometryExtraction } from "./ap214_geometry_extraction.js";
+import { pcurve } from "./AP214E3_2010_gen/index.js";
+import AP214StepParser from "./ap214_step_parser.js";
+let extraction;
+let model;
+// Coordinates round-trip through the native curve at float precision (a
+// CurveObject's get3d hands back ~1e-7 relative of what went in), so the
+// checks here are geometric and to four decimal places rather than bit-exact.
+const PRECISION_DIGITS = 4;
+const MONOTONIC_EPSILON = 0.0001;
+const CYLINDER_RADIUS = 25;
+const CYLINDER_TOP = 20;
+const CONE_ORIGIN_X = 5;
+const CONE_ORIGIN_Y = -3;
+const CONE_ORIGIN_Z = 50;
+const CONE_BASE_RADIUS = 10;
+const CONE_HEIGHT = 20;
+const CONE_SEMI_ANGLE = Math.PI / 6;
+const CONE_TOP_RADIUS = CONE_BASE_RADIUS + (CONE_HEIGHT * Math.tan(CONE_SEMI_ANGLE));
+const SPHERE_RADIUS = 10;
+const SPHERE_HEIGHT = 5;
+const SPHERE_LATITUDE = Math.PI / 6;
+const SPHERE_RING_RADIUS = SPHERE_RADIUS * Math.cos(SPHERE_LATITUDE);
+const TORUS_MAJOR_RADIUS = 20;
+const TORUS_MINOR_RADIUS = 5;
+const TORUS_OUTER = 25;
+const TORUS_INNER = 15;
+const PLANE_ORIGIN = { x: 1, y: 2, z: 3 };
+const PLANE_END = { x: 5, y: 9, z: 3 };
+const CURVE_3D_END_Y = 40;
+const PARAMETER_SAMPLES = 3;
+/**
+ * Parse the fixture and set up geometry extraction.
+ *
+ * @return {Promise<boolean>} True if initialization succeeded.
+ */
+async function initialize() {
+    const parser = AP214StepParser.Instance;
+    const buffer = fs.readFileSync("data/pcurve-basis-surfaces.step");
+    const bufferInput = new ParsingBuffer(buffer);
+    if (parser.parseHeader(bufferInput)[1] !== ParseResult.COMPLETE) {
+        return false;
+    }
+    const conwayGeometry = new ConwayGeometry();
+    if (!(await conwayGeometry.initialize())) {
+        return false;
+    }
+    const [, parsedModel] = parser.parseDataToModel(bufferInput);
+    if (parsedModel === void 0) {
+        return false;
+    }
+    model = parsedModel;
+    extraction = new AP214GeometryExtraction(conwayGeometry, model);
+    return extraction.isInitialized();
+}
+/**
+ * Find the fixture's pcurve carrying a given name.
+ *
+ * @param name The PCURVE's name attribute.
+ * @return {pcurve} The matching pcurve.
+ */
+function pcurveNamed(name) {
+    const found = Array.from(model.types(pcurve)).find((item) => item.name === name);
+    expect(found).toBeDefined();
+    return found;
+}
+/**
+ * Extract a pcurve through extractCurve - the arm that dispatches to
+ * extractPScurve1 - and read its points out.
+ *
+ * @param name The PCURVE's name attribute.
+ * @return {Vector3[]} The extracted curve's points, empty if it was dropped.
+ */
+function extractedPoints(name) {
+    const curve = extraction.extractCurve(pcurveNamed(name));
+    if (curve === void 0) {
+        return [];
+    }
+    const points = [];
+    for (let index = 0; index < curve.getPointsSize(); ++index) {
+        points.push(curve.get3d(index));
+    }
+    return points;
+}
+/**
+ * Find a buffered warning containing a given fragment.
+ *
+ * @param fragment Text the message must contain.
+ * @return {LogEntry | undefined} The matching entry.
+ */
+function warningContaining(fragment) {
+    return Logger.getLogs().find((entry) => entry.level === "warning" && entry.message.includes(fragment));
+}
+describe("AP214 pcurve basis surfaces (bldrs-ai/conway#505)", () => {
+    beforeAll(async () => {
+        Logger.clearLogs();
+        // The b-spline basis surface warns by design below, and the echo would be
+        // noise in the test console. The buffer these tests read is filled
+        // regardless of the console threshold.
+        const threshold = Logger.getLogLevel();
+        Logger.setLogLevel(LogLevel.OFF);
+        try {
+            expect(await initialize()).toBe(true);
+        }
+        finally {
+            Logger.setLogLevel(threshold);
+        }
+    });
+    // (u, v) walks a straight line from (0, 0) to (pi, 20): a half turn of the
+    // cylinder while climbing its full height, which is a helix arc and not the
+    // chord across it.
+    test("a cylindrical basis surface maps (u, v) onto the cylinder", () => {
+        const points = extractedPoints("cylinder");
+        // More points than the parameter curve has: the angular span is
+        // subdivided rather than chorded across.
+        expect(points.length).toBeGreaterThan(PARAMETER_SAMPLES);
+        let previousZ = -Infinity;
+        for (const point of points) {
+            expect(Math.sqrt((point.x * point.x) + (point.y * point.y)))
+                .toBeCloseTo(CYLINDER_RADIUS, PRECISION_DIGITS);
+            // v maps to height along the axis, so it climbs with the parameter.
+            expect(point.z).toBeGreaterThanOrEqual(previousZ - MONOTONIC_EPSILON);
+            previousZ = point.z;
+        }
+        const first = points[0];
+        const last = points[points.length - 1];
+        expect(first.x).toBeCloseTo(CYLINDER_RADIUS, PRECISION_DIGITS);
+        expect(first.y).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(first.z).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(last.x).toBeCloseTo(-CYLINDER_RADIUS, PRECISION_DIGITS);
+        expect(last.y).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(last.z).toBeCloseTo(CYLINDER_TOP, PRECISION_DIGITS);
+    });
+    // A generator line at u = 0 on a cone whose placement is offset and turned a
+    // quarter turn about z, so the local frame has to be applied for the mapped
+    // points to land: local +x is world +y here.
+    //
+    // This also pins the cone's v convention, the point a review of this code
+    // queried (bldrs-ai/conway#520): ISO 10303-42 measures v along the axis, so
+    // the far end is a ring of 10 + 20 tan(30 deg) = 21.547005 at an axial 20,
+    // landing at (5, 18.547005, 70). Were v distance along the generator, the
+    // same (0, 20) would give a ring of 10 + 20 sin(30 deg) = 20 at an axial
+    // 20 cos(30 deg), i.e. (5, 17, 67.320508), and both of the assertions on
+    // `last` below would fail.
+    test("a conical basis surface applies the taper and the placement frame", () => {
+        const points = extractedPoints("cone");
+        expect(points.length).toBeGreaterThan(1);
+        const first = points[0];
+        const last = points[points.length - 1];
+        expect(first.x).toBeCloseTo(CONE_ORIGIN_X, PRECISION_DIGITS);
+        expect(first.y).toBeCloseTo(CONE_ORIGIN_Y + CONE_BASE_RADIUS, PRECISION_DIGITS);
+        expect(first.z).toBeCloseTo(CONE_ORIGIN_Z, PRECISION_DIGITS);
+        // Radius at the far end is base + height * tan(30 degrees).
+        expect(last.x).toBeCloseTo(CONE_ORIGIN_X, PRECISION_DIGITS);
+        expect(last.y).toBeCloseTo(CONE_ORIGIN_Y + CONE_TOP_RADIUS, PRECISION_DIGITS);
+        expect(last.z).toBeCloseTo(CONE_ORIGIN_Z + CONE_HEIGHT, PRECISION_DIGITS);
+    });
+    // u sweeps a quarter turn at a fixed latitude of 30 degrees.
+    test("a spherical basis surface maps latitude to height", () => {
+        const points = extractedPoints("sphere");
+        expect(points.length).toBeGreaterThan(2);
+        for (const point of points) {
+            expect(Math.sqrt((point.x * point.x) + (point.y * point.y) + (point.z * point.z)))
+                .toBeCloseTo(SPHERE_RADIUS, PRECISION_DIGITS);
+            expect(point.z).toBeCloseTo(SPHERE_HEIGHT, PRECISION_DIGITS);
+        }
+        const first = points[0];
+        const last = points[points.length - 1];
+        expect(first.x).toBeCloseTo(SPHERE_RING_RADIUS, PRECISION_DIGITS);
+        expect(first.y).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(last.x).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(last.y).toBeCloseTo(SPHERE_RING_RADIUS, PRECISION_DIGITS);
+    });
+    // v walks half way around the tube at a fixed u, from the outer equator to
+    // the inner one.
+    test("a toroidal basis surface maps the tube angle", () => {
+        const points = extractedPoints("torus");
+        expect(points.length).toBeGreaterThan(2);
+        for (const point of points) {
+            const planar = Math.sqrt((point.x * point.x) + (point.y * point.y));
+            const fromTubeCentre = Math.sqrt(((planar - TORUS_MAJOR_RADIUS) * (planar - TORUS_MAJOR_RADIUS)) +
+                (point.z * point.z));
+            expect(fromTubeCentre).toBeCloseTo(TORUS_MINOR_RADIUS, PRECISION_DIGITS);
+        }
+        const first = points[0];
+        const last = points[points.length - 1];
+        expect(first.x).toBeCloseTo(TORUS_OUTER, PRECISION_DIGITS);
+        expect(first.z).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(last.x).toBeCloseTo(TORUS_INNER, PRECISION_DIGITS);
+        expect(last.z).toBeCloseTo(0, PRECISION_DIGITS);
+    });
+    // The planar case the extractor already claimed to support: (u, v) are
+    // distances along the placement's x and y axes, so the parameter curve's
+    // (4, 7) lands 4 and 7 from an origin at (1, 2, 3).
+    test("a planar basis surface maps (u, v) along the placement axes", () => {
+        const points = extractedPoints("plane");
+        expect(points.length).toBe(2);
+        expect(points[0].x).toBeCloseTo(PLANE_ORIGIN.x, PRECISION_DIGITS);
+        expect(points[0].y).toBeCloseTo(PLANE_ORIGIN.y, PRECISION_DIGITS);
+        expect(points[0].z).toBeCloseTo(PLANE_ORIGIN.z, PRECISION_DIGITS);
+        expect(points[1].x).toBeCloseTo(PLANE_END.x, PRECISION_DIGITS);
+        expect(points[1].y).toBeCloseTo(PLANE_END.y, PRECISION_DIGITS);
+        expect(points[1].z).toBeCloseTo(PLANE_END.z, PRECISION_DIGITS);
+    });
+    // The residue: dropped, but under a message that names the basis surface so
+    // the family can be sized per type rather than as one undifferentiated row.
+    test("an unsupported basis surface is dropped with its type named", () => {
+        expect(extractedPoints("bspline").length).toBe(0);
+        const warning = warningContaining("Unsupported PCURVE basis surface");
+        expect(warning).toBeDefined();
+        expect(warning.message).toContain("B_SPLINE_SURFACE_WITH_KNOTS");
+        expect(warning.expressIDs.has(String(pcurveNamed("bspline").expressID))).toBe(true);
+    });
+    // The pcurve here is one variant of a complex instance that also carries a
+    // SURFACE_CURVE; its curve_3d runs +y from (25, 0, 0), which the pcurve's
+    // own parameter curve (a helix on the cylinder) never touches.
+    test("an explicit curve_3d on the same instance beats the mapping", () => {
+        const points = extractedPoints("complex");
+        expect(points.length).toBe(2);
+        expect(points[0].x).toBeCloseTo(CYLINDER_RADIUS, PRECISION_DIGITS);
+        expect(points[0].y).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(points[0].z).toBeCloseTo(0, PRECISION_DIGITS);
+        expect(points[1].x).toBeCloseTo(CYLINDER_RADIUS, PRECISION_DIGITS);
+        expect(points[1].y).toBeCloseTo(CURVE_3D_END_Y, PRECISION_DIGITS);
+        expect(points[1].z).toBeCloseTo(0, PRECISION_DIGITS);
+    });
+});

package/compiled/src/AP214E3_2010/ap214_sphere_vertex_loop.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ap214_sphere_vertex_loop.test.d.ts.map

package/compiled/src/AP214E3_2010/ap214_sphere_vertex_loop.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ap214_sphere_vertex_loop.test.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_sphere_vertex_loop.test.ts"],"names":[],"mappings":""}

package/compiled/src/AP214E3_2010/ap214_sphere_vertex_loop.test.js

@@ -0,0 +1,147 @@
+import fs from "fs";
+import { describe, expect, test, beforeAll } from "@jest/globals";
+import { AP214GeometryExtraction } from "./ap214_geometry_extraction.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import AP214StepParser from "./ap214_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import { ExtractResult } from "../core/shared_constants.js";
+/* eslint-disable no-magic-numbers -- the fixture's radius, the reified vertex
+   layout (6 floats) and 4x4 matrix element indices all read more clearly as
+   literals here than as named constants. */
+/**
+ * A whole sphere as OCCT writes one: a single `ADVANCED_FACE` on a
+ * `SPHERICAL_SURFACE`, bounded by a single `VERTEX_LOOP` at the north
+ * pole. ISO 10303-42 reads a lone degenerate loop as covering the entire
+ * surface — the vertex marks a pole, it does not trim anything.
+ *
+ * This shape used to load as ZERO meshes, silently: one point constrains
+ * no CDT, so the dual-hemisphere unwrap produced no triangles and nothing
+ * downstream could tell "trimmed away to nothing" from "never
+ * triangulated". See https://github.com/bldrs-ai/conway/issues/461.
+ */
+const FIXTURE = "data/sphere-vertex-loop.step";
+/** The fixture's radius, in its own (millimetre) file coordinates. */
+const RADIUS_MM = 15;
+/**
+ * Fractional slack. The fallback emits a 48x24 parametric grid, which
+ * inscribes the true sphere, so every measured quantity sits slightly
+ * under the analytic value — hence a tolerance wide enough for chord
+ * error rather than one that only covers floating point.
+ */
+const TOLERANCE = 0.02;
+let scene;
+let conwayGeometry;
+beforeAll(async () => {
+    const parser = AP214StepParser.Instance;
+    const buffer = new ParsingBuffer(fs.readFileSync(FIXTURE));
+    expect(parser.parseHeader(buffer)[1]).toBe(ParseResult.COMPLETE);
+    const [, parsed] = parser.parseDataToModel(buffer);
+    expect(parsed).not.toBe(void 0);
+    conwayGeometry = new ConwayGeometry();
+    expect(await conwayGeometry.initialize()).toBe(true);
+    const [result, sceneBuilder] = new AP214GeometryExtraction(conwayGeometry, parsed).extractAP214GeometryData();
+    expect(result).toBe(ExtractResult.COMPLETE);
+    scene = sceneBuilder;
+});
+/**
+ * Every vertex in the scene, in file coordinates (no transform applied —
+ * this fixture has a single mesh at the origin, and the unit scale is the
+ * subject of a different test).
+ *
+ * @return Flat [x, y, z] triples, in vertex-buffer order.
+ */
+function vertices() {
+    const wasm = conwayGeometry.wasmModule;
+    const points = [];
+    for (const [, , mesh] of scene.walk()) {
+        const geometry = mesh.geometry;
+        const floatCount = geometry.GetVertexDataSize();
+        // Reified layout: 6 floats per vertex, position xyz then normal xyz.
+        // Read into a copy immediately — HEAPF32 views detach on wasm growth.
+        const data = wasm.HEAPF32.slice(geometry.GetVertexData() / 4, (geometry.GetVertexData() / 4) + floatCount);
+        for (let where = 0; where < floatCount; where += 6) {
+            points.push([data[where], data[where + 1], data[where + 2]]);
+        }
+    }
+    return points;
+}
+/**
+ * Every triangle in the scene, as three positions.
+ *
+ * The reified vertex buffer is NOT triangle soup — it is indexed, and its
+ * vertex count is not even a multiple of three — so triangles have to be
+ * assembled through the index buffer rather than by walking vertices in
+ * threes.
+ *
+ * @return Triples of [x, y, z] triples.
+ */
+function triangles() {
+    const wasm = conwayGeometry.wasmModule;
+    const result = [];
+    for (const [, , mesh] of scene.walk()) {
+        const geometry = mesh.geometry;
+        const floatCount = geometry.GetVertexDataSize();
+        const data = wasm.HEAPF32.slice(geometry.GetVertexData() / 4, (geometry.GetVertexData() / 4) + floatCount);
+        const indexCount = geometry.GetIndexDataSize();
+        const indices = wasm.HEAPU32.slice(geometry.GetIndexData() / 4, (geometry.GetIndexData() / 4) + indexCount);
+        /**
+         * @param index Vertex index into the reified buffer.
+         * @return The vertex position.
+         */
+        const at = (index) => [data[index * 6], data[(index * 6) + 1], data[(index * 6) + 2]];
+        for (let where = 0; where + 2 < indexCount; where += 3) {
+            result.push([at(indices[where]), at(indices[where + 1]), at(indices[where + 2])]);
+        }
+    }
+    return result;
+}
+describe("AP214 spherical surface bounded by a vertex loop", () => {
+    test("a whole sphere produces geometry at all (issue #461)", () => {
+        // The regression this pins is silence, not wrongness: before the
+        // full-surface fallback this walked zero meshes and reported no error.
+        const points = vertices();
+        expect(points.length).toBeGreaterThan(0);
+    });
+    test("every vertex lies on the sphere of the declared radius", () => {
+        const points = vertices();
+        // Not decoration: without it this whole test passes vacuously when the
+        // sphere produces no geometry — which is the exact defect the suite
+        // exists to catch. Confirmed by disabling the fallback and watching
+        // this case stay green while its two siblings went red.
+        expect(points.length).toBeGreaterThan(0);
+        // Cheap and total, rather than sampling: if the fallback ever emits a
+        // grid on the wrong radius, centre, or axis, at least one point moves
+        // off the surface. A grid inscribes the sphere, so points may sit
+        // slightly inside, never outside.
+        for (const [x, y, z] of points) {
+            const radius = Math.hypot(x, y, z);
+            expect(radius).toBeGreaterThan(RADIUS_MM * (1 - TOLERANCE));
+            expect(radius).toBeLessThan(RADIUS_MM * (1 + 0.000001));
+        }
+    });
+    test("the sphere is closed, so the area-weighted normal sum vanishes", () => {
+        // Orientation check, and the reason it is worth having: a closed
+        // oriented surface has its triangle area-vectors cancel exactly. If
+        // the grid's winding were inconsistent — the defect class of #459 and
+        // #463 — this residual would be a large fraction of the total area
+        // while the per-vertex radius test above stayed perfectly green.
+        const faces = triangles();
+        expect(faces.length).toBeGreaterThan(0);
+        const sum = [0, 0, 0];
+        let area = 0;
+        for (const [[ax, ay, az], [bx, by, bz], [cx, cy, cz]] of faces) {
+            const ux = bx - ax, uy = by - ay, uz = bz - az;
+            const vx = cx - ax, vy = cy - ay, vz = cz - az;
+            const nx = (uy * vz) - (uz * vy);
+            const ny = (uz * vx) - (ux * vz);
+            const nz = (ux * vy) - (uy * vx);
+            sum[0] += nx;
+            sum[1] += ny;
+            sum[2] += nz;
+            area += Math.hypot(nx, ny, nz);
+        }
+        expect(area).toBeGreaterThan(0);
+        expect(Math.hypot(sum[0], sum[1], sum[2]) / area).toBeLessThan(0.001);
+    });
+});

package/compiled/src/AP214E3_2010/ap214_step_model.d.ts

@@ -1,6 +1,7 @@
 import EntityTypesAP214 from "./AP214E3_2010_gen/entity_types_ap214.gen.js";
 import StepModelBase from "../step/step_model_base.js";
 import { StepIndexEntry } from "../step/parsing/step_parser.js";
+import { StepIndexColumns } from "../step/parsing/columnar_index.js";
 import { MultiIndexSet } from "../indexing/multi_index_set.js";
 import { AP214ModelGeometry } from "./ap214_model_geometry.js";
 import { AP214ModelProfile } from "./ap214_model_profile.js";
@@ -26,6 +27,6 @@ export default class AP214StepModel extends StepModelBase<EntityTypesAP214> {
      * @param buffer The buffer to values from.
      * @param elementIndex The parsed index to elements in the STEP.
      */
-    constructor(buffer: Uint8Array, elementIndex: StepIndexEntry<EntityTypesAP214>[]);
+    constructor(buffer: Uint8Array, elementIndex: StepIndexEntry<EntityTypesAP214>[] | StepIndexColumns<EntityTypesAP214>);
 }
 //# sourceMappingURL=ap214_step_model.d.ts.map

package/compiled/src/AP214E3_2010/ap214_step_model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ap214_step_model.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAyC,MAAM,2CAA2C,CAAA;AACjG,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,wBAAwB,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,gBAAgB,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,aAAa,CAAE,gBAAgB,CAAE;IAE3E,SAAgB,SAAS,EAAE,aAAa,CAAE,gBAAgB,CAAE,CAAA;IAC5D,SAAgB,mBAAmB,kCAA2B;IAC9D,SAAgB,QAAQ,qBAA2B;IACnD,SAAgB,SAAS,qBAA2B;IACpD,SAAgB,QAAQ,oBAA0B;IAClD,SAAgB,MAAM,mBAA6B;IACnD,SAAgB,aAAa,iBAAuB;IAEpD;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,gBAAgB,CAAE,EAAE;CAKvD"}
+{"version":3,"file":"ap214_step_model.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAyC,MAAM,2CAA2C,CAAA;AACjG,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAA;AAE/D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,wBAAwB,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,gBAAgB,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,aAAa,CAAE,gBAAgB,CAAE;IAE3E,SAAgB,SAAS,EAAE,aAAa,CAAE,gBAAgB,CAAE,CAAA;IAC5D,SAAgB,mBAAmB,kCAA2B;IAC9D,SAAgB,QAAQ,qBAA2B;IACnD,SAAgB,SAAS,qBAA2B;IACpD,SAAgB,QAAQ,oBAA0B;IAClD,SAAgB,MAAM,mBAA6B;IACnD,SAAgB,aAAa,iBAAuB;IAEpD;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,gBAAgB,CAAE,EAAE,GAAG,gBAAgB,CAAE,gBAAgB,CAAE;CAK9F"}

package/compiled/src/AP214E3_2010/ap214_step_model.js

@@ -28,6 +28,6 @@ export default class AP214StepModel extends StepModelBase {
         this.profiles = new AP214ModelProfile();
         this.curves = new AP214ModelCurves(this);
         this.csgOperations = new CsgMemoization();
-        this.typeIndex = indexerInstance.create(elementIndex);
+        this.typeIndex = indexerInstance.createFor(elementIndex);
     }
 }

package/compiled/src/AP214E3_2010/ap214_typed_select_enum.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ap214_typed_select_enum.test.d.ts.map

package/compiled/src/AP214E3_2010/ap214_typed_select_enum.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ap214_typed_select_enum.test.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_typed_select_enum.test.ts"],"names":[],"mappings":""}