@pascal-app/ifc-converter 1.0.0 → 1.0.3

package/README.md

@@ -5,3 +5,28 @@ IFC bytes, returns `{ nodes, rootNodeIds, stats }` shaped against
 `@pascal-app/core` schemas.
 
 No DOM, no React. The UI lives in `apps/ifc-converter`.
+
+`IFCBEAM` and `IFCBEAMSTANDARDCASE` are imported as editable `block` nodes.
+Their triangulated IFC geometry preserves cross-sections, rotations, and slopes;
+positions are relative to the containing storey. IFC IDs, names, properties,
+and material metadata are retained. Beams without renderable geometry are
+reported in the conversion log. Imported beams use the block editor rather than
+dedicated parametric beam controls.
+
+Native Pascal nodes are produced when the converter can recover the required
+parameters for sites, buildings, levels, walls, doors, windows, slabs, columns,
+and IFC spaces (as room zones). IFC stair flights are retained as exact imported
+meshes; roofs retain Pascal hierarchy and source metadata but are not yet a
+complete parametric conversion. Railings, coverings, furnishings, proxies,
+curtain walls, plates, members,
+footings, and elements whose native parameters cannot be recovered are retained
+as selectable `imported-mesh` nodes using their IFC triangle geometry and color.
+Imported meshes are import-only and do not appear as empty objects in the editor
+palette.
+
+Door families are derived from `IfcDoor.OperationType`. Glazing is applied from
+the standardized `Pset_DoorCommon.GlazingAreaFraction` property rather than
+from element names or project-specific conventions.
+
+Browser callers use the default WebIFC WASM path (`/`). Node callers can pass
+`{ wasmPath: '/absolute/path/to/web-ifc/' }` in `ConversionOptions`.

package/dist/beam-geometry.d.ts

@@ -0,0 +1,14 @@
+import { type BlockTopology } from '@pascal-app/core';
+import type { IfcAPI } from 'web-ifc';
+type Point = [number, number, number];
+export declare function extractBeamGeometry(ifcApi: IfcAPI, modelID: number, expressID: number, options: {
+    origin: number[];
+    unitFactor: number;
+    swapYZ: boolean;
+    levelElevation: number;
+}): {
+    position: Point;
+    topology: BlockTopology;
+} | null;
+export {};
+//# sourceMappingURL=beam-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"beam-geometry.d.ts","sourceRoot":"","sources":["../src/beam-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAA0B,MAAM,kBAAkB,CAAA;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAErC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzF;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,GAAG,IAAI,CAyFrD"}

package/dist/beam-geometry.js

@@ -0,0 +1,92 @@
+import { blockUndirectedEdgeKey } from '@pascal-app/core';
+export function extractBeamGeometry(ifcApi, modelID, expressID, options) {
+    const mesh = ifcApi.GetFlatMesh(modelID, expressID);
+    const topology = { vertices: [], edges: [], faces: [] };
+    const vertexByPosition = new Map();
+    const edgeKeys = new Set();
+    try {
+        for (let g = 0; g < mesh.geometries.size(); g++) {
+            const placed = mesh.geometries.get(g);
+            const m = placed.flatTransformation;
+            const geometry = ifcApi.GetGeometry(modelID, placed.geometryExpressID);
+            try {
+                const vertices = ifcApi.GetVertexArray(geometry.GetVertexData(), geometry.GetVertexDataSize());
+                const indices = ifcApi.GetIndexArray(geometry.GetIndexData(), geometry.GetIndexDataSize());
+                const vertexIds = [];
+                for (let v = 0; v < vertices.length; v += 6) {
+                    const x = vertices[v];
+                    const y = vertices[v + 1];
+                    const z = vertices[v + 2];
+                    const wx = m[0] * x + m[4] * y + m[8] * z + m[12];
+                    const wy = m[1] * x + m[5] * y + m[9] * z + m[13];
+                    const wz = m[2] * x + m[6] * y + m[10] * z + m[14];
+                    // web-ifc meshes are already in meters and use (X, Z, -Y).
+                    // Undo that basis before applying the converter's origin and axis preset.
+                    const sx = wx - options.origin[0] * options.unitFactor;
+                    const sy = -wz - options.origin[1] * options.unitFactor;
+                    const sz = wy - options.origin[2] * options.unitFactor - options.levelElevation;
+                    const position = options.swapYZ ? [sx, sz, sy] : [sx, sy, sz];
+                    if (!position.every(Number.isFinite))
+                        throw new Error('Non-finite beam vertex');
+                    const key = position.join(',');
+                    let id = vertexByPosition.get(key);
+                    if (!id) {
+                        id = `v${topology.vertices.length}`;
+                        topology.vertices.push({ id, position });
+                        vertexByPosition.set(key, id);
+                    }
+                    vertexIds.push(id);
+                }
+                const determinant = m[0] * (m[5] * m[10] - m[9] * m[6]) -
+                    m[4] * (m[1] * m[10] - m[9] * m[2]) +
+                    m[8] * (m[1] * m[6] - m[5] * m[2]);
+                // Baking a reflection into the vertices also reverses the outward face winding.
+                const reverseWinding = determinant < 0 !== options.swapYZ;
+                for (let i = 0; i + 2 < indices.length; i += 3) {
+                    const ids = [vertexIds[indices[i]], vertexIds[indices[i + 1]], vertexIds[indices[i + 2]]];
+                    if (ids.some((id) => id === undefined))
+                        throw new Error('Invalid beam triangle index');
+                    if (new Set(ids).size < 3)
+                        continue;
+                    if (reverseWinding)
+                        ids.reverse();
+                    topology.faces.push({
+                        id: `f${topology.faces.length}`,
+                        vertexIds: ids,
+                        materialSlot: 'body',
+                    });
+                    for (let j = 0; j < 3; j++) {
+                        const a = ids[j];
+                        const b = ids[(j + 1) % 3];
+                        const key = blockUndirectedEdgeKey(a, b);
+                        if (edgeKeys.has(key))
+                            continue;
+                        edgeKeys.add(key);
+                        topology.edges.push({ id: `e${topology.edges.length}`, vertexIds: [a, b] });
+                    }
+                }
+            }
+            finally {
+                geometry.delete();
+            }
+        }
+    }
+    finally {
+        mesh.delete?.();
+    }
+    if (topology.faces.length === 0)
+        return null;
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const vertex of topology.vertices) {
+        for (let axis = 0; axis < 3; axis++) {
+            min[axis] = Math.min(min[axis], vertex.position[axis]);
+            max[axis] = Math.max(max[axis], vertex.position[axis]);
+        }
+    }
+    const position = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+    for (const vertex of topology.vertices) {
+        vertex.position = vertex.position.map((value, axis) => value - position[axis]);
+    }
+    return { position, topology };
+}

package/dist/door-semantics.d.ts

@@ -0,0 +1,8 @@
+import type { DoorNode } from '@pascal-app/core';
+type DoorStyle = Partial<DoorNode>;
+/** Map standardized IfcDoor operation values to Pascal door families. */
+export declare function doorStyleFromIfcOperation(operationType: unknown): DoorStyle;
+/** Apply the standardized Pset_DoorCommon glazing fraction after psets load. */
+export declare function doorGlazingStyle(door: DoorNode, glazingAreaFraction: unknown): DoorStyle;
+export {};
+//# sourceMappingURL=door-semantics.d.ts.map

