@pascal-app/viewer 0.7.0 → 0.9.1

package/dist/systems/door/door-system.js

@@ -1,31 +1,109 @@
-import { clampDoorOperationState, getDoorRenderOpenAmount, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { clampDoorOperationState, DoorNode as DoorNodeSchema, getDoorRenderOpenAmount, getEffectiveNode, sceneRegistry, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
-import { baseMaterial, glassMaterial } from '../../lib/materials';
+import { createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, } from '../../lib/materials';
+import useViewer from '../../store/use-viewer';
 // Invisible material for root mesh — used as selection hitbox only
 const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
-const revealMaterial = new THREE.MeshBasicMaterial({ color: '#7f766c' });
+const defaultRevealMaterial = new THREE.MeshBasicMaterial({ color: '#7f766c' });
+let baseMaterial = getBaseMaterial();
+let revealMaterial = defaultRevealMaterial;
+let glassMaterial = defaultGlassMaterial;
+const DOOR_RENDER_DEFAULTS = DoorNodeSchema.parse({ id: 'door_render_default' });
+const MAX_DOOR_REBUILDS_PER_FRAME = 16;
+const DOOR_PROGRESSIVE_DIRTY_THRESHOLD = MAX_DOOR_REBUILDS_PER_FRAME;
+const DOOR_PROGRESSIVE_TIME_BUDGET_MS = 8;
+// Legacy/unparsed door nodes can miss schema-defaulted fields (segments,
+// columnRatios, dividerThickness, …) and crash the geometry build. Re-apply the
+// Zod defaults; if the node is structurally invalid (e.g. a segment missing a
+// required field) drop the bad segments, then fall back to defaults entirely.
+function normalizeDoorNodeForRender(node) {
+    const parsed = DoorNodeSchema.safeParse(node);
+    if (parsed.success)
+        return parsed.data;
+    const retry = DoorNodeSchema.safeParse({ ...node, segments: undefined });
+    if (retry.success)
+        return retry.data;
+    return { ...DOOR_RENDER_DEFAULTS, id: node.id, parentId: node.parentId };
+}
 export const DoorSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    const shading = useViewer((state) => state.shading);
+    const textures = useViewer((state) => state.textures);
+    const colorPreset = useViewer((state) => state.colorPreset);
+    const materialRevisionRef = useRef(null);
+    // Subscribe so an override-only update (no scene write) still re-runs
+    // the component, letting the gate below pick up the latest dirtyNodes
+    // set from the same render pass that received the override-publishing
+    // `markDirty` call. Mirrors WallSystem.
+    useLiveNodeOverrides((s) => s.overrides);
+    const joineryMaterial = createSurfaceRoleMaterial('joinery', colorPreset);
+    baseMaterial = textures ? getBaseMaterial(shading) : joineryMaterial;
+    revealMaterial = textures ? defaultRevealMaterial : joineryMaterial;
+    glassMaterial = textures ? defaultGlassMaterial : joineryMaterial;
+    useEffect(() => {
+        const materialRevision = `${shading}:${textures ? 'textures' : 'solid'}:${colorPreset}`;
+        if (materialRevisionRef.current === materialRevision)
+            return;
+        materialRevisionRef.current = materialRevision;
+        const nodes = useScene.getState().nodes;
+        for (const node of Object.values(nodes)) {
+            if (node?.type === 'door') {
+                useScene.getState().dirtyNodes.add(node.id);
+            }
+        }
+    });
     useFrame(() => {
         if (dirtyNodes.size === 0)
             return;
+        const frameJoineryMaterial = createSurfaceRoleMaterial('joinery', colorPreset);
+        baseMaterial = textures ? getBaseMaterial(shading) : frameJoineryMaterial;
+        revealMaterial = textures ? defaultRevealMaterial : frameJoineryMaterial;
+        glassMaterial = textures ? defaultGlassMaterial : frameJoineryMaterial;
         const nodes = useScene.getState().nodes;
+        const dirtyDoorIds = [];
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
             if (!node || node.type !== 'door')
                 return;
+            dirtyDoorIds.push(id);
+        });
+        const useProgressiveDoorRebuilds = dirtyDoorIds.length > DOOR_PROGRESSIVE_DIRTY_THRESHOLD;
+        const frameStartedAt = performance.now();
+        let rebuiltDoorsThisFrame = 0;
+        for (const id of dirtyDoorIds) {
+            if (useProgressiveDoorRebuilds) {
+                if (rebuiltDoorsThisFrame >= MAX_DOOR_REBUILDS_PER_FRAME) {
+                    break;
+                }
+                if (rebuiltDoorsThisFrame > 0 &&
+                    performance.now() - frameStartedAt >= DOOR_PROGRESSIVE_TIME_BUDGET_MS) {
+                    break;
+                }
+            }
+            const node = nodes[id];
+            if (!node || node.type !== 'door')
+                continue;
             const mesh = sceneRegistry.nodes.get(id);
             if (!mesh)
-                return; // Keep dirty until mesh mounts
-            updateDoorMesh(node, mesh);
+                continue; // Keep dirty until mesh mounts
+            // Merge any live override (width / height / position) so the mesh
+            // rebuild reflects the in-flight drag without zustand churn. When
+            // no override is set this returns the scene node unchanged.
+            const effectiveNode = getEffectiveNode(node);
+            updateDoorMesh(effectiveNode, mesh);
             clearDirty(id);
+            rebuiltDoorsThisFrame += 1;
             // Rebuild the parent wall so its cutout reflects the updated door geometry
-            if (node.parentId) {
-                useScene.getState().dirtyNodes.add(node.parentId);
+            // Avoid triggering expensive wall CSG rebuilds while the door is being interactively moved/duplicated.
+            // The editor tools will request a final wall rebuild on commit.
+            const isTransient = !!node.metadata?.isTransient;
+            if (!isTransient && effectiveNode.parentId) {
+                useScene.getState().dirtyNodes.add(effectiveNode.parentId);
             }
-        });
+        }
     }, 3);
     return null;
 };
