@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/column/panel.js

@@ -5,6 +5,7 @@ import { ActionButton, ActionGroup, cn, PanelSection, PanelWrapper, SliderContro
 import { useViewer } from '@pascal-app/viewer';
 import { Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
+import { planColumnEdit } from './hosted-resize';
 const SELECT_CLASS = 'h-10 w-full rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-sm text-foreground outline-none transition-colors hover:bg-[#3e3e3e] focus:ring-1 focus:ring-border';
 const MANAGED_LEAN_TO_LAYOUT_FIELDS = new Set([
     'position',
@@ -246,7 +247,7 @@ export default function ColumnPanel() {
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const selectedCount = useViewer((s) => s.selection.selectedIds.length);
     const setSelection = useViewer((s) => s.setSelection);
-    const updateNode = useScene((s) => s.updateNode);
+    const updateNodes = useScene((s) => s.updateNodes);
     const deleteNode = useScene((s) => s.deleteNode);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
@@ -256,8 +257,10 @@ export default function ColumnPanel() {
         const nextUpdates = node && isManagedLeanToPost(node) ? filterManagedLeanToLayoutUpdates(updates) : updates;
         if (Object.keys(nextUpdates).length === 0)
             return;
-        updateNode(selectedId, nextUpdates);
-    }, [node, selectedId, updateNode]);
+        const updatesToApply = planColumnEdit(selectedId, nextUpdates);
+        if (updatesToApply)
+            updateNodes(updatesToApply.map(([id, data]) => ({ id, data })));
+    }, [node, selectedId, updateNodes]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
     }, [setSelection]);

package/dist/column/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/column/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAwwEzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA6C3D,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCAgDrE,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/column/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,kBAAkB,CAAA;AA6nEzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA6C3D,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCAgErE,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/column/renderer.js

@@ -1,9 +1,10 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
-import { baseMaterial, createColumnBoxGeometry, createColumnCylinderGeometry, createColumnSphereGeometry, createColumnTorusGeometry, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { collectDescendants, createSceneApi, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { baseMaterial, createColumnBoxGeometry, createColumnCylinderGeometry, createColumnSphereGeometry, createColumnTorusGeometry, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, NodeRenderer, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { createContext, useContext, useEffect, useMemo, useRef } from 'react';
 import { BufferGeometry, Float32BufferAttribute } from 'three';
+import { columnCapitalBlocks, columnShaftLayout, getSegments, getShaftScaleAt, getShaftSegmentCount, getShaftTwistRadians, } from './shape';
 import { COLUMN_BASE_DEFAULT, COLUMN_CAPITAL_DEFAULT, COLUMN_FRAME_DEFAULT, COLUMN_SHAFT_DEFAULT, } from './slots';
 const DEFAULT_COLUMN_MATERIAL = baseMaterial();
 const DEFAULT_COLUMN_SLOT_MATERIALS = createSingleColumnMaterialMap(DEFAULT_COLUMN_MATERIAL);
@@ -99,51 +100,6 @@ function createColumnSlotMaterials({ colorPreset, material, materialPreset, node
         }),
     };
 }
-function getSegments(node) {
-    if (node.crossSection === 'octagonal')
-        return 8;
-    if (node.crossSection === 'sixteen-sided')
-        return 16;
-    return 32;
-}
-function getShaftProfile(node) {
-    return node.shaftProfile ?? (node.shaftTaper > 0 ? 'tapered' : 'straight');
-}
-function getShaftSegmentCount(node) {
-    const shaftProfile = getShaftProfile(node);
-    const shaftTaper = node.shaftTaper ?? 0;
-    const hasTwist = Math.abs(node.shaftTwistStep ?? 0) > 0.001;
-    return Math.max(hasTwist ? 4 : 1, shaftProfile === 'straight' && shaftTaper <= 0 && !hasTwist
-        ? 1
-        : (node.shaftSegmentCount ?? (hasTwist ? 12 : 24)));
-}
-function getShaftTwistRadians(node, index) {
-    return ((node.shaftTwistStep ?? 0) * Math.PI * index) / 180;
-}
-function getShaftScaleAt(node, t) {
-    const shaftProfile = getShaftProfile(node);
-    const shaftTaper = Math.min(node.shaftTaper ?? 0, 0.85);
-    const startScale = node.shaftStartScale ?? 0.72;
-    const endScale = node.shaftEndScale ?? startScale;
-    const shaftBulge = node.shaftBulge ??
-        (shaftProfile === 'bulged'
-            ? 0.16
-            : shaftProfile === 'baluster'
-                ? 0.2
-                : shaftProfile === 'hourglass'
-                    ? 0.18
-                    : 0);
-    const taperedScale = 1 - shaftTaper * t;
-    const linearScale = (startScale + (endScale - startScale) * t) * taperedScale;
-    const bulgeCurve = Math.sin(Math.PI * t);
-    const hourglassCurve = Math.abs(t - 0.5) * 2;
-    const profileScale = shaftProfile === 'bulged' || shaftProfile === 'baluster'
-        ? linearScale + shaftBulge * bulgeCurve
-        : shaftProfile === 'hourglass'
-            ? linearScale - shaftBulge * (1 - hourglassCurve)
-            : linearScale;
-    return Math.max(0.1, profileScale);
-}
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
@@ -868,58 +824,15 @@ function LeafCarvings({ node, capitalY, capitalHeight, }) {
         })) }));
 }
 function Capital({ node, y, height }) {
-    if (height <= 0)
+    const blocks = columnCapitalBlocks(node, y, height);
+    if (!blocks.length)
         return null;
-    const capitalStyle = node.capitalStyle ?? 'simple';
-    if (capitalStyle === 'none')
-        return null;
-    if (capitalStyle === 'south-indian-bracket' || capitalStyle === 'wood-bracket') {
-        const tierCount = Math.max(1, node.bracketTierCount ?? 3);
-        const tierHeight = height / tierCount;
-        const bracketDepth = node.bracketDepth ?? 0.35;
-        return (_jsxs("group", { children: [Array.from({ length: tierCount }, (_, index) => {
-                    const t = index / Math.max(1, tierCount - 1);
-                    const scale = (node.capitalWidthScale ?? 1.6) + t * 0.32;
-                    return (_jsx(SquareBlock, { depth: node.depth * scale + bracketDepth * t, height: tierHeight, width: node.width * scale + bracketDepth * t, y: y + index * tierHeight }, index));
-                }), Array.from({ length: node.pendantCount ?? 0 }, (_, index) => {
-                    const count = Math.max(1, node.pendantCount ?? 0);
-                    const angle = (index / count) * Math.PI * 2;
+    return (_jsxs("group", { children: [blocks.map((block, index) => block.kind === 'box' ? (_jsx(SquareBlock, { y: block.y, height: block.height, width: block.width, depth: block.depth }, index)) : block.kind === 'oval' ? (_jsx(OvalBlock, { y: block.y, height: block.height, width: block.width, depth: block.depth }, index)) : block.kind === 'round' ? (_jsx(RoundBlock, { y: block.y, height: block.height, radius: block.radius, segments: getSegments(node) }, index)) : (_jsx(ColumnBlock, { node: node, y: block.y, height: block.height, scale: block.scale }, index))), (node.capitalStyle === 'south-indian-bracket' || node.capitalStyle === 'wood-bracket') &&
+                Array.from({ length: node.pendantCount ?? 0 }, (_, index) => {
+                    const angle = (index / Math.max(1, node.pendantCount ?? 0)) * Math.PI * 2;
                     const distance = Math.max(node.width, node.depth) * 0.56;
                     return (_jsx(MappedCone, { height: height * 0.28, position: [Math.cos(angle) * distance, y - height * 0.1, Math.sin(angle) * distance], radiusX: 0.035, rotation: [0, 0, 0], segments: 6 }, index));
-                })] }));
-    }
-    if (capitalStyle === 'rounded' || capitalStyle === 'doric') {
-        const topWidth = node.width * (node.capitalWidthScale ?? 1.34);
-        const topDepth = node.depth * (node.capitalDepthScale ?? node.capitalWidthScale ?? 1.34);
-        return (_jsxs("group", { children: [_jsx(OvalBlock, { depth: topDepth * 0.72, height: height * 0.24, segments: 32, width: topWidth * 0.72, y: y }), _jsx(OvalBlock, { depth: topDepth * 0.92, height: height * 0.32, segments: 32, width: topWidth * 0.92, y: y + height * 0.24 }), _jsx(SquareBlock, { depth: topDepth, height: height * 0.44, width: topWidth, y: y + height * 0.56 })] }));
-    }
-    if (capitalStyle === 'stepped') {
-        const widthScale = node.capitalWidthScale ?? 1.46;
-        const depthScale = node.capitalDepthScale ?? widthScale;
-        const tierCount = Math.max(3, node.capitalTierCount ?? 3);
-        const tierHeight = height / tierCount;
-        const stepSpread = node.capitalStepSpread ?? 0.42;
-        return (_jsx("group", { children: Array.from({ length: tierCount }, (_, index) => {
-                const t = index / Math.max(1, tierCount - 1);
-                const widthScaleAt = Math.max(0.5, widthScale - (1 - t) * stepSpread);
-                const depthScaleAt = Math.max(0.5, depthScale - (1 - t) * stepSpread);
-                return (_jsx(SquareBlock, { depth: node.depth * depthScaleAt, height: tierHeight * 1.01, width: node.width * widthScaleAt, y: y + index * tierHeight }, index));
-            }) }));
-    }
-    if (capitalStyle === 'volute' ||
-        capitalStyle === 'ionic-volute' ||
-        capitalStyle === 'leaf-carved' ||
-        capitalStyle === 'corinthian-leaf') {
-        const topWidth = node.width * (node.capitalWidthScale ?? 1.46);
-        const topDepth = node.depth * (node.capitalDepthScale ?? node.capitalWidthScale ?? 1.46);
-        return (_jsxs("group", { children: [_jsx(ColumnBlock, { height: height * 0.24, node: node, scale: 0.9, y: y }), _jsx(ColumnBlock, { height: height * 0.2, node: node, scale: 1.08, y: y + height * 0.24 }), _jsx(SquareBlock, { depth: topDepth, height: height * 0.28, width: topWidth, y: y + height * 0.44 }), _jsx(Volutes, { capitalHeight: height, capitalY: y, node: node }), _jsx(LeafCarvings, { capitalHeight: height, capitalY: y, node: node })] }));
-    }
-    const widthScale = node.capitalWidthScale ?? (capitalStyle === 'simple-slab' ? 1.28 : 1.18);
-    const depthScale = node.capitalDepthScale ?? widthScale;
-    if (node.crossSection === 'square' || node.crossSection === 'rectangular') {
-        return (_jsx(SquareBlock, { depth: node.depth * depthScale, height: height, width: node.width * widthScale, y: y }));
-    }
-    return (_jsx(RoundBlock, { height: height, radius: Math.max(node.radius * widthScale, node.width * widthScale * 0.5), segments: getSegments(node), y: y }));
+                }), _jsx(Volutes, { capitalHeight: height, capitalY: y, node: node }), _jsx(LeafCarvings, { capitalHeight: height, capitalY: y, node: node })] }));
 }
 /**
  * The column's geometry tree — either a fabricated support frame or the
@@ -931,12 +844,7 @@ function Capital({ node, y, height }) {
  * wrapping this in its own providers.
  */
 function ColumnBody({ node }) {
-    const shaftLayout = useMemo(() => {
-        const baseHeight = node.baseStyle === 'none' ? 0 : Math.min(node.baseHeight, node.height * 0.4);
-        const capitalHeight = node.capitalStyle === 'none' ? 0 : Math.min(node.capitalHeight, node.height * 0.4);
-        const shaftHeight = Math.max(0.1, node.height - baseHeight - capitalHeight);
-        return { baseHeight, capitalHeight, shaftY: baseHeight, shaftHeight };
-    }, [node.baseHeight, node.baseStyle, node.capitalHeight, node.capitalStyle, node.height]);
+    const shaftLayout = columnShaftLayout(node);
     if (node.supportStyle !== 'vertical') {
         const support = node.supportStyle === 'a-frame' ? (_jsx(AFrameSupport, { node: node })) : node.supportStyle === 'y-frame' ? (_jsx(YFrameSupport, { node: node })) : node.supportStyle === 'v-frame' ? (_jsx(VFrameSupport, { node: node })) : node.supportStyle === 'x-brace' ? (_jsx(XBraceSupport, { node: node })) : node.supportStyle === 'k-brace' ? (_jsx(KBraceSupport, { node: node })) : node.supportStyle === 'single-strut' ? (_jsx(SingleStrutSupport, { node: node })) : node.supportStyle === 'tripod' ? (_jsx(TripodSupport, { node: node })) : node.supportStyle === 'trestle' ? (_jsx(TrestleSupport, { node: node })) : node.supportStyle === 'portal-frame' ? (_jsx(PortalFrameSupport, { node: node })) : (_jsx(BoxFrameSupport, { node: node }));
         return _jsx(ColumnSlot, { slotId: "frame", children: support });
@@ -1011,6 +919,20 @@ export const ColumnRenderer = ({ node: rawNode }) => {
         colorPreset,
     }), [shading, textures, colorPreset, node, sceneMaterials]);
     useRegistry(node.id, node.type, ref);