package/dist/door-semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-semantics.d.ts","sourceRoot":"","sources":["../src/door-semantics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,KAAK,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAalC,yEAAyE;AACzE,wBAAgB,yBAAyB,CAAC,aAAa,EAAE,OAAO,GAAG,SAAS,CAoC3E;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,mBAAmB,EAAE,OAAO,GAAG,SAAS,CASxF"}

package/dist/door-semantics.js

@@ -0,0 +1,56 @@
+const glazedSegments = [
+    {
+        type: 'glass',
+        heightRatio: 1,
+        columnRatios: [1],
+        dividerThickness: 0.025,
+        panelDepth: 0.008,
+        panelInset: 0.035,
+    },
+];
+/** Map standardized IfcDoor operation values to Pascal door families. */
+export function doorStyleFromIfcOperation(operationType) {
+    const operation = String(operationType ?? '').toUpperCase();
+    const leafCount = operation.startsWith('DOUBLE_DOOR') ? 2 : 1;
+    if (operation.includes('SLIDING')) {
+        return {
+            doorType: 'sliding',
+            leafCount,
+            slideDirection: operation.includes('RIGHT') ? 'right' : 'left',
+            trackStyle: 'visible',
+            threshold: false,
+        };
+    }
+    if (operation.includes('FOLDING')) {
+        return {
+            doorType: 'folding',
+            leafCount,
+        };
+    }
+    if (operation === 'ROLLINGUP') {
+        return {
+            doorCategory: 'garage',
+            doorType: 'garage-rollup',
+            trackStyle: 'overhead',
+        };
+    }
+    if (operation.startsWith('DOUBLE_DOOR')) {
+        return { doorType: 'double', leafCount: 2 };
+    }
+    if (operation.includes('SWING_RIGHT'))
+        return { hingesSide: 'right' };
+    if (operation.includes('SWING_LEFT'))
+        return { hingesSide: 'left' };
+    return {};
+}
+/** Apply the standardized Pset_DoorCommon glazing fraction after psets load. */
+export function doorGlazingStyle(door, glazingAreaFraction) {
+    const fraction = Number(glazingAreaFraction);
+    if (!Number.isFinite(fraction) || fraction <= 0)
+        return {};
+    return {
+        doorType: door.doorType === 'double' ? 'french' : door.doorType,
+        segments: glazedSegments,
+        contentPadding: [0.04, 0.05],
+    };
+}

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export interface ConversionOptions {
     swapYZ?: boolean;
     extrusionDepthIsHeight?: boolean;
     swapProfileDimensions?: boolean;
+    wasmPath?: string;
     simplify?: boolean | IfcConversionSimplificationOptions;
     label?: string;
 }

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,EAaf,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,KAAK,kCAAkC,EAA+B,MAAM,WAAW,CAAA;AAEhG,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,OAAO,CAAC,CAAA;CACtC;AAimBD,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,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,CA65C3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAkBf,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,KAAK,kCAAkC,EAA+B,MAAM,WAAW,CAAA;AAIhG,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,OAAO,CAAC,CAAA;CACtC;AAixBD,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,CA8nD3B"}

package/dist/index.js

@@ -1,7 +1,10 @@
-import { BuildingNode, ColumnNode, DEFAULT_WALL_HEIGHT, DEFAULT_WALL_THICKNESS, DoorNode, LevelNode, RoofNode, SiteNode, SlabNode, StairNode, WallNode, WindowNode, } from '@pascal-app/core';
+import { BlockNode, BuildingNode, ColumnNode, DEFAULT_LEVEL_HEIGHT, DEFAULT_WALL_HEIGHT, DEFAULT_WALL_THICKNESS, DoorNode, GROUND_SUPPORT_ID, ImportedMeshNode, LevelNode, RoofNode, SiteNode, SlabNode, WallNode, WindowNode, ZoneNode, } from '@pascal-app/core';
 import { customAlphabet } from 'nanoid';
 import * as WebIFC from 'web-ifc';
+import { extractBeamGeometry } from './beam-geometry';
 import { simplifyConvertedSceneGraph } from './cleanup';
+import { doorGlazingStyle, doorStyleFromIfcOperation } from './door-semantics';
+import { selectStoreyForElevation } from './storey-semantics';
 function meta(node) {
     return (node?.metadata ?? {});
 }
@@ -498,6 +501,146 @@ function wallHeightThicknessFromExtents(extents, knownLengthMeters, unitFactor)
     }
     return null;
 }
+function sourceColor(color) {
+    const channel = (value) => Math.max(0, Math.min(255, Math.round((value ?? 0.58) * 255)))
+        .toString(16)
+        .padStart(2, '0');
+    return `#${channel(color?.x)}${channel(color?.y)}${channel(color?.z)}`;
+}
+function roundMeshPosition(value) {
+    const rounded = Math.round(value * 10_000) / 10_000;
+    return rounded === 0 ? 0 : rounded;
+}
+function roundMeshNormal(value) {
+    const rounded = Math.round(value * 1000) / 1000;
+    return rounded === 0 ? 0 : rounded;
+}
+function extractImportedMeshPrimitives(ifcApi, modelID, expressID, unitFactor, originOffset, levelElevation, swapYZ) {
+    let flatMesh;
+    try {
+        flatMesh = ifcApi.GetFlatMesh(modelID, expressID);
+    }
+    catch {
+        return [];
+    }
+    const primitives = [];
+    try {
+        for (let geometryIndex = 0; geometryIndex < flatMesh.geometries.size(); geometryIndex++) {
+            const placed = flatMesh.geometries.get(geometryIndex);
+            const matrix = placed.flatTransformation;
+            const geometry = ifcApi.GetGeometry(modelID, placed.geometryExpressID);
+            try {
+                const vertices = ifcApi.GetVertexArray(geometry.GetVertexData(), geometry.GetVertexDataSize());
+                const sourceIndices = ifcApi.GetIndexArray(geometry.GetIndexData(), geometry.GetIndexDataSize());
+                const positions = [];
+                const normals = [];
+                for (let vertex = 0; vertex + 5 < vertices.length; vertex += 6) {
+                    const x = vertices[vertex];
+                    const y = vertices[vertex + 1];
+                    const z = vertices[vertex + 2];
+                    const world = [
+                        matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
+                        matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
+                        matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14],
+                    ];
+                    // `GetFlatMesh` does not use the same axes as the STEP placement
+                    // data read by `resolveWorldTransform`: web-ifc has already mapped
+                    // IFC Z-up coordinates to an X/Y-up/-Z frame. Applying the regular
+                    // STEP `swapYZ` transform here a second time makes plan depth look
+                    // like height (and height look like plan depth), exploding fallback
+                    // walls and railings across the scene.
+                    const mappedPosition = swapYZ
+                        ? [
+                            world[0] - originOffset[0] * unitFactor,
+                            world[1] - originOffset[2] * unitFactor - levelElevation,
+                            -(world[2] + originOffset[1] * unitFactor),
+                        ]
+                        : [
+                            world[0] - originOffset[0] * unitFactor,
+                            -(world[2] + originOffset[1] * unitFactor),
+                            world[1] - originOffset[2] * unitFactor - levelElevation,
+                        ];
+                    positions.push(...mappedPosition.map(roundMeshPosition));
+                    const nx = vertices[vertex + 3];
+                    const ny = vertices[vertex + 4];
+                    const nz = vertices[vertex + 5];
+                    const worldNormal = [
+                        matrix[0] * nx + matrix[4] * ny + matrix[8] * nz,
+                        matrix[1] * nx + matrix[5] * ny + matrix[9] * nz,
+                        matrix[2] * nx + matrix[6] * ny + matrix[10] * nz,
+                    ];
+                    const mappedNormal = swapYZ
+                        ? [worldNormal[0], worldNormal[1], -worldNormal[2]]
+                        : [worldNormal[0], -worldNormal[2], worldNormal[1]];
+                    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 (swapYZ) {
+                    for (let index = 0; index + 2 < indices.length; index += 3) {
+                        const second = indices[index + 1];
+                        indices[index + 1] = indices[index + 2];
+                        indices[index + 2] = second;
+                    }
+                }
+                if (positions.length >= 9 && indices.length >= 3) {
+                    primitives.push({
+                        positions,
+                        normals,
+                        indices,
+                        color: sourceColor(placed.color),
+                        opacity: Math.max(0, Math.min(1, placed.color?.w ?? 1)),
+                    });
+                }
+            }
+            finally {
+                ;
+                geometry.delete?.();
+            }
+        }
+    }
+    catch {
+        return primitives;
+    }
+    finally {
+        flatMesh.delete?.();
+    }
+    return primitives;
+}
+function meshFootprint(primitives, swapYZ) {
+    const unique = new Map();
+    const secondPlanAxis = swapYZ ? 2 : 1;
+    for (const primitive of primitives) {
+        for (let i = 0; i + 2 < primitive.positions.length; i += 3) {
+            const point = [
+                primitive.positions[i],
+                primitive.positions[i + secondPlanAxis],
+            ];
+            unique.set(`${point[0].toFixed(5)}:${point[1].toFixed(5)}`, point);
+        }
+    }
+    const points = [...unique.values()].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    if (points.length < 3)
+        return null;
+    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    const lower = [];
+    for (const point of points) {
+        while (lower.length >= 2 && cross(lower.at(-2), lower.at(-1), point) <= 0)
+            lower.pop();
+        lower.push(point);
+    }
+    const upper = [];
+    for (let i = points.length - 1; i >= 0; i--) {
+        const point = points[i];
+        while (upper.length >= 2 && cross(upper.at(-2), upper.at(-1), point) <= 0)
+            upper.pop();
+        upper.push(point);
+    }
+    lower.pop();
+    upper.pop();
+    const hull = [...lower, ...upper];
+    return hull.length >= 3 ? hull : null;
+}
 function getExtrusionPosition(ifcApi, modelID, element) {
     try {
         if (!element.Representation?.value)
@@ -553,6 +696,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         swapYZ: options?.swapYZ ?? true,
         extrusionDepthIsHeight: options?.extrusionDepthIsHeight ?? true,
         swapProfileDimensions: options?.swapProfileDimensions ?? false,
+        wasmPath: options?.wasmPath ?? '/',
     };
     const simplificationOptions = options?.simplify === false
         ? { enabled: false }
@@ -565,13 +709,22 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     };
     progress('Initializing IFC parser...', 0);
     const ifcApi = new WebIFC.IfcAPI();