@@ -56,6 +134,16 @@ function addShape(parent, material, shape, depth) {
     const mesh = new THREE.Mesh(geometry, material);
     parent.add(mesh);
 }
+function addShapeAt(parent, material, shape, depth, x, y, z) {
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth,
+        bevelEnabled: false,
+        curveSegments: 24,
+    });
+    geometry.translate(x, y, z - depth / 2);
+    const mesh = new THREE.Mesh(geometry, material);
+    parent.add(mesh);
+}
 function getClampedArchHeight(width, height, archHeight) {
     return Math.min(Math.max(archHeight ?? width / 2, 0.01), Math.max(height, 0.01));
 }
@@ -83,6 +171,32 @@ function getArchBoundaryY(x, halfWidth, springY, archHeight) {
     const t = Math.min(Math.abs(x) / halfWidth, 1);
     return springY + archHeight * Math.sqrt(Math.max(1 - t * t, 0));
 }
+function getOneSidedArchBoundaryYAtX(x, left, right, top, archHeight, curvedSide) {
+    const width = right - left;
+    if (width <= 1e-6)
+        return top;
+    const clampedArchHeight = getClampedArchHeight(width, Number.MAX_SAFE_INTEGER, archHeight);
+    const springY = top - clampedArchHeight;
+    const distanceFromApex = curvedSide === 'left'
+        ? Math.max(0, Math.min((right - x) / width, 1))
+        : Math.max(0, Math.min((x - left) / width, 1));
+    return (springY + clampedArchHeight * Math.sqrt(Math.max(1 - distanceFromApex * distanceFromApex, 0)));
+}
+function getRoundedBoundaryYAtX(x, left, right, top, radii) {
+    if (radii.topLeft > 1e-6 && x < left + radii.topLeft) {
+        const centerX = left + radii.topLeft;
+        const centerY = top - radii.topLeft;
+        const dx = x - centerX;
+        return centerY + Math.sqrt(Math.max(radii.topLeft * radii.topLeft - dx * dx, 0));
+    }
+    if (radii.topRight > 1e-6 && x > right - radii.topRight) {
+        const centerX = right - radii.topRight;
+        const centerY = top - radii.topRight;
+        const dx = x - centerX;
+        return centerY + Math.sqrt(Math.max(radii.topRight * radii.topRight - dx * dx, 0));
+    }
+    return top;
+}
 function createArchBandShape(width, outerSpringY, outerTopY, innerSpringY, innerTopY, insetX) {
     const halfWidth = width / 2;
     const innerHalfWidth = Math.max(halfWidth - insetX, 0);
@@ -215,6 +329,87 @@ function createRoundedLeafFrameShape(width, bottom, top, radii, insetX, insetY)
     outer.holes.push(shapeToReversedPath(createRoundedTopShape(innerLeft, innerRight, innerBottom, innerTop, innerRadii)));
     return outer;
 }