-    return (_jsx(ColumnMaterialContext.Provider, { value: materials, children: _jsx(ColumnEdgeSoftnessContext.Provider, { value: node.edgeSoftness ?? 0.025, children: _jsx("group", { position: liveTransform?.position ?? node.position, ref: ref, rotation: [0, liveTransform?.rotation ?? node.rotation, 0], visible: node.visible, ...handlers, children: _jsx(ColumnBody, { node: node }) }) }) }));
+    // This renderer bypasses GeometrySystem, which normally invalidates hosted descendants.
+    useEffect(() => {
+        const dirtySubtree = () => {
+            const scene = createSceneApi(useScene);
+            for (const id of collectDescendants(node.id, { scene })) {
+                scene.markDirty(id);
+            }
+        };
+        dirtySubtree();
+        return useLiveTransforms.subscribe((state, previous) => {
+            if (state.transforms.get(node.id) !== previous.transforms.get(node.id))
+                dirtySubtree();
+        });
+    }, [node]);
+    return (_jsx(ColumnMaterialContext.Provider, { value: materials, children: _jsx(ColumnEdgeSoftnessContext.Provider, { value: node.edgeSoftness ?? 0.025, children: _jsxs("group", { position: liveTransform?.position ?? node.position, ref: ref, rotation: [0, liveTransform?.rotation ?? node.rotation, 0], visible: node.visible, ...handlers, children: [_jsx(ColumnBody, { node: node }), node.children.map((id) => (_jsx(NodeRenderer, { nodeId: id }, id)))] }) }) }));
 };
 export default ColumnRenderer;