-    ifcApi.SetWasmPath('/', true);
+    ifcApi.SetWasmPath(opts.wasmPath, true);
     await ifcApi.Init();
     progress('Opening IFC model...', 10);
     const modelID = ifcApi.OpenModel(ifcData);
     console.log(`[IFC→Pascal] Model opened, ID: ${modelID}, File size: ${(ifcData.length / 1024).toFixed(1)} KB`);
     const nodes = {};
     const rootNodeIds = [];
+    function attachNodeToGraph(nodeId, parentNodeId) {
+        const parent = parentNodeId ? nodes[parentNodeId] : undefined;
+        const children = parent && 'children' in parent ? parent.children : undefined;
+        if (children) {
+            children.push(nodeId);
+            return;
+        }
+        rootNodeIds.push(nodeId);
+    }
     // Maps to track relationships
     const parentMap = new Map();
     const childrenMap = new Map();
@@ -602,6 +755,10 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             (worldPt[2] - originOffset[2]) * unitFactor,
         ];
     }
+    const toPascalPoint = (scenePoint, levelElevation) => opts.swapYZ
+        ? [scenePoint[0], scenePoint[2] - levelElevation, scenePoint[1]]
+        : [scenePoint[0], scenePoint[1], scenePoint[2] - levelElevation];
+    const storeyElevationByExpressId = new Map();
     // Collect storey expressIDs for level mapping
     const storeyExpressIds = new Set();
     const storeyIds = ifcApi.GetLineIDsWithType(modelID, WebIFC.IFCBUILDINGSTOREY);
@@ -654,6 +811,80 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         }
         return null;
     }
+    // Some IFC authoring tools aggregate roof elements under IfcRoof ->
+    // IfcBuilding instead of spatially containing them in an IfcBuildingStorey.
+    // Infer the most appropriate storey from the element elevation so those
+    // elements still become reachable, level-local Pascal nodes.
+    function resolveStoreyForElement(expressId) {
+        const containedStorey = findStoreyForElement(expressId);
+        if (containedStorey != null)
+            return containedStorey;
+        let buildingExpressId = null;
+        let current = expressId;
+        for (let guard = 0; guard < 20 && current != null; guard++) {
+            const nodeId = expressIdToNodeId.get(current);
+            if (nodeId && nodes[nodeId]?.type === 'building') {
+                buildingExpressId = current;
+                break;
+            }
+            current = parentMap.get(current);
+        }
+        let elementElevation = Number.POSITIVE_INFINITY;
+        try {
+            const element = ifcApi.GetLine(modelID, expressId);
+            if (element.ObjectPlacement?.value) {
+                const matrix = resolveWorldTransform(ifcApi, modelID, element.ObjectPlacement.value);
+                elementElevation = worldToScene(transformPoint3(matrix, [0, 0, 0]))[2];
+            }
+        }
+        catch {
+            /* use highest storey */
+        }
+        const candidates = [...storeyExpressIds]
+            .filter((candidate) => {
+            if (buildingExpressId == null)
+                return true;
+            let ancestor = candidate;
+            for (let guard = 0; guard < 20 && ancestor != null; guard++) {
+                if (ancestor === buildingExpressId)
+                    return true;
+                ancestor = parentMap.get(ancestor);
+            }
+            return false;
+        })
+            .map((candidate) => ({
+            expressId: candidate,
+            elevation: storeyElevationByExpressId.get(candidate) ?? 0,
+        }));
+        return selectStoreyForElevation(candidates, elementElevation);
+    }
+    function resolveElementParent(expressId) {
+        const storeyExpressId = resolveStoreyForElement(expressId);
+        if (storeyExpressId != null) {
+            const levelId = expressIdToNodeId.get(storeyExpressId);
+            if (levelId)
+                return levelId;
+        }
+        const parentExpressId = parentMap.get(expressId);
+        const parentNodeId = parentExpressId ? expressIdToNodeId.get(parentExpressId) : undefined;
+        const parentNode = parentNodeId ? nodes[parentNodeId] : undefined;
+        if (parentNode?.type === 'level')
+            return parentNodeId ?? null;
+        return null;
+    }
+    function elementLevelElevation(expressId) {
+        const storeyExpressId = resolveStoreyForElement(expressId);
+        return storeyExpressId == null ? 0 : (storeyElevationByExpressId.get(storeyExpressId) ?? 0);
+    }
+    const importedPrimitivesByExpressId = new Map();
+    function importedMeshPrimitivesFor(expressId) {
+        const cached = importedPrimitivesByExpressId.get(expressId);
+        if (cached)
+            return cached;
+        const primitives = extractImportedMeshPrimitives(ifcApi, modelID, expressId, unitFactor, originOffset, elementLevelElevation(expressId), opts.swapYZ);
+        importedPrimitivesByExpressId.set(expressId, primitives);
+        return primitives;
+    }
     progress('Processing sites...', 30);
     // Process sites
     const sites = ifcApi.GetLineIDsWithType(modelID, WebIFC.IFCSITE);