+function createRoundedClippedLeafFrameShape(left, right, bottom, top, fullLeft, fullRight, radii, insetX, insetY) {
+    const outerRadii = normalizeTopCornerRadii(radii, fullRight - fullLeft, top - bottom);
+    const outer = createTopClippedRectShape(left, right, bottom, top, (x) => getRoundedBoundaryYAtX(x, fullLeft, fullRight, top, {
+        topLeft: outerRadii.topLeft,
+        topRight: outerRadii.topRight,
+    }));
+    if (!outer)
+        return null;
+    const innerLeft = left + insetX;
+    const innerRight = right - insetX;
+    const innerBottom = bottom + insetY;
+    const innerTop = top - insetY;
+    if (innerRight <= innerLeft + 0.01 || innerTop <= innerBottom + 0.01)
+        return outer;
+    const innerFullLeft = fullLeft + insetX;
+    const innerFullRight = fullRight - insetX;
+    const innerRadii = normalizeTopCornerRadii({
+        topLeft: Math.max(outerRadii.topLeft - Math.max(insetX, insetY), 0),
+        topRight: Math.max(outerRadii.topRight - Math.max(insetX, insetY), 0),
+    }, innerFullRight - innerFullLeft, innerTop - innerBottom);
+    const holeShape = createTopClippedRectShape(innerLeft, innerRight, innerBottom, innerTop, (x) => getRoundedBoundaryYAtX(x, innerFullLeft, innerFullRight, innerTop, {
+        topLeft: innerRadii.topLeft,
+        topRight: innerRadii.topRight,
+    }));
+    if (holeShape)
+        outer.holes.push(shapeToReversedPath(holeShape));
+    return outer;
+}
+function createArchedLeafFrameShape(width, bottom, top, archHeight, insetX, insetY) {
+    const halfWidth = width / 2;
+    const outer = createArchShape(-halfWidth, halfWidth, bottom, top, archHeight);
+    const innerLeft = -halfWidth + insetX;
+    const innerRight = halfWidth - insetX;
+    const innerBottom = bottom + insetY;
+    const innerTop = top - insetY;
+    if (innerRight <= innerLeft + 0.01 || innerTop <= innerBottom + 0.01)
+        return outer;
+    const innerArchHeight = getClampedArchHeight(innerRight - innerLeft, innerTop - innerBottom, Math.max(archHeight - insetY, 0.01));
+    outer.holes.push(shapeToReversedPath(createArchShape(innerLeft, innerRight, innerBottom, innerTop, innerArchHeight)));
+    return outer;
+}
+function createArchedClippedLeafFrameShape(left, right, bottom, top, fullLeft, fullRight, archHeight, insetX, insetY) {
+    const fullCenterX = (fullLeft + fullRight) / 2;
+    const fullHalfWidth = (fullRight - fullLeft) / 2;
+    const springY = top - archHeight;
+    const outer = createTopClippedRectShape(left, right, bottom, top, (x) => getArchBoundaryY(x - fullCenterX, fullHalfWidth, springY, archHeight));
+    if (!outer)
+        return null;
+    const innerLeft = left + insetX;
+    const innerRight = right - insetX;
+    const innerBottom = bottom + insetY;
+    const innerTop = top - insetY;
+    if (innerRight <= innerLeft + 0.01 || innerTop <= innerBottom + 0.01)
+        return outer;
+    const innerFullLeft = fullLeft + insetX;
+    const innerFullRight = fullRight - insetX;
+    const innerArchHeight = getClampedArchHeight(innerFullRight - innerFullLeft, innerTop - innerBottom, Math.max(archHeight - insetY, 0.01));
+    const innerFullCenterX = (innerFullLeft + innerFullRight) / 2;
+    const innerFullHalfWidth = (innerFullRight - innerFullLeft) / 2;
+    const innerSpringY = innerTop - innerArchHeight;
+    const holeShape = createTopClippedRectShape(innerLeft, innerRight, innerBottom, innerTop, (x) => getArchBoundaryY(x - innerFullCenterX, innerFullHalfWidth, innerSpringY, innerArchHeight));
+    if (holeShape)
+        outer.holes.push(shapeToReversedPath(holeShape));
+    return outer;
+}
+function createOneSidedArchLeafFrameShape(left, right, bottom, top, archHeight, insetX, insetY, curvedSide) {
+    const outer = createTopClippedRectShape(left, right, bottom, top, (x) => getOneSidedArchBoundaryYAtX(x, left, right, top, archHeight, curvedSide));
+    if (!outer)
+        return null;
+    const innerLeft = left + insetX;
+    const innerRight = right - insetX;
+    const innerBottom = bottom + insetY;
+    const innerTop = top - insetY;
+    if (innerRight <= innerLeft + 0.01 || innerTop <= innerBottom + 0.01)
+        return outer;
+    const innerArchHeight = getClampedArchHeight(innerRight - innerLeft, innerTop - innerBottom, Math.max(archHeight - insetY, 0.01));
+    const holeShape = createTopClippedRectShape(innerLeft, innerRight, innerBottom, innerTop, (x) => getOneSidedArchBoundaryYAtX(x, innerLeft, innerRight, innerTop, innerArchHeight, curvedSide));
+    if (holeShape)
+        outer.holes.push(shapeToReversedPath(holeShape));
+    return outer;
+}
 function createTopClippedRectShape(left, right, bottom, top, getBoundaryY) {
     const segments = 20;
     const points = [];
@@ -242,16 +437,16 @@ function disposeObject(object) {
             child.geometry.dispose();
     });
 }