package/dist/column/shape.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnNode } from '@pascal-app/core';
+export declare function getSegments(node: ColumnNode): 8 | 16 | 32;
+export declare function getShaftSegmentCount(node: ColumnNode): number;
+export declare function getShaftTwistRadians(node: ColumnNode, index: number): number;
+export declare function getShaftScaleAt(node: ColumnNode, t: number): number;
+export declare function columnShaftLayout(node: ColumnNode): {
+    baseHeight: number;
+    capitalHeight: number;
+    shaftY: number;
+    shaftHeight: number;
+};
+export type CapitalBlock = {
+    kind: 'box' | 'round' | 'oval' | 'column';
+    y: number;
+    height: number;
+    width?: number;
+    depth?: number;
+    radius?: number;
+    scale?: number;
+};
+export declare function columnCapitalBlocks(node: ColumnNode, y: number, height: number): CapitalBlock[];
+//# sourceMappingURL=shape.d.ts.map

package/dist/column/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../../src/column/shape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,eAI3C;AAMD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,UAUpD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,UAEnE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,UA0B1D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU;;;;;EAMjD;AACD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;IACzC,CAAC,EAAE,MAAM,CAAA;IACT,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,CAyE/F"}

package/dist/column/shape.js

@@ -0,0 +1,120 @@
+export function getSegments(node) {
+    if (node.crossSection === 'octagonal')
+        return 8;
+    if (node.crossSection === 'sixteen-sided')
+        return 16;
+    return 32;
+}
+function getShaftProfile(node) {
+    return node.shaftProfile ?? (node.shaftTaper > 0 ? 'tapered' : 'straight');
+}
+export function getShaftSegmentCount(node) {
+    const shaftProfile = getShaftProfile(node);
+    const shaftTaper = node.shaftTaper ?? 0;
+    const hasTwist = Math.abs(node.shaftTwistStep ?? 0) > 0.001;
+    return Math.max(hasTwist ? 4 : 1, shaftProfile === 'straight' && shaftTaper <= 0 && !hasTwist
+        ? 1
+        : (node.shaftSegmentCount ?? (hasTwist ? 12 : 24)));
+}
+export function getShaftTwistRadians(node, index) {
+    return ((node.shaftTwistStep ?? 0) * Math.PI * index) / 180;
+}
+export function getShaftScaleAt(node, t) {
+    const shaftProfile = getShaftProfile(node);
+    const shaftTaper = Math.min(node.shaftTaper ?? 0, 0.85);
+    const startScale = node.shaftStartScale ?? 0.72;
+    const endScale = node.shaftEndScale ?? startScale;
+    const shaftBulge = node.shaftBulge ??
+        (shaftProfile === 'bulged'
+            ? 0.16
+            : shaftProfile === 'baluster'
+                ? 0.2
+                : shaftProfile === 'hourglass'
+                    ? 0.18
+                    : 0);
+    const taperedScale = 1 - shaftTaper * t;
+    const linearScale = (startScale + (endScale - startScale) * t) * taperedScale;
+    const bulgeCurve = Math.sin(Math.PI * t);
+    const hourglassCurve = Math.abs(t - 0.5) * 2;
+    const profileScale = shaftProfile === 'bulged' || shaftProfile === 'baluster'
+        ? linearScale + shaftBulge * bulgeCurve
+        : shaftProfile === 'hourglass'
+            ? linearScale - shaftBulge * (1 - hourglassCurve)
+            : linearScale;
+    return Math.max(0.1, profileScale);
+}
+export function columnShaftLayout(node) {
+    const baseHeight = node.baseStyle === 'none' ? 0 : Math.min(node.baseHeight, node.height * 0.4);
+    const capitalHeight = node.capitalStyle === 'none' ? 0 : Math.min(node.capitalHeight, node.height * 0.4);
+    const shaftHeight = Math.max(0.1, node.height - baseHeight - capitalHeight);
+    return { baseHeight, capitalHeight, shaftY: baseHeight, shaftHeight };
+}
+export function columnCapitalBlocks(node, y, height) {
+    const style = node.capitalStyle ?? 'simple';
+    if (height <= 0 || style === 'none')
+        return [];
+    if (style === 'south-indian-bracket' || style === 'wood-bracket') {
+        const count = Math.max(1, node.bracketTierCount ?? 3);
+        return Array.from({ length: count }, (_, index) => {
+            const t = index / Math.max(1, count - 1), scale = (node.capitalWidthScale ?? 1.6) + t * 0.32;
+            return {
+                kind: 'box',
+                y: y + (index * height) / count,
+                height: height / count,
+                width: node.width * scale + (node.bracketDepth ?? 0.35) * t,
+                depth: node.depth * scale + (node.bracketDepth ?? 0.35) * t,
+            };
+        });
+    }
+    if (style === 'rounded' || style === 'doric') {
+        const width = node.width * (node.capitalWidthScale ?? 1.34), depth = node.depth * (node.capitalDepthScale ?? node.capitalWidthScale ?? 1.34);
+        return [
+            { kind: 'oval', y, height: height * 0.24, width: width * 0.72, depth: depth * 0.72 },
+            {
+                kind: 'oval',
+                y: y + height * 0.24,
+                height: height * 0.32,
+                width: width * 0.92,
+                depth: depth * 0.92,
+            },
+            { kind: 'box', y: y + height * 0.56, height: height * 0.44, width, depth },
+        ];
+    }
+    if (style === 'stepped') {
+        const widthScale = node.capitalWidthScale ?? 1.46, depthScale = node.capitalDepthScale ?? widthScale, count = Math.max(3, node.capitalTierCount ?? 3);
+        return Array.from({ length: count }, (_, index) => {
+            const t = index / Math.max(1, count - 1), spread = (1 - t) * (node.capitalStepSpread ?? 0.42);
+            return {
+                kind: 'box',
+                y: y + (index * height) / count,
+                height: (height / count) * 1.01,
+                width: node.width * Math.max(0.5, widthScale - spread),
+                depth: node.depth * Math.max(0.5, depthScale - spread),
+            };
+        });
+    }
+    if (['volute', 'ionic-volute', 'leaf-carved', 'corinthian-leaf'].includes(style)) {
+        return [
+            { kind: 'column', y, height: height * 0.24, scale: 0.9 },
+            { kind: 'column', y: y + height * 0.24, height: height * 0.2, scale: 1.08 },
+            {
+                kind: 'box',
+                y: y + height * 0.44,
+                height: height * 0.28,
+                width: node.width * (node.capitalWidthScale ?? 1.46),
+                depth: node.depth * (node.capitalDepthScale ?? node.capitalWidthScale ?? 1.46),
+            },
+        ];
+    }
+    const widthScale = node.capitalWidthScale ?? (style === 'simple-slab' ? 1.28 : 1.18), depthScale = node.capitalDepthScale ?? widthScale;
+    return node.crossSection === 'square' || node.crossSection === 'rectangular'
+        ? [{ kind: 'box', y, height, width: node.width * widthScale, depth: node.depth * depthScale }]
+        : [
+            {
+                kind: 'round',
+                y,
+                height,
+                radius: Math.max(node.radius * widthScale, node.width * widthScale * 0.5),
+            },
+        ];
+}