@@ -721,10 +952,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             }),
         });
         nodes[nodeId] = buildingNode;
-        if (parentNodeId && nodes[parentNodeId]) {
-            ;
-            nodes[parentNodeId].children?.push(nodeId);
-        }
+        attachNodeToGraph(nodeId, parentNodeId);
     }
     progress('Processing levels...', 50);
     // Process building storeys (levels)
@@ -752,6 +980,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         else {
             elevation *= unitFactor;
         }
+        storeyElevationByExpressId.set(storeyExpressID, elevation);
         const levelNode = tryParse(LevelNode, 'level', {
             object: 'node',
             id: nodeId,
@@ -769,9 +998,33 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             }),
         });
         nodes[nodeId] = levelNode;
-        if (parentNodeId && nodes[parentNodeId]) {
-            ;
-            nodes[parentNodeId].children?.push(nodeId);
+        attachNodeToGraph(nodeId, parentNodeId);
+    }
+    // Pascal stacks levels from their stored heights. Match those heights to
+    // IFC storey elevations, while normalizing the lowest IFC storey to y=0.
+    const storeysByBuilding = new Map();
+    for (let i = 0; i < storeys.size(); i++) {
+        const storeyExpressId = storeys.get(i);
+        const buildingExpressId = parentMap.get(storeyExpressId) ?? null;
+        const group = storeysByBuilding.get(buildingExpressId) ?? [];
+        group.push(storeyExpressId);
+        storeysByBuilding.set(buildingExpressId, group);
+    }
+    for (const group of storeysByBuilding.values()) {
+        group.sort((a, b) => (storeyElevationByExpressId.get(a) ?? 0) - (storeyElevationByExpressId.get(b) ?? 0));
+        for (let index = 0; index < group.length; index++) {
+            const expressId = group[index];
+            const nodeId = expressIdToNodeId.get(expressId);
+            const level = nodeId ? nodes[nodeId] : undefined;
+            if (level?.type !== 'level')
+                continue;
+            const nextExpressId = group[index + 1];
+            const height = nextExpressId
+                ? (storeyElevationByExpressId.get(nextExpressId) ?? 0) -
+                    (storeyElevationByExpressId.get(expressId) ?? 0)
+                : DEFAULT_LEVEL_HEIGHT;
+            level.level = index;
+            level.height = height > 0.1 ? height : DEFAULT_LEVEL_HEIGHT;
         }
     }
     progress('Processing walls...', 60);
@@ -824,8 +1077,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             const wall = ifcApi.GetLine(modelID, wallExpressID);
             const nodeId = generateId('wall');
             expressIdToNodeId.set(wallExpressID, nodeId);
-            const parentExpressID = parentMap.get(wallExpressID);
-            const parentNodeId = parentExpressID ? expressIdToNodeId.get(parentExpressID) : null;
+            const parentNodeId = resolveElementParent(wallExpressID);
             let start = [0, 0];
             let end = null;
             let thickness;
@@ -867,16 +1119,33 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                     const ys = body.profilePoints.map((p) => p[1]);
                     thickness = (Math.max(...ys) - Math.min(...ys)) * unitFactor;
                 }
-                // If no axis polyline, derive wall length from profile or XDim
+                // If no axis polyline, derive the centerline from the body's local
+                // profile. IFC rectangle/profile dimensions are centered on the wall
+                // placement origin. Treating that origin as an endpoint shifts every
+                // such wall by half its own length (most visible on exterior walls).
                 if (!axisPts) {
-                    let wallLength = body.xDim;
-                    if (!wallLength && body.profilePoints && body.profilePoints.length >= 3) {
-                        const xs = body.profilePoints.map((p) => p[0]);
-                        wallLength = Math.max(...xs) - Math.min(...xs);
+                    const extrusionMat = getExtrusionPosition(ifcApi, modelID, wall);
+                    const centerlineMat = extrusionMat ? multiply(worldMat, extrusionMat) : worldMat;
+                    let localStart = null;
+                    let localEnd = null;
+                    if (body.profilePoints && body.profilePoints.length >= 3) {
+                        const xs = body.profilePoints.map((point) => point[0]);
+                        const ys = body.profilePoints.map((point) => point[1]);
+                        const minX = Math.min(...xs);
+                        const maxX = Math.max(...xs);
+                        const centerY = (Math.min(...ys) + Math.max(...ys)) / 2;
+                        localStart = [minX, centerY, 0];
+                        localEnd = [maxX, centerY, 0];
                     }
-                    if (wallLength) {
-                        const se = worldToScene(transformPoint3(worldMat, [wallLength, 0, 0]));
-                        end = [se[0], se[1]];
+                    else if (body.xDim) {
+                        localStart = [-body.xDim / 2, 0, 0];
+                        localEnd = [body.xDim / 2, 0, 0];
+                    }
+                    if (localStart && localEnd) {
+                        const s0 = worldToScene(transformPoint3(centerlineMat, localStart));
+                        const s1 = worldToScene(transformPoint3(centerlineMat, localEnd));
+                        start = [s0[0], s0[1]];
+                        end = [s1[0], s1[1]];
                     }
                 }
             }
@@ -884,8 +1153,10 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                 // keep defaults
             }
             // Skip walls where we couldn't determine geometry
-            if (!end)
+            if (!end) {
+                expressIdToNodeId.delete(wallExpressID);
                 continue;
+            }
             // Plain IFCWALL frequently carries Brep / mapped geometry rather
             // than a clean IfcExtrudedAreaSolid, so getBodyExtrusionData can't
             // read its height/thickness (only IFCWALLSTANDARDCASE reliably
@@ -942,10 +1213,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                 }),
             });
             nodes[nodeId] = wallNode;
-            if (parentNodeId && nodes[parentNodeId]) {
-                ;
-                nodes[parentNodeId].children?.push(nodeId);
-            }
+            attachNodeToGraph(nodeId, parentNodeId);
         }
     }
     // Process doors and windows via void/fill relationships
@@ -1055,11 +1323,13 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                         width: width ?? 0.9,
                         height: height ?? 2.1,
                         position: doorPosition,
+                        ...doorStyleFromIfcOperation(element.OperationType?.value),
                         metadata: buildMetadata({
                             ifcType: 'IFCDOOR',
                             expressID: fillId,
                             globalId: element.GlobalId?.value,
                             hostWallExpressID: wallExpressID,
+                            operationType: element.OperationType?.value,
                         }),
                     });
                     nodes[nodeId] = doorNode;
@@ -1111,8 +1381,10 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     // door/window → wall link is only implicit in the element's world
     // placement. We recover it by projecting the element's world position
     // onto the nearest wall segment. Anything farther than
