@pascal-app/ifc-converter 1.0.6 → 1.0.7

package/README.md

@@ -35,6 +35,7 @@ The importer writes intent for Pascal's room-first model; the scene load
 migrations (room adoption, floor plates) and the structure kernel turn it into
 rooms, floor plates and ceilings. `tests/room-first-load.test.ts` converts the
 reference files and runs that load chain.
+
 - **Walls.** Merged collinear fragments, then every straight wall end moves
   along its axis onto the centreline it meets (L and T joins; ends inside
   another wall's body reach its centreline, `IfcRelConnectsPathElements` widens

package/dist/export/scene-to-ifc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-to-ifc.d.ts","sourceRoot":"","sources":["../../src/export/scene-to-ifc.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,UAAU,EAoChB,MAAM,kBAAkB,CAAA;AAyBzB,0FAA0F;AAC1F,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC5B,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC3B,+BAA+B;IAC/B,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;IAClD,oGAAoG;IACpG,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,sDAAsD;IACtD,SAAS,CAAC,EAAE,IAAI,CAAA;IAChB,qFAAqF;IACrF,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,GAAG,YAAY,GAAG,UAAU,CAAA;CAClD;AAED,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,gBAAgB,CAAA;CAC1B;AAoMD,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CAm1CrE;AAiCD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAE9D"}
+{"version":3,"file":"scene-to-ifc.d.ts","sourceRoot":"","sources":["../../src/export/scene-to-ifc.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,UAAU,EAsChB,MAAM,kBAAkB,CAAA;AAyBzB,0FAA0F;AAC1F,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC5B,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC3B,+BAA+B;IAC/B,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;IAClD,oGAAoG;IACpG,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,sDAAsD;IACtD,SAAS,CAAC,EAAE,IAAI,CAAA;IAChB,qFAAqF;IACrF,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,GAAG,YAAY,GAAG,UAAU,CAAA;CAClD;AAED,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,gBAAgB,CAAA;CAC1B;AAoMD,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CA+1CrE;AAiCD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAE9D"}

package/dist/export/scene-to-ifc.js

@@ -1,4 +1,4 @@
-import { calculateLevelMiters, DEFAULT_WALL_THICKNESS, difference, getLevelElevations, getOpeningWallCut, getRenderableSlabPolygon, getWallAssemblyPreset, getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, getWallPlanFootprint, getWallTop, hidesDescendants, intersection, isCurvedWall, liftedManualSlab, measureStair, prepareSlabPolygonContext, resolveCeilingHeight, resolveWallExteriorSide, sampleWallCenterline, union, wallSupportForNodes, } from '@pascal-app/core';
+import { calculateLevelMiters, DEFAULT_WALL_THICKNESS, difference, getDoorOpeningSize, getLevelElevations, getOpeningWallCut, getRenderableSlabPolygon, getWallAssemblyPreset, getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, getWallPlanFootprint, getWallTop, hidesDescendants, intersection, isCurvedWall, liftedManualSlab, measureStair, openingHostFacing, prepareSlabPolygonContext, resolveCeilingHeight, resolveWallExteriorSide, sampleWallCenterline, union, wallSupportForNodes, } from '@pascal-app/core';
 import { doorGlazingFraction, doorOperationForIfc } from './door-operation';
 import { bool, cleanRing, DERIVED, enumValue, frameToLocal, IDENTITY_FRAME, IfcModel, identifier, int, label, logical, ratio, relativeFrame, } from './ifc-model';
 import { typed } from './step';
@@ -682,10 +682,14 @@ export function buildIfcExport(input) {
                     angle: Math.atan2(-curve.tangent.y, curve.tangent.x),
                 };
                 const cutBottom = (cut?.bottom ?? nominalBottom) - nominalBottom;
-                const cutDepth = (cut?.top ?? nominalBottom + opening.height) - (cut?.bottom ?? nominalBottom);
+                const openingSize = getDoorOpeningSize(opening);
+                const cutDepth = (cut?.top ?? nominalBottom + openingSize.height) - (cut?.bottom ?? nominalBottom);
+                const cutOffset = isCurvedWall(wall)
+                    ? 0
+                    : openingSize.leafOffsetX * openingHostFacing(opening);
                 let openingRef = null;
                 let openingPlacement = null;
-                if (cutDepth > 1e-4 && opening.width > 1e-4) {
+                if (cutDepth > 1e-4 && openingSize.width > 1e-4) {
                     let profile;
                     const band = isCurvedWall(wall) && cut
                         ? cleanRing(cut.band.map(([x, z]) => {
@@ -697,8 +701,16 @@ export function buildIfcExport(input) {
                     if (band.length > 0)
                         profile = model.polygonProfile(band);
                     else
-                        profile = model.rectangleProfile(opening.width, thickness + 0.2);
-                    openingPlacement = model.localPlacement(wallPlacement, relativeFrame(frame, openingFrame));
+                        profile = model.rectangleProfile(openingSize.width, thickness + 0.2);
+                    const cutFrame = {
+                        ...openingFrame,
+                        origin: [
+                            openingFrame.origin[0] - cutOffset * curve.tangent.x,
+                            openingFrame.origin[1] + cutOffset * curve.tangent.y,
+                            nominalBottom,
+                        ],
+                    };
+                    openingPlacement = model.localPlacement(wallPlacement, relativeFrame(frame, cutFrame));
                     openingRef = step.add('IFCOPENINGELEMENT', model.guid(`${opening.id}:opening`), ownerHistory, `${nodeName(opening, opening.type === 'door' ? 'Door' : 'Window')} opening`, null, null, openingPlacement, model.shape([
                         model.bodyRepresentation('SweptSolid', [
                             model.extrusion(profile, cutBottom, cutDepth),
@@ -720,7 +732,7 @@ export function buildIfcExport(input) {
                     ]);
                 }
                 const elementPlacement = openingPlacement
-                    ? model.localPlacement(openingPlacement, IDENTITY_FRAME)
+                    ? model.localPlacement(openingPlacement, { origin: [cutOffset, 0, 0], angle: 0 })
                     : model.localPlacement(storey.placement, openingFrame);
                 const fill = emitElement(meshClassFor(opening), opening.id, opening, nodeName(opening, opening.type === 'door' ? 'Door' : 'Window'), elementPlacement, body);
                 storey.contained.push(fill);

package/dist/geometry-validity.d.ts

@@ -0,0 +1,45 @@
+/**
+ * What a conversion could not read and left out or replaced, instead of failing the whole file
+ * on one bad number (a NaN vertex used to reject every imported mesh with
+ * "Could not build imported mesh node at primitives.0.positions.0").
+ */
+export interface IfcConversionReport {
+    skippedGeometry: {
+        /** Placed geometries whose placement matrix had a non-finite entry. */
+        transforms: number;
+        /** Vertices with a non-finite position. */
+        vertices: number;
+        /** Triangles that used a skipped or missing vertex. */
+        triangles: number;
+        /** Mesh pieces left with no valid triangle. */
+        primitives: number;
+        /** Elements left out because none of their geometry could be read. */
+        elements: number;
+    };
+    /** Values that were not finite and fell back to a neutral default. */
+    replaced: {
+        unitFactor: boolean;
+        originOffset: boolean;
+        levelElevations: number;
+        /** Vertex normals recomputed from the faces around them: shading only, nothing lost. */
+        normals: number;
+    };
+}
+export declare function emptyConversionReport(): IfcConversionReport;
+/** True when the report has anything to tell the person (a recomputed normal loses nothing). */
+export declare function conversionReportHasIssues(report: IfcConversionReport): boolean;
+export declare function isFiniteMatrix(matrix: ArrayLike<number> | null | undefined): boolean;
+export interface MeshBuffers {
+    positions: number[];
+    normals: number[];
+    indices: number[];
+}
+/**
+ * Drops vertices with a non-finite position and every triangle that uses one (or an index past
+ * the vertex count), then compacts the vertex buffers to the vertices still used. A non-finite
+ * normal on a kept vertex is shading, not shape: it is recomputed from the kept triangles around
+ * it (zero when they have no area). Returns null when no triangle survives; a source with
+ * triangles that all fail counts as a skipped primitive.
+ */
+export declare function keepValidTriangles(mesh: MeshBuffers, report: IfcConversionReport): MeshBuffers | null;
+//# sourceMappingURL=geometry-validity.d.ts.map

package/dist/geometry-validity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-validity.d.ts","sourceRoot":"","sources":["../src/geometry-validity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE;QACf,uEAAuE;QACvE,UAAU,EAAE,MAAM,CAAA;QAClB,2CAA2C;QAC3C,QAAQ,EAAE,MAAM,CAAA;QAChB,uDAAuD;QACvD,SAAS,EAAE,MAAM,CAAA;QACjB,+CAA+C;QAC/C,UAAU,EAAE,MAAM,CAAA;QAClB,sEAAsE;QACtE,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;IACD,sEAAsE;IACtE,QAAQ,EAAE;QACR,UAAU,EAAE,OAAO,CAAA;QACnB,YAAY,EAAE,OAAO,CAAA;QACrB,eAAe,EAAE,MAAM,CAAA;QACvB,wFAAwF;QACxF,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;CACF;AAED,wBAAgB,qBAAqB,IAAI,mBAAmB,CAK3D;AAED,gGAAgG;AAChG,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAa9E;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAIpF;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,mBAAmB,GAC1B,WAAW,GAAG,IAAI,CAqDpB"}

package/dist/geometry-validity.js

@@ -0,0 +1,138 @@
+export function emptyConversionReport() {
+    return {
+        skippedGeometry: { transforms: 0, vertices: 0, triangles: 0, primitives: 0, elements: 0 },
+        replaced: { unitFactor: false, originOffset: false, levelElevations: 0, normals: 0 },
+    };
+}
+/** True when the report has anything to tell the person (a recomputed normal loses nothing). */
+export function conversionReportHasIssues(report) {
+    const { skippedGeometry, replaced } = report;
+    return (skippedGeometry.transforms +
+        skippedGeometry.vertices +
+        skippedGeometry.triangles +
+        skippedGeometry.primitives +
+        skippedGeometry.elements +
+        replaced.levelElevations >
+        0 ||
+        replaced.unitFactor ||
+        replaced.originOffset);
+}
+export function isFiniteMatrix(matrix) {
+    if (!matrix || matrix.length < 16)
+        return false;
+    for (let i = 0; i < 16; i++)
+        if (!Number.isFinite(matrix[i]))
+            return false;
+    return true;
+}
+/**
+ * Drops vertices with a non-finite position and every triangle that uses one (or an index past
+ * the vertex count), then compacts the vertex buffers to the vertices still used. A non-finite
+ * normal on a kept vertex is shading, not shape: it is recomputed from the kept triangles around
+ * it (zero when they have no area). Returns null when no triangle survives; a source with
+ * triangles that all fail counts as a skipped primitive.
+ */
+export function keepValidTriangles(mesh, report) {
+    const skipped = report.skippedGeometry;
+    const triangleCount = Math.floor(mesh.indices.length / 3);
+    if (triangleCount === 0)
+        return null;
+    const vertexCount = Math.floor(mesh.positions.length / 3);
+    const valid = new Uint8Array(vertexCount);
+    for (let vertex = 0; vertex < vertexCount; vertex++) {
+        if (finiteTriple(mesh.positions, vertex))
+            valid[vertex] = 1;
+        else
+            skipped.vertices++;
+    }
+    const remap = new Int32Array(vertexCount).fill(-1);
+    const positions = [];
+    const normals = [];
+    const indices = [];
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+        const corners = [
+            mesh.indices[triangle * 3],
+            mesh.indices[triangle * 3 + 1],
+            mesh.indices[triangle * 3 + 2],
+        ];
+        if (!corners.every((index) => Number.isInteger(index) && index >= 0 && index < vertexCount && valid[index])) {
+            skipped.triangles++;
+            continue;
+        }
+        for (const index of corners) {
+            if (remap[index] === -1) {
+                remap[index] = positions.length / 3;
+                positions.push(mesh.positions[index * 3], mesh.positions[index * 3 + 1], mesh.positions[index * 3 + 2]);
+                normals.push(mesh.normals[index * 3], mesh.normals[index * 3 + 1], mesh.normals[index * 3 + 2]);
+            }
+            indices.push(remap[index]);
+        }
+    }
+    if (indices.length === 0) {
+        skipped.primitives++;
+        return null;
+    }
+    report.replaced.normals += recomputeNonFiniteNormals(positions, normals, indices);
+    return { positions, normals, indices };
+}
+function finiteTriple(values, vertex) {
+    return (Number.isFinite(values[vertex * 3]) &&
+        Number.isFinite(values[vertex * 3 + 1]) &&
+        Number.isFinite(values[vertex * 3 + 2]));
+}
+// A vertex whose faces have no area has no direction to take; a unit normal keeps lighting sane.
+const FALLBACK_NORMAL = [0, 0, 1];
+/**
+ * Each non-finite normal becomes the area-weighted normal of the triangles at its vertex, or the
+ * fallback when they have no area. Returns how many were recomputed. Accumulates in typed arrays:
+ * a whole mesh can need it (__bench__/normal-recompute.bench.ts).
+ */
+function recomputeNonFiniteNormals(positions, normals, indices) {
+    const vertexCount = positions.length / 3;
+    const slotOf = new Int32Array(vertexCount).fill(-1);
+    let broken = 0;
+    for (let vertex = 0; vertex < vertexCount; vertex++)
+        if (!finiteTriple(normals, vertex))
+            slotOf[vertex] = broken++;
+    if (broken === 0)
+        return 0;
+    const sums = new Float64Array(broken * 3);
+    for (let t = 0; t + 2 < indices.length; t += 3) {
+        const a = indices[t];
+        const b = indices[t + 1];
+        const c = indices[t + 2];
+        if (slotOf[a] < 0 && slotOf[b] < 0 && slotOf[c] < 0)
+            continue;
+        const ux = positions[b * 3] - positions[a * 3];
+        const uy = positions[b * 3 + 1] - positions[a * 3 + 1];
+        const uz = positions[b * 3 + 2] - positions[a * 3 + 2];
+        const vx = positions[c * 3] - positions[a * 3];
+        const vy = positions[c * 3 + 1] - positions[a * 3 + 1];
+        const vz = positions[c * 3 + 2] - positions[a * 3 + 2];
+        const fx = uy * vz - uz * vy;
+        const fy = uz * vx - ux * vz;
+        const fz = ux * vy - uy * vx;
+        for (const corner of [a, b, c]) {
+            const slot = slotOf[corner];
+            if (slot < 0)
+                continue;
+            sums[slot * 3] += fx;
+            sums[slot * 3 + 1] += fy;
+            sums[slot * 3 + 2] += fz;
+        }
+    }
+    for (let vertex = 0; vertex < vertexCount; vertex++) {
+        const slot = slotOf[vertex];
+        if (slot < 0)
+            continue;
+        const x = sums[slot * 3];
+        const y = sums[slot * 3 + 1];
+        const z = sums[slot * 3 + 2];
+        // Coordinates past ~1e154 overflow the summed cross products: Infinity, not a direction.
+        const length = Math.hypot(x, y, z);
+        const normal = length > 0 && Number.isFinite(length) ? [x / length, y / length, z / length] : FALLBACK_NORMAL;
+        for (let axis = 0; axis < 3; axis++)
+            normals[vertex * 3 + axis] = Math.round(normal[axis] * 1000) / 1000 || 0;
+    }
+    return broken;
+}

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { type AnyNode, type AnyNodeId, type Collection } from '@pascal-app/core';
 import { type IfcConversionSimplificationOptions } from './cleanup';
+import { type IfcConversionReport } from './geometry-validity';
 export type { IfcConversionSimplificationOptions, IfcConversionSimplificationStats, } from './cleanup';
+export { conversionReportHasIssues, type IfcConversionReport } from './geometry-validity';
 export type PascalNode = AnyNode;
 export interface PascalSceneGraph {
     nodes: Record<AnyNodeId, AnyNode>;
@@ -12,9 +14,20 @@ export interface ConversionOptions {
     extrusionDepthIsHeight?: boolean;
     swapProfileDimensions?: boolean;
     wasmPath?: string;
+    /**
+     * The URL to load one of web-ifc's wasm files from (`web-ifc.wasm`, or `web-ifc-mt.wasm` when
+     * the page is cross-origin isolated). Wins over `wasmPath`; lets a host serve a versioned or
+     * cache-busted URL.
+     */
+    locateWasmFile?: (fileName: string) => string;
     simplify?: boolean | IfcConversionSimplificationOptions;
     label?: string;
 }
 export declare const VARIANT_PRESETS: Record<string, ConversionOptions>;
 export declare function convertIfcToPascal(ifcData: Uint8Array, onProgress?: (message: string, percent: number) => void, options?: ConversionOptions): Promise<PascalSceneGraph>;
+/** `convertIfcToPascal`, plus what the conversion had to skip or replace to finish. */
+export declare function convertIfcToPascalWithReport(ifcData: Uint8Array, onProgress?: (message: string, percent: number) => void, options?: ConversionOptions): Promise<{
+    scene: PascalSceneGraph;
+    report: IfcConversionReport;
+}>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,UAAU,EAmBhB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,KAAK,kCAAkC,EAA+B,MAAM,WAAW,CAAA;AAQhG,YAAY,EACV,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,WAAW,CAAA;AAElB,MAAM,MAAM,UAAU,GAAG,OAAO,CAAA;AAEhC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACzC;AAiyBD,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,GAAG,kCAAkC,CAAA;IACvD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAa7D,CAAA;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACvD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CA8/D3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,UAAU,EAmBhB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,KAAK,kCAAkC,EAA+B,MAAM,WAAW,CAAA;AAGhG,OAAO,EAEL,KAAK,mBAAmB,EAGzB,MAAM,qBAAqB,CAAA;AAM5B,YAAY,EACV,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,yBAAyB,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEzF,MAAM,MAAM,UAAU,GAAG,OAAO,CAAA;AAEhC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACzC;AAuyBD,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;IAC7C,QAAQ,CAAC,EAAE,OAAO,GAAG,kCAAkC,CAAA;IACvD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAa7D,CAAA;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACvD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAE3B;AAED,uFAAuF;AACvF,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACvD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAshEnE"}

package/dist/index.js

@@ -1,13 +1,16 @@
 import { BlockNode, BuildingNode, CeilingNode, ColumnNode, containsPoint, DEFAULT_LEVEL_HEIGHT, DEFAULT_WALL_HEIGHT, DEFAULT_WALL_THICKNESS, DoorNode, GROUND_SUPPORT_ID, ImportedMeshNode, LevelNode, polygonInteriorPoint, RoofNode, SiteNode, SlabNode, WallNode, WindowNode, ZoneNode, zoneColorForSeed, } from '@pascal-app/core';
+import { NEW_DOOR_FRAME_THICKNESS } from '@pascal-app/core/building';
 import * as WebIFC from 'web-ifc';
 import { extractBeamGeometry } from './beam-geometry';
 import { simplifyConvertedSceneGraph } from './cleanup';
 import { importCollections } from './collections';
 import { doorGlazingStyle, doorStyleFromIfcOperation } from './door-semantics';
+import { emptyConversionReport, isFiniteMatrix, keepValidTriangles, } from './geometry-validity';
 import { nextId, seedIds } from './ids';
 import { applyRoomFirstStructure } from './room-first';
 import { selectStoreyForElevation } from './storey-semantics';
 import { redundantWallIds } from './wall-joins';
+export { conversionReportHasIssues } from './geometry-validity';
 function meta(node) {
     return (node?.metadata ?? {});
 }
@@ -534,7 +537,7 @@ function roundMeshNormal(value) {
     const rounded = Math.round(value * 1000) / 1000;
     return rounded === 0 ? 0 : rounded;
 }
-function extractImportedMeshPrimitives(ifcApi, modelID, expressID, unitFactor, originOffset, levelElevation, swapYZ) {
+function extractImportedMeshPrimitives(ifcApi, modelID, expressID, unitFactor, originOffset, levelElevation, swapYZ, report) {
     let flatMesh;
     try {
         flatMesh = ifcApi.GetFlatMesh(modelID, expressID);
@@ -547,6 +550,10 @@ function extractImportedMeshPrimitives(ifcApi, modelID, expressID, unitFactor, o
         for (let geometryIndex = 0; geometryIndex < flatMesh.geometries.size(); geometryIndex++) {
             const placed = flatMesh.geometries.get(geometryIndex);
             const matrix = placed.flatTransformation;
+            if (!isFiniteMatrix(matrix)) {
+                report.skippedGeometry.transforms++;
+                continue;
+            }
             const geometry = ifcApi.GetGeometry(modelID, placed.geometryExpressID);
             try {
                 const vertices = ifcApi.GetVertexArray(geometry.GetVertexData(), geometry.GetVertexDataSize());
@@ -594,12 +601,10 @@ function extractImportedMeshPrimitives(ifcApi, modelID, expressID, unitFactor, o
                     const normalLength = Math.hypot(...mappedNormal) || 1;
                     normals.push(roundMeshNormal(mappedNormal[0] / normalLength), roundMeshNormal(mappedNormal[1] / normalLength), roundMeshNormal(mappedNormal[2] / normalLength));
                 }
-                const indices = Array.from(sourceIndices);
-                if (positions.length >= 9 && indices.length >= 3) {
+                const mesh = keepValidTriangles({ positions, normals, indices: Array.from(sourceIndices) }, report);
+                if (mesh) {
                     primitives.push({
-                        positions,
-                        normals,
-                        indices,
+                        ...mesh,
                         color: sourceColor(placed.color),
                         opacity: Math.max(0, Math.min(1, placed.color?.w ?? 1)),
                     });
@@ -704,6 +709,11 @@ export const VARIANT_PRESETS = {
     },
 };
 export async function convertIfcToPascal(ifcData, onProgress, options) {
+    return (await convertIfcToPascalWithReport(ifcData, onProgress, options)).scene;
+}
+/** `convertIfcToPascal`, plus what the conversion had to skip or replace to finish. */
+export async function convertIfcToPascalWithReport(ifcData, onProgress, options) {
+    const report = emptyConversionReport();
     const opts = {
         swapYZ: options?.swapYZ ?? true,
         extrusionDepthIsHeight: options?.extrusionDepthIsHeight ?? true,
@@ -722,7 +732,8 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     progress('Initializing IFC parser...', 0);
     const ifcApi = new WebIFC.IfcAPI();
     ifcApi.SetWasmPath(opts.wasmPath, true);
-    await ifcApi.Init();
+    const locateWasmFile = options?.locateWasmFile;
+    await ifcApi.Init(locateWasmFile ? (fileName) => locateWasmFile(fileName) : undefined);
     progress('Opening IFC model...', 10);
     const modelID = ifcApi.OpenModel(ifcData);
     seedIds(ifcData);
@@ -744,7 +755,9 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     const expressIdToNodeId = new Map();
     progress('Analyzing spatial relationships...', 20);
     // Detect length unit → meters conversion factor
-    const unitFactor = getLengthUnitFactor(ifcApi, modelID);
+    const detectedUnitFactor = getLengthUnitFactor(ifcApi, modelID);
+    report.replaced.unitFactor = !(Number.isFinite(detectedUnitFactor) && detectedUnitFactor > 0);
+    const unitFactor = report.replaced.unitFactor ? 1 : detectedUnitFactor;
     // Compute scene origin offset to center georeferenced models near (0,0,0)
     let originOffset = [0, 0, 0];
     try {
@@ -754,7 +767,11 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             const anchor = ifcApi.GetLine(modelID, anchorId);
             if (anchor.ObjectPlacement?.value) {
                 const mat = resolveWorldTransform(ifcApi, modelID, anchor.ObjectPlacement.value);
-                originOffset = transformPoint3(mat, [0, 0, 0]);
+                const offset = transformPoint3(mat, [0, 0, 0]);
+                if (offset.every(Number.isFinite))
+                    originOffset = offset;
+                else
+                    report.replaced.originOffset = true;
             }
         }
     }
@@ -949,11 +966,21 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         return storeyExpressId == null ? 0 : (storeyElevationByExpressId.get(storeyExpressId) ?? 0);
     }
     const importedPrimitivesByExpressId = new Map();
+    // Elements whose every piece of geometry was unreadable: omitted, never rebuilt as a native
+    // node from their placement data.
+    const unreadableGeometry = new Set();
     function importedMeshPrimitivesFor(expressId) {
         const cached = importedPrimitivesByExpressId.get(expressId);
         if (cached)
             return cached;
-        const primitives = extractImportedMeshPrimitives(ifcApi, modelID, expressId, unitFactor, originOffset, elementLevelElevation(expressId), opts.swapYZ);
+        const { transforms, primitives: skippedPrimitives } = report.skippedGeometry;
+        const skippedBefore = transforms + skippedPrimitives;
+        const primitives = extractImportedMeshPrimitives(ifcApi, modelID, expressId, unitFactor, originOffset, elementLevelElevation(expressId), opts.swapYZ, report);
+        const skippedAfter = report.skippedGeometry.transforms + report.skippedGeometry.primitives;
+        if (primitives.length === 0 && skippedAfter > skippedBefore) {
+            unreadableGeometry.add(expressId);
+            report.skippedGeometry.elements++;
+        }
         importedPrimitivesByExpressId.set(expressId, primitives);
         return primitives;
     }
@@ -1129,6 +1156,11 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         else {
             elevation *= unitFactor;
         }
+        if (!Number.isFinite(elevation)) {
+            report.replaced.levelElevations++;
+            const explicit = (storey.Elevation?.value ?? 0) * unitFactor;
+            elevation = Number.isFinite(explicit) ? explicit : 0;
+        }
         storeyElevationByExpressId.set(storeyExpressID, elevation);
         const levelNode = tryParse(LevelNode, 'level', {
             object: 'node',
@@ -1575,6 +1607,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                         object: 'node',
                         id: nodeId,
                         type: 'door',
+                        frameThickness: NEW_DOOR_FRAME_THICKNESS,
                         name: element.Name?.value || `Door`,
                         parentId: wallNodeId,
                         visible: true,
@@ -1756,6 +1789,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                     object: 'node',
                     id: nodeId,
                     type: 'door',
+                    frameThickness: NEW_DOOR_FRAME_THICKNESS,
                     name: element.Name?.value || `Door`,
                     parentId: parentNodeId,
                     visible: true,
@@ -1824,11 +1858,12 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         // Pascal's storey-wide wall-support calculation. Preserve roofs and stair
         // landings as exact meshes: roofs may be sloped, while a local landing is
         // not a storey floor and must not raise adjacent wall bases.
+        const hasMesh = importedMeshPrimitivesFor(slabExpressID).length > 0;
+        if (unreadableGeometry.has(slabExpressID))
+            continue;
         const slabPredefinedType = String(slab.PredefinedType?.value ?? '').toUpperCase();
-        if ((slabPredefinedType === 'ROOF' || slabPredefinedType === 'LANDING') &&
-            importedMeshPrimitivesFor(slabExpressID).length > 0) {
+        if ((slabPredefinedType === 'ROOF' || slabPredefinedType === 'LANDING') && hasMesh)
             continue;
-        }
         const levelElevation = elementLevelElevation(slabExpressID);
         let plan = null;
         try {
@@ -1838,7 +1873,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             // mesh fallback below
         }
         // A sloped or tilted slab is not a Pascal floor; keep its exact mesh.
-        if (plan?.flat === false && importedMeshPrimitivesFor(slabExpressID).length > 0)
+        if (plan?.flat === false && hasMesh)
             continue;
         if (!plan?.polygon)
             continue;
@@ -2680,8 +2715,11 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     });
     progress('Complete!', 100);
     return {
-        nodes,
-        rootNodeIds: rootNodeIds,
-        collections,
+        scene: {
+            nodes,
+            rootNodeIds: rootNodeIds,
+            collections,
+        },
+        report,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/ifc-converter",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "IFC → Pascal scene-graph conversion. Pure logic — no DOM, no React.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,21 +19,24 @@
   },
   "files": [
     "dist",
+    "!dist/__bench__",
     "README.md"
   ],
   "scripts": {
     "build": "tsc --build",
+    "check-types": "tsc -p tsconfig.bench.json --pretty false",
     "dev": "tsgo --build --watch",
     "test": "bun test tests",
+    "bench:normals": "bun run src/__bench__/normal-recompute.bench.ts",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@pascal-app/core": "^1.0.6",
+    "@pascal-app/core": "^1.0.7",
     "web-ifc": "^0.0.78"
   },
   "devDependencies": {
     "@pascal/typescript-config": "*",
-    "@types/bun": "^1.4.3",
+    "@types/bun": "^1.4.4",
     "typescript": "7.0.2"
   },
   "repository": {