package/dist/column/surface.d.ts

@@ -0,0 +1,4 @@
+import { type ColumnNode, type DeclaredHostSurface, type SurfaceProvider } from '@pascal-app/core';
+export declare function columnTopSurfaces(node: ColumnNode): DeclaredHostSurface[];
+export declare const columnSurfaceProvider: SurfaceProvider;
+//# sourceMappingURL=surface.d.ts.map

package/dist/column/surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.d.ts","sourceRoot":"","sources":["../../src/column/surface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAExB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAoBzB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,EAAE,CAgDzE;AAED,eAAO,MAAM,qBAAqB,EAAE,eAUnC,CAAA"}

package/dist/column/surface.js

@@ -0,0 +1,66 @@
+import { hitDerivedSurfaceProvider, } from '@pascal-app/core';
+import { columnCapitalBlocks, columnShaftLayout, getSegments, getShaftScaleAt, getShaftSegmentCount, getShaftTwistRadians, } from './shape';
+function roundRegion(radius, segments, yaw = 0) {
+    return {
+        kind: 'polygon',
+        points: Array.from({ length: segments }, (_, i) => {
+            const angle = (i * Math.PI * 2) / segments + yaw;
+            return [Math.sin(angle) * radius, Math.cos(angle) * radius];
+        }),
+    };
+}
+export function columnTopSurfaces(node) {
+    if (node.supportStyle !== 'vertical' || node.style === 'cluster')
+        return [];
+    const layout = columnShaftLayout(node);
+    const cap = columnCapitalBlocks(node, layout.shaftY + layout.shaftHeight, layout.capitalHeight).at(-1);
+    let y;
+    let region;
+    if (cap) {
+        y = cap.y + cap.height;
+        if (cap.kind === 'round')
+            region = roundRegion(cap.radius, getSegments(node));
+        else {
+            const bevel = Math.min(Math.max(0, node.edgeSoftness ?? 0.025), Math.min(cap.width, cap.depth, cap.height) * 0.35);
+            region = { kind: 'rect', size: [cap.width / 2 - bevel, cap.depth / 2 - bevel] };
+        }
+    }
+    else {
+        const segments = getShaftSegmentCount(node);
+        const scale = getShaftScaleAt(node, (segments - 0.5) / segments);
+        const yaw = getShaftTwistRadians(node, segments - 1);
+        y = layout.shaftY + layout.shaftHeight + (layout.shaftHeight / segments) * 0.015;
+        if (node.crossSection === 'square' || node.crossSection === 'rectangular') {
+            const corner = Math.min(Math.max(0, node.shaftCornerRadius ?? 0.035), Math.min(node.width, node.depth) * 0.45) * scale;
+            const x = (node.width * scale) / 2 - corner;
+            const z = (node.depth * scale) / 2 - corner;
+            region = {
+                kind: 'polygon',
+                points: [
+                    [-x, -z],
+                    [x, -z],
+                    [x, z],
+                    [-x, z],
+                ].map(([px, pz]) => [
+                    px * Math.cos(yaw) + pz * Math.sin(yaw),
+                    -px * Math.sin(yaw) + pz * Math.cos(yaw),
+                ]),
+            };
+        }
+        else
+            region = roundRegion(node.radius * scale, getSegments(node), yaw);
+    }
+    return [{ id: 'top', position: [0, y, 0], normal: [0, 1, 0], region }];
+}
+export const columnSurfaceProvider = {
+    ...hitDerivedSurfaceProvider,
+    surfaces: (host) => columnTopSurfaces(host),
+    resolveHit(host, hit, ctx) {
+        const derived = hitDerivedSurfaceProvider.resolveHit(host, hit, ctx);
+        if (!derived)
+            return null;
+        const top = columnTopSurfaces(host)[0];
+        // Lower ornaments remain hit-derived; only the principal top has a durable resize identity.
+        return top && Math.abs(hit.point[1] - top.position[1]) < 1e-4 ? top : derived;
+    },
+};

