@pascal-app/nodes 1.0.1 → 1.0.4

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,CAuDzE;AAED,eAAO,MAAM,qBAAqB,EAAE,eAUnC,CAAA"}

package/dist/column/surface.js

@@ -0,0 +1,73 @@
+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.source)
+        return node.source.manifest.surfaces.map((surface, i) => ({
+            id: `top:${i}`,
+            position: [0, surface.y, 0],
+            normal: [0, 1, 0],
+            region: { kind: 'polygon', points: surface.polygon },
+        }));
+    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/construction-dimension/floorplan.js

@@ -1,4 +1,4 @@
-import { constructionDimensionRequiredAnchorCount, getWallArcData, getWallCurveFrameAt, getWallThickness, } from '@pascal-app/core';
+import { constructionDimensionRequiredAnchorCount, getWallArcData, getWallCurveFrameAt, getWallLocalFaceZ, } from '@pascal-app/core';
 import { readFloorplanContext, readFloorplanMetricNotationOverride, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
 import { resolveMeasurementAnchor } from '../measurement/resolve';
 import { formatConstructionLength, } from '../shared/construction-length';
@@ -117,7 +117,7 @@ function wallDatumSide(node, featureId, resolved, frame) {
 function wallDatumOffset(wall, policy, side) {
     if (policy === 'centerline')
         return 0;
-    return (getWallThickness(wall) / 2) * side;
+    return getWallLocalFaceZ(wall, side > 0 ? 'a' : 'b');
 }
 function wallEndpointDatumExtension(wall, featureId, policy, ctx) {
     if (policy === 'centerline' || (featureId !== 'wall:start' && featureId !== 'wall:end')) {
@@ -135,7 +135,7 @@ function wallEndpointDatumExtension(wall, featureId, policy, ctx) {
         if (candidate?.type !== 'wall' ||
             candidate.id === wall.id ||
             getWallArcData(candidate) ||
-            (!pointsCoincide(endpoint, candidate.start) && !pointsCoincide(endpoint, candidate.end))) {
+            !(pointsCoincide(endpoint, candidate.start) || pointsCoincide(endpoint, candidate.end))) {
             continue;
         }
         const dx = candidate.end[0] - candidate.start[0];
@@ -339,6 +339,10 @@ function dimensionGeometry(node, start, end, dimensionStart, dimensionEnd, offse
         textPosition: node.textPosition,
         text,
         stroke,
+        // A typed value that could not drive geometry falls back to
+        // `textOverride`; the renderer badges it so the drawing never lies
+        // about being associative.
+        overridden: node.textOverride !== null,
     };
 }
 function arcGeometry(center, radius, startAngle, sweep, stroke) {

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,EAML,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA4D9D,CAAA"}

package/dist/cupola/definition.js

@@ -1,4 +1,4 @@
-import { CupolaNode as CupolaNodeSchema, } from '@pascal-app/core';
+import { CUPOLA_LOUVERS_DEFAULT, CupolaNode as CupolaNodeSchema, cupolaSlots, } from '@pascal-app/core';
 import { buildCupolaFloorplan } from './floorplan';
 import { cupolaPaint } from './paint';
 import { cupolaParametrics } from './parametrics';
@@ -9,7 +9,6 @@ const HEIGHT_HANDLE_OFFSET = 0.25;
 const ROTATE_CORNER_OFFSET = 0.12;
 const MIN_DIM = 0.3;
 const MIN_HEIGHT = 0.4;
-const CUPOLA_LOUVERS_DEFAULT = 'library:preset-metal';
 function getBodyMidY(n) {
     return Math.max(0.001, n.height) / 2;
 }
@@ -108,12 +107,7 @@ export const cupolaDefinition = {
         };
     },
     capabilities: {
-        slots: () => [
-            { slotId: 'base', label: 'Base', default: 'library:preset-softwhite' },
-            { slotId: 'body', label: 'Body', default: 'library:preset-softwhite' },
-            { slotId: 'roof', label: 'Roof', default: 'library:preset-softwhite' },
-            { slotId: 'louvers', label: 'Louvers', default: CUPOLA_LOUVERS_DEFAULT },
-        ],
+        slots: cupolaSlots,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -126,6 +120,7 @@ export const cupolaDefinition = {
     parametrics: cupolaParametrics,
     handles: cupolaHandles,
     floorplan: buildCupolaFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAgQlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCA4OlC"}

package/dist/cupola/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CupolaNode as CupolaSchema, getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
@@ -50,27 +50,9 @@ export default function CupolaPanel() {
         setSelection({ selectedIds: [] });
     }, [node, setMovingNode, setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node)
-            return;
-        triggerSFX('sfx:item-pick');
-        const parentId = node.roofSegmentId;
-        if (!parentId)
-            return;
-        const state = useScene.getState();
-        const meta = typeof node.metadata === 'object' && node.metadata !== null
-            ? node.metadata
-            : {};
-        const cloneInput = {
-            ...node,
-            id: undefined,
-            metadata: { ...meta, isNew: true },
-        };
-        const cloned = CupolaSchema.parse(cloneInput);
-        state.createNode(cloned, parentId);
-        state.dirtyNodes.add(parentId);
-        setMovingNode(cloned);
-        setSelection({ selectedIds: [] });
-    }, [node, setMovingNode, setSelection]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleDelete = useCallback(() => {
         if (!(selectedId && node))
             return;

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;AA0BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAiKnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA4H1D,CAAA"}

package/dist/door/definition.js

@@ -1,7 +1,13 @@
+import { doorSlots } from '@pascal-app/core';
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits';
+import { doorBatchable } from '../shared/node-batch/batchable';
 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 { scriptedOpeningHandles } from '../shared/scripted-opening-handles';
 import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
 import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides';
 import { buildDoorContextualDimensions } from './contextual-dimensions';
@@ -9,10 +15,11 @@ import { scaleHandleHeight } from './door-math';
 import { buildDoorFloorplan } from './floorplan';
 import { doorWidthAffordance } from './floorplan-affordances';
 import { doorFloorplanMoveTarget } from './floorplan-move';
+import { doorMechanism } from './mechanism';
 import { doorPaint } from './paint';
 import { doorParametrics } from './parametrics';
+import { DOOR_PLACEMENT_HINTS } from './placement';
 import { DoorNode } from './schema';
-import { doorSlots } from './slots';
 const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_DOOR_HEIGHT = 0.5;
@@ -46,7 +53,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,8 +95,11 @@ 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);
+            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene, n) - bottom);
         },
         currentValue: (n) => n.height,
         onDrag: (node) => publishOpeningResizeGuides(node, false),
@@ -126,11 +136,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,
@@ -174,6 +216,7 @@ export const doorDefinition = {
         return rest;
     },
     capabilities: {
+        batchable: doorBatchable,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -197,9 +240,13 @@ export const doorDefinition = {
         // each mesh with its `userData.slotId`; paint writes `node.slots`.
         slots: () => doorSlots(),
         paint: doorPaint,
+        mechanism: doorMechanism,
     },
     parametrics: doorParametrics,
-    handles: doorHandles,
+    handles: (node) => node.source
+        ? [doorMoveHandle(), ...scriptedOpeningHandles(node, doorWidthHandle, doorHeightHandle)]
+        : doorHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),
@@ -245,6 +292,7 @@ export const doorDefinition = {
     },
     toolHints: [
         { key: 'Left click', label: 'Place door on wall' },
+        ...DOOR_PLACEMENT_HINTS,
         { key: 'R', label: 'Flip side' },
         { key: 'Alt', label: 'Force place' },
         { key: 'Esc', label: 'Cancel' },

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
@@ -8,16 +8,11 @@ import type { WallNode } from '@pascal-app/core';
  */
 export declare function scaleHandleHeight(handleHeight: number, oldHeight: number, newHeight: number): number;
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  */
-export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number): [number, number, number];
-/**
- * Clamps door center X so it stays fully within wall bounds.
- * Y is always height/2 — doors sit at floor level.
- */
-export declare function clampToWall(wallNode: WallNode, localX: number, width: number, height: number): {
-    clampedX: number;
-    clampedY: number;
-};
+export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number, localZ?: number): [number, number, number];
+/** Door centre on its wall: the shared rule in core (`clampDoorToWall`). */
+export { clampDoorToWall as clampToWall } from '@pascal-app/core/building';
 export { hasWallChildOverlap } from '../shared/wall-attach-target';
 //# sourceMappingURL=door-math.d.ts.map

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;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,EACjB,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAW1B;AAED,4EAA4E;AAC5E,OAAO,EAAE,eAAe,IAAI,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAK1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/door/door-math.js

@@ -1,3 +1,4 @@
+import { getWallBodyCenterOffset, 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
@@ -10,28 +11,23 @@ export function scaleHandleHeight(handleHeight, oldHeight, newHeight) {
     return Math.min(Math.max(handleHeight * ratio, 0.5), Math.max(0.5, newHeight - 0.1));
 }
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) 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]);
+export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0, localZ = 0) {
+    const wallLength = getWallCurveLength(wallNode);
+    const frame = getWallCurveFrameAt(wallNode, wallLength > 1e-6 ? localX / wallLength : 0);
+    // `localZ` is measured from the body's centre plane, which a justified wall
+    // sets off its reference line.
+    const across = getWallBodyCenterOffset(wallNode) + localZ;
     return [
-        wallNode.start[0] + localX * Math.cos(wallAngle),
+        frame.point.x + frame.normal.x * across,
         slabElevation + localY + levelYOffset,
-        wallNode.start[1] + localX * Math.sin(wallAngle),
+        frame.point.y + frame.normal.y * across,
     ];
 }