-    // HOST_WALL_MAX_DIST from every wall stays parented to its spatial
-    // container at the origin — we have no basis to place it on a wall.
+    // HOST_WALL_MAX_DIST from every wall is left for the exact imported-mesh
+    // fallback below. A standalone Pascal door/window has wall-local
+    // coordinates, so putting one at its spatial container's origin silently
+    // moves it away from its IFC placement.
     const HOST_WALL_MAX_DIST = 1.0; // metres
     const wallInfos = [];
     for (const [wallExpressId, wallNodeId] of expressIdToNodeId) {
@@ -1184,6 +1456,12 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         try {
             const element = ifcApi.GetLine(modelID, fillId);
             const isDoor = doorExpressIds.has(fillId);
+            // A Pascal WindowNode is always hosted vertically in a wall. Roof
+            // windows need their full IFC transform, so leave skylights unmapped
+            // here and preserve them as imported mesh geometry below.
+            if (!isDoor && String(element.PredefinedType?.value ?? '').toUpperCase() === 'SKYLIGHT') {
+                continue;
+            }
             let width;
             let height;
             if (element.OverallWidth?.value)
@@ -1204,13 +1482,13 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             }
             const effWidth = width ?? (isDoor ? 0.9 : 1.0);
             const hosted = scene ? findHostWall(scene[0], scene[1], effWidth) : null;
-            // When hosted, parent to (and live inside) the wall — same as the
-            // void/fill path. Otherwise fall back to the spatial container.
-            const containerExpressID = parentMap.get(fillId);
-            const containerNodeId = containerExpressID
-                ? (expressIdToNodeId.get(containerExpressID) ?? null)
-                : null;
-            const parentNodeId = hosted ? hosted.info.nodeId : containerNodeId;
+            // Native Pascal openings require a native Pascal wall. Preserve
+            // unhosted openings as exact IFC meshes instead of inventing a
+            // wall-local position at [0, 0, 0].
+            if (!hosted)
+                continue;
+            // Parent to (and live inside) the wall — same as the void/fill path.
+            const parentNodeId = hosted.info.nodeId;
             if (isDoor) {
                 const h = height ?? 2.1;
                 const nodeId = generateId('door');
@@ -1223,14 +1501,14 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                     visible: true,
                     width: width ?? 0.9,
                     height: h,
-                    // Placed by nearest-wall projection; [0,0,0] only when no wall
-                    // is within range (then it sits on its spatial container).
-                    position: hosted ? [hosted.along, h / 2, 0] : [0, 0, 0],
-                    ...(hosted ? { wallId: hosted.info.nodeId } : {}),
+                    position: [hosted.along, h / 2, 0],
+                    wallId: hosted.info.nodeId,
+                    ...doorStyleFromIfcOperation(element.OperationType?.value),
                     metadata: buildMetadata({
                         ifcType: 'IFCDOOR',
                         expressID: fillId,
                         globalId: element.GlobalId?.value,
+                        operationType: element.OperationType?.value,
                     }),
                 });
                 nodes[nodeId] = doorNode;
@@ -1242,7 +1520,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             }
             else {
                 const h = height ?? 1.2;
-                const sill = hosted && scene ? Math.max(0, scene[2] - hosted.info.baseY) : 0;
+                const sill = scene ? Math.max(0, scene[2] - hosted.info.baseY) : 0;
                 const nodeId = generateId('window');
                 const windowNode = tryParse(WindowNode, 'window', {
                     object: 'node',
@@ -1253,13 +1531,13 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                     visible: true,
                     width: width ?? 1.0,
                     height: h,
-                    position: hosted ? [hosted.along, sill + h / 2, 0] : [0, 0, 0],
-                    ...(hosted ? { wallId: hosted.info.nodeId } : {}),
+                    position: [hosted.along, sill + h / 2, 0],
+                    wallId: hosted.info.nodeId,
                     metadata: buildMetadata({
                         ifcType: 'IFCWINDOW',
                         expressID: fillId,
                         globalId: element.GlobalId?.value,
-                        ...(hosted ? { sillHeight: sill } : {}),
+                        sillHeight: sill,
                     }),
                 });
                 nodes[nodeId] = windowNode;
@@ -1280,10 +1558,18 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     for (let i = 0; i < slabs.size(); i++) {
         const slabExpressID = slabs.get(i);
         const slab = ifcApi.GetLine(modelID, slabExpressID);
+        // SlabNode represents a horizontal plan polygon and participates in
+        // 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 slabPredefinedType = String(slab.PredefinedType?.value ?? '').toUpperCase();
+        if ((slabPredefinedType === 'ROOF' || slabPredefinedType === 'LANDING') &&
+            importedMeshPrimitivesFor(slabExpressID).length > 0) {
+            continue;
+        }
         const nodeId = generateId('slab');
         expressIdToNodeId.set(slabExpressID, nodeId);
-        const parentExpressID = parentMap.get(slabExpressID);
-        const parentNodeId = parentExpressID ? expressIdToNodeId.get(parentExpressID) : null;
+        const parentNodeId = resolveElementParent(slabExpressID);
         let polygon = null;
         let elevation = 0;
         let thickness;
@@ -1294,7 +1580,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                 : identity();
             // Get elevation from placement Z
             const s = worldToScene(transformPoint3(worldMat, [0, 0, 0]));
-            elevation = s[2];
+            elevation = s[2] - elementLevelElevation(slabExpressID);
             // Get body extrusion data
             const body = getBodyExtrusionData(ifcApi, modelID, slab);
             // Extrusion depth is slab thickness
@@ -1337,8 +1623,10 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             // keep defaults
         }
         // Skip slabs where we couldn't extract a polygon
-        if (!polygon || polygon.length < 3)
+        if (!polygon || polygon.length < 3) {
+            expressIdToNodeId.delete(slabExpressID);
             continue;
+        }
         const slabNode = tryParse(SlabNode, 'slab', {
             object: 'node',
             id: nodeId,
@@ -1355,114 +1643,12 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                 ifcType: 'IFCSLAB',
                 expressID: slabExpressID,
                 globalId: slab.GlobalId?.value,
+                predefinedType: slab.PredefinedType?.value,
                 thickness,
             }),
         });
         nodes[nodeId] = slabNode;