package/dist/cupola/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA6FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgE9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA6FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAiE9D,CAAA"}

package/dist/cupola/definition.js

@@ -126,6 +126,7 @@ export const cupolaDefinition = {
     parametrics: cupolaParametrics,
     handles: cupolaHandles,
     floorplan: buildCupolaFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/door/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AAkBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA4HnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAqH1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AAqBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAkKnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsH1D,CAAA"}

package/dist/door/definition.js

@@ -1,5 +1,8 @@
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits';
 import { buildDoorFloorplanSchedule, computeDoorFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
+import { createOpeningPropertyPreview } from '../shared/opening-property-preview';
+import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
 import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
 import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
@@ -46,7 +49,7 @@ function doorWidthHandle(side) {
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_DOOR_WIDTH, roofMax);
-            return readWallLength(n, scene);
+            return curtainOpeningResizeMax(n, scene.nodes(), 'x', sign) ?? readWallLength(n, scene);
         },
         currentValue: (n) => n.width,
         onDrag: (node) => publishOpeningResizeGuides(node, false),
@@ -88,6 +91,9 @@ function doorHeightHandle() {
             const roofMax = readRoofFaceHeightMax(n, scene, 1);
             if (roofMax !== null)
                 return Math.max(MIN_DOOR_HEIGHT, roofMax);
+            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', 1);
+            if (curtainMax !== undefined)
+                return curtainMax;
             const bottom = n.position[1] - n.height / 2;
             return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene) - bottom);
         },