-/**
- * 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 clampedY = height / 2; // Doors always sit at floor level
-    return { clampedX, clampedY };
-}
+/** Door centre on its wall: the shared rule in core (`clampDoorToWall`). */
+export { clampDoorToWall as clampToWall } from '@pascal-app/core/building';
 // Wall-child overlap is shared by door + window placement (one source of
 // truth in `shared/wall-attach-target.ts`). Re-exported here so existing
 // `./door-math` importers don't change.

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/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAqPjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAoBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAsPjE,CAAA"}

package/dist/door/floorplan-move.js

@@ -1,6 +1,7 @@
 import { useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
 import { isGridSnapActive, isMagneticSnapActive, snapToHalf, triggerSFX, useEditor, usePlacementPreview, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset';
 import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host';
 import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target';
 import { clampToWall, hasWallChildOverlap } from './door-math';
@@ -175,7 +176,8 @@ export const doorFloorplanMoveTarget = ({ node }) => {
             const side = flipped ? (hit.side === 'front' ? 'back' : 'front') : hit.side;
             const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
             lastValid = {
-                position: [clampedX, clampedY, 0],
+                // Same-wall moves keep the wall-local plane offset; another host resets it.
+                position: [clampedX, clampedY, openingPlaneOffsetOnWall(node, hit.wall.id)],
                 rotation: [0, itemRotation, 0],
                 side,
                 parentId: hit.wall.id,

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmvBjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAczB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAuxBjG"}