-        if (parentNodeId && nodes[parentNodeId]) {
-            ;
-            nodes[parentNodeId].children?.push(nodeId);
-        }
-    }
-    // Process stairs
-    const stairs = ifcApi.GetLineIDsWithType(modelID, WebIFC.IFCSTAIR);
-    for (let i = 0; i < stairs.size(); i++) {
-        const stairExpressID = stairs.get(i);
-        if (expressIdToNodeId.has(stairExpressID))
-            continue;
-        const stair = ifcApi.GetLine(modelID, stairExpressID);
-        const nodeId = generateId('stair');
-        expressIdToNodeId.set(stairExpressID, nodeId);
-        const parentExpressID = parentMap.get(stairExpressID);
-        const parentNodeId = parentExpressID ? expressIdToNodeId.get(parentExpressID) : null;
-        let position = [0, 0, 0];
-        let boundingBox;
-        try {
-            const worldMat = stair.ObjectPlacement?.value
-                ? resolveWorldTransform(ifcApi, modelID, stair.ObjectPlacement.value)
-                : identity();
-            const s = worldToScene(transformPoint3(worldMat, [0, 0, 0]));
-            position = opts.swapYZ ? [s[0], s[2], s[1]] : [s[0], s[1], s[2]];
-            // Try stair's own body first
-            const body = getBodyExtrusionData(ifcApi, modelID, stair);
-            if (body.xDim && body.yDim && body.depth) {
-                boundingBox = opts.swapYZ
-                    ? [body.xDim * unitFactor, body.depth * unitFactor, body.yDim * unitFactor]
-                    : [body.xDim * unitFactor, body.yDim * unitFactor, body.depth * unitFactor];
-            }
-            // If no body, try to derive from stair flight children
-            if (!boundingBox) {
-                const stairChildren = childrenMap.get(stairExpressID) ?? [];
-                for (const childId of stairChildren) {
-                    try {
-                        const child = ifcApi.GetLine(modelID, childId);
-                        // Check for NumberOfRisers / RiserHeight / TreadLength
-                        const nRisers = child.NumberOfRisers?.value ?? child.NumberOfRiser?.value;
-                        const riserHeight = child.RiserHeight?.value;
-                        const treadLength = child.TreadLength?.value;
-                        if (nRisers && riserHeight && treadLength) {
-                            const totalHeight = nRisers * riserHeight * unitFactor;
-                            const totalRun = (nRisers - 1) * treadLength * unitFactor;
-                            const width = 1.0; // Default stair width
-                            const flightBody = getBodyExtrusionData(ifcApi, modelID, child);
-                            const stairWidth = flightBody.yDim ? flightBody.yDim * unitFactor : width;
-                            boundingBox = opts.swapYZ
-                                ? [totalRun || 1, totalHeight, stairWidth]
-                                : [totalRun || 1, stairWidth, totalHeight];
-                            break;
-                        }
-                        // Fallback: try flight body extrusion
-                        const flightBody = getBodyExtrusionData(ifcApi, modelID, child);
-                        if (flightBody.xDim && flightBody.yDim && flightBody.depth) {
-                            boundingBox = opts.swapYZ
-                                ? [
-                                    flightBody.xDim * unitFactor,
-                                    flightBody.depth * unitFactor,
-                                    flightBody.yDim * unitFactor,
-                                ]
-                                : [
-                                    flightBody.xDim * unitFactor,
-                                    flightBody.yDim * unitFactor,
-                                    flightBody.depth * unitFactor,
-                                ];
-                            break;
-                        }
-                    }
-                    catch {
-                        /* skip child */
-                    }
-                }
-            }
-        }
-        catch {
-            /* keep defaults */
-        }
-        const stairNode = tryParse(StairNode, 'stair', {
-            object: 'node',
-            id: nodeId,
-            type: 'stair',
-            name: stair.Name?.value || `Stair ${i + 1}`,
-            parentId: parentNodeId || null,
-            visible: true,
-            position,
-            children: [],
-            // TODO(ifc-fix): Pascal StairNode is parametric (segments / treads /
-            // risers). The converter only knows the bounding box right now;
-            // keep it in metadata until we map IFC stairs onto the parametric
-            // shape (or extend StairNode with a raw-geometry escape hatch).
-            metadata: buildMetadata({
-                ifcType: 'IFCSTAIR',
-                expressID: stairExpressID,
-                globalId: stair.GlobalId?.value,
-                predefinedType: stair.PredefinedType?.value,
-                boundingBox,
-            }),
-        });
-        nodes[nodeId] = stairNode;
-        if (parentNodeId && nodes[parentNodeId]) {
-            ;
-            nodes[parentNodeId].children?.push(nodeId);
-        }
+        attachNodeToGraph(nodeId, parentNodeId);
     }
     // Process roofs
     const roofs = ifcApi.GetLineIDsWithType(modelID, WebIFC.IFCROOF);
@@ -1473,8 +1659,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         const roof = ifcApi.GetLine(modelID, roofExpressID);
         const nodeId = generateId('roof');
         expressIdToNodeId.set(roofExpressID, nodeId);
-        const parentExpressID = parentMap.get(roofExpressID);
-        const parentNodeId = parentExpressID ? expressIdToNodeId.get(parentExpressID) : null;
+        const parentNodeId = resolveElementParent(roofExpressID);
         let polygon;
         let elevation;
         let height;
@@ -1483,7 +1668,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                 ? resolveWorldTransform(ifcApi, modelID, roof.ObjectPlacement.value)
                 : identity();
             const s = worldToScene(transformPoint3(worldMat, [0, 0, 0]));
-            elevation = s[2];
+            elevation = s[2] - elementLevelElevation(roofExpressID);
             const body = getBodyExtrusionData(ifcApi, modelID, roof);
             if (body.depth)
                 height = body.depth * unitFactor;
@@ -1542,10 +1727,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             }),
         });
         nodes[nodeId] = roofNode;
-        if (parentNodeId && nodes[parentNodeId]) {
-            ;
-            nodes[parentNodeId].children?.push(nodeId);
-        }
+        attachNodeToGraph(nodeId, parentNodeId);
     }
     // Process columns
     const columnTypes = [WebIFC.IFCCOLUMN];
@@ -1570,8 +1752,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
             const col = ifcApi.GetLine(modelID, colExpressID);
             const nodeId = generateId('column');
             expressIdToNodeId.set(colExpressID, nodeId);
-            const parentExpressID = parentMap.get(colExpressID);
-            const parentNodeId = parentExpressID ? expressIdToNodeId.get(parentExpressID) : null;
+            const parentNodeId = resolveElementParent(colExpressID);
             let position = [0, 0, 0];
             let width;
             let depth;
@@ -1583,7 +1764,7 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                     ? resolveWorldTransform(ifcApi, modelID, col.ObjectPlacement.value)
                     : identity();
                 const s = worldToScene(transformPoint3(worldMat, [0, 0, 0]));
-                position = opts.swapYZ ? [s[0], s[2], s[1]] : [s[0], s[1], s[2]];
+                position = toPascalPoint(s, elementLevelElevation(colExpressID));
                 const body = getBodyExtrusionData(ifcApi, modelID, col);
                 if (body.depth)
                     height = body.depth * unitFactor;
@@ -1649,73 +1830,232 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
                 }),
             });
             nodes[nodeId] = columnNode;
-            if (parentNodeId && nodes[parentNodeId]) {
-                ;
-                nodes[parentNodeId].children?.push(nodeId);
-            }
+            attachNodeToGraph(nodeId, parentNodeId);
         }
     }