-function addLeafSegmentContent({ addLeafBox, leafWidth, leafHeight, leafCenterX, leafCenterY, leafDepth, segments, contentPadding, keepFrameWhenEmpty = false, }) {
+function addLeafSegmentContent({ addLeafBox, addLeafShape, leafWidth, leafHeight, leafCenterX, leafCenterY, leafDepth, segments, contentPadding, keepFrameWhenEmpty = false, renderPerimeterFrame = true, openingShape = 'rectangle', openingTopRadii, archHeight, archOuterSide, }) {
     const hasLeafContent = segments.some((seg) => seg.type !== 'empty');
     const shouldRenderFrame = hasLeafContent || keepFrameWhenEmpty;
     const cpX = contentPadding[0];
     const cpY = contentPadding[1];
-    if (shouldRenderFrame && cpY > 0) {
+    if (renderPerimeterFrame && shouldRenderFrame && cpY > 0) {
         addLeafBox(baseMaterial, leafWidth, cpY, leafDepth, leafCenterX, leafCenterY + leafHeight / 2 - cpY / 2, 0);
         addLeafBox(baseMaterial, leafWidth, cpY, leafDepth, leafCenterX, leafCenterY - leafHeight / 2 + cpY / 2, 0);
     }
-    if (shouldRenderFrame && cpX > 0) {
+    if (renderPerimeterFrame && shouldRenderFrame && cpX > 0) {
         const innerH = leafHeight - 2 * cpY;
         addLeafBox(baseMaterial, cpX, innerH, leafDepth, leafCenterX - leafWidth / 2 + cpX / 2, leafCenterY, 0);
         addLeafBox(baseMaterial, cpX, innerH, leafDepth, leafCenterX + leafWidth / 2 - cpX / 2, leafCenterY, 0);
@@ -261,9 +456,32 @@ function addLeafSegmentContent({ addLeafBox, leafWidth, leafHeight, leafCenterX,
     const totalRatio = segments.reduce((sum, s) => sum + s.heightRatio, 0);
     const contentTop = leafCenterY + contentH / 2;
     let segY = contentTop;
+    const leafLeft = leafCenterX - leafWidth / 2;
+    const leafRight = leafCenterX + leafWidth / 2;
+    const leafTop = leafCenterY + leafHeight / 2;
+    const hasShapedTop = openingShape === 'rounded' || openingShape === 'arch';
+    const clampedLeafArchHeight = openingShape === 'arch' ? getClampedArchHeight(leafWidth, leafHeight, archHeight) : 0;
+    const leafSpringY = leafTop - clampedLeafArchHeight;
+    const topBoundaryAtX = (x) => {
+        if (openingShape === 'rounded' && openingTopRadii) {
+            return getRoundedBoundaryYAtX(x, leafLeft, leafRight, leafTop, {
+                topLeft: openingTopRadii.topLeft,
+                topRight: openingTopRadii.topRight,
+            });
+        }
+        if (openingShape === 'arch') {
+            if (archOuterSide) {
+                return getOneSidedArchBoundaryYAtX(x, leafLeft, leafRight, leafTop, clampedLeafArchHeight, archOuterSide);
+            }
+            return getArchBoundaryY(x - leafCenterX, leafWidth / 2, leafSpringY, clampedLeafArchHeight);
+        }
+        return leafTop;
+    };
     for (const seg of segments) {
         const segH = (seg.heightRatio / totalRatio) * contentH;
         const segCenterY = segY - segH / 2;
+        const segTop = segY;
+        const segBottom = segY - segH;
         const numCols = seg.columnRatios.length;
         const colSum = seg.columnRatios.reduce((a, b) => a + b, 0);
         const usableW = contentW - (numCols - 1) * seg.dividerThickness;
@@ -280,7 +498,17 @@ function addLeafSegmentContent({ addLeafBox, leafWidth, leafHeight, leafCenterX,
             cx = leafCenterX - contentW / 2;
             for (let c = 0; c < numCols - 1; c++) {
                 cx += colWidths[c];
-                addLeafBox(baseMaterial, seg.dividerThickness, segH, leafDepth + 0.001, cx + seg.dividerThickness / 2, segCenterY, 0);
+                const dividerLeft = cx;
+                const dividerRight = cx + seg.dividerThickness;
+                const dividerShape = hasShapedTop && addLeafShape
+                    ? createTopClippedRectShape(dividerLeft, dividerRight, segBottom, segTop, topBoundaryAtX)
+                    : null;
+                if (dividerShape && addLeafShape) {
+                    addLeafShape(baseMaterial, dividerShape, leafDepth + 0.001);
+                }
+                else {
+                    addLeafBox(baseMaterial, seg.dividerThickness, segH, leafDepth + 0.001, cx + seg.dividerThickness / 2, segCenterY, 0);
+                }
                 cx += seg.dividerThickness;
             }
         }
@@ -289,31 +517,99 @@ function addLeafSegmentContent({ addLeafBox, leafWidth, leafHeight, leafCenterX,
             const colX = colXCenters[c];
             if (seg.type === 'glass') {
                 const glassDepth = Math.max(0.004, leafDepth * 0.15);
-                addLeafBox(glassMaterial, colW, segH, glassDepth, colX, segCenterY, 0);
+                const segmentLeft = colX - colW / 2;
+                const segmentRight = colX + colW / 2;
+                const glassShape = hasShapedTop && addLeafShape
+                    ? createTopClippedRectShape(segmentLeft, segmentRight, segBottom, segTop, topBoundaryAtX)
+                    : null;
+                if (glassShape && addLeafShape) {
+                    addLeafShape(glassMaterial, glassShape, glassDepth);
+                }
+                else {
+                    addLeafBox(glassMaterial, colW, segH, glassDepth, colX, segCenterY, 0);
+                }
             }
             else if (seg.type === 'panel') {
-                addLeafBox(baseMaterial, colW, segH, leafDepth, colX, segCenterY, 0);
+                const segmentLeft = colX - colW / 2;
+                const segmentRight = colX + colW / 2;
+                const outerPanelShape = hasShapedTop && addLeafShape
+                    ? createTopClippedRectShape(segmentLeft, segmentRight, segBottom, segTop, topBoundaryAtX)
+                    : null;
+                if (outerPanelShape && addLeafShape) {
+                    addLeafShape(baseMaterial, outerPanelShape, leafDepth);
+                }
+                else {
+                    addLeafBox(baseMaterial, colW, segH, leafDepth, colX, segCenterY, 0);
+                }
                 const panelW = colW - 2 * seg.panelInset;
                 const panelH = segH - 2 * seg.panelInset;
                 if (panelW > 0.01 && panelH > 0.01) {
                     const effectiveDepth = Math.abs(seg.panelDepth) < 0.002 ? 0.005 : Math.abs(seg.panelDepth);
                     const panelZ = leafDepth / 2 + effectiveDepth / 2;
-                    addLeafBox(baseMaterial, panelW, panelH, effectiveDepth, colX, segCenterY, panelZ);
+                    const insetLeft = colX - panelW / 2;
+                    const insetRight = colX + panelW / 2;
+                    const insetTop = segTop - seg.panelInset;
+                    const insetBottom = segBottom + seg.panelInset;
+                    const innerPanelShape = hasShapedTop && addLeafShape
+                        ? createTopClippedRectShape(insetLeft, insetRight, insetBottom, insetTop, topBoundaryAtX)
+                        : null;
+                    if (innerPanelShape && addLeafShape) {
+                        addLeafShape(baseMaterial, innerPanelShape, effectiveDepth);
+                    }
+                    else {
+                        addLeafBox(baseMaterial, panelW, panelH, effectiveDepth, colX, segCenterY, panelZ);
+                    }
                 }
             }
         }
         segY -= segH;
     }
 }
-function addDoorLeaf(mesh, { leafWidth, leafHeight, leafCenterX, leafCenterY, leafDepth, hingeX, hingeSide, swingRotation, segments, contentPadding, handle, handleBothSides = false, handleHeight, handleSide, doorCloser, panicBar, panicBarHeight, doorHeight, }) {
+function addDoorLeaf(mesh, { leafWidth, leafHeight, leafCenterX, leafCenterY, leafDepth, hingeX, hingeSide, swingRotation, segments, contentPadding, handle, handleBothSides = false, handleHeight, handleSide, doorCloser, panicBar, panicBarHeight, doorHeight, openingShape, openingTopRadii, archHeight, roundedBoundary, archedBoundary, archOuterSide, }) {
     const hasLeafContent = segments.some((seg) => seg.type !== 'empty');
     const leafGroup = new THREE.Group();
     leafGroup.position.set(hingeX, 0, 0);
     leafGroup.rotation.y = swingRotation;
     mesh.add(leafGroup);
     const addLeafBox = (material, w, h, d, x, y, z) => addBox(leafGroup, material, w, h, d, x - hingeX, y, z);
+    const addLeafShape = (material, shape, depth) => addShapeAt(leafGroup, material, shape, depth, -hingeX, 0, 0);
+    const localLeafCenterX = leafCenterX - hingeX;
+    const leafBottom = leafCenterY - leafHeight / 2;
+    const leafTop = leafCenterY + leafHeight / 2;
+    const usesShapedLeafFrame = openingShape === 'rounded' || openingShape === 'arch';
+    if (usesShapedLeafFrame && hasLeafContent) {
+        if (openingShape === 'rounded') {
+            const roundedLeafShape = roundedBoundary
+                ? createRoundedClippedLeafFrameShape(leafCenterX - leafWidth / 2, leafCenterX + leafWidth / 2, leafBottom, leafTop, roundedBoundary.fullLeft, roundedBoundary.fullRight, roundedBoundary.radii, contentPadding[0], contentPadding[1])
+                : createRoundedLeafFrameShape(leafWidth, leafBottom, leafTop, openingTopRadii, contentPadding[0], contentPadding[1]);
+            if (roundedLeafShape) {
+                if (roundedBoundary) {
+                    addLeafShape(baseMaterial, roundedLeafShape, leafDepth);
+                }
+                else {
+                    addShapeAt(leafGroup, baseMaterial, roundedLeafShape, leafDepth, localLeafCenterX, 0, 0);
+                }
+            }
+        }
+        else if (openingShape === 'arch') {
+            const archedLeafShape = archOuterSide
+                ? createOneSidedArchLeafFrameShape(leafCenterX - leafWidth / 2, leafCenterX + leafWidth / 2, leafBottom, leafTop, archHeight, contentPadding[0], contentPadding[1], archOuterSide)
+                : archedBoundary
+                    ? createArchedClippedLeafFrameShape(leafCenterX - leafWidth / 2, leafCenterX + leafWidth / 2, leafBottom, leafTop, archedBoundary.fullLeft, archedBoundary.fullRight, archedBoundary.archHeight, contentPadding[0], contentPadding[1])
+                    : createArchedLeafFrameShape(leafWidth, leafBottom, leafTop, getClampedArchHeight(leafWidth, leafHeight, archHeight), contentPadding[0], contentPadding[1]);
+            if (archedLeafShape) {
+                if (archOuterSide || archedBoundary) {
+                    addLeafShape(baseMaterial, archedLeafShape, leafDepth);
+                }
+                else {
+                    addShapeAt(leafGroup, baseMaterial, archedLeafShape, leafDepth, localLeafCenterX, 0, 0);
+                }
+            }
+        }
+    }
     addLeafSegmentContent({
         addLeafBox,
+        addLeafShape,
         leafWidth,
         leafHeight,
         leafCenterX,
@@ -321,6 +617,11 @@ function addDoorLeaf(mesh, { leafWidth, leafHeight, leafCenterX, leafCenterY, le
         leafDepth,
         segments,
         contentPadding,
+        renderPerimeterFrame: !usesShapedLeafFrame,
+        openingShape,
+        openingTopRadii,
+        archHeight,
+        archOuterSide,
     });
     if (hasLeafContent && handle) {
         const handleY = handleHeight - doorHeight / 2;
@@ -349,8 +650,6 @@ function addDoorLeaf(mesh, { leafWidth, leafHeight, leafCenterX, leafCenterY, le
         const hingeH = 0.1;
         const hingeW = 0.024;
         const hingeD = leafDepth + 0.016;
-        const leafBottom = leafCenterY - leafHeight / 2;
-        const leafTop = leafCenterY + leafHeight / 2;
         addBox(mesh, baseMaterial, hingeW, hingeH, hingeD, hingeMarkerX, leafBottom + 0.25, 0);
         addBox(mesh, baseMaterial, hingeW, hingeH, hingeD, hingeMarkerX, (leafBottom + leafTop) / 2, 0);
         addBox(mesh, baseMaterial, hingeW, hingeH, hingeD, hingeMarkerX, leafTop - 0.25, 0);
@@ -607,7 +906,16 @@ function addGarageTiltupDoor(mesh, { insideWidth, leafHeight, leafCenterY, leafD
     addTiltupTrim(insetWidth / 2, 0, 0.018, insetHeight);
     addBox(mesh, revealMaterial, insideWidth, 0.026, Math.max(frameDepth * 0.4, 0.035), 0, hingeY, 0);
 }
-function updateDoorMesh(node, mesh) {
+function getEffectiveOpeningShape(node) {
+    return node.doorType === 'folding' ||
+        node.doorType === 'pocket' ||
+        node.doorType === 'barn' ||
+        node.doorType === 'sliding'
+        ? 'rectangle'
+        : (node.openingShape ?? 'rectangle');
+}
+function updateDoorMesh(rawNode, mesh) {
+    const node = normalizeDoorNodeForRender(rawNode);
     // Root mesh is an invisible hitbox; all visuals live in child meshes
     mesh.geometry.dispose();
     mesh.geometry = new THREE.BoxGeometry(node.width, node.height, node.frameDepth);
@@ -622,7 +930,8 @@ function updateDoorMesh(node, mesh) {
         disposeObject(child);
         mesh.remove(child);
     }
-    const { width, height, openingKind, openingShape, frameThickness, frameDepth, threshold, thresholdHeight, segments, handle, handleHeight, handleSide, doorCloser, panicBar, panicBarHeight, contentPadding, hingesSide, swingDirection, swingAngle: nodeSwingAngle = 0, doorType = 'hinged', operationState: nodeOperationState = 0, leafCount = 1, slideDirection = 'left', garagePanelCount = 4, } = node;
+    const { width, height, openingKind, openingShape: rawOpeningShape, frameThickness, frameDepth, threshold, thresholdHeight, segments, handle, handleHeight, handleSide, doorCloser, panicBar, panicBarHeight, contentPadding, hingesSide, swingDirection, swingAngle: nodeSwingAngle = 0, doorType = 'hinged', operationState: nodeOperationState = 0, leafCount = 1, slideDirection = 'left', garagePanelCount = 4, } = node;
+    const openingShape = getEffectiveOpeningShape(node) ?? rawOpeningShape;
     const runtimeDoorState = useInteractive.getState().doors[node.id];
     const swingAngle = runtimeDoorState?.swingAngle ?? nodeSwingAngle;
     const operationState = runtimeDoorState?.operationState ?? nodeOperationState;
@@ -768,6 +1077,14 @@ function updateDoorMesh(node, mesh) {
     }
     else if (doorType === 'double' || doorType === 'french') {
         const doubleLeafW = insideWidth / 2;
+        const fullLeafTopRadii = getDoorTopRadii(node, insideWidth, leafH);
+        const roundedBoundary = openingShape === 'rounded'
+            ? {
+                fullLeft: -insideWidth / 2,
+                fullRight: insideWidth / 2,
+                radii: fullLeafTopRadii,
+            }
+            : undefined;
         addDoorLeaf(mesh, {
             leafWidth: doubleLeafW,
             leafHeight: leafH,
@@ -787,6 +1104,13 @@ function updateDoorMesh(node, mesh) {
             panicBar,
             panicBarHeight,
             doorHeight: height,
+            openingShape,
+            openingTopRadii: openingShape === 'rounded'
+                ? { topLeft: fullLeafTopRadii.topLeft, topRight: 0 }
+                : fullLeafTopRadii,
+            archHeight: node.archHeight ?? 0.45,
+            roundedBoundary,
+            archOuterSide: openingShape === 'arch' ? 'left' : undefined,
         });
         addDoorLeaf(mesh, {
             leafWidth: doubleLeafW,
@@ -807,6 +1131,13 @@ function updateDoorMesh(node, mesh) {
             panicBar,
             panicBarHeight,
             doorHeight: height,
+            openingShape,
+            openingTopRadii: openingShape === 'rounded'
+                ? { topLeft: 0, topRight: fullLeafTopRadii.topRight }
+                : fullLeafTopRadii,
+            archHeight: node.archHeight ?? 0.45,
+            roundedBoundary,
+            archOuterSide: openingShape === 'arch' ? 'right' : undefined,
         });
     }
     else {
@@ -831,9 +1162,28 @@ function updateDoorMesh(node, mesh) {
             panicBar,
             panicBarHeight,
             doorHeight: height,
+            openingShape,
+            openingTopRadii: getDoorTopRadii(node, insideWidth, leafH),
+            archHeight: node.archHeight ?? 0.45,
         });
     }
     syncDoorCutout(node, mesh);
+    // Guard: some degenerate door configs can leave a child mesh with an
+    // empty (0-vertex) geometry — e.g. a zero-area extruded leaf frame.
+    // Submitting such a mesh trips a WebGPU error ("Vertex buffer slot 0
+    // … was not set" on a Draw(0, …)). Hide any empty mesh so it is never
+    // drawn (it would render nothing anyway).
+    hideEmptyGeometryMeshes(mesh);
+}
+function hideEmptyGeometryMeshes(root) {
+    root.traverse((obj) => {
+        const child = obj;
+        if (!child.isMesh || !child.geometry)
+            return;
+        const position = child.geometry.getAttribute('position');
+        if (!position || position.count === 0)
+            child.visible = false;
+    });
 }
 function syncDoorCutout(node, mesh) {
     // ── Cutout (for wall CSG) — always full door dimensions, 1m deep ──
@@ -844,7 +1194,8 @@ function syncDoorCutout(node, mesh) {
         mesh.add(cutout);
     }
     cutout.geometry.dispose();
-    if (node.openingShape === 'arch') {
+    const openingShape = getEffectiveOpeningShape(node);
+    if (openingShape === 'arch') {
         cutout.geometry = new THREE.ExtrudeGeometry(createArchShape(-node.width / 2, node.width / 2, -node.height / 2, node.height / 2, getClampedArchHeight(node.width, node.height, node.archHeight)), {
             depth: 1,
             bevelEnabled: false,
@@ -852,7 +1203,7 @@ function syncDoorCutout(node, mesh) {
         });
         cutout.geometry.translate(0, 0, -0.5);
     }
-    else if (node.openingShape === 'rounded') {
+    else if (openingShape === 'rounded') {
         cutout.geometry = new THREE.ExtrudeGeometry(createRoundedTopShape(-node.width / 2, node.width / 2, -node.height / 2, node.height / 2, getDoorTopRadii(node, node.width, node.height)), {
             depth: 1,
             bevelEnabled: false,

package/dist/systems/elevator/elevator-interaction-system.d.ts

@@ -0,0 +1,2 @@
+export declare function ElevatorInteractionSystem(): null;
+//# sourceMappingURL=elevator-interaction-system.d.ts.map

package/dist/systems/elevator/elevator-interaction-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-interaction-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-interaction-system.tsx"],"names":[],"mappings":"AAkCA,wBAAgB,yBAAyB,SA0DxC"}

package/dist/systems/elevator/elevator-interaction-system.js

@@ -0,0 +1,62 @@
+import { openElevatorDoor, requestElevatorLevel, resolveElevatorDispatchTarget, useInteractive, useScene, } from '@pascal-app/core';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Raycaster, Vector2 } from 'three';
+function getElevatorButtonData(object) {
+    let current = object;
+    while (current) {
+        const data = current.userData.elevatorButton;
+        if (data)
+            return data;
+        current = current.parent;
+    }
+    return null;
+}
+export function ElevatorInteractionSystem() {
+    const camera = useThree((state) => state.camera);
+    const gl = useThree((state) => state.gl);
+    const scene = useThree((state) => state.scene);
+    const raycasterRef = useRef(new Raycaster());
+    const pointerRef = useRef(new Vector2());
+    useEffect(() => {
+        const canvas = gl.domElement;
+        const handlePointerDown = (event) => {
+            if (event.button !== 0)
+                return;
+            const rect = canvas.getBoundingClientRect();
+            const pointer = pointerRef.current;
+            pointer.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+            pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+            const raycaster = raycasterRef.current;
+            raycaster.setFromCamera(pointer, camera);
+            const button = raycaster
+                .intersectObjects(scene.children, true)
+                .map((intersection) => getElevatorButtonData(intersection.object))
+                .find((data) => data !== null);
+            if (!button || button.disabled)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            if (button.action === 'open-door') {
+                openElevatorDoor(button.elevatorId);
+                return;
+            }
+            if (!button.levelId)
+                return;
+            const targetElevatorId = button.kind === 'landing'
+                ? resolveElevatorDispatchTarget({
+                    elevators: useInteractive.getState().elevators,
+                    levelId: button.levelId,
+                    nodes: useScene.getState().nodes,
+                    requestedElevatorId: button.elevatorId,
+                })
+                : button.elevatorId;
+            requestElevatorLevel(targetElevatorId, button.levelId);
+        };
+        canvas.addEventListener('pointerdown', handlePointerDown, true);
+        return () => {
+            canvas.removeEventListener('pointerdown', handlePointerDown, true);
+        };
+    }, [camera, gl, scene]);
+    return null;
+}

package/dist/systems/fence/fence-system.d.ts

@@ -1,2 +1,5 @@
+import { type FenceNode } from '@pascal-app/core';
+import * as THREE from 'three';
+export declare function generateFenceGeometry(fence: FenceNode): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
 export declare const FenceSystem: () => null;
 //# sourceMappingURL=fence-system.d.ts.map

package/dist/systems/fence/fence-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AA6QA,eAAO,MAAM,WAAW,YAiBvB,CAAA"}
+{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA2O9B,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,oFAcrD;AAgBD,eAAO,MAAM,WAAW,YAiBvB,CAAA"}