@@ -126,11 +132,43 @@ function doorMoveHandle() {
         },
     };
 }
+function doorRadiusHandle(index) {
+    const sign = index === 0 ? -1 : 1;
+    return {
+        kind: 'corner-radius',
+        corner: [sign, 1],
+        width: (node) => node.width,
+        height: (node) => node.height,
+        currentValue: (node) => node.openingRadiusMode === 'individual'
+            ? (node.openingTopRadii[index] ?? 0)
+            : node.cornerRadius,
+        max: (node) => Math.min(node.width / 2, node.height),
+        apply: (node, radius, _scene, modifiers) => {
+            if (!modifiers.shiftKey) {
+                return { openingShape: 'rounded', openingRadiusMode: 'all', cornerRadius: radius };
+            }
+            const radii = node.openingRadiusMode === 'individual'
+                ? [...node.openingTopRadii]
+                : [node.cornerRadius, node.cornerRadius];
+            radii[index] = radius;
+            return {
+                openingShape: 'rounded',
+                openingRadiusMode: 'individual',
+                openingTopRadii: radii,
+            };
+        },
+        createPreview: (node) => createOpeningPropertyPreview(node.id, openingPropertyPreviewHost),
+        visible: (node) => node.openingShape !== 'arch',
+        portal: 'grandparent',
+    };
+}
 const doorHandles = [
     doorMoveHandle(),
     doorWidthHandle('left'),
     doorWidthHandle('right'),
     doorHeightHandle(),
+    doorRadiusHandle(0),
+    doorRadiusHandle(1),
 ];
 /**
  * Door — Phase 5 batch kind. Hosted on walls, cuts holes in them,
@@ -200,6 +238,7 @@ export const doorDefinition = {
     },
     parametrics: doorParametrics,
     handles: doorHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/door/door-math.d.ts

@@ -1,4 +1,4 @@
-import type { WallNode } from '@pascal-app/core';
+import { type WallNode } from '@pascal-app/core';
 /**
  * Keep the door handle at the same relative height when the door is resized:
  * scale it by the height ratio, then clamp to the panel's slider bounds

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

@@ -1 +1 @@
-{"version":3,"file":"door-math.d.ts","sourceRoot":"","sources":["../../src/door/door-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAU1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAQxC;AAKD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}
+{"version":3,"file":"door-math.d.ts","sourceRoot":"","sources":["../../src/door/door-math.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAOxC;AAKD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/door/door-math.js

@@ -1,3 +1,4 @@
+import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, } from '@pascal-app/core';
 /**
  * Keep the door handle at the same relative height when the door is resized:
  * scale it by the height ratio, then clamp to the panel's slider bounds
@@ -13,22 +14,18 @@ export function scaleHandleHeight(handleHeight, oldHeight, newHeight) {
  * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
  */
 export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0) {
-    const wallAngle = Math.atan2(wallNode.end[1] - wallNode.start[1], wallNode.end[0] - wallNode.start[0]);
-    return [
-        wallNode.start[0] + localX * Math.cos(wallAngle),
-        slabElevation + localY + levelYOffset,
-        wallNode.start[1] + localX * Math.sin(wallAngle),
-    ];
+    const wallLength = getWallCurveLength(wallNode);
+    const frame = getWallCurveFrameAt(wallNode, wallLength > 1e-6 ? localX / wallLength : 0);
+    return [frame.point.x, slabElevation + localY + levelYOffset, frame.point.y];
 }
 /**
  * Clamps door center X so it stays fully within wall bounds.
  * Y is always height/2 — doors sit at floor level.
  */
 export function clampToWall(wallNode, localX, width, height) {
-    const dx = wallNode.end[0] - wallNode.start[0];
-    const dz = wallNode.end[1] - wallNode.start[1];
-    const wallLength = Math.sqrt(dx * dx + dz * dz);
-    const clampedX = Math.max(width / 2, Math.min(wallLength - width / 2, localX));
+    const wallLength = getWallCurveLength(wallNode);
+    const margin = wallNode.wallType === 'curtain' ? getCurtainWallConfig(wallNode).perimeterWidth : 0;
+    const clampedX = Math.max(margin + width / 2, Math.min(wallLength - margin - width / 2, localX));
     const clampedY = height / 2; // Doors always sit at floor level
     return { clampedX, clampedY };
 }