-    // Beams: skipped for now — Pascal has no `beam` node type yet. When it
-    // lands in @pascal-app/core, restore the IFCBEAM → BeamNode mapping
-    // (axis polyline → start/end [x,y,z], profile XDim/YDim → width/depth,
-    // extrusion depth → axis length). Reference implementation lives in
-    // git history of this file. We still walk the entities to log how
-    // many beams the IFC contained so the conversion summary is accurate.
-    let skippedBeamCount = 0;
-    const beamTypes = [WebIFC.IFCBEAM];
+    // Spaces become editable Pascal room zones. Prefer their swept-area
+    // profile (preserves concavity); fall back to the mesh's plan hull.
+    let importedSpaceCount = 0;
     try {
-        beamTypes.push(WebIFC.IFCBEAMSTANDARDCASE);
+        const spaces = ifcApi.GetLineIDsWithType(modelID, WebIFC.IFCSPACE);
+        for (let i = 0; i < spaces.size(); i++) {
+            try {
+                const spaceExpressId = spaces.get(i);
+                if (expressIdToNodeId.has(spaceExpressId))
+                    continue;
+                const space = ifcApi.GetLine(modelID, spaceExpressId);
+                const parentNodeId = resolveElementParent(spaceExpressId);
+                const primitives = importedMeshPrimitivesFor(spaceExpressId);
+                let polygon = null;
+                let footprintApproximated = false;
+                let ceilingHeight = DEFAULT_LEVEL_HEIGHT;
+                try {
+                    const worldMat = space.ObjectPlacement?.value
+                        ? resolveWorldTransform(ifcApi, modelID, space.ObjectPlacement.value)
+                        : identity();
+                    const body = getBodyExtrusionData(ifcApi, modelID, space);
+                    const extrusionMat = getExtrusionPosition(ifcApi, modelID, space);
+                    if (body.profilePoints && body.profilePoints.length >= 3) {
+                        const combinedMat = extrusionMat ? multiply(worldMat, extrusionMat) : worldMat;
+                        polygon = body.profilePoints.map((point) => {
+                            const scene = worldToScene(transformPoint3(combinedMat, [point[0], point[1], 0]));
+                            return [scene[0], scene[1]];
+                        });
+                        const first = polygon[0];
+                        const last = polygon.at(-1);
+                        if (polygon.length > 3 &&
+                            last &&
+                            Math.abs(first[0] - last[0]) < 1e-6 &&
+                            Math.abs(first[1] - last[1]) < 1e-6) {
+                            polygon.pop();
+                        }
+                    }
+                    if (body.depth)
+                        ceilingHeight = body.depth * unitFactor;
+                }
+                catch {
+                    /* mesh fallback below */
+                }
+                if (!polygon) {
+                    polygon = meshFootprint(primitives, opts.swapYZ);
+                    footprintApproximated = polygon !== null;
+                }
+                if (!polygon || polygon.length < 3)
+                    continue;
+                if (primitives.length > 0) {
+                    const heightAxis = opts.swapYZ ? 1 : 2;
+                    const heights = primitives.flatMap((primitive) => primitive.positions.filter((_, index) => index % 3 === heightAxis));
+                    if (heights.length > 0)
+                        ceilingHeight = Math.max(...heights) - Math.min(...heights);
+                }
+                const spaceName = space.Name?.value;
+                const longName = space.LongName?.value;
+                const roomNumberCandidate = longName && spaceName !== longName ? (spaceName ?? '').trim() : '';
+                const roomNumber = roomNumberCandidate.length <= 32 ? roomNumberCandidate : '';
+                const nodeId = generateId('zone');
+                const zone = tryParse(ZoneNode, 'zone', {
+                    object: 'node',
+                    id: nodeId,
+                    type: 'zone',
+                    name: longName || spaceName || `Space ${i + 1}`,
+                    parentId: parentNodeId,
+                    visible: true,
+                    polygon,
+                    spaceRole: 'room',
+                    roomNumber,
+                    ceilingHeight: Math.max(0.1, ceilingHeight),
+                    metadata: buildMetadata({
+                        ifcType: 'IFCSPACE',
+                        expressID: spaceExpressId,
+                        globalId: space.GlobalId?.value,
+                        predefinedType: space.PredefinedType?.value,
+                        ifcName: spaceName,
+                        footprintApproximated: footprintApproximated || undefined,
+                    }),
+                });
+                expressIdToNodeId.set(spaceExpressId, nodeId);
+                nodes[nodeId] = zone;
+                attachNodeToGraph(nodeId, parentNodeId);
+                importedSpaceCount++;
+            }
+            catch {
+                /* skip malformed space */
+            }
+        }
     }
     catch {
-        /* not in all versions */
+        /* IFC schema may not expose spaces */
     }
-    for (const beamType of beamTypes) {
-        try {
-            const beams = ifcApi.GetLineIDsWithType(modelID, beamType);
-            skippedBeamCount += beams.size();
-        }
-        catch {
-            /* type not present in this file */
+    progress('Processing beams...', 85);
+    let convertedBeamCount = 0;
+    let skippedBeamCount = 0;
+    for (const beamType of [WebIFC.IFCBEAM, WebIFC.IFCBEAMSTANDARDCASE]) {
+        const beams = ifcApi.GetLineIDsWithType(modelID, beamType);
+        for (let i = 0; i < beams.size(); i++) {
+            const beamExpressID = beams.get(i);
+            if (expressIdToNodeId.has(beamExpressID))
+                continue;
+            try {
+                const beam = ifcApi.GetLine(modelID, beamExpressID);
+                const storeyExpressID = findStoreyForElement(beamExpressID);
+                const parentExpressID = storeyExpressID ?? parentMap.get(beamExpressID);
+                const parentNodeId = parentExpressID ? expressIdToNodeId.get(parentExpressID) : undefined;
+                const parent = parentNodeId ? nodes[parentNodeId] : undefined;
+                const levelElevation = parent?.type === 'level' ? Number(meta(parent).elevation ?? 0) : 0;
+                const geometry = extractBeamGeometry(ifcApi, modelID, beamExpressID, {
+                    origin: originOffset,
+                    unitFactor,
+                    swapYZ: opts.swapYZ,
+                    levelElevation,
+                });
+                if (!geometry)
+                    throw new Error('No renderable beam geometry');
+                const beamNode = tryParse(BlockNode, 'beam', {
+                    name: beam.Name?.value || `Beam ${i + 1}`,
+                    parentId: parentNodeId ?? null,
+                    ...geometry,
+                    // IFC already places the beam vertically; overlapping slabs must not lift it again.
+                    supportSlabId: GROUND_SUPPORT_ID,
+                    metadata: buildMetadata({
+                        ifcType: beamType === WebIFC.IFCBEAM ? 'IFCBEAM' : 'IFCBEAMSTANDARDCASE',
+                        expressID: beamExpressID,
+                        globalId: beam.GlobalId?.value,
+                        predefinedType: beam.PredefinedType?.value,
+                    }),
+                });
+                nodes[beamNode.id] = beamNode;
+                expressIdToNodeId.set(beamExpressID, beamNode.id);
+                if (parent && 'children' in parent) {
+                    ;
+                    parent.children.push(beamNode.id);
+                }
+                else {
+                    rootNodeIds.push(beamNode.id);
+                }
+                convertedBeamCount++;
+            }
+            catch (error) {
+                skippedBeamCount++;
+                console.warn(`[IFC→Pascal] Could not convert beam #${beamExpressID}:`, error);
+            }
         }
     }
-    if (skippedBeamCount > 0) {
-        console.warn(`[IFC→Pascal] Skipped ${skippedBeamCount} beam${skippedBeamCount === 1 ? '' : 's'} — Pascal has no beam node yet.`);
-    }
-    // Items: skipped for now — Pascal's ItemNode requires a full `asset`
-    // (catalog reference with id/src/dimensions/etc.) that the converter
-    // can't synthesise from raw IFC geometry. When the editor grows a
-    // raw-geometry escape hatch (or we add a placeholder-asset registry),
-    // restore the mapping from the pre-migration git history. We still
-    // walk the entities to log a count for diagnostics.
-    let skippedItemCount = 0;
-    const itemTypeKeys = [
-        WebIFC.IFCFURNISHINGELEMENT,
-        WebIFC.IFCBUILDINGELEMENTPROXY,
-        WebIFC.IFCRAILING,
-        WebIFC.IFCCOVERING,
-        WebIFC.IFCCURTAINWALL,
-        WebIFC.IFCPLATE,
-        WebIFC.IFCMEMBER,
-        WebIFC.IFCFOOTING,
-    ];
-    for (const itemType of itemTypeKeys) {
+    // Preserve every unsupported building element as serialized triangle
+    // geometry. Failed native walls/slabs are included so unusual BRep or
+    // mapped geometry remains visible instead of silently disappearing.
+    const fallbackTypes = new Map();
+    const addFallbackType = (value, label) => {
+        if (typeof value === 'number' && value > 0)
+            fallbackTypes.set(value, label);
+    };
+    addFallbackType(WebIFC.IFCBEAM, 'IFCBEAM');
+    addFallbackType(WebIFC.IFCBEAMSTANDARDCASE, 'IFCBEAMSTANDARDCASE');
+    addFallbackType(WebIFC.IFCFURNISHINGELEMENT, 'IFCFURNISHINGELEMENT');
+    addFallbackType(WebIFC.IFCBUILDINGELEMENTPROXY, 'IFCBUILDINGELEMENTPROXY');
+    addFallbackType(WebIFC.IFCRAILING, 'IFCRAILING');
+    addFallbackType(WebIFC.IFCCOVERING, 'IFCCOVERING');
+    addFallbackType(WebIFC.IFCCURTAINWALL, 'IFCCURTAINWALL');
+    addFallbackType(WebIFC.IFCPLATE, 'IFCPLATE');
+    addFallbackType(WebIFC.IFCMEMBER, 'IFCMEMBER');
+    addFallbackType(WebIFC.IFCFOOTING, 'IFCFOOTING');
+    addFallbackType(WebIFC.IFCSTAIRFLIGHT, 'IFCSTAIRFLIGHT');
+    addFallbackType(WebIFC.IFCSPACE, 'IFCSPACE');
+    addFallbackType(WebIFC.IFCWALL, 'IFCWALL');
+    addFallbackType(WebIFC.IFCWALLSTANDARDCASE, 'IFCWALLSTANDARDCASE');
+    addFallbackType(WebIFC.IFCSLAB, 'IFCSLAB');
+    addFallbackType(WebIFC.IFCWINDOW, 'IFCWINDOW');
+    addFallbackType(WebIFC.IFCWINDOWSTANDARDCASE, 'IFCWINDOWSTANDARDCASE');
+    addFallbackType(WebIFC.IFCDOOR, 'IFCDOOR');
+    addFallbackType(WebIFC.IFCDOORSTANDARDCASE, 'IFCDOORSTANDARDCASE');
+    let importedMeshCount = 0;
+    for (const [ifcType, ifcTypeName] of fallbackTypes) {
+        let elements;
         try {
-            const items = ifcApi.GetLineIDsWithType(modelID, itemType);
-            skippedItemCount += items.size();
+            elements = ifcApi.GetLineIDsWithType(modelID, ifcType);
         }
         catch {
-            /* type not present in this file */
+            continue;
+        }
+        for (let i = 0; i < elements.size(); i++) {
+            const expressId = elements.get(i);
+            if (expressIdToNodeId.has(expressId))
+                continue;
+            const element = ifcApi.GetLine(modelID, expressId);
+            const parentNodeId = resolveElementParent(expressId);
+            const primitives = importedMeshPrimitivesFor(expressId);
+            if (primitives.length === 0)
+                continue;
+            const nodeId = generateId('imesh');
+            const importedMesh = tryParse(ImportedMeshNode, 'imported mesh', {
+                object: 'node',
+                id: nodeId,
+                type: 'imported-mesh',
+                name: element.Name?.value || `${ifcTypeName} ${i + 1}`,
+                parentId: parentNodeId,
+                visible: true,
+                position: [0, 0, 0],
+                rotation: [0, 0, 0],
+                primitives,
+                metadata: buildMetadata({
+                    ifcType: ifcTypeName,
+                    expressID: expressId,
+                    globalId: element.GlobalId?.value,
+                    predefinedType: element.PredefinedType?.value,
+                    objectType: element.ObjectType?.value,
+                }),
+            });
+            expressIdToNodeId.set(expressId, nodeId);
+            nodes[nodeId] = importedMesh;
+            attachNodeToGraph(nodeId, parentNodeId);
+            importedMeshCount++;
         }
-    }
-    if (skippedItemCount > 0) {
-        console.warn(`[IFC→Pascal] Skipped ${skippedItemCount} item${skippedItemCount === 1 ? '' : 's'} — Pascal items require a catalog asset the converter can't synthesise yet.`);
     }
     // Post-process: resolve levelId for all element nodes
     for (const node of Object.values(nodes)) {
         const m = meta(node);
         if (!m.expressID)
             continue;
-        const storeyExpId = findStoreyForElement(m.expressID);
+        const storeyExpId = resolveStoreyForElement(m.expressID);
         if (storeyExpId != null) {
             m.levelId = expressIdToNodeId.get(storeyExpId) ?? undefined;
         }
@@ -1794,6 +2134,15 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
     catch {
         /* no property rels */
     }
+    // Door presentation is derived only from standardized IFC semantics.
+    // OperationType is available on IfcDoor itself; glazing is conventionally
+    // carried by Pset_DoorCommon.GlazingAreaFraction.
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'door')
+            continue;
+        const glazingAreaFraction = meta(node).properties?.Pset_DoorCommon?.GlazingAreaFraction;
+        Object.assign(node, doorGlazingStyle(node, glazingAreaFraction));
+    }
     // Materials via IFCRELASSOCIATESMATERIAL
     try {
         const relMat = ifcApi.GetLineIDsWithType(modelID, WebIFC.IFCRELASSOCIATESMATERIAL);
@@ -1906,8 +2255,10 @@ export async function convertIfcToPascal(ifcData, onProgress, options) {
         stairs: Object.values(nodes).filter((n) => n.type === 'stair').length,
         roofs: Object.values(nodes).filter((n) => n.type === 'roof').length,
         columns: Object.values(nodes).filter((n) => n.type === 'column').length,
+        beams: convertedBeamCount,
         skippedBeams: skippedBeamCount,
-        skippedItems: skippedItemCount,
+        spaces: importedSpaceCount,
+        importedMeshes: importedMeshCount,
     });
     progress('Complete!', 100);
     return {

package/dist/storey-semantics.d.ts

@@ -0,0 +1,6 @@
+export type StoreyElevation = {
+    expressId: number;
+    elevation: number;
+};
+export declare function selectStoreyForElevation(candidates: StoreyElevation[], elementElevation: number): number | null;
+//# sourceMappingURL=storey-semantics.d.ts.map

package/dist/storey-semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storey-semantics.d.ts","sourceRoot":"","sources":["../src/storey-semantics.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,eAAe,EAAE,EAC7B,gBAAgB,EAAE,MAAM,GACvB,MAAM,GAAG,IAAI,CAIf"}

package/dist/storey-semantics.js

@@ -0,0 +1,5 @@
+export function selectStoreyForElevation(candidates, elementElevation) {
+    const ordered = [...candidates].sort((a, b) => a.elevation - b.elevation);
+    const atOrBelow = ordered.filter((candidate) => candidate.elevation <= elementElevation + 0.1);
+    return atOrBelow.at(-1)?.expressId ?? ordered.at(0)?.expressId ?? null;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pascal-app/ifc-converter",
-  "version": "1.0.0",
-  "description": "IFC \u2192 Pascal scene-graph conversion. Pure logic \u2014 no DOM, no React.",
+  "version": "1.0.3",
+  "description": "IFC → Pascal scene-graph conversion. Pure logic — no DOM, no React.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@pascal-app/core": "^1.0.0",
+    "@pascal-app/core": "^1.0.3",
     "nanoid": "^5.1.6",
     "web-ifc": "^0.0.77"
   },
@@ -34,7 +34,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pascalorg/editor.git",
+    "url": "git+https://github.com/pascalorg/editor.git",
     "directory": "packages/ifc-converter"
   },
   "license": "MIT",