package/dist/door/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuF7D,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAkF7D,CAAA"}

package/dist/door/floorplan-affordances.js

@@ -1,4 +1,6 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getWallCurveLength, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { curtainOpeningLimits } from '../shared/curtain-opening-limits';
+import { projectPlanPointToWallLocalX } from '../shared/wall-attach-target';
 const MIN_DOOR_WIDTH = 0.3;
 /**
  * 2D drag affordance for the door's width side-arrows. Sister to the 3D
@@ -29,21 +31,15 @@ export const doorWidthAffordance = {
         // toward wall.end), -1 for 'start' (drag outward toward wall.start).
         const growDir = side === 'end' ? 1 : -1;
         const anchorX = side === 'end' ? initialDoorX - initialWidth / 2 : initialDoorX + initialWidth / 2;
-        // Wall axis (level-local) for projecting pointer movement to a
-        // wall-local X delta.
-        const wallStart = wall ? wall.start : [0, 0];
-        const wallEnd = wall ? wall.end : [1, 0];
-        const dx = wallEnd[0] - wallStart[0];
-        const dz = wallEnd[1] - wallStart[1];
-        const wallLength = Math.hypot(dx, dz) || 1;
-        const dirX = dx / wallLength;
-        const dirZ = dz / wallLength;
+        const wallLength = wall ? getWallCurveLength(wall) : 1;
         // Max width keeps the dragged edge inside the wall span. With the
         // anchor fixed, the moving edge is `anchorX ± width`, so the largest
         // legal width is the headroom on the grow side.
-        const maxWidth = growDir > 0 ? wallLength - anchorX : anchorX;
+        const limits = curtainOpeningLimits(node, nodes);
+        const margin = limits?.margin ?? 0;
+        const maxWidth = growDir > 0 ? (limits?.length ?? wallLength) - margin - anchorX : anchorX - margin;
         const projectToWallLocalX = (planPoint) => {
-            return (planPoint[0] - wallStart[0]) * dirX + (planPoint[1] - wallStart[1]) * dirZ;
+            return wall ? projectPlanPointToWallLocalX(wall, planPoint) : planPoint[0];
         };
         // Initial pointer in wall-local X — anchored to where the user
         // actually pressed, so any subtle offset between the arrow's visual

package/dist/door/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,kBAAkB,CAAA;AAkDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA0hC9C,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,kBAAkB,CAAA;AAmDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAwhC9C,CAAA;AAED,eAAe,YAAY,CAAA"}